Problem: You are given the set of vectors on the plane, each of them starting at the origin. Your task is to find a pair of vectors with the minimal non-oriented angle between them.

Non-oriented angle is non-negative value, minimal between clockwise and counterclockwise direction angles. Non-oriented angle is always between 0 and π. For example, opposite directions vectors have angle equals to π.

Input

First line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the number of vectors.

The i-th of the following n lines contains two integers xi and yi (|x|, |y| ≤ 10 000, x2 + y2 > 0) — the coordinates of the i-th vector. Vectors are numbered from 1 to n in order of appearing in the input. It is guaranteed that no two vectors in the input share the same direction (but they still can have opposite directions).

Output

Print two integer numbers a and b (a ≠ b) — a pair of indices of vectors with the minimal non-oriented angle. You can print the numbers in any order. If there are many possible answers, print any.

Examples

Input

4
-1 0
0 -1
1 0
1 1


Output

3 4


Input

6
-1 0
0 -1
1 0
1 1
-4 -5
-4 -6


Output

6 5

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using point_ex_t = pair<ll, ll>;
const int big_num_base = 10;
using big_num_t = vector<int>;
void print_big_num(const big_num_t &v) {
  for (auto it = v.rbegin(); it != v.rend(); ++it) {
    cout << *it;
  }
  cout << "\n";
}
void add(big_num_t &x, const big_num_t &y) {
  int rest = 0;
  int length = x.size();
  for (int i = 0; i < length - 1; ++i) {
    int main = rest + x[i] + y[i];
    x[i] = main % big_num_base;
    rest = main / big_num_base;
  }
  x[length - 1] = rest;
}
void big_num_init(big_num_t &v, ll x) {
  if (x == 0) {
    v.push_back(x);
  }
  while (x > 0) {
    v.push_back(x % 10);
    x /= 10;
  }
}
void multiply(const big_num_t &x, const big_num_t &y, big_num_t &result) {
  int length_x = x.size();
  int length_y = y.size();
  int total_length = length_x + length_y + 1;
  result.resize(total_length);
  big_num_t partial_sum(total_length);
  for (int i = 0; i < total_length; ++i) {
    partial_sum[i] = 0;
    result[i] = 0;
  }
  for (int i = 0; i < length_x; ++i) {
    int rest = 0;
    for (int j = 0; j < length_y; ++j) {
      int main = rest + x[i] * y[j];
      partial_sum[j + i] = main % big_num_base;
      rest = main / big_num_base;
    }
    partial_sum[i + length_y] = rest;
    add(result, partial_sum);
    partial_sum[i] = 0;
  }
  int i = result.size() - 1;
  while (i > 0 && result[i] == 0) {
    result.pop_back();
    --i;
  }
}
bool big_num_first_smaller(const big_num_t &x, const big_num_t &y) {
  bool result = false;
  size_t length_x = x.size();
  size_t length_y = y.size();
  if (length_x < length_y) {
    result = true;
  } else if (length_x == length_y) {
    int i = length_x - 1;
    while (i >= 0 && x[i] == y[i]) {
      --i;
    }
    result = (i >= 0) && (x[i] < y[i]);
  }
  return result;
}
enum quadrants {
  first_quadrant = 1,
  second_quadrant,
  third_quadrant,
  fourth_quadrant
};
ll v_length_square(point_ex_t x) {
  return (x.first * x.first + x.second * x.second);
}
point_ex_t cos_square_minus_one_val(point_ex_t x, point_ex_t y) {
  ll dot_product = x.first * y.first + x.second * y.second;
  ll modules_square = (v_length_square(x) * v_length_square(y));
  ll dot_product_square = dot_product * dot_product;
  point_ex_t result{dot_product_square + modules_square, modules_square};
  if (dot_product < 0) {
    result = make_pair(modules_square - dot_product_square, modules_square);
  }
  return result;
}
bool first_val_bigger(point_ex_t x, point_ex_t y) {
  big_num_t first_numerator, second_numerator, x_1, y_1, x_2, y_2;
  big_num_init(x_1, x.first);
  big_num_init(y_1, y.first);
  big_num_init(x_2, x.second);
  big_num_init(y_2, y.second);
  multiply(x_1, y_2, first_numerator);
  multiply(x_2, y_1, second_numerator);
  return big_num_first_smaller(second_numerator, first_numerator);
}
pair<point_ex_t, int> orientation(int x, int y) {
  pair<point_ex_t, int> result;
  if ((x >= 0) && (y >= 0)) {
    result = make_pair(make_pair(1, 0), first_quadrant);
  } else if (y >= 0) {
    result = make_pair(make_pair(0, 1), second_quadrant);
  } else if (x >= 0) {
    result = make_pair(make_pair(0, -1), fourth_quadrant);
  } else {
    result = make_pair(make_pair(-1, 0), third_quadrant);
  }
  return result;
}
int main() {
  ios_base::sync_with_stdio(false);
  std::cin.tie(NULL);
  int answer_x = 0;
  int answer_y = 0;
  int n;
  int x, y;
  cin >> n;
  vector<tuple<point_ex_t, int, int, point_ex_t>> coordinates(n);
  for (int i = 0; i < n; ++i) {
    cin >> x >> y;
    pair<point_ex_t, int> point_orientation = orientation(x, y);
    point_ex_t point{x, y};
    coordinates[i] =
        make_tuple(cos_square_minus_one_val(point, point_orientation.first),
                   point_orientation.second, i + 1, point);
  }
  auto comp = [](tuple<point_ex_t, int, int, point_ex_t> x,
                 tuple<point_ex_t, int, int, point_ex_t> y) {
    pair<point_ex_t, int> x_angle = make_pair(get<0>(x), get<1>(x));
    pair<point_ex_t, int> y_angle = make_pair(get<0>(y), get<1>(y));
    return (x_angle.second < y_angle.second) ||
           ((x_angle.second == y_angle.second) &&
            (x_angle.first.first * y_angle.first.second >
             x_angle.first.second * y_angle.first.first));
  };
  sort(coordinates.begin(), coordinates.end(), comp);
  point_ex_t max_val = {0, 1};
  answer_x = get<2>(coordinates[0]);
  answer_y = get<2>(coordinates[1]);
  point_ex_t current_val;
  for (int i = 0; i < n; ++i) {
    int j = (i + 1) % n;
    current_val = cos_square_minus_one_val(get<3>(coordinates[i]),
                                           get<3>(coordinates[j]));
    if (first_val_bigger(current_val, max_val)) {
      max_val = current_val;
      answer_x = get<2>(coordinates[i]);
      answer_y = get<2>(coordinates[j]);
    }
  }
  cout << answer_x << " " << answer_y << "\n";
  return 0;
}