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.Scanner;
import java.io.IOException;
import java.util.Arrays;
import java.awt.geom.Point2D;
import java.util.SortedSet;
import java.util.Set;
import java.util.Comparator;
import java.io.OutputStream;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.io.FileInputStream;
import java.util.TreeSet;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author "Johan Sannemo"
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream;
        try {
            inputStream = new FileInputStream("input.txt");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        OutputStream outputStream;
        try {
            outputStream = new FileOutputStream("output.txt");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskJ solver = new TaskJ();
        solver.solve(1, in, out);
        out.close();
    }
}

class TaskJ {

    static class Point extends java.awt.Point.Double {

        int ox, oy, name;
        public Point(int xx, int yy, int name){
            super(Math.abs(xx), Math.abs(yy));
            ox = xx;
            oy = yy;
            this.name = name+1;
        }

        public Point(double x, double y){
            super(x, y);
        }
    }

    Point[] pnts;

    public void solve(int testNumber, Scanner in, PrintWriter out) {
        int n = in.nextInt();
        pnts = new Point[n];
        for (int i = 0; i < n; i++) {
            int x = in.nextInt(), y = in.nextInt();
            pnts[i] = new Point(x, y, i);
        }
        Point[] closest = closestPair(pnts);
        Point f = closest[0];
        Point s = closest[1];
        int fch = -1;
        int sch = -1;
        boolean x1 = false, y1 = false, x2 = false, y2 = false;
        if (Math.abs(f.ox) >= Math.abs(s.ox)) {
            if (f.ox < 0) x1 = true;
            if (s.ox > 0) x2 = true;
        } else {
            if (f.ox > 0) x1 = true;
            if (s.ox < 0) x2 = true;
        }
        if (Math.abs(f.oy) >= Math.abs(s.oy)) {
            if (f.oy < 0) y1 = true;
            if (s.oy > 0) y2 = true;
        } else {
            if (f.oy > 0) y1 = true;
            if (s.oy < 0) y2 = true;
        }
        out.print(f.name + " ");
        if (x1 && y1) out.print(4);
        if (x1 && !y1) out.print(2);
        if (!x1 && y1) out.print(3);
        if (!x1 && !y1) out.print(1);
        out.print(" " + s.name + " ");
        if (x2 && y2) out.println(4);
        if (x2 && !y2) out.println(2);
        if (!x2 && y2) out.println(3);
        if (!x2 && !y2) out.println(1);

    }

    public static Point[] closestPair(Point[] points) {
        Point[] closestPair = new Point[2];

        //When we start the min distance is the infinity
        double crtMinDist = Double.POSITIVE_INFINITY;

        //Get the points and sort them
        Point[] sorted = Arrays.copyOf(points, points.length);
        Arrays.sort(sorted, HORIZONTAL_COMPARATOR);

        //When we start the left most candidate is the first one
        int leftMostCandidateIndex = 0;

        //Vertically sorted set of candidates
        SortedSet<Point> candidates = new TreeSet<Point>(VERTICAL_COMPARATOR);

        //For each point from left to right
        for (Point current : sorted) {
            //Shrink the candidates
            while (leftMostCandidateIndex < sorted.length && current.x - sorted[leftMostCandidateIndex].x < crtMinDist){
                candidates.remove(sorted[leftMostCandidateIndex]);
                leftMostCandidateIndex++;
            }

            //Compute the y head and the y tail of the candidates set
            Point head = new Point(current.x, (int) (current.y - crtMinDist));
            Point tail = new Point(current.x, (int) (current.y + crtMinDist));

            //We take only the interesting candidates in the y axis
            for (Point point : candidates.subSet(head, tail)) {
                double distance = current.distance(point);

                //Simple min computation
                if (distance < crtMinDist) {
                    crtMinDist = distance;

                    closestPair[0] = current;
                    closestPair[1] = point;
                }
            }

            //The current point is now a candidate
            candidates.add(current);
        }

        return closestPair;
    }

    private static final Comparator<Point> VERTICAL_COMPARATOR = new Comparator<Point>() {
        public int compare(Point a, Point b) {
            if (a.y < b.y) {
                return -1;
            }
            if (a.y > b.y) {
                return 1;
            }
            if (a.x < b.x) {
                return -1;
            }
            if (a.x > b.x) {
                return 1;
            }
            return 0;
        }
    };

    private static final Comparator<Point> HORIZONTAL_COMPARATOR = new Comparator<Point>() {
        public int compare(Point a, Point b) {
            if (a.x < b.x) {
                return -1;
            }
            if (a.x > b.x) {
                return 1;
            }
            if (a.y < b.y) {
                return -1;
            }
            if (a.y > b.y) {
                return 1;
            }
            return 0;
        }
    };
}