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 static java.util.Arrays.*;
import static java.lang.Math.*;
import static java.math.BigInteger.*;
import java.util.*;
import java.math.*;
import java.io.*;

public class J implements Runnable
{
    String file = "input";
    
    boolean TEST = false;
    
    void solve() throws IOException
    {
        int n = nextInt();
        ps = new Point[n];
        qs = new int[n];
        
        for(int i = 0; i < n; i++)
        {
            ps[i] = new Point(nextInt(), nextInt(), i, 0);
            if(ps[i].x < 0)
            { 
                ps[i].p |= 1;
                ps[i].x = -ps[i].x;
            }
            if(ps[i].y < 0)
            {
                ps[i].p |= 2;
                ps[i].y = -ps[i].y;
            }
        }
        sort(ps);
        res = new int[4];
        best = Long.MAX_VALUE / 2;
        shortest_distance(0, n - 1);
        
        for(int i = 0; i < 4; i++) out.print((res[i] + 1) + " ");
        out.println();
    }
    long best;
    
    void check(int i, int j)
    {
        long X = ps[i].x - ps[j].x;
        long Y = ps[i].y - ps[j].y;
        if(X * X + Y * Y < best)
        {
            best = X * X + Y * Y;
            res[0] = ps[i].i;
            res[1] = ps[i].p;
            res[2] = ps[j].i;
            res[3] = ps[j].p ^ 3;
        }
    
    }
    
    void mergeY(int S, int T)
    {
        int M = (S + T) / 2;
        Point[] as = new Point[M - S + 1];
        Point[] bs = new Point[T - M];
        Point[] cs = new Point[T - S + 1];
        for(int i = 0; i < as.length; i++) as[i] = ps[S + i];
        for(int i = 0; i < bs.length; i++) bs[i] = ps[M + 1 + i];
        
        int i, j, k;
        for(i = 0, j = 0, k = 0; i < as.length && j < bs.length;)
        {
            if(as[i].y <= bs[j].y) cs[k++] = as[i++];
            else cs[k++] = bs[j++];
        }
        while(i < as.length) cs[k++] = as[i++];
        while(j < bs.length) cs[k++] = bs[j++];
        for(i = S; i <= T; i++) ps[i] = cs[i - S];
    }
    
    //shortest distance of all points from S to T (inclusive)
    void shortest_distance(int S, int T)
    {
        if(S == T) return;
        int M = (S + T) / 2;
        int xMid = ps[M].x;
        
        shortest_distance(S, M); 
        shortest_distance(M + 1, T);
            
        mergeY(S, T); //merge sort on y coordinates
            
        double R = sqrt(best);

        int qLen = 0;
        for(int i = S; i <= T; i++)
            if(xMid - R <= ps[i].x && ps[i].x <= xMid + R) qs[qLen++] = i;
        
        for(int i = 0; i < qLen; i++)
            for(int j = i + 1; j < qLen && ps[qs[j]].y - ps[qs[i]].y <= R; j++)
                check(qs[i], qs[j]);
    }

    int[] res;
    Point[] ps;
    int[] qs;
    
    class Point implements Comparable<Point>
    {
        int x, y, i, p;
        
        Point(int x, int y, int i, int p)
        {
            this.x = x;
            this.y = y;
            this.i = i;
            this.p = p;
        }
        
        public String toString()
        {
            return "(" + x + ", " + y + ")";
        }
        
        public int compareTo(Point p)
        {
            if(x != p.x) return x - p.x;
            return y - p.y;
        }
    }
    
    String next() throws IOException
    {
        while(st == null || !st.hasMoreTokens()) st = new StringTokenizer(input.readLine());
        return st.nextToken();
    }
    
    int nextInt() throws IOException
    {
        return Integer.parseInt(next());
    }
    
    long nextLong() throws IOException
    {
        return Long.parseLong(next());
    }
    
    double nextDouble() throws IOException
    {
        return Double.parseDouble(next());
    }
    
    void print(Object... o)
    {
        System.out.println(deepToString(o));
    }
    
    void gcj(Object o)
    {
        String s = String.valueOf(o);
        out.println("Case #" + test + ": " + s);
        System.out.println("Case #" + test + ": " + s);
    }
    
    BufferedReader input;
    PrintWriter out;
    StringTokenizer st;
    int test;
    
    void init() throws IOException
    {
        input = new BufferedReader(new FileReader(file + ".txt")); 
        if(TEST) out = new PrintWriter(new BufferedOutputStream(System.out));
        else out = new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    
    public static void main(String[] args) throws IOException
    {
        new Thread(null, new J(), "", 1 << 20).start();
    }
    
    public void run()
    {
        try
        {
            init();
            if(TEST) 
            {
                int runs = nextInt();
                for(int i = 0; i < runs; i++) solve();
            }
            else solve();
            out.close();        
        }
        catch(Exception e)
        {
            e.printStackTrace();
            System.exit(1);
        }
    }
}