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".


import java.io.*;
import java.text.DecimalFormat;
import java.util.*;


    public class educational97A  {
    	
    	
    	public static void main(String[] args)throws Exception {
    		
    		  Scanner sc =new Scanner(System.in);
    		  int t=sc.nextInt();
    		
    		  while(t-->0) {
    			  int freq[]=new int[26];
    			  int n=sc.nextInt();
    			  String s=sc.nextLine();
    			  for(int i=0;i<s.length();i++) {
    				  freq[s.charAt(i)-'a']++;
    			  }
    			  String res="";
    			  for(int i=0;i<26;i++) {
    				 for(int j=0;j<freq[i];j++) {
    					 char d=(char)('a'+i);
    					 res+=d;
    				 }
    			  }
    			  System.out.println(res);
    			 
    			}}
    
    	



	

    static long npr (int n, int r) 
    { 
        return fact[n] / fact[n - r]; 
    } 
  static long fact[];
	static int[]indices;
	static int cnmax;
	static int cnmin;
	public static void binaryasearch(int pos) {
	int left=0;
	int right=indices.length-1;
	
	while(left<right) {
		int mid=(left+right)/2;
		if(indices[mid]<=pos) {
			left=mid+1;
		    cnmax++;		    
		}
		else {
			right=mid;
			cnmin++;
		}
	}
}
 
	static class Pair implements Comparable<Pair>{
		long a, b;
 
		public Pair(long a1, long b1) {
			a = a1;
			b = b1;
 
		}

		@Override
		public int compareTo(Pair o) {
			// TODO Auto-generated method stub
			return Long.compare(o.a, a);
		}
	}

    	
    	  	 	static class SegmentTree{
    	   	 		String[] arr , sTree;
    	   	 	static	int N;
    	   	 		public SegmentTree(String[] in){
    	   	 			arr=in;
    	   	 		N=arr.length-1;
    	   	 			sTree=new String[2*N];
    	   	 			
    	   	 			build(1,1,N);
    	   	 		}
    	   	 		public void build(int node, int l, int r){
    	   	 			if(l==r){
    	   	 				sTree[node]=arr[l];
    	   	 			}
    	   	 			else{
    	   	 				int leftchild=node*2;
    	   	 				int rightchild=node*2+1;
    	   	 				int mid =(l+r)/2;
    	   	 				build(leftchild,l,mid);
    	   	 				build(rightchild,mid+1,r);
    	   	 				sTree[node]=sTree[leftchild].concat(sTree[rightchild]);
    	   	 			}
    	   	 		}
    	   	 		public  void update(int i, String val){
    	   	 			int node =i+N-1;
    	   	 			arr[i]=val;
    	   	 			sTree[node]=val;
    	   	 			node=node/2;
    	   	 			while(node>0){
    	   	 			int leftchild=node *2;
       	 				int rightchild=node*2+1;
       	 			sTree[node]=sTree[leftchild].concat(sTree[rightchild]);
       	 			node=node/2;
    	   	 			}
    	   	 			return;
    	   	 			
    	   	 		}
    	   	 		public String query(int i, int j){
    	   	 			 return query(1,1, N,  i, j);
    	   	 		}
    	   	 		public String query(int node,int l, int r, int i , int j){
    	   	 			if(i>r||j<l){
    	   	 				return "";
    	   	 			}
    	   	 			if(i<=l&&r<=j){
    	   	 				return sTree[node];
    	   	 			}
    	   	 		int leftchild=node*2;
    	 				int rightchild=node*2+1;
    	 				int mid =(l+r)/2;
    	 				
    	 			return	(query(leftchild,l,mid,i,j).concat(query(rightchild,mid+1,r,i,j)));
    	 				
    	   	 		}
    	   	 	}
     
    	  	 	static ArrayList<Pair>factors;
    	    	static boolean isComposite[];
    	    	static ArrayList<Integer> primes;
    	    	public static boolean isprime(long n){
    	    		if(n<=100001){
    	    			return !isComposite[(int)n];
    	    		}
    	    		for(int i=0;i<primes.size();i++){
    	    			if(primes.get(i)*primes.get(i)*1l>n){
    	    				break;
    	    			}
    	    			if(n%primes.get(i)==0){
    	    				return false;
    	    			}
    	    			
    	    		}
    	    		return true;
    	    	}
    	    	
    	    	
    	    	public static void sieve(int n){
    	    		isComposite=new boolean[n+1];
    	    		primes =new ArrayList<Integer>();
    	    		isComposite[0]=true;
    	    		isComposite[1]=true;
    	    		for(int i=2;i<=n;i++){
    	    			if(!isComposite[i]){
    	    				for(int j=2*i;j<=n;j=j+i){
    	    					isComposite[j]=true;
    	    				}
    	    				primes.add(i);
    	    			}
    	    			
    	    		}
    	    		
    	    	}
    	    	public static void primefactors(long n){
    	    		 factors=new ArrayList<Pair>();
    	    		for(int x:primes){
    	    			if(x*x*1l>n){
    	    				break;
    	    			}
    	    		
    	    			
    	    			if(n%x==0){
    	    				
    	    					Pair p=new Pair(x,0);
    	    					 factors.add(p);
    	    				while(n%x==0){
    	    				n/=x;
    	    				p.b++;}
    	    				
    	    			}
    	    		}
    	    		if(n!=1){
    	    			factors.add(new Pair((int)n,1));
    	    		}
    	    		
    	    	}
    	    	public static long powfact(long n,long p){
    	    		int res=0;
    	    		for(long i=p;i*1l<=n;i=i*p*1l){
    	    			res+=(n/i);
    	    		}
    	    		return res;
    	    	}
    	    	
    	    	public static long GCD(long i, long j){
    	    	if (i==0){
    	    		return j;
    	    	}
    	    	return GCD(j%i,i);
    	    	}
    	    	public static long LCM(long i, long j){
    	    		return(i*j)/GCD(i,j);
    	    	}
    	    
 	static class Scanner {
    		StringTokenizer st;
    		BufferedReader br;
     
    		public Scanner(InputStream s) {
    			br = new BufferedReader(new InputStreamReader(s));
    		}
     
    		public boolean hasNext() {
    			// TODO Auto-generated method stub
    			return false;
    		}
     
    		public String next() throws IOException {
    			while (st == null || !st.hasMoreTokens())
    				st = new StringTokenizer(br.readLine());
    			return st.nextToken();
    		}
     
    		public int nextInt() throws IOException {
    			return Integer.parseInt(next());
    		}
     
    		public long nextLong() throws IOException {
    			return Long.parseLong(next());
    		}
     
    		public String nextLine() throws IOException {
    			return br.readLine();
    		}
     
    		public double nextDouble() throws IOException {
    			String x = next();
    			StringBuilder sb = new StringBuilder("0");
    			double res = 0, f = 1;
    			boolean dec = false, neg = false;
    			int start = 0;
    			if (x.charAt(0) == '-') {
    				neg = true;
    				start++;
    			}
    			for (int i = start; i < x.length(); i++)
    				if (x.charAt(i) == '.') {
    					res = Long.parseLong(sb.toString());
    					sb = new StringBuilder("0");
    					dec = true;
    				} else {
    					sb.append(x.charAt(i));
    					if (dec)
    						f *= 10;
    				}
    			res += Long.parseLong(sb.toString()) / f;
    			return res * (neg ? -1 : 1);
    		}
     
    		public boolean ready() throws IOException {
    			return br.ready();
    		}
     
    	}}
