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.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.Arrays;
import java.util.Comparator;


public class J {
    
    static StreamTokenizer in;
    static PrintWriter out;
    static Point[] a;
    static int[] x, y;
    static int n;
    static int id1, id2, min = Integer.MAX_VALUE;
    static Comp tmp = new Comp();
    public static void main(String[] args) throws IOException {
        in = new StreamTokenizer(new FileReader("input.txt"));
        out = new PrintWriter("output.txt");    
        n = nextInt();
        x = new int [n];
        y = new int [n];
        a = new Point [n];
        for (int i = 0; i < n; ++i) {
            x[i] = nextInt();
            y[i] = nextInt();
            a[i] = new Point(Math.abs(x[i]), Math.abs(y[i]), i);
        }
        t = new Point [n];
        Arrays.sort(a, 0, n, new Compar());
        find(0, n);
        print(id1, id2);
    }
    private static void print(int i, int j) {
        int k1 = 1, k2 = 1;
        if (x[i] < 0 && y[i] < 0) k1 = 4;
        if (x[i] >= 0 && y[i] < 0) k1 = 3;
        if (x[i] < 0 && y[i] >= 0) k1 = 2;
        if (x[j] > 0 && y[j] > 0) k2 = 4;
        if (x[j] <= 0 && y[j] > 0) k2 = 3;
        if (x[j] > 0 && y[j] <= 0) k2 = 2;
        out.println((i + 1) + " " + k1 + " " + (j + 1) + " " + k2);
        out.close();
    }
    static Point[] t;
    private static void find(int l, int r) {
        if (r - l <= 3) {
            for (int i = l; i < r - 1; ++i)
                for (int j = i + 1; j < r; ++j)
                    check(a[i], a[j]);
            return;
        }
        int m = (l + r) >> 1;
        int midx = a[m].x;
        find(l, m); find(m + 1, r);
        Arrays.sort(a, l, r, tmp);
        int ts = 0;
        for (int i = l; i < r; ++i) {
            if ((a[i].x - midx) * (a[i].x - midx) < min) {
                for (int j = ts - 1; j >= 0 && (a[i].y - t[j].y) * (a[i].y - t[j].y) < min; --j) {
                    check(a[i], t[j]);
                }
                t[ts++] = a[i];
            }
        }
    }

    private static void check(Point a, Point b) {
        int dist = (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
        if (dist < min) {
            min = dist;
            id1 = a.id;
            id2 = b.id;
        }
    }

    private static int nextInt() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }
    static class Point {

        int x, y;
        int id;
        
        public Point(int x, int y, int id) {
            this.x = x;
            this.y = y;
            this.id = id;
        }
        
        //@Override
        //public int compareTo(Point a) {
        //  return (x == a.x) ? y - a.y : x - a.x;
        //}
    }
    
    static class Compar implements Comparator<Point> {

        @Override
        public int compare(Point a, Point b) {
            return (a.x == b.x) ? (a.y - b.y) : (a.x - b.x);
        }       
    }
    
    static class Comp implements Comparator<Point> {

        @Override
        public int compare(Point a, Point b) {
            return a.y - b.y;
        }
        
    }
}