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
'''It comprises of 4 functions :-

1) inp — For taking integer inputs.

2) inlt — For taking List inputs.

3) insr — For taking string inputs. Actually it returns a List of Characters,
instead of a string,which is easier to use in Python, because in Python, Strings are Immutable.

4) invr — For taking space seperated integer variable inputs.

The input = sys.stdin.readline is actually for Faster Inputs,
 because line reading through System STDIN (Standard Input) is faster in Python.
'''

import sys
input = sys.stdin.readline

############ ---- Input Functions ---- ############
def inp():
    return(int(input()))
def inlt():
    return(list(map(int,input().split())))
def insr():
    s = input()
    return(list(s[:len(s) - 1]))
def invr():
    return(map(int,input().split()))


inp = inp()
inlt = inlt()
insr = insr()


previousS = -999999
previousIndex = 1
result = [len(inlt), 1]

previousNeighbourSum = 0

lowestValue = [999999999]
for index, s in enumerate(inlt, start=1):
  neighbourSum = abs(s - previousS)
  lowestValue.append(neighbourSum)
  if(neighbourSum < previousNeighbourSum and neighbourSum <  abs(inlt[0] - inlt[-1]) and neighbourSum <= min(lowestValue)):
    result = [previousIndex, index]

  previousS = s
  previousIndex = index
  previousNeighbourSum = neighbourSum


print(" ".join([str(elem) for elem in result]))
