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.util.*;
import java.io.*;

public class J {
    static double inf = 1e18;
    static point first;
    static point second;
    static double min = inf;

    public static point[] getStrip(double x, double dis, point[] B) {
        int s = 0;
        for (int i = 0; i < B.length; i++)
            if (Math.abs(B[i].x - x) <= dis)
                s++;
        point[] S = new point[s];
        s = 0;
        for (int i = 0; i < B.length; i++)
            if (Math.abs(B[i].x - x) <= dis)
                S[s++] = B[i];
        return S;
    }

    public static void partition(int mid, point[] B, point[] leftB,
            point[] rightB) {
        int left = 0;
        int right = 0;
        for (int i = 0; i < B.length; i++) {
            if (B[i].index <= mid)
                leftB[left++] = B[i];
            else
                rightB[right++] = B[i];
        }
    }

    public static double get(int start, int end, point[] A, point[] B) {
        if (start == end)
            return inf;
        int mid = (start + end) / 2;
        point[] leftB = new point[mid - start + 1];
        point[] rightB = new point[end - mid];
        partition(mid, B, leftB, rightB);
        double dis1 = get(start, mid, A, leftB);
        double dis2 = get(mid + 1, end, A, rightB);
        double dis = Math.min(dis1, dis2);
        double x = (A[mid].x + A[mid + 1].x) / 2;
        point[] S = getStrip(x, dis, B);
        for (int i = 0; i < S.length; i++) {
            for (int j = i + 1; j < S.length; j++) {
                if (S[j].y - S[i].y > dis || S[j].inputIndex == S[i].inputIndex)
                    break;
                double dx = Math.abs(S[i].x - S[j].x);
                double dy = Math.abs(S[i].y - S[j].y);
                double temp = Math.sqrt(dx * dx + dy * dy);
                if (temp < dis) {
                    dis = temp;
                    if (temp < min) {
                        first = S[i];
                        second = S[j];
                        min = temp;
                    }
                }
            }
        }
        return dis;
    }

    public static void main(String[] args) throws IOException {
        Scanner in = new Scanner(new FileReader("input.txt"));
        PrintWriter out = new PrintWriter(new FileWriter("output.txt"));
        int n = in.nextInt();
        point[] A = new point[4 * n];
        point[] B = new point[4 * n];
        for (int i = 0; i < n; i++) {
            int x = in.nextInt();
            int y = in.nextInt();
            A[4 * i] = B[4 * i] = new point(x, y, -1, i, 1);
            A[4 * i + 1] = B[4 * i + 1] = new point(-x, y, -1, i, 2);
            A[4 * i + 2] = B[4 * i + 2] = new point(x, -y, -1, i, 3);
            A[4 * i + 3] = B[4 * i + 3] = new point(-x, -y, -1, i, 4);
        }
        Arrays.sort(A, new Comparator<point>() {
            public int compare(point o1, point o2) {
                if (o1.x != o2.x)
                    return o1.x - o2.x;
                return o1.y - o2.y;
            }
        });
        for (int i = 0; i < 4 * n; i++)
            A[i].index = i;
        Arrays.sort(B, new Comparator<point>() {
            public int compare(point o1, point o2) {
                if (o1.y != o2.y)
                    return o1.y - o2.y;
                return o1.x - o2.x;
            }
        });
        get(0, 4 * n - 1, A, B);
        out.print(first.inputIndex + 1 + " " + first.transform + " ");
        out.println(second.inputIndex + 1 + " " + (5 - second.transform));
        out.flush();
    }
}

class point {
    int x;
    int y;
    int index;
    int inputIndex;
    int transform;

    public point(int i, int j, int k, int l, int t) {
        x = i;
        y = j;
        index = k;
        inputIndex = l;
        transform = t;
    }
}