A country decides to build a palace.
In this country, the average temperature of a point at an elevation of x meters is T-x \times 0.006 degrees Celsius.
There are N places proposed for the place. The elevation of Place i is H_i meters.
Among them, Princess Joisino orders you to select the place whose average temperature is the closest to A degrees Celsius, and build the palace there.
Print the index of the place where the palace should be built.
It is guaranteed that the solution is unique.

-----Constraints-----
 - 1 \leq N \leq 1000
 - 0 \leq T \leq 50
 - -60 \leq A \leq T
 - 0 \leq H_i \leq 10^5
 - All values in input are integers.
 - The solution is unique.

-----Input-----
Input is given from Standard Input in the following format:
N
T A
H_1 H_2 ... H_N

-----Output-----
Print the index of the place where the palace should be built.

-----Sample Input-----
2
12 5
1000 2000

-----Sample Output-----
1

 - The average temperature of Place 1 is 12-1000 \times 0.006=6 degrees Celsius.
 - The average temperature of Place 2 is 12-2000 \times 0.006=0 degrees Celsius.
Thus, the palace should be built at Place 1.

Difficulty: introductory

Starter code:

Solutions:
N = int(input())
T, A = map(int, input().split())
H = list(map(int, input().split()))

high = []
abso = []
for i in range(N):
    high.append(T - (H[i] * 0.006))

n = 0
while n <= N - 1:
    abso.append(abs(A - high[n]))
    n += 1

answer = abso.index(min(abso)) + 1
print(answer)

N = int(input())
T, A = map(int,input().split())
H = list(map(int,input().split()))

temp_diff = []
for i in range(N):
    temp_avr = T - H[i] * 0.006
    temp_diff.append(abs(A - temp_avr))

min_diff = min(temp_diff)
print(temp_diff.index(min_diff) + 1)

n = int(input())
t,a = map(int,input().split())
data = list(map(int,input().split()))
ans = 0
for i in range(n):
    if abs(t - data[i] * 0.006 - a) < abs(t - data[ans] * 0.006 - a):
        ans = i
print(ans + 1)

N = int(input())
T,A = list(map(int, input().split()))
temp_list = list(map(int, input().split()))
near_place = 100000
H = []
min_index = 0
for i in range(N):
    a = T - temp_list[i]*0.006
    H.append(abs(A - a))
print((H.index(min(H)) + 1))



N = int(input())

T, A = [int(i) for i in input().split()]

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

temp_list = [(i, abs(A - (T-x*0.006))) for i, x in enumerate(h_list, 1)]

ans = min(temp_list, key=lambda x: x[1])

print((ans[0]))


n=int(input())
t,a =map(int,input().split())  
h =list(map(int, input().split()))
cnt = 0
dict = {}
for i in h:
    cnt +=1
    dict[abs(a - (t-i*0.006))] = cnt
print(dict[min(dict)])

a = int(input())
b,c = list(map(int,input().split()))
d = list(map(int,input().split()))
e = []
f = []
ans = 10**9
for i in d:
  e.append(b-0.006*i)
for j in e:
  f.append(abs(c-j))
print((f.index(min(f))+1))





n = int(input())
t,a = map(int,input().split())
h = list(map(int,input().split()))
l = []
for i in range(0,n):
  l.append(abs(a-(t-h[i]*0.006)))
print(l.index(min(l))+1)

N=int(input())
T,A=map(int, input().split())
H=list(map(int, input().split()))
res=0
for i in range(N):
    t1=T-H[i]*0.006
    t2=T-H[res]*0.006
    if abs(t1-A) < abs(t2-A): res=i
print(str(res+1))

#-*-coding:utf-8-*-
import sys
input=sys.stdin.readline
import decimal

def main():
    numbers=[]
    n = int(input())
    t,a = map(int,input().split())
    numbers=list(map(int,input().split()))
    dp=[]
    hensu=decimal.Decimal('0.006')
    for number in numbers:
        tmp=abs(t-number*hensu-a)
        dp.append(tmp)
    answer=dp.index(min(dp))+1
    print(answer)

def __starting_point():
    main()
__starting_point()

import numpy as np

N = int(input())
T, A = map(int, input().split())
H = list(map(int, input().split()))

H = np.array(H)
temp = T-H*0.006
res = np.abs(temp-A)

print(np.argmin(res)+1)

n = int(input())
t, a = map(int, input().split())
h = list(map(int, input().split()))
candidate = float('inf')
ans = 0

for i in range(n):
  temp = t - h[i] * 0.006
  difference = abs(a - temp)
  if difference < candidate:
    candidate = difference
    ans = i + 1

print(ans)

_, ta, hs = int(input()), list(map(int, input().split())), list(map(int, input().split()))
t, a = ta[0], ta[1]
min_diff, answer = float('inf'), 0
for index, h in enumerate(hs):
    diff = abs(a - (t - h * 0.006))
    if diff <= min_diff:
        min_diff, answer = diff, index + 1

print(answer)


n=int(input())
T,A=map(int,input().split())
h=list(map(int,input().split()))
a=[]
for i in h:
  a.append(abs(A-(T-i*0.006)))
print(a.index(min(a))+1)

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

ans = 0
temp = 1000000000000

for i in range(n):
  if temp > abs(a*1000-1000*t+h[i]*6):
    temp = abs(a*1000-1000*t+h[i]*6)
    ans = i+1

print(ans)

n = int(input())
t,a = map(int,input().split())
high = list(map(int,input().split()))
ans = []
for i in range(n):
    m = t - high[i]*0.006
    b = abs(m-a)
    ans.append(b)

print(ans.index(min(ans))+1)

N=int(input())
T,A=list(map(int,input().split()))
H=list(map(int,input().split()))
ans=1000000000000
for i in range(N):
    temp=T-H[i]*0.006
    if abs(temp-A)<ans:
        ans=abs(temp-A)
        p=i+1
print(p)


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

dt = 1000
ans = 0
for i in range(len(h)):
    tmp = float(t) - 0.006 * h[i]
    if dt > abs( a - tmp ):
        dt = abs( a - tmp )
        ans = i + 1

print(ans)


n = int(input())
t,a = map(int,input().split())
li = list(map(int,input().split()))
lis = []
for i in li:
    lis.append(abs((t-i*0.006)-a))
print(lis.index(min(lis))+1)

N = int(input())
T, A = map(float, input().split())
H = list(map(float, input().split()))

diff = [0 for i in range(N)]
for i in range(N):
  diff[i] = abs(A - (T-H[i]*0.006))
print(diff.index(min(diff)) + 1)

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

index = 0
ans = 10**10
cnt = 0
for i in range(n):
    temp = t-h[i]*0.006
    if ans > abs(a-temp):
        ans = abs(a-temp)
        cnt = i+1
print(cnt)

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

atlist = []
for i in h:
    atlist.append(abs(a - (t - i * 0.006)))

print(atlist.index(min(atlist)) + 1)

n = int(input())
t,a = map(float,input().split())
h = list(map(float,input().split()))
best = 10 ** 5
ans = -1
for i in range(n):
    tt = t - h[i] * 0.006
    best = min(best,abs(tt - a))
    if abs(a - tt) == best:
        ans = i
print(ans+1)

N = int(input())
T, A = list(map(int, input().split()))
H = list(map(int, input().split()))

avg_tmp = []

for i in range(N):
    avg_tmp.append(T*1000 - (H[i] * 6))
abs_tmp = []
for j in range(N):
    abs_tmp.append(abs(A*1000 - avg_tmp[j]))

ans = abs_tmp.index(min(abs_tmp)) + 1

print(ans)


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

temp = 10**6
res = 0
for i in range(n):
    dt = abs((t - al[i]*0.006)-a)
    if temp >= dt:
        temp = dt
        res = i+1

print(res)

N = int(input())
T, A = map(int, input().split())
H = map(int, input().split())

result = 0
min_avarage = float('inf')
for i, v in enumerate(H):
    if ((T-v*0.006) - A)**2 < min_avarage:
        min_avarage = ((T-v*0.006) - A)**2
        result = i + 1

print(result)

n = int(input())
t, a = map(int, input().split())
h = list(map(int, input().split()))
b = 10 ** 5
c = 0
for i in range(len(h)):
    if abs((t - h[i] * 0.006) - a) < b:
        b = abs((t - h[i] * 0.006) - a)
        c = i
print(c + 1)

n = int(input())
t,a = map(int,input().split())
h = list(map(int,input().split()))
ans = []
for i in range(n):
    ans.append([abs((t-h[i]*0.006)-a),i])
ans.sort()
print(ans[0][1]+1)

N = int(input())
T, A = list(map(int, input().split()))
X = list(map(int, input().split()))

s = 10000

for i in range(N):
  x = T - X[i] * 0.006
  if abs(A - x) < s:
    ans = i
    s = abs(A - x)
print((ans+1))


n = int(input())
t, a = list(map(int, input().split()))
b = [abs(a - (t - i * 0.006)) for i in list(map(int, input().split()))]
print((b.index(min(b)) + 1))


n = int(input())
t,a = map(int,input().split())
H = list(map(int,input().split()))
p = 9999
m = 9999
for i in range(n):
  tem = t - (H[i]*0.006)
  dist = abs(a-tem)
  if dist < m:
    p = H[i]
    m = dist
print(H.index(p)+1)

def calc(T, x):
  return T - x * 0.006

N = int(input())
T, A = map(int, input().split())
L = list(map(int, input().split()))
l = []
for i in L:
  l.append(abs(A - calc(T, i)))

mi = min(l)
print(l.index(mi)+1)

N=int(input())
T,A=map(float,input().split())
H=list(map(float,input().split()))
d=[]
for i in H:
  d.append(abs(A-(T-i*0.006)))
print(d.index(min(d))+1)

n=int(input())
t,a=map(int, input().split())  
h=list(map(int, input().split()))
kaiteki=[abs(t-i*0.006-a) for i in h]
print(kaiteki.index(min(kaiteki))+1)

N = int(input())
T, A = map(int, input().split())
H = list(map(int, input().split()))

cnt = []
for h in H:
    a = T-(h*0.006)
    c = abs(A-a)
    cnt.append(c)
    
ans = cnt.index(min(cnt))+1
print(ans)

n = int(input())
t,a = map(int, input().split())
h = list(map(int,input().split()))
ans = 1
temp = t-h[0]*0.006
for i in range(n):
    loc = t-h[i]*0.006
    if abs(a-loc)<abs(a-temp):
        temp = loc
        ans = i+1
print(ans)

n=int(input())
t,a=map(int,input().split())
h=list(map(int,input().split()))
x=10**6
total=0
for i in range(n):
    if abs(x-a)>abs(t-h[i]*0.006-a):
        x=t-h[i]*0.006
        total=i+1
print(total)

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

res = 0
val = 10**5
for i in range(n):
    if (v := abs(a - (t - h[i]*0.006))) < val:
        val = v
        res = i+1
print(res)


N = int(input())
T, A = list(map(int, input().split()))
H = list(map(int, input().split()))
tans = 1000
nans = 0
for i in range(N):
    ans = abs(A - (T - (H[i] * 0.006)))
    if ans == 0:
        print((i+1))
        return
    elif ans < tans:
        tans = ans
        nanns = i
print((nanns+1))


N = int(input())
T, A = map(int, input().split())
H = list(map(int, input().split()))

result_score = 10000
result_num = 0

for num, h in enumerate(H, 1):
    temp = T - h * 0.006
    score = abs(A-temp)

    if result_score >= score:
        result_score = score
        result_num = num

print(result_num)

n=int(input())
t,a=map(int, input().split())
h=list(map(int, input().split()))
palace=0
for i in range(n):
  if abs(a-t+h[i]*0.006)<abs(a-t+h[palace]*0.006):
    palace=i
print(palace+1)

N = int(input())
T,A = map(int,input().split())
H = list(map(int,input().split()))
now = 99999
ans = 0
for i in range(N):
  tem = T - H[i] * 0.006
  if abs(tem - A ) < now:
    now = abs(tem - A)
    ans = i+1
print(ans)

n = int(input())
t, a = (int(i) for i in input().split())
list_h = [int(i) for i in input().split()]
tmp = 999
ans = 0
for i in range(0, n):
    if tmp > abs((t - list_h[i] * 0.006) - a):
        tmp = abs((t - list_h[i] * 0.006) - a)
        ans = i
print(ans + 1)

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

z = [abs(t-x*0.006-a) for x in h]
print(z.index(min(z))+1)

n = int(input())
t,a = list(map(int,input().split()))
h = [int(x) for x in input().split()]

l = [t-x*0.006 for x in h]

mi = float('INF')
for i in range(n):
    ab = abs(a-l[i])
    if(mi>ab):
        mi = ab
        ans = i+1

print(ans)


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

ts = [abs(t - x*0.006 - a) for x in h]

now = ts[0]
ans = 1
for i in range(n):
    if ts[i] < now:
        ans = i+1
        now = ts[i]

print(ans)


n = int(input())
t, a = map(int, input().split())
h = list(map(int, input().split()))
ans, near = 0, 10**5
for i, high in enumerate(h):
	temp = abs(a - (t - high * 0.006))
	if near > temp:
		near = temp
		ans = i + 1
print(ans)

# author:  Taichicchi
# created: 11.10.2020 10:45:06

import sys

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

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

ls = [abs(a - (t - (h[i] * 0.006))) for i in range(n)]

m = min(ls)

ans = ls.index(m) + 1

print(ans)


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

num=10**5
ans=0

for i,j in enumerate(l):
  tem=abs(a-(t-j*0.006))
  num=min(num,tem)
  if num==tem:
    ans=i+1
    
print(ans)

n=int(input())
t,a=list(map(int,input().split()))
h=list(map(int,input().split()))
ans=[]
for i in range(n):
    temp=t-h[i]*0.006
    s=abs(temp-a)
    ans.append(s)
print((ans.index(min(ans))+1))


N = int(input())
T, A = map(int, input().split())
H = list(map(int, input().split()))

min_value = abs(A - (T - H[0] * 0.006))
min_index = 1
for i in range(1, len(H)):
    if(min_value > abs(A - (T - H[i] * 0.006))):
        min_value = abs(A - (T - H[i] * 0.006))
        min_index = i+1
print(min_index)

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

dt = 10000000
ans = 0
for i in range(len(h)):
    tmp = float(t) - 0.006 * h[i]
    if dt > abs( a - tmp ):
        dt = abs( a - tmp )
        ans = i + 1

print(ans)


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

ans = 0
diff = 100000
for (i, ele) in enumerate(arr):
    temp = t - ele * 0.006
    if abs(a - temp) < diff:
        diff = abs(a - temp)
        ans = i + 1

print(ans)

N = int(input())
T,A = list(map(int,input().split()))
H = list(map(int,input().split()))
tmp = 10000 
ans = 0
for i in range(N):
  x = T - H[i] * 0.006
  if A > x:
    b = A - x
  else:
    b = x - A
  if b < tmp:
    tmp = b
    ans = i + 1
print(ans)



N = int(input())
T, A = map(int, input().split())
H = list(map(int, input().split()))

h_c = (T - A) * 1000 / 6

res = 10**5
ind = 0

for i in range(N):
    if res > abs(H[i] - h_c):
        ind = i + 1
        res = abs(H[i] - h_c)

print(ind)

n=str(input())
t,a=list(map(int,input().split()))
h=list(map(int,input().split()))
d=1000
ans=0
for index,x in enumerate(h):
    if abs(a-(t-x*0.006))<d:
        d=abs(a-(t-x*0.006))
        ans=index+1
print(ans)


import sys

input = sys.stdin.readline


def main():
    N = int(input())
    T, A = [int(x) for x in input().split()]
    H = [int(x) for x in input().split()]

    ans = 0
    sa = float("inf")

    for i in range(N):
        tmp = sa
        sa = min(sa, abs(T - H[i] * 0.006 - A))
        if sa != tmp:
            ans = i + 1

    print(ans)


def __starting_point():
    main()

__starting_point()

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

x = t - l[0] * 0.006
tmp = []
for x in l:
    x = t - x * 0.006
    tmp.append(x)

ans = []

for z in tmp:
    y = a - z
    ans.append(abs(y))

print((ans.index(min(ans)) + 1))


N = int (input ())
T,A = map (int, input ().split ())
S = 1000000
l = [int (x) for x in input().split()]
for i in range (len(l)):
  s = abs((T-l[i]*0.006)-A)
  if s < S:
    S = s
    ans = i
print (ans+1)

import numpy as np

n = int(input())
t, a = map(int,input().split())
li = list(map(int, input().split())) #数値

t = t*1000
a = a*1000
npli = np.array(li)
npli = t-npli*6

res = npli[0]
res_num = 1
for i in range(n):
    # print(abs(res),abs(npli[i]),res_num)
    if abs(a-res) > abs(a-npli[i]):
        res = npli[i]
        res_num = i+1
print(res_num)

n = int(input())
t,a = map(int,input().split())
h = list(map(int,input().split()))
b = list(map(lambda h:abs(a-(t-h*0.006)),h))
print(b.index(min(b))+1)

n = int(input())
t, a = map(int, input().split())
h = list(map(int, input().split()))
tmp = []

for i in range(n):
    x = t - h[i] * 0.006
    if a >= x:
        TMP = a - x
        tmp.append(TMP)
    else:
        TMP = x - a
        tmp.append(TMP)

for i in range(n):
    if tmp[i] == min(tmp):
        print(i+1)

n = int(input())
t, a = list(map(int, input().split()))
h = list(map(int, input().split()))
a1 = []
a2 = []
for i in range(n):
    tt = abs((t - h[i]*0.006) - a)
    a1.append(tt)
    a2.append(i+1)
ans = {}
ans.update(list(zip(a1, a2)))
small = sorted(a1, reverse=False)[0]
print((ans[small]))


N = int(input())
T, A = list(map(int, input().split()))
H = list(map(int, input().split()))

index = 0
ans = 10**10
for i in range(N):
  tmp = T - 0.006*H[i]
  if ans > abs(A-tmp):
    ans = abs(A-tmp)
    index = i+1
print(index)


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

mypoints = []
for i in range(len(points)):
    mypoints.append(t - points[i] * 0.006)

subpoints = []
for j in range(len(points)):
    subpoints.append(abs(a - mypoints[j]))

print((subpoints.index(min(subpoints))+1))


def mapt(fn, *args):
    return tuple(map(fn, *args))


def Input():
    return mapt(int, input().split(" "))


def main():
    n = int(input())
    t, a = Input()
    h = Input()

    h = [t-i*0.006 for i in h]
    h = [abs(a-i) for i in h]
    min_h = min(h)

    print(h.index(min_h)+1)


main()

n = int(input())
t, a = map(int, input().split())
h = list(map(int, input().split()))
y = list(map(lambda x:abs((t-(x*0.006)) - a), h))
print(y.index(min(y))+1)

n=int(input())
t,a=map(int,input().split())
m=10000
h=list(map(int,input().split()))
for i in range(n):
  x=t-h[i]*0.006
  m=min(m,abs(x-a))

for i in range(n):
  if m==abs((t-h[i]*0.006)-a):
    print(1+i)

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

x = t - l[0] * 0.006
ans = []
for x in l:
    x = t - x * 0.006
    y = a - x
    ans.append(abs(y))

print((ans.index(min(ans)) + 1))


n = int(input())
t, a = map(int, input().split())
h = [int(s) for s in input().split()]

min_abs = 100000
index = 0
for i in range(n):
    temp = t - h[i] * 0.006
    if abs(a - temp) < min_abs:
        min_abs = abs(a - temp)
        index = i
print(index + 1)


url = "https://atcoder.jp//contests/abc113/tasks/abc113_b"

def main():
    input()
    t, a = list(map(int, input().split()))
    syuto = list(map(int, input().split()))
    tempture = []
    for s in syuto:
        tempture.append(abs(a - (t - s * 0.006)))
    print((tempture.index(min(tempture))+1))


def __starting_point():
    main()


__starting_point()

N = int(input())

T, A = map(int,input().split())
H = map(int,input().split())
candidates = list(H)
decide = []

for candidate in candidates:
    temparature = T - candidate * 0.006
    decide.append(abs(A-temparature))
# print(decide)
hope_place = (min(decide))
print(decide.index(hope_place)+1)

n = int(input())
T,A = map(int,input().split())
H = list(map(int,input().split()))
TH = []
for i in range(n):
  TH.append(abs(A-T+0.006*H[i]))
print(TH.index(min(TH))+1)

N=int(input())
T,A=list(map(int,input().split()))
H=list(map(int,input().split()))
k=0
for i in range(N):
    if abs(T-0.006*H[i]-A)<abs(T-0.006*H[k]-A):
        k=i
print((k+1))


n=int(input())
t,a=map(int,input().split())
h=list(map(int,input().split()))
def avg_tmp(t, x):
  return t- x*0.006
ans, ans_index = 10000000, 0
for i in range(n):
  if abs(avg_tmp(t, h[i]) -a) < abs(ans-a):
         ans = avg_tmp(t, h[i])
         ans_index = i+1
print(ans_index)

import numpy as np
N = int(input())
T, A = (int(x) for x in input().split())

result = [int(N) for N in input().split()]

list = []
for num in range(N):
    list.append(abs(T-0.006*result[num]-A))

m = np.argmin(list) + 1

print(m)

N = int(input())
T, A = map(int, input().split())
H = list(map(int, input().split()))

diff = 100000009
diff_id = 0
for i in range(N):
    if diff>abs(A-(T-H[i]*0.006)):
        diff = abs(A-(T-H[i]*0.006))
        diff_id = i

print(diff_id+1)        

N = int(input())
T, A = map(int, input().split())
H = [int(i) for i in input().split()]
temp = []

for i in H:
    temp.append(abs(A - (T - i * 0.006)))
min_ind = temp.index(min(temp))
print(min_ind+1)

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

diff = []
for height in h:
    temp = t - (height * 0.006)
    diff.append(abs(a - temp))

minimum = min(diff)
ans = diff.index(minimum) + 1

print(ans)


N = int(input())
T,A = map(int,input().split())
H = list(map(int,input().split()))

diff = []
for i in H:
	diff.append(abs(A-T+i*0.006))

diffmin = diff[0]
ans = 0
for i in range(N):
	if diffmin > diff[i]:
		diffmin = diff[i]
		ans = i
print(ans+1)

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

p=[]

for i in range(n):
  q=(t-0.006*h[i])
  p.append(abs(q-a))

print(p.index(min(p))+1)

N = int(input())
T, A = list(map(int, input().split()))
H = list(map(int, input().split()))

mn = 10000000
ans = 0
for i in range(N):
    now = T - H[i] * 0.006
    if abs(now - A) <= mn:
        mn = abs(now - A)
        ans = i
print((ans + 1))


def ave_ten(T,x):
    return T - x*0.006

N = int(input())
T,A = map(int, input().split())
li = list(map(int, input().split()))

min_ten = 9999999999

for i in range(len(li)):
    if abs(min_ten - A) > abs(ave_ten(T,li[i])-A):
        min_ten = ave_ten(T,li[i])
        min_in = i+1

print(min_in)

N = int(input())
T, A = map(int, input().split())
H = list(map(int, input().split()))

mini = float('inf')
res = 0

for i in range(len(H)):
    spot = T - H[i] * 0.006
    if abs(spot - A) < mini:
        mini = abs(spot - A)
        res = i+1

print(res)

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

ans=0
anst=10e7
for i,j in enumerate(h):
    avg=t-j*0.006
    if anst>abs(a-avg):
        anst=abs(a-avg)
        ans=i+1
print(ans)

n=int(input())
t,a = map(int,input().split())
H = list(map(int,input().split()))
ans = -1
h = 1000
for i in range(n):
  if abs(t-H[i]*0.006-a) < h:
    h = abs(t-H[i]*0.006-a)
    ans = i+1
print(ans)

N=int(input())
T,A=map(int,input().split())
H=list(map(int,input().split()))

l=[]
for i in range(N):
	l.append(abs(T-H[i]*0.006-A))
    
print(l.index(min(l))+1)

n=int(input())
t,a=list(map(int,input().split()))
h=[int(x) for x in input().split()]

ans=float('inf')
x=0
for i in range(n):
  now=t-h[i]*0.006
  if abs(now-a)<ans:
    ans=abs(now-a)
    x=i+1
print(x)


n = int(input())
t,a = map(int,input().split())
h = list(map(int, input().split()))
b = 10**9
for i in range(n):
    c = abs(a-(t-h[i]*0.006))
    if c<b:
        b=c
        d=i
print(d+1)

N = int(input())
T, A = list(map(int, input().split()))
H = [int(_) for _ in input().split()]

answer = 0
for i in range(len(H)):
    H[i] = abs(T - (H[i] * 0.006) - A)
    if H[answer] > H[i]:
        answer = i
print((answer + 1))


import numpy as np

def palace():
    
    N = int(input())
    T, A = np.array(input().split(), dtype="int")[:2]
    H = [int(i) for i in input().split()]
    
    min_dif = 10000
    place = 0
    for i in range(N):
        temp = T - H[i] *0.006
        dif = abs(A-temp)
        
        #誤差の最小値(→候補地も更新)
        if min_dif >= dif:
            min_dif = dif
            place = i+1
    
    print(place)
    
    
palace()

n = int(input())
t, a = map(int, input().split())
h = list(map(int, input().split()))
h = [abs((t - i * 0.006)- a) for i in h]
print(h.index(min(h)) + 1)

n = int(input())
t, a = map(int,input().split())
temp = list(map(int,input().split()))
ans = [1e5,1e6]
for i,j in enumerate(temp):
    if ans[1] > abs(a -(t - j * 0.006)):
        ans[0] = i+1
        ans[1] = abs(a -(t - j * 0.006))
print(ans[0])

N = input()
T, A = map(int, input().split())
H = list(map(int, input().split()))
min = 100000
count = 1
num = 0

for h in H:
    titen = T - h * 0.006
    s = abs(A - titen)
    if s < min:
        min = s
        num = count
    count += 1

print(num)

n = int(input())
t, a = list(map(int, input().split()))
points = list(map(int, input().split()))
# print(points)

mypoints = []
for i in range(len(points)):
    mypoints.append(t - points[i] * 0.006)
# print(mypoints)

subpoints = []
for j in range(len(points)):
    subpoints.append(abs(a - mypoints[j]))

# print(subpoints)
# print(min(subpoints))
print((subpoints.index(min(subpoints))+1))


n=int(input())
t,a=map(int,input().split())
h=list(map(int,input().split()))
ans=0
res=float('inf')
for i in range(n):
  if abs(t-h[i]*float(0.006)-a)<res:
    res=abs(t-h[i]*float(0.006)-a)
    ans=i+1
print(ans)

from typing import List


def answer(n: int, t: int, a: int, hs: List[int]) -> int:
    import sys
    
    result = 0
    temperature_difference = sys.maxsize
    
    for i, h in enumerate(hs, start=1):
        temp = abs(a - (t - h * 0.006))
        if temp < temperature_difference:
            temperature_difference = temp
            result = i

    return result


def main():
    n = int(input())
    t, a = map(int, input().split())
    hs = list(map(int, input().split()))
    print(answer(n, t, a, hs))


def __starting_point():
    main()
__starting_point()

N = int(input())
T,A = map(int,input().split())
H = list(map(int,input().split()))
HT = [0]*N

for i in range(len(H)):
    HT[i] = T-(H[i]*0.006)

sa = [float('inf')]*N
for i in range(N):
     sa[i] = float(abs(A - HT[i]))

print(sa.index(min(sa))+1)

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

min_abs = 10**6
ans = -1
for i, h in enumerate(heights):
    t = tempre - 0.006 * h
    if abs(t-a) < min_abs:
        ans = i+1
        min_abs = abs(t-a)
print(ans)



N = int(input())
T,A = map(int,input().split())
H = list(map(int,input().split()))

tmp = float("inf")
ans = 0

for i in range(N):
  num = abs(A - (T - H[i] * 0.006))
  if tmp > num:
    ans = i + 1
    tmp = num

print(ans)