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

public class Main {
	public static void main(String[] args) throws Exception {
        InputReader in = new StreamInputReader(new FileInputStream(new File("Input.txt")));
		PrintWriter out = new PrintWriter(new PrintStream("Output.txt"));
		run(in, out);
	}

	public static void run(InputReader in, PrintWriter out) {
		Solver solver = new MinimumSum();
		int testCount = 1;
		for (int i = 1; i <= testCount; i++)
			solver.solve(i, in, out);
	    Exit.exit(in, out);
	}
}

abstract class InputReader {
	private boolean finished = false;

	public abstract int read();

	public int readInt() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public String readString() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuffer res = new StringBuffer();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isSpaceChar(c));
		return res.toString();
	}

	private boolean isSpaceChar(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

    private String readLine0() {
        StringBuffer buf = new StringBuffer();
        int c = read();
        while (c != '\n' && c != -1) {
            if (c != '\r')
                buf.appendCodePoint(c);
            c = read();
        }
        return buf.toString();
    }

    public String readLine() {
        String s = readLine0();
        while (s.trim().length() == 0)
            s = readLine0();
        return s;
    }

	public void setFinished(boolean finished) {
		this.finished = finished;
	}

	public abstract void close();
}

class StreamInputReader extends InputReader {
	private InputStream stream;
	private byte[] buf = new byte[1024];
	private int curChar, numChars;

	public StreamInputReader(InputStream stream) {
		this.stream = stream;
	}

	public int read() {
		if (numChars == -1)
			throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try {
				numChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (numChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public void close() {
		try {
			stream.close();
		} catch (IOException ignored) {
		}
	}
}

class Exit {
	private Exit() {
	}

	public static void exit(InputReader in, PrintWriter out) {
		in.setFinished(true);
		in.close();
		out.close();
	}
}

interface Solver {
	public void solve(int testNumber, InputReader in, PrintWriter out);
}

class MinimumSum implements Solver {
    static class Point {
        int x, y, k, id;
        public Point(int x, int y, int k, int id) {
            this.x = x;
            this.y = y;
            this.k = k;
            this.id = id;
        }
        public long distance(Point another) {
            long dx = this.x - another.x;
            long dy = this.y - another.y;
            return dx * dx + dy * dy;
        }
    }
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int n = in.readInt();
        Point[] points = new Point[n];
        Point[] absolutePoints = new Point[n];
        for(int i = 0; i < n; ++i) {
            int x = in.readInt();
            int y = in.readInt();
            int k = ((x > 0) ? ((y > 0) ? 1 : 3) : ((y > 0) ? 2 : 4));
            points[i] = new Point(x, y, k, i);
            absolutePoints[i] = new Point(Math.abs(x), Math.abs(y), 0, i);
        }
        long minSum = Integer.MAX_VALUE;
        int id1 = 0, id2 = 0;
        Arrays.sort(absolutePoints, new Comparator<Point>() {
            public int compare(Point o1, Point o2) {
                if(o1.x < o2.x) return -1;
                if(o1.x > o2.x) return 1;
                if(o1.y < o2.y) return -1;
                if(o1.y > o2.y) return 1;
                return 0;
            }
        });
        for(int i = 0; i < n; ++i) {
            for(int j = i + 1; j < n; ++j) {
                int dx = absolutePoints[i].x - absolutePoints[j].x;
                if(dx * dx >= minSum) break;
                else if(absolutePoints[i].distance(absolutePoints[j]) < minSum) {
                    minSum = absolutePoints[i].distance(absolutePoints[j]);
                    id1 = absolutePoints[i].id;
                    id2 = absolutePoints[j].id;
                }
            }
        }
        out.println((id1 + 1) + " " + points[id1].k + " " + (id2 + 1) + " " + (5  - points[id2].k));
        //System.out.println(minSum);
    }
}