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:
//package saratovSchool2011;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Comparator;
import java.util.StringTokenizer;

public class J {

	static BufferedReader bf = new BufferedReader(new InputStreamReader(
			System.in));
	static StringTokenizer st;
	static PrintWriter out = new PrintWriter(System.out);

	static String nextToken() throws IOException {
		while (st == null || !st.hasMoreTokens()) {
			String s = bf.readLine();
			if (s == null)
				return null;
			st = new StringTokenizer(s);
		}

		return st.nextToken();
	}

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

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

	static String nextStr() throws IOException {
		return nextToken();
	}

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

	public static void main(String[] args) throws IOException {
		bf = new BufferedReader(new FileReader("input.txt"));
		out = new PrintWriter("output.txt");

		int n = nextInt();
		p = new Point[n * 4];
		tmp = new Point[n * 4];
		for (int i = 0; i < n; i++) {
			int x = nextInt();
			int y = nextInt();
			
			p[i * 4] = new Point(x, y, 1, i + 1);
			p[i * 4 + 1] = new Point(-x, y, 2, i + 1);
			p[i * 4 + 2] = new Point(x, -y, 3, i + 1);
			p[i * 4 + 3] = new Point(-x, -y, 4, i + 1);
		}
		
		Arrays.sort(p, 0, n * 4 - 1, new Comparator<Point>() {
			public int compare(Point o1, Point o2) {
				if (o1.x < o2.x || o1.x == o2.x && o1.y < o2.y) {
					return -1;
				}
				if (o2.x < o1.x || o2.x == o1.x && o2.y < o1.y) {
					return 1;
				}
				return 0;
			}
		});
		
		f(0, n * 4 - 1);
		
		B.k = 5 - B.k;
		out.println(A.ind + " " + A.k + " " + B.ind + " " + B.k);
		out.close();
	}
	
	static Point p[];
	static int min = Integer.MAX_VALUE;
	static Point A, B;
	static Point[] tmp;
	
	static int sqr(int a) {
		return a * a;
	}
	
	static int dist(Point i, Point j) {
		return sqr(i.x - j.x) + sqr(i.y - j.y);
	}

	static void f(int l, int r) {
		if (r - l <= 3) {
			for (int i = l; i < r; i++) {
				for (int j = i + 1; j <= r; j++) {
					int d = dist(p[i], p[j]);
					if (d < min && p[i].ind != p[j].ind) {
						min = d;
						A = p[i];
						B = p[j];
					}
				}
			}
			
			Arrays.sort(p, l, r + 1, new Comparator<Point>() {
				public int compare(Point o1, Point o2) {
					if (o1.y < o2.y) {
						return -1;
					}
					if (o2.y < o1.y) {
						return 1;
					}
					return 0;
				}
			});
			
			return;
		}
		
		int mid = (l + r) / 2;
		int x = p[mid].x;
		f(l, mid);
		f(mid + 1, r);
		
		int p1 = l;
		int p2 = mid + 1;
		
		int k = 0;
		while (p1 != mid + 1 || p2 != r + 1) {
			if (p1 == mid + 1) {
				tmp[k++] = p[p2++];
			} else if (p2 == r + 1) {
				tmp[k++] = p[p1++];
			} else if (p[p1].y < p[p2].y) {
				tmp[k++] = p[p1++];
			} else {
				tmp[k++] = p[p2++];
			}
		}
		
		for (int i = 0; i < k; i++) {
			p[i + l] = tmp[i];
		}
		
		k = 0;
//		System.err.println(l + " " + r);
		for (int i = l; i <= r; i++) {
			if (Math.abs(p[i].x - x) < min) {
				for (int j = k - 1; j >= 0 && p[i].y - tmp[j].y < min; j--) {
					int d = dist(p[i], tmp[j]);
					if (d < min && p[i].ind != tmp[j].ind) {
						min = d;
						A = p[i];
						B = tmp[j];
					}
				}
				
				tmp[k++] = p[i];
			}
		}
	}
}

class Point {
	int x, y, k;
	int ind;
	
	Point(int X, int Y, int K, int Ind) {
		x = X;
		y = Y;
		k = K;
		ind = Ind;
	}
}