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 implements Runnable {
	private BufferedReader in;
	private PrintWriter out;
	private StringTokenizer st;
	private Random rnd;
	
	long x_dot, y_dot;
	
	class Pair implements Comparable<Pair> {
		final int x, y;
		final int id;
		
		Pair(int x, int y, int id) {
			this.x = x;
			this.y = y;
			this.id = id;
		}
		
		public int compareTo(Pair o) {
			if(Math.abs(this.x) != Math.abs(o.x)) return Math.abs(this.x) - Math.abs(o.x);
			return Math.abs(this.y) - Math.abs(o.y);
		}
	}
	
	final int border = 100;

	int res = Integer.MAX_VALUE;
	
	int ians = -1, jans = -1, k1ans = -1, k2ans = -1;
	
	Pair[] xy;
	
	private void check(int i, int j) {
		int x = (Math.abs(xy[i].x) - Math.abs(xy[j].x));
		int y = (Math.abs(xy[i].y) - Math.abs(xy[j].y));
		
		int cur_res = x * x + y * y;
		
		if(cur_res < res) {
			res = cur_res;
			ians = xy[i].id;
			jans = xy[j].id;
			
			
			k1ans = getK(xy[i].x, xy[i].y);
			k2ans = getKrev(xy[j].x, xy[j].y);
		}
	}
	
	private int getK(long x, long y) {
		if(x >= 0 && y >= 0) return 1;
		else if(x <= 0 && y >= 0) return 2;
		else if(x >= 0 && y <= 0) return 3;
		else if(x <= 0 && y <= 0) return 4;
		else return -1;
	}
	
	private int getKrev(long x, long y) {
		if(x >= 0 && y >= 0) return 4;
		else if(x <= 0 && y >= 0) return 3;
		else if(x >= 0 && y <= 0) return 2;
		else if(x <= 0 && y <= 0) return 1;
		else return -1;
	}
	
	public void solve() throws IOException {
		int n = nextInt();
		
		xy = new Pair[n];
		
		for(int i = 0; i < n; i++) {
			int x = nextInt(), y = nextInt();
			
			xy[i] = new Pair(x, y, i + 1);
		}
		
		for(int its = 0; its < (16 * 1024); its++) {
			int u = rnd.nextInt(n), v = rnd.nextInt(n);
			if(u == v) continue;
			
			check(u, v);
		}
		
		
		Arrays.sort(xy);
		
		for(int i = 0; i < n; i++) {
			for(int j = i + 1; j < Math.min(n, i + 1000); j++) {
				int x_cur = Math.abs(xy[i].x) - Math.abs(xy[j].x);
				int x_sqrt = x_cur * x_cur;
				
				if(x_sqrt > res) break;
				
				check(i, j);
			}
		}
		
		out.println(ians + " " + k1ans + " " + jans + " " + k2ans);
	}
		
	public static void main(String[] args) {
		new Main().run();
	} 
	
	public void run() {
		try {
			in = new BufferedReader(new FileReader("input.txt"));
			out = new PrintWriter(new FileWriter("output.txt"));
			
			//in = new BufferedReader(new InputStreamReader((System.in)));
			//out = new PrintWriter(System.out);
			
			st = null;
			rnd = new Random();
			
			solve();
			
			out.close();
		} catch(IOException e) {
			e.printStackTrace();
		}
	}
	
	private String nextToken() throws IOException, NullPointerException {
		while(st == null || !st.hasMoreTokens()) {
			st = new StringTokenizer(in.readLine());
		}
		
		return st.nextToken();
	}
	
	private int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}
	
	private long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}
	
	private double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

}