#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
 
ll int gcd(ll int a,ll int b){if(!b)return a;return gcd(b, a % b);}
ll int lcm(ll int a,ll int b){ return (a*b)/gcd(a,b);}
string inc(string &s){  ll x = stoll(s);   x++;  return s = to_string(x);}

template<typename T> T pow(T a,T b, long long m){T ans=1; while(b>0){ if(b%2==1) ans=(ans*a)%m; b/=2; a=(a*a)%m; } return ans%m; }


ll int _mergeSort(int arr[], int temp[], int left, int right);
ll int merge(int arr[], int temp[], int left, int mid,
          int right);
 
/* This function sorts the
   input array and returns the
number of inversions in the array */
ll int mergeSort(int arr[], int array_size)
{
    int temp[array_size];
    return _mergeSort(arr, temp, 0, array_size - 1);
}
 
/* An auxiliary recursive function
  that sorts the input array and
returns the number of inversions in the array. */
ll int _mergeSort(int arr[], int temp[], int left, int right)
{
    int mid;
    ll int inv_count = 0;
    if (right > left) {
        /* Divide the array into two parts and
        call _mergeSortAndCountInv()
        for each of the parts */
        mid = (right + left) / 2;
 
        /* Inversion count will be sum of
        inversions in left-part, right-part
        and number of inversions in merging */
        inv_count += _mergeSort(arr, temp, left, mid);
        inv_count += _mergeSort(arr, temp, mid + 1, right);
 
        /*Merge the two parts*/
        inv_count += merge(arr, temp, left, mid + 1, right);
    }
    return inv_count;
}
 
/* This funt merges two sorted arrays
and returns inversion count in the arrays.*/
ll int merge(int arr[], int temp[], int left, int mid,
          int right)
{
    int i, j, k;
   ll int inv_count = 0;
 
    i = left; /* i is index for left subarray*/
    j = mid; /* j is index for right subarray*/
    k = left; /* k is index for resultant merged subarray*/
    while ((i <= mid - 1) && (j <= right)) {
        if (arr[i] <= arr[j]) {
            temp[k++] = arr[i++];
        }
        else {
            temp[k++] = arr[j++];
 
            /* this is tricky -- see above
            explanation/diagram for merge()*/
            inv_count = inv_count + (mid - i);
        }
    }
 
    /* Copy the remaining elements of left subarray
(if there are any) to temp*/
    while (i <= mid - 1)
        temp[k++] = arr[i++];
 
    /* Copy the remaining elements of right subarray
       (if there are any) to temp*/
    while (j <= right)
        temp[k++] = arr[j++];
 
    /*Copy back the merged elements to original array*/
    for (i = left; i <= right; i++)
        arr[i] = temp[i];
 
    return inv_count;
}



 int main(){
   // IOS;
ll int tt=1;
  cin>>tt;
for(ll int ii=1;ii<=tt;ii++){
    int n;
    ll int mx=-1;
   string s;
   cin>>s;
   n=s.size();
  map<char,vector<int> > m;
   map<char,int> p,cnt;
    int a[n];
   
   for(int i=0;i<s.size();i++){
       if(s[i]=='A') cnt['A']++;
       if(s[i]=='N') cnt['N']++;
       if(s[i]=='T') cnt['T']++;
       if(s[i]=='O') cnt['O']++;
       
      m[s[i]].pb(i+1);   
      p[s[i]]=0;
   }
   
    string str="ANOT";
    string ans="";
   do{
        map<char,int> c=cnt;
       
       string st="";
       while(c[str[0]]--) st+=str[0];
       while(c[str[1]]--) st+=str[1];
       while(c[str[2]]--) st+=str[2];
       while(c[str[3]]--) st+=str[3];
       //cout<<st<<" ";
       
   for(int i=0;i<n;i++){
      a[i]=m[st[i]][p[st[i]]]; 
      p[st[i]]++;
   }
   
   for(char i='A';i<='Z';i++) p[i]=0;
   ll int sol=mergeSort(a,n);
  
   if(sol>mx){ mx=sol; ans=st;}
   } while(next_permutation(str.begin(), str.end()));
   
   cout<<ans<<endl;
}
}
