It is so boring in the summer holiday, isn't it? So Alice and Bob have invented a new game to play. The rules are as follows. First, they get a set of n distinct integers. And then they take turns to make the following moves. During each move, either Alice or Bob (the player whose turn is the current) can choose two distinct integers x and y from the set, such that the set doesn't contain their absolute difference |x - y|. Then this player adds integer |x - y| to the set (so, the size of the set increases by one).

If the current player has no valid move, he (or she) loses the game. The question is who will finally win the game if both players play optimally. Remember that Alice always moves first.

Input

The first line contains an integer n (2 ≤ n ≤ 100) — the initial number of elements in the set. The second line contains n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the elements of the set.

Output

Print a single line with the winner's name. If Alice wins print "Alice", otherwise print "Bob" (without quotes).

Examples

Input

2
2 3


Output

Alice


Input

2
5 3


Output

Alice


Input

3
5 6 7


Output

Bob

Note

Consider the first test sample. Alice moves first, and the only move she can do is to choose 2 and 3, then to add 1 to the set. Next Bob moves, there is no valid move anymore, so the winner is Alice.

import javafx.util.Pair;

import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.nio.Buffer;
import java.util.*;

public class codeforces
{


   // public static long fact[];
   // public static int mod=1000000007;
    public static long []st;
    public static int k;
    public static int[][] grid;
   // public static boolean[][] visit;
    public static int n;
    public static int m;
    public static long q;
    public static int move=0;
    public static long MOD;
    static int []dx = {1,1,0,-1,-1,-1,0,1};
    static int []dy = {0,1,1,1,0,-1,-1,-1};
    static long []a ;
    static int ans;
    public static long badCount=0;
    public static HashSet<String> hs;
    static int[][] visit;
    public static int []x={-1,-1,-2,-2,2,2,1,1};
    public static int []y={-2,2,-1,1,-1,1,-2,2};


    public static void main(String[] args) throws IOException {

        InputReader in = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);

        int n = in.nextInt();
       // int []a = new int[n];
        long []a = new long[n];
        for (int  i =0; i<n;i++)
        {
            a[i] = in.nextLong();
        }
        Arrays.sort(a);
        long g = a[0];
       // out.println(gcd(20,12));
        for (int i=1;i<n;i++)
        {
            g = gcd(g,a[i]);
        }
        long k = a[n-1]/g - n ;
        if(k%2 ==1)
        {
            out.println("Alice");
        }else
        {
            out.println("Bob");
        }


        out.close();

        }
        static long gcd(long a , long b)
        {
            if(a == 0)
                return b;
            else
                return gcd(b%a,a);

        }



    public static long mod = 1000000009, inf = 1000000000L;
    public static long fac[],inv[];
    public static void cal()
    {
        fac = new long[1000005];
        inv = new long[1000005];
        fac[0]=1;
        inv[0]=1;
        for(int i=1; i<=1000000; i++)
        {
            fac[i]=(fac[i-1]*i)%mod;
            inv[i]=(inv[i-1]*modPow(i,mod-2,mod))%mod;

        }
    }
    public static long ncr(int n, int r)
    {
        return (((fac[n]*inv[r])%mod)*inv[n-r])%mod;
    }

    public static long modPow(long base, long exp, long mod) {
        base = base % mod;
        long result =1;
        while(exp > 0)
        {
            if(exp % 2== 1)
            {
                result = (result * base) % mod;
                exp --;
            }
            else
            {
                base = (base * base) % mod;
                exp = exp >> 1;
            }

        }
        return result;
    }






    public static int check(int n) {
        int m = n;
        int digit;
        int count = 0;
        while(m > 0) {
            digit = m % 10;
            m = m / 10;
            if(n % digit == 0) {
                count++;
            }
        }
        if(count >= 2) {
            return 1;
        } else {
            return 0;
        }
    }

    static boolean isPalindrome(int str[])
    {
        int l = 0;
        int h = str.length - 1;

        while (h > l)
        {
            if (str[l++] != str[h--])
            {
               return false;
            }
        }
      return true;
    }

    public static boolean isPrime(int n) {
        // Corner cases
        if (n <= 1)
            return false;
        if (n <= 3)
            return true;

        // This is checked so that we can skip
        // middle five numbers in below loop
        if (n % 2 == 0 || n % 3 == 0)
            return false;

        for (int i = 5; i * i <= n; i = i + 6)
            if (n % i == 0 || n % (i + 2) == 0)
                return false;

        return true;
    }
    public static int lcs(char []aa,char []bb , int n,int m)
    {
        int [][]l=new int[n+1][m+1];
        for (int i=0;i<=n;i++)
        {
            for (int j=0;j<=m;j++)
            {
                if(i==0 || j==0)
                {
                    l[i][j]=0;
                }else if(aa[i-1]==bb[j-1])
                {
                    l[i][j]=1+l[i-1][j-1];
                }else
                {
                    l[i][j]=Math.max(l[i-1][j],l[i][j-1]);
                }
            }
        }
        return l[n][m];

    }


    public static int bs(int []search,int target)
    {
        int low=0;
        int high=search.length-1;
        int ans=0;
        while (low<=high) {
            int mid = (low + high) >> 1;
            if (search[mid] <= target) {
                ans = mid;
                low = mid + 1;
            } else {
                high = mid - 1;
            }
        }
        return ans;

    }

   public static long ts(long start, long end)
    {
        long l = start, r = end;

        for(int i=0; i<200; i++) {
            long l1 = (l*2+r)/3;
            long l2 = (l+2*r)/3;

            if(fc(l1) > fc(l2))
                r = l2;
            else
                l = l1;
        }

       long x=l;

        return x;
    }
    public static long fc(long x) {

        return x*(n-x*q);
    }

   /* public static int bfs(int i,int j,int n,int m)
    {
        int troop=0;
        Queue<node> qq=new LinkedList<>();
        qq.add(new node(i,j));
        while (!qq.isEmpty())
        {
            node cur=qq.poll();
            troop++;
            for (int r=-1;r<=1;r++)
            {
                for (int c=-1;c<=1;c++)
                {
                    if(cur.x+r>=0 && cur.x+r<n && cur.y+c>=0 && cur.y+c<m)
                    {
                        if(!visit[cur.x+r][cur.y+c])
                        {
                            visit[cur.x+r][cur.y+c]=true;
                            if(grid[cur.x+r][cur.y+c]==1)
                            {
                                qq.add(new node(cur.x+r,cur.y+c));
                            }

                        }
                    }

                }
            }
        }
        return troop;


    }
    */

    static class node{

        int x;
        int y;

        public node(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }




    public static int nextPowerOf2(final int a) {
        int b = 1;
        while (b < a) {
            b = b << 1;
        }
        return b;
    }

    public static long []contruct(long []a)

    {
        int next2power=nextPowerOf2(a.length);
        st=new long[next2power*2-1];
        //System.out.println(size);
        // st=new long[size];
        Arrays.fill(st,Integer.MAX_VALUE);
        constructST(a,0,a.length-1,0);
        return st;



    }
    public static void constructST(long []a,int start,int end,int pos)
    {
        if(start==end)
        {
            st[pos]=a[start];
            return ;
        }
        int mid=(start+end)>>1;
        constructST(a,start,mid,pos*2+1);
        constructST(a,mid+1,end,pos*2+2);
        st[pos]=st[2*pos+1]^st[2*pos+2];


    }

       static class InputReader {

        private InputStream stream;
        private byte[] buf = new byte[8192];
        private int curChar, snumChars;
        private InputReader.SpaceCharFilter filter;

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

        public int snext() {
            if (snumChars == -1)
                throw new InputMismatchException();
            if (curChar >= snumChars) {
                curChar = 0;
                try {
                    snumChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (snumChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = snext();
            while (isSpaceChar(c))
                c = snext();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = snext();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = snext();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public long nextLong() {
            int c = snext();
            while (isSpaceChar(c))
                c = snext();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = snext();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = snext();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public int[] nextIntArray(int n) {
            int a[] = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }

        public String readString() {
            int c = snext();
            while (isSpaceChar(c))
                c = snext();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = snext();
            } 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 interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }
}