CodeEff/ECCO huggingface dataset:
# Original solution
n = int(input())
h = [int(i) for i in input().split()]
num = []
for i in range(len(h)):
  num += [h.index(i+1)+1]
print(*num, sep=" ")


# Optimized solution
n = int(eval(input()))
h = [int(i) for i in input().split()]
num = [0 for i in range(n)]
for i in range(len(h)):
  num[h[i]-1] = i+1
print((' '.join(map(str, num))))
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))
ans = []
for i in range(1, n+1):
    for j in range(0, n):
        if a[j] == i:
            ans.append(j+1)
print((' '.join(map(str, ans))))

# Optimized solution
n = int(eval(input()))
a = list(map(int, input().split()))
b = []
for i in range(n):
    b.append([i, a[i]])
b = sorted(b, key=lambda x: x[1])
c = []
for k, v in b:
    c.append(k+1)
print((' '.join(map(str, c))))
# Original solution
n = int(eval(input()))
a = list(map(int,input().split()))
b = []

for i in range(1, n+1):
    num = a.index(i)
    b.append(num+1)

print((' '.join(map(str, b))))

# Optimized solution
n = int(eval(input()))
a = list(map(int, input().split()))
b = [0]*n

for i in range(0, n):
    b[a[i]-1] = i + 1


print((' '.join(map(str, b))))
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))
indices = [i + 1 for i in range(n)]
result = sorted(zip(a, indices))
ans = "{}".format(result[0][1])
for i in range(n)[1::]:
    ans += " {}".format(result[i][1])
print(ans)


# Optimized solution
n = int(eval(input()))
a = list(map(int, input().split()))
indices = [i + 1 for i in range(n)]
ans = list([str(x[1]) for x in sorted(zip(a, indices))])
print((" ".join(ans)))
# Original solution
n = int(eval(input()))
a = [int(x) for x in input().split()]

ans = []
for i in range(1, n+1):
    ans.append(str(a.index(i)+1))

print((' '.join(ans)))

# Optimized solution
n = int(eval(input()))
a = [int(x) for x in input().split()]

ans = [0]*n

for i in range(n):
    ans[a[i]-1] = str(i+1)

print((' '.join(ans)))
# Original solution
N = int(eval(input()))
A = [int(i) for i in input().split()]
t = []
for i in range(N):
    t.append(str(A.index(i + 1) + 1))
print((' '.join(t)))

# Optimized solution
N = int(eval(input()))
A = [int(i) for i in input().split()]
d = {v: str(k + 1) for k, v in enumerate(A)}
print((' '.join([v for _, v in sorted(d.items())])))
# Original solution
n=int(eval(input()))
a=[int(_) for _ in input().split()]
ans=[]
for i in range(n):
	m=min(a)
	ans.append(str(a.index(m)+1))
	a[a.index(m)]=10**6
print((' '.join(ans)))

# Optimized solution
n=int(eval(input()))
a=[int(_) for _ in input().split()]
ans=[0]*n
for i in range(n):
	ans[a[i]-1]=i+1
print((' '.join(map(str,ans))))
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))
ans = []
for i in range(1, n+1):
    for j in range(n):
        if a[j] == i:
            ans.append(str(j+1))
print((" ".join(ans)))

# Optimized solution
n = int(eval(input()))
a = list(map(int, input().split()))
l = []
for i in range(n):
    l.append([a[i], i+1])
l = sorted(l)
ans = []
for j in range(n):
    ans.append(str(l[j][1]))
print((" ".join(ans)))
# Original solution
N = int(input())
A = list(map(int, input().split()))

dic = {i:0 for i in range(1, N + 1)}


for i in range(N):
    a = A[i]
    dic[a] = i + 1

for i in range(1, N + 1):
    print(dic[i], end="")
    if i != N:
        print(" ", end="")

print()


# Optimized solution
N = int(eval(input()))
A = list(map(int, input().split()))

a = [0] * N

for i in range(N):
    a[A[i] - 1] = str(i + 1)

res = " ".join(a)

print(res)
# Original solution
N = int(eval(input()))
A = [int(a) for a in input().split()]
print((" ".join([str(A.index(i)+1) for i in range(1,N+1)])))

# Optimized solution
N = int(eval(input()))
A = ["0"]*N
for a,i in zip(input().split(), list(range(1,N+1))):
    A[(int(a)-1)] = str(i)
print((" ".join(A)))
# Original solution
n = int(eval(input()))
an = [int(num) for num in input().split()]

answer = []
for index in range(1,len(an)+1):
  answer.append(str(an.index(index)+1))

print((" ".join(answer)))

# Optimized solution
n = int(eval(input()))
an = [int(num) for num in input().split()]

answer = [0 for _ in range(n)]
for index in range(n):
  answer[an[index] - 1] = str(index + 1)

print((" ".join(answer)))
# Original solution
a=int(eval(input()))
b=list(map(int,input().split()))
c=[]
for i in range(a):
    c.append(b.index(i+1)+1)
result = ' '.join(map(str,c))
print(result)

# Optimized solution
a=int(eval(input()))
b=list(map(int,input().split()))
c=[0]*a
"""
for i in range(a):
    c.append(b.index(i+1)+1) #おそらく計算量O(N^2)
"""
for i in range(a):
    c[b[i]-1]=i+1
result = ' '.join(map(str,c))
print(result)
# Original solution
from operator import itemgetter


def main():
    A = {k + 1: v for k, v in enumerate(map(int, open(0).read().split()[1:]))}
    # value `昇順
    print((" ".join([str(i[0]) for i in sorted(list(A.items()), key=itemgetter(1))])))
    return


main()


# Optimized solution
def main():
    N, *A = list(map(int, open(0).read().split()))
    ans = [0] * N
    for k, v in enumerate(A, 1):
        ans[v - 1] = k
    print((" ".join([str(a) for a in ans])))
    return


main()
# Original solution
def main():
    N, *A = list(map(int, open(0).read().split()))
    ans = [0] * N
    for k, v in enumerate(A, 1):
        ans[v - 1] = k
    print((" ".join([str(a) for a in ans])))
    return


main()


# Optimized solution
def main():
    N, *A = list(map(int, open(0).read().split()))
    ans = [0] * N
    for k, v in enumerate(A, 1):
        ans[v - 1] = k
    print((" ".join(map(str, ans))))
    return


main()
# Original solution
N=int(eval(input()))
A=list(input().split())

shusseki_jun=[' ' for _ in range(N)]
for i in range(N):
    shusseki_jun[i] = str(A.index(str(i+1))+1)

print((' '.join(shusseki_jun)))


# Optimized solution
N=int(eval(input()))
A=list(input().split())

shusseki_jun=[' ' for _ in range(N)]
for i in range(N):
    ind = A[i]
    shusseki_jun[int(ind)-1] = str(i+1)

print((' '.join(shusseki_jun)))
# Original solution
n=int(eval(input()))
a=list(map(int,input().split()))

num=[i for i in range(1,n+1)]

order=dict(list(zip(num,a)))

order2=sorted(list(order.items()),key=lambda x:x[1])

ans=[]

for i in range(n):
  ans.append(order2[i][0])

print((' '.join([str(n) for n in ans])))

# Optimized solution
n=int(eval(input()))
a=list(map(int,input().split()))

ans=['-']*n
for i in range(n):
    ans[a[i]-1]=str(i+1)

print((' '.join(ans)))
# Original solution
N = int(eval(input()))
a = list(map(int, input().split()))
ans = list()
for i in range(1, N + 1):
    ans.append(str(a.index(i) + 1))
print((' '.join(ans)))

# Optimized solution
N = int(eval(input()))
a = list(map(int, input().split()))
ans = [-1] * N
for i in range(N):
    ai = a[i]
    ans[ai - 1] = str(i + 1)
print((' '.join(ans)))
# Original solution
N=int(eval(input()))
A=list(map(int,input().split()))
l=len(A)
x=[]
for i in range(l):
    m=A.index(min(A))
    x.append(m+1)
    A[m]=10**5+1
x=[str(a) for a in x]
L=' '.join(x)
print(L)

# Optimized solution
N=int(eval(input()))
A=list(map(int,input().split()))
L=[0]*N
for i in range(N):
    L[A[i]-1]=i+1
L=[str(a) for a in L]
print((' '.join(L)))
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))
b = []
for i in range(1,n+1):
    b.append(a.index(i)+1)
b =list(map(str,b))
print((" ".join(b)))

# Optimized solution
n = int(eval(input()))
a = list(map(int, input().split()))
b = [0]*n
for i in range(n):
    b[a[i]-1] = i+1
print((" ".join(map(str,b))))
# Original solution
n = int(eval(input()))
A = list(map(int,input().split()))
ans = [0]*n

for i in range(n):
    tmp = A.index(i+1)
    ans[i] = tmp+1
    
print((' '.join([str(n) for n in ans])))

# Optimized solution
n = int(eval(input()))
A = list(map(int,input().split()))
ans = [0]*n

for i,j in enumerate(A):
    ans[j-1] = i+1    
print((' '.join([str(n) for n in ans])))
# Original solution
n = int(eval(input()))
a = [ int(i) for i in input().split()]
b = []

for i in range(1,n+1):
    j = a.index(i)
    b.append(str(j+1))

print((" ".join(b)))

# Optimized solution
n = int(eval(input()))
a = [ int(i) for i in input().split()]
b = [""] * n

for i, ai in enumerate(a):
    b[ai-1] = str(i+1)

print((" ".join(b)))
# Original solution
N = int(eval(input()))
A = list(map(int,input().split()))

ans = [A.index(i)+1 for i in range(1,N+1)]


print((' '.join(map(str, ans))))


# Optimized solution
N = int(eval(input()))
A = list(map(int,input().split()))

ans = [0]*N
# ans = [A.index(i)+1 for i in range(1,N+1)]
for i in range(N):
    ans[A[i]-1] = i+1

print((' '.join(map(str, ans))))
# Original solution
n = int(eval(input()))
a = list(map(int,input().split()))
ans=[str(a.index(i)+1) for i in range(1,n+1)]
print((" ".join(ans)))

# Optimized solution
n = int(eval(input()))
a = list(map(int,input().split()))
ans=[0]*n
for k,i in enumerate(a):
    ans[i-1]=str(k+1)
print((" ".join(ans)))
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))
result = []
for i in range(1, N+1):
    result.append(A.index(i) + 1)

print((' '.join(map(str, result))))


# Optimized solution
N = int(eval(input()))
A = list(map(int, input().split()))
result = [0] * (N + 1)
for i in range(1, N+1):
    result[A[i - 1]] = i

print((' '.join(map(str, result[1::]))))
# Original solution
N = int(eval(input()))
A = list(map(int,input().split()))

print_str = ''

for i in range(N):
    if i != N-1:
        print_str += str(A.index(i+1)+1) + ' '
    else:
        print_str += str(A.index(i+1)+1)
    
print(print_str)




# Optimized solution
N = int(eval(input()))
A = list(map(int,input().split()))

student = [0] * N
for i in range(N):
  student[A[i]-1] = i + 1
  
print((' '.join(map(str, student))))
# Original solution
N = int(eval(input()))
A = list(map(int,input().split()))
ans =[]
for i in range(1,N+1):
    AN = A.index(i)
    ans.append(AN+1)
ans2 = [str(ans[i]) for i in range(len(ans))]
print((" ".join(ans2)))

# Optimized solution
N = int(eval(input()))
A = list(map(int,input().split()))
AN = list(enumerate(A))
sAN = sorted(AN, key=lambda x: x[1])
ans = []
for i in range(N):
    ans.append(sAN[i][0]+1)
ans2 = [str(ans[i]) for i in range(len(ans))]
print((" ".join(ans2)))
# Original solution
def main():
  n=int(eval(input()))
  l=list(map(int,input().split()))
  k=[0]*n
  for i in range(1,n+1):
    k[i-1]=str(l.index(i)+1)
  print((" ".join(k)))


if __name__ == '__main__':
    main()

# Optimized solution
def main():
  n=int(eval(input()))
  l=list(map(int,input().split()))
  k=[0]*n
  for i in range(1,n+1):
    k[l[i-1]-1]=str(i)
  print((" ".join(k)))


if __name__ == '__main__':
    main()
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))
b = []

for i in range(1, n+1):
  b.append(a.index(i)+1)

print((' '.join(map(str, b))))

# Optimized solution
n = int(eval(input()))
a = list(map(int, input().split()))
b = [0]*n

for i in range(n):
  b[a[i]-1] = i+1

print((' '.join(map(str, b))))
# Original solution
stdin = open(0).read().rstrip().split('\n')
N = int(stdin[0])
A = list(map(int,stdin[1].split()))
ans =[0]*N
for i in range(N):
    ans[i] = A.index(i+1)+1
print((' '.join(map(str,ans))))

# Optimized solution
stdin = open(0).read().rstrip().split('\n')
N = int(stdin[0])
A = list(map(int,stdin[1].split()))
ans =[0]*N
for i in range(N):
     ans[A[i]-1] = i+1
print((' '.join(map(str,ans))))
# Original solution
n = int(input())
al = list(map(int, input().split()))
l = []
for i in range(n):
    l.append(al.index(i + 1) + 1)
print(*l, sep = ' ')


# Optimized solution
n = int(input())
al = list(map(int, input().split()))
cl = []
for j in range(n):
    cl.append([al[j], j + 1])
cl.sort()
bl = []
for i in range (n):
    bl.append(cl[i][1])
print(*bl, sep=' ')
# Original solution
n = int(eval(input()))
a = list(map(int,input().split()))

ans = ""
for i in range(1, n+1):
	ans = ans + str(a.index(i)+1) + " "

print((ans.rstrip()))


# Optimized solution
n = int(eval(input()))
a = list(map(int,input().split()))

ans = []
for i in range(1, n+1):
	ans.append("")

for i in range(n):
	tmp = i + 1
	ans[a[i]-1] = str(tmp)
	
print((' '.join(ans)))
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))
ans = []

for i in range(1, N+1):
    ans.append(A.index(i)+1)
print((' '.join(map(str, ans))))

# Optimized solution
N = int(eval(input()))
A = list(map(int, input().split()))
ans = [0]*N

for i, a in enumerate(A):
    ans[int(a-1)] = str(i+1)
print((' '.join(map(str, ans))))
# Original solution
n = int(eval(input()))

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

ans = []

for i in range(1, n+1):
    ans.append(a.index(i) + 1)

print((' '.join(map(str,ans))))

# Optimized solution
n = int(eval(input()))

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

ans = [0] * n

for i in range(n):
    ans[a[i] - 1] = i + 1 

print((' '.join(map(str,ans))))
# Original solution
n=int(eval(input()))
b=[]
a=list(map(int,input().split()))
for i in range(n):
    b.append(str(a.index(i+1)+1))
print((' '.join(b)))

# Optimized solution
n=int(eval(input()))
b=['']*n
a=list(map(int,input().split()))
for i in range(n):
    b[a[i]-1]=str(i+1)
print((' '.join(b)))
# Original solution
n = int(eval(input()))
h =list(map(int, input().split()))
a = []

for i in range(n):
    a.append(i)
    a[i] = i+1

for i in range (n-1):
    for j in range(n-1, i ,-1):
        if h[j] < h[j-1]:
            tmp = h[j]
            h[j] = h[j-1]
            h[j-1] = tmp
            tmp = a[j]
            a[j] = a[j-1]
            a[j-1] = tmp
# print(h)
print((' '.join(map(str, a))))

# Optimized solution
n = int(eval(input()))
h_kari =list(map(int, input().split()))
h = []

for i in range(n):
    h.append([h_kari[i],i+1])
    
h.sort()    
    
ans = [h[i][1] for i in range(n)]    

print((' '.join(map(str, ans))))
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))
out = [""] * n
count = 0
out_str = ""
for i in range(n):
    out_str += str(a.index(i + 1) + 1) + " "

print((out_str[:-1]))


# Optimized solution
n = int(eval(input()))
a = list(map(int, input().split()))
out = [""] * n
out_str = ""
for i in range(n):
    out[a[i] - 1] = str(i + 1)
        
out_str = " ".join(out)
 
print(out_str)
# Original solution
N = int(eval(input()))
As = list(map(int, input().split()))
ordList = []
for i in range(1,N+1):
    ordList.append(str(As.index(i)+1))
print((' '.join(ordList)))

# Optimized solution
N = int(eval(input()))
As = list(map(int, input().split()))
ordList = [None] * N
noCount = 1
for i in As:
    ordList[i-1] = str(noCount)
    noCount += 1
print((' '.join(ordList)))
# Original solution
N=int(eval(input()))
L=list(map(int,input().split()))
R=list()
for i in range(1,N+1):
  R.append(L.index(i)+1)
print((" ".join(list(map(str,R)))))

# Optimized solution
N=int(eval(input()))
L=list(map(int,input().split()))
R=[0]*N
for i in range(0,N):
  R[L[i]-1]=i+1
print((" ".join(list(map(str,R)))))
# Original solution
# 2020/04/22
# AtCoder Beginner Contest 142 - C

# Input
n = int(eval(input()))
a = list(map(int,input().split()))
tbl = [-1] * (n+1)

# Calc
for i in range(n):
    tbl[a[i]] = i+1

# Output
ans = str(tbl[1])
for i in range(2, n+1):
    ans = ans + " " + str(tbl[i])

print(ans)

# Optimized solution
# 2020/04/22
# AtCoder Beginner Contest 142 - C

# Input
n = int(eval(input()))
a = list(map(int,input().split()))
tbl = [-1] * (n+1)

# Calc
for i in range(n):
    tbl[a[i]] = i+1

tbl.pop(0)

# Output
print((' '.join(map(str, tbl))))
# Original solution
N = int(input())
A = tuple(map(int, input().split()))

l = len(A)

for i in range(l):
    print(A.index(i+1)+1, end='')
    if i == l - 1:
        print()
    else:
        print(' ', end='')


# Optimized solution
N = int(input())
A = tuple(map(int, input().split()))

ans = []

for i, j in enumerate(A):
    ans.append((j, i+1))

ans.sort()

for i, j in ans:
    print(j, end='')
    if i == len(ans):
        print()
    else:
        print(' ', end='')
# Original solution
A, B = list(map(int, input().split()))
if A == 1 and B == 13:
    winner = "Alice"
elif A == 13 and B == 1:
    winner = "Bob"
elif A > B:
    winner = "Alice"
elif A < B:
    winner = "Bob"
else:
    winner = "Draw"
print(winner)

# Optimized solution
A, B = [int(x) if int(x)> 1 else 14 for x in input().split()]
if A > B:
    print('Alice')
if A == B:
    print('Draw')
if A < B:
    print('Bob')
# Original solution
# AliceとBobは、2人で1枚ポーカーを行います。
# 1枚ポーカーは、トランプを用いて行う2人ゲームです。
#
# 今回使用するトランプでは、各カードに 1 から 13 までの数が書かれています。
# カードの強さは、カードに書かれている数で決まり，強さの基準は以下の通りです。
# 弱 2 < 3 < 4 < 5 < 6 < 7 < 8 < 9 < 10 < 11 < 12 < 13 < 1 強
#
# 1枚ポーカーは以下の手順で行います。
#
# 各プレイヤーは、トランプからカードを1枚選んで、自分の手札とします。
# 両プレイヤーは、手札を見せ合います。強いカードを持っているプレイヤーが勝ちです。
# なお、両プレイヤーの持っているカードの強さが同じ場合は引き分けです。
# 2人の対戦を眺めていたあなたは、AliceとBobの手札を知ることができます。
# Aliceが持っているカードに書かれている数は A、Bobが持っているカードカードに書かれている数は Bです。
# 2人の代わりに、勝敗を判定するプログラムを作ってください。

input_alice, input_bob = list(map(int,input().split()))

result = 'ret'

if input_alice > input_bob:
    if input_bob == 1:      # Bobがエースなので勝ち～
        result = 'Bob'
    else:
        result = 'Alice'
elif input_alice < input_bob:
    if input_alice == 1:     # Aliceがエースなので勝ち～
        result = 'Alice'
    else:
        result = 'Bob'
else:
    result = 'Draw'         # どっちも同じ手札なので引き分け～

print(result)


# Optimized solution
# AliceとBobは、2人で1枚ポーカーを行います。
# 1枚ポーカーは、トランプを用いて行う2人ゲームです。
#
# 今回使用するトランプでは、各カードに 1 から 13 までの数が書かれています。
# カードの強さは、カードに書かれている数で決まり，強さの基準は以下の通りです。
# 弱 2 < 3 < 4 < 5 < 6 < 7 < 8 < 9 < 10 < 11 < 12 < 13 < 1 強
#
# 1枚ポーカーは以下の手順で行います。
#
# 各プレイヤーは、トランプからカードを1枚選んで、自分の手札とします。
# 両プレイヤーは、手札を見せ合います。強いカードを持っているプレイヤーが勝ちです。
# なお、両プレイヤーの持っているカードの強さが同じ場合は引き分けです。
# 2人の対戦を眺めていたあなたは、AliceとBobの手札を知ることができます。
# Aliceが持っているカードに書かれている数は A、Bobが持っているカードカードに書かれている数は Bです。
# 2人の代わりに、勝敗を判定するプログラムを作ってください。

input_alice, input_bob = list(map(int,input().split()))

result = 'ret'  # 結果格納用

if input_alice > input_bob: # Aの方がBより大きい
    if input_bob == 1:
        result = 'Bob'  # Bobがエースなので勝ち～
    else:
        result = 'Alice'
elif input_alice < input_bob:   # Bの方がAより大きい
    if input_alice == 1:
        result = 'Alice'    # Aliceがエースなので勝ち～
    else:
        result = 'Bob'
else:
    result = 'Draw'         # どっちも同じ手札なので引き分け～

print(result)   # 結果出力～
# Original solution
a,b=list(map(int,input().split()))
if( a == 1):
    a = 14

if(b == 1):
    b = 14

if( a < b):
    print('Bob')

elif(b < a):
    print('Alice')

else:
    print('Draw')

# Optimized solution
a,b=list(map(int,input().split()))
a=(a+12)%14
b=(b+12)%14
print((['Draw','Bob','Alice'][(a<b)-(a>b)]))
# Original solution
lst = list(map(int,input().split()))

if lst[1] != 1 and lst[0] > lst[1] :
    print('Alice')
elif lst[0] != 1 and lst[0] < lst[1]:
    print('Bob')
elif lst[1] == 1 and lst[0] != 1:
    print('Bob')
elif lst[0] == 1 and lst[1] != 1:
    print('Alice')
else:
  print('Draw')

# Optimized solution
lst = [14 if x == 1 else x for x in map(int,input().split())]
if lst[1] != 1 and lst[0] > lst[1] :
    print('Alice')
elif lst[0] != 1 and lst[0] < lst[1]:
    print('Bob')
else:
  print('Draw')
# Original solution
A, B = list(map(int, input().split()))
if A == B:
    print("Draw")
elif A != 1 and B != 1:
    if A < B:
        print("Bob")
    else:
        print("Alice")
elif A == 1:
    print("Alice")
elif B == 1:
    print("Bob")


# Optimized solution
A, B = list(map(int, input().split()))

if A == B:
    print('Draw')
elif A == 1 or B < A and B != 1:
    print('Alice')
else:
    print('Bob')
# Original solution
# AliceのスコアAとBobのスコアBを整数で入力
A,B = list(map(int,input().split()))
# AとBが同じならDrawを出力
if A == B:
    print("Draw")
# Aが1がBより大きいならAliceを出力
elif A == 1 or A > B and B!= 1 :
    print("Alice")
# Bの方が強ければBobを出力
else:
    print("Bob")

# Optimized solution
# AliceのスコアAとBobのスコアBを整数で入力
A,B = list(map(int,input().split()))
# AとBが同じならDrawを出力
if A == B:
    print("Draw")
# Aが1か、Bが1でなく且つAがBより大きいならAliceを出力
elif  A == 1 or B!= 1 and A > B:
    print("Alice")
# Bの方が強ければBobを出力
else:
    print("Bob")
# Original solution
a,b=list(map(int, input().split()))

if a==1:
  k=14
else:
  k=a
if b==1:
  m=14
else:
  m=b
  
if k>m:
  print("Alice")
elif k==m:
  print("Draw")
else:
  print("Bob")

# Optimized solution
a , b =(list(map(int , input().split())))

if a==1:
  a=a+13

if b==1:
  b=b+13
  
if a>b :
  print("Alice")

elif a<b:
  print("Bob")

else:
  print("Draw")
# Original solution
a,b = list(map(int,input().split()))
if a == 1 and a != b :
    print("Alice")
elif b == 1 and b != a:
    print("Bob")
elif (a != 1 and b != 1) and a > b:
    print("Alice")
elif (a != 1 and b != 1) and a < b:
    print("Bob")
elif a == b:
    print("Draw")

# Optimized solution
a,b = list(map(int,input().split()))
if a == b == 1:
    print("Draw")
elif a == 1:
    print("Alice")
elif b == 1:
    print("Bob")
else:
    if a > b:
        print("Alice")
    elif a < b:
        print("Bob")
    elif a == b:
        print("Draw")
# Original solution
from collections import defaultdict


def main():
    A, B = list(map(int, input().split()))

    if A == 1:
        A += 100
    if B == 1:
        B += 100

    if A == B:
        print("Draw")
    elif A > B:
        print("Alice")
    else:
        print("Bob")


if __name__ == '__main__':
    main()


# Optimized solution
from collections import defaultdict


def main():
    A, B = list(map(int, input().split()))
    d = {1: 14}

    if d.get(A, A) == d.get(B, B):
        print("Draw")
    elif d.get(A, A) > d.get(B, B):
        print("Alice")
    else:
        print("Bob")


if __name__ == '__main__':
    main()
# Original solution
from collections import defaultdict


def main():
    A, B = list(map(int, input().split()))
    d = {1: 14}

    if d.get(A, A) == d.get(B, B):
        print("Draw")
    elif d.get(A, A) > d.get(B, B):
        print("Alice")
    else:
        print("Bob")


if __name__ == '__main__':
    main()


# Optimized solution
from collections import defaultdict


def main():
    A, B = list(map(int, input().split()))
    if A == 1:
        A = 14
    if B == 1:
        B = 14
    if A == B:
        print("Draw")
    elif A > B:
        print("Alice")
    else:
        print("Bob")


if __name__ == '__main__':
    main()
# Original solution
a,b=list(map(int,input().split()))
a,b=(a+13)%15,(b+13)%15
print(("Alice" if a>b else "Bob" if a<b else "Draw"))

# Optimized solution
a,b=list(map(int,input().split()))
print(("Draw" if a==b else ("Bob" if (a+13)%15<(b+13)%15 else "Alice")))
# Original solution
a, b = list(map(int, input().split()))

if a != 1 and b != 1:
    if a > b:
        print('Alice')
    elif a < b:
        print('Bob')
    else:
        print('Draw')
elif a == 1 and b != 1:
    print('Alice')
elif a != 1 and b == 1:
    print('Bob')
else:
    print('Draw')

# Optimized solution
a, b = list(map(int, input().split()))

if a == b:
    print('Draw')
elif a ==1:
    print('Alice')
elif b == 1:
    print('Bob')
elif a > b:
    print('Alice')
elif a < b:
    print('Bob')
# Original solution
a,b=[(int(x)+13)%15 for x in input().split()];print((['Draw',['Bob','Alice'][a>b]][a!=b]))

# Optimized solution
a,b=list(map(int,input().split()));print((['Draw',['Bob','Alice'][(a+13)%15>(b+13)%15]][a!=b]))
# Original solution
# aアリス　　　ｂボブ
a, b = list(map(int, input().split()))
if a == b:
    print("Draw")
elif a == 1:
    print("Alice")
elif b == 1:
    print("Bob")
elif a < b:
    print("Bob")
elif b < a:
    print("Alice")


# Optimized solution
# # aアリス　　　ｂボブ
# a, b = map(int, input().split())
# if a == b:
#     print("Draw")
# elif a == 1:
#     print("Alice")
# elif b == 1:
#     print("Bob")
# elif a < b:
#     print("Bob")
# elif b < a:
#     print("Alice")

x, y = list(map(int, input().split()))

L = list(range(2, 14)) + [1]
a = L.index(x)
b = L.index(y)

if a>b:
    print("Alice")
elif b>a:
    print("Bob")
else:
    print("Draw")
# Original solution
A, B = list(map(int,input().split()))

if(A == 1 and B == 1):
  print("Draw")
  exit()
elif(A == 1):
  print("Alice")
  exit()
elif(B == 1):
  print("Bob")
  exit()
elif(A > B):
  print("Alice")
elif(A < B):
  print("Bob")
else:
  print("Draw")

# Optimized solution
A, B = list(map(int,input().split()))
if(A == 1):
  A += 13
if(B == 1):
  B += 13
if(A > B):
  print('Alice')
elif(A < B):
  print('Bob')
else:
  print('Draw')