A string b is a subsequence of a string a if b can be obtained from a by deletion of several (possibly, zero or all) characters. For example, "xy" is a subsequence of "xzyw" and "xy", but not "yx".

You are given a string a. Your task is to reorder the characters of a so that "trygub" is not a subsequence of the resulting string.

In other words, you should find a string b which is a permutation of symbols of the string a and "trygub" is not a subsequence of b.

We have a truly marvelous proof that any string can be arranged not to contain "trygub" as a subsequence, but this problem statement is too short to contain it.

Input

The first line contains a single integer t (1≤ t≤ 100) — the number of test cases.

The first line of each test case contains a single integer n (1≤ n≤ 200) — the length of a.

The next line contains the string a of length n, consisting of lowercase English letters.

Output

For each test case, output a string b of length n which is a permutation of characters of the string a, and such that "trygub" is not a subsequence of it.

If there exist multiple possible strings b, you can print any.

Example

Input


3
11
antontrygub
15
bestcoordinator
19
trywatchinggurabruh


Output


bugyrtnotna
bestcoordinator
bruhtrywatchinggura

Note

In the first test case, "bugyrtnotna" does not contain "trygub" as a subsequence. It does contain the letters of "trygub", but not in the correct order, so it is not a subsequence.

In the second test case, we did not change the order of characters because it is not needed.

In the third test case, "bruhtrywatchinggura" does contain "trygu" as a subsequence, but not "trygub".

#include<bits/stdc++.h>
using namespace std;
 
/*#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds*/
//-----------------------------------------------------------//

#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization ("unroll-loops")
 
typedef long long ll;
typedef pair<ll, ll> pi;
typedef vector<ll> vi;
typedef vector<pi> vpi;
typedef map<ll,ll> mi;
 
#define f first
#define ss second
#define ins insert
#define pb push_back
#define lc cout<<endl;
#define lb lower_bound 
#define ub upper_bound 
#define last(x) x.back()
#define pq priority_queue
#define pl(x) x.pop_back()
#define sqr(n) floor(sqrt(n))
#define sz(v) ((ll)(v.size()))
#define trav(a,x) for (auto& a: x)
#define all(v) (v).begin(),(v).end()
#define arl(v) (v).rbegin(),(v).rend()
#define fsp(a) fixed<<setprecision(a)
#define mem(a) memset(a, 0, sizeof (a))
#define prnt(k,x,y) cout<<(k?x:y)<<" "
#define IOS ios::sync_with_stdio(0);cin.tie(0);
#define vmn(a) (*min_element(a.begin(),a.end()))   
#define vmx(a) (*max_element(a.begin(),a.end()))
#define foo(i,a,b) for (ll i = (a); i < (b); ++i)
#define foor(i,a,b) for (ll i = (a); i >= (b); --i)
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
 
//-----------------------debug-------------------------------//
//not going to work for stack and queue ->>can not be iterated by for(auto)..
void __print(int x) {cout << x;}
void __print(long x) {cout << x;}
void __print(long long x) {cout << x;}
void __print(unsigned x) {cout << x;}
void __print(unsigned long x) {cout << x;}
void __print(unsigned long long x) {cout << x;}
void __print(float x) {cout << x;}
void __print(double x) {cout << x;}
void __print(long double x) {cout << x;}
void __print(char x) {cout << '\'' << x << '\'';}
void __print(const char *x) {cout << '\"' << x << '\"';}
void __print(const string &x) {cout << '\"' << x << '\"';}
void __print(bool x) {cout << (x ? "true" : "false");}
 
template<typename T, typename V>
void __print(const pair<T, V> &x) {cout << '{'; __print(x.first); cout << ','; __print(x.second); cout << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cout << '{'; for (auto &i: x) cout << (f++ ? "," : ""), __print(i); cout << "}";}
void _print() {cout << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cout << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cout << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
//---------------------bitsrelated----------------------------//
//indexing from zero so take maximum bit val==63,also take long long..
 
#define cone(x) (__builtin_popcountll(x))
#define fone(x) (__builtin_ffsll(x) -1LL)        ///give wrong answer if x==0;(zero indexed)
#define mone(x) (63LL-__builtin_clzll(x))       ///give undefined behaviour on x==0;(zero indexed)
 
 
//------------------------------------------------------------//
 
/*
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> pbds;
#define val_index(a,x) (*a.find_by_order(x))  //zero index.
#define hope_index(a,x) (a.order_of_key(x))   //zero index.
*/

/*some comments...
iota(all(a),val)-->>fill vector a with consecutive values starting from val..
vectorname.resize(size,val)-->>val is the default value which you want to give...
shuffle(all(a),rng)-->>randomly shuffle elements of vector..
some iterator functions->>> advance(it,val),next(it,val),prev(it,val)..
prnt it like-->>  (*it).ss,,,,[s+=('a'+i)]possible in string..
//while using vmn vmx vector should not be empty..other wise segem..fault.
stoi-->string to int,,  to_string-->>convert int into string..work fine incase of ll.
always see the max which can run nlogn or nsqrtn..nsqrtn makes it very easy..
*/
 
template<class T> void remdup(vector<T>& v) { 
  sort(all(v)); v.erase(unique(all(v)),end(v)); }
 
template<typename T> struct cmp{
bool operator()(const T &p1, const T &p2)
{
    //sort(all(a),cmp<datatype>());
    return true;
}
};

#define bs(a,key) binary_search(all(a),key)    /// return bool.
#define rotl(a,x) rotate(a.begin(),a.begin()+x,a.end());
#define rotr(a,x) rotl(a,a.size()-x);

const ll N=2e5+100;
const ll mod=1e9+7;
const ll X=2e5+100; //for sieve

int main()
{
  
  /*#ifndef ONLINE_JUDGE
  freopen("input.txt","r",stdin);
  freopen("output.txt","w",stdout);
  #endif*/

  IOS;
  ll t;
  cin>>t;
  while(t--)
  {
    ll n;cin>>n;
    string s;
    cin>>s;
    ll ans=0;
    foo(i,0,n)if(s[i]=='b')ans++;
    foo(i,0,ans)cout<<"b";
    foo(i,0,n)if(s[i]!='b')cout<<s[i];
    cout<<"\n";
  } 
  return 0;
}
 