Problem: You are given a set of n vectors on a plane. For each vector you are allowed to multiply any of its coordinates by -1. Thus, each vector vi = (xi, yi) can be transformed into one of the following four vectors:

  * vi1 = (xi, yi), 
  * vi2 = ( - xi, yi), 
  * vi3 = (xi, - yi), 
  * vi4 = ( - xi, - yi). 



You should find two vectors from the set and determine which of their coordinates should be multiplied by -1 so that the absolute value of the sum of the resulting vectors was minimally possible. More formally, you should choose two vectors vi, vj (1 ≤ i, j ≤ n, i ≠ j) and two numbers k1, k2 (1 ≤ k1, k2 ≤ 4), so that the value of the expression |vik1 + vjk2| were minimum.

Input

The first line contains a single integer n (2 ≤ n ≤ 105). Then n lines contain vectors as pairs of integers "xi yi" ( - 10000 ≤ xi, yi ≤ 10000), one pair per line.

Output

Print on the first line four space-separated numbers "i k1 j k2" — the answer to the problem. If there are several variants the absolute value of whose sums is minimum, you can print any of them. 

Examples

Input

5
-7 -3
9 0
-8 6
7 -8
4 -5


Output

3 2 4 2


Input

5
3 2
-4 7
-6 0
-8 4
5 1


Output

3 4 5 4

Note

A sum of two vectors v = (xv, yv) and u = (xu, yu) is vector s = v + u = (xv + xu, yv + yu).

An absolute value of vector v = (x, y) is number <image>. 

In the second sample there are several valid answers, such as:

(3 1 4 2), (3 1 4 4), (3 4 4 1), (3 4 4 3), (4 1 3 2), (4 1 3 4), (4 2 3 1).

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.Random;
import java.util.StringTokenizer;

public class Solution{
	
	
	static int n;
	static Point[] p;
	static boolean[][] sign; //if the sign of x & y coordinate is positive or negative
	static int mindist = (int)1e9+100;
	static int[] ans;
	
	
	
    public static void main(String[] args) throws IOException {
    	
    	System.setOut(new PrintStream("output.txt"));
		System.setIn(new FileInputStream("input.txt"));
		
    	FastScanner fs = new FastScanner();
    	PrintWriter out = new PrintWriter(System.out);
    	
    	
    		
    	int tt = 1;
    	while(tt-->0) {
    		
    		n = fs.nextInt();
    		p = new Point[n];
    		sign = new boolean[n][2];
    		
    		for(int i=0;i<n;i++) {
    			int x = fs.nextInt(), y = fs.nextInt();
    			sign[i][0] = x>=0; sign[i][1] = y>=0;
    			p[i] = new Point(Math.abs(x), Math.abs(y), i);
    		}
    		
    		Arrays.sort(p, (p1, p2) -> (p1.x==p2.x)?(p1.y-p2.y):(p1.x-p2.x));
    		
    		solve(0, n-1);
    		
    		int i = ans[0], j = ans[1];
    		
    		out.print(i+1+" "+positive(sign[i])+" "+(j+1)+" "+positive(new boolean[] {!sign[j][0], !sign[j][1]}));
    		
    		
    		
    		
    	}
    	
    		
    		
    		
    	out.close();
    		
    }
    
    
    
    static Point[] solve(int l, int r) {
    	Point[] res = new Point[r-l+1];
    	if(r-l+1<=3) {
    		for(int i=0,j=l;j<=r;i++,j++) {
    			res[i] = new Point(p[j].x, p[j].y, j);
    			for(int k=j+1;k<=r;k++) {
    				update(j, k);
    			}
    		}
    		Arrays.sort(res, (p1, p2) -> p1.y-p2.y);
    		return res;
    	}
    	
    	int mid = (l+r)/2;
    	int midx = p[mid].x;
    	Point[] left = solve(l, mid);
    	Point[] right = solve(mid+1, r);
    	
    	int i=0, j = 0;
    	for(int k=0;k<res.length;k++) {
    		if(j==right.length || (i<left.length && left[i].y<=right[j].y)) {
    			res[k] = new Point(left[i].x, left[i].y, left[i].idx);
    			i++;
    		}
    		else {
    			res[k] = new Point(right[j].x, right[j].y, right[j].idx);
    			j++;
    		}
    	}
    	
    	
    	ArrayList<Integer> list = new ArrayList<>();
    	
    	for(int k=0;k<res.length;k++) {
    		if(square(midx-res[k].x)>=mindist) continue;
    		for(int m=list.size()-1;m>=0;m--) {
    			if(square(res[k].y-p[list.get(m)].y)>mindist) break;
    			update(res[k].idx, list.get(m));
    		}
    		list.add(res[k].idx);
    	}
    	
    	return res;
    }


    
    
    static void update(int i, int j) {
    	int d = dist(i, j);
    	if(d<mindist) {
    		mindist = d;
    		ans = new int[] {p[i].idx, p[j].idx};
    	}
    }
    
    
    static class Point{
    	int x, y, idx;
    	Point(int x,int y,int idx){
    		this.x = x;
    		this.y = y;
    		this.idx = idx;
    	}
    }
   
    
    static int dist(int i, int j) {
    	return square(p[i].x-p[j].x) + square(p[i].y-p[j].y);
    }
    
    static int square(int x) {
    	return x*x;
    }
    
    
    static int positive(boolean[] sign) {
    	if(sign[0] && sign[1]) {
    		return 1;
    	}
    	if(!sign[0] && sign[1]) {
    		return 2;
    	}
    	if(sign[0] && !sign[1]) {
    		return 3;
    	}
    	return 4;
    }
  
    
    
    static final Random random=new Random();
    	
    static void ruffleSort(int[] a) {
    	int n=a.length;//shuffle, then sort 
    	for (int i=0; i<n; i++) {
    		int oi=random.nextInt(n); int temp=a[oi];
    		a[oi]=a[i]; a[i]=temp;
    	}
    	Arrays.sort(a);
    }
    
    static void ruffleSort(long[] a) {
    	int n=a.length;//shuffle, then sort 
    	for (int i=0; i<n; i++) {
    		int oi=random.nextInt(n); long temp=a[oi];
    		a[oi]=a[i]; a[i]=temp;
    	}
    	Arrays.sort(a);
    }
   
  
    
    static void reverse(int[] arr, int l, int r) {
    	for(int i=l;i<l+(r-l)/2;i++){
    		int temp = arr[i]; arr[i] = arr[r-i+l-1]; arr[r-i+l-1] = temp;
    	}
    }
    
    static void reverse(long[] arr, int l, int r) {
    	for(int i=l;i<l+(r-l)/2;i++){
    		long temp = arr[i]; arr[i] = arr[r-i+l-1]; arr[r-i+l-1] = temp;
    	}
    }
    
    
    static <T> void reverse(T[] arr, int l, int r) {
    	for(int i=l;i<l+(r-l)/2;i++) {
    		T temp = arr[i]; arr[i] = arr[r-i+l-1]; arr[r-i+l-1] = temp;
    	}
    }
    	
    	
    static class FastScanner{
    	BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    	StringTokenizer st = new StringTokenizer("");
     
    	public String next(){
    		while(!st.hasMoreElements()){
    			try{
    				st = new StringTokenizer(br.readLine());
    			} catch(IOException e){
    				e.printStackTrace();
    			}
    		}
    		return st.nextToken();
    	}
    		
    	public String nextLine() throws IOException {
    		return br.readLine();
    	}
    		
    	public int nextInt(){
    		return Integer.parseInt(next());
    	}
     
    	public int[] readArray(int n){
    		int[] a = new int[n];
    		for(int i=0;i<n;i++)
    			a[i] = nextInt();
    		return a;
    	}
    		
    	public long nextLong() {
    		return Long.parseLong(next());
    	}
    		
    	public char nextChar() {
    		return next().toCharArray()[0];
    	}
    }
   	
}