Polycarp and String Transformation

链接

Polycarp has a string $s$. Polycarp performs the following actions until the string $s$ is empty ( $t$ is initially an empty string):

• he adds to the right to the string t the string $s$, i.e. he does $t=t+s$, where $t+s$ is a concatenation of the strings $t$ and $s$;
• he selects an arbitrary letter of $s$ and removes from $s$ all its occurrences (the selected letter must occur in the string s at the moment of performing this action).
  Polycarp performs this sequence of actions strictly in this order.

Note that after Polycarp finishes the actions, the string $s$ will be empty and the string $t$ will be equal to some value (that is undefined and depends on the order of removing).

E.g. consider $s="abacaba"$ so the actions may be performed as follows:

$t="abacaba"$, the letter ${}^{\prime }{b}^{\prime }$ is selected, then $s="aacaa"$;
$t="abacabaaacaa",$ the letter ${}^{\prime }{a}^{\prime }$ is selected, then $s="c"$;
$t="abacabaaacaac"$, the letter ${}^{\prime }{c}^{\prime }$ is selected, then $s=""$ (the empty string).
You need to restore the initial value of the string $s$ using only the final value of $t$ and find the order of removing letters from $s$.

Input

The first line contains one integer $T(1\le T\le 104)$ — the number of test cases. Then $T$ test cases follow.

Each test case contains one string $t$ consisting of lowercase letters of the Latin alphabet. The length of $t$ doesn’t exceed $5\cdot 105$. The sum of lengths of all strings $t$ in the test cases doesn’t exceed $5\cdot 105$.

Output

For each test case output in a separate line:

• −1, if the answer doesn’t exist;
• two strings separated by spaces. The first one must contain a possible initial value of $s$. The second one must contain a sequence of letters — it’s in what order one needs to remove letters from $s$ to make the string $t$. E.g. if the string $"bac"$ is outputted, then, first, all occurrences of the letter ${}^{\prime }{b}^{\prime }$ were deleted, then all occurrences of ${}^{\prime }{a}^{\prime }$, and then, finally, all occurrences of ${}^{\prime }{c}^{\prime }$. If there are multiple solutions, print any one.

Example

input

7
abacabaaacaac
nowyouknowthat
polycarppoycarppoyarppyarppyrpprppp
isi
everywherevrywhrvryhrvrhrvhv
haaha
qweqeewew

output

abacaba bac
-1
polycarp lcoayrp
is si
everywhere ewyrhv
-1
-1

Note

The first test case is considered in the statement.

思路

首先假设每个字符串 $t$ 都可以构造出一个满足题意的 $s$ 串。从后到前扫描一遍 $t$ 串，找出每个字符最后出现的顺序，将这个顺序反转，就是删除字符的顺序。

统计一遍 $t$ 中每个字符出现的次数，这个次数除以它在删除顺序中的下标，就是它在 $s$ 串中出现的次数。这样就可以得到 $s$ 串中每个字母的出现的次数。

从前到后扫描一遍 $s$ 串，统计每个字母出现的次数，若找到一个位置，使得字母出现次数满足要求，那么就用这段前缀，根据删除字母的顺序，构造一个 $t^{\prime }$，若 $t^{\prime }==t$，则满足题意，否则不存在这样的 $s$ 串。

#include<bits/stdc++.h>
using namespace std;
const int N=5e5+10;
string s,ord; int T,n;

bool check(int x){
	vector<bool> vis(n);
	string ss=s.substr(0,x+1);
	for(int i=0;i<(int)ord.size();i++)
		for(int j=0;j<=x;j++){
			if(vis[j]==1||s[j]==ord[i]) vis[j]=1;
			else ss.push_back(s[j]);
		}
	return ss==s;
}

void solve(){
	cin>>s; n=s.size();
	ord.clear();
	vector<int> v(26),pre(26),cnt(26);
	for(int i=n-1;i>=0;i--){
		int t=s[i]-'a';
		if(v[t]==0){ v[t]=1; ord.push_back(t+'a'); }
	}
	reverse(ord.begin(),ord.end());
	for(int i=0;i<n;i++) cnt[s[i]-'a']++;
	for(int i=0;i<(int)ord.size();i++) cnt[ord[i]-'a']/=(i+1);
	for(int i=0;i<n;i++){
		pre[s[i]-'a']++;
		if(pre==cnt){
			if(check(i)){ s=s.substr(0,i+1);
				return (void)(cout<<s+" "+ord<<"\n");
			}else return (void)(cout<<"-1\n");
		}
	}
	cout<<"-1\n";
}

int main(){
	ios::sync_with_stdio(false);
	for(cin>>T;T;T--) solve();
}