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.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Locale;
import java.util.StringTokenizer;


public class J {
    BufferedReader in;
    StringTokenizer st;
    PrintWriter out;

    String _token() throws IOException {
        while (in.ready() && !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }

    int _int() throws NumberFormatException, IOException {
        return Integer.parseInt(_token());
    }

    long _long() throws NumberFormatException, IOException {
        return Long.parseLong(_token());
    }

    double _double() throws NumberFormatException, IOException {
        return Double.parseDouble(_token());
    }

    void deb(String s) {
        System.err.println(s);
    }

    void deb(Object a) {
        System.err.println(a.toString());
    }

    void init(boolean FILE, String name) throws NumberFormatException,
            IOException {
        Locale.setDefault(Locale.US);
        if (FILE) {
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        } else {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }
        st = new StringTokenizer("");
    }

    int X,Y;
    class vec implements Comparable<vec>{
        int x,y,n,rot;
        double sc;
        vec(){}
        vec(int _x, int _y, int _n, int _rot) {
            x= _x;
            y= _y;
            n= _n;
            rot= _rot;
            sc = Math.sqrt(x*X + y*Y)/ Math.sqrt(X*X + Y*Y);
        }
        public int compareTo(vec b) {
            if (b.n == n) {
                return 0;
            }
            if (sc < b.sc) {
                return -1;
            }
            return 1;
        }
    }
    void gen() throws FileNotFoundException {
        out = new PrintWriter(new File("input.txt"));
        int n = 100000;
        out.println(n);
        for(int i=0;i<n;i++) {
            int rx = (int)(Math.random() * 10000);
            int ry = (int)(Math.random() * 10000);
            out.println(rx +" "+ry);
        }
        out.close();
    }
    void mainProgram() throws NumberFormatException, IOException {
    //  gen();
        init(true, "");
        int n = _int();
        vec a[] = new vec[n];
        
        X = 1234;
        Y = 178;
        
        for(int i=0;i<n;i++) {
            int x = _int();
            int y = _int();
            int rot = 0;
            if (x<0)
                rot |= 1;
            if (y<0)
                rot |= 2;
            a[i] = new vec(Math.abs(x), Math.abs(y), i, rot);
        }
        Arrays.sort(a);
        deb("ok");
        
        int ans = 1<<30;
        int wi=0, wj=0;
        int l=0, r=0;
        
        for(int i=0;i<n;i++) {
           while (i>l && (a[i].sc - a[l].sc) * (a[i].sc - a[l].sc) > ans-1e-7) {
               l++;
           }    
           while (r>i && (a[i].sc - a[r].sc) * (a[i].sc - a[r].sc) > ans-1e-7) {
               r--;
           }
           while (r<n && (a[i].sc - a[r].sc) * (a[i].sc - a[r].sc) < ans - 1e-7) {
               r++;
           }    
           if (r>0)
               r--;
           
           for(int j=l; j<=r; j++) {
               if (i==j) {
                   continue;
               }
               
               int dist = (a[j].x - a[i].x) * (a[j].x - a[i].x) +
                          (a[j].y - a[i].y) * (a[j].y - a[i].y);
               if (dist < ans) {
                   ans = dist;
                   wi = i;
                   wj = j;
               }
           }
        }
        out.println((a[wi].n+1) +" "+(a[wi].rot+1) +" " +
                    (a[wj].n+1) +" "+((a[wj].rot ^ 3)+1));
        
        out.close();
    }

    public static void main(String[] args) throws NumberFormatException,
            IOException {
        long T = System.currentTimeMillis();
        new J().mainProgram();
        System.err.println("Time of working: "
                + (System.currentTimeMillis() - T) + " ms");
    }

    BigInteger add(BigInteger A, BigInteger B) {
        return A.add(B);
    }

    BigInteger mult(BigInteger A, BigInteger B) {
        return A.multiply(B);
    }

    BigInteger sub(BigInteger A, BigInteger B) {
        return A.subtract(B);
    }

    BigInteger div(BigInteger A, BigInteger B) {
        return A.divide(B);
    }

    BigInteger mi(BigInteger A) {
        return (BigInteger.ZERO).subtract(A);
    }

    BigInteger sq(BigInteger A) {
        return A.multiply(A);
    }

    BigInteger val(long a) {
        return BigInteger.valueOf(a);
    }

    int cmp(BigInteger a, BigInteger b) {
        return a.compareTo(b);
    }

}