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.*;

public class Main{
	static int[][]points;
	static int ans,best[];
	static int dist(int i,int j) {
		return (points[i][0]-points[j][0])*(points[i][0]-points[j][0])+(points[i][1]-points[j][1])*(points[i][1]-points[j][1]);
	}
	static void update(int i,int j) {
		int cur=dist(i, j);
		if(cur<ans) {
			ans=cur;
			best=new int[] {points[i][2],points[j][2]};
		}
	}
	static int square(int x) {
		return x*x;
	}
	static int[][] solve(int l,int r){
		int[][]res=new int[r-l+1][];
		if(r-l+1<4) {
			for(int c=0,o=l;o<=r;c++,o++) {
				res[c]=new int[] {points[o][0],points[o][1],o};
				for(int j=o-1;j>=l;j--) {
					update(o,j);	
				}
			}
			Arrays.sort(res,(x,y)->x[1]-y[1]);
			return res;
		}
		int mid=(l+r)>>1;
		int midx=points[mid][0];
		int[][]left=solve(l, mid),right=solve(mid+1, r);
		int i=0,j=0;
		for(int c=0;c<res.length;c++) {
			if(j==right.length || (i<left.length && left[i][1]<=right[j][1])) {
				res[c]=new int[] {left[i][0],left[i][1],left[i][2]};
				i++;
			}
			else {
				res[c]=new int[] {right[j][0],right[j][1],right[j][2]};
				j++;
			}
		}
		ArrayList<Integer>B=new ArrayList<Integer>();
		for(int idx=0;idx<res.length;idx++) {
			if(square(Math.abs(midx-res[idx][0]))>=ans)continue;
			for(int p1=B.size()-1;p1>=0;p1--) {
				if(square(Math.abs(points[B.get(p1)][1]-points[res[idx][2]][1]))>=ans)break;
				update(res[idx][2],B.get(p1));
			}
			B.add(res[idx][2]);
		}
		
		return res;
	}
	static void positive(boolean[]sign) {
		if(sign[0] && sign[1]) {
			pw.print(1+" ");
			return;
		}
		if(!sign[0] && sign[1]) {
			pw.print(2+" ");
			return;
		}
		if(sign[0] && !sign[1]) {
			pw.print(3+" ");
			return;
		}
		pw.print(4+" ");
	}
	static void main() throws Exception{
		int n=sc.nextInt();
		ans=(int)1e9;
		points=new int[n][3];
		boolean[][]sign=new boolean[n][2];
		for(int i=0;i<n;i++) {
			for(int j=0;j<2;j++) {
				int x=sc.nextInt();
				points[i][j]=Math.abs(x);
				sign[i][j]=x>=0;
			}
			points[i][2]=i;
		}
		Arrays.sort(points,(x,y)->x[0]==y[0]?x[1]-y[1]:x[0]-y[0]);
		solve(0, n-1);
		int i=best[0],j=best[1];
		pw.print((i+1)+" ");
		//make i positive
		positive(sign[i]);
		pw.print((j+1)+" ");
		//make j negative
		positive(new boolean[] {!sign[j][0],!sign[j][1]});
		
	}
	public static void main(String[] args) throws Exception {
		sc = new MScanner("input.txt");
		pw = new PrintWriter("output.txt");
		int tc = 1;
//		tc=sc.nextInt();
		while (tc-->0)
			main();
		pw.flush();
	}

	static PrintWriter pw;
	static MScanner sc;

	static class MScanner {
		StringTokenizer st;
		BufferedReader br;

		public MScanner(InputStream system) {
			br = new BufferedReader(new InputStreamReader(system));
		}

		public MScanner(String file) throws Exception {
			br = new BufferedReader(new FileReader(file));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int[] intArr(int n) throws IOException {
			int[] in = new int[n];
			for (int i = 0; i < n; i++)
				in[i] = nextInt();
			return in;
		}

		public long[] longArr(int n) throws IOException {
			long[] in = new long[n];
			for (int i = 0; i < n; i++)
				in[i] = nextLong();
			return in;
		}

		public int[] intSortedArr(int n) throws IOException {
			int[] in = new int[n];
			for (int i = 0; i < n; i++)
				in[i] = nextInt();
			shuffle(in);
			Arrays.sort(in);
			return in;
		}

		public long[] longSortedArr(int n) throws IOException {
			long[] in = new long[n];
			for (int i = 0; i < n; i++)
				in[i] = nextLong();
			shuffle(in);
			Arrays.sort(in);
			return in;
		}

		public Integer[] IntegerArr(int n) throws IOException {
			Integer[] in = new Integer[n];
			for (int i = 0; i < n; i++)
				in[i] = nextInt();
			return in;
		}

		public Long[] LongArr(int n) throws IOException {
			Long[] in = new Long[n];
			for (int i = 0; i < n; i++)
				in[i] = nextLong();
			return in;
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

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

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

		public char nextChar() throws IOException {
			return next().charAt(0);
		}

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

		public boolean ready() throws IOException {
			return br.ready();
		}

		public void waitForInput() throws InterruptedException {
			Thread.sleep(3000);
		}
	}

	static void shuffle(int[] in) {
		for (int i = 0; i < in.length; i++) {
			int idx = (int) (Math.random() * (i + 1));
			int tmp = in[i];
			in[i] = in[idx];
			in[idx] = tmp;
		}
	}

	static void shuffle(long[] in) {
		for (int i = 0; i < in.length; i++) {
			int idx = (int) (Math.random() * (i + 1));
			long tmp = in[i];
			in[i] = in[idx];
			in[idx] = tmp;
		}
	}
}