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 Main {

	BufferedReader in;
	StringTokenizer str = null;
	PrintWriter out;
	
	private String next() throws Exception{
		while (str == null || !str.hasMoreElements())
			str = new StringTokenizer(in.readLine());
		return str.nextToken();
	}
	
	private int nextInt() throws Exception{
		return Integer.parseInt(next());
	}
	
	private long nextLong() throws Exception{
		return Long.parseLong(next());
	}
	
	private double nextDouble() throws Exception{
		return Double.parseDouble(next());
	}
	
	int n;
	int min, ri, rj;
	Pt []a, t;
	int []x, y;

	public void run() throws Exception{
		in =  new BufferedReader(new FileReader("input.txt"));
		out = new PrintWriter(new File("output.txt"));
		n = nextInt();
		a = new Pt[n];
		t = new Pt[n];

		x = new int[n];
		y = new int[n];

		for(int i=0;i<n;i++){
			x[i] = nextInt();
			y[i] = nextInt();
			a[i] = new Pt(Math.abs(x[i]), Math.abs(y[i]), i);
		}

		Arrays.sort(a, 0, n, new cmpX());
		// for(int i=0;i<n;i++){
		// 	System.out.println(a[i]);
		// }
		min = Integer.MAX_VALUE;
		ri = -1;rj = -1;

		find(0, n-1);
		
		out.println((ri + 1) + " " + print(Math.abs(x[ri]), Math.abs(y[ri]), ri) + " " + (rj + 1) + " " + print(-Math.abs(x[rj]), -Math.abs(y[rj]), rj));
		out.close();
	}

	private int print(int ax, int ay, int i) {
		//System.out.println(ax + " " + ay + " " + x[i] + " " + y[i]);
		if (x[i] == ax && y[i] == ay) return 1;
		if (x[i] == -ax && y[i] == ay) return 2;
		if (x[i] == ax && y[i] == -ay) return 3;
		return 4;
	}

	private void find(int l, int r) {
		if (r - l <= 3) {
			for(int i=l;i<=r;i++){
				for(int j=i+1;j<=r;j++){
					updateAns(a[i], a[j]);
				}
			}
			return;
		}

		int mid = (l + r) >> 1;
		int x = a[mid].x;
		find(l, mid);
		find(mid+1, r);
		
		Arrays.sort(a, l, r + 1, new cmpY());
		int tsize = 0;
		for(int i=l;i<=r;i++){
			if (Math.abs(x - a[i].x) < min) {
				for(int j=tsize-1;j>=0 && a[i].y - t[j].y < min;j--) {
					updateAns(a[i], t[j]);
				}
				t[tsize++] = a[i];
			}
		}
	}

	private void updateAns(Pt a, Pt b) {
		int dis = (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
		if (min > dis) {
			min = dis;
			ri = a.id;
			rj = b.id;
		}
	}

	static class Pt {
		int x, y, id;

		public Pt(int x, int y, int id) {
			this.x = x;
			this.y = y;
			this.id = id;
		}

		public String toString() {
			return "x = " + x + " y = " + y + " id = " + id;
		}
	}

	static class cmpX implements Comparator<Pt> {
		public int compare(Pt a, Pt 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;
		}
	}

	static class cmpY implements Comparator<Pt> {
		public int compare(Pt a, Pt b) {
			if (a.y > b.y) return 1;
			if (a.y < b.y) return -1;
			return 0;
		}
	}
		
	public static void main(String[] args) throws Exception{
		new Main().run();
	}
}