description: 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 'b' is selected, then s="aacaa"; 
    * t="abacabaaacaa", the letter 'a' is selected, then s="c"; 
    * t="abacabaaacaac", the letter 'c' 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 ≤ T ≤ 10^4) — 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 ⋅ 10^5. The sum of lengths of all strings t in the test cases doesn't exceed 5 ⋅ 10^5.
  
  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 'b' were deleted, then all occurrences of 'a', and then, finally, all occurrences of 'c'. 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.
solution: #DaRk DeveLopeR
  import sys
  
  
  #taking input as string 
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  inp = lambda: list(map(int,sys.stdin.readline().rstrip("\r\n").split()))
  mod = 10**9+7; Mod = 998244353; INF = float('inf')
  #______________________________________________________________________________________________________
  import math
  from bisect import *
  from heapq import *
  from collections import defaultdict as dd
  from collections import OrderedDict as odict
  from collections import Counter as cc
  from collections import deque
  from itertools import groupby
  sys.setrecursionlimit(20*20*20*20+10) #this is must for dfs
  
  
  
  def order(string):
  
  	s=set()
  	st=""
  
  	for i in string[::-1]:
  		if i not in s:
  			st+=i
  			s.add(i)
  	# print(st[::-1])
  	
  	
  	return st[::-1]
  
  def solve():
  
  	string=takesr()
  
  	dict_1=cc(string)
  	# print(dict_1)
  
  	st=order(string)
  
  	dict_2=dd(lambda:0)
  
  	count=1
  
  	
  
  	for i in st:
  
  		if dict_1[i]%count!=0:
  			print(-1)
  			return
  		else:
  
  			dict_2[i]=dict_1[i]//count
  
  		count+=1
  
  	ans=""
  
  	for i in string:
  
  		if dict_2[i]>0:
  			ans+=i
  			dict_2[i]-=1
  		else:
  			break
  	temp=first=ans
  	s=set()
  	index=0
  	while first and index<len(st):
  		s.add(st[index])
  
  		for i in first:
  
  			if i not in s:
  				temp+=i
  
  		index+=1
  
  	if temp==string:
  		print(ans,st)
  	else:
  		print(-1)
  
  
  
  
  
  
  
  	
  
  
  
  
  def main():
      global tt
      if not ONLINE_JUDGE:
          sys.stdin = open("input.txt","r")
          sys.stdout = open("output.txt","w")
      t = 1
      t = takein()
      #t = 1
      for tt in range(1,t + 1):
          solve()
      if not ONLINE_JUDGE:
          print("Time Elapsed :",time.time() - start_time,"seconds")
          sys.stdout.close()
  
  #---------------------- USER DEFINED INPUT FUNCTIONS ----------------------#
  def takein():
      return (int(sys.stdin.readline().rstrip("\r\n")))
  
  
  # input the string
  
  def takesr():
      return (sys.stdin.readline().rstrip("\r\n"))
  
  
  # input int array
  def takeiar():
      return (list(map(int, sys.stdin.readline().rstrip("\r\n").split())))
  
  
  # input string array
  def takesar():
      return (list(map(str, sys.stdin.readline().rstrip("\r\n").split())))
  
  
  # innut values for the diffrent variables
  def takeivr():
      return (map(int, sys.stdin.readline().rstrip("\r\n").split()))
  
  
  def takesvr():
      return (map(str, sys.stdin.readline().rstrip("\r\n").split()))
  
   
   
  #------------------ USER DEFINED PROGRAMMING FUNCTIONS ------------------#
  
  
  
  def ispalindrome(s):
  
  	return s==s[::-1]
   
  def invert(bit_s):
  
  
  	  
  	# convert binary string 
  	# into integer
  	temp = int(bit_s, 2)
  	  
  	# applying Ex-or operator
  	# b/w 10 and 31
  	inverse_s = temp ^ (2 ** (len(bit_s) + 1) - 1)
  	  
  	# convert the integer result 
  	# into binary result and then 
  	# slicing of the '0b1' 
  	# binary indicator
  	rslt = bin(inverse_s)[3 : ]
  
  	return str(rslt) 	  
  
  def counter(a):
      q = [0] * max(a)
      for i in range(len(a)):
          q[a[i] - 1] = q[a[i] - 1] + 1
      return(q)
   
  def counter_elements(a):
      q = dict()
      for i in range(len(a)):
          if a[i] not in q:
              q[a[i]] = 0
          q[a[i]] = q[a[i]] + 1
      return(q)
   
  def string_counter(a):
      q = [0] * 26
      for i in range(len(a)):
          q[ord(a[i]) - 97] = q[ord(a[i]) - 97] + 1
      return(q)
   
  def factorial(n,m = 1000000007):
      q = 1
      for i in range(n):
          q = (q * (i + 1)) % m
      return(q)
   
  def factors(n):
      q = []
      for i in range(1,int(n ** 0.5) + 1):
          if n % i == 0: q.append(i); q.append(n // i)
      return(list(sorted(list(set(q)))))
   
  def prime_factors(n):
      q = []
      while n % 2 == 0: q.append(2); n = n // 2
      for i in range(3,int(n ** 0.5) + 1,2):
          while n % i == 0: q.append(i); n = n // i
      if n > 2: q.append(n)
      return(list(sorted(q)))
   
  def transpose(a):
      n,m = len(a),len(a[0])
      b = [[0] * n for i in range(m)]
      for i in range(m): 
          for j in range(n): 
              b[i][j] = a[j][i]
      return(b)
   
  def power_two(x):
      return (x and (not(x & (x - 1))))
   
  def ceil(a, b):
      return -(-a // b)
  
  
  
  def seive(n):
  	a = [1]
  	prime = [True for i in range(n+1)] 
  	p = 2
  	while (p * p <= n): 
  	    if (prime[p] == True): 
  	        for i in range(p ** 2,n + 1, p): 
  	            prime[i] = False
  	    p = p + 1
  	for p in range(2,n + 1): 
  	    if prime[p]: 
  	        a.append(p)
  	return(a)
  
   
  def pref(li):
      pref_sum = [0]
      for i in li:
          pref_sum.append(pref_sum[-1]+i)
      return pref_sum
   
  def kadane(x):  # maximum sum contiguous subarray
      sum_so_far = 0
      current_sum = 0
      for i in x:
          current_sum += i
          if current_sum < 0:
              current_sum = 0
          else:
              sum_so_far = max(sum_so_far, current_sum)
      return sum_so_far
  
  def binary_search(li, val):
      # print(lb, ub, li)
      ans = -1
      lb = 0
      ub = len(li)-1
      while (lb <= ub):
          mid = (lb+ub) // 2
          # print('mid is',mid, li[mid])
          if li[mid] > val:
              ub = mid-1
          elif val > li[mid]:
              lb = mid+1
          else:
              ans = mid  # return index
              break
      return ans
  
  
   
  def upper_bound(li, num):
      answer = -1
      start = 0
      end = len(li)-1
   
      while (start <= end):
          middle = (end+start) // 2
   
          if li[middle] <= num:
              answer = middle
              start = middle+1
   
          else:
              end = middle-1
      return answer  # max index where x is not greater than num
  
  
  def lower_bound(li, num):
      answer = -1
      start = 0
      end = len(li)-1
   
      while (start <= end):
          middle = (end+start) // 2
          if li[middle] >= num:
              answer = middle
              end = middle-1
          else:
              start = middle+1
      return answer  # min index where x is not less than num
  #-----------------------------------------------------------------------#
  ONLINE_JUDGE = __debug__
  if ONLINE_JUDGE:
      input = sys.stdin.readline
      
  main()