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 a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 10^9) — 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.

Source: codeforces | Difficulty: MEDIUM_HARD
Tags: Number theory

Game theory

Mathematics


Solutions:
import math
for _ in range(1):
	n = int(input())
	a = list(map(int, input().split()))
	g = 0
	for i in range(0, len(a)):
		g = math.gcd(a[i], g)
	maxi = max(a) // g
	if (n - maxi) % 2 == 0:
		print('Bob')
	else:
		print('Alice')


from fractions import gcd
from functools import reduce
n = int(input())
a = list(map(int, input().split()))
g = reduce(gcd, a)
s = max(a) // g - n
if s % 2:
	print('Alice')
else:
	print('Bob')


def gcd(a, b):
	c = a % b
	return gcd(b, c) if c else b
n = int(input())
t = list(map(int, input().split()))
x = gcd(t[0], t[1])
for i in t[2:]:
	x = gcd(i, x)
print(['Bob', 'Alice'][(max(t) // x - n) % 2])


def gcd(a, b):
	while a != 0 and b != 0:
		(a, b) = (b % a, a)
	return a + b

def gcd2(a):
	g = a[0]
	for i in a:
		g = gcd(g, i)
	return g
n = int(input())
a = list(map(int, input().split()))
print('Bob' if (n - max(a) // gcd2(a)) % 2 == 0 else 'Alice')


(n, listo2, c) = (int(input()), [], 0)
import math
listo = list(map(int, input().split()))
listo.sort()
obaa = listo[0]

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
for i in range(1, n):
	GCD = gcd(listo[i], obaa)
	obaa = GCD
bomba = int(listo[n - 1] / GCD) - n
if bomba % 2 == 0:
	print('Bob')
else:
	print('Alice')


def gcd(x, y):
	while x:
		y = y % x
		(x, y) = (y, x)
	return y

def main():
	n = int(input())
	v = list(map(int, input().split()))
	a = max(v)
	g = v[0]
	for vk in v:
		g = gcd(g, vk)
	a = a // g - n
	if a % 2:
		print('Alice')
	else:
		print('Bob')
main()


def gcd(a, b):
	return gcd(b, a % b) if b else a
n = int(input())
A = [int(x) for x in input().split()]
A.sort()
g = 0
for x in A:
	g = gcd(x, g)
print('Alice' if (A[n - 1] // g - n) % 2 else 'Bob')


from fractions import gcd
n = int(input())
a = list(map(int, input().split()))
d = gcd(a[0], a[1])
for i in range(1, n, 1):
	d = gcd(d, a[i])
m2 = max(a)
if (m2 // d - n) % 2 == 1:
	print('Alice')
else:
	print('Bob')


import fractions
n = int(input())
a = list(map(int, input().split()))
gcd = a[0]
for x in a:
	gcd = fractions.gcd(gcd, x)
moves = max(a) // gcd - n
print('Alice' if moves % 2 else 'Bob')


import collections
import functools
import math
import random
import sys
import bisect
import copy
import io, os
input = sys.stdin.readline

def In():
	return map(int, input().split())

def pf(*args, sep=' ', end='\n'):
	print(*args, sep=sep, end=end)
	sys.stdout.flush()

def art():
	for _ in range(int(input())):
		(n, l, r) = In()
		last = 0
		ans = 0
		for i in input().split():
			i = int(i)
			ans += max(i - last, 0)
			last = i
		print(ans)

def ab():
	n = int(input())
	gcf = 0
	m = 0
	for i in input().split():
		i = int(i)
		m = max(i, m)
		gcf = math.gcd(gcf, i)
	print(['Alice', 'Bob'][not (m // gcf - n) % 2])
ab()


from fractions import gcd
n = int(input())
A = list(map(int, input().split()))
A.sort()
x = A[0]
for i in range(1, n):
	x = gcd(x, A[i])
moves = max(A) // x - n
if moves % 2 == 0:
	print('Bob')
else:
	print('Alice')


def gcd(a, b):
	if a < b:
		(a, b) = (b, a)
	if b == 0:
		return a
	return gcd(a % b, b)
n = int(input())
a = list(map(int, input().split()))
ma = max(a)
mi = min(a)
c = a[0]
for i in a[1:]:
	c = gcd(c, i)
ma //= c
if (ma - n) % 2 == 1:
	print('Alice')
else:
	print('Bob')


def find(x):
	if x % 2 == 1:
		print('Alice')
	else:
		print('Bob')
n = int(input().strip())
la = [int(x) for x in input().strip().split()]
odd = 0
even = 0
i = 0
mx = 0
mv = 1000 ** 3
while i < n:
	if la[i] % 2 == 1:
		odd = 1
	else:
		even = 1
	mx = max(mx, la[i])
	mv = min(mv, la[i])
	i += 1
if odd == 0:
	rem = mx
	for i in range(0, n):
		for j in range(i + 1, n):
			if la[i] > la[j]:
				mod = la[i] % la[j]
				if mod == 0:
					continue
				if mod < rem:
					rem = mod
				if la[i] % mod != 0 and la[i] % mod < rem:
					rem = la[i] % mod
				if la[j] % mod != 0 and la[j] % mod < rem:
					rem = la[j] % mod
			elif la[j] > la[i]:
				mod = la[j] % la[i]
				if mod == 0:
					continue
				if mod < rem:
					rem = mod
				if la[i] % mod != 0 and la[i] % mod < rem:
					rem = la[i] % mod
				if la[j] % mod != 0 and la[j] % mod < rem:
					rem = la[j] % mod
	mv = mx // rem - n
	find(mv)
else:
	find(mx - n)


import itertools as it
import math
n = int(input())
a = list(map(int, input().split()))
g = list(it.accumulate(a, math.gcd))[-1]
print(('Bob', 'Alice')[(max(a) // g - n) % 2])


from fractions import gcd
n = int(input())
sez = [int(i) for i in input().split()]
sez.sort()
g = gcd(sez[0], sez[1])
for i in range(2, n):
	g = gcd(g, sez[i])
left = sez[n - 1] / g - n
if left % 2 == 1:
	print('Alice')
else:
	print('Bob')


import math
n = int(input())
a = list(map(int, input().split()))
j = 1
p = a[0]
q = max(a)
while j < n:
	p = math.gcd(p, a[j])
	if p == 1:
		break
	else:
		j = j + 1
res = q // p - n
if res % 2 == 0:
	print('Bob')
else:
	print('Alice')


def gcd(a, b):
	while a > 0:
		(a, b) = (b % a, a)
	return b
n = int(input())
a = [int(x) for x in input().split()]
g = a[0]
m = a[0]
for i in range(1, n):
	g = gcd(g, a[i])
	m = m if m >= a[i] else a[i]
if (m // g - n) % 2:
	print('Alice')
else:
	print('Bob')


def gcd(x, y):
	if x < y:
		return gcd(y, x)
	elif y == 0:
		return x
	else:
		return gcd(y, x % y)
inp = input()
inp = input()
arr = inp.split(' ')
L = []
for a in arr:
	L.append(int(a))
L.sort()
mv = L[0]
T = L[1:]
for t in T:
	mv = gcd(mv, t)
tot = L[-1] // mv
for l in L:
	if l % mv == 0:
		tot -= 1
if tot % 2 == 1:
	print('Alice')
else:
	print('Bob')


import sys
input = sys.stdin.readline

def ceil(x):
	if x != int(x):
		x = int(x) + 1
	return x

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def nCr(n, k):
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def upper_bound(a, x, lo=0, hi=None):
	if hi == None:
		hi = len(a)
	while lo < hi:
		mid = (lo + hi) // 2
		if a[mid] < x:
			lo = mid + 1
		else:
			hi = mid
	return lo

def primefs(n):
	primes = {}
	while n % 2 == 0 and n > 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0 and n > 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
MAXN = int(100000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i

def factoriazation(x):
	ret = {}
	while x != 1:
		ret[spf[x]] = ret.get(spf[x], 0) + 1
		x = x // spf[x]
	return ret

def int_array():
	return list(map(int, input().strip().split()))

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
n = int(input())
a = sorted(int_array())
num = a[0]
for i in a:
	num = gcd(num, i)
x = a[-1] // num
x -= n
if x % 2:
	print('Alice')
else:
	print('Bob')


import fractions
n = int(input())
A = list(map(int, input().split()))
x = A[0]
for i in A:
	x = fractions.gcd(x, i)
if (max(A) // x - len(A)) % 2 == 0:
	print('Bob')
else:
	print('Alice')


from math import *
from collections import *
from random import *
from bisect import *
import sys
input = sys.stdin.readline

def lis():
	return list(map(int, input().split()))

def ma():
	return map(int, input().split())

def inp():
	return int(input())

def bfs(deg, vis, cur):
	qu = deque([])
	qu.append(cur)
	while qu:
		x = qu.popleft()
		vis[x] = 1
		for i in deg[x]:
			if vis[i] == 0:
				qu.append(i)
n = inp()
a = lis()
z = max(a)
x = 0
s = 'Alice'
for i in a:
	x = gcd(x, i)
need = z // x - n
if need % 2 == 0:
	s = 'Bob'
print(s)


import math as mt
import sys, string
input = sys.stdin.readline
from collections import defaultdict
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())
n = I()
l = L()
m = 0
g = l[0]
for i in l:
	g = mt.gcd(g, i)
	m = max(m, i)
ans = m // g - n
if ans % 2:
	print('Alice')
else:
	print('Bob')


def gcd(a, b):
	while a:
		(a, b) = (b % a, a)
	return b
n = int(input())
A = list(map(int, input().split()))
G = A[0]
for i in range(1, n):
	G = gcd(G, A[i])
for i in range(n):
	A[i] //= G
if (max(A) - n) % 2 == 1:
	print('Alice')
else:
	print('Bob')


n = int(input())
l = [int(i) for i in input().split()]

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)
g = 0
for i in l:
	g = gcd(g, i)
no_of_moves = max(l) // g - n
print('Alice' if no_of_moves & 1 else 'Bob')


import sys, os, io

def rs():
	return sys.stdin.readline().rstrip()

def ri():
	return int(sys.stdin.readline())

def ria():
	return list(map(int, sys.stdin.readline().split()))

def ws(s):
	sys.stdout.write(s + '\n')

def wi(n):
	sys.stdout.write(str(n) + '\n')

def wia(a):
	sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
import math, datetime, functools, itertools, operator, bisect, fractions, statistics
from collections import deque, defaultdict, OrderedDict, Counter
from fractions import Fraction
from decimal import Decimal
from sys import stdout
from heapq import heappush, heappop, heapify, _heapify_max, _heappop_max, nsmallest, nlargest
INF = 999999999999999999999999
alphabets = 'abcdefghijklmnopqrstuvwxyz'

class SortedList:

	def __init__(self, iterable=[], _load=200):
		values = sorted(iterable)
		self._len = _len = len(values)
		self._load = _load
		self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
		self._list_lens = [len(_list) for _list in _lists]
		self._mins = [_list[0] for _list in _lists]
		self._fen_tree = []
		self._rebuild = True

	def _fen_build(self):
		self._fen_tree[:] = self._list_lens
		_fen_tree = self._fen_tree
		for i in range(len(_fen_tree)):
			if i | i + 1 < len(_fen_tree):
				_fen_tree[i | i + 1] += _fen_tree[i]
		self._rebuild = False

	def _fen_update(self, index, value):
		if not self._rebuild:
			_fen_tree = self._fen_tree
			while index < len(_fen_tree):
				_fen_tree[index] += value
				index |= index + 1

	def _fen_query(self, end):
		if self._rebuild:
			self._fen_build()
		_fen_tree = self._fen_tree
		x = 0
		while end:
			x += _fen_tree[end - 1]
			end &= end - 1
		return x

	def _fen_findkth(self, k):
		_list_lens = self._list_lens
		if k < _list_lens[0]:
			return (0, k)
		if k >= self._len - _list_lens[-1]:
			return (len(_list_lens) - 1, k + _list_lens[-1] - self._len)
		if self._rebuild:
			self._fen_build()
		_fen_tree = self._fen_tree
		idx = -1
		for d in reversed(range(len(_fen_tree).bit_length())):
			right_idx = idx + (1 << d)
			if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
				idx = right_idx
				k -= _fen_tree[idx]
		return (idx + 1, k)

	def _delete(self, pos, idx):
		_lists = self._lists
		_mins = self._mins
		_list_lens = self._list_lens
		self._len -= 1
		self._fen_update(pos, -1)
		del _lists[pos][idx]
		_list_lens[pos] -= 1
		if _list_lens[pos]:
			_mins[pos] = _lists[pos][0]
		else:
			del _lists[pos]
			del _list_lens[pos]
			del _mins[pos]
			self._rebuild = True

	def _loc_left(self, value):
		if not self._len:
			return (0, 0)
		_lists = self._lists
		_mins = self._mins
		(lo, pos) = (-1, len(_lists) - 1)
		while lo + 1 < pos:
			mi = lo + pos >> 1
			if value <= _mins[mi]:
				pos = mi
			else:
				lo = mi
		if pos and value <= _lists[pos - 1][-1]:
			pos -= 1
		_list = _lists[pos]
		(lo, idx) = (-1, len(_list))
		while lo + 1 < idx:
			mi = lo + idx >> 1
			if value <= _list[mi]:
				idx = mi
			else:
				lo = mi
		return (pos, idx)

	def _loc_right(self, value):
		if not self._len:
			return (0, 0)
		_lists = self._lists
		_mins = self._mins
		(pos, hi) = (0, len(_lists))
		while pos + 1 < hi:
			mi = pos + hi >> 1
			if value < _mins[mi]:
				hi = mi
			else:
				pos = mi
		_list = _lists[pos]
		(lo, idx) = (-1, len(_list))
		while lo + 1 < idx:
			mi = lo + idx >> 1
			if value < _list[mi]:
				idx = mi
			else:
				lo = mi
		return (pos, idx)

	def add(self, value):
		_load = self._load
		_lists = self._lists
		_mins = self._mins
		_list_lens = self._list_lens
		self._len += 1
		if _lists:
			(pos, idx) = self._loc_right(value)
			self._fen_update(pos, 1)
			_list = _lists[pos]
			_list.insert(idx, value)
			_list_lens[pos] += 1
			_mins[pos] = _list[0]
			if _load + _load < len(_list):
				_lists.insert(pos + 1, _list[_load:])
				_list_lens.insert(pos + 1, len(_list) - _load)
				_mins.insert(pos + 1, _list[_load])
				_list_lens[pos] = _load
				del _list[_load:]
				self._rebuild = True
		else:
			_lists.append([value])
			_mins.append(value)
			_list_lens.append(1)
			self._rebuild = True

	def discard(self, value):
		_lists = self._lists
		if _lists:
			(pos, idx) = self._loc_right(value)
			if idx and _lists[pos][idx - 1] == value:
				self._delete(pos, idx - 1)

	def remove(self, value):
		_len = self._len
		self.discard(value)
		if _len == self._len:
			raise ValueError('{0!r} not in list'.format(value))

	def pop(self, index=-1):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		value = self._lists[pos][idx]
		self._delete(pos, idx)
		return value

	def bisect_left(self, value):
		(pos, idx) = self._loc_left(value)
		return self._fen_query(pos) + idx

	def bisect_right(self, value):
		(pos, idx) = self._loc_right(value)
		return self._fen_query(pos) + idx

	def count(self, value):
		return self.bisect_right(value) - self.bisect_left(value)

	def __len__(self):
		return self._len

	def __getitem__(self, index):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		return self._lists[pos][idx]

	def __delitem__(self, index):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		self._delete(pos, idx)

	def __contains__(self, value):
		_lists = self._lists
		if _lists:
			(pos, idx) = self._loc_left(value)
			return idx < len(_lists[pos]) and _lists[pos][idx] == value
		return False

	def __iter__(self):
		return (value for _list in self._lists for value in _list)

	def __reversed__(self):
		return (value for _list in reversed(self._lists) for value in reversed(_list))

	def __repr__(self):
		return 'SortedList({0})'.format(list(self))

class SegTree:

	def __init__(self, n):
		self.N = 1 << n.bit_length()
		self.tree = [0] * (self.N << 1)

	def update(self, i, j, v):
		i += self.N
		j += self.N
		while i <= j:
			if i % 2 == 1:
				self.tree[i] += v
			if j % 2 == 0:
				self.tree[j] += v
			(i, j) = (i + 1 >> 1, j - 1 >> 1)

	def query(self, i):
		v = 0
		i += self.N
		while i > 0:
			v += self.tree[i]
			i >>= 1
		return v

def SieveOfEratosthenes(limit):
	isPrime = [True] * (limit + 1)
	isPrime[0] = isPrime[1] = False
	primes = []
	for i in range(2, limit + 1):
		if not isPrime[i]:
			continue
		primes += [i]
		for j in range(i * i, limit + 1, i):
			isPrime[j] = False
	return primes

def main():
	mod = 1000000007
	starttime = datetime.datetime.now()
	if os.path.exists('input.txt'):
		sys.stdin = open('input.txt', 'r')
		sys.stdout = open('output.txt', 'w')
	tc = 1
	for _ in range(tc):
		n = ri()
		a = sorted(ria())
		g = a[0]
		for i in range(1, n):
			g = math.gcd(a[i], g)
		k = a[-1] // g
		moves_made = k - n
		if moves_made % 2:
			ws('Alice')
		else:
			ws('Bob')
	endtime = datetime.datetime.now()
	time = (endtime - starttime).total_seconds() * 1000
	if os.path.exists('input.txt'):
		print('Time:', time, 'ms')

class FastReader(io.IOBase):
	newlines = 0

	def __init__(self, fd, chunk_size=1024 * 8):
		self._fd = fd
		self._chunk_size = chunk_size
		self.buffer = io.BytesIO()

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self, size=-1):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

class FastWriter(io.IOBase):

	def __init__(self, fd):
		self._fd = fd
		self.buffer = io.BytesIO()
		self.write = self.buffer.write

	def flush(self):
		os.write(self._fd, self.buffer.getvalue())
		(self.buffer.truncate(0), self.buffer.seek(0))

class FastStdin(io.IOBase):

	def __init__(self, fd=0):
		self.buffer = FastReader(fd)
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

class FastStdout(io.IOBase):

	def __init__(self, fd=1):
		self.buffer = FastWriter(fd)
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.flush = self.buffer.flush
sys.stdin = FastStdin()
sys.stdout = FastStdout()
main()


from math import gcd

def alice_bob(lst):
	(m, g) = (0, 0)
	for elem in lst:
		(g, m) = (gcd(g, elem), max(m, elem))
	if (m // g + len(lst)) % 2:
		return 'Alice'
	return 'Bob'
n = int(input())
a = [int(i) for i in input().split()]
print(alice_bob(a))


from math import gcd
n = int(input())
seq = [int(c) for c in input().split()]
g = seq[0]
for e in seq:
	g = gcd(g, e)
seq = [e // g for e in seq]
turns = max(seq) - len(seq)
print('Alice' if turns % 2 == 1 else 'Bob')


import math

def check(list, n):
	for i in range(0, n):
		for j in range(0, n):
			if i != j:
				if list.count(abs(list[j] - list[i])) == 0:
					return True
	return False

def gcd(list):
	s = int(math.sqrt(max(list)))
	while s >= 0:
		b = True
		for i in list:
			if i % s != 0:
				b = False
		if b == True:
			return s
		else:
			s -= 1
import sys
n = int(input())
list = list(map(int, input().split()))
f = 0
if check(list, n) == False:
	print('Bob')
	sys.exit()
l = gcd(list)
m = max(list)
m /= l
m = int(m)
m -= n
if m % 2 == 0:
	print('Bob')
else:
	print('Alice')


from sys import stdin
from math import gcd
input = stdin.readline
n = int(input())
a = [*map(int, input().split())]
g = gcd(a[-1], a[-2])
for i in a:
	g = gcd(i, g)
print(['Bob', 'Alice'][(max(a) // g - n) % 2])


from fractions import gcd
n = int(input())
a = [int(x) for x in input().split()]
gg = a[0]
for i in range(1, n):
	gg = gcd(gg, a[i])
for i in range(n):
	a[i] //= gg
if (max(a) - n) % 2 == 0:
	print('Bob')
else:
	print('Alice')


from fractions import gcd
(n, f, m) = (int(input()), 0, 0)
for x in map(int, input().split()):
	(f, m) = (gcd(f, x), max(m, x))
print('Alice' if (m // f - n) % 2 else 'Bob')


from sys import stdin, stdout
from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import *
from random import *
from itertools import permutations
input = stdin.readline
prin = stdout.write
from random import sample
from collections import Counter, deque
from fractions import *
from math import sqrt, ceil, log2, gcd, cos, pi, floor
from copy import deepcopy
mod = 10 ** 9 + 7
mod2 = 998244353

def ps(n):
	cp = 0
	lk = 0
	arr = {}
	lk = 0
	ap = n
	cc = 0
	while n % 2 == 0:
		n = n // 2
		cc = 1
	if cc == 1:
		lk += 1
	for ps in range(3, ceil(sqrt(n)) + 1, 2):
		cc = 0
		while n % ps == 0:
			n = n // ps
			cc = 1
		lk += 1 if cc == 1 else 0
	if n != 1:
		lk += 1
	if lk == 1:
		return False
	return True

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def factorials(n, r):
	slr = n
	dpr = r
	qlr = 1
	qs = 1
	mod = 10 ** 9 + 7
	for ip in range(n - r + 1, n):
		qlr = qlr * ip % mod
	for ij in range(1, r):
		qs = qs * ij % mod
	ans = qlr * modInverse(qs) % mod
	return ans

def modInverse(b):
	qr = 10 ** 9 + 7
	return pow(b, qr - 2, qr)
from types import GeneratorType

def iterative(f, stack=[]):

	def wrapped_func(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		to = f(*args, **kwargs)
		while True:
			if type(to) is GeneratorType:
				stack.append(to)
				to = next(to)
				continue
			stack.pop()
			if not stack:
				break
			to = stack[-1].send(to)
		return to
	return wrapped_func

def power(arr):
	listrep = arr
	subsets = []
	for i in range(2 ** len(listrep)):
		subset = []
		for k in range(len(listrep)):
			if i & 1 << k:
				subset.append(listrep[k])
		subsets.append(subset)
	return subsets

def pda(n):
	list = []
	su = 0
	for i in range(1, int(sqrt(n) + 1)):
		if n % i == 0:
			if n // i == i:
				list.append(i)
				su += i
			else:
				list.append(n // i)
				list.append(i)
				su += i
				su += n // i
	return su

def dis(xa, ya, xb, yb):
	return sqrt((xa - xb) ** 2 + (ya - yb) ** 2)

def ii():
	return int(input())

def ilist():
	return [int(x) for x in input().strip().split()]

def islist():
	return list(map(str, input().split().rstrip()))

def inp():
	return input().strip()

def google(test):
	return 'Case #' + str(test) + ': '

def overlap(x1, y1, x2, y2):
	if x2 > y1:
		return y1 - x2
	if y1 > y2:
		return y2 - x2
	return y1 - x2

def dist(x1, y1, x2, y2):
	return sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 1
	prime[0] = False
	prime[1] = False
	ans = []
	for i in range(1, n + 1):
		if prime[i]:
			ans.append(i)
	return ans

def prod(arr):
	n = len(arr)
	k = 1
	for j in range(n):
		k *= arr[j]
	return k

def SumOfDigits(s):
	su = 0
	while s:
		su += s % 10
		s = s // 10
	return su
t = 1
for pl in range(t):
	n = ii()
	arr = ilist()
	sk = max(arr)
	g = arr[0]
	for i in range(1, n):
		g = gcd(arr[i], g)
	ma = sk // g - n
	if ma % 2 == 0:
		print('Bob')
	else:
		print('Alice')


def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)
a = int(input())
b = map(int, input().split())
c = m = 0
for x in b:
	c = gcd(c, x)
	if x > m:
		m = x
if m // c - a & 1:
	print('Alice')
else:
	print('Bob')


from math import *
n = int(input())
ls = [int(x) for x in input().split()]
g = 0
for i in ls:
	g = gcd(g, i)
x = max(ls) // g
if x - n & 1:
	print('Alice')
else:
	print('Bob')


from functools import reduce
from math import gcd
n = int(input())
(*a,) = map(int, input().split())
if max(a) // reduce(gcd, a) - n & 1:
	print('Alice')
else:
	print('Bob')


from sys import stdin
from math import *
g = lambda : stdin.readline().strip()
gl = lambda : g().split()
gil = lambda : [int(var) for var in gl()]
gfl = lambda : [float(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
mod = int(1000000000.0) + 7
inf = float('inf')
(n,) = gil()
a = gil()
g = 0
for v in a:
	g = gcd(g, v)
d = max(a) // g - n
print('Alice' if d & 1 else 'Bob')


def gcd(a, b):
	while b != 0:
		(a, b) = (b, a % b)
	return a
n = int(input())
ai = list(map(int, input().split()))
num = ai[0]
for i in range(1, n):
	num = gcd(num, ai[i])
ans = (max(ai) // num - n) % 2
print('Alice' * ans + 'Bob' * (1 - ans))


from math import *
n = int(input())
a = list(map(int, input().split()))
b = a[0]
for i in a:
	b = gcd(i, b)
print('Alice' if (max(*a) // b - n) % 2 == 1 else 'Bob')


import math
n = int(input())
listt = list(map(int, input().split()))
x = 0
for i in range(n):
	x = math.gcd(x, listt[i])
moves = max(listt) // x - n
if moves & 1 == 1:
	print('Alice')
else:
	print('Bob')


import collections, itertools, functools, math, fractions

def solve(a):
	g = functools.reduce(fractions.gcd, a)
	r = max(a) // g - len(a)
	return 1 - r % 2

def __starting_point():
	n = int(input())
	a = list(map(int, input().split()))
	print(['Alice', 'Bob'][solve(a)])
__starting_point()


def main():
	n = int(input())
	l = list(map(int, input().split()))
	a = l[-1]
	for b in l:
		while a:
			(a, b) = (b % a, a)
		a = b
	print(('Bob', 'Alice')[max(l) // a - n & 1])

def __starting_point():
	main()
__starting_point()


from math import gcd
from sys import stdin

def main():
	n = int(stdin.readline())
	ar = list(map(int, stdin.readline().split()))
	d = gcd(ar[0], ar[1])
	for i in range(2, n):
		d = gcd(ar[i], d)
	ans = []
	me = max(ar)
	ci = 1
	count = me // d
	size = count - n
	if size % 2 == 1:
		print('Alice')
	else:
		print('Bob')
main()


from math import gcd
n = int(input())
a = list(map(int, input().split()))
g = a[0]
max = a[0]
for i in a:
	if i > max:
		max = i
	g = gcd(g, i)
ans = max // g - n
if ans % 2 == 0:
	print('Bob')
else:
	print('Alice')


n = int(input())
l = list(map(int, input().split()))
g = l[0]
from math import gcd
for i in l:
	g = gcd(g, i)
moves = max(l) // g - n
if moves % 2 == 1:
	print('Alice')
else:
	print('Bob')


import sys
import math
MAXNUM = math.inf
MINNUM = -1 * math.inf
ASCIILOWER = 97
ASCIIUPPER = 65

def getInt():
	return int(sys.stdin.readline().rstrip())

def getInts():
	return map(int, sys.stdin.readline().rstrip().split(' '))

def getString():
	return sys.stdin.readline().rstrip()

def printOutput(ans):
	sys.stdout.write()
	pass

def solve(nums):
	c = math.gcd(nums[0], nums[1])
	for ele in nums:
		c = math.gcd(c, ele)
	total = max(nums) // c - len(nums)
	if total % 2 == 1:
		return 'Alice'
	return 'Bob'

def readinput():
	_ = getInt()
	nums = list(getInts())
	print(solve(nums))
readinput()


from fractions import gcd
n = int(input())
a = list(map(int, input().split()))
mel = max(a)
for i in range(1, len(a)):
	a[0] = gcd(a[0], a[i])
print(('Bob', 'Alice')[(mel // a[0] - n) % 2])


from math import gcd
n = int(input())
A = list(map(int, input().split()))
G = 0
for a in A:
	G = gcd(G, a)
t = max(A) // G - n
if t % 2 == 1:
	print('Alice')
else:
	print('Bob')


from math import gcd
from functools import reduce
(n, a) = (int(input()), list(map(int, input().split())))
g = reduce(lambda x, y: gcd(x, y), a, 0)
print('Alice' if (max(a) // g - n) % 2 == 1 else 'Bob')


n = int(input())
a = list(map(int, input().split()))
m = max(a)
d = m

def gcd(a, b):
	if a * b == 0:
		return a + b
	return gcd(b, a % b)
for i in range(n):
	for j in range(n):
		if i != j:
			d = gcd(d, abs(a[i] - a[j]))
if (m // d - n) % 2 == 0:
	print('Bob')
else:
	print('Alice')


import math

def answer(n, A):
	maxi = A[0]
	g = A[0]
	for i in range(1, n):
		g = math.gcd(g, A[i])
		maxi = max(maxi, A[i])
	x = maxi // g - n
	if x % 2 == 0:
		return 'Bob'
	else:
		return 'Alice'
n = int(input())
arr = list(map(int, input().split()))
print(answer(n, arr))


from sys import stdin
from math import gcd
from functools import reduce
input = stdin.readline
put = lambda : list(map(int, input().split()))
mod = int(1000000000.0 + 7)
(n,) = put()
l = put()
g = reduce(gcd, l)
m = max(l) // g
if (m - n) % 2 == 1:
	print('Alice')
else:
	print('Bob')


from fractions import gcd
n = int(input())
x = list(map(int, input().split(' ')))
gcdx = x[0]
for i in x:
	gcdx = gcd(gcdx, i)
nums = max(x) / gcdx
if (int(nums) - n) % 2 == 1:
	print('Alice')
else:
	print('Bob')


import fractions, functools
n = int(input())
a = list(map(int, input().split()))
gcd = functools.reduce(fractions.gcd, a)
moves = max(a) // gcd - n
print(['Bob', 'Alice'][moves % 2])


def main():
	n = int(input())
	a = list(map(int, input().split()))
	from fractions import gcd
	gmax = a[0]
	for i in range(1, n):
		gmax = gcd(gmax, a[i])
	for i in range(n):
		a[i] /= gmax
	c = max(a) - n
	if c % 2 == 0:
		print('Bob')
	else:
		print('Alice')
main()


from fractions import gcd
from functools import reduce
n = int(input())
a = [int(i) for i in input().split()]
k = reduce(gcd, a)
m = max(a) / k
if (m - n) % 2 == 0:
	print('Bob')
else:
	print('Alice')


from functools import reduce

def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a
n = int(input())
a = list(map(int, input().split()))
(m, g) = (max(a), reduce(gcd, a))
print('Alice' if m // g - n & 1 else 'Bob')


import math
n = int(input())
arr = list(map(int, input().split()))
gcd = 0
for num in arr:
	gcd = math.gcd(gcd, num)
moves = max(arr) / gcd - n
if moves % 2:
	print('Alice')
else:
	print('Bob')


import sys

def fastio():
	from io import StringIO
	from atexit import register
	global input
	sys.stdin = StringIO(sys.stdin.read())
	input = lambda : sys.stdin.readline().rstrip('\r\n')
	sys.stdout = StringIO()
	register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()

def debug(*var, sep=' ', end='\n'):
	print(*var, file=sys.stderr, end=end, sep=sep)
INF = 10 ** 20
MOD = 10 ** 9 + 7
I = lambda : list(map(int, input().split()))
from math import gcd
from math import ceil
from collections import defaultdict as dd, Counter
from bisect import bisect_left as bl, bisect_right as br
(n,) = I()
a = I()
g = 0
for i in a:
	g = gcd(g, i)
d = max(a) // g - len(set(a))
ans = 'Alice'
if d % 2 == 0:
	ans = 'Bob'
print(ans)


import bisect
from itertools import accumulate, count
import os
import sys
import math
from decimal import *
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

def input():
	return sys.stdin.readline().rstrip('\r\n')

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def SieveOfEratosthenes(n):
	prime = []
	primes = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if primes[p] == True:
			for i in range(p * p, n + 1, p):
				primes[i] = False
		p += 1
	for i in range(2, len(primes)):
		if primes[i] == True:
			prime.append(i)
	return prime

def primefactors(n):
	fac = []
	while n % 2 == 0:
		fac.append(2)
		n = n // 2
	for i in range(3, int(math.sqrt(n)) + 2):
		while n % i == 0:
			fac.append(i)
			n = n // i
	if n > 1:
		fac.append(n)
	return fac

def factors(n):
	fac = set()
	fac.add(1)
	fac.add(n)
	for i in range(2, int(math.sqrt(n)) + 1):
		if n % i == 0:
			fac.add(i)
			fac.add(n // i)
	return list(fac)

def NcR(n, r):
	p = 1
	k = 1
	if n - r < r:
		r = n - r
	if r != 0:
		while r:
			p *= n
			k *= r
			m = math.gcd(p, k)
			p //= m
			k //= m
			n -= 1
			r -= 1
	else:
		p = 1
	return p

def Log2(x):
	if x == 0:
		return False
	return math.log10(x) / math.log10(2)

def isPowerOfTwo(n):
	return math.ceil(Log2(n)) == math.floor(Log2(n))
for _ in range(1):
	n = int(input())
	a = list(map(int, input().split()))
	g = 0
	for i in range(0, len(a)):
		g = math.gcd(a[i], g)
	maxi = max(a) // g
	if (n - maxi) % 2 == 0:
		print('Bob')
	else:
		print('Alice')


from sys import stdin, setrecursionlimit
import math
from collections import defaultdict, deque
setrecursionlimit(15000)

def get_gcd(arr):
	g = arr[0]
	for i in range(1, len(arr)):
		g = math.gcd(g, arr[i])
	return g
n = int(stdin.readline().strip())
arr = list(map(int, stdin.readline().split()))
g = get_gcd(arr)
mx = max(arr)
if (mx // g - n) % 2:
	print('Alice')
else:
	print('Bob')


from sys import *
from math import *
from string import *
from operator import *
from functools import *
from fractions import *
from collections import *
setrecursionlimit(10 ** 7)
dX = [-1, 1, 0, 0, -1, 1, -1, 1]
dY = [0, 0, -1, 1, 1, -1, -1, 1]
RI = lambda : list(map(int, input().split()))
RS = lambda : input().rstrip().split()
n = RI()[0]
a = RI()
maxVal = max(a)
gcdVal = reduce(lambda x, y: gcd(x, y), a)
print(['Bob', 'Alice'][maxVal // gcdVal - n & 1])


from math import gcd
n = int(input())
ar = sorted(map(int, input().split()))
d = gcd(ar[0], ar[1])
for i in range(2, n):
	d = gcd(d, ar[i])
N = max(ar) // d - n
print('Alice' if N % 2 else 'Bob')


import os
import sys
from math import *
from collections import *
from fractions import *
from bisect import *
from heapq import *
from io import BytesIO, IOBase

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
ALPHA = 'abcdefghijklmnopqrstuvwxyz'
M = 1000000007
EPS = 1e-06

def value():
	return tuple(map(int, input().split()))

def array():
	return [int(i) for i in input().split()]

def Int():
	return int(input())

def Str():
	return input()

def arrayS():
	return [i for i in input().split()]
n = Int()
a = array()
gcds = a[0]
for i in a[1:]:
	gcds = gcd(gcds, i)
tot = max(a) // gcds
need = tot - len(a)
if need % 2 == 0:
	print('Bob')
else:
	print('Alice')


import os
import sys
from io import BytesIO, IOBase
from functools import reduce
from math import gcd

def main():
	n = int(input())
	a = list(map(int, input().split()))
	g = reduce(gcd, a)
	alpha = max(a) // g - n
	print('Alice' if alpha % 2 else 'Bob')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


from functools import reduce
div = 1000000007
s = input()
n = int(s)
s = input()
num = list([int(x) for x in s.split(' ')])

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)
g = reduce(gcd, num)
m = max(num)
now = m / g
remain = now - len(num)
if remain % 2 == 0:
	print('Bob')
else:
	print('Alice')


n = int(input())
a = list(map(int, input().split()))

def nod(a, b):
	while a * b:
		if a > b:
			(a, b) = (b, a % b)
		else:
			(a, b) = (b % a, a)
	return a + b
b = a[:]
ans = nod(b[0], b[1])
b = b[2:]
while b:
	ans = nod(ans, b[0])
	b = b[1:]
for i in range(n):
	a[i] = a[i] // ans
if (-n + max(a)) % 2 == 0:
	print('Bob')
else:
	print('Alice')


from fractions import gcd
n = int(input())
a = list(map(int, input().split()))
d = max(a)
c = 0
for i in range(len(a)):
	c = gcd(c, a[i])
result = d // c - n
if result % 2 == 0:
	print('Bob')
else:
	print('Alice')


from sys import stdin, stdout
from sys import maxsize
input = stdin.readline

def gcd1(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def gcd(*args):
	n = len(args)
	ans = args[0]
	for i in range(1, n):
		ans = gcd1(ans, args[i])
	return ans

def solve():
	pass
test = 1
for t in range(0, test):
	n = int(input().strip())
	a = [int(x) for x in input().strip().split()]
	ans = a[0]
	for el in a[1:]:
		ans = gcd1(ans, el)
	ans = max(a) // ans
	ans = n - ans
	if ans % 2 == 0:
		print('Bob')
	else:
		print('Alice')
	ans = solve()


from sys import stdin
from math import gcd
input = stdin.readline
n = int(input())
a = list(map(int, input().split()))
g = a[0]
for i in range(1, n):
	g = gcd(g, a[i])
r = max(max(a) // g - n, 0)
if r % 2 == 0:
	print('Bob')
else:
	print('Alice')


from fractions import gcd
from functools import reduce
n = int(input())
seq = list(map(int, input().split()))
gcd_gcd = reduce(gcd, seq)
moves = max(seq) // gcd_gcd - n
if moves % 2 != 0:
	print('Alice')
else:
	print('Bob')


import math
n = int(input())
a = list(map(int, input().split()))
temp = min(a)
for i in a:
	temp = math.gcd(temp, i)
max1 = max(a)
n1 = max1 // temp - len(a)
if n1 % 2 == 0:
	print('Bob')
else:
	print('Alice')


def minyin(x, y):
	a = min(x, y)
	b = max(x, y)
	while b > a and b % a != 0:
		c = b % a
		b = a
		a = c
	return a
n = int(input())
l = list(map(int, input().split()))
l.sort()
li = []
for i in range(n - 1):
	for j in range(i + 1, n):
		s = minyin(l[i], l[j])
		li.append(s)
li = list(set(li))
li.sort()
s = li[0]
maxl = max(l)
num1 = maxl / s
num2 = num1 - n
if num2 % 2 == 1:
	print('Alice')
else:
	print('Bob')


import math
import sys
from functools import reduce
input = sys.stdin.readline

def read_int():
	return int(input().strip())

def read_ints():
	return list(map(int, input().strip().split(' ')))

def solve():
	n = read_int()
	a = read_ints()
	gcd = reduce(math.gcd, a, a[0])
	moves = max(a) / gcd - n
	if moves % 2 == 0:
		return 'Bob'
	return 'Alice'
print(solve())


from sys import stdin
from functools import reduce
from math import gcd
(n, a) = (int(stdin.readline()), sorted(map(int, stdin.readline().split())))
g = reduce(gcd, a)
print('Alice' if (a[-1] - g * n) // g % 2 else 'Bob')


def NOD(a, b):
	if b > a:
		c = b
		b = a
		a = c
	while a > 0:
		c = b % a
		b = a
		a = c
	return b
n = int(input())
x = list(map(int, input().split()))
d = x[0]
for i in range(1, n):
	d = NOD(d, x[i])
m = max(x)
k = m // d - n
if k % 2 == 0:
	print('Bob')
else:
	print('Alice')


def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)
n = int(input())
A = list(map(int, input().split()))
res = A[0]
for c in A[1:]:
	res = gcd(res, c)
e = max(A) // res - len(A)
if e % 2 != 0:
	print('Alice')
else:
	print('Bob')


import fractions
n = int(input())
a = list(map(int, input().split()))
m = max(a)
g = 0
for i in a:
	g = fractions.gcd(g, i)
if (m // g - n) % 2 == 0:
	print('Bob')
else:
	print('Alice')


import functools
import math
n = int(input())
tab = list(map(int, input().split()))
pgcd = functools.reduce(lambda x, y: math.gcd(x, y), tab)
nbturns = max(tab) / pgcd - n
print('Alice' if nbturns % 2 == 1 else 'Bob')


from fractions import gcd
n = int(input())
a = list(map(int, input().split()))
ans = a[0]
for i in a:
	ans = gcd(ans, i)
cnt = max(a) // ans
left = cnt - n
if left % 2 == 1:
	print('Alice')
else:
	print('Bob')


def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)
n = int(input())
A = [int(i) for i in input().split()]
gx = A[0]
for i in A:
	gx = gcd(gx, i)
for i in range(n):
	A[i] = A[i] // gx
start = 1
val = 0
A.sort()
for i in range(n):
	if start <= A[i]:
		val += A[i] - start
		start = A[i] + 1
if val & 1:
	print('Alice')
else:
	print('Bob')


n = int(input())
A = list(map(int, input().split()))

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
g = 0
for a in A:
	g = gcd(g, a)
u = max(A) // g - n
if u % 2 == 0:
	print('Bob')
else:
	print('Alice')


def gcd(a, b):
	(a, b) = (max(a, b), min(a, b))
	while a % b != 0:
		a %= b
		(a, b) = (b, a)
	return b
n = int(input())
sp = list(map(int, input().split()))
g = sp[0]
mx = 0
for i in sp:
	mx = max(mx, i)
	g = gcd(g, i)
cnt = mx / g - n
if cnt % 2 == 1:
	print('Alice')
else:
	print('Bob')


from math import gcd
n = int(input())
arr = list(map(int, input().split()))
x = 0
for i in arr:
	x = gcd(i, x)
moves = max(arr) // x - n
if moves & 1:
	print('Alice')
else:
	print('Bob')


from sys import stdin, stdout
from math import gcd
nmbr = lambda : int(stdin.readline())
lst = lambda : list(map(int, stdin.readline().split()))
for _ in range(1):
	n = nmbr()
	a = lst()
	g = a[0]
	for v in a[1:]:
		g = gcd(g, v)
	mx = max(a)
	terms = abs(n - mx // g)
	print('Alice' if terms & 1 else 'Bob')


def gcd(a, b):
	return a if b == 0 else gcd(b, a % b)
n = int(input())
a = list(map(int, input().split()))
com = a[0]
for x in a:
	com = gcd(com, x)
cnt = max(a) // com
print((cnt - n) % 2 == 1 and 'Alice' or 'Bob')


from math import gcd
n = int(input())
l = list(map(int, input().split()))
cnt = 0
g = 0
for i in range(n):
	g = gcd(g, l[i])
z = max(l) // g - n
if z % 2 != 0:
	print('Alice')
else:
	print('Bob')


import math
n = int(input())
a = sorted([int(_) for _ in input().split()])
b = 0
for i in a:
	b = math.gcd(b, i)
c = (a[0] - 1) // b
for i in range(n - 1):
	c += (a[i + 1] - a[i] - 1) // b
if c % 2 == 0:
	print('Bob')
else:
	print('Alice')


def gcd(a, b):
	while b > 0:
		(a, b) = (b, a % b)
	return a
n = int(input())
A = list(map(int, input().split()))
GCD = A[0]
for x in A[1:]:
	GCD = gcd(GCD, x)
num = max(A) // GCD - n
if num % 2 == 0:
	print('Bob')
else:
	print('Alice')


n = int(input())
S = [int(x) for x in input().split(' ')]

def gcd(lst):
	res = lst[0]
	for x in lst[1:]:
		while x != 0:
			(res, x) = (x, res % x)
	return res
size_end = max(S) // gcd(S)
if (size_end - len(S)) % 2 == 0:
	print('Bob')
else:
	print('Alice')


def gcd(a, b):
	(a, b) = (min(a, b), max(a, b))
	while a > 0:
		(a, b) = (b % a, a)
	return b
n = int(input())
p = [int(x) for x in input().split()]
c = gcd(p[0], p[1])
if n >= 3:
	for i in range(1, n - 1):
		c = gcd(p[i + 1], c)
m = max(p) / c
t = m - n
if t % 2 == 0:
	print('Bob')
else:
	print('Alice')


n = int(input())
a = sorted(map(int, input().split()))

def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a

def gcd2(lst):
	if len(lst) == 1:
		return lst[0]
	lst.append(gcd(lst.pop(), lst.pop()))
	return gcd2(lst)
m = a[-1]
print('Alice' if (m // gcd2(a) - n) % 2 == 1 else 'Bob')


import sys
lines = sys.stdin.readlines()
n = int(lines[0].strip())
nums = list(map(int, lines[1].strip().split(' ')))

def gcd(a, b):
	if a == 0:
		return b
	if a > b:
		return gcd(b, a)
	return gcd(b % a, a)
G = nums[0]
for i in range(1, n):
	G = gcd(G, nums[i])
turns = max(nums) // G - n
if turns % 2 == 0:
	print('Bob')
else:
	print('Alice')


import math
n = int(input())
arr = sorted(list(map(int, input().split())))
b = 0
for i in arr:
	b = math.gcd(b, i)
c = (arr[0] - 1) // b
c += sum([(arr[i + 1] - arr[i] - 1) // b for i in range(n - 1)])
print('Bob' if c % 2 == 0 else 'Alice')