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.File;
import java.io.PrintStream;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Random;
import java.util.Scanner;
import java.util.TreeMap;
import java.util.TreeSet;


public class J {
    static class P implements Comparable<P> {
        public int x, y;
        public P(int x, int y) { this.x=x;this.y=y; }
        @Override
        public int compareTo(P o) {
            return x!=o.x?x-o.x:y-o.y;
        }
        @Override
        public boolean equals(Object p) {
            return x==((P)p).x&&y==((P)p).y;
        }
    }
    
    static P[] ClosestPair(int[] x, int[] y) {
        final int n = x.length;
        P[] ps = new P[n];
        for(int i = 0; i < n; i++)
            ps[i] = new P(x[i], y[i]);
        Arrays.sort(ps);
        TreeSet<P> setx = new TreeSet<P>();
        TreeSet<P> set = new TreeSet<P>(new Comparator<P>() {
            @Override
            public int compare(P o1, P o2) {
                return o1.y!=o2.y?o1.y-o2.y:o1.x-o2.y;
            }
        });
        int len = 1<<29;
        P p1 = null, p2 = null;
        setx.add(ps[0]);
        set.add(ps[0]);
        for(int i = 1; i < n; i++) {
//          System.err.println(i);
            while(!setx.isEmpty()) {
                P p = setx.pollFirst();
                if(p.x + len >= ps[i].x) {
                    setx.add(p);
                    break;
                }
                set.remove(p);
            }
            P low = new P(0, ps[i].y-len);
            P high = new P(0, ps[i].y+len+1);
            for(P p : set.subSet(low, high)) {
                final int dx = p.x-ps[i].x;
                final int dy = p.y-ps[i].y;
                final int d = dx*dx+dy*dy;
                if(d < len) {
                    len = d;
                    p1 = ps[i];
                    p2 = p;
                }
            }
            setx.add(ps[i]);
            set.add(ps[i]);
        }
        return new P[]{p1,p2};
    }
    
    public static void main(String[] args) {
        try {
            //*
            File in = new File("input.txt");
            File out = new File("output.txt");
            PrintStream writer = new PrintStream(out);
            Scanner sc = new Scanner(in);
            /*///*
            PrintStream writer = new PrintStream(System.out);
            Scanner sc = new Scanner(System.in);
            //*/
            
            final int n = sc.nextInt();
            int[] x = new int[n];
            int[] y = new int[n];
            int[] k = new int[n];
            for(int i = 0; i < n; i++) {
                x[i] = sc.nextInt();
                y[i] = sc.nextInt();
                int j = 0;
                if(x[i]<0) { j|=1; x[i] = Math.abs(x[i]); }
                if(y[i]<0) { j|=2; y[i] = Math.abs(y[i]); }
                k[i] = j+1;
            }
            P[] p = ClosestPair(x, y);
            int[] id = new int[]{-1,-1};
            for(int i = 0; i < n; i++) {
                if(id[0]==-1&&p[0].equals(new P(x[i], y[i]))) id[0] = i;
                else if(id[1]==-1&&p[1].equals(new P(x[i], y[i]))) id[1] = i;
            }
//          writer.printf("%d %d %d %d\n", p[0].x, p[0].y, p[1].x, p[1].y);
            writer.printf("%d %d %d %d\n", id[0]+1, k[id[0]], id[1]+1, 5-k[id[1]]);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            
        }
    }
}