import java.io.IOException;
import java.io.InputStream;
import java.math.BigInteger;
import java.util.InputMismatchException;

public class CityDay {
	public static void main(String[] args) {
		FastReader in = new FastReader(System.in);
		int n, x, y;
		int[] arr;

		n = in.nextInt();
		x = in.nextInt();
		y = in.nextInt();
		arr = new int[n];

		for (int i = 0; i < n; i++)
			arr[i] = in.nextInt();

		int[] leftBig = new int[n];
		int[] rightBig = new int[n];

		leftBig[0] = 0;
		rightBig[n - 1] = 0;

		for (int i = 1; i < n; i++) {
			if (arr[i] < arr[i - 1]) {
				leftBig[i] = leftBig[i - 1] + 1;
			} else {
				leftBig[i] = 0;
			}
		}
		for (int i = n - 2; i >= 0; i--) {
			if (arr[i] < arr[i + 1]) {
				rightBig[i] = rightBig[i + 1] + 1;
			} else {
				rightBig[i] = 0;
			}
		}
//		System.out.println(Arrays.toString(leftBig));
//		System.out.println(Arrays.toString(rightBig));

		for (int i = 0; i < n; i++)
			if (checkLeft(i, arr[i], arr, x) && checkRight(i, arr[i], n, arr, y)) {
				System.out.println(i + 1);
				return;
			}

	}

	private static boolean checkLeft(int index, int num, int[] arr, int x) {
		int i = index - 1;
		int count = 0;
		while (i >= 0 && i >= index - x && count < x) {
			if (arr[i] > num) {
				count++;
			}
			i--;
		}
		return (index == 0 || (index < x && count > 0) || count >= x);
	}

	private static boolean checkRight(int index, int num, int n, int[] arr, int y) {
		int i = index + 1;
		int count = 0;
		while (i < n && i <= index + y && count < y) {
			if (arr[i] > num) {
				count++;
			}
			i++;
		}
		return (index == n - 1 || (index > n - y - 1 && count > 0) || count >= y);
	}
}

class FastReader{
	private boolean finished = false;
 
	private InputStream stream;

	private byte[] buf = new byte[1024];
	private int curChar;
	private int numChars;
	private SpaceCharFilter filter;
 
	public FastReader(InputStream stream){
		this.stream = stream;
	}
 
	public int read(){
		if (numChars == -1){
			throw new InputMismatchException();
		}
		if (curChar >= numChars){
			curChar = 0;
			try{
				numChars = stream.read (buf);
			} catch (IOException e){
				throw new InputMismatchException ();
			}
			if (numChars <= 0){
				return -1;
			}
		}
		return buf[curChar++];
	}
 
	public int peek(){
		if (numChars == -1){
			return -1;
		}
		if (curChar >= numChars){
			curChar = 0;
			try{
				numChars = stream.read (buf);
			} catch (IOException e){
				return -1;
			}
			if (numChars <= 0){
				return -1;
			}
		}
		return buf[curChar];
	}
 
	public int nextInt(){
		int c = read ();
		while (isSpaceChar (c))
			c = read ();
		int sgn = 1;
		if (c == '-'){
			sgn = -1;
			c = read ();
		}
		int res = 0;
		do{
			if(c==','){
				c = read();
			}
			if (c < '0' || c > '9'){
				throw new InputMismatchException ();
			}
			res *= 10;
			res += c - '0';
			c = read ();
		} while (!isSpaceChar (c));
		return res * sgn;
	}
 
	public long nextLong(){
		int c = read ();
		while (isSpaceChar (c))
			c = read ();
		int sgn = 1;
		if (c == '-'){
			sgn = -1;
			c = read ();
		}
		long res = 0;
		do{
			if (c < '0' || c > '9'){
				throw new InputMismatchException ();
			}
			res *= 10;
			res += c - '0';
			c = read ();
		} while (!isSpaceChar (c));
		return res * sgn;
	}
 
	public String nextString(){
		int c = read ();
		while (isSpaceChar (c))
			c = read ();
		StringBuilder res = new StringBuilder ();
		do{
			res.appendCodePoint (c);
			c = read ();
		} while (!isSpaceChar (c));
		return res.toString ();
	}
 
	public boolean isSpaceChar(int c){
		if (filter != null){
			return filter.isSpaceChar (c);
		}
		return isWhitespace (c);
	}
 
	public static boolean isWhitespace(int c){
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}
 
	private String readLine0(){
		StringBuilder buf = new StringBuilder ();
		int c = read ();
		while (c != '\n' && c != -1){
			if (c != '\r'){
				buf.appendCodePoint (c);
			}
			c = read ();
		}
		return buf.toString ();
	}
 
	public String nextLine(){
		String s = readLine0 ();
		while (s.trim ().length () == 0)
			s = readLine0 ();
		return s;
	}
 
	public String nextLine(boolean ignoreEmptyLines){
		if (ignoreEmptyLines){
			return nextLine ();
		}else{
			return readLine0 ();
		}
	}
 
	public BigInteger nextBigInteger(){
		try{
			return new BigInteger (nextString ());
		} catch (NumberFormatException e){
			throw new InputMismatchException ();
		}
	}
 
	public char nextCharacter(){
		int c = read ();
		while (isSpaceChar (c))
			c = read ();
		return (char) c;
	}
 
	public double nextDouble(){
		int c = read ();
		while (isSpaceChar (c))
			c = read ();
		int sgn = 1;
		if (c == '-'){
			sgn = -1;
			c = read ();
		}
		double res = 0;
		while (!isSpaceChar (c) && c != '.'){
			if (c == 'e' || c == 'E'){
				return res * Math.pow (10, nextInt ());
			}
			if (c < '0' || c > '9'){
				throw new InputMismatchException ();
			}
			res *= 10;
			res += c - '0';
			c = read ();
		}
		if (c == '.'){
			c = read ();
			double m = 1;
			while (!isSpaceChar (c)){
				if (c == 'e' || c == 'E'){
					return res * Math.pow (10, nextInt ());
				}
				if (c < '0' || c > '9'){
					throw new InputMismatchException ();
				}
				m /= 10;
				res += (c - '0') * m;
				c = read ();
			}
		}
		return res * sgn;
	}
 
	public boolean isExhausted(){
		int value;
		while (isSpaceChar (value = peek ()) && value != -1)
			read ();
		return value == -1;
	}
 
	public String next(){
		return nextString ();
	}
 
	public SpaceCharFilter getFilter(){
		return filter;
	}
 
	public void setFilter(SpaceCharFilter filter){
		this.filter = filter;
	}
 
	public interface SpaceCharFilter{
		public boolean isSpaceChar(int ch);
	}
}
