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 java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.InputMismatchException;
import java.util.Iterator;
import java.util.TreeMap;
public class Solution1 implements Runnable
{
	static final long MAX = 1000000007L;
	static class InputReader
	{
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;
		private SpaceCharFilter filter;
		private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
 
		public InputReader(InputStream stream)
		{
			this.stream = stream;
		}
		
		public int read()
		{
			if (numChars==-1) 
				throw new InputMismatchException();
			
			if (curChar >= numChars)
			{
				curChar = 0;
				try 
				{
					numChars = stream.read(buf);
				}
				catch (IOException e)
				{
					throw new InputMismatchException();
				}
				
				if(numChars <= 0)				
					return -1;
			}
			return buf[curChar++];
		}
	 
		public String nextLine()
		{
			String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
		}
		public int nextInt()
		{
			int c = read();
			
			while(isSpaceChar(c)) 
				c = read();
			
			int sgn = 1;
			
			if (c == '-') 
			{
				sgn = -1;
				c = read();
			}
			
			int res = 0;
			do 
			{
				if(c<'0'||c>'9') 
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			while (!isSpaceChar(c)); 
			
			return res * sgn;
		}
		
		public long nextLong() 
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') 
			{
				sgn = -1;
				c = read();
			}
			long res = 0;
			
			do 
			{
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			while (!isSpaceChar(c));
				return res * sgn;
		}
		
		public double nextDouble() 
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') 
			{
				sgn = -1;
				c = read();
			}
			double res = 0;
			while (!isSpaceChar(c) && c != '.') 
			{
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, nextInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			if (c == '.') 
			{
				c = read();
				double m = 1;
				while (!isSpaceChar(c)) 
				{
					if (c == 'e' || c == 'E')
						return res * Math.pow(10, nextInt());
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					m /= 10;
					res += (c - '0') * m;
					c = read();
				}
			}
			return res * sgn;
		}
		
		public String readString() 
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do 
			{
				res.appendCodePoint(c);
				c = read();
			} 
			while (!isSpaceChar(c));
			
			return res.toString();
		}
	 
		public boolean isSpaceChar(int c) 
		{
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}
	 
		public String next() 
		{
			return readString();
		}
		
		public interface SpaceCharFilter 
		{
			public boolean isSpaceChar(int ch);
		}
	}
 	
	public static void main(String args[]) throws Exception
	{
		new Thread(null, new Solution1(),"Solution1",1<<26).start();
	}
	ArrayList<Integer> ar[];
	Pair[] p1;
	public void run()
	{
		InputReader sc= new InputReader(System.in);
		PrintWriter w= new PrintWriter(System.out);
		int n = sc.nextInt();
		p = new Pair[n];
		for(int i = 0;i < n;i++){
			p[i] = new Pair(sc.nextInt(),sc.nextInt(),i);
		}
		Arrays.sort(p);
		segTree = new ArrayList[4*n];
		build(0,n-1,0);
		for(int i = 0;i < p.length;i++){
			int x = query(0,n-1,i+1,n-1,0,p[i].x);
			if(x != -1){
				w.println((x+1) + " " + (p[i].z+1));
				w.close();
				System.exit(0);
			}
		}
		w.println("-1 -1");
		w.close();
	}
	Pair[] p;
	ArrayList<Pair> segTree[];
	void build(int l,int r,int pos){
		if(l == r){
			segTree[pos] = new ArrayList();
			segTree[pos].add(p[l]);
			return;
		}
		int mid = (l + r)/2;
		build(l,mid, 2*pos+1);
		build(mid+1,r,2*pos+2);
		segTree[pos] = merge(segTree[2*pos+1],segTree[2*pos+2]);
	}
	int query(int l,int r,int start,int end,int pos,int val){
		if(l > end || r < start || l > r){
			return -1;
		}
		if(l >= start && r <= end){
			if(segTree[pos].get(segTree[pos].size()-1).x >= val){
				return segTree[pos].get(segTree[pos].size()-1).z;
			}else{
				return -1;
			}
		}
		int mid = (l + r)/2;
		int p1 = query(l,mid, start, end, 2*pos+1, val);
		int p2 = query(mid+1, r, start, end, 2*pos+2, val);
		return (p1 >= 0) ? p1 : p2;
	}
	ArrayList<Pair> merge(ArrayList<Pair> a,ArrayList<Pair> b){
		ArrayList<Pair> c = new ArrayList();
		int i = 0;
		int j = 0;
		while(i < a.size() && j < b.size()){
			if(a.get(i).x <= b.get(j).x){
				c.add(a.get(i));
				i++;
			}else{
				c.add(b.get(j));
				j++;
			}
		}
		while(i < a.size()){
			c.add(a.get(i));
			i++;
		}
		while(j < b.size()){
			c.add(b.get(j));
			j++;
		}
		return c;
	}
	static class Pair implements Comparable<Pair>{
		int x;
		int y;
		int z;
		
		Pair(){}	
		Pair(int x,int y,int z){
			this.x = x;
			this.y = y;
			this.z = z;
		}
		public int compareTo(Pair p){
			if(p.y == this.y){
				return Long.compare(this.x,p.x);
			}
			return Long.compare(p.y,this.y);
		}
	}
}