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.

Difficulty: MEDIUM_HARD

Solutions:
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')


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 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')


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')


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 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 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 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 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')


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())


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')


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 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):
	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')