Little Petya likes arrays of integers a lot. Recently his mother has presented him one such array consisting of n elements. Petya is now wondering whether he can swap any two distinct integers in the array so that the array got unsorted. Please note that Petya can not swap equal integers even if they are in distinct positions in the array. Also note that Petya must swap some two integers even if the original array meets all requirements.

Array a (the array elements are indexed from 1) consisting of n elements is called sorted if it meets at least one of the following two conditions:

  1. a1 ≤ a2 ≤ ... ≤ an; 
  2. a1 ≥ a2 ≥ ... ≥ an. 



Help Petya find the two required positions to swap or else say that they do not exist.

Input

The first line contains a single integer n (1 ≤ n ≤ 105). The second line contains n non-negative space-separated integers a1, a2, ..., an — the elements of the array that Petya's mother presented him. All integers in the input do not exceed 109.

Output

If there is a pair of positions that make the array unsorted if swapped, then print the numbers of these positions separated by a space. If there are several pairs of positions, print any of them. If such pair does not exist, print -1. The positions in the array are numbered with integers from 1 to n.

Examples

Input

1
1


Output

-1


Input

2
1 2


Output

-1


Input

4
1 2 3 4


Output

1 2


Input

3
1 1 1


Output

-1

Note

In the first two samples the required pairs obviously don't exist.

In the third sample you can swap the first two elements. After that the array will look like this: 2 1 3 4. This array is unsorted.
3
3 2 3
 3
1 3 1
 5
1 1 2 1 1
 5
1 1 1 1 2
 4
562617869 562617869 562617869 562617869
 6
1 2 3 3 2 1
 4
562617869 961148050 961148050 961148050
 4
961148050 951133776 596819899 0
 4
961148050 961148050 562617869 961148050
 3
1 2 2
 4
562617869 562617869 961148050 562617869
 3
2 1 3
 4
596819899 562617869 951133776 961148050
 4
951133776 961148050 596819899 562617869
 7
6 5 4 3 2 1 0
 10
1 2 1 2 1 2 1 2 1 2
 4
562617869 596819899 951133776 961148050
 4
961148050 961148050 961148050 562617869
 4
961148050 562617869 562617869 562617869
 4
562617869 562617869 562617869 961148050
 4
2 1 3 4
 4
961148050 951133776 596819899 562617869
 4
562617869 961148050 562617869 562617869
 4
961148050 562617869 961148050 961148050
 3
1 3 2
 4
562617869 961148050 596819899 951133776
 3
2 1 2
 11
1 1 1 1 1 2 2 2 2 2 1
 4
562617869 596819899 951133776 0
 3
1 2 1

-1
 -1
 2 3
 4 5
 -1
 1 2
 1 2
 1 2
 2 3
 1 2
 2 3
 2 3
 2 3
 2 3
 1 2
 1 2
 1 2
 3 4
 1 2
 3 4
 2 3
 1 2
 2 3
 2 3
 1 2
 1 2
 -1
 5 6
 1 2
 -1

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.util.InputMismatchException;
import java.io.InputStreamReader;
import java.io.BufferedOutputStream;
import java.util.StringTokenizer;
import java.io.Closeable;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.Flushable;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	static class TaskAdapter implements Runnable {
		@Override
		public void run() {
			InputStream inputStream = System.in;
			OutputStream outputStream = System.out;
			Input in = new Input(inputStream);
			Output out = new Output(outputStream);
			BUnsortingArray solver = new BUnsortingArray();
			solver.solve(1, in, out);
			out.close();
		}
	}

	public static void main(String[] args) throws Exception {
		Thread thread = new Thread(null, new TaskAdapter(), "", 1<<29);
		thread.start();
		thread.join();
	}
	static class BUnsortingArray {
		public BUnsortingArray() {
		}

		public boolean unsorted(int[] arr) {
			boolean valid = true;
			for(int i = 0; i<arr.length-1&&valid; i++) {
				valid = arr[i]<=arr[i+1];
			}
			if(valid) {
				return false;
			}
			valid = true;
			for(int i = 0; i<arr.length-1&&valid; i++) {
				valid = arr[i]>=arr[i+1];
			}
			return !valid;
		}

		public void solve(int kase, Input in, Output pw) {
			int n = in.nextInt();
			int[] arr = new int[n];
			for(int i = 0; i<n; i++) {
				arr[i] = in.nextInt();
			}
			boolean equals = true;
			for(int i = 0; i<n-1&&equals; i++) {
				equals = arr[i]==arr[i+1];
			}
			if(equals) {
				pw.println("-1");
				return;
			}
			for(int i = 0; i<n; i++) {
				for(int j = i+1; j<n; j++) {
					if(arr[i]!=arr[j]) {
						Utilities.swap(arr, i, j);
						if(unsorted(arr)) {
							pw.println(i+1, j+1);
							return;
						}
						Utilities.swap(arr, i, j);
					}
				}
			}
			pw.println("-1");
		}

	}

	static class Input {
		BufferedReader br;
		StringTokenizer st;

		public Input(InputStream is) {
			this(is, 1<<20);
		}

		public Input(InputStream is, int bs) {
			br = new BufferedReader(new InputStreamReader(is), bs);
			st = null;
		}

		public boolean hasNext() {
			try {
				while(st==null||!st.hasMoreTokens()) {
					String s = br.readLine();
					if(s==null) {
						return false;
					}
					st = new StringTokenizer(s);
				}
				return true;
			}catch(Exception e) {
				return false;
			}
		}

		public String next() {
			if(!hasNext()) {
				throw new InputMismatchException();
			}
			return st.nextToken();
		}

		public int nextInt() {
			return Integer.parseInt(next());
		}

	}

	static class Utilities {
		public static void swap(int[] arr, int i, int j) {
			if(i!=j) {
				arr[i] ^= arr[j];
				arr[j] ^= arr[i];
				arr[i] ^= arr[j];
			}
		}

	}

	static class Output implements Closeable, Flushable {
		public StringBuilder sb;
		public OutputStream os;
		public int BUFFER_SIZE;
		public boolean autoFlush;
		public String LineSeparator;

		public Output(OutputStream os) {
			this(os, 1<<16);
		}

		public Output(OutputStream os, int bs) {
			BUFFER_SIZE = bs;
			sb = new StringBuilder(BUFFER_SIZE);
			this.os = new BufferedOutputStream(os, 1<<17);
			autoFlush = false;
			LineSeparator = System.lineSeparator();
		}

		public void print(String s) {
			sb.append(s);
			if(autoFlush) {
				flush();
			}else if(sb.length()>BUFFER_SIZE >> 1) {
				flushToBuffer();
			}
		}

		public void println(Object... o) {
			for(int i = 0; i<o.length; i++) {
				if(i!=0) {
					print(" ");
				}
				print(String.valueOf(o[i]));
			}
			println();
		}

		public void println(String s) {
			sb.append(s);
			println();
			if(autoFlush) {
				flush();
			}else if(sb.length()>BUFFER_SIZE >> 1) {
				flushToBuffer();
			}
		}

		public void println() {
			sb.append(LineSeparator);
		}

		private void flushToBuffer() {
			try {
				os.write(sb.toString().getBytes());
			}catch(IOException e) {
				e.printStackTrace();
			}
			sb = new StringBuilder(BUFFER_SIZE);
		}

		public void flush() {
			try {
				flushToBuffer();
				os.flush();
			}catch(IOException e) {
				e.printStackTrace();
			}
		}

		public void close() {
			flush();
			try {
				os.close();
			}catch(IOException e) {
				e.printStackTrace();
			}
		}

	}
}

