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 time
import io
import math
import random

def timer(f):
    def tmp(*args, **kwargs):
        t = time.time()
        res = f(*args, **kwargs)
        print ("Time : %f" % (time.time()-t))
        return res

    return tmp

def gcd(a, b):
    if b == 0:
        return a
    else:
        return gcd(b, a%b)

def f(a, b):
    return Value(gcd(a.val, b.val))

class Value:
    val = 0
    def __init__(self, val):
        self.val = val

    def __str__(self):
        return str(self.val)

    @staticmethod
    def zero():
        return Value(1)

    @staticmethod
    def dif(a, b):
        return Value(a.val - b.val)

class BinaryTree():
    leftChild = None
    rightChild= None
    value = None
    left=0;
    right=0;

    def __init__(self, left, right, value, leftBound, rightBound):
        self.leftChild = left
        self.rightChild = right
        self.value = value;
        self.left = leftBound
        self.right = rightBound

    def print(self, indent):
        if self.leftChild == None:
            return str(self.value)+" ("+str(self.left)+" - "+str(self.right)+")";
        else:
            sleft = self.leftChild.print(indent+1)
            sright = self.rightChild.print(indent+1)
            return str(self.value)+" ("+str(self.left)+" - "+str(self.right)+")"+'\n'+("   "*indent)+sleft+"\n"+("   "*indent)+sright

    @staticmethod
    def build(array, left, right, f):
        if left == right :
            return BinaryTree(None, None, array[left], left, right)
        else:
            middle = (left+right)//2
            leftTree = BinaryTree.build(array, left, middle, f)
            rightTree = BinaryTree.build(array, middle+1, right, f)
            value = f(leftTree.value, rightTree.value)
            return BinaryTree(leftTree, rightTree, value, left, right)

    def query(self, fr, to, f):
        if fr > to:
            return Value.zero()
        if self.left == fr and self.right == to:
            return self.value
        else:
            middle = (self.left+self.right)//2
            leftVal = self.leftChild.query(fr, min(middle, to), f)
            rightVal = self.rightChild.query(max(middle+1, fr), to, f)
            return f(leftVal, rightVal)

    def modify(self, index, newValue, f):
        dif = Value.dif(newValue, self.query(index, index,f))
        if index == self.left and index == self.right:
            self.value = newValue
        else:
            middle = (self.left+self.right)//2
            self.value = f(self.value, dif)
            if index <= middle:
                self.leftChild.modify(index, newValue, f)
            else:
                self.rightChild.modify(index, newValue, f)


@timer
def use():
    array = []
    #for i in range(4):
    #array.append(Value(i+1))

    array.append(Value(4))
    array.append(Value(6))
    array.append(Value(12))
    array.append(Value(4))

    segmentTree = BinaryTree.build(array, 0, len(array)-1, f)
    print(segmentTree.print(1))
    print(segmentTree.query(1, 3, f))
    segmentTree.modify(3, Value(5), f)
    print(segmentTree.print(1))
    print(segmentTree.query(1, 3, f))

#use(
#print(V, a, k)

s = int(input())
str = input().split(' ')
array = []
for i in range(s):
    array.append(int(str[i]))

min = 1000000
ll = 0
rr = 0;
for i in range(s):
    left = array[i]
    right = array[(i+1)%s]
    if math.fabs(left-right)<min:
        min = math.fabs(left-right)
        ll = i
        rr = (i+1)%s
print(ll+1, rr+1)