Problem:
 Score : 100 points    Problem Statement Snuke lives at position x on a number line.
On this line, there are two stores A and B , respectively at position a and b , that offer food for delivery.  Snuke decided to get food delivery from the closer of stores A and B .
Find out which store is closer to Snuke's residence.  Here, the distance between two points s and t on a number line is represented by |s-t| .      Constraints  1 \leq x \leq 1000  1 \leq a \leq 1000  1 \leq b \leq 1000  x, a and b are pairwise distinct.  The distances between Snuke's residence and stores A and B are different.         Input Input is given from Standard Input in the following format:  x  a  b       Output If store A is closer, print A ; if store B is closer, print B .        Sample Input 1 5 2 7      Sample Output 1 B  The distances between Snuke's residence and stores A and B are 3 and 2 , respectively.
Since store B is closer, print B .       Sample Input 2 1 999 1000      Sample Output 2 A

Solution (Python):
x,a,b = map(int,input().split())
a1,b1 = abs(x-a),abs(x-b)
if a1 >= b1:
    print("B")
else:
    print("A")

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

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

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

Solution (Python):
x,a,b=map(int,input().split())

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

Solution (Python):
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")

Solution (Python):
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
INF = 10**9
mod = 10**9+7

X,A,B = I()
if abs(A-X) > abs(B-X):
    print('B')
else:
    print('A')

Solution (Python):
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate


def mina(*argv, sub=1): return list(map(lambda x: x - sub, argv))



def a_int(): return int(read())


def ints(): return list(map(int, read().split()))


def read_col(H):
    '''H is number of rows
    A列、B列が与えられるようなとき
    ex1)A,B=read_col(H)    ex2) A,=read_col(H) 
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return tuple(map(list, zip(*ret)))


def read_tuple(H):
    '''H is number of rows'''
    ret = []
    for _ in range(H):
        ret.append(tuple(map(int, read().split())))
    return ret


def read_matrix(H):
    '''H is number of rows'''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return ret
    


MOD = 10**9 + 7
INF = 2**31  

from collections import defaultdict, Counter, deque
from operator import itemgetter, xor, add
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right  
from functools import reduce
from math import gcd


def lcm(a, b):
    
    g = gcd(a, b)
    return a // g * b


x, a, b = ints()

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

Solution (Python):
def solve():
    x, a, b = map(int, input().split())
    if min(abs(a-x), abs(b-x)) == abs(a-x):
        print("A")
    else:
        print("B")
    return 0

if __name__ == "__main__":
    solve()

Solution (Python):
from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:list(map(int,stdin.readline().split()))

x,a,b=nii()
print('A' if abs(x-a)<abs(x-b) else 'B')

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

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

Solution (Python):
x,a,b = map(int, input().split())
print("A" if min(abs(x-a), abs(x-b))==abs(x-a) else "B")

Solution (Python):
x,a,b = map(int,input().split())
A = abs(a-x)
B = abs(b-x)

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

Solution (Python):
X,A,B=map(int,input().split())
if abs(X-A)>abs(X-B):
  print('B')
else:
  print('A')

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

Solution (Python):
x, a, b = map(int, input().split())

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

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

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

Solution (Python):
x, a, b = map(int, input().split())

x_a = abs(x-a)
x_b = abs(x-b)

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

else:
    print("A")

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

Solution (Python):
from fractions import gcd
from collections import Counter, deque, defaultdict
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, merge
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
from itertools import accumulate, product, permutations, combinations

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

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

if __name__ == '__main__':
    main()

Solution (Python):


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

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

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

Solution (Python):
def actual(x, a, b):
    

    if abs(x - a) < abs(x - b):
        return 'A'

    return 'B'

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

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

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

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

Solution (Python):
x,a,b = map(int,input().split())

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

Solution (Python):
x,a,b=map(int,input().split())
y=abs(x-a)
z=abs(b-x)
if y<z:
    print('A')
else:
    print('B')

Solution (Python):



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

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

Solution (Python):
x,a,b = list(map(int,input().strip().split()))

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

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

Solution (Python):
x, A, B = map(int,input().split())
a = abs(x-A)
b = abs(x-B)

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

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

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

Solution (Python):
x,a,b = tuple(map(int,input().split()))

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

Solution (Python):
x,a,b = map(int,input().split())

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

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

Solution (Python):
x,a,b=map(int,input().split())
d1=abs(x-a)
d2=abs(x-b)
if d1<d2:print('A')
else:print('B')

Solution (Python):
x, a, b = map(int, input().split())

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

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

Solution (Python):
x,a,b=map(int,input().split());print('AB'[abs(x-a)>abs(x-b)])

Solution (Python):
x,a,b=map(int,input().split());print(['A','B'][abs(x-a)>abs(x-b)])

Solution (Python):
import sys

input = sys.stdin.readline


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

    if abs(x - a) < abs(x - b):
        ans = "A"
    else:
        ans = "B"

    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
x,a,b=map(int,input().split())
print(['A','B'][abs(x-a)>abs(x-b)])

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

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

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

Solution (Python):
x, a, b = map(int, input().split())
distance_a = abs(a - x)
distance_b = abs(b - x)

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

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

Solution (Python):
x,a,b=map(int,input().split());print("AB"[abs(x-a)>abs(x-b)])

Solution (Python):
x, a, b = map(int, input().split())

k = (x - a) ** 2
l = (x - b) ** 2

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

Solution (Python):
x,a,b = map(int,input().split())
da = abs(x - a)
db = abs(x - b)
if da < db: print('A')
else: print('B')

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

Solution (Python):
x,a,b = map(int,input().split())

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

Solution (Python):
x,a,b=map(int,input().split())

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

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

Solution (Python):
x,a,b = map(int, input().split())

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

Solution (Python):
x,a,b=map(int,input().split())
print('BA'[abs(x-a)<abs(x-b)])

Solution (Python):
x,a,b=map(int,input().split())
DisXA=abs(a-x)
DisXB=abs(b-x)
if DisXA<DisXB:
    print('A')
else:
    print('B')

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

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

Solution (Python):
x,a,b = map(int,input().split())

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

Solution (Python):
import sys

def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))

def main():
    x, a, b = MII()
    print('A' if abs(a-x) < abs(x-b) else 'B')

if __name__ == '__main__':
    main()

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

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

Solution (Python):
x,a,b=map(int,input().split())

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

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

Solution (Python):
x,a,b = map(int, input().split())

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

Solution (Python):
x,a,b = map(int,input().split())

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

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

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

Solution (Python):
x,a,b = map(int,input().split())

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

Solution (Python):
x, a, b = map(int, input().split())

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

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

Solution (Python):
x, a, b = map(int, input().split())

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

Solution (Python):


import sys






























def main():
    mod = 1000000007                
    inf = float('inf')              
    
    sys.setrecursionlimit(10**6)    
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    
    x, a, b = mi()
    print('A') if abs(x-a) < abs(x-b) else print('B')


if __name__ == "__main__":
    main()

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
x, a, b = map(int, input().split())

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

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

Solution (Python):
x,a,b = map(int, input().split())

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

Solution (Python):

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

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

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

Solution (Python):
x,a,b = map(int,input().split())
print('AB'[abs(a-x)>abs(b-x)])

Solution (Python):
A, B, C = map(int, input().split())
def check():
    if abs(B-A)<abs(C-A):
        return 'A'
    return 'B'
print(check())

Solution (Python):
import sys

import math


from collections import deque

from fractions  import gcd

input=sys.stdin.readline
x,a,b=map(int,input().split())
if abs(x-a)<abs(x-b):
    print("A")
else:
    print("B")

Solution (Python):
x, a, b = map(int, input().split())

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

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

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

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

Solution (Python):
z = input().split()
x = int(z[0])
a = int(z[1])
b = int(z[2])
A = x - a
B = x - b
if A < 0:
  A = A*-1
if B < 0:
  B = B*-1
if A > B:
  print('B')
else:
  print('A')

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

Solution (Python):
x,a,b=map(int,input().split())
if abs(x-a)<abs(x-b):
    print("A")
    exit()
print("B")

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

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

Solution (Python):
x,a,b = map(int, input().split())

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

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

Solution (Python):
x,a,b = map(int,input().split())

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

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

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

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

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

Solution (Python):
x, y, z = map(int, input().split())
if abs(y-x) < abs(z-x):
    print("A")
else:
    print("B")

Solution (Python):
x,a,b = map(int, input().split())
xa = (x-a)**2
xb = (x-b)**2

if xa > xb:
    print('B')
elif xb > xa:
    print('A')

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

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

Solution (Python):
x, a, b = map(int, input().split())

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

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

Solution (Python):
x, a, b = map(int, input().split())

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

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

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

Solution (Python):
x,a,b = map(int,input().split())

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

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

Solution (Python):
x,a,b =map(int,input().split())

x1 =abs(x - a)
x2 =abs(x - b)

if x1 > x2:
    print("B")

else:
    print("A")

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

Solution (Python):
X, A, B = map(int, input().split())
print("A" if abs(X - A) < abs(X - B) else "B")

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

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

Solution (Python):
x, a, b = map(int, input().split())

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

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7


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


if __name__ == '__main__':
    resolve()

Solution (Python):
x,a,b = map(int,input().split())

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

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

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

Solution (Python):

"""
Created on Thu May 14 11:42:53 2020

@author: shinba
"""

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

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

Solution (Python):
x,a,b = map(int,input().split())

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

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

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

Solution (Python):

x, a, b = map(int, input().split())
print('BA'[abs(a - x) < abs(b - x)])

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()

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

resolve()

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

Solution (Python):






import sys
input = sys.stdin.readline

import math
from collections import deque
from fractions import gcd
from functools import lru_cache






MOD = 10**9+7
INF = float('inf')






def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]


def inv(n): return pow(n, MOD-2, MOD)


kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret


def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])
    return arr


def lcm(a, b):
    return a * b // gcd (a, b)





x,a,b = inputIL()

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

Solution (Python):
x,a,b = map(int,input().split())

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

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

Solution (Python):
import sys
import math
import bisect

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

if __name__ == "__main__":
    main()

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

Solution (Python):
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")

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

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

Solution (Python):
def main():
    x, a, b = map(int, input().split())
    if abs(x-a) < abs(x-b):
        ans = 'A'
    else:
        ans = 'B'
    print(ans)


if __name__ == "__main__":
    main()

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

Solution (Python):
x, a, b = map(int, input().split())

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

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

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

Solution (Python):
def ABC_71_A():
    X,A,B = map(int, input().split())
    
    if abs(X-A) <= abs(X-B):
        print('A')
    else:
        print('B')

if __name__ == '__main__':

    ABC_71_A()

Solution (Python):

import sys
import math
from bisect import bisect_left, bisect_right, insort_left, insort_right
from collections import defaultdict, deque, Counter
from copy import deepcopy
from fractions import gcd
from functools import lru_cache, reduce
from heapq import heappop, heappush
from itertools import accumulate, groupby, product, permutations, combinations, combinations_with_replacement
from math import ceil, floor, factorial, log, sqrt, sin, cos
from operator import itemgetter
from string import ascii_lowercase, ascii_uppercase, digits
sys.setrecursionlimit(10**7)
rs = lambda: sys.stdin.readline().rstrip()
ri = lambda: int(rs())
rf = lambda: float(rs())
rs_ = lambda: [_ for _ in rs().split()]
ri_ = lambda: [int(_) for _ in rs().split()]
rf_ = lambda: [float(_) for _ in rs().split()]
INF = float('inf')
MOD = 10 ** 9 + 7
PI = math.pi

x, a, b = ri_()
print('A' if abs(a - x) < abs(b - x) else 'B')

Solution (Python):
x, a, b = map(int, input().split())

xa = abs(x - a)
xb = abs(x - b)

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

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

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

Solution (Python):

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

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

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

Solution (Python):
def main():
    x,a,b = (int(x) for x in input().split())
    if abs(a-x) < abs(b-x): print('A')
    else: print('B')

if __name__ == '__main__':
    main()

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

Solution (Python):
x,a,b=map(int,input().split());print("BA"[abs(x-a)<abs(x-b)])

Solution (Python):
x,a,b=map(int,input().split())
ad=abs(x-a)
bd=abs(x-b)

if ad > bd:
    print("B")
elif ad < bd:
    print("A")

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

Solution (Python):
import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy

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

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

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

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

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

Solution (Python):
x, a, b = map(int, input().split())
print(['A', 'B'][abs(x - a) > abs(x - b)])

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

Solution (Python):
x,a,b = map(int,input().split())
print(['A','B'][abs(x-a) > abs(x-b)])

Solution (Python):
a,b,c=map(int,input().split())
if abs(a-b)>abs(c-a):
  print("B")
else:
  print("A")

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

Solution (Python):
X, A, B = map(int, input().split())

if abs(X - A) < abs(X - B):
    print ('A')
else:
    print ('B')

Solution (Python):
X,A,B = map(int,input().split())
if abs(X-A) < abs(X-B):
    print('A')
else:
    print('B')

Solution (Python):
x, a, b = map(int, input().split())

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

Solution (Python):
x, a, b = map(int, input().split())

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

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

Solution (Python):
def main():
    x, a, b = map(int, input().split())
    if abs(x-a) < abs(x-b):
        print("A")
    else:
        print("B")


main()

Solution (Python):
x,a,b = map(int,input().split())
K = abs(a-x)
L = abs(b-x)
if K < L:
    print("A")
else:
    print("B")

Solution (Python):
A,B,C = list(map(int,input().split()))
if abs(A-B) < abs(A-C):
    print("A")
else:
    print("B")

Solution (Python):
x,a,b=map(int,input().split())
if abs(x-a) > abs(x-b):
  print('B')
elif abs(x-a) < abs(x-b):
  print('A')

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
 
x, a, b = MAP()
if abs(a-x) > abs(b-x):
	print("B")
else:
	print("A")

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

Solution (Python):


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

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

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

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

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

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

Solution (Python):
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections

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

Solution (Python):
def resolve():
	x, a, b = map(int, input().split())
	if abs(x-a) > abs(x-b):
		print('B')
	else:
		print('A')
resolve()

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

Solution (Python):
x,a,b=map(int,input().split())
c=abs(a-x)
d=abs(b-x)
if c>d:
    print("B")
else:
    print("A")

Solution (Python):
a,b,c=map(int,input().split())
if abs(a-b)<abs(a-c):
  print('A')
else:
  print('B')

Solution (Python):
n,a,b = map(int,input().split())
if abs(n-a)<abs(n-b):
    print("A")
else:
    print("B")

Solution (Python):
x, a, b = map(int, input().split())

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

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

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