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.util.*;
import java.io.*;

public class Main{

    BufferedReader in;
    StringTokenizer str = null;
    PrintWriter out;
    
    private String next() throws Exception{
    	while (str == null || !str.hasMoreElements())
    	    str = new StringTokenizer(in.readLine());
    	return str.nextToken();
    }
    
    private int nextInt() throws Exception{
	return Integer.parseInt(next());
    }
    
    int n, min, ri, rj;
    int []x, y;
    Pt[] p, t;
    
    public void run() throws Exception{
    	in = new BufferedReader(new FileReader("input.txt"));
    	out = new PrintWriter(new File("output.txt"));
    	//in = new BufferedReader(new InputStreamReader(System.in));
    	//out = new PrintWriter(System.out);
    	
    	n = nextInt();
    	x = new int[n];
    	y = new int[n];
    	for(int i=0;i<n;i++){
    	    x[i] = nextInt();
    	    y[i] = nextInt();
    	}
    	
    	p = new Pt[n];
    	for(int i=0;i<n;i++){
    	    p[i] = new Pt(Math.abs(x[i]), Math.abs(y[i]), i);
    	}
    	
    	t = new Pt[n];
    	Arrays.sort(p, 0, n, new cmpX());
    	
    	min = Integer.MAX_VALUE;
    	ri = -1; rj = -1;
    	find(0, n-1);
    	
    	out.println((ri+1) + " " + print(Math.abs(x[ri]), Math.abs(y[ri]), ri) + " " + (rj + 1) + " " + print(-Math.abs(x[rj]), -Math.abs(y[rj]), rj));
    	out.close();
    }
    
    private int print(int a, int b, int i){
	//System.out.println(a + " " + b + " " + x[i] + " " + y[i] + " " + i);
	if (x[i] == a && y[i] == b) return 1;
	if (x[i] == -a && y[i] == b) return 2;
	if (x[i] == a && y[i] == -b) return 3;
	return 4;
    }
    
    private void updateAns(Pt a, Pt b){
	int dis = a.dis(b);
	//System.out.println(min + " " + dis);
	if (min > dis){
	    min = dis;
	    ri = a.id;
	    rj = b.id;
	}
    }
    
    public void find(int l, int r){
	if (r - l <= 3){
	    for(int i=l;i<=r;i++){
		for(int j=i+1;j<=r;j++){
		    updateAns(p[i], p[j]);
		}
	    }
	    return;
	}
	
	int mid = (l + r) >> 1;
	int x = p[mid].x;
	
	find(l, mid);
	find(mid+1, r);
	
	Arrays.sort(p, l, r+1, new cmpY());
	
	int tsize = 0;
	for(int i=l;i<=r;i++){
	    if (Math.abs(x - p[i].x) < min){
		for(int j=tsize-1;j>=0 && p[i].y - t[j].y < min;j--){
		    updateAns(p[i], t[j]);
		}
	    }
	    t[tsize++] = p[i];
	}
    }
    
    static class Pt{
	int x, y, id;
	
	public Pt(int x, int y, int id){
	    this.x = x;
	    this.y = y;
	    this.id = id;
	}
	
	public int dis(Pt other){
	    return (x - other.x) * (x - other.x) + (y - other.y) * (y - other.y);
	}
    }
    
    static class cmpX implements Comparator<Pt>{
	public int compare(Pt a, Pt b){
	    return (a.x - b.x) == 0 ? a.y - b.y : a.x - b.x;
	}
    }
    
    static class cmpY implements Comparator<Pt>{
	public int compare(Pt a, Pt b){
	    return a.y - b.y;
	}
    }

    public static void main(String args[]) throws Exception{
	   new Main().run();
    }
}