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 JAVA):

Solution:
import java.io.*;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(in, out);
        out.close();
    }
}

class Vector implements Comparable<Vector> {
    int id;
    int x;
    int y;

    public Vector(int id, int x, int y) {
        this.id = id;
        this.x = x;
        this.y = y;
    }

    private int get(int x, int y) {
        if(x > 0) {
            return (y > 0) ? 2 : (y < 0) ? 8 : 1;
        } else if(x == 0) {
            return (y > 0) ? 3 : (y < 0) ? 7 : 0;
        } else {
            return (y > 0) ? 4 : (y < 0) ? 6 : 5;
        }
    }

    @Override
    public int compareTo(Vector other) {
        int comp = get(x,y) - get(other.x, other.y);
        if(comp != 0) return comp;
        int cross = x * other.y - y * other.x;
        return -Integer.signum(cross);
    }
}



class TaskC {

    public void solve(InputReader in, OutputWriter out) {
        int n = in.nextInt();
        List<Vector> vectors = new ArrayList<>(n);
        for (int i = 0; i < n; i++) {
            vectors.add(new Vector(i,in.nextInt(), in.nextInt()));
        }
        vectors.sort(Comparator.<Vector>naturalOrder());
        Vector best1 = vectors.get(0);
        Vector best2 = vectors.get(1);
        for(int i=1;i<n;i++) {
            Vector candidate1 = vectors.get(i);
            Vector candidate2 = vectors.get((i+1) % n);
            if(isSmaller(best1, best2, candidate1, candidate2)) {
                best1 = candidate1;
                best2 = candidate2;
            }
        }
        out.printLine((best1.id+1) + " " + (best2.id + 1));
    }

    private boolean isSmaller(Vector a, Vector b, Vector c, Vector d) {
        // cos(a,b) = a o b / |a| * |b|
        long num1 = getDot(a, b) * getDot(a, b);
        long den1 = getDot(a,a) * getDot(b,b);
        long num2 = getDot(c,d) * getDot(c,d);
        long den2 = getDot(c,c) * getDot(d,d);

        int sign1 = Long.signum(getDot(a,b));
        int sign2 = Long.signum(getDot(c,d));
        if(sign1 != sign2) {
            return sign2 > sign1;
        }
        boolean result = cmp(num1, den1, num2, den2);
        return (result ? sign1 > 0 : sign1 < 0);
    }

    // return true if num2/den2  is bigger than num1/den1
    private boolean cmp(long num1, long den1, long num2, long den2) {
        if(num1/den1 != num2/den2) {
            return num2/den2 > num1/den1;
        }
        num1 %= den1;
        num2 %= den2;
        if(num2 == 0) return false;
        if(num1 == 0) return true;
        return cmp(den2, num2, den1, num1);
    }


    private long getDot(Vector vector1, Vector vector2) {
        return (long)vector1.x * vector2.x + (long)vector1.y * vector2.y;
    }


}

class InputReader {
    public BufferedReader reader;
        public StringTokenizer tokenizer;
    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }
    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }
    public boolean hasNext() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                String line = reader.readLine();
                if ( line == null ) {
                    return false;
                }
                tokenizer = new StringTokenizer(line);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return true;
    }
    public int nextInt() {
        return Integer.parseInt(next());
    }

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

    public double nextDouble() { return Double.parseDouble(next());}
}
class OutputWriter {
    private final PrintWriter writer;
    public OutputWriter(OutputStream outputStream) {
        writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }
    public OutputWriter(Writer writer) {
        this.writer = new PrintWriter(writer);
    }
    public void print(Object... objects) {
        for (int i = 0; i < objects.length; i++) {
            if ( i != 0 ) {
                writer.print(' ');
            }
            writer.print(objects[i]);
        }
    }
    public void printLine(Object... objects) {
        print(objects);
        writer.println();
    }
    public void close() {
        writer.close();
    }
}