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
#include <iostream>
#include <vector>
#include <algorithm>
#include <math.h>
#include <cmath>
#include <cstdio>
#include <string>
#include <cstring>
#include <queue>
#include <set>
#include <memory.h>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <deque>

using namespace std;

typedef long long ll;

struct Point
{
    ll x, y;
    int ind;
    int deg;
    Point(ll x = 0, ll y = 0, int ind = 0, int deg = 0):
        x(x),
        y(y),
        ind(ind),
        deg(deg) {}
};

ll dist(Point a, Point b)
{
    return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}

const int N = 500001;
const ll INF = 1e18;

Point a[N];

bool cmp(Point a, Point b)
{
    return (a.x < b.x || (a.x == b.x && a.y < b.y));
}

vector<Point> cur;

pair<pair<int, int>, ll> min1(pair<pair<int, int>, ll> ans, int x, int y)
{
    if (dist(a[x], a[y]) >= ans.second || a[x].ind == a[y].ind)
        return ans;
    return make_pair(make_pair(x, y), dist(a[x], a[y]));
}

pair<pair<int, int>, ll> divide(int l, int r)
{
    if (l + 1 >= r)
        return make_pair(make_pair(0, 0), INF);
    if (l + 2 == r)
        return make_pair(make_pair(l, l + 1), dist(a[l], a[l + 1]));
    int mid = (r + l) / 2;
    pair<pair<int, int>, ll> ans = divide(l, mid), ans1 = divide(mid, r);
    if (ans.second > ans1.second)
        ans = ans1;
    for (int i = mid; i < r; i++)
        for (int j = mid - 1; j >= l; j--)
        {
            if ((a[j].x - a[i].x) * (a[j].x - a[i].x) >= ans.second)
                break;
            ans = min1(ans, j, i);
        }
    return ans;
}

int main()
{
//    freopen("in.txt", "r", stdin);
    freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
    int n;
    cout.precision(30);
    while (cin >> n)
    {
        if (n == 0)
            break;
        for (int i = 0; i < n; i++)
        {
            cin >> a[i].x >> a[i].y;
            a[i].ind = i + 1;
            a[i].deg = 1;
            if (a[i].x < 0)
            {
                a[i].x *= -1;
                if (a[i].y < 0)
                {
                    a[i].deg = 4;
                    a[i].y *= -1;
                }
                else
                    a[i].deg = 2;
            }
            else if (a[i].y < 0)
            {
                a[i].y *= -1;
                a[i].deg = 3;
            }
            /*a[i].ind = i / 4 + 1;
            a[i].deg = 1;
            a[i + 1] = a[i + 2] = a[i + 3] = a[i];
            a[i + 1].deg = 2;
            a[i + 2].deg = 3;
            a[i + 3].deg = 4;
            a[i + 1].x *= -1;
            a[i + 2].y *= -1;
            a[i + 3].x *= -1;
            a[i + 3].y *= -1;*/
        }
        sort(a, a + n, cmp);
        auto ans = divide(0, n);
      /*  if (ans.second >= 100000000)
            cout << "INFINITY\n";
        else
            cout << sqrt(ans) << "\n";*/
        int &x = a[ans.first.first].deg;
        if (x == 1)
            x = 4;
        else if (x == 2)
            x = 3;
        else if (x == 3)
            x = 2;
        else
            x = 1;
        cout << a[ans.first.first].ind << " " << a[ans.first.first].deg << " ";
        cout << a[ans.first.second].ind << " " << a[ans.first.second].deg << "\n";
    }
    return 0;
}
