#include <bits/stdc++.h>
void task_a() {
  int t = 0;
  std::cin >> t;
  for (int test = 0; test < t; ++test) {
    int num = 0;
    std::cin >> num;
    int high = 0;
    while ((1 << high) <= num) {
      high += 1;
    }
    int64_t bin_sum = (static_cast<int64_t>(1) << (high + 1)) - 2;
    int64_t result = (int64_t)num * (num + 1) / 2 - bin_sum;
    std::cout << result << std::endl;
  }
}
void task_b() {
  std::string s;
  std::cin >> s;
  std::string aux = s;
  int queries = 0;
  std::cin >> queries;
  for (int query = 0; query < queries; ++query) {
    int left = 0, right = 0, shift = 0;
    std::cin >> left >> right >> shift;
    left -= 1;
    right -= 1;
    for (int it = left; it <= right; ++it) {
      aux[left + (it - left + shift) % (right - left + 1)] = s[it];
    }
    s = aux;
  }
  std::cout << s << std::endl;
}
struct OrientedSegment {
  OrientedSegment(int _x = 1, int _y = 1, int _id = 0)
      : x(_x), y(_y), id(_id), phi(atan2(_y, _x)) {}
  bool operator<(const OrientedSegment &other) const { return phi < other.phi; }
  int x, y, id;
  long double phi;
};
void task_c() {
  int n = 0;
  std::cin >> n;
  std::vector<OrientedSegment> segments;
  segments.reserve(n);
  for (int i = 0; i < n; ++i) {
    int x = 0, y = 0;
    std::cin >> x >> y;
    segments.push_back(OrientedSegment(x, y, i + 1));
  }
  std::sort(segments.begin(), segments.end());
  int ans1 = -1, ans2 = -1;
  long double min = std::numeric_limits<long double>::max();
  for (int i = 0; i < n - 1; ++i) {
    if (segments[(i + 1) % n].phi - segments[i].phi < min) {
      min = segments[(i + 1) % n].phi - segments[i].phi;
      ans1 = segments[i].id;
      ans2 = segments[(i + 1) % n].id;
    }
  }
  if (segments[0].phi + 2 * 3.14159265358979323846 - segments[n - 1].phi <
      min) {
    min = segments[0].phi + 2 * 3.14159265358979323846 - segments[n - 1].phi;
    ans1 = segments[n - 1].id;
    ans2 = segments[0].id;
  }
  std::cout << ans1 << " " << ans2 << std::endl;
}
struct Cell {
  Cell(int _x, int _y) : x(_x), y(_y) {}
  int x, y;
};
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
bool is_in_field(int i, int j, int n, int m) {
  return 0 <= i && i < n && 0 <= j && j < m;
}
void bfs(int i, int j, int n, int m, std::vector<std::vector<int>> &result,
         std::vector<std::vector<bool>> &used,
         const std::vector<std::vector<char>> &field) {
  std::queue<Cell> queue;
  used[i][j] = true;
  queue.push(Cell(i, j));
  std::vector<Cell> path;
  path.push_back(Cell(i, j));
  int ans = 0;
  while (!queue.empty()) {
    Cell current = queue.front();
    queue.pop();
    for (int dir = 0; dir < 4; ++dir) {
      if (!is_in_field(current.x + dx[dir], current.y + dy[dir], n, m)) {
        continue;
      }
      if (field[current.x + dx[dir]][current.y + dy[dir]] == '*') {
        ans += 1;
      } else if (!used[current.x + dx[dir]][current.y + dy[dir]]) {
        used[current.x + dx[dir]][current.y + dy[dir]] = true;
        queue.push(Cell(current.x + dx[dir], current.y + dy[dir]));
        path.push_back(Cell(current.x + dx[dir], current.y + dy[dir]));
      }
    }
  }
  for (const auto &step : path) {
    result[step.x][step.y] = ans;
  }
}
std::vector<std::vector<int>> run_bfs(
    int n, int m, const std::vector<std::vector<char>> &field) {
  std::vector<std::vector<int>> result(n, std::vector<int>(m));
  std::vector<std::vector<bool>> used(n, std::vector<bool>(m, false));
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < m; ++j) {
      if (!used[i][j] && field[i][j] != '*') {
        bfs(i, j, n, m, result, used, field);
      }
    }
  }
  return result;
}
void task_d() {
  int n = 0, m = 0, k = 0;
  std::cin >> n >> m >> k;
  std::vector<std::vector<char>> field(n, std::vector<char>(m));
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < m; ++j) {
      std::cin >> field[i][j];
    }
  }
  std::vector<std::vector<int>> ans = run_bfs(n, m, field);
  for (int query = 0; query < k; ++query) {
    int x = 0, y = 0;
    std::cin >> x >> y;
    x -= 1;
    y -= 1;
    std::cout << ans[x][y] << std::endl;
  }
}
int main() {
  task_c();
  return 0;
}
