output_description: Print the index of the place where the palace should be built.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      T A
      H_1 H_2 ... H_N
attempt: #!usr/bin/env python3
  from collections import defaultdict
  from collections import deque
  from heapq import heappush, heappop
  import sys
  import math
  import bisect
  import random
  import itertools
  
  sys.setrecursionlimit(10**5)
  stdin = sys.stdin
  
  
  def LI():
      return list(map(int, stdin.readline().split()))
  
  
  def LF():
      return list(map(float, stdin.readline().split()))
  
  
  def LI_():
      return list(map(lambda x: int(x) - 1, stdin.readline().split()))
  
  
  def II():
      return int(stdin.readline())
  
  
  def IF():
      return float(stdin.readline())
  
  
  def LS():
      return list(map(list, stdin.readline().split()))
  
  
  def S():
      return list(stdin.readline().rstrip())
  
  
  def IR(n):
      return [II() for _ in range(n)]
  
  
  def LIR(n):
      return [LI() for _ in range(n)]
  
  
  def FR(n):
      return [IF() for _ in range(n)]
  
  
  def LFR(n):
      return [LI() for _ in range(n)]
  
  
  def LIR_(n):
      return [LI_() for _ in range(n)]
  
  
  def SR(n):
      return [S() for _ in range(n)]
  
  
  def LSR(n):
      return [LS() for _ in range(n)]
  
  
  mod = 1000000007
  inf = float("INF")
  
  
  # A
  def A():
      x, y = LI()
      print(x + y // 2)
      return
  
  
  # B
  def B():
      II()
      a, t = LI()
      h = LI()
      ans = [0, inf]
      for num, i in enumerate(h):
          if ans[1] > abs(t - a - i * 0.006):
              ans = [num, abs(t - a - i * 0.006)]
      print(ans[0] + 1)
      return
  
  
  # C
  def C():
      n, m = LI()
      py = LIR(m)
      pya = py[::1]
      py.sort(key=lambda x: x[1])
      city = [1 for i in range(n)]
      dicity = {}
      for p, y in py:
          dicity[(p, y)] = city[p - 1]
          city[p - 1] += 1
      for p, y in pya:
          a = "00000" + str(p)
          a = a[-6:]
          b = "00000" + str(dicity[(p, y)])
          b = b[-6:]
          print(a + b)
  
      return
  
  
  # D
  def D():
      return
  
  
  # Solve
  if __name__ == "__main__":
      B()
  
problem_description: Statement
  
  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.
samples: [{"input": "2\n    12 5\n    1000 2000", "output": "1\n    \n\n  * The average temperature of Place 1 is 12-1000 \\times 0.006=6 degrees Celsius.\n  * The average temperature of Place 2 is 12-2000 \\times 0.006=0 degrees Celsius.\n\nThus, the palace should be built at Place 1.\n\n* * *"}, {"input": "3\n    21 -11\n    81234 94124 52141", "output": "3"}]