n soldiers stand in a circle. For each soldier his height ai is known. A reconnaissance unit can be made of such two neighbouring soldiers, whose heights difference is minimal, i.e. |ai - aj| is minimal. So each of them will be less noticeable with the other. Output any pair of soldiers that can form a reconnaissance unit.

Input

The first line contains integer n (2 ≤ n ≤ 100) — amount of soldiers. Then follow the heights of the soldiers in their order in the circle — n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 1000). The soldier heights are given in clockwise or counterclockwise direction.

Output

Output two integers — indexes of neighbouring soldiers, who should form a reconnaissance unit. If there are many optimum solutions, output any of them. Remember, that the soldiers stand in a circle.

Examples

Input

5
10 12 13 15 10


Output

5 1


Input

4
10 20 30 40


Output

1 2


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class A {
    /*
     * In a Programming contest, you are expected to print the output at the
     * end, so `output` variable will hold all the processed results till the
     * end
     */
    public static String output = "";

    // Program's starting point
    public static void main(String[] args) {

        /*
         * A Scanner class slows down Input/Output a LOT ,thereby increasing
         * your code execution time , Hence for best results that is Fast I/O
         * try to use BufferedReader
         */
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        /*
         * Generally Code Chef, Hacker Rank gives X number of test cases so we
         * process the input for each.
         */

        try {

            /*
             * Logic of the program must be separated from the meta code to
             * increase readability and help debugging easier
             * Also note that Solver object is created inside for loop to
             * avoid multiple object creation that drastically increases
             * execution time and memory usage
             */
            int n = Integer.parseInt(br.readLine());
            String[] line = br.readLine().split(" ");
            int[] h = new int[n];
            for(int i = 0; i < n; ++i) {
                h[i] = Integer.parseInt(line[i]);
            }
            Solver solver = new Solver();
            solver.solve(n, h);

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        // Print the final output
        System.out.println(output);
    }
}

class Solver {

    /*
     * Logic goes here ...
     * Add to the global variables after processing the input
     * Maybe reverse a string or parse to an integer or , etc.
     */
    public void solve(int n, int[] h) {
        String pair = "1" + " " + n;
        int minDiff = Math.abs(h[n-1] - h[0]);

        if(minDiff > 0) {
            for(int i = 0; i < n-1; ++i ) {
                if(Math.abs(h[i] - h[i+1]) < minDiff) {
                    minDiff = Math.abs(h[i] - h[i+1]);
                    pair = (i+1) + " " + (i+2);
                }
                if(minDiff == 0) break;
            }
        }
        A.output = A.output.concat(pair);
    }

}

