Problem: 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

Solution (in JAVA):

Solution:


import java.math.BigInteger;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Solution {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		
		int count = Integer.parseInt(scanner.nextLine());
		
		int[] nums = Util.toIntArray(scanner.nextLine());
		
		
		
		Map<Integer, Set<Integer>> meta = 
		
		IntStream.range(0, count)
			.boxed()
			.collect(Collectors.groupingBy(i -> nums[i], Collectors.toSet()));
		
		int singles = 0, moreThan2 = 0;
		for(Set<Integer> val : meta.values()) {
			if(val.size() == 1) {
				singles++;
			} else if(val.size() > 2) {
				moreThan2++;
			}
		}
		if(Util.isOdd(singles) && moreThan2 == 0) {
			System.out.println("NO");
			return;
		}
		
		char[] result = new char[count];
		boolean balanced = true;
		Set<Integer> moreThan2Values = null;
		for(Entry<Integer, Set<Integer>> e : meta.entrySet()) {
			if(e.getValue().size() == 2) {
				e.getValue().forEach(i -> result[i] = 'A');
			} else if(e.getValue().size() == 1) {
				if(balanced) {
					result[e.getValue().iterator().next()] = 'A';
				} else {
					result[e.getValue().iterator().next()] = 'B';
				}
				balanced = !balanced;
			} else {
				moreThan2Values = e.getValue();
			}
			
			
		}
		
		if(!balanced) {
			result[moreThan2Values.iterator().next()] = 'B';
		}
		
		for(int i = 0; i < result.length; i++) {
			if(result[i] != 'A' && result[i] != 'B') {
				result[i] = 'A';
			}
		}
		System.out.println("YES");
		System.out.println(new String(result));
		
	}
	
	public static class Util {

		public static int[] toIntArray(String s) {
			String[] nums = s.split("\\s");
			return IntStream.range(0, nums.length)
				.map(index -> Integer.parseInt(nums[index]))
				.toArray();
		}
		
		public static BigInteger[] toBigIntArray(String s) {
			String[] nums = s.split("\\s");
			return IntStream.range(0, nums.length)
					.boxed()
					.map(index -> new BigInteger(nums[index]))
					.toArray(size -> new BigInteger[size]);
			
		}
		
		public static long[] toLongArray(String s) {
			String nums[] = s.split("\\s");
			return IntStream.range(0, nums.length)
					.mapToLong(index -> Long.parseLong(nums[index]))
					.toArray();
	    }
		
		
		public static String getSpaceSeperatedInts(int[] ints) {
			return Stream.of(ints).map(String::valueOf).collect(Collectors.joining(" "));
		}
		
		public static String getSpaceSeperatedBigInteger(BigInteger[] nums) {
			return Stream.of(nums)
					.map(BigInteger::toString)
					.collect(Collectors.joining(" "));
			
		}
		
		public static boolean isEven(long number) {
			return number % 2 == 0;
		}
		
		public static boolean isOdd(long number) {
			return !isEven(number);
		}
		
		public static boolean isEven(BigInteger number) {
			return !number.testBit(1);
		}
		
		public static boolean isOdd(BigInteger number) {
			return !isEven(number);
		}
		
	}

}