A non-empty string is called palindrome, if it reads the same from the left to the right and from the right to the left. For example, "abcba", "a", and "abba" are palindromes, while "abab" and "xy" are not.

A string is called a substring of another string, if it can be obtained from that string by dropping some (possibly zero) number of characters from the beginning and from the end of it. For example, "abc", "ab", and "c" are substrings of the string "abc", while "ac" and "d" are not.

Let's define a palindromic count of the string as the number of its substrings that are palindromes. For example, the palindromic count of the string "aaa" is 6 because all its substrings are palindromes, and the palindromic count of the string "abc" is 3 because only its substrings of length 1 are palindromes.

You are given a string s. You can arbitrarily rearrange its characters. You goal is to obtain a string with the maximum possible value of palindromic count.

Input

The first line contains an integer n (1 ≤ n ≤ 100 000) — the length of string s.

The second line contains string s that consists of exactly n lowercase characters of Latin alphabet.

Output

Print string t, which consists of the same set of characters (and each characters appears exactly the same number of times) as string s. Moreover, t should have the maximum possible value of palindromic count among all such strings strings.

If there are multiple such strings, print any of them.

Examples

Input

5
oolol


Output

ololo


Input

16
gagadbcgghhchbdf


Output

abccbaghghghgdfd

Note

In the first example, string "ololo" has 9 palindromic substrings: "o", "l", "o", "l", "o", "olo", "lol", "olo", "ololo". Note, that even though some substrings coincide, they are counted as many times as they appear in the resulting string.

In the second example, the palindromic count of string "abccbaghghghgdfd" is 29.
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.*;
import java.io.*;
import java.math.*;
public class Main
{
    public static long pow(long a, long b)
    {
        long result=1;
        while(b>0)
        {
            if (b % 2 != 0)
            {
                result=(result*a);
                b--;
            } 
            a=(a*a);
            b /= 2;
        }   
                return result;
    }
    public static BigInteger fact(long num)
    {
                BigInteger fact=new BigInteger("1");
                int i=0;
                for(i=1; i<=num; i++)
                {
                    BigInteger bg=BigInteger.valueOf(i);
                    fact=fact.multiply(bg);
                }
                return fact;
            }
            public static long gcd(long a, long b)
            {
                if (a == 0)
                    return b;
                return gcd(b%a, a);
            }
            
            public static long lcm(int a,int b)
            {
                return a * (b / gcd(a, b));
            }
            public static long sum(int h)
            {
                return (h*(h+1)/2);
            }
		/*	public static void dfs(int parent,boolean[] visited)
			{
				ArrayList<Integer> arr=new ArrayList<Integer>();
				arr=graph.get(parent);
				visited[parent]=true;
				storing1[parent]=count++;
				for(int i=0;i<arr.size();i++)
				{
					int num=arr.get(i);
					if(visited[num]==false)
					{
						dfs(num,visited);
					}
				}
				storing2[parent]=count;
			}
			static int count=0;
			static int[] storing1;
			static int[] storing2;
			static ArrayList<ArrayList<Integer>> graph;
		*/	public static void main(String args[])throws IOException
            {
                InputReader in=new InputReader(System.in);
        		OutputWriter out=new OutputWriter(System.out);
        	//	long a=pow(26,1000000005);
        	//    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        	    ArrayList<Integer> ar=new ArrayList<>();
				ArrayList<Integer> ar1=new ArrayList<>();
				TreeSet<Integer> ts=new TreeSet<>();
				TreeSet<Integer> ts1=new TreeSet<>();
				HashMap<Long,Integer> hash=new HashMap<Long,Integer>();
				int n=i();
				String s=s();
				char[] ch=s.toCharArray();
				int[] count=new int[26];
				for(int i=0;i<n;i++)
				{
					count[ch[i]-'a']++;
				}
				int odd=0,index=0;
				char[] b=new char[n];
				int j=0;
				for(int i=0;i<26;i++)
				{
					if(count[i]>0)
					{
						while(count[i]>0)
						{
							b[j]=(char)(i+'a');
							j++;
							count[i]--;
						}
					}
				}
				String s1=new String(b);
				pln(s1);
		/*		for(int i=0;i<26;i++)
				{
					System.out.print(count[i]+" ");
				}*/
		/*		boolean brk=false;
				for(int i=0;i<26;i++)
				{
					if(count[i]>0 && count[i]%2!=0 && brk==false)
					{
						index=i;
						brk=true;
					}
					if(count[i]%2!=0)
					{
						odd++;
					}
				}
			//	pln(odd+"");
				if(n%2==0)
				{
					int l=1,k=0;
					int turn=1;
					for(int i=0;i<26;i++)
					{
						if(count[i]>0)
						{
							if(count[i]%2!=0 && count[i]!=1)
							{
							//	flag[i]=1;
								int num=count[i]-1;
								while(num%2==0 && num!=0)
								{
									b[n/2-l]=(char)(i+'a');
									b[n/2+k]=(char)(i+'a');
									num-=2;
									l++;
									k++;
								}
								if(turn==1)
								{
									b[n/2-l]=(char)(i+'a');
									l++;
									turn=2;
								}
								else
								{
									b[n/2+k]=(char)(i+'a');
									k++;
									turn=1;
								}
							}
						}
					}for(int i=0;i<26;i++)
					{
						if(count[i]>0)
						{
							while(count[i]%2==0 && count[i]!=0)
							{
								b[n/2-l]=(char)(i+'a');
								b[n/2+k]=(char)(i+'a');
								count[i]-=2;
								l++;
								k++;
							}
							
						}
					}
					
				}
				else
				{
					if(odd==1)
					{
					//	pln("HI");
						b[n/2]=(char)(index+'a');
						count[index]--;
						int l=1,k=1;
						for(int i=0;i<26;i++)
						{
							if(count[i]>0)
							{
								while(count[i]%2==0 && count[i]!=0)
								{
									b[n/2-l]=(char)(i+'a');
									b[n/2+k]=(char)(i+'a');
									count[i]-=2;
									l++;
									k++;
								}
							}
						}
					}
					else
					{
						int l=0,k=1;
						int turn=1;
						for(int i=0;i<26;i++)
						{
							if(count[i]%2!=0)
							{
								int num=count[i]-1;
								while(num%2==0 && num%2!=0)
								{
									b[n/2-l]=(char)(i+'a');
									b[n/2+k]=(char)(i+'a');
									num-=2;
									l++;
									k++;
								}
							}
							if(turn==1)
								{
									b[n/2-l]=(char)(i+'a');
									l++;
									turn=2;
								}
								else
								{
									b[n/2+k]=(char)(i+'a');
									k++;
									turn=1;
								}
						}for(int i=0;i<26;i++)
						{
							if(count[i]>0)
							{
								while(count[i]%2==0 && count[i]!=0)
								{
									b[n/2-l]=(char)(i+'a');
									b[n/2+k]=(char)(i+'a');
									l++;
									k++;
									count[i]-=2;
								}
								
							}
						}
						
					}
				}
				String s1=new String(b);
				System.out.println(s1);*/
			}
			
			
			
			/**/
			static InputReader in=new InputReader(System.in);
                static OutputWriter out=new OutputWriter(System.out);
                public static long l()
                {
                    String s=in.String();
                    return Long.parseLong(s);
                }
                public static void pln(String value)
                {
                    System.out.println(value);
                }
                public static int i()
                {
                    return in.Int();
                }
                public static String s()
                {
                    return in.String();
                }
	}
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
        class InputReader {
        	 
        	private InputStream stream;
        	private byte[] buf = new byte[1024];
        	private int curChar;
        	private int numChars;
        	private SpaceCharFilter filter;
         
        	public InputReader(InputStream stream) {
        		this.stream = stream;
        	}
         
        	public int read() {
        		if (numChars== -1)
        			throw new InputMismatchException();
        		if (curChar >= numChars) {
        			curChar = 0;
        			try {
        				numChars = stream.read(buf);
        			} catch (IOException e) {
        				throw new InputMismatchException();
        			}
        			if (numChars <= 0)
        				return -1;
        		}
        		return buf[curChar++];
        	}
         
        	public int Int() {
        		int c = read();
        		while (isSpaceChar(c))
        			c = read();
        		int sgn = 1;
        		if (c == '-') {
        			sgn = -1;
        			c = read();
        		}
        		int res = 0;
        		do {
        			if (c < '0' || c > '9')
        				throw new InputMismatchException();
        			res *= 10;
        			res += c - '0';
        			c = read();
        		} while (!isSpaceChar(c));
        		return res * sgn;
        	}
         
        	public String String() {
        		int c = read();
        		while (isSpaceChar(c))
        			c = read();
        		StringBuilder res = new StringBuilder();
        		do {
        			res.appendCodePoint(c);
        			c = read();
        		} while (!isSpaceChar(c));
        		return res.toString();
        	}
         
        	public boolean isSpaceChar(int c) {
        		if (filter != null)
        			return filter.isSpaceChar(c);
        		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        	}
         
        	public String next() {
        		return String();
        	}
         
        	public interface SpaceCharFilter {
        		public boolean isSpaceChar(int ch);
        	}
        }
         
        class OutputWriter {
        	private final PrintWriter writer;
         
        	public OutputWriter(OutputStream outputStream) {
        		writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        	}
         
        	public OutputWriter(Writer writer) {
        		this.writer = new PrintWriter(writer);
        	}
         
        	public void print(Object...objects) {
        		for (int i = 0; i < objects.length; i++) {
        			if (i != 0)
        				writer.print(' ');
        			writer.print(objects[i]);
        		}
        	}
         
        	public void printLine(Object...objects) {
        		print(objects);
        		writer.println();
        	}
         
        	public void close() {
        		writer.close();
        	}
         
        	public void flush() {
        		writer.flush();
        	}
         
        	}
         
            class IOUtils {
         
        	public static int[] readIntArray(InputReader in, int size) {
        		int[] array = new int[size];
        		for (int i = 0; i < size; i++)
        			array[i] = in.Int();
        		return array;
        	}
         
        	} 