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: EASY

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


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


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) = 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):
	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())
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) = 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))
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) = 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 = 100000000.0
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) = 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())
temp = list(map(int, input().split()))
ans = [100000.0, 1000000.0]
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) = 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)