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.*;
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
public class Main{
    public static void main(String[]args){
        InputStream in = System.in;
        PrintWriter out = new PrintWriter(System.out);
        try{
            in = new BufferedInputStream(new FileInputStream(new File("input.txt")));
            out = new PrintWriter(new BufferedOutputStream(new FileOutputStream("output.txt")));
        }catch (Exception e) {
        }
        new Main().run(in,out);
        out.flush();
    }
    private void debug(Object...os){
        System.err.println(deepToString(os));
    }
    class P{
        double x,y;
        int type;
        int id;
        public P(int x,int y,int id){
            super();
            if(x>=0 && y>=0)type=1;
            if(x<0 && y>=0)type=2;
            if(x>=0 && y<0)type=3;
            if(x<0 && y<0)type=4;
            this.x=abs(x);
            this.y=abs(y);
            this.id = id;
        }
        public double dist2(P p){
            return p2(x-p.x)+p2(y-p.y);
        }
        private double p2(double d){
            return d*d;
        }
        
    }
    private void run(InputStream in,PrintWriter out){
        int n = nextInt(in);
        P[] ps=new P[n];
        for(int i=0;i<n;i++){
            ps[i] = new P(nextInt(in),nextInt(in),i);
        }
        P[] res = closestPair(ps);
        out.printf("%d %d %d %d\n",res[0].id+1,res[0].type,res[1].id+1,5-res[1].type);
    }
    
    public P[] closestPair(P[] ps){
        sort(ps,new Comparator<P>(){
            public int compare(P o1,P o2){
                return Double.compare(o1.x,o2.x);
            }
        });
        return closestPair(ps,0,ps.length,new Comparator<P>(){
            public int compare(P o1,P o2){
                return Double.compare(o1.y,o2.y);
            }
        });
    }
    
    private P[] closestPair(P[] ps,int from,int to,Comparator<P> compY){
        int n = to-from;
        if(n<100){
            P[] best = null;
            for(int i=0;i<n;i++)for(int j=0;j<i;j++)best = best(best,mp(ps[i],ps[j]));
            return best;
        }
        int mid = from + n/2;
        
        P[] resL = closestPair(ps,from,mid,compY);
        P[] resR = closestPair(ps,mid,to,compY);
        
        P[] best = best(resL,resR);
        double minDist = dist(best);
        
        P midPoint = ps[mid];
        ArrayList<P> list = new ArrayList<P>();
        for(P p:ps)if(abs(p.x-midPoint.x) < minDist)list.add(p);
        sort(list,compY);
        for(int i=0;i<list.size();i++){
            int j=i+1;
            while(j<list.size() && list.get(j).y-list.get(i).y<minDist){
                double d = list.get(j).dist2(list.get(i));
                if(minDist > d){
                    minDist = d;
                    best = mp(list.get(i),list.get(j));
                }
                j++;
            }
        }
        return best;
    }
    
    private P[] best(P[] as,P[] bs){
        if(as==null)return bs;
        if(bs==null)return as;
        double a = dist(as);
        double b = dist(bs);
        return a>b ? bs : as;
    }
    
    private double dist(P[] ps){
        return ps[0].dist2(ps[1]);
    }
    private P[] mp(P i,P j){
        return new P[]{i,j};
    }

    private int nextInt(InputStream in){
        try{
            int c=in.read();
            if(c==-1) return c;
            while(c!='-'&&(c<'0'||'9'<c)){
                c=in.read();
                if(c==-1) return c;
            }
            if(c=='-') return -nextInt(in);
            int res=0;
            do{
                res*=10;
                res+=c-'0';
                c=in.read();
            }while('0'<=c&&c<='9');
            return res;
        }catch(Exception e){
            return -1;
        }
    }
}