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.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Locale;
import java.util.SortedSet;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class Main implements Runnable {

	public static class CompX implements Comparator<Point> {

		public int compare(Point p1, Point p2) {
			if (p1.x < p2.x)
				return -1;
			if (p1.x > p2.x)
				return 1;
			if (p1.y < p2.y)
				return -1;
			if (p1.y > p2.y)
				return 1;
			return 0;
		}

	}

	public static class CompY implements Comparator<Point> {

		public int compare(Point p1, Point p2) {
			if (p1.y < p2.y)
				return -1;
			if (p1.y > p2.y)
				return 1;
			if (p1.x < p2.x)
				return -1;
			if (p1.x > p2.x)
				return 1;
			return 0;
		}

	}

	public static class Point {
		int x;
		int y;
		int id;
		int sx;
		int sy;

		public int dist2(Point p) {
			return (p.x - x) * (p.x - x) + (p.y - y) * (p.y - y);
		}

		public Point(int x, int y, int id) {
			super();
			this.x = x;
			this.y = y;
			this.id = id;
			this.sx = x < 0 ? -1 : 1;
			this.sy = y < 0 ? -1 : 1;
		}
		
		public void fix() {
			x*=sx;
			y*=sy;
		}

	}

	private static final int INF = 1000000000;

	void solve() throws IOException {
		int n = nextInt();
		CompX cmpx = new CompX();
		CompY cmpy = new CompY();

		Point[] Sx = new Point[n];

		for (int i = 0; i < n; i++) {
			int xi = nextInt();
			int yi = nextInt();
			Sx[i] = new Point(xi, yi, i + 1);
			Sx[i].fix();
		}

		Point a = null;
		Point b = null;
		SortedSet<Point> Sy = new TreeSet<Point>(cmpy);
		Arrays.sort(Sx, cmpx);
		int tail = 0;
		int h = INF;
		for (int i = 0; i < n; i++) {
			while (Sx[i].x - Sx[tail].x > h) {
				Sy.remove(Sx[tail]);
				tail++;
			}
			SortedSet<Point> range = Sy.subSet(new Point(-INF, Sx[i].y - h, 0),
					new Point(INF, Sx[i].y + h, 0));
			for (Point p : range) {
				if (p.dist2(Sx[i]) < h) {
					h = p.dist2(Sx[i]);
					a = p;
					b = Sx[i];
				}
			}
			Sy.add(Sx[i]);
		}

		assert a!=null : "A = null!";
		assert b!=null : "B = null!";

		a.fix();
		b.fix();
		int k1 = -1;
		int k2 = -1;
		h = INF;
		int[] sx = { 0, 1, -1, 1, -1 };
		int[] sy = { 0, 1, 1, -1, -1 };
		
		for (int i = 1; i <= 4; i++) {
			for (int j = 1; j <= 4; j++) {
				Point p1 = new Point(a.x * sx[i], a.y * sy[i], 0);
				Point p2 = new Point(b.x * sx[j], b.y * sy[j], 0);
				if ( (p1.x+p2.x)*(p1.x+p2.x) + (p1.y+p2.y)*(p1.y+p2.y) < h ) {
					k1 = i;
					k2 = j;
					h = (p1.x+p2.x)*(p1.x+p2.x) + (p1.y+p2.y)*(p1.y+p2.y);
				}
			}
		}

		out.println(a.id + " " + k1 + " " + b.id + " " + k2);
	}

	private BufferedReader in;
	private PrintWriter out;
	private StringTokenizer st;

	private void eat(String s) {
		st = new StringTokenizer(s);
	}

	String next() throws IOException {
		while (!st.hasMoreTokens()) {
			String line = in.readLine();
			if (line == null) {
				return null;
			}
			eat(line);
		}
		return st.nextToken();
	}

	int nextInt() throws IOException {
		return Integer.parseInt(next());
	}

	long nextLong() throws IOException {
		return Long.parseLong(next());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}

	public static void main(String[] args) throws IOException {
		new Thread(null, new Main(), "Main", 1 << 23).start();
	}

	public void run() {
		try {
			Locale.setDefault(Locale.US);
//			 in = new BufferedReader(new InputStreamReader(System.in));
//			 out = new PrintWriter(System.out);
			 in = new BufferedReader(new FileReader("input.txt"));
			 out = new PrintWriter("output.txt");
			eat("");
			solve();
			in.close();
			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}