Vasya has a multiset s consisting of n integer numbers. Vasya calls some number x nice if it appears in the multiset exactly once. For example, multiset \{1, 1, 2, 3, 3, 3, 4\} contains nice numbers 2 and 4.

Vasya wants to split multiset s into two multisets a and b (one of which may be empty) in such a way that the quantity of nice numbers in multiset a would be the same as the quantity of nice numbers in multiset b (the quantity of numbers to appear exactly once in multiset a and the quantity of numbers to appear exactly once in multiset b).

Input

The first line contains a single integer n~(2 ≤ n ≤ 100).

The second line contains n integers s_1, s_2, ... s_n~(1 ≤ s_i ≤ 100) — the multiset s.

Output

If there exists no split of s to satisfy the given requirements, then print "NO" in the first line.

Otherwise print "YES" in the first line.

The second line should contain a string, consisting of n characters. i-th character should be equal to 'A' if the i-th element of multiset s goes to multiset a and 'B' if if the i-th element of multiset s goes to multiset b. Elements are numbered from 1 to n in the order they are given in the input.

If there exist multiple solutions, then print any of them.

Examples

Input

4
3 5 7 1


Output

YES
BABA


Input

3
3 5 1


Output

NO
import java.util.*;
import java.util.Map.Entry;
import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
public class codefor_3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
    FastReader s = new FastReader();
    int t=s.nextInt();
    int[] arr = new int[t];
 //   int[] arr2 = new int[t];
    HashMap<Integer,Integer> h = new HashMap<Integer,Integer>();
    boolean res=false;
    HashMap<Integer,Character> h1 = new HashMap<Integer,Character>();

    int val=0;
    for(int i=0;i<t;i++)
    {
    	arr[i]=s.nextInt();
    //	arr2[i]=s.nextInt();
    	if(h.containsKey(arr[i]))
    	{
    		int k1 = h.get(arr[i]);
    		h.put(arr[i],k1+1);
    		if(k1+1==2)
    		{
    			res=true;
    			val=arr[i];
    		}
    	}
    	else
    		h.put(arr[i],0);
    }
    for(Map.Entry<Integer,Integer>e : h.entrySet())
    {
    	if(e.getValue()>0)
    	{
    		h.put(e.getKey(),Integer.MAX_VALUE);
    	}
    }
    int c=0;
    for(Map.Entry<Integer,Integer> e: h.entrySet())
    {
    	if(e.getValue()!=Integer.MAX_VALUE)
    	c++;
    }
    
    if(c%2!=0)
    {
    	if(res==false)
    	System.out.println("NO");
    	else
    	{
    		boolean m=true;
    		System.out.println("YES");
    		for(int i=0;i<arr.length;i++)
        	{
        		if(h.get(arr[i])!=Integer.MAX_VALUE)
        		{
        			if(m)
        			{
        				System.out.print("B");
        			
        			}
        			else
        				System.out.print("A");
        			m=!m;
        			
        		}
        		else
        		{
        			if(!h1.containsKey(arr[i]) && arr[i]==val)
        			{
        				System.out.print("A");
        				h1.put(arr[i],'B');
        			}
        			else if(!h1.containsKey(arr[i]) && arr[i]!=val)
        			{
        				System.out.print("B");
        				h1.put(arr[i],'B');
        			}
        			else
        			{
        				char c1  =h1.get(arr[i]);
        				System.out.print(c1);
        			//	System.out.println(arr[i]+" "+c1);
        			}
        			
        		}
        	}
    	}
    }
    else
    {
    	boolean m=true;
    	System.out.println("YES");
    	for(int i=0;i<arr.length;i++)
    	{
    		if(h.get(arr[i])!=Integer.MAX_VALUE)
    		{
    			if(m)
    			{
    				System.out.print("B");
    			
    			}
    			else
    				System.out.print("A");
    			m=!m;
    			
    		}
    		else
    		{
    			System.out.print("B");
    		}
    	}
    }
//    int[] arr1 = new int[t];
//    Arrays.sort(arr);
//    int len=0;
//    boolean b=true;
//    for(int i=0;i<arr.length-1;i++)
//    {
//    	if(arr[i]!=arr[i+1] && b==true)
//    	{
//    	
//    		arr1[len]=arr[i];
//    		len++;
//    	}
//    	if(arr[i]!=arr[i+1] && b==false)
//    	{
//    	
//    		b=true;
//    	}
//    	if(arr[i]==arr[i+1])
//    	{
//    		b=false;
//    	}
//    		
//    }
//    if(arr[arr.length-2]!=arr[arr.length-1])
//    	arr1[len]=arr[arr.length-1];
//    
//    
    
}


static class FastReader 
{ 
    BufferedReader br; 
    StringTokenizer st; 

    public FastReader() 
    { 
        br = new BufferedReader(new
                 InputStreamReader(System.in)); 
    } 

    String next() 
    { 
        while (st == null || !st.hasMoreElements()) 
        { 
            try
            { 
                st = new StringTokenizer(br.readLine()); 
            } 
            catch (IOException  e) 
            { 
                e.printStackTrace(); 
            } 
        } 
        return st.nextToken(); 
    } 

    int nextInt() 
    { 
        return Integer.parseInt(next()); 
    } 

    long nextLong() 
    { 
        return Long.parseLong(next()); 
    } 

    double nextDouble() 
    { 
        return Double.parseDouble(next()); 
    } 

    String nextLine() 
    { 
        String str = ""; 
        try
        { 
            str = br.readLine(); 
        } 
        catch (IOException e) 
        { 
            e.printStackTrace(); 
        } 
        return str; 
    } 
} 
}
