For years, the Day of city N was held in the most rainy day of summer. New mayor decided to break this tradition and select a not-so-rainy day for the celebration. The mayor knows the weather forecast for the $n$ days of summer. On the $i$-th day, $a_i$ millimeters of rain will fall. All values $a_i$ are distinct.

The mayor knows that citizens will watch the weather $x$ days before the celebration and $y$ days after. Because of that, he says that a day $d$ is not-so-rainy if $a_d$ is smaller than rain amounts at each of $x$ days before day $d$ and and each of $y$ days after day $d$. In other words, $a_d < a_j$ should hold for all $d - x \le j < d$ and $d < j \le d + y$. Citizens only watch the weather during summer, so we only consider such $j$ that $1 \le j \le n$.

Help mayor find the earliest not-so-rainy day of summer.


-----Input-----

The first line contains three integers $n$, $x$ and $y$ ($1 \le n \le 100\,000$, $0 \le x, y \le 7$) — the number of days in summer, the number of days citizens watch the weather before the celebration and the number of days they do that after.

The second line contains $n$ distinct integers $a_1$, $a_2$, ..., $a_n$ ($1 \le a_i \le 10^9$), where $a_i$ denotes the rain amount on the $i$-th day.


-----Output-----

Print a single integer — the index of the earliest not-so-rainy day of summer. We can show that the answer always exists.


-----Examples-----
Input
10 2 2
10 9 6 7 8 3 2 1 4 5

Output
3

Input
10 2 3
10 9 6 7 8 3 2 1 4 5

Output
8

Input
5 5 5
100000 10000 1000 100 10

Output
5



-----Note-----

In the first example days $3$ and $8$ are not-so-rainy. The $3$-rd day is earlier.

In the second example day $3$ is not not-so-rainy, because $3 + y = 6$ and $a_3 > a_6$. Thus, day $8$ is the answer. Note that $8 + y = 11$, but we don't consider day $11$, because it is not summer.

Source: codeforces | Difficulty: EASY
Tags: Implementation


Solutions:
(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
for i in range(n):
	if l[i] <= min(l[max(0, i - x):i + y + 1]):
		print(i + 1)
		exit()


import sys
input = sys.stdin.readline
(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(n):
	if a[i] <= min(a[max(i - x, 0):i + 1]) and a[i] <= min(a[i:min(i + y + 1, n)]):
		print(i + 1)
		exit(0)


_in = input()
(n, x, y) = (int(_in.strip().split()[0]), int(_in.strip().split()[1]), int(_in.strip().split()[2]))
_in = input()
_in = _in.strip().split()
arr = [int(val) for val in _in]
for i in range(n):
	idx = i - 1
	flag = 0
	while idx >= 0 and x > 0:
		if arr[idx] <= arr[i]:
			flag = 1
		if idx == i - x:
			break
		idx = idx - 1
	if flag == 1:
		continue
	idx = i + 1
	flag = 0
	while idx < n and y > 0:
		if arr[idx] <= arr[i]:
			flag = 1
		if idx == i + y:
			break
		idx = idx + 1
	if flag == 1:
		continue
	ans = i + 1
	break
print(ans)


import os
import sys
import bisect
from math import gcd, ceil
from heapq import heapify, heappop, heappush
from io import BytesIO, IOBase

def main():
	(n, x, y) = map(int, input().split())
	mx = 10 ** 9 + 1
	a = list(map(int, input().split()))
	minx = set()
	minx.add(mx)
	for i in range(n):
		miny = set()
		miny.add(mx)
		for j in range(i + 1, min(n, i + y + 1)):
			miny.add(a[j])
		minix = min(minx)
		miniy = min(miny)
		if a[i] < minix and a[i] < miniy:
			print(i + 1)
			return
		minx.add(a[i])
		if i - x >= 0:
			minx.remove(a[i - x])
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = lambda s: self.buffer.write(s.encode()) if self.writable else None

	def read(self):
		if self.buffer.tell():
			return self.buffer.read().decode('ascii')
		return os.read(self._fd, os.fstat(self._fd).st_size).decode('ascii')

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline().decode('ascii')

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

def print(*args, sep=' ', end='\n', file=sys.stdout, flush=False):
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(end)
	if flush:
		file.flush()
(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
sys.setrecursionlimit(10000)
main()


import sys
input = sys.stdin.readline
I = lambda : list(map(int, input().split()))
(n, x, y) = I()
l = I()
an = 0
c = 0
for i in range(n):
	le = i - x
	r = i + y
	f = 0
	for j in range(le, r + 1):
		if j != i and 0 <= j <= n - 1:
			if l[i] >= l[j]:
				f = 1
				break
	if f == 0:
		an = i + 1
		break
print(an)


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
for i in range(n):
	f = 1
	for j in range(i - x, i - 1):
		if j >= 0 and l[j] <= l[i]:
			f = 0
			break
	for j in range(i + 1, i + y + 1):
		if j < n and l[i] >= l[j]:
			f = 0
			break
	if f:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
A = [int(i) for i in input().split()]
i = 0
flag = False
while i < n:
	pre = A[i]
	if i < x:
		Bef = A[:i]
	else:
		Bef = A[i - x:i]
	if i + y + 1 >= n:
		Aft = A[i + 1:]
	else:
		Aft = A[i + 1:i + 1 + y]
	flag1 = True
	flag2 = True
	for k in range(len(Bef)):
		if Bef[k] <= pre:
			flag1 = False
			break
	for k in range(len(Aft)):
		if Aft[k] <= pre:
			flag2 = False
			break
	if flag1 and flag2:
		print(i + 1)
		break
	else:
		i += 1


(n, x, y) = map(int, input().split(' '))
rain = [int(a) for a in input().split(' ')]
flag = True
if n is 1 or y is 0:
	print(1)
	flag = False
if n is 2 and y is not 0:
	if rain[0] > rain[1]:
		print(2)
	else:
		print(1)
	flag = False
for i in range(n):
	if flag is False:
		continue
	if i is 0:
		if min(rain[1:min(i + y + 1, n)]) > rain[0]:
			print(1)
			break
	elif i is n - 1:
		if min(rain[max(0, i - x):n - 1]) > rain[i]:
			print(n)
			break
	elif min(rain[max(0, i - x):max(1, i)]) > rain[i] and min(rain[min(i + 1, n - 1):min(i + y + 1, n)]) > rain[i]:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
arr = list(map(int, input().split()))
for i in range(n):
	if arr[i] <= min(arr[max(0, i - x):i + y + 1]):
		i += 1
		print(i)
		break


(n, x, y) = map(int, input().split())
s = input()
s = (str(10 ** 10) + ' ') * x + s + (' ' + str(10 ** 10)) * y
a = list(map(int, s.split()))
ans = 0
k = x
while ans == 0:
	if a[k] == min(a[k - x:k + y + 1]):
		ans = k - x + 1
	else:
		k += 1
print(ans)


(n, x, y) = map(int, input().split())
a = [int(x) for x in input().split()]
for i in range(n):
	flag = True
	j = max(0, i - x)
	while j <= min(n - 1, i + y):
		if j == i:
			j += 1
			continue
		if a[j] <= a[i]:
			flag = False
			break
		j += 1
	if flag:
		print(i + 1)
		break


(n, x, y) = input().split(' ')
n = int(n)
x = int(x)
y = int(y)
arr = list(map(int, input().split(' ')))
flag = 0
for i in range(n):
	flag = 0
	for j in range(1, x + 1):
		if i - j < 0:
			flag = 0
			break
		if arr[i - j] < arr[i]:
			flag = 1
			break
	if flag == 0:
		for j in range(1, y + 1):
			if i + j >= n:
				flag = 0
				break
			if arr[i + j] < arr[i]:
				flag = 1
				break
	if flag == 0:
		print(i + 1)
		break


(a, b, c) = map(int, input().split())
d = list(map(int, input().split()))
d = [max(d) + 1] * 7 + d + [max(d) + 1] * 7
print([i - 6 for i in range(7, a + 7) if min(d[i - b:i + 1]) >= d[i] <= min(d[i:i + c + 1])][0])


import sys
input = sys.stdin.readline
l = list(map(int, input().split()))
l1 = list(map(int, input().split()))
n = l[0]
x = l[1]
y = l[2]
for i in range(n):
	x1 = x
	left = i - 1
	f_l = True
	while x1 != 0 and left >= 0:
		if l1[left] <= l1[i]:
			f_l = False
		left -= 1
		x1 -= 1
	y1 = y
	right = i + 1
	f_r = True
	while y1 != 0 and right <= n - 1:
		if l1[right] <= l1[i]:
			f_r = False
		right += 1
		y1 -= 1
	if f_l == True and f_r == True:
		print(i + 1)
		break


import sys

def ints():
	return list(map(int, sys.stdin.readline().strip().split()))
tc = 1
while tc:
	tc -= 1
	(n, a, b) = map(int, input().split())
	ls = ints()
	for i in range(n):
		ans = True
		for j in range(i - 1, max(-1, i - a), -1):
			if ls[i] >= ls[j]:
				ans = False
				break
		if ans:
			for j in range(i + 1, min(n - 1, i + b) + 1):
				if ls[i] >= ls[j]:
					ans = False
					break
		if ans:
			print(i + 1)
			break


def city_day(n, s, a, b):
	for i in range(n):
		y = s[max(0, i - a):min(i + b + 1, n)]
		target = s[i]
		y.sort()
		if y[0] == target:
			return i + 1
(n, r, t) = list(map(int, input().split()))
v = list(map(int, input().split()))
print(city_day(n, v, r, t))


(n, x, y) = [int(x) for x in input().split(' ')]
ent = input().split(' ')
for i in range(n):
	ent[i] = int(ent[i])
pos = 0
while True:
	resp = 'yeap'
	for i in range(x):
		if pos - i - 1 < 0 or pos < 0 or pos > len(ent) - 1:
			break
		if ent[pos - i - 1] <= ent[pos]:
			resp = 'nope'
			break
	if resp != 'nope':
		for i in range(y):
			if pos + i + 1 > len(ent) - 1 or pos < 0 or pos > len(ent) - 1:
				break
			if ent[pos + i + 1] <= ent[pos]:
				resp = 'nope'
				break
	if resp == 'nope':
		pos += 1
		resp = 'yeap'
	else:
		break
if pos >= len(ent):
	print(pos)
else:
	print(pos + 1)


(n, x, y) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
for i in range(n):
	if a[i] == min(a[max(0, i - x):min(n, i + y + 1)]):
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
aa = list(map(int, input().split()))
for i in range(n):
	good = True
	for l in range(max(i - x, 0), i):
		if aa[l] <= aa[i]:
			good = False
			break
	if not good:
		continue
	for r in range(i + 1, min(i + y + 1, n)):
		if aa[r] <= aa[i]:
			good = False
			break
	if good:
		print(i + 1)
		exit(0)


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
for i in range(n):
	ll = i - x if i - x > 0 else 0
	ul = i + y + 1 if i + y < n else n
	flag = 1
	for j in range(ll, ul):
		if l[j] < l[i]:
			flag = 0
	if flag:
		print(i + 1)
		break


(n, x, y) = map(int, input().strip().split())
nums = [int(i) for i in input().strip().split()]
for i in range(n):
	has = True
	for j in range(x + 1 if i - x >= 0 else i):
		if nums[i] > nums[i - j]:
			has = False
			break
	if has:
		for k in range(y + 1 if i + y < n else n - i):
			if nums[i] > nums[i + k]:
				has = False
				break
	if has:
		print(i + 1)
		break


(n, a, b) = [int(j) for j in input().split()]
ds = [int(i) for i in input().split()]
il = 0
ir = 0
m = len(ds)
for i in range(m):
	ini = i - a if i - a > 0 else 0
	end = i + b + 1 if i + b + 1 < m else m
	isDay = True
	for j in range(ini, end):
		if j != i and ds[j] < ds[i]:
			isDay = False
			break
	if isDay:
		print(i + 1)
		break


(n, x, y) = [int(x) for x in input().split()]
arr = []
arr.append(-1)
a = [int(x) for x in input().split()]
arr += a
for i in range(1, len(arr)):
	l = i - x
	r = i + y
	if r > n:
		r = n
	if l < 1:
		l = 1
	la = arr[l:i]
	ra = arr[i + 1:r + 1]
	lb = False
	rb = False
	if len(la) == 0:
		lb = True
	else:
		lt = min(la)
		if lt > arr[i]:
			lb = True
	if len(ra) == 0:
		rb = True
	else:
		rt = min(ra)
		if rt > arr[i]:
			rb = True
	if lb and rb:
		print(i)
		break


from sys import stdin
(n, x, y) = map(int, stdin.readline().strip().split())
s = list(map(int, stdin.readline().strip().split()))
for i in range(n):
	t = True
	for j in range(i - 1, max(-1, i - x - 1), -1):
		if s[j] < s[i]:
			t = False
	for j in range(i + 1, min(n, i + y + 1)):
		if s[j] < s[i]:
			t = False
	if t:
		print(i + 1)
		break


from sys import stdin
input = []
for i in stdin:
	input.append([int(j) for j in i.split()])
n = input[0][0]
x = input[0][1]
y = input[0][2]
arr = input[1]
for i in range(n):
	candidate = True
	left = max(0, i - x)
	right = min(n - 1, i + y)
	for j in range(left, i):
		if arr[j] < arr[i]:
			candidate = False
			break
	if candidate:
		for j in range(i + 1, right + 1):
			if arr[j] < arr[i]:
				candidate = False
				break
	if candidate:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))[:n]
for i in range(n):
	if i < x:
		if l[i] == min(l[0:i + y + 1]):
			print(i + 1)
			break
	elif i < n - y and i >= x:
		if l[i] == min(l[i - x:i + y + 1]):
			print(i + 1)
			break
	elif l[i] == min(l[i - x:n]):
		print(i + 1)
		break


def find_not_so_rainy(a, x, y):
	i = 0
	while a[i] > min(a[max(0, i - x):i + y + 1]):
		i += 1
	return i + 1
(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
print(find_not_so_rainy(a, x, y))


(summer, bef, aft) = input().split()
summer = int(summer)
bef = int(bef)
aft = int(aft)
water = list(map(int, input().split()))
for x in range(summer):
	if water[x] == min(water[x:x + aft + 1]) and water[x] == min(water[max(0, x - bef):max(0, x + 1)]):
		print(x + 1)
		break


(n, x, y) = map(int, input().split())
a = [int(i) for i in input().split()]
for i in range(n):
	ok = True
	for j in range(max(i - x, 0), i):
		if a[i] >= a[j]:
			ok = False
			break
	for j in range(i + 1, min(i + y + 1, n)):
		if a[i] >= a[j]:
			ok = False
			break
	if ok == True:
		print(i + 1)
		exit()


b = []

def ssm(i, x, y):
	global b
	for k in range(x, y):
		if b[k] < b[i]:
			return False
	return True

def main():
	a = []
	a = input().split(' ')
	b = input().split(' ')
	for item in b:
		item = int(item)
	n = int(a[0])
	x = int(a[1])
	y = int(a[2])
	for i in range(0, len(b)):
		fg = 1
		for j in range(max(i - x, 0), min(i + y + 1, n)):
			if int(b[j]) < int(b[i]):
				fg = 0
				break
		if fg == 1:
			print(i + 1)
			break
main()


(n, x, y) = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(n):
	k = a[i]
	for j in range(max(0, i - x), min(i + y + 1, n)):
		if j == i:
			continue
		if a[j] <= k:
			break
	else:
		print(i + 1)
		return


a = input()
a = a.split()
b = input()
b = b.split()
for i in range(len(a)):
	a[i] = int(a[i])
for i in range(len(b)):
	b[i] = int(b[i])
daylength = a[0]
x = a[1]
y = a[2]
for i in range(len(b)):
	truth = 1
	for j in range(i - x, i):
		if j >= 0 and b[i] > b[j]:
			truth = 0
	for j in range(i, i + y + 1):
		if j < daylength and b[i] > b[j]:
			truth = 0
	if truth == 1:
		print(i + 1)
		break


R = lambda : map(int, input().split())
(n, x, y) = R()
a = [*R()]
i = 0
while a[i] >= min(a[max(0, i - x):i] + a[i + 1:i + y + 1] + [1 << 30]):
	i += 1
print(i + 1)


from sys import stdin
inp = list(map(int, stdin.read().split()))
(n, x, y) = inp[:3]
a = inp[3:]
day = 0
near = a[:y]
for i in range(n):
	if i - x - 1 >= 0:
		near.pop(0)
	if i + y < n:
		near.append(a[i + y])
	if a[i] == min(near):
		print(i + 1)
		break


import sys
input = sys.stdin.readline
(n, x, y) = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(n):
	minimum = A[i]
	for j in range(i, max(-1, i - x + 1), -1):
		minimum = min(A[j], minimum)
	for j in range(i, min(n, i + y + 1)):
		minimum = min(A[j], minimum)
	if A[i] == minimum:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for d in range(n):
	if d < x:
		temp = a[d]
		l = a[:d + y + 1]
		l.sort()
		if l[0] == temp:
			print(d + 1)
			break
	elif d + y >= n:
		temp = a[d]
		l = a[d - x:]
		l.sort()
		if l[0] == temp:
			print(d + 1)
			break
	else:
		temp = a[d]
		l = a[d - x:d + y + 1]
		l.sort()
		if l[0] == temp:
			print(d + 1)
			break


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
mod = int(pow(10, 9) + 7)
mod2 = 998244353

def data():
	return sys.stdin.readline().strip()

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def L():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
try:
	sys.stdin = open('input.txt', 'r')
except:
	pass
(n, x, y) = L()
A = L()
A = [10 ** 10] * x + A + [10 ** 10] * y
for i in range(x, x + n):
	if min(A[i - x:i + y + 1]) == A[i]:
		print(i - x + 1)
		exit()


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(n):
	ans = True
	for j in range(x):
		if i - j - 1 < 0:
			break
		if a[i - j - 1] < a[i]:
			ans = False
			break
	if not ans:
		continue
	for j in range(y):
		if i + j + 1 > n - 1:
			break
		if a[i + j + 1] < a[i]:
			ans = False
			break
	if ans:
		print(i + 1)
		exit()
	else:
		continue


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(n):
	f = 0
	left = max(0, i - x)
	right = min(n - 1, i + y)
	for j in range(left, right + 1):
		if a[i] != a[j]:
			if a[i] >= a[j]:
				f = 1
				break
	if f == 0:
		print(i + 1)
		break


(n, x, y) = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(0, n):
	if max(0, i - x) < i:
		m1 = min(a[max(0, i - x):i])
	else:
		m1 = 10 ** 9 + 1
	if i + 1 < min(i + y, n) + 1 and i + 1 < n:
		m2 = min(a[i + 1:min(i + y, n - 1) + 1])
	else:
		m2 = 10 ** 9 + 1
	if a[i] < m1 and a[i] < m2:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
index = 0
while index < n:
	result = True
	if index < x and index > 0:
		for i in range(0, index):
			if l[i] - l[index] < 0:
				result = False
				break
	elif index >= x:
		for i in range(index - x, index):
			if l[i] - l[index] < 0:
				result = False
				break
	if result:
		if index < n - y:
			for i in range(index + 1, index + y + 1):
				if l[i] - l[index] < 0:
					result = False
					break
		elif index >= n - y:
			for i in range(index + 1, n):
				if l[i] - l[index] < 0:
					result = False
					break
	if result:
		break
	index += 1
print(index + 1)


(n, x, y) = list(map(int, input().split()))[:3]
a = list(map(int, input().split()))
for i in range(len(a)):
	tmp = a[max(i - x, 0):i] + a[i + 1:min(i + y + 1, n)]
	if len(tmp) == 0 or a[i] < min(tmp):
		print(i + 1)
		break


def findNotSoRainyDay(n, x, y, a):
	for i in range(n):
		flag = True
		l = i - x
		r = i + y
		if l < 0:
			l = 0
		if r >= n:
			r = n - 1
		for j in range(l, i):
			if a[j] < a[i]:
				flag = False
				break
		for j in range(i + 1, r + 1):
			if a[j] < a[i]:
				flag = False
				break
		if flag:
			return i
(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
print(findNotSoRainyDay(n, x, y, a) + 1)


def fastio():
	import sys
	from io import StringIO
	from atexit import register
	global input
	sys.stdin = StringIO(sys.stdin.read())
	input = lambda : sys.stdin.readline().rstrip('\r\n')
	sys.stdout = StringIO()
	register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()
MOD = 10 ** 9 + 7
I = lambda : list(map(int, input().split()))
(n, x, y) = I()
l = I() + [MOD] * 7
for i in range(n):
	for j in range(max(0, i - x), i + y + 1):
		if j == i:
			continue
		if l[j] < l[i]:
			break
	else:
		print(i + 1)
		exit()


def int_multiple():
	return [int(c) for c in input().split()]

def int_single():
	return int(input())

def str_multiple():
	return [c for c in input().split()]

def str_single():
	return input()
(n, x, y) = int_multiple()
a = int_multiple()
a = [10 ** 9] * x + a + [10 ** 9] * y
window = x + y + 1
res = 0
for i in range(x, n + x + y + 1):
	if min(a[i - x:i + y + 1]) == a[i]:
		res = i - x + 1
		break
print(res)


from math import *
from collections import *
from itertools import *
from functools import *
from random import *

def getl(t=int):
	return [t(x) for x in input().split()]

def get(t=int):
	return t(input())
alphabet = [chr(x) for x in range(ord('a'), ord('z') + 1)]
alnum = lambda x: ord(x) - ord('a')

def main():
	(n, x, y) = getl()
	a = getl()
	for i in range(n):
		cl = []
		for j in range(i - x, i + y + 1):
			if 0 <= j < n and j != i:
				cl.append(a[j])
		if len(cl) == 0 or min(cl) > a[i]:
			print(i + 1)
			return
main()


(n, x, y) = map(int, input().split())
a = [int(i) for i in input().split()]
for i in range(n):
	k = a[i]
	t = True
	for j in range(max(0, i - x), min(i + y + 1, n)):
		if k > a[j]:
			t = False
			break
	if t:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
lst = list(map(int, input().split()))
for i in range(n):
	test = 0
	for j in range(1, x + 1):
		if i >= j:
			if lst[i] > lst[i - j]:
				test = 1
				break
	if test != 1:
		for j in range(1, y + 1):
			if i + j < n:
				if lst[i] > lst[i + j]:
					test = 1
					break
	if test == 0:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
fallout = list(map(int, input().split()))
if n < x or n < y:
	print(fallout.index(min(fallout)) + 1)
else:
	left = set(fallout[:0])
	right = set(fallout[1:y + 1])
	for i in range(n):
		min_left = min(left) if len(left) > 0 else 1000000000.0 + 1
		min_right = min(right) if len(right) > 0 else 1000000000.0 + 1
		if fallout[i] < min_left and fallout[i] < min_right:
			print(i + 1)
			break
		else:
			left.add(fallout[i])
			right.remove(fallout[i + 1])
			if i + y + 1 < n:
				right.add(fallout[i + y + 1])
			if i - x >= 0:
				left.remove(fallout[i - x])


(n, x, y) = map(int, input().split())
lis = list(map(int, input().split()))
for i in range(n):
	a = lis[max(i - x, 0):i]
	b = lis[i + 1:min(i + y + 1, n)]
	if len(a) == len(b) == 0:
		print(i + 1)
		break
	if len(a) == 0:
		if min(b) > lis[i]:
			print(i + 1)
			break
		continue
	if len(b) == 0:
		if min(a) > lis[i]:
			print(i + 1)
			break
		continue
	if min(min(a), min(b)) > lis[i]:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
flag = False
for i in range(n):
	tmp = a[i]
	f = True
	for j in range(i + 1, min(i + y + 1, n)):
		if a[j] <= tmp:
			f = False
	for j in range(max(0, i - x), i):
		if a[j] <= tmp:
			f = False
	if f:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
preLeft = -1
preRight = -1
l = 0
r = 0
c = 0
c2 = 0
idex = -1
i = 0
while i < n:
	left = max(0, i - x)
	right = min(n - 1, i + y)
	p = 1
	for j in range(i - 1, left - 1, -1):
		if a[i] > a[j]:
			p = 0
			break
	if p:
		for j in range(i + 1, right + 1):
			if a[i] > a[j]:
				p = 0
				break
	if p:
		print(i + 1)
		break
	else:
		i += 1


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
be = []
af = []
for i in range(1, min(n, y + 1)):
	af.append(a[i])
for i in range(n):
	if (not be or min(be) > a[i]) and (not af or min(af) > a[i]):
		print(i + 1)
		exit(0)
	if i >= x and x > 0:
		be.pop(0)
	be.append(a[i])
	af.pop(0)
	if i + y + 1 < n and y > 0:
		af.append(a[i + y + 1])


def checkx(ind, arr, x):
	var = 1
	for i in range(ind - 1, ind - 1 - x, -1):
		if arr[ind] > arr[i]:
			var = 0
			break
	return var

def checky(ind, arr, y):
	var = 1
	for i in range(ind + 1, ind + y + 1):
		if arr[ind] > arr[i]:
			var = 0
			break
	return var
(n, x, y) = map(int, input().split())
arr = [int(j) for j in input().split()]
arr = [10 ** 10] * 7 + arr + [10 ** 10] * 7
for i in range(7, n + 7):
	if checkx(i, arr, x) == 1 and checky(i, arr, y) == 1:
		ans = i
		break
print(ans - 6)


def is_not_so_rainy(d, A, x, y, n):
	ans = True
	for i in range(max(0, d - x), min(n, d + y + 1)):
		if i != d and A[i] <= A[d]:
			ans = False
	return ans
array = input()
A = [int(x) for x in array.split()]
(n, x, y) = (A[0], A[1], A[2])
array = input()
A = [int(x) for x in array.split()]
found = False
ans = 0
for d in range(n):
	if found == False:
		if is_not_so_rainy(d, A, x, y, n):
			found = True
			ans = d
			break
print(ans + 1)


from sys import *
from math import *
(n, x, y) = map(int, stdin.readline().split())
a = list(map(int, stdin.readline().split()))
for i in range(n):
	x1 = min(i, x)
	y1 = min(n - i - 1, y)
	a1 = a[i - x1:i + y1 + 1]
	m = min(a1)
	if a[i] == m:
		f = 1
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
ch = 0
for i in range(len(a)):
	for j in range(i, max(i - x - 1, 0), -1):
		if j == i:
			continue
		if a[j] < a[i]:
			ch = 1
			break
	if ch == 0 and i + 1 < n:
		for j in range(i + 1, min(i + y + 1, n)):
			if a[j] < a[i]:
				ch = 1
				break
	if ch == 0:
		print(i + 1)
		break
	ch = 0


import sys
from collections import defaultdict
input = sys.stdin.readline

def main():
	(n, x, y) = map(int, input().split())
	a = list(map(int, input().split()))
	res = -1
	for i in range(n):
		ok = True
		for j in range(1, x + 1):
			if i - j >= 0 and a[i] > a[i - j]:
				ok = False
				break
		if ok:
			for j in range(1, y + 1):
				if i + j < n and a[i] > a[i + j]:
					ok = False
					break
		if ok:
			res = i + 1
			break
	print(res)
main()


def check(lst, i):
	x = y = 0
	if i - b < 0:
		x = 0
	else:
		x = i - b
	if lst[i] == min(lst[x:i + c + 1]):
		return True
	else:
		False

def solve(lst):
	for i in range(a):
		if check(lst, i):
			print(i + 1)
			return
(a, b, c) = list(map(int, input().split()))
lst = list(map(int, input().split()))
solve(lst)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for (i, A) in enumerate(a):
	if min(a[max(i - x, 0):i + y + 1]) == A:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
lst = list(map(int, input().split()))
for (i, b) in enumerate(lst):
	(k, l) = (0, 0)
	for (j, a) in enumerate(lst[max(0, i - x):i]):
		if b > a:
			k = 1
			break
	for (j, a) in enumerate(lst[i + 1:min(n, i + y + 1)]):
		if b > a:
			l = 1
			break
	if k == 0 and l == 0:
		print(i + 1)
		break


def rainyDay(n, x, y):
	for i in range(len(n)):
		if i - x >= 0 and i + y + 1 <= len(n):
			if n[i] == min(n[i - x:i + y + 1]):
				return i
		elif i - x >= 0 and i + y + 1 >= len(n):
			if n[i] == min(n[i - x:len(n)]):
				return i
		elif n[i] == min(n[0:i + y + 1]):
			return i
(nums, x, y) = map(int, input().split())
n = [int(i) for i in input().split()]
print(rainyDay(n, x, y) + 1)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
mod2 = 998244353
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def IF(c, t, f):
	return t if c else f

def YES(c):
	return IF(c, 'YES', 'NO')

def Yes(c):
	return IF(c, 'Yes', 'No')

def main():
	t = 1
	rr = []
	for _ in range(t):
		(n, x, y) = LI()
		a = LI()
		for i in range(n):
			t = a[i]
			ok = 1
			for j in range(max(0, i - x), min(n, i + y + 1)):
				if a[j] < t:
					ok = 0
					break
			if ok:
				rr.append(i + 1)
				break
	return JA(rr, '\n')
print(main())


(n, x, y) = input().split()
n = int(n)
x = int(x)
y = int(y)
a = []
inp = input().split()
for i in inp:
	a.append(int(i))
ans = 0
for i in range(n):
	f1 = 0
	f2 = 0
	yy = i - x
	while yy < 0:
		yy += 1
	for j in range(yy, i):
		if a[j] < a[i]:
			f1 = 1
			break
	zz = i + y + 1
	while zz > n:
		zz -= 1
	for j in range(i + 1, zz):
		if a[j] < a[i]:
			f2 = 1
			break
	if f1 == 0 and f2 == 0:
		ans = i + 1
		break
print(ans)


(n, x, y) = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(0, n):
	flag = 1
	for j in range(i - 1, max(i - x - 1, 0), -1):
		if a[i] >= a[j]:
			flag = 0
			break
	if flag == 0:
		continue
	for j in range(i + 1, min(n, i + y + 1)):
		if a[i] >= a[j]:
			flag = 0
			break
	if flag == 0:
		continue
	print(i + 1)
	break


r = lambda : map(int, input().split())
(n, x, y) = r()
rain = [*r()]
d = 0
while rain[d] > min(rain[max(0, d - x):1 + d + y]):
	d += 1
print(d + 1)


L = list(map(int, input().split()))
[n, x, y] = L
L = list(map(int, input().split()))
for i in range(n):
	day = L[i]
	if day <= min(L[max(0, i - x):i + 1]) and day <= min(L[i:min(n, i + y + 1)]):
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = []
a = list(map(int, input().strip().split()))
for i in range(n):
	flag = 0
	for j in range(x + 1):
		if i - j >= 0 and a[i] > a[i - j]:
			flag = 1
	for j in range(y + 1):
		if i + j < n and a[i] > a[i + j]:
			flag = 1
	if flag == 0:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))[:n]
f = 0
for i in range(n):
	f = 0
	if i + 1 <= x:
		for j in range(i, 0, -1):
			if a[j] < a[i]:
				f = 1
				break
	else:
		for j in range(i - x, i):
			if a[j] < a[i]:
				f = 1
				break
	if i + 1 + y > n:
		for j in range(i + 1, n):
			if a[j] < a[i]:
				f = 1
				break
	else:
		for j in range(i + 1, i + y + 1):
			if a[j] < a[i]:
				f = 1
				break
	if f == 1:
		continue
	else:
		print(i + 1)
		break


def solve(arr, x, y, n):
	res = 0
	for i in range(n):
		before = arr[i - x:i]
		after = arr[i + 1:i + y + 1]
		done1 = True
		for a in before:
			if arr[i] > a:
				done1 = False
				break
		if not done1:
			continue
		done2 = True
		for b in after:
			if arr[i] > b:
				done2 = False
				break
		if done1 and done2:
			res = i + 1
			break
	if res == 0:
		print(n)
	else:
		print(res)

def main():
	(n, x, y) = map(int, input().split())
	arr = list(map(int, input().split()))
	solve(arr, x, y, n)
main()


(n, x, y) = list(map(int, input().split()))
arr = list(map(int, input().split()))
for i in range(n):
	if i < x and min(arr[:i + y + 1]) == arr[i] or (i >= x and min(arr[i - x:i + y + 1]) == arr[i]):
		print(i + 1)
		break


from sys import stdin
input = stdin.readline
(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
f = False
for i in range(n):
	for j in range(i - x, i + y + 1):
		if j >= n or j < 0 or i == j:
			continue
		if a[j] <= a[i]:
			break
	else:
		print(i + 1)
		break


(n, x, y) = list(map(int, input().split()))
arr = list(map(int, input().split()))
for nowi in range(n):
	now = arr[nowi]
	check = True
	for i in range(x):
		if nowi - 1 - i < 0:
			break
		if arr[nowi - 1 - i] < now:
			check = False
			break
	for i in range(y):
		if nowi + 1 + i >= n:
			break
		if arr[nowi + 1 + i] < now:
			check = False
			break
	if check:
		print(nowi + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
ind = 0
for i in range(len(a)):
	chx = 1
	chy = 1
	for j in range(i - x, i):
		if j >= 0:
			if a[i] >= a[j]:
				chx = 0
				break
	for j in range(i + 1, i + y + 1):
		if j < n:
			if a[i] >= a[j]:
				chy = 0
				break
	if chx == 1 and chy == 1:
		ind = i
		break
print(ind + 1)


(n, x, y) = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
for i in range(n):
	flg = True
	for j in range(max(0, i - x), i):
		if a[j] <= a[i]:
			flg = False
	for j in range(i + 1, min(n, i + y + 1)):
		if a[j] <= a[i]:
			flg = False
	if flg:
		print(i + 1)
		return


import sys
(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
ans = 0
for i in range(n):
	d = False
	for j in range(max(i - x, 0), i):
		if a[j] < a[i]:
			d = True
			break
	if d:
		continue
	for j in range(i + 1, min(i + y + 1, n)):
		if a[j] < a[i]:
			d = True
			break
	if d:
		continue
	print(i + 1)
	sys.exit()


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if n == 1:
	print(1)
	exit()
array = [1000000000] * x + a + [1000000000] * y
left = 0
right = 0
for i in range(n):
	for j in range(i - x, i):
		if a[i] < array[j + x]:
			left += 1
	for k in range(i + 1, i + 1 + y):
		if a[i] < array[k + x]:
			right += 1
	if left >= x and right >= y:
		print(i + 1)
		exit(0)
	left = 0
	right = 0


(n, x, y) = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
ans = 0
for i in range(n):
	ok = 1
	for j in range(max(0, i - x), min(i + y + 1, n)):
		if j == i:
			continue
		elif A[j] > A[i]:
			continue
		else:
			ok = 0
			break
	if ok:
		ans = i
		break
print(ans + 1)


N = list(map(int, input().split()))
p = list(map(int, input().split()))
for i in range(N[0]):
	if i >= N[1]:
		if i + N[2] <= N[0] - 1:
			if min(p[i - N[1]:i + N[2] + 1]) == p[i]:
				print(i + 1)
				break
		elif min(p[i - N[1]:]) == p[i]:
			print(i + 1)
			break
	elif i + N[2] <= N[0] - 1:
		if min(p[:i + N[2] + 1]) == p[i]:
			print(i + 1)
			break
	elif min(p[:]) == p[i]:
		print(i + 1)
		break


from collections import deque
dq = deque()
(n, x, y) = map(int, input().split())
arr = list(map(int, input().split()))
for i in range(y):
	while dq and arr[i] < arr[dq[-1]]:
		dq.pop()
	dq.append(i)
ans = -1
for i in range(y, n + y):
	if i < n:
		while dq and dq[0] < i - y - x:
			dq.popleft()
		while dq and arr[i] < arr[dq[-1]]:
			dq.pop()
		dq.append(i)
		if dq[0] == i - y:
			ans = dq[0] + 1
			break
	else:
		while dq and dq[0] < i - y - x:
			dq.popleft()
		if dq[0] == i - y:
			ans = dq[0] + 1
			break
print(ans)


def nice(d):
	for i in range(d - x, d + y + 1):
		if i >= 0 and i < n and (m[i] < m[d]):
			return False
	return True
(n, x, y) = map(int, input().split())
m = list(map(int, input().split()))
for i in range(n):
	if nice(i):
		print(i + 1)
		exit(0)


I = lambda : map(int, input().split())
(n, x, y) = I()
A = list(I())
for i in range(n):
	if all((A[i] <= a for a in A[max(0, i - x):i + y + 1])):
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
arr = list(map(int, input().split()))
if n == 1:
	print(1)
	exit()
if y == 0 or arr[0] < min(arr[1:min(n, y + 1)]):
	print(1)
	exit()
for i in range(n):
	if max(0, i - x) == i or i + 1 == min(n, i + y + 1):
		continue
	if arr[i] < min(arr[max(0, i - x):i]) and arr[i] < min(arr[i + 1:min(n, i + y + 1)]):
		print(i + 1)
		exit()
if x == 0 or arr[n - 1] < min(arr[max(0, n - 1 - x):-1]):
	print(n)
	exit()
print(-1)


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))

def check(i, n, x, y):
	for j in range(min(i + 1, n), min(n, i + y + 1)):
		if l[j] <= l[i]:
			return j
	for j in range(max(0, i - x), i):
		if l[j] <= l[i]:
			return i + 1
	return 'y'
i = 0
while i < n:
	t = check(i, n, x, y)
	if t == 'y':
		print(i + 1)
		break
	else:
		i = t


from collections import defaultdict, deque, Counter
from sys import stdin, stdout
from heapq import heappush, heappop
import math
import io
import os
import math
import bisect

def isPrime(x):
	for i in range(2, x):
		if i * i > x:
			break
		if x % i == 0:
			return False
	return True

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(int(i))
			n = n / i
	if n > 2:
		l.append(n)
	return list(set(l))

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime

def digits(n):
	c = 0
	while n > 0:
		n //= 10
		c += 1
	return c

def ceil(n, x):
	if n % x == 0:
		return n // x
	return n // x + 1

def mapin():
	return map(int, input().split())
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
(n, x, y) = mapin()
fl = 0
a = [int(x) for x in input().split()]
for i in range(n):
	s = min(a[max(0, i - x):min(n, i + y + 1)])
	if a[i] == s:
		fl = i
		break
print(fl + 1)


R = lambda : map(int, input().split())
(n, x, y) = R()
a = list(R())
for i in range(len(a)):
	if a[i] == min(a[max(0, i - x):min(len(a), i + y + 1)]):
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
i = 0
if n == 1:
	print(1)
else:
	for i in range(n):
		cnt = 0
		j = i - 1
		ok = True
		while j > 0:
			if cnt == x:
				ok = True
				break
			if a[i] >= a[j]:
				ok = False
				break
			else:
				cnt += 1
			j -= 1
		if ok:
			z = 0
			j = i + 1
			while j <= n - 1:
				if z == y:
					ok = True
					break
				if a[i] >= a[j]:
					ok = False
					break
				else:
					z += 1
				j += 1
		if ok:
			break
	print(i + 1)


(N, X, Y) = map(int, input().split())
A = list(map(int, input().split()))
for i in range(N):
	valid = True
	for j in range(i - X, i + Y + 1):
		if j < 0 or j >= N:
			continue
		if A[i] > A[j]:
			valid = False
			break
	if valid:
		print(i + 1)
		exit(0)


(n, z, y) = [int(x) for x in input().split()]
l = [int(x) for x in input().split()]
tries = y
num = l[0]
ind = 0
for i in range(1, len(l)):
	if tries == 0:
		print(ind + 1)
		break
	if l[i] < num:
		num = l[i]
		ind = i
		tries = y
	else:
		tries -= 1
else:
	print(ind + 1)


from sys import stdin

def iinput():
	return int(stdin.readline())

def minput():
	return map(int, stdin.readline().split())

def linput():
	return list(map(int, stdin.readline().split()))
(n, x, y) = minput()
a = linput()
for i in range(n):
	flag = True
	for j in range(i - 1, max(-1, i - x - 1), -1):
		if a[i] > a[j]:
			flag = False
			break
	if flag:
		for j in range(i + 1, min(n, i + y + 1)):
			if a[i] > a[j]:
				flag = False
				break
	if flag:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
days = list(map(int, input().split()))
for i in range(n):
	flag = 1
	j = i - 1
	while j >= i - x and j >= 0:
		if days[j] <= days[i]:
			flag = 0
			break
		j -= 1
	if flag == 0:
		continue
	j = i + 1
	while j <= i + y and j < n:
		if days[j] <= days[i]:
			flag = 0
			break
		j += 1
	if flag == 0:
		continue
	else:
		break
print(i + 1)


import sys
input = sys.stdin.readline
RI = lambda : [int(x) for x in sys.stdin.readline().strip().split()]
rw = lambda : input().strip().split()
infinite = float('inf')
(n, x, y) = RI()
l = RI()
pre = [1] * n
pre[0] = 1
for i in range(n):
	for j in range(max(0, i - x), i):
		if l[j] <= l[i]:
			pre[i] = 0
			continue
pos = [1] * n
pos[n - 1] = 1
for i in range(n - 1, -1, -1):
	for j in range(i + 1, min(n, i + y + 1)):
		if l[j] <= l[i]:
			pos[i] = 0
			continue
for i in range(n):
	if pre[i] == 1 and pos[i] == 1:
		print(i + 1)
		break


(n, x, y) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
for i in range(n):
	f = True
	for j in range(max(i - x, 0), min(i + y + 1, n)):
		if a[j] < a[i]:
			f = False
			break
	if f:
		print(i + 1)
		break


(n, x, y) = [int(i) for i in input().split()]
arr = [int(i) for i in input().split()]
for i in range(n):
	flag = True
	for j in range(max(0, i - x), min(n, i + y + 1)):
		if i != j and arr[j] <= arr[i]:
			flag = False
			break
	if flag:
		print(i + 1)
		break


(day, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(day):
	if min(a[i - x if i >= x else 0:i + y + 1]) == a[i]:
		print(i + 1)
		exit()


(x, y, z) = map(int, input().split())
sura = list(map(int, input().split()))
for i in range(0, x, 1):
	hbe = True
	for j in range(i - 1, max(i - 1 - y, -1), -1):
		if sura[i] >= sura[j]:
			hbe = False
	for j in range(i + 1, min(i + z + 1, x), 1):
		if sura[i] >= sura[j]:
			hbe = False
	if hbe:
		print(i + 1)
		exit(0)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
m = -1
k = 0
for i in range(n):
	if a[i] < m or m == -1:
		m = a[i]
		k = i
	if i - k >= y:
		break
print(k + 1)


import math

class Read:

	@staticmethod
	def int():
		return int(input())

	@staticmethod
	def list(sep=' '):
		return input().split(sep)

	@staticmethod
	def list_int(sep=' '):
		return list(map(int, input().split(sep)))

def solve():
	(n, x, y) = Read.list_int()
	a = Read.list_int()
	for i in range(n):
		d = a[i]
		isTrue = True
		for j in range(x):
			if i - j - 1 >= 0:
				if d >= a[i - j - 1]:
					isTrue = False
					break
		if isTrue:
			for j in range(y):
				if j + i + 1 < n:
					if d >= a[j + i + 1]:
						isTrue = False
						break
		if isTrue:
			print(i + 1)
			return
query_count = 1
for j in range(query_count):
	solve()


from sys import stdin
inp = lambda : stdin.readline().strip()
(n, x, y) = [int(x) for x in inp().split()]
a = [int(x) for x in inp().split()]
x1 = 0
y1 = 0
for i in range(n):
	for j in range(1, min(x, i)):
		if a[i] > a[i - j]:
			break
	else:
		for j in range(1, min(y + 1, n - i)):
			if a[i] > a[i + j]:
				break
		else:
			print(i + 1)
			exit()
print(n)


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
for i in range(x):
	l.insert(0, 10 ** 10)
for i in range(x, n + x):
	if min(l[i - x:i + y + 1]) == l[i]:
		print(i + 1 - x)
		break


from sys import stdin, stdout
(N, X, Y) = [int(x) for x in stdin.readline().split()]
arr = [int(x) for x in stdin.readline().split()]
for i in range(N):
	left = max(0, i - X)
	right = min(N - 1, i + Y)
	flag = 0
	for j in range(left, right + 1):
		if arr[j] <= arr[i] and i != j:
			flag = 1
			break
	if flag == 0:
		print(i + 1)
		quit()


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
m = -1
m_id = None
y_count = 0
for k in range(n):
	if a[k] < m or m_id is None:
		m = a[k]
		m_id = k
		y_count = 0
		if y == 0:
			break
	else:
		y_count += 1
		if y_count == y:
			break
print(m_id + 1)


import heapq

def solve(days, x, y, n):
	window = dict()
	win_beg = 0
	win_end = 0
	res = 0
	pre = 0
	while pre < n:
		while win_beg < pre - x:
			del window[days[win_beg]]
			win_beg += 1
		while win_end < min(pre + y + 1, n):
			window[days[win_end]] = True
			if days[win_end] < days[res]:
				res = win_end
			win_end += 1
		if pre == res:
			return pre + 1
		pre = res
	return -1
(n, x, y) = [int(ele) for ele in input().split()]
days = [int(ele) for ele in input().split()]
print(solve(days, x, y, n))


from sys import stdin, stdout

def solve(inp, out):
	(n, x, y) = map(int, inp().split())
	a = list(map(int, inp().split()))
	idx = 0
	for d in range(n):
		l = max(0, d - x)
		m = True
		for j in range(l, d):
			if a[j] < a[d]:
				m = False
				break
		r = min(d + y, n - 1)
		for j in range(d + 1, r + 1):
			if a[j] < a[d]:
				m = False
				break
		if m:
			idx = d + 1
			break
	print(idx)

def main():
	inp = stdin.readline
	out = stdout.write
	t = 0
	if t == 0:
		test = 1
	else:
		test = int(inp())
	for _ in range(test):
		solve(inp, out)
main()


(n, x, y) = map(int, input().split())
a = [*map(int, input().split())]
for i in range(n):
	o = max(i - x, 0)
	p = min(i + 1 + y, n)
	if a[i] == min(a[o:p]):
		print(i + 1)
		exit()


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
for i in range(n):
	m1 = min((l[j] for j in range(max(0, i - x), i))) if i > 0 and x > 0 else 1000000001
	m2 = min((l[j] for j in range(i + 1, min(i + y + 1, n)))) if i < n - 1 and y > 0 else 1000000001
	if l[i] < min(m1, m2):
		print(i + 1)
		exit()


(n, x, y) = list(map(int, input().split(' ')))
a = [int(i) for i in input().split(' ')]
for i in range(n):
	current = a[i]
	wrong = False
	for j in range(max(0, i - x), i):
		if a[j] <= current:
			wrong = True
			break
	for j in range(i + 1, min(i + y + 1, n)):
		if a[j] <= current:
			wrong = True
			break
	if wrong:
		continue
	print(i + 1)
	return


import math
(n, x, y) = [int(j) for j in input().split()]
a = [int(j) for j in input().split()]
for i in range(0, n):
	min1 = math.inf
	min2 = math.inf
	for j in range(max(0, i - x), i):
		if min1 > a[j]:
			min1 = a[j]
	for j in range(i + 1, min(i + 1 + y, n)):
		if min2 > a[j]:
			min2 = a[j]
	if a[i] < min1 and a[i] < min2:
		print(i + 1)
		exit()


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
i = 0
if y == 0:
	print(1)
else:
	while i < n:
		if i < n - 1:
			if a[i + 1] < a[i]:
				i += 1
		if min(a[i:min(n, i + y + 1)]) == a[i]:
			print(i + 1)
			break
		i += 1


def naiveSolve(n):
	return

def main():
	(n, x, y) = readIntArr()
	a = readIntArr()
	for i in range(n):
		minBefore = inf
		for j in range(max(i - x, 0), i):
			minBefore = min(minBefore, a[j])
		minAfter = inf
		for j in range(i + 1, min(i + y + 1, n)):
			minAfter = min(minAfter, a[j])
		if minBefore > a[i] < minAfter:
			print(i + 1)
			break
	return
import sys
input = sys.stdin.buffer.readline

def oneLineArrayPrint(arr):
	print(' '.join([str(x) for x in arr]))

def multiLineArrayPrint(arr):
	print('\n'.join([str(x) for x in arr]))

def multiLineArrayOfArraysPrint(arr):
	print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))

def readIntArr():
	return [int(x) for x in input().split()]

def makeArr(defaultValFactory, dimensionArr):
	dv = defaultValFactory
	da = dimensionArr
	if len(da) == 1:
		return [dv() for _ in range(da[0])]
	else:
		return [makeArr(dv, da[1:]) for _ in range(da[0])]

def queryInteractive(l, r):
	print('? {} {}'.format(l, r))
	sys.stdout.flush()
	return int(input())

def answerInteractive(x):
	print('! {}'.format(x))
	sys.stdout.flush()
inf = float('inf')
MOD = 10 ** 9 + 7
from math import gcd, floor, ceil
for _abc in range(1):
	main()


def check(id):
	for i in range(id - x, id + y + 1):
		if i >= 0 and i < n and (a[id] > a[i]):
			return 0
	return 1
(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(0, n):
	if check(i):
		print(i + 1)
		break


import sys
Input = lambda : map(int, input().split())
(n, x, y) = Input()
a = list(Input())
i = ind = 0
res = n
com = a[0]
if y == 0:
	print(1)
	exit()
while i < n - 1:
	if com < a[i + 1]:
		if i + 1 - ind >= y:
			print(ind + 1)
			exit()
	else:
		com = a[i + 1]
		ind = i + 1
	i += 1
print(ind + 1)


from sys import stdin, stdout

def main():
	arr1 = [int(x) for x in stdin.readline().split()]
	arr2 = [int(x) for x in stdin.readline().split()]
	n = arr1[0]
	x = arr1[1]
	y = arr1[2]
	ans = 0
	length = len(arr2)
	for i in range(length):
		if lessx(x, arr2, i) and lessy(y, arr2, i):
			print(i + 1)
			return

def lessx(x, arr, i):
	bool = 1
	for b in range(x + 1):
		if i - b > 0:
			if arr[i - b] < arr[i]:
				bool = 0
	if bool == 1:
		return True
	else:
		return False
	return False

def lessy(y, arr, i):
	bool = 1
	for b in range(y + 1):
		if i + b < len(arr):
			if arr[i + b] < arr[i]:
				bool = 0
	if bool == 1:
		return True
	else:
		return False
	return False
main()


def solve():
	(n, x, y) = list(map(int, input().split()))
	a = list(map(int, input().split()))
	best = 0
	for i in range(n):
		is_good = True
		for j in range(1, x + 1):
			if i - j < 0:
				break
			if a[i - j] <= a[i]:
				is_good = False
		for j in range(1, y + 1):
			if i + j >= n:
				break
			if a[i + j] <= a[i]:
				is_good = False
		if is_good:
			best = i
			break
	print(best + 1)
solve()


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))[:n]
c = 1
for i in range(n - y):
	c = 0
	for j in range(i + 1, i + y + 1):
		if l[i] > l[j]:
			c += 1
	e = i - x
	if e < 0:
		e = 0
	for k in range(e, i):
		if l[i] > l[k]:
			c += 1
	if c == 0:
		print(i + 1)
		break
d = 0
if c != 0:
	for i in range(n - y, n):
		d = 0
		for j in range(i + 1, n):
			if l[i] > l[j]:
				d += 1
		if d == 0:
			print(i + 1)
			break


import sys
input = sys.stdin.readline
from collections import defaultdict as dc
from collections import Counter
from bisect import bisect_right, bisect_left
import math
from heapq import heapify, heappop, heappush
(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
m = -1
for i in range(n):
	f = 1
	for j in range(max(i - x, 0), min(i + y + 1, n)):
		if j != i:
			if l[i] > l[j]:
				f = 0
				break
	if f:
		break
print(i + 1)


(n, m, k) = map(int, input().split())
arr = list(map(int, input().split()))
for i in range(n):
	f = 1
	for j in range(max(0, i - m - 1), min(n, i + k + 1)):
		if arr[i] > arr[j]:
			f = 0
			break
	if f:
		print(i + 1)
		exit(0)


import sys, heapq, math
from collections import deque, defaultdict
printn = lambda x: sys.stdout.write(x)
inn = lambda : int(input())
inl = lambda : list(map(int, input().split()))
inm = lambda : map(int, input().split())
DBG = True
R = 10 ** 9 + 7

def ddprint(x):
	if DBG:
		print(x)
(n, x, y) = inm()
a = inl()
for i in range(n):
	ok = True
	mn = max(0, i - x)
	mx = min(n - 1, i + y)
	for j in range(mn, mx + 1):
		if j != i and a[j] <= a[i]:
			ok = False
			break
	if ok:
		print(i + 1)
		exit()


import sys
input = sys.stdin.readline
(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
if n == 1:
	print(1)
	exit(0)
for i in range(x):
	q = min(n, i + 1 + y)
	s = l[:i] + l[i + 1:i + 1 + y]
	if s == []:
		print(i + 1)
		exit(0)
	if l[i] < min(s):
		print(i + 1)
		exit(0)
for i in range(x, n):
	q = min(n, i + 1 + y)
	s = l[i - x:i] + l[i + 1:q]
	if s == []:
		print(i + 1)
		exit(0)
	if l[i] < min(s):
		print(i + 1)
		exit(0)


(n, x, y) = [int(x) for x in input().split()]
a = []
a = [int(x) for x in input().split()]
for i in range(n):
	l = min(i, x)
	s1 = a[i - l:i]
	u = min(y, n - i - 1)
	s2 = a[i + 1:i + u + 1]
	if len(s1) == 0 and len(s2) == 0:
		break
	if len(s1) == 0 and a[i] < min(s2):
		break
	if len(s2) == 0:
		break
	if i != 0:
		if a[i] < min(s1) and a[i] < min(s2):
			break
print(i + 1)


(n, x, y) = map(int, input().split())
li = list(map(int, input().split()))
ans = n
for i in range(0, n):
	lower = 0
	if i > x:
		lower = i - x
	else:
		lower = 0
	greater = 0
	if i + y > n:
		greater = n
	else:
		greater = i + y + 1
	region = li[lower:greater]
	m = min(region)
	if li[i] == m:
		ans = i + 1
		break
	else:
		pass
print(ans)


lamb = lambda : [*map(int, input().split())]
(n, x, y) = lamb()
cities = lamb()
cities = x * [10000000000] + cities + y * [10000000000]
a = 0
b = x + y
while True:
	if cities[a + x] == min(cities[a:b + 1]):
		print(a + 1)
		break
	a = a + 1
	b = b + 1


(n, x, y) = map(int, input().split())
from math import *
A = [inf] * x
A += list(map(int, input().split()))
A += [inf] * y
for i in range(x, x + n):
	flag = True
	for l in range(1, x + 1):
		if A[i] >= A[i - l]:
			flag = False
			break
	for r in range(1, y + 1):
		if A[i] >= A[i + r]:
			flag = False
			break
	if flag == True:
		print(i - x + 1)
		break


(n, x, y) = list(map(int, input().split()))
arr = list(map(int, input().split()))
for i in range(n):
	flag = 0
	for j in range(i - 1, max(i - x - 1, -1), -1):
		if arr[j] <= arr[i]:
			flag = 1
	for j in range(i + 1, min(i + y + 1, n)):
		if arr[j] <= arr[i]:
			flag = 1
	if flag == 0:
		print(i + 1)
		return


(n, x, y) = map(int, input().split())
li = list(map(int, input().split()))
for i in range(len(li)):
	val = li[i]
	ll = 0 if i - x < 0 else i - x
	rl = n - 1 if i + y >= n else i + y
	if min(li[ll:rl + 1]) == val:
		print(i + 1)
		break


(N, BEFORE, AFTER) = map(int, input().split())
days = list(map(int, input().split()))

def goodbefore(j):
	for diff in range(1, BEFORE + 1):
		k = j - diff
		if k < 0:
			continue
		if days[k] <= days[j]:
			return False
	return True

def goodafter(j):
	for diff in range(1, AFTER + 1):
		k = j + diff
		if k >= N:
			continue
		if days[k] <= days[j]:
			return False
	return True
for i in range(N):
	if goodbefore(i) and goodafter(i):
		print(i + 1)
		break


(n, dosl, aftersl) = map(int, input().split())
weath = list(map(int, input().split()))
for i in range(len(weath)):
	x = weath[i]
	t = True
	for j in range(i - 1, max(i - dosl - 1, -1), -1):
		if x > weath[j]:
			t = False
			break
	else:
		for j in range(i + 1, min(i + aftersl + 1, len(weath))):
			if x > weath[j]:
				t = False
				break
	if t:
		res = i
		break
print(i + 1)


import sys
import math

def inp():
	p = sys.stdin.readline()
	return p

def mini(a):
	if len(a) == 0:
		return 10 ** 10
	else:
		return min(a)
(n, x, y) = list(map(int, inp().split()))
a = [int(i) for i in inp().split()]
for i in range(n):
	if i < x:
		p = mini(a[:i])
	else:
		p = mini(a[i - x:i])
	if i >= n - y:
		q = mini(a[i + 1:])
	else:
		q = mini(a[i + 1:i + y + 1])
	if a[i] < p and a[i] < q:
		print(i + 1)
		break


def check(t):
	z = 0
	if data1[0] - (t + 1) < data1[2]:
		f = data1[0] - (t + 1)
	else:
		f = data1[2]
	for i in range(f + 1):
		if data2[t] > data2[i + t]:
			z += 1
			break
	if z != 0:
		return (1, i + t)
	else:
		return (0, t + 1)
data1 = [int(x) for x in input().split()]
data2 = [int(x) for x in input().split()]
a = check(0)
while True:
	if a[0] == 0:
		print(a[1])
		break
	else:
		a = check(a[1])


(a, x, y) = input().split()
d = [int(i) for i in input().split()]
a = int(a)
x = int(x)
y = int(y)
v = 0
for i in range(a):
	day = i - 1
	fail = 0
	while day >= 0 and day >= i - x:
		if d[day] > d[i]:
			day -= 1
		else:
			fail = 1
			break
	if not fail:
		day = i + 1
		while day < a and day <= i + y:
			if d[day] > d[i]:
				day += 1
			else:
				fail = 1
				break
	if not fail:
		v = i
		break
print(v + 1)


(n, x, y) = list(map(int, input().split(' ')))
days = list(map(int, input().split(' ')))
if x == n:
	x -= 1
for i in range(n):
	yes = 1
	for j in range(i - 1, max(0, i - x - 1), -1):
		if days[i] > days[j]:
			yes = 0
			break
	if yes == 1:
		for j in range(i + 1, min(n, i + y + 1)):
			if days[i] > days[j]:
				yes = 0
				break
	if yes == 1:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
ar = list(map(int, input().split()))
ans = 0
for i in range(n):
	if ar[i] < ar[ans]:
		ans = i
	if i - ans >= y:
		break
print(ans + 1)


max_ = 10 ** 9 + 1
(n, x, y) = map(int, input().split(' '))
a = list(map(int, input().split(' ')))
for i in range(7):
	a.append(max_)
	a.insert(0, max_)
for i in range(7, 7 + n):
	(left, right) = (False, False)
	for j in range(x):
		if a[i] < a[i - j - 1]:
			None
		else:
			break
	else:
		left = True
	for j in range(y):
		if a[i] < a[i + j + 1]:
			None
		else:
			break
	else:
		right = True
	if left == True and right == True:
		print(i - 6)
		break


(n, x, y) = map(int, input().split())
days = list(map(int, input().split()))
res = 0
while True:
	if (x == 0 or res == 0 or (x > 0 and res > 0 and (days[res] < min(days[max(0, res - x):res])))) and (y == 0 or res == n - 1 or (y > 0 and res < n - 1 and (days[res] < min(days[res + 1:min(n, res + y + 1)])))):
		break
	else:
		res += 1 + days[res + 1:min(n, res + y + 1)].index(min(days[res + 1:min(n, res + y + 1)]))
print(res + 1)


(n, x, y) = map(int, input().split())
m = list(map(int, input().split()))
for i in range(n):
	check = 1
	for j in m[max(0, i - x):i] + m[i + 1:i + y + 1]:
		if m[i] > j:
			check = 0
	if check == 1:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
A = list(map(int, input().split()))

def f(i, l):
	if l < 0:
		return '+'
	elif A[i] < A[l]:
		return '+'
	else:
		return '-'

def g(i, l):
	if l > n - 1:
		return '+'
	elif A[i] < A[l]:
		return '+'
	else:
		return '-'
for i in range(n):
	out1 = 0
	out2 = 0
	for j in range(i - 1, i - x - 1, -1):
		if f(i, j) == '+':
			out1 += 1
	for k in range(i + 1, i + y + 1):
		if g(i, k) == '+':
			out2 += 1
	if out1 >= x and out2 >= y:
		print(i + 1)
		break


(n, a, b) = map(int, input().split())
l = [int(x) for x in input().split()]
for x in range(n):
	flag = 0
	for y in range(1, a + 1):
		i = x - y
		if i < 0:
			continue
		if l[i] < l[x]:
			flag = 1
			break
	if flag == 1:
		continue
	for y in range(1, b + 1):
		i = x + y
		if i >= n:
			continue
		if l[i] < l[x]:
			flag = 1
			break
	if flag == 1:
		continue
	print(x + 1)
	break


(n, x, y) = map(int, input().split(' '))
a = list(map(int, input().split(' ')))
largest = 10 ** 9 + 1
for i in range(n):
	if i == 0 or x == 0:
		lmin = largest
	else:
		lmin = min(a[max(0, i - x):i])
	if i == n - 1 or y == 0:
		rmin = largest
	else:
		rmin = min(a[i + 1:min(n, i + y + 1)])
	if a[i] < lmin and a[i] < rmin:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
a = [a[0] + 1] * x + a + [a[-1] + 1] * y
for i in range(x, x + len(a)):
	if a[i] == min(a[i - x:i + y + 1]) and a[i - x:i + y + 1].count(a[i]) == 1:
		print(i - x + 1)
		break


(n, x, y) = [int(i) for i in input().split()]
data = [1 << 30] * x + [int(i) for i in input().split()] + [1 << 30] * y
bump = list(range(-x, 0)) + list(range(1, y + 1))
for i in range(x, x + n):
	num = data[i]
	bad = False
	for j in bump:
		if data[i + j] <= num:
			bad = True
			break
	if not bad:
		print(i + 1 - x)
		break


(n, x, y) = map(int, input().split())
arr = list(map(int, input().split()))
ans = False
for i in range(n):
	before = arr[i - x if i - x > 0 else 0:i]
	after = arr[i + 1:i + 1 + y if i + y + 1 < n else n]
	a = min(before) if len(before) != 0 else arr[i] + 1
	b = min(after) if len(after) != 0 else arr[i] + 1
	if arr[i] < min(a, b):
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
ans = -1
for i in range(0, n):
	k = 55555555555555555555555555
	for j in range(max(0, i - x), i):
		k = min(k, a[j])
	t = 55555555555555555555555555555
	for j in range(i + 1, min(i + y + 1, n)):
		t = min(t, a[j])
	if a[i] < min(t, k):
		ans = i + 1
		break
print(ans)


(n, x, y) = map(int, input().split())
s = list(map(int, input().split()))
i = 0
while i < n:
	j = max(0, i - x)
	lx = []
	ly = [s[i]]
	while j <= i:
		lx.append(s[j])
		j += 1
	while j <= min(n - 1, i + y):
		ly.append(s[j])
		j += 1
	if s[i] == min(min(lx), min(ly)):
		break
	else:
		i = i + ly.index(min(ly))
print(i + 1)


t = input().split()
n = int(t[0])
x = int(t[1])
y = int(t[2])
a = list(map(int, input().split()))
result = 0
b = True
for i in range(0, n):
	b = True
	j = i - 1
	while j > -1 and i - j < x + 1:
		if a[i] > a[j]:
			b = False
			break
		j = j - 1
	if not b:
		continue
	j = i + 1
	while j < n and j - i < y + 1:
		if a[i] > a[j]:
			b = False
			break
		j = j + 1
	if b:
		result = i
		break
print(result + 1)


import heapq

def solve(days, x, y, n):
	window = []
	for i in range(0, x + y + 1):
		heapq.heappush(window, days[i])
	pre = x
	to_remove = dict()
	while pre < x + n:
		smallest = heapq.heappop(window)
		while smallest in to_remove:
			smallest = heapq.heappop(window)
		if days[pre] == smallest:
			return pre - x + 1
		to_remove[days[pre - x]] = True
		heapq.heappush(window, smallest)
		heapq.heappush(window, days[pre + y + 1])
		pre += 1
	return -1
line = [int(ele) for ele in input().split()]
n = line[0]
x = line[1]
y = line[2]
days = [10000000000] * x + [int(ele) for ele in input().split()] + [10000000000] * y
print(solve(days, x, y, n))


import sys
(n, x, y) = list(map(int, sys.stdin.readline().strip().split()))
a = list(map(int, sys.stdin.readline().strip().split()))
a = [10 ** 9 + 1] * x + a + [10 ** 9 + 1] * y
for i in range(x, len(a) - y + 1):
	if a[i] == min(a[i - x:i + 1]) and a[i] == min(a[i:i + y + 1]):
		print(i - x + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
maxi = max(a) + 1
for i in range(n):
	if min(a[i - x if i - x >= 0 else 0:i] + [maxi]) > a[i] and min(a[i + 1:i + y + 1] + [maxi]) > a[i]:
		print(i + 1)
		quit()


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(n):
	if (not x or not i or min(a[max(0, i - x):i]) > a[i]) and (not y or i + 1 >= n or min(a[i + 1:min(i + y + 1, n)]) > a[i]):
		print(i + 1)
		break


import math
[N, X, Y] = list(map(int, input().split()))
listi = list(map(int, input().split()))
for i in range(len(listi)):
	start = i - X
	if start < 0:
		start = 0
	min1 = math.inf
	end = i
	while start < end:
		if min1 > listi[start]:
			min1 = listi[start]
		start += 1
	start = i + 1
	end = i + Y
	if end > len(listi) - 1:
		end = len(listi) - 1
	mini2 = math.inf
	while start <= end:
		if mini2 > listi[start]:
			mini2 = listi[start]
		start += 1
	if listi[i] < min(min1, mini2):
		print(i + 1)
		exit()


import math
t = list(map(int, input().split()))
k = list(map(int, input().split()))
day = 0
for i in range(t[0]):
	ans = 1
	for j in range(i - 1, max(i - 1 - t[1], 0), -1):
		if k[i] > k[j]:
			ans = 0
			break
	if ans == 0:
		continue
	for kk in range(i + 1, min(i + 1 + t[2], t[0])):
		if k[i] > k[kk]:
			ans = 0
			break
	if ans == 0:
		continue
	day = i
	break
print(day + 1)


(lenm, x, y) = map(int, input().split())
m = list(map(int, input().split()))
for i in range(lenm):
	s = True
	for r in m[max(0, i - x):i] + m[i + 1:i + y + 1]:
		if m[i] > r:
			s = False
	if s == True:
		print(i + 1)
		break


(n, x, y) = input().split(' ')
n = int(n)
x = int(x)
y = int(y)
needed = 0
osadki = list(map(int, input().split(' ')))
for i in range(0, n):
	needed = 1
	for j in range(1, x + 1):
		if i - j > -1:
			if osadki[i] > osadki[i - j]:
				needed = 0
				break
	for j in range(1, y + 1):
		if i + j < n:
			if osadki[i] > osadki[i + j]:
				needed = 0
				break
	if needed == 1:
		print(i + 1)
		break


def main():
	(n, x, y) = map(int, input().split())
	rain = list(map(int, input().split()))
	for i in range(n):
		ad = rain[i]
		count1 = 0
		j = i - 1
		while j >= 0:
			if count1 == x:
				break
			if ad < rain[j]:
				count1 += 1
			else:
				break
			j -= 1
		j = i + 1
		count2 = 0
		while j < n:
			if count2 == y:
				break
			if ad < rain[j]:
				count2 += 1
			else:
				break
			j += 1
		before = i
		after = n - 1 - i
		if before >= x and after >= y:
			if count1 == x and count2 == y:
				print(i + 1)
				return
		if before < x and after < y:
			if count1 == before and count2 == after:
				print(i + 1)
				return
		if before < x:
			if count1 == before and count2 == y:
				print(i + 1)
				return
		if after < y:
			if count1 == x and count2 == after:
				print(i + 1)
				return
main()


pre = [10 ** 9 + 1] * 7
last = [10 ** 9 + 1] * 7
(n, x, y) = [int(i) for i in input().split()]
nums = pre + [int(i) for i in input().split()] + last
ind = 7
if x == 0 and y == 0:
	print(1)
elif x == 0 or y == 0:
	for i in range(n):
		if x == 0 and nums[ind + i] < min(nums[ind + i + 1:ind + i + 1 + y]):
			print(i + 1)
			break
		elif y == 0 and min(nums[ind + i - x:ind + i]) > nums[ind + i]:
			print(i + 1)
			break
else:
	for i in range(n):
		if min(nums[ind + i - x:ind + i]) > nums[ind + i] < min(nums[ind + i + 1:ind + i + 1 + y]):
			print(i + 1)
			break


import sys
from collections import deque
in_file = sys.stdin
(n, x, y) = map(int, in_file.readline().strip().split())
A = list(map(int, in_file.readline().strip().split()))
M = max(A) + 1
l = deque([])
r = deque(A[1:y + 1])
d = 0
while A[d] >= min(r, default=M) or A[d] >= min(l, default=M):
	l.append(A[d])
	if len(l) > x:
		l.popleft()
	if d + y + 1 < len(A):
		r.append(A[d + y + 1])
	r.popleft()
	d += 1
sys.stdout.write(str(d + 1))
sys.stdout.flush()


import math
from collections import deque, defaultdict
from sys import stdin, stdout
input = stdin.readline
listin = lambda : list(map(int, input().split()))
mapin = lambda : map(int, input().split())
(n, x, y) = mapin()
a = listin()
for i in range(n):
	m = a[i]
	for j in range(max(i - x, 0), min(i + y + 1, n)):
		m = min(m, a[j])
	if m == a[i]:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
b = [10 ** 9 + 10] * 7
c = [10 ** 9 + 10] * 7
b.extend(a)
b.extend(c)
for i in range(7, n + 7):
	cnt = 0
	for j in range(i - x, i + y + 1):
		if b[j] <= b[i]:
			cnt += 1
	if cnt == 1:
		print(i - 6)
		break


(n, x, y) = [int(a) for a in input().split()]
list = [int(a) for a in input().split()]
out = []
for i in range(n):
	flag = 0
	for k in range(0, x + 1):
		if i - k >= 0:
			if list[i] <= list[i - k]:
				flag = 0
			else:
				flag = 1
			if flag == 1:
				break
		if flag == 0:
			for j in range(0, y + 1):
				if i + j < n:
					if list[i] <= list[i + j]:
						flag = 0
					else:
						flag = 1
					if flag == 1:
						break
	if flag == 0:
		print(i + 1)
		break


from collections import deque
(n, x, y) = map(int, input().split())
arr = list(map(int, input().split()))
left_dq = deque()
right_dq = deque()
for i in range(1, y):
	while right_dq and arr[right_dq[-1]] > arr[i]:
		right_dq.pop()
	right_dq.append(i)
ans = 1
if x == 0 and y == 0:
	ans = 1
for i in range(n):
	while left_dq and left_dq[0] < i - x:
		left_dq.popleft()
	while right_dq and right_dq[0] <= i:
		right_dq.popleft()
	if i > 0:
		while left_dq and arr[left_dq[-1]] > arr[i - 1]:
			left_dq.pop()
		left_dq.append(i - 1)
		min_left = arr[left_dq[0]]
	else:
		min_left = float('inf')
	if i + y < n:
		while right_dq and arr[right_dq[-1]] > arr[i + y]:
			right_dq.pop()
		right_dq.append(i + y)
		min_right = arr[right_dq[0]]
	else:
		min_right = arr[right_dq[0]] if right_dq else float('inf')
	if arr[i] < min_left and arr[i] < min_right:
		ans = i + 1
		break
print(ans)


(n, x, y) = map(int, input().split())
arr = list(map(int, input().split()))
for i in range(n):
	ol = all((t > arr[i] for t in arr[i + 1:min(i + y + 1, n)]))
	uf = all((t > arr[i] for t in arr[max(i - x, 0):i]))
	if ol == True and uf == True:
		print(i + 1)
		break


from collections import *
(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
i = 0
for i in range(n):
	val = a[i]
	for j in range(max(0, i - x), min(n, i + y + 1)):
		if val > a[j]:
			break
	else:
		break
print(i + 1)


import itertools
(n, x, y) = (int(x) for x in input().split())
days = list((int(x) for x in input().split()))
for i in range(n):
	if len([rain for rain in days[max(i - x, 0):i] if days[i] < rain]) == min(i, x):
		if len([rain for rain in days[i + 1:min(i + y + 1, n)] if days[i] < rain]) == min(n - (i + 1), y):
			print(i + 1)
			break


import sys
from collections import defaultdict as dd
mod = 10 ** 9 + 7

def ri(flag=0):
	if flag == 0:
		return [int(i) for i in sys.stdin.readline().split()]
	else:
		return int(sys.stdin.readline())
(n, x, y) = ri()
a = ri()
ans = 0
for i in range(0, n):
	status = 0
	for j in range(max(0, i - x), min(n, i + y + 1)):
		if i != j and a[i] > a[j]:
			status = 1
	if status == 0:
		ans = 1
		print(i + 1)
		break


(n, x, y) = list(map(int, input().split()))
a = list(map(int, input().split()))
d = []
for i in range(n - 1):
	d.append(a[i] - a[i + 1])
t = n - 1
if x == 0 and y == 0 or (x != 0 and y == 0):
	t = 0
else:
	for i in range(n - 1):
		if d[i] < 0:
			f = 0
			g = 0
			if x > i:
				r = i
			else:
				r = x
			if n - 1 - i < y:
				s = n - 1 - i
			else:
				s = y
			for j in range(r):
				if a[i - j - 1] < a[i]:
					f = 1
					break
			for j in range(s):
				if a[i + j + 1] < a[i]:
					g = 1
					break
			if f == 0 and g == 0:
				t = i
				break
print(t + 1)


(n, x, y) = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(n):
	ans = True
	for j in range(i - x, i):
		if j >= 0 and a[j] < a[i]:
			ans = False
			break
	for j in range(i + 1, i + y + 1):
		if j < n and a[j] < a[i]:
			ans = False
			break
	if ans:
		print(i + 1)
		return


(n, x, y) = input().split()
n = int(n)
x = int(x)
y = int(y)
inp = input()
a = [int(ele) for ele in inp.split()]
for i in range(len(a)):
	flagA = 0
	flagB = 0
	if i < x:
		for j in range(i):
			if a[j] <= a[i]:
				flagA = 1
				break
		if n - i > y:
			for j in range(i + 1, i + 1 + y):
				if a[j] <= a[i]:
					flagB = 1
		else:
			for j in range(i + 1, len(a)):
				if a[j] <= a[i]:
					flagB = 1
		if flagA == 0 and flagB == 0:
			print(i + 1)
			break
	else:
		for j in range(i - x, i):
			if a[j] <= a[i]:
				flagA = 1
				break
		if n - i > y:
			for j in range(i + 1, i + 1 + y):
				if a[j] <= a[i]:
					flagB = 1
		else:
			for j in range(i + 1, len(a)):
				if a[j] <= a[i]:
					flagB = 1
		if flagA == 0 and flagB == 0:
			print(i + 1)
			break


R = lambda : list(map(int, input().split()))
(n, x, y) = R()
l = R()
for d in range(n):
	f = 0
	for j in range(max(d - x, 0), min(d + y + 1, n)):
		if j != d and l[j] <= l[d]:
			f = 1
			break
	if f == 0:
		break
print(d + 1)


(n, x, y) = (*map(int, input().split()),)
a = (*map(int, input().split()),)

def check(i):
	return all(map(lambda x: x > a[i], a[max(0, i - x):i] + a[i + 1:i + y + 1]))
for i in range(n):
	if check(i):
		print(i + 1)
		break


from sys import stdin

def main():
	(n, x, y) = [int(x) for x in stdin.readline().rstrip().split()]
	list1 = [int(x) for x in stdin.readline().rstrip().split()]
	list0 = [list1[0] + 1] * x
	list2 = [list1[-1] + 1] * y
	mainlist = list0 + list1 + list2
	for i in range(x, len(mainlist) - y):
		if all((mainlist[i] < mainlist[x1] for x1 in range(i - x, i))) and all((mainlist[i] < mainlist[y1] for y1 in range(i + 1, i + y + 1))):
			return i - x + 1
print(main())


(n, x, y) = list((int(a) for a in input().split()))
a = list((int(x) for x in input().split()))
for d in range(n):
	fail = False
	for i in range(max(d - x, 0), d):
		if a[i] <= a[d]:
			fail = True
			break
	if not fail:
		for i in range(d + 1, min(n, d + y + 1)):
			if a[i] <= a[d]:
				fail = True
				break
	if not fail:
		print(d + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(n):
	if all([a[i] < a[j] for j in range(i - x, i + y + 1) if i != j and j >= 0 and (j < n)]):
		print(i + 1)
		exit()


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
a = [10 ** 10] * x + a
a.extend([10 ** 10] * y)
n = len(a)
for i in range(x, n - y):
	c = 0
	for j in range(i - 1, i - x - 1, -1):
		if a[j] > a[i]:
			c += 1
	for k in range(i + 1, i + 1 + y):
		if a[k] > a[i]:
			c += 1
	if c == x + y:
		print(i + 1 - x)
		break


(n, x, y) = map(int, input().split(' '))
arr = list(map(int, input().split(' ')))
for index in range(0, n):
	lowI = max(0, index - x)
	pre = arr[lowI:index]
	highI = min(n - 1, index + y)
	post = arr[index + 1:highI + 1]
	mPre = min(pre) if pre else max(arr) + 1
	mPost = min(post) if post else max(arr) + 1
	if mPre > arr[index] and mPost > arr[index]:
		break
print(index + 1)


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
i = 0
f = 1
while i < len(l) and f == 1:
	j = i - 1
	cnt = 1
	f = 0
	while j > -1 and cnt <= x:
		if l[i] >= l[j]:
			f = 1
		j -= 1
		cnt += 1
	j = i + 1
	cnt = 1
	while j < len(l) and cnt <= y:
		if l[i] >= l[j]:
			f = 1
		j += 1
		cnt += 1
	if not f:
		break
	i = i + 1
print(i + 1)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(0, n, 1):
	w = 1
	for j in range(i - 1, i - x - 1, -1):
		if j >= 0:
			if a[i] >= a[j]:
				w = 0
				break
	for j in range(i + 1, i + y + 1, 1):
		if j < n:
			if a[i] >= a[j]:
				w = 0
				break
	if w == 1:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(len(a)):
	minval = 1000000001
	for left in range(1, x + 1):
		if i - left < 0:
			continue
		minval = min(minval, a[i - left])
	for right in range(1, y + 1):
		if i + right >= len(a):
			continue
		minval = min(minval, a[i + right])
	if a[i] < minval:
		print(i + 1)
		break


import math
import sys
import collections

def getdict(n):
	d = {}
	if type(n) is list:
		for i in n:
			if i in d:
				d[i] += 1
			else:
				d[i] = 1
	else:
		for i in range(n):
			t = ii()
			if t in d:
				d[t] += 1
			else:
				d[t] = 1
	return d

def cdiv(n, k):
	return n // k + (n % k != 0)

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))
MAX = 10 ** 9 + 1
(n, x, y) = mi()
d = li() + [MAX] * y
i = 0
ans = 0
while i < n:
	f = True
	for j in range(1, y + 1):
		if d[i + j] < d[i]:
			i = i + j
			ans = i
			f = False
			break
	if f:
		exit(print(i + 1))
print(ans + 1)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(n):
	f1 = True
	f2 = True
	for j in range(max(i - x, 0), i):
		if a[j] <= a[i]:
			f1 = False
	for j in range(i + 1, min(n, i + 1 + y)):
		if a[j] <= a[i]:
			f2 = False
	if f1 and f2:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
A = list(map(int, input().split()))
ans = A.index(min(A))
i = 0

def s(A, i, x, y):
	k = min(A[max(0, i - x):min(len(A), i + y + 1)])
	if min(A[max(0, i - x):min(len(A), i + y + 1)]) == A[i]:
		return True
	return False
while i <= ans - y:
	a = s(A, i, x, y)
	if s(A, i, x, y) == True:
		ans = i
		break
	i += 1
print(ans + 1)


a = list(map(int, input().split()))
n = a[0]
x = a[1]
y = a[2]
l = list(map(int, input().split()))
m = []
for i in range(0, x):
	m.append(10 ** 10)
j = 0
while j < len(l):
	m.append(l[j])
	j += 1
j = y
while j > 0:
	m.append(10 ** 10)
	j -= 1
for i in range(0, len(m)):
	list1 = m[i:x + y + i + 1]
	if m[i + x] == min(list1):
		print(i + 1)
		break


(n, x, y) = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(n):
	(j, p, t) = (1, 0, a[i])
	while j <= x and i - j >= 0:
		if a[i - j] < t:
			p = p + 1
			break
		j += 1
	j = 1
	while j <= y and i + j < n:
		if a[i + j] < t:
			p = p + 1
			break
		j += 1
	if p == 0:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(n):
	flag1 = 0
	flag2 = 0
	for j in range(max(i - x, 0), i):
		if a[j] <= a[i]:
			flag1 = 1
			break
	for j in range(i + 1, min(i + y, n - 1) + 1):
		if a[j] <= a[i]:
			flag2 = 1
			break
	if flag1 == flag2 == 0:
		print(i + 1)
		break


(days, before, after) = [int(a) for a in input().split()]
rains = [int(a) for a in input().split()]
i = 0
while rains[i] > min(rains[max(0, i - before):min(i + after + 1, days)]):
	i += 1
print(i + 1)


(n, x, y) = map(int, input().split())
li = list(map(int, input().split()))

def pirms(i):
	ele = li[i]
	for en in range(1, x + 1):
		if i - n < 0:
			continue
		if li[i - en] <= ele:
			return False
	return True

def pec(i):
	ele = li[i]
	for en in range(1, y + 1):
		if i + en >= n:
			continue
		if li[i + en] <= ele:
			return False
	return True
for e in range(len(li)):
	if pec(e) and pirms(e):
		print(e + 1)
		break


(n, x, y) = map(int, input().split(' '))
a = list(map(int, input().split()))
i = f1 = 0
while i < n:
	if i - x < 0:
		start = 0
	else:
		start = i - x
	if i + y > n - 1:
		end = n - 1
	else:
		end = i + y
	f = 0
	j = start
	while j <= end:
		if i != j:
			if a[i] < a[j]:
				j += 1
			else:
				f = 1
				break
		else:
			j += 1
	if f == 0:
		f1 = 1
		break
	i += 1
if f1 == 1:
	print(i + 1)


(n, x, y) = map(int, input().split())
(*a,) = map(int, input().split())
i = 0
while a[i] > min(a[max(0, i - x):i + y + 1]):
	i += 1
print(i + 1)


def main():
	(n, x, y) = [int(v) for v in input().split()]
	val = [int(v) for v in input().split()]
	for i in range(0, len(val)):
		before = all([v > val[i] for v in val[i - x:i]])
		after = all([v > val[i] for v in val[i + 1:i + y + 1]])
		if before and after:
			print(i + 1)
			return
main()


def mp():
	return map(int, input().split())

def xx(d):
	global a, x, n
	for i in range(max(0, d - x), d):
		if a[i] <= a[d]:
			return False
	return True

def yy(d):
	global a, y, n
	for i in range(d + 1, min(n, d + y + 1)):
		if a[i] <= a[d]:
			return False
	return True
(n, x, y) = mp()
a = list(mp())
for i in range(n):
	if xx(i) and yy(i):
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for (d, ad) in enumerate(a):
	inf = ad + 1
	l = max(0, d - x)
	l_min = min(a[l:d]) if l < d else inf
	r = min(n - 1, d + y)
	r_min = min(a[d + 1:r + 1]) if d < r else inf
	if ad < min(l_min, r_min):
		print(d + 1)
		break


(A, B, C) = input().split()
n = int(A)
x = int(B)
y = int(C)
d = list(map(int, input().split()))
for i in range(n):
	t = 0
	j = i - 1
	while j >= 0 and j >= i - x:
		if d[i] > d[j]:
			t = 1
			break
		j += -1
	j = i + 1
	while j < n and j <= i + y:
		if d[i] > d[j]:
			t = 1
			break
		j += 1
	if t == 0:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
cnt = 0
tcnt = 0
for i in range(n):
	if n == 1:
		print(1)
		break
	if i == 0:
		min_ele1 = 10 ** 9 + 1
		if y == 0:
			min_ele2 = 10 ** 9 + 1
		else:
			min_ele2 = min(a[i + 1:min(n, i + 1 + y)])
	elif i == n - 1:
		if x == 0:
			min_ele1 = 10 ** 9 + 1
		else:
			min_ele1 = min(a[max(0, i - x):i])
		min_ele2 = 10 ** 9 + 1
	else:
		if x == 0:
			min_ele1 = 10 ** 9 + 1
		else:
			min_ele1 = min(a[max(0, i - x):i])
		if y == 0:
			min_ele2 = 10 ** 9 + 1
		else:
			min_ele2 = min(a[i + 1:min(n, i + 1 + y)])
	if a[i] < min_ele1 and a[i] < min_ele2:
		print(i + 1)
		break


import os
import sys
import string
import math

def main(rains, x, y):
	for i in range(len(rains)):
		if min(rains[max(0, i - x):min(len(rains), i + y + 1)]) == rains[i]:
			return i + 1

def parse():
	(n, x, y) = [int(s) for s in input().split(' ')]
	rains = [int(s) for s in input().split(' ')]
	return (rains, x, y)

def output(ans):
	print(ans)
output(main(*parse()))


(n, x, y) = map(int, input().split())
a = []
if n == 1:
	print(1)
	exit()
a.extend([1000000000] * x)
a.extend(list(map(int, input().split())))
a.extend([1000000000] * y)
for i in range(x, n):
	if a[i] == min(a[i - x:i + y + 1]):
		print(i + 1 - x)
		exit()
print(a.index(min(a)) + 1 - x)


def solve(n, x, y, seq):

	def is_min(idx, subseq):
		for i in range(len(subseq)):
			if i != idx and subseq[i] <= subseq[idx]:
				return False
		return True
	seq = [10 ** 9 + 1] * x + seq + [10 ** 9 + 1] * y
	for i in range(len(seq) - (x + y)):
		if is_min(x, seq[i:i + x + y + 1]):
			return i + x
(n, x, y) = [int(s) for s in input().split(' ')]
seq = [int(s) for s in input().split(' ')]
out = solve(n, x, y, seq)
out += 1 - x
print('{}'.format(out))


(n, x, y) = [int(x) for x in input().split()]
a = list(map(int, input().split()))
ans = 0
for i in range(n):
	l = max(0, i - x)
	r = min(n - 1, i + y)
	f = 0
	for j in range(l, r + 1):
		if a[i] > a[j]:
			f = 1
			break
	if not f:
		print(i + 1)
		exit()


import sys
input = sys.stdin.readline
(n, x, y) = map(int, input().split())
A = [1 << 50] + list(map(int, input().split())) + [1 << 50]
for i in range(1, n + 1):
	if (x == 0 or min(A[max(0, i - x):i]) > A[i]) and (y == 0 or min(A[i + 1:min(i + y + 1, n + 2)]) > A[i]):
		print(i)
		sys.exit()


f = lambda : map(int, input().split())
(n, x, y) = f()
arr = list(map(int, input().split()))
for i in range(n):
	if arr[i] == min(arr[i - x if i >= x else 0:i + y + 1]):
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(n):
	f = True
	q = a[i]
	w = 1
	while w <= x and i - w >= 0:
		if a[i] > a[i - w]:
			f = False
			break
		w += 1
	w = 1
	while w <= y and i + w < n:
		if a[i] > a[i + w]:
			f = False
			break
		w += 1
	if f:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
sp = list(map(int, input().split()))
for i in range(0, n):
	k = 0
	sx = 0
	d = 0
	j1 = 0
	j2 = 0
	min1 = 10000000000000000
	if i < x:
		j1 = 0
	else:
		j1 = i - x
	if i > n - y - 1:
		j2 = n
	else:
		j2 = i + y + 1
	for j in range(j1, i):
		min1 = min(min1, sp[j])
	if sp[i] >= min1:
		continue
	min1 = sp[i]
	for j in range(i + 1, j2):
		if min1 >= sp[j]:
			d = 1
			break
	if d == 0:
		print(i + 1)
		break


def input_to_list(inp):
	inp = inp.split(' ')
	inp = [int(i) for i in inp]
	return inp
(n, x, y) = input_to_list(input())
a_s = input_to_list(input())
for i in range(0, len(a_s)):
	trigger = True
	left = min(x, i)
	right = min(y, len(a_s) - i - 1)
	for j in a_s[i - left:i]:
		if j <= a_s[i]:
			trigger = False
			break
	if trigger:
		for k in a_s[i + 1:i + right + 1]:
			if k <= a_s[i]:
				trigger = False
				break
	if trigger:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
ind = -1
for i in range(n):
	flag = True
	for j in range(i - x, i + y + 1):
		if j < n and j >= 0:
			if a[j] < a[i]:
				flag = False
				break
	if flag:
		ind = i + 1
		break
print(ind)


import sys

def input():
	return sys.stdin.readline().strip()

def iinput():
	return int(input())

def minput():
	return map(int, input().split())

def listinput():
	return list(map(int, input().split()))
(n, x, y) = minput()
a = listinput()
earliest = 0
while a[earliest] > min(a[max(0, earliest - x):earliest + y + 1]):
	earliest += 1
print(earliest + 1)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
t = False
a.insert(0, 0)
for i in range(1, n + 1):
	c = True
	for j in range(max(1, i - x), min(n + 1, i + y + 1)):
		if a[j] < a[i] and j != i:
			c = False
	if c == True and t == False:
		print(i)
		t = True


(daynum, before, after) = [int(x) for x in input().split(' ')]
days = [int(x) for x in input().split(' ')]
for i in range(daynum):
	rainy = 0
	for k in range(1, before + 1):
		if i - k >= 0 and days[i - k] <= days[i]:
			rainy = 1
			break
	for k in range(1, after + 1):
		if i + k <= daynum - 1 and days[i + k] <= days[i]:
			rainy = 1
			break
	if rainy == 0:
		print(i + 1)
		break


(n, x, y) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
p = n
for i in range(n):
	x1 = x
	y1 = y
	k = 0
	if i + 1 > x1:
		while x1 != 0:
			if a[i] >= a[i - x1]:
				k += 1
			x1 -= 1
	else:
		j = 0
		while j != i:
			if a[i] >= a[j]:
				k += 1
			j += 1
	if n - i > y1:
		while y1 != 0:
			if a[i] >= a[i + y1]:
				k += 1
			y1 -= 1
	elif i != n - 1:
		j = i + 1
		while j != n:
			if a[i] >= a[j]:
				k += 1
			j += 1
	if k == 0 and i < p:
		p = i
print(p + 1)


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
for i in range(n):
	g = 0
	for j in range(i - 1, max(0, i - x) - 1, -1):
		if l[j] < l[i]:
			g = 1
	for j in range(i + 1, min(n - 1, i + y) + 1):
		if l[j] < l[i]:
			g = 1
	if g == 0:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
arr = list(map(int, input().split()))
for i in range(n):
	smallest = True
	for j in range(i + 1, min(n, i + y + 1)):
		if arr[j] < arr[i]:
			smallest = False
			break
	if smallest:
		for j in range(i - 1, max(-1, i - x - 1), -1):
			if arr[j] < arr[i]:
				smallest = False
				break
	if smallest:
		print(i + 1)
		break


(n, x, y) = input().split()
amountOfRain = input().split()
isBreak = False
condition = 0
for (index, element) in enumerate(amountOfRain):
	isBreak = False
	if index < int(x):
		condition = index + 1
	else:
		condition = int(x) + 1
	for daysBefore in range(1, condition):
		if int(amountOfRain[index - daysBefore]) < int(element):
			isBreak = True
			break
	if isBreak == False:
		if index > int(n) - 1 - int(y):
			condition = int(n) - index
		else:
			condition = int(y) + 1
		for daysAfter in range(1, condition):
			if int(amountOfRain[index + daysAfter]) < int(element):
				isBreak = True
				break
		if isBreak == False:
			print(index + 1)
			quit()


(n, a, b) = map(int, input().split())
arr = list(map(int, input().split()))
for i in range(0, n):
	if arr[i] == min(arr[max(0, i - a):min(i + b + 1, n)]):
		print(i + 1)
		break


import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
from itertools import permutations as p
sys.setrecursionlimit(100000000)
inp = lambda : int(input())
strng = lambda : input().strip()
jn = lambda x, l: x.join(map(str, l))
strl = lambda : list(input().strip())
mul = lambda : map(int, input().strip().split())
mulf = lambda : map(float, input().strip().split())
seq = lambda : list(map(int, input().strip().split()))
ceil = lambda x: int(x) if x == int(x) else int(x) + 1
ceildiv = lambda x, d: x // d if x % d == 0 else x // d + 1
flush = lambda : stdout.flush()
stdstr = lambda : stdin.readline()
stdint = lambda : int(stdin.readline())
stdpr = lambda x: stdout.write(str(x))
mod = 1000000007
(n, x, y) = mul()
l = seq()
for i in range(n):
	if l[i] == min(l[max(i - x, 0):min(i + y + 1, n)]):
		print(i + 1)
		break


n = input().split(' ')
n = list(map(int, n))
arr = input().split(' ')
arr = list(map(int, arr))
ans = 0
for i in range(0, len(arr)):
	if i < n[1]:
		flag = 1
		for j in range(i - 1, -1, -1):
			if arr[i] > arr[j]:
				flag = -1
				break
	else:
		flag = 1
		for j in range(i - 1, i - n[1], -1):
			if arr[i] > arr[j]:
				flag = -1
				break
	if flag == 1:
		if i + n[2] < len(arr):
			flag1 = 1
			for j in range(i + 1, i + n[2] + 1):
				if arr[i] > arr[j]:
					flag1 = -1
					break
		else:
			flag1 = 1
			for j in range(i + 1, len(arr)):
				if arr[i] > arr[j]:
					flag1 = -1
					break
		if flag1 == 1:
			ans = i + 1
			break
print(ans)


import sys
import os
from io import BytesIO, IOBase

def ceil(n, k):
	return n // k + (n % k != 0)

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))

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

def prr(a, sep=' '):
	print(sep.join(map(str, a)))

def dd():
	return defaultdict(int)

def ddl():
	return defaultdict(list)

def ddd():
	return defaultdict(defaultdict(int))
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from collections import defaultdict
for _ in range(1):
	(n, x, y) = mi()
	a = li()
	idx = -1
	for i in range(n):
		f = 0
		j = max(0, i - x)
		while j < i:
			if a[i] > a[j]:
				f = 1
				break
			j += 1
		j = min(n - 1, i + y)
		while j > i:
			if a[i] > a[j]:
				f = 1
				break
			j -= 1
		if f == 0:
			idx = i + 1
			break
	print(idx)


ints = [int(x) for x in input().split()]
days = [int(x) for x in input().split()]
for i in range(ints[0]):
	pos = True
	for j in range(min(ints[1], i)):
		if days[i - j - 1] < days[i]:
			pos = False
			break
	for k in range(min(ints[2], ints[0] - i - 1)):
		if days[i + k + 1] < days[i]:
			pos = False
			break
	if pos == True:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
s = list(map(int, input().split()))
for i in range(n):
	a = s[max(0, i - x):i]
	b = s[i + 1:min(n, i + 1 + y)]
	if len(a) == 0:
		a.append(float('inf'))
	if len(b) == 0:
		b.append(float('inf'))
	if s[i] < min(a) and s[i] < min(b):
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = [int(i) for i in input().split()]
for d in range(n):
	j = d - 1
	(f1, f2) = (0, 0)
	while j >= d - x:
		if j < 0:
			break
		if a[d] >= a[j]:
			f1 = 1
			break
		j -= 1
	j = d + 1
	while j <= d + y:
		if j > n - 1:
			break
		if a[d] >= a[j]:
			f2 = 1
			break
		j += 1
	if f1 == 0 and f2 == 0:
		print(d + 1)
		break


(n, x, y) = map(int, input().rstrip().split())
A = list(map(int, input().rstrip().split()))
for i in range(len(A)):
	flag = 0
	for j in range(1, x + 1):
		if i - j >= 0:
			if A[i - j] <= A[i]:
				flag = 1
				break
	flag2 = 0
	for j in range(1, y + 1):
		if i + j < n:
			if A[i + j] <= A[i]:
				flag2 = 1
				break
	if flag == 0 and flag2 == 0:
		break
print(i + 1)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
a = [10 ** 10 for _ in range(x)] + a
a = a + [10 ** 10 for _ in range(y)]
for i in range(n):
	if a[i + x] == min(a[i:i + x + y + 1]):
		ans = i + 1
		break
print(ans)


inf = float('inf')
(n, x, y) = map(int, input().split())
arr = [inf] * 10 + list(map(int, input().split())) + [inf] * 10
for i in range(10, 10 + n):
	flag = True
	for j in range(i - x, i):
		if arr[j] <= arr[i]:
			flag = False
			break
	for j in range(i + 1, i + y + 1):
		if arr[j] <= arr[i]:
			flag = False
			break
	if flag:
		print(i - 9)
		exit()


nxy = input()
a = input()
nxy = list(map(int, nxy.split()))
(n, x, y) = nxy
a = list(map(int, a.split()))
now_min = 100007
for i in range(n):
	minValue = min(a[max(0, i - x):min(n, i + y + 1)])
	if a[i] == minValue:
		print(i + 1)
		break


(n, x, y) = [int(s) for s in input().split()]
INF = 10 ** 20
a = [INF] * x + [int(s) for s in input().split()] + [INF] * y
if x > 0 and y > 0:
	for i in range(x, n + x):
		if min(a[i - x:i]) > a[i] < min(a[i + 1:i + y + 1]):
			print(i - x + 1)
			break
elif x > 0:
	for i in range(x, n + x):
		if min(a[i - x:i]) > a[i]:
			print(i - x + 1)
			break
elif y > 0:
	for i in range(x, n + x):
		if a[i] < min(a[i + 1:i + y + 1]):
			print(i - x + 1)
			break
else:
	print(1)


import sys
import math as mt
input = sys.stdin.buffer.readline
t = 1
for _ in range(t):
	(n, x, y) = map(int, input().split())
	l = list(map(int, input().split()))
	for i in range(n):
		ch = 0
		for i1 in range(max(i - x, 0), min(i + y + 1, n)):
			if i1 != i and l[i1] <= l[i]:
				ch = 1
				break
		if ch == 0:
			ans = i + 1
			break
	print(ans)


(n, x, y) = [int(x) for x in input().strip().split()]
arr = [int(x) for x in input().strip().split()]
temp = -1
for i in range(0, n):
	l_range = i - x
	r_range = i + y
	l_flag = True
	r_flag = True
	for j in range(i - 1, l_range - 1, -1):
		if j < 0:
			break
		if arr[i] >= arr[j]:
			l_flag = False
			break
	for j in range(i + 1, r_range + 1):
		if j > n - 1:
			break
		if arr[i] >= arr[j]:
			r_flag = False
			break
	temp = i
	if l_flag and r_flag:
		break
print(temp + 1)


str1 = input().split()
n = int(str1[0])
x = int(str1[1])
y = int(str1[2])
str2 = list(map(int, input().split()))
j = 0
if n == 1:
	print(1)
for i in range(1, n):
	if str2[i] < str2[j]:
		if i - j > y:
			print(j + 1)
			break
		j = i
	if i == n - 1:
		print(j + 1)


import sys
input = sys.stdin.readline
import collections
(n, x, y) = map(int, input().split())
A = [int(i) for i in input().split()]
A = [float('inf')] * x + A + [float('inf')] * y
if x == 0:
	CL = [True] * n
else:
	CL = [False] * n
	L = collections.deque(A[:x])
	for i in range(n):
		if A[i + x] < min(L):
			CL[i] = True
		L.popleft()
		L.append(A[i + x])
if y == 0:
	CR = [True] * n
else:
	CR = [False] * n
	R = collections.deque(A[n + x:])
	for i in reversed(range(n)):
		if A[i + x] < min(R):
			CR[i] = True
		R.pop()
		R.appendleft(A[i + x])
for i in range(n):
	if CR[i] == True and CL[i] == True:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
inf = 10 ** 10
a = [inf] * 7 + list(map(int, input().split())) + [inf] * 7
for i in range(7, n + 7):
	if a[i] < (min(a[i - x:i]) if x else inf) and a[i] < (min(a[i + 1:i + y + 1]) if y else inf):
		print(i - 6)
		exit()


import sys
(n, x, y) = map(int, sys.stdin.readline().split())
chis = [*map(int, sys.stdin.readline().split())]
(x1, y1) = (x, y)
for i in range(0, n):
	if i - x1 < 0:
		x1 = x1 - i
	if i + 1 + y1 > n:
		y1 = n
	mas = chis[i - x1:i] + chis[i + 1:i + y1 + 1]
	if len(mas) > 0:
		mina = min(mas)
	else:
		sys.stdout.write(str(i + 1))
		break
	if mina > chis[i]:
		sys.stdout.write(str(i + 1))
		break
	(x1, y2) = (x, y)


(n, x, y) = map(int, input().split())
arr = list(map(int, input().split()))
a = []
b = []
for i in range(n):
	a = []
	for j in range(max(i - x, 0), min(i + y + 1, n)):
		if i != j:
			a.append(arr[j])
	if not a:
		print(i + 1)
		exit(0)
	if min(a) > arr[i]:
		print(i + 1)
		exit(0)


import heapq
from collections import Counter
(n, x, y) = map(int, input().split())
rain = list(map(int, input().split()))
before = []
after = rain[1:min(y + 1, len(rain))]
heapq.heapify(after)
after_deleted = Counter()
before_deleted = Counter()
for (i, amount) in enumerate(rain):
	while before and before_deleted[before[0]]:
		before_deleted[before[0]] -= 1
		heapq.heappop(before)
	while after and after_deleted.get(after[0], 0):
		after_deleted[after[0]] -= 1
		heapq.heappop(after)
	if (not before or amount < before[0]) and (not after or amount < after[0]):
		print(i + 1)
		break
	if i - x >= 0:
		before_deleted[rain[i - x]] += 1
	heapq.heappush(before, amount)
	if i + 1 < len(rain):
		after_deleted[rain[i + 1]] += 1
	if i + y + 1 < len(rain):
		heapq.heappush(after, rain[i + y + 1])


z = lambda : map(int, input().split())
(a, b, c) = z()
d = list(z())
print([i for i in range(a) if d[i] <= min(d[max(0, i - b):i + c + 1])][0] + 1)


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
for i in range(0, n):
	day = l[i]
	p = i - x
	if p < 0:
		p = 0
	li1 = l[p:i]
	k = i + y + 1
	if k > n:
		k = n
	li2 = l[i + 1:k]
	li1.append(9999999999)
	li2.append(9999999999)
	if min(li1) > day and min(li2) > day:
		break
print(l.index(day) + 1)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
cy = 0
j = 0
i = 1
while i < n and cy != y:
	if a[i] >= a[j]:
		cy = cy + 1
	else:
		j = i
		cy = 0
	i = i + 1
print(j + 1)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
ans = 0
while a[ans] != min(a[max(ans - x, 0):min(ans + y + 1, n)]):
	ans += 1
print(ans + 1)


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))

def le(i):
	for j in range(1, x + 1):
		if i - j > -1:
			if l[i - j] <= l[i]:
				return False
		else:
			break
	return True

def r(i):
	for j in range(1, y + 1):
		if i + j < n:
			if l[i + j] <= l[i]:
				return False
		else:
			break
	return True
for i in range(n):
	if le(i) and r(i):
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
now = top = 0
left = right = False
for i in range(n):
	for j in range(i - 1, max(-1, i - x - 1), -1):
		if a[j] < a[i]:
			break
	else:
		for j in range(i + 1, min(n, i + y + 1)):
			if a[j] < a[i]:
				break
		else:
			break
print(i + 1)


(n, x, y) = map(int, input().split())
ar = list(map(int, input().split()))
for i in range(n):
	ans = 'yes'
	z = i - x
	if z < 0:
		z = 0
	for j in range(z, i):
		if ar[j] <= ar[i]:
			ans = 'no'
			break
	for j in range(i + 1, i + 1 + y):
		if j < n:
			if ar[j] <= ar[i]:
				ans = 'no'
				break
	if ans == 'yes':
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for q in range(n):
	min1 = float('inf')
	for q1 in range(max(0, q - x - 1), q):
		min1 = min(min1, a[q1])
	for q1 in range(q + 1, min(n, q + y + 1)):
		min1 = min(min1, a[q1])
	if min1 > a[q]:
		print(q + 1)
		break


(n, l, r) = tuple(map(int, input().split()))
days = list(map(int, input().split()))
for day in range(0, n):
	found = True
	for compare_day in range(max(day - l, 0), min(day + r + 1, n)):
		if days[compare_day] == days[day]:
			continue
		elif days[compare_day] < days[day]:
			found = False
			break
	if found:
		print(day + 1)
		break


inputs = input().split(' ')
n = int(inputs[0])
x = int(inputs[1])
y = int(inputs[2])
nums = input().split(' ')
arr = []
for i in nums:
	arr.append(int(i))
for z in range(n):
	flag = 0
	for a in range(x):
		if z - (a + 1) >= 0 and z - (a + 1) < n:
			if arr[z] >= arr[z - (a + 1)]:
				flag = 1
	for b in range(y):
		if z + (b + 1) >= 0 and z + (b + 1) < n:
			if arr[z] >= arr[z + (b + 1)]:
				flag = 1
	if flag == 0:
		print(z + 1)
		break


(n, x, y) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
minleft = 10 ** 10
minright = 10 ** 10
for (i, v) in enumerate(a):
	minl = min(a[max(0, i - x):i], default=10 ** 10)
	minr = min(a[i + 1:i + y + 1], default=10 ** 10)
	if v < minl and v < minr:
		print(i + 1)
		break


try:
	a = []
	ans = 0
	(n, x, y) = map(int, input().split())
	a = list(map(int, input().split()))
	for i in range(n):
		if (a[i - x if i - x >= 0 else 0:i] == [] or min(a[i - x if i - x >= 0 else 0:i]) > a[i]) and (a[i + 1:i + y + 1 if i + y + 1 <= n else n] == [] or min(a[i + 1:i + y + 1 if i + y + 1 <= n else n]) > a[i]):
			ans = i
			break
	print(ans + 1)
except EOFError:
	pass


l1 = [int(x) for x in input().split()]
(n, x, y) = (l1[0], l1[1], l1[2])
l2 = [int(x) for x in input().split()]
for i in range(n):
	ruined = 0
	if i < x:
		left = 0
	else:
		left = i - x
	if i + y > n - 1:
		right = n - 1
	else:
		right = i + y
	j = i - 1
	while j >= 0 and j >= left:
		if l2[i] >= l2[j]:
			ruined = 1
			break
		j -= 1
	j = i + 1
	while j < len(l2) and j <= right:
		if l2[i] >= l2[j]:
			ruined = 1
			break
		j += 1
	if ruined:
		pass
	else:
		break
print(i + 1)


[n, x, y] = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
for i in range(n):
	valid = True
	for j in range(i - x, i + y + 1):
		if j == i:
			continue
		if j >= n:
			continue
		if j < 0:
			continue
		if a[j] < a[i]:
			valid = False
	if valid:
		print(i + 1)
		exit()


l = list(map(int, input().split(' ')))
x = l[1]
y = l[2]
t = list(map(int, input().split(' ')))
for i in range(0, len(t)):
	if i - x < 0:
		m = 0
	else:
		m = i - x
	if i + y == len(t):
		p = len(t)
	else:
		p = i + y
	maxi = min(t[m:i + 1])
	mini = min(t[i:p + 1])
	if t[i] <= maxi and t[i] <= mini:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
t = 0
ans = 0
for i in range(n):
	(f1, f2) = (0, 0)
	(p, q) = (i + 1, i - 1)
	while p <= i + y and p <= n - 1:
		if a[i] < a[p]:
			p += 1
		else:
			f1 = 1
			break
	while q >= 0 and q >= i - y:
		if a[i] < a[q]:
			q -= 1
		else:
			f2 = 1
			break
	if f1 == 0 and f2 == 0:
		ans = i + 1
		break
print(ans)


ip = [int(i) for i in input().split()]
(x, y) = (ip[1], ip[2])
arr = [int(i) for i in input().split()]
l = len(arr)
for i in range(l):
	rainy = False
	lr = i - x
	rr = i + y
	if lr < 0:
		if not i == 0:
			for j in range(i - 1, 0, -1):
				if arr[i] > arr[j]:
					rainy = True
					break
	else:
		for j in range(i - 1, lr - 1, -1):
			if arr[i] > arr[j]:
				rainy = True
				break
	if rr >= l and rainy == False:
		if not i == l - 1:
			for j in range(i + 1, l):
				if arr[i] > arr[j]:
					rainy = True
					break
	elif rainy == False:
		for j in range(i + 1, rr + 1):
			if arr[i] > arr[j]:
				rainy = True
				break
	if rainy is False:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
if x + y >= n:
	print(a.index(min(a)) + 1)
else:
	for i in range(n):
		ele = a[i]
		be = 0
		af = 0
		for j in range(max(i - 1, 0), max(-1, i - x - 1), -1):
			if a[j] > ele:
				be += 1
			else:
				break
		for k in range(min(i + 1, n - 1), min(i + y + 1, n)):
			if a[k] > ele:
				af += 1
			else:
				break
		if be + af == min(i + y + 1, n) - max(-1, i - x - 1) - 2:
			ans = i + 1
			break
	print(ans)


(n, x, y) = list(map(int, input().split()))
List = list(map(int, input().split()))
for i in range(n):
	j = i - 1
	count_x = x - 1
	c = 0
	while j >= 0 and count_x >= 0:
		if List[i] >= List[j]:
			c += 1
			break
		j -= 1
		count_x -= 1
	if c > 0:
		continue
	j = i + 1
	count_y = y - 1
	while j < n and count_y >= 0:
		if List[i] >= List[j]:
			c += 1
			break
		j += 1
		count_y -= 1
	if c > 0:
		continue
	else:
		break
print(i + 1)


(n, x, y) = list(map(int, input().split()))
li = list(map(int, input().split()))
for i in range(len(li)):
	if i < x:
		do = li[:i]
	else:
		do = li[i - x:i]
	if n - i - 1 < y:
		posle = li[i + 1:]
	else:
		posle = li[i + 1:i + y + 1]
	if len(posle) == 0:
		posle.append(max(li))
	if len(do) == 0:
		do.append(max(li))
	if sorted(do)[0] >= li[i] and sorted(posle)[0] >= li[i]:
		print(i + 1)
		break


import sys
(n, x, y) = map(int, input().split())
(*a,) = map(int, input().split())
for i in range(n):
	for j in range(max(0, i - x), i):
		if a[j] <= a[i]:
			break
	else:
		for k in range(i + 1, min(i + y + 1, n)):
			if a[k] <= a[i]:
				break
		else:
			print(i + 1)
			sys.exit(0)


(n, x, y) = map(int, input().split(' '))
rainingday = list(map(int, input().split(' ')))
stack = [0]
left = [0 for i in range(n)]
right = [n - 1 for i in range(n)]
for i in range(1, n):
	while len(stack) != 0 and rainingday[stack[-1]] >= rainingday[i]:
		right[stack[-1]] = i - 1
		stack.pop()
	if len(stack) != 0:
		left[i] = stack[-1] + 1
	else:
		left[i] = 0
	stack.append(i)
for i in range(n):
	if i - left[i] >= x and right[i] - i >= y:
		print(i + 1)
		break
	elif (left[i] == 0 or i - left[i] >= x) and (right[i] == n - 1 or right[i] - i >= y):
		print(i + 1)
		break


a = input()
b = input()
a = list(map(int, a.split()))
b = list(map(int, b.split()))
x = a[1]
y = a[2]

def legit(b, i, d):
	if i < 0 or i >= len(b):
		return True
	elif b[i] > d:
		return True
	return False
for i in range(len(b)):
	abort = False
	for j in range(1, x + 1):
		if legit(b, i - j, b[i]):
			continue
		else:
			abort = True
			break
	if abort is True:
		continue
	for k in range(1, y + 1):
		if legit(b, i + k, b[i]):
			continue
		else:
			abort = True
			break
	if abort is False:
		print(i + 1)
		break


from heapq import heappush, heappop
from collections import deque
import itertools
from itertools import permutations
import sys
import bisect
sys.setrecursionlimit(10 ** 6)

def MI():
	return map(int, input().split())

def I():
	return int(input())

def LI():
	return [int(i) for i in input().split()]
YN = ['Yes', 'No']
YNeos = 'YNeos'
GYN = ['Yes', 'trumpet']
mo = 10 ** 9 + 7
imp = 'IMPOSSIBLE'
(n, x, y) = LI()
q = deque()
a = LI()
b = [0] * n
for i in range(n):
	b[i] = min(a[max(0, i - x):min(i + y + 1, n)])
for i in range(n):
	if b[i] == a[i]:
		print(i + 1)
		break


import sys
input = sys.stdin.readline
(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
for i in range(n):
	li = max(0, i - x)
	ri = min(n, i + y + 1)
	if l[i] == min(l[li:ri]):
		print(i + 1)
		exit(0)


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
for i in range(n):
	j = i - x
	k = i + y
	if j < 0:
		j = 0
	if k >= n:
		k = n - 1
	if all((l[i] < arr for arr in l[j:i])) and all((l[i] < brr for brr in l[i + 1:k + 1])):
		print(i + 1)
		break


def cityday(a, x, y):
	for i in range(len(a)):
		valid = True
		for j in range(i - 1, min(i - x + 1, -1) - 1):
			if a[i] > a[j]:
				valid = False
				break
		if not valid:
			continue
		for j in range(i + 1, min(i + y + 1, len(a)), 1):
			if a[i] > a[j]:
				valid = False
				break
		if valid:
			return i + 1
(n, x, y) = tuple(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
print(cityday(a, x, y))


(n, x, y) = map(int, input().split())
a = (*map(int, input().split()),)
for k in range(n):
	v = 1
	for l in range(max(0, k - x), k):
		v &= a[k] < a[l]
	for l in range(k + 1, min(k + y + 1, n)):
		v &= a[k] < a[l]
	if v:
		print(k + 1)
		break


(n, x, y) = map(int, input().split())
arr = list(map(int, input().split()))
flag = False
i = 0
while i < x:
	flag = True
	temp = arr[i]
	j = i - 1
	while j >= 0 and j >= i - x:
		if temp < arr[j]:
			j -= 1
		else:
			flag = False
			break
	if flag:
		j = i + 1
		while j < n and j <= i + y:
			if temp < arr[j]:
				j += 1
			else:
				flag = False
				break
		if flag:
			print(i + 1)
			break
	i += 1
i = 0
if not flag:
	while i < n:
		while not i + x < n:
			x -= 1
		temp = arr[i + x]
		j = i + x - 1
		flag = True
		while j >= i:
			if temp < arr[j]:
				j -= 1
			else:
				flag = False
				break
		if flag:
			j = i + x + 1
			while j < n and j <= i + x + y:
				if temp < arr[j]:
					j += 1
				else:
					flag = False
					break
			if flag or j == n:
				print(i + x + 1)
				break
		i += 1


(n, x, y) = map(int, input().split())
z = list(map(int, input().split()))
tra = 0
for i in range(len(z)):
	d = i
	flag = 0
	for t in range(max(i - x, 0), i):
		if z[t] <= z[i]:
			flag = 1
			break
	for t in range(i + 1, min(i + y + 1, len(z))):
		if z[t] <= z[i]:
			flag = 1
			break
	if flag == 0:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = [int(s) for s in input().split()]
ans = 1
for i in range(n):
	ok = True
	for j in range(i - 1, i - x - 1, -1):
		if j < 0:
			break
		if a[j] < a[i]:
			ok = False
			break
	if not ok:
		continue
	for j in range(i + 1, i + y + 1):
		if j >= n:
			break
		if a[j] < a[i]:
			ok = False
			break
	if ok:
		ans = i + 1
		break
print(ans)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(n):
	g = True
	for j in range(max(0, i - x), i):
		if a[j] <= a[i]:
			g = False
	for j in range(i + 1, min(n, i + y + 1)):
		if a[j] <= a[i]:
			g = False
	if g:
		print(i + 1)
		exit()


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(n):
	flag = True
	l = i - 1
	r = i + 1
	while l >= 0 and i - l <= x:
		if a[l] <= a[i]:
			flag = False
		l -= 1
	while r < n and r - i <= y:
		if a[r] <= a[i]:
			flag = False
		r += 1
	if flag == True:
		print(i + 1)
		return


(n, x, y) = map(int, input().split())
a = [int(s) for s in input().split()]
for i in range(n):
	ai = a[i]
	for j in range(max(0, i - x), i):
		if a[j] < ai:
			break
	else:
		for j in range(i + 1, min(n, i + y + 1)):
			if a[j] < ai:
				break
		else:
			print(i + 1)
			break


line1 = input()
line1 = line1.split()
k = int(line1[0])
bef = int(line1[1])
aft = int(line1[2])
line2 = input()
line2 = line2.split()
line2 = list(map(int, line2))
length = len(line2)
line2 = [2 * 10 ** 9] * bef + line2 + [2 * 10 ** 9] * aft
for i in range(length):
	el = line2[bef + i]
	if all(list(map(lambda x: x > el, line2[i:bef + i]))) and all(list(map(lambda x: x > el, line2[bef + i + 1:bef + aft + i + 1]))):
		print(i + 1)
		break


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

def is_not_so_rainy(n, x, y, a, i):
	for j in range(max(0, i - x), i):
		if a[j] <= a[i]:
			return False
	for j in range(i + 1, min(i + y + 1, n)):
		if a[j] <= a[i]:
			return False
	return True

def find_not_so_rainy(n, x, y, a):
	for i in range(n):
		if is_not_so_rainy(n, x, y, a, i):
			return i + 1
	return None
print(find_not_so_rainy(n, x, y, a))


(a, b, c) = map(int, input().split())
l = list(map(int, input().split()))
for i in range(a):
	if l[i] == min(l[max(0, i - b):min(a, i + c + 1)]):
		print(i + 1)
		break


(amount, x, y) = map(int, input().split())
days = list(map(int, input().split()))
for i in range(len(days)):
	curr_weather = days[i]
	bottom_border = max(0, i - x)
	top_border = min(i + y + 1, amount)
	check = False
	for j in range(bottom_border, i):
		if days[j] < curr_weather:
			check = True
			break
	if check:
		continue
	for j in range(i + 1, top_border):
		if days[j] < curr_weather:
			check = True
			break
	if check is False:
		print(i + 1)
		break


(n, a, b) = map(int, input().split())
lis = [10000000000] * a + list(map(int, input().split())) + [10000000000] * b
for i in range(a, n + a):
	if lis[i] == min(lis[i - a:i + b + 1]):
		print(i + 1 - a)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
a.insert(0, 0)
for i in range(1, n + 1):
	c = 0
	p = i - x
	if p < 1:
		p = 1
	f = i + y
	if f > n:
		f = n
	for j in range(p, i):
		if a[i] < a[j]:
			c += 1
	for j in range(i + 1, f + 1):
		if a[i] < a[j]:
			c += 1
	if c == i - p + f - i:
		print(i)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(0, n + 1):
	C = []
	if i - x > 0:
		b = i - x
	else:
		b = 0
	if i + y < n:
		e = i + y + 1
	else:
		e = n
	for r in range(b, e):
		C.append(a[r])
	if a[i] == min(C):
		print(i + 1)
		break
else:
	assert False


flag = True
if flag:
	t = input().strip().split(' ')
	assert len(t) == 3
	t = [int(e) for e in t]
	(n, x, y) = t
	t = input().strip().split(' ')
	t = [int(e) for e in t]
	a = t
	assert len(a) == n

def check(index):
	for i in range(index - 1, index - x - 1, -1):
		if i < 0:
			break
		if a[i] <= a[index]:
			return False
	for i in range(index + 1, index + y + 1):
		if i >= n:
			break
		if a[i] <= a[index]:
			return False
	return True
for index in range(n):
	if check(index):
		print(index + 1)
		exit(0)


(n, x, y) = [int(x) for x in input().split(' ')]
alist = [int(x) for x in input().split(' ')]
for i in range(n):
	yon = 0
	for j in range(min(i, x)):
		if alist[i - j - 1] <= alist[i]:
			yon = 1
			break
	for k in range(min(y, n - i - 1)):
		if alist[i + k + 1] <= alist[i]:
			yon = 1
			break
	if yon == 0:
		break
print(i + 1)


(n, x, y) = [int(i) for i in input().split()]
arr = [int(i) for i in input().split()]
m = 0
while True:
	a = True
	b = True
	i = m - x
	j = m + 1
	while i > 0 and i < m:
		if arr[i] < arr[m]:
			a = False
			break
		i += 1
	if not a:
		m += 1
		continue
	while j < n and j < m + y + 1:
		if arr[j] < arr[m]:
			b = False
			break
		j += 1
	if not b:
		m += 1
		continue
	else:
		print(m + 1)
		break


line1 = input()
line2 = input()
tmp1 = line1.split(' ')
(n, x, y) = (int(tmp1[0]), int(tmp1[1]), int(tmp1[2]))
lst = [int(i) for i in line2.split(' ')]

def f(left, right, mid):
	idx = left
	while idx <= right:
		if idx == mid:
			idx += 1
			continue
		if lst[idx] < lst[mid]:
			return False
		idx += 1
	return True
ans = -1
for i in range(n):
	l1 = max(0, i - x)
	l2 = min(n - 1, i + y)
	if f(l1, l2, i):
		ans = i
		break
print(ans + 1)


import sys
inf = sys.maxsize
(n, x, y) = map(int, input().split())
arr = [inf for i in range(x)] + list(map(int, input().split())) + [inf for i in range(y)]
flag = 1
for i in range(x, n + x):
	flag = 1
	for j in range(1, x + 1):
		if arr[i] > arr[i - j]:
			flag = 0
			break
	if flag:
		for k in range(1, y + 1):
			if arr[i] > arr[i + k]:
				flag = 0
				break
	if flag:
		print(i - x + 1)
		break


a = list(map(int, input().rstrip().split()))
n = a[0]
x = a[1]
y = a[2]
arr = list(map(int, input().rstrip().split()))
for i in range(n):
	val = arr[i]
	flag1 = True
	flag2 = True
	for j in range(1, x + 1):
		if i - j < 0:
			continue
		if val < arr[i - j]:
			flag1 = True
		else:
			flag1 = False
			break
	for j in range(1, y + 1):
		if i + j > n - 1:
			break
		if val < arr[i + j]:
			flag2 = True
		else:
			flag2 = False
			break
	if flag1 == True and flag2 == True:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
kq = -1
v = 0
t = 0
for i in range(n):
	v = 1
	t = a[i]
	for j in range(1, x + 1):
		if i - j < 0:
			break
		elif a[i - j] < t:
			v = 0
			break
	if v == 0:
		continue
	for j in range(1, y + 1):
		if i + j < n:
			if a[i + j] < t:
				v = 0
				break
		else:
			break
	if v == 1:
		kq = i + 1
		break
print(kq)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(n):
	boo = True
	for j in range(max(0, i - x), i):
		boo = boo and a[i] < a[j]
	for j in range(i + 1, min(n, i + y + 1)):
		boo = boo and a[i] < a[j]
	if boo:
		print(i + 1)
		exit(0)


def check(list, index, x, y, n):
	i = index - x
	if i < 0:
		i = 0
	z = True
	while i < index and z:
		if list[index] >= list[i]:
			return False
		else:
			i += 1
	i = index + 1
	while i <= index + y and i < n:
		if list[i] <= list[index]:
			return False
		else:
			i += 1
	return True
(n, x, y) = map(int, input().split())
l = list(map(int, input().strip().split()))
(i, z) = (0, True)
while i < n and z:
	if check(l, i, x, y, n):
		print(i + 1)
		z = False
	else:
		i += 1
if z:
	print(i)


def check(arr, x, y, d):
	for x in range(d - 1, max(d - x - 1, -1), -1):
		if arr[x] <= arr[d]:
			return False
	for y in range(d + 1, min(d + y + 1, len(arr))):
		if arr[y] <= arr[d]:
			return False
	return True
[n, x, y] = [int(i) for i in input().split()]
a = [int(j) for j in input().split()]
for w in range(len(a)):
	if check(a, x, y, w):
		print(w + 1)
		break


p = input().rstrip().split(' ')
q = input().rstrip().split(' ')
x = int(p[1])
y = int(p[2])
A = x
for i in range(0, len(q)):
	if i - x <= 0:
		T = q[0:i]
	else:
		T = q[i - x:i]
	if len(T) != 0:
		T.sort(key=int)
	if len(T) == 0 or int(q[i]) < int(T[0]):
		Y = q[i + 1:i + y + 1]
		if len(Y) != 0:
			Y.sort(key=int)
		if len(Y) == 0 or int(q[i]) < int(Y[0]):
			print(i + 1)
			break


(day, x, y) = map(int, input().split())
lst = list(map(int, input().split()))
for i in range(0, day):
	xx = lst[max(0, i - x):i + y + 1]
	if min(xx) >= lst[i]:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
id = None
c = 0
m = 0
for i in range(n):
	if id == None or a[i] < m:
		m = a[i]
		id = i
		c = 0
		if not y:
			break
	else:
		c += 1
		if c == y:
			break
print(id + 1)


from sys import stdin
input = stdin.readline

def test_x(ind):
	j = ind - 1
	while j >= 0 and ind - j <= x:
		if a[ind] > a[j]:
			return False
		j -= 1
	return True

def test_y(ind):
	j = ind + 1
	while j < n and j - ind <= y:
		if a[ind] > a[j]:
			return False
		j += 1
	return True
(n, x, y) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
for i in range(n):
	if test_x(i) and test_y(i):
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
array = list(map(int, input().split()))
inf = float('inf')
ar_x = [float('inf')] * x
ar_y = []
for i in range(1, min(y + 1, n)):
	ar_y.append(array[i])
if not ar_y or array[0] <= min(ar_y):
	print(1)
	exit(0)
for i in range(1, n):
	ar_x.append(array[i - 1])
	if i + y < n:
		ar_y.append(array[i + y])
	ar_x.pop(0)
	ar_y.pop(0)
	if not ar_y and (not ar_x):
		print(i + 1)
		exit(0)
	elif not ar_y and array[i] < min(ar_x):
		print(i + 1)
		exit(0)
	elif not ar_x and array[i] < min(ar_y):
		print(i + 1)
		exit(0)
	elif array[i] < min(ar_y) and array[i] < min(ar_x):
		print(i + 1)
		exit(0)


(n, x, y) = map(int, input().split())
rain = [10 ** 9 + 1] * 7 + list(map(int, input().split())) + [10 ** 9 + 1] * 7
for i in range(7, n + 7):
	mn = 10 ** 9 + 1
	for j in range(i + 1, i + y + 1):
		mn = min(rain[j], mn)
	for j in range(i - 1, i - x - 1, -1):
		mn = min(rain[j], mn)
	if mn > rain[i]:
		print(i - 6)
		break


L = lambda : map(int, input().split())
(n, x, y) = L()
val = (*L(),)
for i in range(n):
	if val[i] <= min(val[max(0, i - x):i + 1 + y]):
		print(i + 1)
		break


import sys, collections
(n, x, y) = map(int, sys.stdin.readline().split())
arr = list(map(int, sys.stdin.readline().split()))
for i in range(n):
	can = True
	if i - x < 0 and i + y > n - 1:
		for j in range(i - 1):
			if arr[j] < arr[i]:
				can = False
		for j in range(i + 1, n):
			if arr[j] < arr[i]:
				can = False
	elif i - x < 0 and i + y <= n - 1:
		for j in range(i - 1):
			if arr[j] < arr[i]:
				can = False
		for j in range(i + 1, i + y + 1):
			if arr[j] < arr[i]:
				can = False
	elif i - x >= 0 and i + y > n - 1:
		for j in range(i - x, i - 1):
			if arr[j] < arr[i]:
				can = False
		for j in range(i + 1, n):
			if arr[j] < arr[i]:
				can = False
	else:
		for j in range(i - x, i - 1):
			if arr[j] < arr[i]:
				can = False
		for j in range(i + 1, i + y + 1):
			if arr[j] < arr[i]:
				can = False
	if can:
		print(i + 1)
		break


def check(lst, val):
	for i in lst:
		if val > i:
			return False
	return True
(day, x, y) = map(int, input().split())
lst = list(map(int, input().split()))
for i in range(0, day):
	xx = lst[max(0, i - x):i + y + 1]
	if check(xx, lst[i]):
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
data = list(map(int, input().split()))
for i in range(len(data)):
	flag = False
	for k in range(i - x, i):
		if k >= 0:
			if data[k] < data[i]:
				flag = True
				break
	if flag:
		continue
	for k in range(i + 1, i + 1 + y):
		if k < len(data):
			if data[k] < data[i]:
				flag = True
				break
	if flag:
		continue
	print(i + 1)
	break


(n, x, y) = map(int, input().split())
u = list(map(int, input().split()))
for i in range(n):
	ok = True
	for j in range(i - 1, max(-1, i - x - 1), -1):
		if u[j] <= u[i]:
			ok = False
			break
	for j in range(i + 1, min(n, i + y + 1), 1):
		if u[j] <= u[i]:
			ok = False
			break
	if ok:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = [*map(int, input().split())]
for i in range(n):
	(l, r, f) = (i - 1, i + 1, False)
	while l >= max(i - x, 0):
		if a[i] >= a[l]:
			f = True
			break
		l -= 1
	if f:
		continue
	f = False
	while r <= min(i + y, n - 1):
		if a[i] >= a[r]:
			f = True
			break
		r += 1
	if f:
		continue
	break
print(i + 1)


import math
(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(n):
	target = a[i]
	left = []
	j = i - 1
	m = 0
	while j >= 0 and m < x:
		left.append(a[j])
		m += 1
		j -= 1
	right = []
	j = i + 1
	m = 0
	while j < n and m < y:
		right.append(a[j])
		m += 1
		j += 1
	flag = 0
	if len(left) != 0 and target > min(left):
		flag = -1
	if len(right) != 0 and target > min(right):
		flag = -1
	if flag == 0:
		print(i + 1)
		break


def vikas():
	a = list(map(int, input().strip().split()))
	array = list(map(int, input().strip().split()))
	for i in range(len(array)):
		flag = True
		for j in range(i - a[1], i, 1):
			if j < 0:
				break
			if i > j and array[i] > array[j]:
				flag = False
		for j in range(i + 1, i + a[2] + 1, 1):
			if j >= len(array):
				break
			if i < j and array[i] > array[j]:
				flag = False
		if flag == True:
			return i + 1
	return -1
print(vikas())


(n, x, y) = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
if y == 0:
	print(1)
	exit()
for i in range(n):
	if i + y > n - 1:
		z = n - 1
	else:
		z = i + y
	c = min(a[max(0, i - x):z + 1])
	if a[i] <= c:
		print(i + 1)
		exit()


s = list(map(int, input().rstrip().split()))
N = s[0]
x = s[1]
y = s[2]
a = list(map(int, input().rstrip().split()))
for i in range(N):
	ok = True
	for j in range(max(0, i - x), i):
		if a[i] >= a[j]:
			ok = False
			break
	if not ok:
		continue
	for j in range(i + 1, min(N, i + y + 1)):
		if a[i] >= a[j]:
			ok = False
			break
	if ok:
		print(i + 1)
		break


(a, b, c) = map(int, input().split())
lst = list(map(int, input().split()))
i = 0
num = 0
while i < a:
	for j in range(i + 1, i + c + 1):
		if j < a and lst[j] < lst[i]:
			i = j
			break
	else:
		print(i + 1)
		break
else:
	print(-1)


(n, a, b) = map(int, input().split())
l = list(map(int, input().split()))
for x in range(n):
	if l[x] == min(l[max(0, x - a):min(x + b + 1, n)]):
		print(x + 1)
		break


mod = 1000000007
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
(n, x, y) = f()
l = il()
for i in range(n):
	f = 0
	for j in range(i - 1, max(i - x, 0), -1):
		if l[j] <= l[i]:
			f = 1
			break
	for j in range(i + 1, min(i + y + 1, n), 1):
		if l[j] <= l[i]:
			f = 1
			break
	if f != 1:
		exit(print(i + 1))


s = input().split()
n = int(s[0])
x = int(s[1])
y = int(s[2])
a = [int(num) for num in input().split()]
for i in range(0, n):
	flag = True
	for disx in range(max(i - x, 0), i):
		if a[i] > a[disx]:
			flag = False
			break
	for disy in range(i + 1, min(i + y + 1, len(a))):
		if a[i] > a[disy]:
			flag = False
			break
	if flag:
		print(i + 1)
		break


s1 = list(map(int, input().split()))
l = list(map(int, input().split()))
(n, x, y) = (s1[0], s1[1], s1[2])

def func(z, i):
	if i - x <= 0:
		a = 0
	else:
		a = i - x
	return z[a:i + y + 1]
for i in range(n):
	z = func(l, i)
	if min(z) == l[i]:
		print(i + 1)
		break


l = [int(i) for i in input().split(' ')]
n = l[0]
x = l[1]
y = l[2]
ln = [int(i) for i in input().split(' ')]
m = [ln[0], 0]
lst = []
if x == 0 and y == 0:
	print(1)
else:
	for i in range(0, len(ln)):
		f = True
		for j in range(i - x, i + y + 1):
			if j == i:
				continue
			if j < 0:
				continue
			if j >= len(ln):
				break
			if ln[j] < ln[i]:
				f = False
				break
		if f:
			print(i + 1)
			break


def less_rain(arr, x, y, ind):
	for i in range(ind - x, ind + y + 1, 1):
		if 0 <= i < len(arr) and arr[ind] > arr[i] and (i != ind):
			return False
	return True
(n, x, y) = map(int, input().split())
arr = list(map(int, input().split()))
for i in range(n):
	possible = less_rain(arr, x, y, i)
	if possible:
		print(i + 1)
		break


X = list(map(int, input().split()))
Days = list(map(int, input().split()))
for i in range(X[0]):
	Temp = Days[max(0, i - X[1]):i] + Days[i + 1:min(X[0] - 1, i + X[2]) + 1]
	if len(Temp) == 0 or Days[i] < min(Temp):
		print(i + 1)
		exit()


(n, l, h) = input().strip(' ').split(' ')
n = int(n)
l = int(l)
h = int(h)
ar = [int(i) for i in input().strip(' ').split(' ')]
for i in range(n):
	if i - l < 0:
		low = 0
	else:
		low = i - l
	if i + h > n - 1:
		up = n - 1
	else:
		up = i + h
	if len(ar[low:i]) > 0:
		l_min = min(ar[low:i])
	else:
		l_min = ar[i]
	if len(ar[i + 1:up + 1]) > 0:
		r_min = min(ar[i + 1:up + 1])
	else:
		r_min = ar[i]
	if ar[i] <= l_min and ar[i] <= r_min:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
ans = 0
for i in range(len(l)):
	flag = 0
	z1 = max(0, i - x)
	z2 = min(n, i + y + 1)
	for j in range(z1, i):
		if l[i] > l[j]:
			flag = 1
			break
	if flag != 1:
		for k in range(i + 1, z2):
			if l[i] > l[k]:
				flag = 1
				break
	if flag == 0:
		ans = i + 1
		break
print(ans)


def fing_day(day_count, rain_data, pre_count, following_count):
	for day in range(day_count):
		rain_check = True
		for before in range(1, pre_count + 1):
			if day - before < 0:
				break
			if rain_data[day] > rain_data[day - before]:
				rain_check = False
				break
		if rain_check:
			for after in range(1, following_count + 1):
				if day + after >= day_count:
					break
				if rain_data[day] > rain_data[day + after]:
					rain_check = False
					break
			if rain_check:
				return day
data = input().split()
rain_data = list(map(int, input().split()))
print(fing_day(int(data[0]), rain_data, int(data[1]), int(data[2])) + 1)


def read():
	return list(map(int, input().split()))
try:
	for _ in range(1):
		(n, x, y) = read()
		l = read()
		for i in range(n):
			mi1 = min(l[i:min(n - 1, i + y) + 1])
			mi2 = min(l[max(i - x, 0):i + 1])
			if mi1 == mi2 and mi1 == l[i]:
				print(i + 1)
				exit()
except Exception:
	pass


def run():
	in_data = input().split()
	(n, x, y) = (int(in_data[0]), int(in_data[1]), int(in_data[2]))
	measures = [int(t) for t in input().split()]
	for i in range(n):
		s = True
		for d in range(x):
			if i - d - 1 >= 0 and measures[i - d - 1] <= measures[i]:
				s = False
		for d in range(y):
			if i + d + 1 < n and measures[i + d + 1] <= measures[i]:
				s = False
		if s:
			print(i + 1)
			break
run()


a = list(map(int, input().split()))
b = list(map(int, input().split()))
for i in range(a[0]):
	(l, k) = (1, 1)
	c = min(a[1], i)
	d = min(a[2], a[0] - 1 - i)
	for j in range(i - c, i):
		if b[i] < b[j]:
			l = l + 1
		else:
			l = 0
			break
	for m in range(i + 1, i + d + 1):
		if b[m] > b[i]:
			k = k + 1
		else:
			k = 0
			break
	if l != 0 and k != 0:
		print(i + 1)
		break


from sys import stdin
(n, x, y) = map(int, stdin.readline().split())
a = list(map(int, stdin.readline().split()))
for i in range(n):
	if min(a[max(i - x, 0):min(i + y + 1, n)]) == a[i]:
		print(i + 1)
		break


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

def call(n, x, y):
	for i in range(n):
		j = i - 1
		tf = True
		while j >= 0 and j >= i - x:
			if a[j] <= a[i]:
				tf = False
				break
			j -= 1
		if tf:
			j = i + 1
			while j < n and j <= i + y:
				if a[j] <= a[i]:
					tf = False
					break
				j += 1
			if tf:
				return i + 1
print(call(n, x, y))


(n, x, y) = map(int, input().split())
A = list(map(int, input().split()))
for i in range(n):
	sl = A[max(i - x, 0):min(i + y + 1, n)]
	if A[i] == min(sl) and sl.count(A[i]) == 1:
		print(i + 1)
		break


(n, x, y) = list(map(int, input().split()))
nums = list(map(int, input().split()))
for i in range(n):
	good = True
	beg = i - x
	if beg < 0:
		beg = 0
	for j in range(beg, i - 1):
		if nums[j] < nums[i]:
			good = False
			continue
	en = i + y + 1
	if en > n:
		en = n
	for k in range(i + 1, en):
		if nums[k] < nums[i]:
			good = False
			continue
	if good:
		print(i + 1)
		break
	else:
		continue


(n, x, y) = map(int, input().split())
A = list(map(int, input().split()))
for i in range(n):
	t = 1
	for j in range(x):
		if i - j - 1 < 0:
			break
		if A[i - j - 1] <= A[i]:
			t = 0
			break
	for k in range(y):
		if i + k + 1 > n - 1:
			break
		if A[i + k + 1] <= A[i]:
			t = 0
			break
	if t == 1:
		print(i + 1)
		break


raw_nxy = input().split()
[n, x, y] = [int(k) for k in raw_nxy]
raw_data = input().split()
sum_data = [int(k) for k in raw_data]
days = len(sum_data)
for i in range(days):
	check = sum_data[i]
	stat = True
	for j in range(i - x, i + y + 1):
		if j < 0 or j >= days:
			continue
		elif j != i and sum_data[j] <= check:
			stat = False
			break
	if stat == True:
		result = i
		break
print(result + 1)


(n, x, y) = list(map(int, input().split()))
b = [n, x, y]
a = list(map(int, input().split()))
for i in range(n):
	m = True
	begin = i - x
	end = i + 1 + y
	if begin < 0:
		begin = 0
	for j in range(begin, i):
		if a[j] < a[i]:
			m = False
			break
	if not m:
		continue
	if end > n:
		end = n
	for k in range(i + 1, end):
		if a[k] < a[i]:
			m = False
			break
	if not m:
		continue
	if m:
		print(i + 1)
		break


import sys
input = sys.stdin.readline
sys.setrecursionlimit(100000)

def getN():
	return int(input())

def getList():
	return list(map(int, input().split()))
import math
from bisect import bisect_left
inf = 10 ** 10
(n, x, y) = getList()
nums = getList()
nums = [inf] * x + nums + [inf] * y
for i in range(n):
	flag = 0
	tgt = nums[x + i]
	for j in range(x):
		dif = nums[x + i - j - 1]
		if dif <= tgt:
			flag = 1
			continue
	if not flag:
		for j in range(y):
			dif = nums[x + i + j + 1]
			if dif <= tgt:
				flag = 1
				continue
	if not flag:
		print(i + 1)
		sys.exit()


(n, x, y) = [int(item) for item in input().split()]
a = [int(item) for item in input().split()]
for i in range(n):
	a_part = a[max(0, i - x):min(i + y + 1, n)]
	target = a[i]
	a_part.sort()
	if a_part[0] == target:
		print(i + 1)
		break


nxy = [int(i) for i in input().split()]
n = nxy[0]
x = nxy[1]
y = nxy[2]
arr = [int(i) for i in input().split()]
i = 0
while arr[i] > min(arr[max(0, i - x):i + y + 1]):
	i += 1
print(i + 1)


(n, x, y) = map(int, input().split())
A = list(map(int, input().split()))
ans = 0
for i in range(0, n):
	a = b = 1
	c1 = x
	c2 = y
	j = i - 1
	k = i + 1
	while j > 0 and c1 > 0:
		if A[j] < A[i]:
			a = 0
			break
		j -= 1
		c1 -= 1
	while k < n and c2 > 0:
		if A[k] < A[i]:
			b = 0
			break
		k += 1
		c2 -= 1
	if a == 1 and b == 1:
		ans = i + 1
		break
print(ans)


def process():
	(n, x, y) = list(map(int, input().split()))
	days = list(map(int, input().split()))
	for i in range(n):
		m = min(i + y + 1, n)
		m1 = max(0, i - x)
		if sum((days[j] > days[i] for j in range(m1, m))) == m - m1 - 1:
			print(i + 1)
			return
process()


(N, X, Y) = map(int, input().split(' '))
Arr = list(map(int, input().split(' ')))
for i in range(N):
	Temp = Arr[i]
	CC = 0
	for j in range(1, X + 1):
		if i - j < 0:
			continue
		if Temp >= Arr[i - j]:
			CC = -1
			break
	if CC == -1:
		continue
	else:
		for j in range(1, Y + 1):
			if i + j >= N:
				break
			if Temp >= Arr[i + j]:
				CC = -1
				break
		if CC == -1:
			continue
		else:
			print(i + 1)
			break


from sys import stdin

def ii():
	return int(stdin.readline())

def mi():
	return map(int, stdin.readline().split())

def li():
	return list(mi())
(n, x, y) = mi()
a = li()
for i in range(n):
	(p, q) = (i - x, i + y + 1)
	p = max(0, p)
	q = min(n, q)
	if a[i] == min(a[p:q]):
		print(i + 1)
		exit()


(n, x, y) = map(int, input().split())
t = list(map(int, input().split()))
arr = [10 ** 9 + 1] * x
arr.extend(t)
for i in range(y):
	arr.append(10 ** 9 + 1)
for i in range(x, n + x):
	(lc, rc) = (0, 0)
	for j in range(1, x + 1):
		if arr[i - j] > arr[i]:
			lc += 1
		else:
			break
	for j in range(1, y + 1):
		if arr[i] < arr[i + j]:
			rc += 1
		else:
			break
	if lc + rc == x + y:
		print(i - x + 1)
		exit()


(n, x, y) = map(int, input().split())
arr = list(map(int, input().split()))
for i in range(n):
	min_val = arr[i]
	j = i - 1
	counter = x
	while j >= 0 and counter > 0:
		counter -= 1
		if arr[j] < min_val:
			min_val = arr[j]
			break
		j -= 1
	if min_val == arr[i]:
		counter = y
		j = i + 1
		while j < n and counter > 0:
			counter -= 1
			if arr[j] < min_val:
				min_val = arr[j]
				break
			j += 1
		if min_val == arr[i]:
			print(i + 1)
			break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
i = 0
for k in a:
	if k == min(a[max(0, i - x):min(n, i + y + 1)]):
		if a[max(0, i - x):min(n, i + y + 1)].count(k) == 1:
			print(i + 1)
			break
	i += 1


import sys
import math
import bisect
import itertools
import random

def main():
	(n, x, y) = map(int, input().split())
	A = list(map(int, input().split()))
	for i in range(n):
		l = max(0, i - x)
		r = min(n - 1, i + y)
		if A[i] == min(A[l:r + 1]):
			print(i + 1)
			break
main()


(n, x, y) = list(map(int, input().split()))
l = list(map(int, input().split()))
i = 0
ans = 0
while ans == 0:
	if l[i] == min(l[max(0, i - x):i + y + 1]):
		ans = 1
		break
	else:
		i += 1
print(i + 1)


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
for i in range(n):
	f = 0
	for j in range(max(0, i - x), i):
		if l[j] <= l[i]:
			f = 1
			break
	for j in range(min(n, i + 1), min(n, i + y + 1)):
		if l[j] <= l[i]:
			f = 1
			break
	if f == 0:
		print(i + 1)
		break


input1 = list(map(int, input().split()))
input2 = list(map(int, input().split()))
for i in range(input1[0]):
	if input2[i] == min(input2[max(0, i - input1[1]):min(input1[0], i + input1[2] + 1)]):
		print(i + 1)
		quit()


(n, x, y) = input().split()
a = list(map(int, input().split()))
n = int(n)
x = int(x)
y = int(y)
j = 0
k = True
while j < x:
	if j == a.index(min(a[:y + j + 1])):
		print(j + 1)
		k = False
		break
	else:
		j = j + 1
if k:
	for i in range(0, n):
		if a[x + i] == min(a[i:i + x + y + 1]):
			print(x + i + 1)
			break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(n):
	idx = i
	fl = True
	while i - idx < x:
		if idx <= 0:
			break
		if a[i] >= a[idx - 1]:
			ans = False
		idx -= 1
	idx = i
	while idx - i < y:
		if idx >= n - 1:
			break
		if a[i] >= a[idx + 1]:
			fl = False
		idx += 1
	if fl:
		print(i + 1)
		exit()


from math import *
from sys import *
from collections import defaultdict
M = 10 ** 9 + 7

def pow(a, b):
	res = 1
	while b > 0:
		if b & 1:
			res *= a
		a *= a
		b >>= 1
	return res

def powmod(a, b, m):
	res = 1
	while b > 0:
		if b & 1:
			res = res * a % m
		a *= a
		b >>= 1
	return res

def inv(a, m):
	return powmod(a, m - 2, m)

def factor(n):
	potentional_p = 3
	itog_list = {}
	if n % 2 == 0:
		itog_list[2] = 0
	while n % 2 == 0:
		n = n // 2
		itog_list[2] += 1
	while n - 1:
		if potentional_p > n ** 0.5:
			if n in itog_list:
				itog_list[n] += 1
			else:
				itog_list[n] = 1
			return itog_list
		while n % potentional_p == 0:
			n = n // potentional_p
			if potentional_p in itog_list:
				itog_list[potentional_p] += 1
			else:
				itog_list[potentional_p] = 1
		potentional_p += 2
	return itog_list

def min1(lst):
	if len(lst) == 0:
		return 10 ** 9 + 1
	return min(lst)
(n, x, y) = list(map(int, stdin.readline().split()))
a = list(map(int, stdin.readline().split()))
for i in range(n):
	if a[i] < min1(a[i - x if i - x > 0 else 0:i]) and a[i] < min1(a[i + 1:i + 1 + y]):
		print(i + 1)
		break


(n, x, y) = list(map(int, input().split()))
l = list(map(int, input().split()))

def test(i):
	p = l[max(0, i - x):min(i + y + 1, n)]
	return True if p.count(l[i]) == 1 and l[i] == min(p) else False
for i in range(n):
	if test(i):
		print(i + 1)
		break


(n, x, y) = (int(s) for s in input().split())
l = [int(s) for s in input().split()]
for i in range(n):
	flag1 = 1
	flag2 = 1
	for j in range(x):
		if i - j - 1 >= 0 and l[i] < l[i - j - 1]:
			continue
		elif i - j - 1 < 0:
			break
		else:
			flag1 = 0
			break
	for j in range(y):
		if i + j + 1 < n and l[i] < l[i + j + 1]:
			continue
		elif i + j + 1 >= n:
			break
		else:
			flag2 = 0
			break
	if flag1 and flag2:
		print(i + 1)
		break


import atexit
import io
import sys
R = lambda : map(int, input().split())
(n, x, y) = R()
l = list(R())
temp = 0
flag = False
for i in range(n):
	fl = max(0, i - x)
	sl = min(n, i + y + 1)
	if l[i] == min(l[fl:sl]):
		print(i + 1)
		break


(n, x, y) = [int(a) for a in input().split()]
days = [int(a) for a in input().split()]
for i in range(n):
	res = True
	for j in range(max(i - x, 0), i):
		if days[i] >= days[j]:
			res = False
	for k in range(i + 1, min(i + y + 1, n)):
		if days[i] >= days[k]:
			res = False
	if res:
		print(i + 1)
		break


import sys
import re
import random
import math
import os

def check(a, i):
	a = sorted(a)
	if a[0] == i:
		return True
	else:
		return False
i = list(map(int, input().rstrip().split()))
a = list(map(int, input().rstrip().split()))
f = check
for j in range(0, len(a)):
	if j - i[1] < 0:
		if f(a[0:j + i[2] + 1], a[j]):
			print(j + 1)
			break
	elif j + i[2] + 1 >= len(a):
		if f(a[j - i[1]:len(a)], a[j]):
			print(j + 1)
			break
	elif f(a[j - i[1]:j + i[2] + 1], a[j]):
		print(j + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
currlist = a[:y + x]
ans = 0

def chk(a, i):
	if len(a) >= 1:
		if min(a) > i:
			return True
		return False
	else:
		return True
i = True
k = 0
while i:
	if chk(a[max(0, k - x):k], a[k]) and chk(a[k + 1:min(n, k + y + 1)], a[k]):
		ans = k
		break
	k += 1
print(ans + 1)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(len(a)):
	if True:
		q = 0
		qw = x
		while qw < x and i - qw >= 0:
			if a[i - qw] < a[i]:
				q = 1
			qw = qw - 1
		for j in range(1, y + 1):
			if i + j < len(a):
				if a[i + j] < a[i]:
					q = 1
	if q == 0:
		print(i + 1)
		break


nxy = input().split(' ')
n = int(nxy[0])
x = int(nxy[1])
y = int(nxy[2])
a = []
a_line = input().split(' ')
for l in a_line:
	a.append(int(l))
for d in range(n):
	ad = a[d]
	x_true = True
	y_true = True
	if d - x < 0:
		for j in range(0, d):
			if ad > a[j]:
				x_true = False
	else:
		for j in range(d - x, d):
			if ad > a[j]:
				x_true = False
	if d + y >= n:
		for j in range(d + 1, n):
			if ad > a[j]:
				y_true = False
	else:
		for j in range(d + 1, d + y + 1):
			if ad > a[j]:
				y_true = False
	if x_true and y_true:
		print(d + 1)
		break


def f(a, x, y):
	n = len(a)
	for i in range(len(a)):
		flag = True
		for l in range(max(0, i - x), i):
			if a[i] >= a[l]:
				flag = False
		for r in range(i + 1, min(n, i + y + 1)):
			if a[i] >= a[r]:
				flag = False
		if flag:
			return i + 1
(a, x, y) = map(int, input().strip().split())
lst = list(map(int, input().strip().split()))
print(f(lst, x, y))


(n, x, y) = map(int, input().split())
ls1 = list(map(int, input().split()))
for i in range(n):
	if i > x:
		ind1 = i - x
	else:
		ind1 = 0
	if i + y + 1 > n:
		ind2 = n
	else:
		ind2 = i + y + 1
	if min(ls1[ind1:ind2]) == ls1[i]:
		print(str(i + 1))
		break


inp = list(map(int, input().split()))
n = inp[0]
x = inp[1]
y = inp[2]
inp = list(map(int, input().split()))
if x == 0 or y == 0:
	if x == 0 and y == 0:
		print(1)
	elif x == 0 and y != 0:
		for i in range(len(inp)):
			if i + y <= len(inp) - 1:
				t = min(inp[i + 1:i + y + 1])
			elif i + y > len(inp) - 1 and i != len(inp) - 1:
				t = min(inp[i + 1:])
			elif i == len(inp) - 1:
				t = inp[i] + 1
			if t > inp[i]:
				print(i + 1)
				break
	elif x != 0 and y == 0:
		for i in range(len(inp)):
			if i > x:
				k = min(inp[i - x:i])
			elif i != 0 and i <= x:
				k = min(inp[:i])
			elif i == 0:
				k = inp[i] + 1
			if k > inp[i]:
				print(i + 1)
				break
else:
	for i in range(0, len(inp)):
		if i > x:
			k = min(inp[i - x:i])
		elif i != 0 and i <= x:
			k = min(inp[:i])
		elif i == 0:
			k = inp[i] + 1
		if i + y <= len(inp) - 1:
			t = min(inp[i + 1:i + y + 1])
		elif i + y > len(inp) - 1 and i != len(inp) - 1:
			t = min(inp[i + 1:])
		elif i == len(inp) - 1:
			t = inp[i] + 1
		if k > inp[i] and t > inp[i]:
			print(i + 1)
			break


import itertools

def input_ints():
	return list(map(int, input().split()))

def output_list(v):
	print(' '.join((str(x) for x in v)))

def main():
	(n, x, y) = input_ints()
	a = input_ints()
	for i in range(n):
		if a[i] < min(a[max(0, i - x):i] + a[i + 1:i + y + 1] or [10 ** 19]):
			print(i + 1)
			return
main()


(n, x, y) = [int(s) for s in input().split()]
a = [int(s) for s in input().split()]
for i in range(n):
	l = r = i
	t1 = x
	t2 = 0
	f1 = f2 = 1
	while l >= 0 and t1 > 0:
		if a[l] < a[i]:
			f1 = 0
			break
		t1 -= 1
		l -= 1
	while r < n and t2 <= y:
		if a[r] < a[i]:
			f2 = 0
			break
		t2 += 1
		r += 1
	if f1 and f2:
		print(i + 1)
		break


(n, x, y) = list(map(int, input().split()))
d = list(map(int, input().split()))
for i in range(len(d)):
	i1 = d[max(0, i - x):i]
	i2 = d[i + 1:min(n, i + y + 1)]
	if i1 != []:
		maxi1 = min(i1)
	else:
		maxi1 = 999999999999999
	if i2 != []:
		maxi2 = min(i2)
	else:
		maxi2 = 999999999999999
	if maxi1 > d[i] and maxi2 > d[i]:
		print(i + 1)
		exit(0)


(n, x, y) = [int(s) for s in input().split()]
arr = [int(s) for s in input().split()]
for i in range(n):
	sol = 1
	for j in range(-x, y + 1):
		if i + j >= 0 and i + j < n and (arr[i] > arr[i + j]):
			sol = 0
			break
	if sol == 1:
		print(i + 1)
		break


while True:
	try:
		(n, x, y) = map(int, input().split())
		days = list(map(int, input().split()))
		i = 0
		while i < n:
			flag = 0
			lft = i - x
			if lft < 0:
				lft = 0
			rgt = i + y + 1
			if rgt > n:
				rgt = n
			for j in range(lft, i):
				if days[j] > days[i]:
					continue
				else:
					flag = 1
					break
			if flag != 1:
				for j in range(i + 1, rgt):
					if days[i] < days[j]:
						continue
					else:
						flag = 1
						break
			if flag == 0:
				break
			flag = 0
			i += 1
		print(i + 1)
	except EOFError:
		break


(n, x, y) = list(map(int, input().split()))
forecast = list(map(int, input().split()))
for i in range(n):
	left = forecast[max(0, i - x):i]
	right = forecast[i + 1:min(n, i + 1 + y)]
	if len(left) == 0:
		left_min = float('inf')
	else:
		left_min = min(left)
	if len(right) == 0:
		right_min = float('inf')
	else:
		right_min = min(right)
	m = forecast[i]
	if m <= left_min and m <= right_min:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = [int(i) for i in input().split()]
res = []
for i in range(n):
	window = a[max(0, i - x):min(i + y + 1, n)]
	if a[i] == min(window):
		res.append(i + 1)
print(res[0])


ll = lambda : list(map(int, input().split()))
testcases = 1
for testcase in range(testcases):
	[n, x, y] = ll()
	a = ll()
	(al, ar) = ([], [])
	for i in range(0, n):
		ok = True
		for j in range(1, x + 1):
			if i - j < 0:
				continue
			if a[i - j] < a[i]:
				ok = False
				break
		if ok:
			for j in range(1, y + 1):
				if i + j >= n:
					continue
				if a[i + j] < a[i]:
					ok = False
		if ok:
			print(i + 1)
			break


import os
import sys
from io import BytesIO, IOBase
_str = str
BUFSIZE = 8192

def str(x=b''):
	return x if type(x) is bytes else _str(x).encode()

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def inp():
	return sys.stdin.readline().rstrip()

def mpint():
	return map(int, inp().split(' '))

def itg():
	return int(inp())

class RangeQuery:

	def __init__(self, data, func=min):
		self.func = func
		self._data = _data = [list(data)]
		(i, n) = (1, len(_data[0]))
		while 2 * i <= n:
			prev = _data[-1]
			_data.append([func(prev[j], prev[j + i]) for j in range(n - 2 * i + 1)])
			i <<= 1

	def query(self, begin, end):
		depth = (end - begin).bit_length() - 1
		return self.func(self._data[depth][begin], self._data[depth][end - (1 << depth)])

def solve():
	(n, x, y) = mpint()
	arr = tuple(mpint())
	rmq = RangeQuery(range(n), lambda i, j: min(i, j, key=arr.__getitem__))
	for i in range(n):
		lf = max(0, i - x)
		rg = min(n, i + y + 1)
		if rmq.query(lf, rg) == i:
			return i + 1

def main():
	print(solve())
DEBUG = 0
URL = 'https://codeforces.com/contest/1199/problem/A'
if DEBUG == 1:
	import requests
	from ACgenerator.Y_Test_Case_Runner import TestCaseRunner
	runner = TestCaseRunner(main, URL)
	inp = runner.input_stream
	print = runner.output_stream
	runner.checking()
elif DEBUG == 2:
	main()
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
	main()


import math as mt
import collections as cc
import sys
I = lambda : list(map(int, input().split()))
(n, x, y) = I()
l = I()
for i in range(n):
	if l[i] == min(l[max(0, i - x):min(i + y + 1, n)]):
		print(i + 1)
		sys.exit()


(n, x, y) = map(int, input().split())
a = [int(s) for s in input().split()]
k = i = 0
j = -1
for i in range(n - 1):
	if k >= y:
		break
	elif a[i] < a[i + 1] or (j != -1 and a[j] < a[i + 1]):
		if k == 0:
			j = i
		k += 1
	else:
		k = 0
		j = -1
if k == 0 and i == n - 2 and (a[i] > a[i + 1]) and (y != 0):
	print(n)
elif y == 0 or n == 1:
	print(1)
else:
	print(j + 1)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split())) + [2000000000.0] * 10
for i in range(len(a)):
	if min(a[max(i - x, 0):i] + a[i + 1:i + y + 1] + [2000000000.0]) > a[i]:
		print(i + 1)
		exit(0)


def main():
	(n, x, y) = map(int, input().split())
	rain = list(map(int, input().split()))
	for (i, r) in enumerate(rain):
		less_rain = False
		for a in range(x):
			b = i - a - 1
			try:
				if b >= 0 and r > rain[b]:
					less_rain = True
			except IndexError:
				continue
		for a in range(y):
			b = i + a + 1
			try:
				if b >= 0 and r > rain[b]:
					less_rain = True
			except IndexError:
				continue
		if not less_rain:
			print(i + 1)
			return
main()


(n, x, y) = map(int, input().split())
a = input()
a = a.split()
a = list(map(int, a))
for i in range(n):
	if i < x:
		x1 = i
	else:
		x1 = x
	if n - i < y:
		y = n - i
	else:
		y1 = y
	if a[i] == min(a[i - x1:i + y1 + 1]):
		print(a.index(a[i]) + 1)
		break


(n, x, y) = list(map(int, input().split()))
l = list(map(int, input().split()))
for i in range(n):
	ct1 = 0
	v1 = min(x, i)
	for j in range(i - 1, max(-1, i - x - 1), -1):
		if l[j] > l[i]:
			ct1 += 1
	ct2 = 0
	v2 = min(y, n - i - 1)
	for j in range(i + 1, min(n, i + y + 1)):
		if l[j] > l[i]:
			ct2 += 1
	if ct1 == v1 and ct2 == v2:
		print(i + 1)
		exit()


nums = input()
days = input()
nums_list = nums.split(' ')
days_list = days.split(' ')
mins_list = []
nums_list = list(map(int, nums_list))
days_list = list(map(int, days_list))
for i in range(nums_list[0]):
	if i < nums_list[1]:
		if days_list[i] == min(days_list[:i + nums_list[2] + 1]):
			mins_list.append(i + 1)
	elif i >= nums_list[0] - nums_list[2]:
		if days_list[i] == min(days_list[i - nums_list[1]:]):
			mins_list.append(i + 1)
	elif days_list[i] == min(days_list[i - nums_list[1]:i + nums_list[2] + 1]):
		mins_list.append(i + 1)
print(min(mins_list))


(a, b, c) = map(int, input().split())
arr = list(map(int, input().split()))
for i in range(0, a):
	flag = 0
	j = i + 1
	while j < i + c + 1 and j < a:
		if arr[i] > arr[j]:
			flag = 1
			break
		j += 1
	if flag == 1:
		continue
	k = i - 1
	while k > i - b - 1 and k >= 0:
		if arr[i] > arr[k]:
			flag = 1
			break
		k -= 1
	if flag == 0:
		print(i + 1)
		break


import sys

class ACityDay:

	def solve(self):
		(n, x, y) = [int(_) for _ in input().split()]
		a = [int(_) for _ in input().split()]
		for d in range(n):
			ok = True
			for j in range(d - x, d + y + 1):
				if j == d or j < 0 or j >= n:
					continue
				if a[j] <= a[d]:
					ok = False
					break
			if ok:
				print(d + 1)
				break
solver = ACityDay()
input = sys.stdin.readline
solver.solve()


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(n):
	isg = True
	j = i - 1
	while j >= 0 and j >= i - x:
		if a[j] < a[i]:
			isg = False
			break
		j -= 1
	else:
		j = i + 1
		while j < n and j <= i + y:
			if a[j] < a[i]:
				isg = False
				break
			j += 1
	if isg:
		print(i + 1)
		exit()


(n, x, y) = map(int, input().split(' '))
a = list(map(int, input().split(' ')))
result = 0
for i in range(n):
	ai = a[i]
	start = 0 if i - x < 0 else i - x
	end = n - 1 if i + y > n - 1 else i + y
	minV = a[start]
	for j in range(start, end + 1):
		if a[j] < minV:
			minV = a[j]
	if ai == minV:
		result = i
		break
print(result + 1)


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
for d in range(n):
	ad = l[d]
	valid = True
	for j in range(max(d - x, 0), d):
		if ad >= l[j]:
			valid = False
	for j in range(d + 1, min(d + y + 1, n)):
		if ad >= l[j]:
			valid = False
	if valid:
		print(d + 1)
		quit()


[n, x, y] = [int(x) for x in input().split()]
arr = [int(x) for x in input().split()]
j = 0
idx = 0
while j < n:
	if j < x and j + y >= n:
		if arr[j] == min([arr[i] for i in range(0, n)]):
			idx = j + 1
			break
	elif j < x:
		if arr[j] == min([arr[i] for i in range(0, j + y + 1)]):
			idx = j + 1
			break
	elif j + y >= n:
		if arr[j] == min([arr[i] for i in range(j - x, n)]):
			idx = j + 1
			break
	elif arr[j] == min([arr[i] for i in range(j - x, j + y + 1)]):
		idx = j + 1
		break
	j += 1
print(idx)


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(n):
	l = i - 1
	flag1 = True
	while l >= max(0, i - x):
		if a[l] <= a[i]:
			flag1 = False
			break
		else:
			l -= 1
	r = i + 1
	flag2 = True
	while r <= min(n - 1, i + y):
		if a[r] <= a[i]:
			flag2 = False
			break
		else:
			r += 1
	if flag1 and flag2:
		print(i + 1)
		break


(n, x, y) = input().split()
List = [int(i) for i in input().split()]
ix = int(x)
iy = int(y)
L = []
for i in range(0, int(n)):
	cx = 0
	cy = 0
	for j in range(1, ix + 1):
		if i - j < 0:
			cx += 1
		elif List[i - j] > List[i]:
			cx += 1
	for j in range(1, iy + 1):
		if i + j >= int(n):
			cy += 1
		elif List[i + j] > List[i]:
			cy += 1
	if cx == ix and cy == iy:
		L.append(i + 1)
print(min(L))


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
i = 0
while i < n:
	a1 = a[max(0, i - x):i]
	a2 = a[i + 1:min(n, i + y + 1)]
	if a1 == []:
		p = 10 ** 9 + 1
	else:
		p = min(a1)
	if a2 == []:
		q = 10 ** 9 + 1
	else:
		q = min(a2)
	if a[i] < min(p, q):
		break
	i += 1
print(i + 1)


def mx(x, y):
	if x > y:
		return x
	else:
		return y

def mn(x, y):
	if x < y:
		return x
	else:
		return y
(n, a, b) = [int(x) for x in input().split()]
c = list(map(int, input().split()))
for i in range(n):
	x = min(c[mx(0, i - a):mn(n, i + b + 1)])
	if c[i] == x:
		print(i + 1)
		break


firstrow = list(map(int, input().split()))
days = firstrow[0]
daysbefore = firstrow[1]
daysafter = firstrow[2]
arr = list(map(int, input().split()))
flag = 1
firstiter = 1
answer = days
for i in range(days):
	flag = 1
	mn = min(daysbefore, i - 0)
	mx = min(i + daysafter, days - 1)
	for j in range(i - mn, i):
		if arr[i] > arr[j]:
			flag = 0
	for j in range(i, mx + 1):
		if arr[i] > arr[j]:
			flag = 0
	if flag and firstiter:
		answer = i
		firstiter = 0
print(answer + 1)


(n, x, y) = map(int, input().split())
a = [int(x) for x in input().split()]
flag = 0
if x == 0 and y == 0:
	print(1)
	exit(0)
for i in range(0, n):
	if a[i] == min(a[max(0, i - x):min(n, i + y + 1)]):
		flag = 1
		break
print(i + 1 if flag else n)


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
t = 0
t1 = 0
for i in range(n):
	flag1 = 0
	for j in range(i - 1, max(-1, i - x - 1), -1):
		if l[i] < l[j]:
			continue
		else:
			flag1 = 1
			break
	for j in range(i + 1, min(i + y + 1, n)):
		if l[i] < l[j]:
			continue
		else:
			flag1 = 1
			break
	if flag1 == 0:
		print(i + 1)
		break


from os import path
import sys
from functools import cmp_to_key as ctk
from collections import deque, defaultdict as dd
from bisect import bisect, bisect_left, bisect_right, insort, insort_left, insort_right
from itertools import permutations
from datetime import datetime
from math import ceil, sqrt, log, gcd

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().split())

def li():
	return list(mi())
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod = 1000000007
inf = float('inf')
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def bo(i):
	return ord(i) - ord('a')

def solve():
	(n, x, y) = mi()
	a = li()
	ans = -1
	for i in range(n):
		f = 0
		for j in range(i - 1, max(0, i - x) - 1, -1):
			if a[i] >= a[j]:
				f = 1
		for j in range(i + 1, min(i + y + 1, n)):
			if a[i] >= a[j]:
				f = 1
		if f == 0:
			ans = i + 1
			break
	print(ans)
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
else:
	input = sys.stdin.readline
solve()


def main():
	(n, x, y) = input().split()
	n = int(n)
	x = int(x)
	y = int(y)
	a = [int(i) for i in input().split()]
	for i in range(n):
		norain = True
		for j in range(x):
			if i - j - 1 > 0 and a[i] > a[i - j - 1]:
				norain = False
				break
		if norain:
			for j in range(y):
				if i + j + 1 < n and a[i] > a[i + j + 1]:
					norain = False
					break
		if norain:
			print(i + 1)
			return
	print(-1)
main()


(n, x, y) = map(int, input().split())
a = [int(i) for i in input().split()]
up = 0
down = 0
reach = False
ans = x
for i in range(n - y):
	if a[max(i - x, 0):i + y + 1].index(min(a[max(i - x, 0):i + y + 1])) == i - max(0, i - x):
		print(i + 1)
		break
else:
	j = n - y
	while j < n:
		if a[max(0, j - x):].index(min(a[max(0, j - x):])) == j - max(0, j - x):
			print(j + 1)
			break
		j += 1


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
if x + y >= n:
	print(l.index(min(l)) + 1)
else:
	for i in range(0, n):
		z = l[i]
		a = slice(i - x, i, 1)
		l1 = l[a]
		b = slice(i + 1, y + i + 1, 1)
		l2 = l[b]
		f1 = 0
		f2 = 0
		for j in range(len(l1)):
			if l1[j] < z:
				f1 = 1
				break
		for j in range(len(l2)):
			if l2[j] < z:
				f2 = 1
				break
		if f1 == 0 and f2 == 0:
			print(i + 1)
			break


(n, x, y) = map(int, input().split())
a = [int(x) for x in input().split()]
for i in range(0, n):
	flag = 0
	if i - x >= 0:
		p = i - x
	else:
		p = 0
	if i + y >= n:
		q = n
	else:
		q = i + y + 1
	for j in range(i, p, -1):
		if a[j] < a[i]:
			flag = 1
	for j in range(i, q):
		if a[j] < a[i]:
			flag = 1
	if flag == 0:
		print(i + 1)
		break


INF = 10 ** 10
(N, X, Y) = map(int, input().split())
A = list(map(int, input().split()))
for n in range(N):
	x = max(n - X, 0)
	y = min(n + Y, N - 1)
	if min([INF] + A[x:n]) > A[n] and A[n] < min([INF] + A[n + 1:y + 1]):
		print(n + 1)
		break


(n, x, y) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
ans = 0
for i in range(n):
	ans = 0
	for j in range(max(0, i - x), min(i + y + 1, n)):
		if a[i] >= a[j] and i != j:
			ans = -1
	if ans == -1:
		continue
	if ans != -1:
		ans = i + 1
		break
print(ans)


def read_int():
	return int(input())

def read_ints():
	return map(int, input().split(' '))
(n, x, y) = read_ints()
a = list(read_ints())
for i in range(n):
	ok = True
	for j in range(max(0, i - x), min(n - 1, i + y) + 1):
		if j == i:
			continue
		if a[j] <= a[i]:
			ok = False
			break
	if ok:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
maxi = max(a)
for _ in range(x):
	a.insert(0, maxi + 1)
for _ in range(y):
	a.append(maxi + 1)
for i in range(x, n + x):
	mini = min(a[i - x:i + y + 1])
	if mini == a[i]:
		if a[i - x:i + y + 1].count(mini) == 1:
			print(i - x + 1)
			break


p = list(map(int, input().split()))
n = p[0]
x = p[1]
y = p[2]
d = list(map(int, input().split()))
for i in range(len(d)):
	good = True
	for j in range(i - x, i + y + 1):
		if j >= 0 and j < len(d) and (j != i) and (d[j] <= d[i]):
			good = False
			break
	if good:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(0, n):
	u = i - x
	v = i + y
	q = 0
	if u < 0 and v < n:
		for j in range(0, i):
			if a[j] < a[i]:
				q += 1
				break
		if q == 0:
			for j in range(i + 1, v + 1):
				if a[j] < a[i]:
					q += 1
					break
		if q == 0:
			print(i + 1)
			break
	if u < 0 and v >= n:
		for j in range(0, i):
			if a[j] < a[i]:
				q += 1
				break
		if q == 0:
			for j in range(i + 1, n):
				if a[j] < a[i]:
					q += 1
					break
		if q == 0:
			print(i + 1)
			break
	if u >= 0 and v < n:
		for j in range(u, i):
			if a[j] < a[i]:
				q += 1
				break
		if q == 0:
			for j in range(i + 1, v + 1):
				if a[j] < a[i]:
					q += 1
					break
		if q == 0:
			print(i + 1)
			break
	if u >= 0 and v >= n:
		for j in range(u, i):
			if a[j] < a[i]:
				q += 1
				break
		if q == 0:
			for j in range(i + 1, n):
				if a[j] < a[i]:
					q += 1
					break
		if q == 0:
			print(i + 1)
			break


(n, x, y) = map(int, input().split(' '))
a = list(map(int, input().split(' ')))

def smallest():
	for d in range(n):
		found = True
		for j in range(d - x, d + y + 1):
			if j != d and 0 <= j < n and (a[j] <= a[d]):
				found = False
		if found:
			return d
	return None
print(smallest() + 1)


(N, x, y) = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(N):
	ad = a[i]
	flag = True
	for j in range(max(0, i - x), min(N, i + y + 1)):
		if i != j:
			if ad >= a[j]:
				flag = False
				break
	if flag:
		break
print(i + 1)


(n, x, y) = map(int, input().strip().split(' '))
L = list(map(int, input().strip().split(' ')))
for i in range(len(L)):
	x_min = 10000000000
	y_min = 10000000000
	for j in range(i - 1, max(-1, i - x - 1), -1):
		x_min = min(x_min, L[j])
	for j in range(i + 1, min(n, i + 1 + y)):
		y_min = min(y_min, L[j])
	if x_min > L[i] and y_min > L[i]:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(n):
	if i - x >= 0:
		xi = i - x
	else:
		xi = 0
	if i + y <= n - 1:
		yi = i + y
	else:
		yi = n - 1
	try:
		b = a[xi:i]
		d = a[i + 1:yi + 1]
		if len(b) and len(d) and (a[i] <= min(b)):
			if i != n - 1 and a[i] <= min(d):
				print(i + 1)
				break
			elif i == n - 1:
				print(i + 1)
				break
		elif len(d) and a[i] <= min(d):
			print(i + 1)
			break
		elif len(b) and a[i] <= min(b):
			print(i + 1)
			break
		elif len(b) == 0 and len(d) == 0:
			print(i + 1)
			break
	except:
		pass


(n, x, y) = map(int, input().split())
l = list(map(int, input().split()))
i = 0
while l[i] > min(l[max(0, i - x):i + y + 1]):
	i += 1
print(i + 1)


def main():
	(n, x, y) = map(int, input().split())
	a = list(map(int, input().split()))
	(l, r) = (-x, y)
	cmin = 1000000001
	for i in range(n):
		rl = max(l, 0)
		rr = min(r, n - 1)
		if i == 0 or a[max(rl - 1, 0)] == cmin:
			cmin = min(a[rl:rr + 1])
		else:
			cmin = cmin if cmin < a[rr] else a[rr]
		if a[i] == cmin:
			print(i + 1)
			break
		l += 1
		r += 1
main()


from sys import stdin
(n, x, y) = (int(i) for i in stdin.readline().split())
weather = list((int(i) for i in stdin.readline().split()))
for i in range(0, len(weather)):
	minimum = max(0, i - x)
	maximum = min(n, i + y + 1)
	rainy = 0
	for j in range(minimum, maximum):
		if weather[j] < weather[i]:
			rainy = 1
			break
	if rainy == 0:
		print(i + 1)
		break


(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
s = 0
for d in range(n):
	j = d + y + 1
	if j > n:
		j = n
	t = d - x
	if t < 0:
		t = 0
	for i in range(t, j):
		if i != d:
			if a[d] < a[i]:
				pass
			else:
				break
		if i == j - 1:
			ans = d + 1
			s = 1
	if s == 1:
		break
if s != 1:
	ans = n
print(ans)


(n, l, r) = map(int, input().split())
ls = list(map(int, input().split()))
for i in range(n):
	rl = all((x > ls[i] for x in ls[i + 1:min(i + r + 1, n)]))
	lf = all((x > ls[i] for x in ls[max(i - l, 0):i]))
	if rl == True and lf == True:
		print(i + 1)
		break


s = input()
b = s.split(' ')
n = int(b[0])
x = int(b[1])
y = int(b[2])
s = input()
b = s.split(' ')
a = []
for i in b:
	u = int(i)
	a.append(u)
for i in range(0, n):
	dem = 0
	j = max(0, i - x)
	while a[j] > a[i] and j < i:
		j = j + 1
	if j == i:
		k = min(i + y, n - 1)
		while a[k] > a[i] and k > i:
			k = k - 1
		if k == i:
			dem = 1
	if dem == 1:
		print(i + 1)
		break


import sys
sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline

class SegmentTree:

	def __init__(self, n, func, init=float('inf')):
		self.n = 2 ** (n - 1).bit_length()
		self.init = init
		self.data = [init] * (2 * self.n)
		self.func = func

	def set(self, k, v):
		self.data[k + self.n - 1] = v

	def build(self):
		for k in reversed(range(self.n - 1)):
			self.data[k] = self.func(self.data[k * 2 + 1], self.data[k * 2 + 2])

	def update(self, k, a):
		k += self.n - 1
		self.data[k] = a
		while k > 0:
			k = (k - 1) // 2
			self.data[k] = self.func(self.data[k * 2 + 1], self.data[k * 2 + 2])

	def query(self, l, r):
		L = l + self.n
		R = r + self.n
		ret = self.init
		while L < R:
			if R & 1:
				R -= 1
				ret = self.func(ret, self.data[R - 1])
			if L & 1:
				ret = self.func(ret, self.data[L - 1])
				L += 1
			L >>= 1
			R >>= 1
		return ret
(N, X, Y) = map(int, input().split())
L = [float('inf')] * X
A = list(map(int, input().split()))
L.extend(A)
L.extend([float('inf')] * (X + Y + 2))
Seg = SegmentTree(N + X + Y + X + Y + 2, min, init=float('inf'))
for (i, l) in enumerate(L):
	Seg.set(i, l)
Seg.build()
for i in range(N):
	day = i + X
	day_val = L[i + X]
	before_min = Seg.query(i, day)
	after_min = Seg.query(day + 1, day + 1 + Y)
	if day_val < before_min and day_val < after_min:
		print(i + 1)
		break


(length, back, forw) = map(int, input().split())
rains = list(map(int, input().split()))

def compare(arr, x):
	for i in arr:
		if i < x:
			break
	else:
		return True
	return False
for (day, rain) in enumerate(rains):
	if compare(rains[max(0, day - back):day], rain) and compare(rains[day + 1:day + 1 + forw], rain):
		print(day + 1)
		break


(n, x, y) = map(int, input().split())
aa = list(map(int, input().split()))
for i in range(n):
	good = True
	a = aa[i]
	for j in range(max(0, i - x), i):
		if aa[j] < a:
			good = False
			break
	if good:
		for j in range(i + 1, min(n, i + y + 1)):
			if aa[j] < a:
				good = False
				break
	if good:
		break
print(i + 1)


import pdb
(n, x, y) = map(int, input().strip().split())
a = list(map(int, input().strip().split()))
tr = [0] * n
sau = [0] * n
st = [-1]
for x in range(n):
	while st[-1] != -1 and a[x] <= a[st[-1]]:
		st.pop()
	tr[x] = st[-1]
	st.append(x)
st.clear()
st.append(n)
for x in range(n - 1, -1, -1):
	while st[-1] != n and a[x] <= a[st[-1]]:
		st.pop()
	sau[x] = st[-1]
	st.append(x)
for i in range(n):
	if (i - tr[i] + 1 >= x or tr[i] == -1) and (sau[i] - i - 1 >= y or sau[i] == n):
		print(i + 1)
		break


import sys
import math
input = sys.stdin.readline
(n, x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(n):
	flag = True
	for j in range(1, x + 1):
		if i - j >= 0 and a[i] > a[i - j]:
			flag = False
			break
	for j in range(1, y + 1):
		if i + j < n and a[i] > a[i + j]:
			flag = False
			break
	if flag:
		print(i + 1)
		break


(n, x, y) = [int(x) for x in input().split()]
l = list(map(int, input().split()))
for u in range(n):
	k = list()
	r = list()
	k = l[u - min(u, x):u + 1]
	if min(k) == l[u]:
		r = l[u:u + min(n - u, y + 1)]
		if min(r) == l[u]:
			print(u + 1)
			exit()


t = 1

def solve(a, n, x, y):
	ans = 1
	for i in range(n):
		start = max(0, i - x)
		end = min(n - 1, i + y)
		if min(a[start:end + 1]) == a[i]:
			ans = i + 1
			break
	return ans
for i in range(t):
	(n, x, y) = map(int, input().split())
	a = list(map(int, input().split()))
	print(solve(a, n, x, y))