Alice and Bob are playing a game with n piles of stones. It is guaranteed that n is an even number. The i-th pile has a_i stones.

Alice and Bob will play a game alternating turns with Alice going first.

On a player's turn, they must choose exactly n/2 nonempty piles and independently remove a positive number of stones from each of the chosen piles. They can remove a different number of stones from the piles in a single turn. The first player unable to make a move loses (when there are less than n/2 nonempty piles).

Given the starting configuration, determine who will win the game.

Input

The first line contains one integer n (2 ≤ n ≤ 50) — the number of piles. It is guaranteed that n is an even number.

The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 50) — the number of stones in the piles.

Output

Print a single string "Alice" if Alice wins; otherwise, print "Bob" (without double quotes).

Examples

Input


2
8 8


Output


Bob


Input


4
3 1 4 1


Output


Alice

Note

In the first example, each player can only remove stones from one pile (2/2=1). Alice loses, since Bob can copy whatever Alice does on the other pile, so Alice will run out of moves first.

In the second example, Alice can remove 2 stones from the first pile and 3 stones from the third pile on her first move to guarantee a win.
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.lang.invoke.MethodHandles;
import java.math.BigInteger;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map.Entry;
import java.util.PriorityQueue;
import java.util.Random;
import java.util.TreeSet;

public final class CF_557_D2_E
{


	static boolean verb=true;
	static void log(Object X){if (verb) System.err.println(X);}
	static void log(Object[] X){if (verb) {for (Object U:X) System.err.print(U+" ");System.err.println("");}}
	static void log(int[] X){if (verb) {for (int U:X) System.err.print(U+" ");System.err.println("");}}
	static void log(int[] X,int L){if (verb) {for (int i=0;i<L;i++) System.err.print(X[i]+" ");System.err.println("");}}
	static void log(long[] X){if (verb) {for (long U:X) System.err.print(U+" ");System.err.println("");}}

	static void logWln(Object X){if (verb) System.err.print(X);}
	static void info(Object o){	System.out.println(o);}
	static void output(Object o){outputWln(""+o+"\n");	}
	static void outputWln(Object o){try {out.write(""+ o);} catch (Exception e) {}}

	static long mod=1000000007;

	// Global vars
	static BufferedWriter out;
	static InputReader reader;


	static void test() {
		log("testing");
		
		
		cache=new HashMap<String,Boolean>();
		//log(solveBourrin4(new int[] {2,2,2,1}));
		Random r=new Random();
		for (int t=0;t<100;t++) {
			int[] ar=new int[8];
			for (int i=0;i<8;i++)
				ar[i]=r.nextInt(5)+1;
			
			if (!solveBourrin6(ar))
				log(ar);
			
		}
		
	
		log("done");
	}

	static HashMap<String,Boolean> cache;

	static boolean solveBourrin6(int[] ar) {
		Arrays.sort(ar);
		String s="";
		for (int x:ar)
			s+=x+" ";
		Boolean z=cache.get(s);
		if (z!=null)
			return (boolean)z;
		int n=6;
		int cn=0;
		for (int i=0;i<n;i++) {
			if (ar[i]==1)
				cn++;
		}
		if (cn>n/2)
			return false;
		boolean ok=true;
		for (int a=0;a<n;a++)
			for (int b=a+1;b<n;b++)
				for (int c=b+1;c<n;c++) {
					for (int da=1;da<ar[a];da++)
						for (int db=1;db<ar[b];db++)
							for (int dc=1;dc<ar[c];dc++) {
								int[] tm=new int[n];
								System.arraycopy(ar,0,tm,0,n);
								tm[a]-=da;
								tm[b]-=db;
								tm[c]-=dc;
								boolean bob=solveBourrin6(tm);
								if (bob==false)
									return true;
							}
									
					
				}
		cache.put(s,false);
		return false;
	}
	
	static boolean solveBourrin8(int[] ar) {
		Arrays.sort(ar);
		String s="";
		for (int x:ar)
			s+=x+" ";
		Boolean z=cache.get(s);
		if (z!=null)
			return (boolean)z;
		int n=8;
		int cn=0;
		for (int i=0;i<n;i++) {
			if (ar[i]==1)
				cn++;
		}
		if (cn>n/2)
			return false;
		boolean ok=true;
		for (int a=0;a<n;a++)
			for (int b=a+1;b<n;b++)
				for (int c=b+1;c<n;c++) 
				for (int d=c+1;d<n;d++)
				{
					for (int da=1;da<ar[a];da++)
						for (int db=1;db<ar[b];db++)
							for (int dc=1;dc<ar[c];dc++) 
								for (int dd=1;dd<ar[d];dd++) {
								int[] tm=new int[n];
								System.arraycopy(ar,0,tm,0,n);
								tm[a]-=da;
								tm[b]-=db;
								tm[c]-=dc;
								tm[d]-=dd;
								boolean bob=solveBourrin8(tm);
								if (bob==false)
									return true;
							}
									
					
				}
		cache.put(s,false);
		return false;
	}
	
	
	static boolean solveBourrin4(int[] ar) {
		Arrays.sort(ar);
		String s="";
		for (int x:ar)
			s+=x+" ";
		Boolean z=cache.get(s);
		if (z!=null)
			return (boolean)z;
		int n=4;
		int cn=0;
		for (int i=0;i<n;i++) {
			if (ar[i]==1)
				cn++;
		}
		if (cn>n/2)
			return false;
		boolean ok=true;
		for (int a=0;a<n;a++)
			for (int b=a+1;b<n;b++)
				 {
					for (int da=1;da<ar[a];da++)
						for (int db=1;db<ar[b];db++)
							 {
								int[] tm=new int[n];
								System.arraycopy(ar,0,tm,0,n);
								tm[a]-=da;
								tm[b]-=db;
								boolean bob=solveBourrin4(tm);
								if (bob==false)
									return true;
							}
									
					
				}
		cache.put(s,false);
		return false;
	}
	

	static void process() throws Exception {


		out = new BufferedWriter(new OutputStreamWriter(System.out));
		reader = new InputReader(System.in);

		//test();
		int n=reader.readInt();
		int[] a=new int[n];
		for (int i=0;i<n;i++)
			a[i]=reader.readInt();
		
		String ans="Alice";
		if (n==2) {
			if (a[0]==a[1]) {
				ans="Bob";
			}
		} else {
			Arrays.sort(a);
			int mid=n/2;
			if (n==4)
				mid++;
			if (a[0]==a[mid-1])
				ans="Bob";
			
		}
		output(ans);
		
		
		try {
			out.close();
		} catch (Exception e) {
		}

	}

	public static void main(String[] args) throws Exception {
		process();

	}

	static final class InputReader {
		private final InputStream stream;
		private final byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;

		public InputReader(InputStream stream) {
			this.stream = stream;
		}

		private int read() throws IOException {
			if (curChar >= numChars) {
				curChar = 0;
				numChars = stream.read(buf);
				if (numChars <= 0) {
					return -1;
				}
			}
			return buf[curChar++];
		}

		public final String readString() throws IOException {
			int c = read();
			while (isSpaceChar(c)) {
				c = read();
			}
			StringBuilder res = new StringBuilder();
			do {
				res.append((char) c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public final int readInt() throws IOException {
			int c = read();
			boolean neg = false;
			while (isSpaceChar(c)) {
				c = read();
			}
			char d = (char) c;
			// log("d:"+d);
			if (d == '-') {
				neg = true;
				c = read();
			}
			int res = 0;
			do {
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			// log("res:"+res);
			if (neg)
				return -res;
			return res;

		}

		public final long readLong() throws IOException {
			int c = read();
			boolean neg = false;
			while (isSpaceChar(c)) {
				c = read();
			}
			char d = (char) c;
			// log("d:"+d);
			if (d == '-') {
				neg = true;
				c = read();
			}
			long res = 0;
			do {
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			// log("res:"+res);
			if (neg)
				return -res;
			return res;

		}

		private boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}
	}

}