qyliang/CodeNanoFix huggingface dataset:
Buggy code:
Q, H, S, D = input().split()
Q, H, S, D = int(Q), int(H), int(S), int(D)
N = int(input())

needtobuy_l = N
needtobuy_m = 0
per_2l_price = [D,
                S*2, S+H*2, S+H+Q*2,
                H*4, H*3+Q*2, H*2+Q*4, H+Q*6,
                Q*8]
per_1l_price = [S,
                H*2, H+Q*2,
                Q*4]

print(per_2l_price)
print(per_1l_price)
if needtobuy_l % 2 == 0:
    mincost = min(per_2l_price)
    needtobuy_m = mincost * (needtobuy_l // 2)
else:
    mincost = min(per_2l_price)
    needtobuy_m = mincost * (needtobuy_l // 2)
    mincost = min(per_1l_price)
    needtobuy_m += mincost * 1

print(needtobuy_m)

Fixed code:
Q, H, S, D = input().split()
Q, H, S, D = int(Q), int(H), int(S), int(D)
N = int(input())

needtobuy_l = N
needtobuy_m = 0
per_2l_price = [D,
                S*2, S+H*2, S+H+Q*2,
                H*4, H*3+Q*2, H*2+Q*4, H+Q*6,
                Q*8]
per_1l_price = [S,
                H*2, H+Q*2,
                Q*4]

if needtobuy_l % 2 == 0:
    mincost = min(per_2l_price)
    needtobuy_m = mincost * (needtobuy_l // 2)
else:
    mincost = min(per_2l_price)
    needtobuy_m = mincost * (needtobuy_l // 2)
    mincost = min(per_1l_price)
    needtobuy_m += mincost * 1

print(needtobuy_m)
Buggy code:
Q, H, S, D = map(int, input().split())

N = int(input())
ans = 0
Q *= 4
H *= 2
twiceQ = Q * 2
twiceH = H * 2
twiceS = S * 2

a = N % 2
if a == 0:
    num = N / 2
    ans += num * min(twiceQ, twiceH, twiceS, D)
else:
    num = (N-1) / 2
    ans += num * min(twiceQ, twiceH, twiceS, D)
    ans += min(Q, H, S)
print(ans)


Fixed code:
Q, H, S, D = map(int, input().split())

N = int(input())
ans = 0

Q *= 4
H *= 2
twiceQ = Q * 2
twiceH = H * 2
twiceS = S * 2

a = N % 2
if a == 0:
    num = N // 2
    ans += num * min(twiceQ, twiceH, twiceS, D)
else:
    num = (N-1) // 2
    ans += num * min(twiceQ, twiceH, twiceS, D)
    ans += min(Q, H, S)

print(ans)
Buggy code:
a,b,c,d=[int(i) for i in input().split()]
M=[4*a,2*b,c,d/2]
N=int(input())

if M[0]==min(M):
    print(N*M[0])
elif M[1]==min(M):
    print(N*M[1])
elif M[2]==min(M):
    print(N*M[2])
else:
    if N%2==0:
        print(int(N*M[3]))
    else:
        if M[0]==min(M):
            print(N//2*int(M[3]*2)+M[0])
        elif M[1]==min(M):
            print(N//2*int(M[3]*2)+M[1])
        elif M[2]==min(M):
            print(N//2*int(M[3]*2)+M[2])


Fixed code:
a,b,c,d=[int(i) for i in input().split()]
M=[4*a,2*b,c,d/2]
N=int(input())

if M[0]==min(M):
    print(N*M[0])
elif M[1]==min(M):
    print(N*M[1])
elif M[2]==min(M):
    print(N*M[2])
else:
    if N%2==0:
        print(int(N//2*int(M[3]*2)))
    else:
        if M[0]==min([4*a,2*b,c]):
            print(N//2*int(M[3]*2)+M[0])
        elif M[1]==min([4*a,2*b,c]):
            print(N//2*int(M[3]*2)+M[1])
        elif M[2]==min([4*a,2*b,c]):
            print(N//2*int(M[3]*2)+M[2])
Buggy code:
q,h,s,d = int(input().strip().split())
n = int(input())

h = min(h, q*2)
s = min(s, h*2)
d = min(d, s*2)

d_num, s_num = n//2, n%2
cost = d_num*d + s_num*s
print(cost)

Fixed code:
q,h,s,d = list(map(int, input().strip().split()))
n = int(input())

h = min(h, q*2)
s = min(s, h*2)
d = min(d, s*2)

d_num, s_num = n//2, n%2
cost = d_num*d + s_num*s
print(cost)
Buggy code:
Q,H,S,D=map(int,raw_input().split())
N=input()
r=min(D,S*2,H*4,Q*8)*(N/2)+min(S,H*2,Q*8)*(N%2)
print r


Fixed code:
Q, H, S, D = map(int, input().split())
N = int(input())
print(min(8*Q, 4*H, 2*S, D)*(N//2) + min(4*Q, 2*H, S)*(N%2))
Buggy code:
q, h, s, d = map(int, input().split())
n = int(input())
print((n/2) * min(8 * q, 4 * h, 2 * s, d) + (n % 2) * min(4 * q, 2 * h, s))

Fixed code:
q, h, s, d = map(int, input().split())
n = int(input())

ans = (n // 2) * min(8 * q, 4 * h, 2 * s, d) + (n % 2) * min(4 * q, 2 * h, s)
print(ans)
Buggy code:
def main(q: int, h: int, s: int, d: int, n: int):
    print((n // 2) * min(q * 8, h * 4, s * 2, d) + (n % 2) * min(q * 4, h * 2, s))


if __name__ == "__main__":
    q, h, s, d = map(int, input().split())
    n = int(input)

    main(q, h, s, d, n)


Fixed code:

def main():
    q, h, s, d = map(int, input().split())
    n = int(input())
    s = min(s, 2 * h, 4 * q)
    d = min(d, s * 2)
    print((n // 2) * d + (n % 2) * s)

if __name__ == '__main__':
    main()
Buggy code:
q,h,s,d=map(int,input().split())
n=int(input())
h=min(q*2,h)
s=min(s,h*2)
print(d*(n//2)+s*(n%2),s*n)

Fixed code:
q, h, s, d = map(int,input().split())
n = int(input())
h = min(h, 2*q)
s = min(s, 2*h)
d = min(d, 2*s)
print(d*(n//2) + s*(n%2))
Buggy code:
x,a,b=map(int, input()split())
if abs(x-b) > abs(x-a):
  print('A')
else:
  print('B')

Fixed code:
x,a,b=map(int, input().split())
if abs(x-b) > abs(x-a):
  print('A')
else:
  print('B')
Buggy code:
x,a,b = map(int,input().split())
if abs(x-a) > abs(x-b):
    print("A")
else:
    print("B")

Fixed code:
x, a, b = map(int, input().split())
if abs(x-a) < abs(x-b):
  print("A")
else:
  print("B")
Buggy code:
x,a,b=map(int,input().split());print(['a','b'][abs(x-a)>abs(x-b)])

Fixed code:
x,a,b=map(int,input().split())
print('AB'[abs(x-a)>abs(x-b)])
Buggy code:
def mealdelivery(x , a , b):

    return "A" if abs(x - a) > abs(x - b) else "B"

def main():
    x , a , b = map(int , input().split())
    print(mealdelivery(x , a , b))

if __name__ == '__main__':
    main()


Fixed code:
def mealdelivery(x , a , b):

    return "A" if abs(x - a) < abs(x - b) else "B"

def main():
    x , a , b = map(int , input().split())
    print(mealdelivery(x , a , b))

if __name__ == '__main__':
    main()
Buggy code:
x,a,b = map(int, input().split)
if abs(a-x) < abs(b-x):
  print('A')
else:
  print('B')

Fixed code:
x, a, b = map(int,input().split(" "))
if abs(x-a) < abs(x-b):
  print("A")
else:
  print("B")
Buggy code:
x, a, b = map(int, input().split())
xa = abs(x - a)
xb = abs(x - b)
if xa > xb:
    print("A")
else:
    print("B")


Fixed code:
x, a, b = map(int, input().split())
xa = abs(x - a)
xb = abs(x - b)
if xa > xb:
    print("B")
else:
    print("A")
Buggy code:
x, a, b = map(int, input().split())
if abs(x - a) < abs(a - b):
    print("A")
else:
    print("B")


Fixed code:
x, a, b=map(int, input().split())
print("A" if abs(x-a)<abs(x-b) else "B")
Buggy code:
x,a,b=map(int,input().split())
if abs(x-a)<abs(x-b):
  print('A'):
else:
  print('B')


Fixed code:
x, a, b = list(map(int, input().split()))

if abs(x - a) < abs(x - b):
	print('A')
else:
	print('B')
Buggy code:
x, a, b = map(int, input().split())
 
if abs(x-a) > abs(x-b):
  print("A")
else:
  print("B")

Fixed code:
x,a,b = map(int,input().split())
A = abs(x-a)
B = abs(x-b)
if A<B:
  print("A")
else:
  print("B")
Buggy code:
x, a, b = map(int, input().split())
 
if abs(x-a) > abs(x-b):
  print(A)
else:
  print(B)

Fixed code:
x, a, b = map(int, input().split())
 
if abs(x-a) > abs(x-b):
  print("B")
else:
  print("A")
Buggy code:
x, a, b = map( int, input().split() )

if abs(x - a) > abs(x - b): print( 'A' )
else:                       print( 'B' )

Fixed code:
x,a,b = map(int, input().split())
if(abs(x-a) < abs(x-b)):
    print('A')
else:
    print('B')
Buggy code:
x = int(input())
a, b = (abs(int(i)-x) for i in input().split())
if a > b:
  print("B")
else:
  print("A")


Fixed code:
x, a, b = (int(i) for i in input().split())
aa = abs(a-x)
bb = abs(b-x)
if aa > bb:
    print("B")
else:
    print("A")
Buggy code:
x, a, b = map(int, input().split())
print("A" if abs(x-a) > abs(x-b) else "B")

Fixed code:
x, a, b = map(int,input().split())
print('A' if abs(a-x) <= abs(b-x) else 'B')
Buggy code:
X,A,B = map(int, input().split())
if A-X < B-X:
  print("A")
else:
  print("B")
  

Fixed code:
X,A,B = map(int, input().split())
if abs(A-X) < abs(B-X):
  print("A")
else:
  print("B")
Buggy code:
x, a, b = map(int, input().split(' '))
if abs(a - x) >= abs(b - x):
    print('A')
else:
    print('B')

Fixed code:
x, a, b = map(int, input().split())

if abs(x-a) <= abs(x-b):
    print("A")
else:
    print("B")
Buggy code:
x,a,b=input().split()
if abs(int(x)-int(a))>abs(int(x)-int(b)):
  print("A")
else:
  print("B")

Fixed code:
x,a,b=input().split()
if abs(int(x)-int(a))<abs(int(x)-int(b)):
  print("A")
else:
  print("B")
Buggy code:
x,a,b = map(int,input().split())

d1 = abs(x-a)
d2 = abs(x-b)

if d1 > d2:
	print('A')
	
else:
	print('B')

Fixed code:
x, a, b=map(int,input().split())

if abs(a-x)  > abs(b-x):
    print('B')
else:
    print('A')
Buggy code:
x,a,b = input().split()
x = int(x)
a = int(a)
b = int(b)
print("x = ", x)
print("a = ", a)
print("b = ", b)

if x < a:
    distance_xa = a - x
else:
    distance_xa = x - a
print("distance_xa = ", distance_xa)

if x < b:
     distance_xb = b - x
else:
     distance_xb = x - b
print("distance_xb = ", distance_xb) 

if distance_xa < distance_xb:
      print("A")
else:
      print("B")

Fixed code:
x,a,b = input().split()
x = int(x)
a = int(a)
b = int(b)

if x < a:
    distance_xa = a - x
else:
    distance_xa = x - a

if x < b:
     distance_xb = b - x
else:
     distance_xb = x - b

if distance_xa < distance_xb:
      print("A")
else:
      print("B")
Buggy code:
x,a,b = map(int,input().split())

A = x - a
B = x - b

if A < B:
  print("A")
else:
  print("B")

Fixed code:
def a():
    x, a, b = map(int, input().split())
    print('A' if abs(x-a) < abs(x-b) else 'B')

a()
Buggy code:
x,a,b = map(int,input().split())

kyori1 = abs(x - a)
kyori2 = abs(x - a)

if kyori1 < kyori2:
  print('A')
else:
  print('B')

Fixed code:
x,a,b = map(int,input().split())

if abs(x-a) < abs(x-b):
    print("A")
else:
    print("B")
Buggy code:
L=list(map(int,input().split()))
A=L[0]-L[1]
B=L[0]-L[2]
if min(A,B)=A:
	print("A")
else:
	print("B")

Fixed code:
L=list(map(int,input().split()))
A=abs(L[0]-L[1])
B=abs(L[0]-L[2])
if min(A,B)==A:
	print("A")
else:
	print("B")
Buggy code:
x, a, b = (int(i) for i in input().split())
da = abs(x-a)
db = abs(x-b)
if da > db:
  print('A')
else:
  print('B')

Fixed code:
x,a,b = (int(i) for i in input().split())
A,B = abs(x-a),abs(x-b)
if A>B: print("B")
else: print("A")
Buggy code:
x, a, b = map(int, input().split())
print("A" if abs(a - x) < abs(a - x) else "B")

Fixed code:
n,a,b = map(int,input().split())
a=abs(n-a)
b=abs(n-b)
print("A" if a<b else "B")
Buggy code:
x, a, b = map(int, input().split())

if abs(x - a) > abs(x - b):
  print("A")
else:
  print("B")

Fixed code:
x,a,b =map(int,input().split())
A = abs(a-x)
B = abs(b-x)
if A>B:
    print("B")
else:
    print("A")
Buggy code:
x,a,b = [int(x) for x in input().split()]
if abs(x-a) > abs(x-b):
    print("A")
else:
    print("B")


Fixed code:
x,a,b = [int(x) for x in input().split()]
if abs(x-a) < abs(x-b):
    print("A")
else:
    print("B")
Buggy code:
from statistics import mean, median,variance,stdev
import sys
import math

a = input().split()
#y = input().split()

for i in range(len(a)):
    a[i] = int(a[i])

#x = int(input())
#y = int(input())
if a[2]-a[0] > a[1]-a[0]:
    print(a[1])
else: print(a[2])

Fixed code:
from statistics import mean, median,variance,stdev
import sys
import math

a = input().split()
#y = input().split()

for i in range(len(a)):
    a[i] = int(a[i])

#x = int(input())
#y = int(input())
if abs(a[2]-a[0]) > abs(a[1]-a[0]):
    print("A")
else: print("B")
Buggy code:
x,a,b=map(int,input().split())
if abs(x-a)<abs(x-b):
    print("B")
else:
    print("A")

Fixed code:
x, a, b = map(int, input().split())
if abs(a-x) > abs(b-x):
    print("B")
else:
    print("A")
Buggy code:
x,a,b = map(int, input().split())

if abs(x-a) > abs(x-b):
    print(B)
else:
    print(A)

Fixed code:
x,a,b = map(int,input().split())
if abs(x-a) >abs(x-b):
  print("B")
else:
  print("A")
Buggy code:
x, a, b = map(int(input())
A = abs(x-a)
B = abs(x-b)
if A < B:
    print("A")
else:
    print("B")

Fixed code:
x, a, b= map(int, input().split())

if abs(a-x) < abs(b-x):
    print("A")
else:
    print("B")
Buggy code:
x,a,b=map(int,input().split())
print('A' if min(abs(a-x),abs(b-x)))==abs(a-x) else 'B')


Fixed code:
x,a,b=map(int,input().split())
print('A' if min(abs(a-x),abs(b-x))==abs(a-x) else 'B')
Buggy code:
x, a, b = map(int, input().split())
print("a") if abs(a - x) < abs(b - x) else print("b")

Fixed code:
x, a, b = map(int, input().split())

print('A' if abs(a-x) < abs(b-x) else 'B')
Buggy code:
x,a,b = map(int, input().split())

if abs(x-a) > abs(x-b):
  print('A')
else:
  print('B')

Fixed code:

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

if abs(x-a) > abs(x-b):
    print('B')
else:
    print('A')
Buggy code:
x,a,b=map(int,input().split())
if abs(x-a)>abs(x-b):
  print(B)
else:
  print(A)


Fixed code:
x,a,b=map(int,input().split())
if abs(x-a)>abs(x-b):
  print('B')
else:
  print('A')
Buggy code:
x=input()
a,b=input().split()
x=int(x)
a=int()
b=int()
if abs(x-a)<abs(x-b):
   print("A")
else:
   print("B")

Fixed code:
x, a, b = map(int, input().split())
print("A" if abs(x - a) < abs(x -b) else "B")
Buggy code:
x, a, b = map(int, input().split())
if abs(x - a) >= abs(x - b):
    print("B"):
else:
    print("A")

Fixed code:
x,s,t = map(int,input().split())
a = abs(s-x)
b = abs(t-x)
if b > a:
    print("A")
else:
    print("B")
Buggy code:
a,b,c=map(int, input().split())
b-=a
c-=a
if b<c:print("B")
else:print("A")

Fixed code:
a,b,c=map(int, input().split())
b-=a
c-=a
if abs(b)<abs(c):print("A")
else:print("B")
Buggy code:
    x, a, b = map(int, input().split(' '))
     
    dist_atox = abs(a-x)
    dist_btox = abs(b-x)
    y = dist_atox - dist_btox
     
    print("A" if dist_atox < dist_btox else "B")

Fixed code:
x, a, b = map(int, input().split(' '))

dist_atox = abs(a-x)
dist_btox = abs(b-x)
y = dist_atox - dist_btox

print("A" if y < 0 else "B")
Buggy code:
x, a, b = map(int, input().split())
i = x-a
j = x-b
if i < j:
    print('A')
else:
    print('B')


Fixed code:
x, a, b = map(int, input().split())
i = abs(x-a)
j = abs(x-b)
if i < j:
    print('A')
else:
    print('B')
Buggy code:
x, a, b = map(int, input().split())

if x - a < x - b:
  print("A")
else:
  print("B")

Fixed code:
x, a, b = map(int, input().split(" "))

if abs(x - a) < abs(x - b):
    print("A")
else:
    print("B")
Buggy code:
x,a,b=map(int,input().split())
if abs(a-x)>abs(b-x):
  print(B)
else:
  print(A)

Fixed code:
x,a,b=map(int,input().split())
if(abs(x-a)>=abs(x-b)):
    print("B")
else:
    print("A")
Buggy code:
x,a,b = map(int, input().split())

if abs(x-a) < abs(x-b):
  print('a')
elif abs(x-a) > abs(x-b):
  print('b')

Fixed code:
x,a,b = map(int, input().split())
 
if abs(x-a) < abs(x-b):
  print('A')
elif abs(x-a) > abs(x-b):
  print('B')
Buggy code:
x , a ,b  = map(int,input().split())
X = abs(a - x)
Y = abs(b - x)
Z = max(Y,X)
if Z == X:
    print("A")
else:
    print("B")


Fixed code:
x , a ,b  = map(int,input().split())
X = abs(a - x)
Y = abs(b - x)
Z = min(Y,X)
if Z == X:
    print("A")
else:
    print("B")
Buggy code:
x,a,b=map(int,inpur().split())
if min(abs(x-a),abs(x-b))==abs(x-a):
  print("A")
else:
  print("B")

Fixed code:
x,a,b=map(int,input().split())

if min(abs(x-a),abs(x-b))==abs(x-a):
    print('A')
else :
    print('B')
Buggy code:
x,a,c=map(int,input().split())
if abs(x-a)<=abs(x-b):
    print('A')
else:
    print('B')

Fixed code:
x,a,b=map(int,input().split())
if abs(x-a)<abs(x-b):
	print("A")
else:
	print("B")
Buggy code:
x,a,b=map(int,input().split())
if (a-x)<(b-x):
    print('A')
else:
    print('B')

Fixed code:
x,a,b = list(map(int,input().split(" ")))
A = abs(a - x)
B = abs(b - x)
if A < B:
    print("A")
else:
    print("B")
Buggy code:
x, a, b = map(int, input().split())
if abs(x - a) << abs(x - b):
    print("A")
else:
    print("B")


Fixed code:
if __name__ == '__main__':
    x, a, b = map(int, input().split())
    if abs(x-a) < abs(x-b):
        print('A')
    else:
        print('B')
Buggy code:
x, a, b = map(int, input().split())
if abs(x - a) > abs(x - b):
    print("A")
else:
    print("B")


Fixed code:
import math
x,a,b = map(int,input().split())
if (abs(x-a)>abs(x-b)):
    print("B")
else:
    print("A")
Buggy code:
x, a, b = map(int, input().split())
if abs(x - a) < (x - b):
  print("A")
else :
  print("B")

Fixed code:
x,a,b = list(map(int, input().split()))
if abs(x-a) < abs(x-b):
    print('A')
else:
    print('B')
Buggy code:
a,b,x=map(int,input().split())
da=abs(x-a)
db=abs(x-b)
if da<db:
  print("A")
elif da>db:
  print("B")



Fixed code:
x,a,b=map(int,input().split())
da=abs(x-a)
db=abs(x-b)
if da<db:
  print("A")
elif da>db:
  print("B")
Buggy code:
x,a,b=map(int,input().split())
A = abs(x-a)
B = abs(x-b)
if A>B:
  print("A")
else:
  print("B")

Fixed code:
x,a,b=map(int,input().split())
if abs(x-a)>abs(x-b):
 print("B")
else:
 print("A")
Buggy code:
x, a, b = map(int, input().split())
if abs(z-a) <  abs(z-b):
  print('A')
else:
  print('B')

Fixed code:
x, a, b = map(int, input().split())
if abs(x-a) <  abs(x-b):
  print('A')
else:
  print('B')
Buggy code:
x,a,b=list(map(int,input().split()))
if(math.fabs(x-a)>math.fabs(x-b)):
    print("B")
else:
    print("A")

Fixed code:
import math

x,a,b=list(map(int,input().split()))
if(math.fabs(x-a)>math.fabs(x-b)):
    print("B")
else:
    print("A")
Buggy code:
a,b,c=map(int,input().split())
print(print 'A' if max(abs(b-a),abs(c-a))==abs(b-a) else 'B')

Fixed code:
a,b,c=map(int,input().split())
print('A' if min(abs(b-a),abs(c-a))==abs(b-a) else 'B')
Buggy code:
x,a,b = map(int ,input().split())
if(abs(x-a) > abs(x-b) ):
  print('A')
else:
  print('B')

Fixed code:
def main():
    x, a, b = map(int, input().split())
    if abs(x - a) > abs(x - b):
        print('B')
    else:
        print('A')


main()
Buggy code:
x,a,b=map(int,input().split())
if abs(x-a)<abs(x-b)
    print('A')
else:
    print('B')

Fixed code:
x, a, b = map(int,input().split())
if abs(x - a) < abs(x - b):
    print('A')
else:
    print('B')
Buggy code:
x,a,b = map(int,raw_input.split())
if abs(x-a) > abs(x-b):
    print "B"
else:
    print "A"

Fixed code:
x,a,b = map(int,input().split())
if abs(a-x) > abs(b-x):
    print("B")
else:
    print("A")
Buggy code:
x, a, b = map(int, input().split())
print(['B', 'A'][abs(x-a)> abs(x-b)])

Fixed code:
x,a,b = map(int,input().split())
print(["A","B"][abs(a-x)>abs(b-x)])
Buggy code:
x,a,b=map(int,input().split())
if |a-x|<|b-x|:print('A')
else:print('B')

Fixed code:
x,a,b=map(int,input().split())
if abs(x-a)<abs(x-b):
    print("A")
else :
    print("B")
Buggy code:
x, a, b = map(int, input().split())

if abs(x-a) > abs(x-b):
  print(B)
else:
  print(A)

Fixed code:
x,a,b=map(int, input().split())

if abs(x-a) > abs(x-b):
    print("B")
else:
    print("A")
Buggy code:
myinput=raw_input()
a=[int(x) for x in myinput.split()]
if abs(a[0]-a[1])<abs(a[0]-a[2]):
    print("A")
else:
    print("B")

Fixed code:
myinput=input()
a=[int(x) for x in myinput.split()]
if abs(a[0]-a[1])<abs(a[0]-a[2]):
    print("A")
else:
    print("B")
Buggy code:
x,a,b=map(int,input().split());print("AB"[abs(x-a)<abs(x-b)])

Fixed code:
x,a,b=map(int,input().split());print("AB"[abs(x-a)>abs(x-b)])
Buggy code:
x, a, b = input().split()
x = int(x)
a = int(a)
b = int(b)
x_a = (x - a) ** 2
x_b = (x - b) ** 2

if x_a > x_b:
	print("b")
# elif x_a == x_b:
# 	print("A = B")
else:
	print("A")

Fixed code:
x, a, b = input().split()
x = int(x)
a = int(a)
b = int(b)

x_a = (x - a) ** 2
x_b = (x - b) ** 2
	


if x_a > x_b:
	print("B")

else:
	print("A")
Buggy code:
x, a, b = input().split()
x = int(x)
a = int(a)
b = int(b)

if x > a:
	x_a = x - a
else:
x_a = a - x

if x > b:
	x_b = x - b
else:
	x_b = b - x
	

if x_a > x_b:
	print("B")
else:
	print("A")

Fixed code:
x, a, b = input().split()
x = int(x)
a = int(a)
b = int(b)

if x > a:
	x_a = x - a
else:
	x_a = a - x

if x > b:
	x_b = x - b
else:
	x_b = b - x
	


if x_a > x_b:
	print("B")
else:
	print("A")
Buggy code:
x,a,b=map(int,input().split())
print("A" if abs(x-a) >= abs(x-b) else "B")

Fixed code:
x,a,b=map(int,input().split())
print("A" if abs(x-a) <= abs(x-b) else "B")
Buggy code:
x,a,b=map(int, input().split())

A=abs(x-a)

B=abs(x-b)

if A>B:
  print("A")
else:
  print("B")

Fixed code:
x, a, b = map(int , input().split())
if abs(x-a) < abs(x-b):
    print("A")
else:
    print("B")
Buggy code:
x,a,b=map(int,input().split())
if min(abs(x-a)>abs(x-b)):
  print("A")
else:
  print("B")
    

Fixed code:
x, a, b = map(int, input().split())
if abs(x-a) > abs(x-b):
    print('B')
else:
    print('A')
Buggy code:
x, a, b = map(int, input().split())
print('A' if abs(x-a)>abs(x-b) else 'B')

Fixed code:
x,a,b = map(int,input().split())
print("A") if abs(x-a) < abs(x-b) else print('B')
Buggy code:
x,a,b=map(int,input().split())
if abs(x-a)>abs(x-b):
  print("A")
else:
  print("B")

Fixed code:
x,a,b=map(int,input().split())
if abs(x-a)<abs(x-b):
      print("A")
else:
      print("B")
Buggy code:
a,b,c=map(int,input().split()); print("A" if abs(b-a) < abs(c-b) else "B")

Fixed code:
a,b,c=map(int,input().split()); print("A" if abs(b-a) < abs(c-a) else "B")
Buggy code:
x,a,n = map(int,input().split())

A = abs(x-a)
B = abs(x-b)

if A < B:
    print('A')
else:
    print('B')

Fixed code:
x,a,b=list(map(int,input().split()))
if abs(x-a) < abs(x-b):
    print('A')
else:
    print('B')
Buggy code:
x,a,b = map(int,input().split())
print('A' if a-x > b-x else 'B')


Fixed code:
x, a, b = map(int, input().split())
if abs(a - x) > abs(b - x):
    print('B')
else:
    print('A')
Buggy code:
x,a,b=map(int,input().split())
print("A" if (a-x)<(b-x) else "B")

Fixed code:
x,a,b = map(int,input().split())
if abs(x-a) < abs(x-b) :
    print("A")
else :
    print("B")
Buggy code:
x, a, b = list(map(int, input().split()))

if math.fabs(x - a) > math.fabs(x - b):
  print("B")
else:
  print("A")


Fixed code:
import math

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

if math.fabs(x - a) > math.fabs(x - b):
  print("B")
else:
  print("A")
Buggy code:
x,a,b=map(int,input().split())
if(abs(x-a)>abs(b-a)):
  print("B")
else:
  print("A")  

Fixed code:
x, a, b = map(int, input().split())
if (abs(a - x) < abs(b - x)):
    print("A")
else:
    print("B")
Buggy code:
getList = lambda: list(map(int, input().split()))
a,b,x = getList()
if abs(a - x) < abs(b = x):
  print("A")
else:
  print("B")

Fixed code:
getList = lambda: list(map(int, input().split()))
x,a,b = getList()
if abs(a - x) < abs(b - x):
  print("A")
else:
  print("B")
Buggy code:
x,a,b=map(int,input.split())
if x-a>x-b:
  print('B')
else:
  print('A')

Fixed code:
x,a,b=map(int,input().split())
if abs(x-a) > abs(x-b):
	print("B")
else:
	print("A")
Buggy code:
x,a,b = map(int,input().split())
print('AB'[abs(a-x)<abs(b-x)::2])

Fixed code:
x,a,b = map(int,input().split())
print('AB'[abs(a-x)>abs(b-x)::2])
Buggy code:
x, a, b = list(map(int, input().split()))
ans = "A" if abs(x-a) > abs(x-b) else "B"
print(ans)

Fixed code:
x, a, b = list(map(int, input().split()))
ans = "A" if abs(x-a) < abs(x-b) else "B"
print(ans)
Buggy code:
x, a, b = map(int, input().split())

if abs(x - a) >= abs(x - b):
  print('A')

else:
  print('B')


Fixed code:
x,a,b = map(int,input().split())

if abs(a-x)<abs(b-x):
    print('A')
else:
    print('B')
Buggy code:
x, a, b = map(int, input().split())

if |x - a| >= |x-b|:
  print('A')

else:
  print('B')

Fixed code:
x,a,b = map(int,input().split(" "))
if abs(x-a)>abs(x-b):
    print("B")
else:
    print("A")
Buggy code:
a, b, c= map(int, input().split())
if abs(a-b) >= abs(a-c):
  print("A")
else:
  print("B")

Fixed code:
a, b, c= map(int, input().split())
if abs(a-b) > abs(a-c):
  print("B")
else:
  print("A")
Buggy code:
x,a,b=[int(i) for i in input().split()]
if abs(x-a)>abs(x-b):
  print("A")
else:
  print("B")

Fixed code:
x, a, b = [int(i) for i in input().split()]
if abs(x - a) <= abs(x - b):
    print("A")
else:
    print("B")
Buggy code:
a, b, c = map(int, input().split())
if abs(x - a) > abs(x - b):
    print('B')
else:
    print('A')

Fixed code:
x,a,b = map(int,input().split(' '))

if abs(x-a) > abs(x-b):
    print('B')
else:
    print('A')
Buggy code:
x, a, b = (int(i) for i in input().split())
if abs(x-a) < abs(x-b):
    print(A)
else:
    print(B)

Fixed code:
x, a, b = (int(i) for i in input().split())
if abs(x-a) < abs(x-b):
    print('A')
else:
    print('B')
Buggy code:
x,a,b = map(int,input().split())

if abs(a-x) > abs(b-x):
    print("A")
else:
    print("B")



Fixed code:
x, a, b = map(int, input().split())
if abs(a-x)>abs(b-x):
  print("B")
else:
  print("A")