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 *v*<sub class="lower-index">*i*</sub> = (*x*<sub class="lower-index">*i*</sub>, *y*<sub class="lower-index">*i*</sub>) can be transformed into one of the following four vectors:
 -  *v*<sub class="lower-index">*i*</sub><sup class="upper-index">1</sup> = (*x*<sub class="lower-index">*i*</sub>, *y*<sub class="lower-index">*i*</sub>), -  *v*<sub class="lower-index">*i*</sub><sup class="upper-index">2</sup> = ( - *x*<sub class="lower-index">*i*</sub>, *y*<sub class="lower-index">*i*</sub>), -  *v*<sub class="lower-index">*i*</sub><sup class="upper-index">3</sup> = (*x*<sub class="lower-index">*i*</sub>,  - *y*<sub class="lower-index">*i*</sub>), -  *v*<sub class="lower-index">*i*</sub><sup class="upper-index">4</sup> = ( - *x*<sub class="lower-index">*i*</sub>,  - *y*<sub class="lower-index">*i*</sub>). 
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 *v*<sub class="lower-index">*i*</sub>, *v*<sub class="lower-index">*j*</sub> (1 ≤ *i*, *j* ≤ *n*, *i* ≠ *j*) and two numbers *k*<sub class="lower-index">1</sub>, *k*<sub class="lower-index">2</sub> (1 ≤ *k*<sub class="lower-index">1</sub>, *k*<sub class="lower-index">2</sub> ≤ 4), so that the value of the expression |*v*<sub class="lower-index">*i*</sub><sup class="upper-index">*k*<sub class="lower-index">1</sub></sup> + *v*<sub class="lower-index">*j*</sub><sup class="upper-index">*k*<sub class="lower-index">2</sub></sup>| were minimum.
The first line contains a single integer *n* (2 ≤ *n* ≤ 10<sup class="upper-index">5</sup>). Then *n* lines contain vectors as pairs of integers "*x*<sub class="lower-index">*i*</sub> *y*<sub class="lower-index">*i*</sub>" ( - 10000 ≤ *x*<sub class="lower-index">*i*</sub>, *y*<sub class="lower-index">*i*</sub> ≤ 10000), one pair per line.
5
-7 -3
9 0
-8 6
7 -8
4 -5
3 2 4 2
5
3 2
-4 7
-6 0
-8 4
5 1
3 4 5 4
2
-4 -2
-2 1
1 4 2 3
3
-4 -3
-4 -5
-1 0
2 4 1 1
10
53 86
-48 72
-74 48
75 -91
-31 14
13 67
24 -55
-76 -67
86 5
-84 94
10 2 4 2
10
-65 29
77 29
74 -54
-79 -65
43 46
-12 -92
9 88
28 6
-63 49
-37 17
6 4 7 4
10
-58 72
76 -39
-28 19
93 10
-84 -97
88 99
69 30
-43 53
65 67
-15 -60
6 1 5 1
10
75 15
0 69
-6 -83
-86 61
91 87
87 -60
3 -78
61 -75
17 60
-67 14
6 3 4 3
class Point(object):
	"""docstring for Point"""
	def __init__(self, x, y, id):
		self.id = id
		self.X = x
		self.Y = y
		self.x = abs(x)
		self.y = abs(y)

	def __repr__(self):
		return f"{self.id}-({self.x}, {self.y})"


def dist(a: Point, b: Point):
	return ((a.x-b.x)**2+(a.y-b.y)**2)**0.5


def calc_min_dist(points):
	ans = [float('INF'), -1, -1]
	for i in range(len(points)):
		for j in range(i+1, len(points)):
			if ans[0] > dist(points[i], points[j]):
				ans = (dist(points[i], points[j]), points[i].id, points[j].id)
	return ans


def solve(points):
	points.sort(key=lambda p: p.x)
	def merge(points, l, r):
		m = (l+r)//2
		tmp = []
		i = l
		j = m
		while i < m or j < r:
			if j == r or (i < m and points[i].y < points[j].y):
				tmp.append(points[i])
				i += 1
			else:
				tmp.append(points[j])
				j += 1
		points[l:r] = tmp


	def calc_rec(points, l, r):
		if r-l<=3:
			ans = calc_min_dist(points[l:r])
			points[l:r] = sorted(points[l:r], key=lambda p: p.y)
			return ans
		else:
			m = (l+r)//2
			middle_x = points[m].x
			ans = min(calc_rec(points, l, m), calc_rec(points, m, r))
			merge(points, l, r)
			min_d = ans[0]

			close_points = list(filter(lambda p: abs(p.x-middle_x)< min_d, points))
			for i in range(len(close_points)):
				for j in range(i-1, 0, -1):
					p1 = close_points[i]
					p2 = close_points[j]
					if p1.y-p2.y > min_d:
						break
					ans = min(ans, (dist(p1, p2), p1.id, p2.id))
			return ans
	ans = calc_rec(points, 0, len(points))

	def transform(s, v, u):
		k1 = 1
		k2 = 1
		v = points[v]
		u = points[u]
		if v.X < 0:
			k1 += 1
		if v.Y < 0:
			k1 += 2
		if u.X < 0:
			k2 += 1
		if u.Y < 0:
			k2 += 2
		return [k1, k2]

	return [ans, transform(*ans)]



if __name__ == '__main__':
	n = int(input())
	points = list(Point(*list(map(int, input().split())), i) for i in range(n))
	ans = solve(points)
	print(ans[0][1]+1, ans[1][0], ans[0][2]+1, ans[1][1])