You are given a sequence a1, a2, ..., an of one-dimensional segments numbered 1 through n. Your task is to find two distinct indices i and j such that segment ai lies within segment aj.

Segment [l1, r1] lies within segment [l2, r2] iff l1 ≥ l2 and r1 ≤ r2.

Print indices i and j. If there are multiple answers, print any of them. If no answer exists, print -1 -1.

Input

The first line contains one integer n (1 ≤ n ≤ 3·105) — the number of segments.

Each of the next n lines contains two integers li and ri (1 ≤ li ≤ ri ≤ 109) — the i-th segment.

Output

Print two distinct indices i and j such that segment ai lies within segment aj. If there are multiple answers, print any of them. If no answer exists, print -1 -1.

Examples

Input

5
1 10
2 9
3 9
2 3
2 9


Output

2 1


Input

3
1 5
2 6
6 20


Output

-1 -1

Note

In the first example the following pairs are considered correct:

  * (2, 1), (3, 1), (4, 1), (5, 1) — not even touching borders; 
  * (3, 2), (4, 2), (3, 5), (4, 5) — touch one border; 
  * (5, 2), (2, 5) — match exactly. 
import sys
range = xrange
input = raw_input

class seg:
    def __init__(self,n):
        m = 1
        while m<n:m*=2
        self.n = n
        self.m = m
        self.data = [(-1,-1)]*(n+m)
    def setter(self,l,r,val):
        l += self.m
        r += self.m
        while l<r:
            if l%2==1:
                self.data[l]=max(self.data[l],val)
                l+=1
            if r%2==1:
                r-=1
                self.data[r]=max(self.data[r],val)
            l//=2
            r//=2
    def maxxer(self,ind):
        ind += self.m
        val = (-1,-1)
        while ind>0:
            val = max(val,self.data[ind])
            ind//=2
        return val


n = int(input())
inp = [int(x) for line in sys.stdin for x in line.split()]

mapper = {}
unused = 0
A = sorted(inp)
for a in A:
    if a not in mapper:
        mapper[a]=unused
        unused+=1

inp = [mapper[i] for i in inp]

segtree = seg(unused) 
for i in sorted(list(range(n)),key=lambda i:inp[2*i+1]-inp[2*i],reverse=True):
    L = inp[2*i]
    R = inp[2*i+1]+1
    cover,j = segtree.maxxer(L)
    if cover>=R:
        print i+1,j+1
        sys.exit()
    segtree.setter(L,R,(R,i))
print -1,-1



