#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <cmath>

#define ABS(a) ((a)>0?(a):-(a))

using namespace std;

struct v{
	int x, y, i;
} m[100100];

int a1 = -1, a2 = -1, n;
long long l1 = 1, l2 = 1, l12 = -1;
double cosA = -1;

int cA(v A){
	int cA;
	if(A.x >= 0 && A.y >= 0) cA = 1;
	else if(A.x < 0 && A.y >= 0) cA = 2;
	else if(A.x < 0 && A.y < 0) cA = 3;
	else if(A.x >= 0 && A.y < 0) cA = 4;

	return cA;
}

int cmp(v A, v B){
	int cA, cB;
	if(A.x >= 0 && A.y >= 0) cA = 1;
	else if(A.x < 0 && A.y >= 0) cA = 2;
	else if(A.x < 0 && A.y < 0) cA = 3;
	else if(A.x >= 0 && A.y < 0) cA = 4;

	if(B.x >= 0 && B.y >= 0) cB = 1;
	else if(B.x < 0 && B.y >= 0) cB = 2;
	else if(B.x < 0 && B.y < 0) cB = 3;
	else if(B.x >= 0 && B.y < 0) cB = 4;
	if(cA != cB) return cA < cB;
	else return B.x*A.y < A.x*B.y;
}

int main(){
	cin>>n;
	for(int i = 0; i < n; i++){
		cin>>m[i].x>>m[i].y;
		m[i].i = i + 1;
	}
	sort(m, m+n, cmp);

//	for(int i = 0; i < n; i++) cout<<m[i].i<<"    "<<m[i].x<<" "<<m[i].y<<"    "<<cA(m[i])<<"\n";
//	cout<<endl;

	for(int i = 0; i < n; i++){
		//cout<<i<<" "<<cosA<<endl;
		int j = (i+1)%n;
		long long ab = m[i].x*m[j].x + m[i].y*m[j].y, a = m[i].x*m[i].x+m[i].y*m[i].y, b = m[j].x*m[j].x+m[j].y*m[j].y;

		if(l12 < 0){
			if(ab >= 0){
				l12 = ab;
				l1 = a;
				l2 = b;
				a1 = m[i].i;
				a2 = m[j].i;
			}else{
				if(ab*ab*l1*l2<l12*l12*a*b){
					l12 = ab;
					l1 = a;
					l2 = b;
					a1 = m[i].i;
					a2 = m[j].i;
				}
			}
		}else{
			if(ab >= 0){
				if(ab*ab*l1*l2>l12*l12*a*b){
					l12 = ab;
					l1 = a;
					l2 = b;
					a1 = m[i].i;
					a2 = m[j].i;
				}
			}else{
				//do nothing
			}
		}

	}
	//cout<<cosA<<endl;
	cout<<a1<<" "<<a2;
	return 0;
}


#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <cmath>

#define ABS(a) ((a)>0?(a):-(a))

using namespace std;

struct v{
	int x, y, i;
} m[100100];

int a1 = -1, a2 = -1, n;
double cosA = -1;

int cA(v A){
	int cA;
	if(A.x >= 0 && A.y >= 0) cA = 1;
	else if(A.x < 0 && A.y >= 0) cA = 2;
	else if(A.x < 0 && A.y < 0) cA = 3;
	else if(A.x >= 0 && A.y < 0) cA = 4;

	return cA;
}

int cmp(v A, v B){
	int cA, cB;
	if(A.x >= 0 && A.y >= 0) cA = 1;
	else if(A.x < 0 && A.y >= 0) cA = 2;
	else if(A.x < 0 && A.y < 0) cA = 3;
	else if(A.x >= 0 && A.y < 0) cA = 4;

	if(B.x >= 0 && B.y >= 0) cB = 1;
	else if(B.x < 0 && B.y >= 0) cB = 2;
	else if(B.x < 0 && B.y < 0) cB = 3;
	else if(B.x >= 0 && B.y < 0) cB = 4;
	if(cA != cB) return cA < cB;
	else return B.x*A.y < A.x*B.y;
}

int main(){
	cin>>n;
	for(int i = 0; i < n; i++){
		cin>>m[i].x>>m[i].y;
		m[i].i = i + 1;
	}
	sort(m, m+n, cmp);

//	for(int i = 0; i < n; i++) cout<<m[i].i<<"    "<<m[i].x<<" "<<m[i].y<<"    "<<cA(m[i])<<"\n";
//	cout<<endl;

	for(int i = 0; i < n; i++){
		//cout<<i<<" "<<cosA<<endl;
		int j = (i+1)%n;
		double ab = m[i].x*m[j].x + m[i].y*m[j].y, a = sqrt(m[i].x*m[i].x+m[i].y*m[i].y), b = sqrt(m[j].x*m[j].x+m[j].y*m[j].y);

		if(ab > cosA*a*b){
			cosA = ab/a/b;
			a1 = m[i].i;
			a2 = m[j].i;
		}
	}
	cout<<a1<<" "<<a2;
	return 0;
}


#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <cmath>

#define ABS(a) ((a)>0?(a):-(a))

using namespace std;

struct v{
	int x, y, i;
} m[100100];

int a1 = -1, a2 = -1, n;
double cosA = -1;

int cA(v A){
	int cA;
	if(A.x >= 0 && A.y >= 0) cA = 1;
	else if(A.x < 0 && A.y >= 0) cA = 2;
	else if(A.x < 0 && A.y < 0) cA = 3;
	else if(A.x >= 0 && A.y < 0) cA = 4;

	return cA;
}

int cmp(v A, v B){
	int cA, cB;
	if(A.x >= 0 && A.y >= 0) cA = 1;
	else if(A.x < 0 && A.y >= 0) cA = 2;
	else if(A.x < 0 && A.y < 0) cA = 3;
	else if(A.x >= 0 && A.y < 0) cA = 4;

	if(B.x >= 0 && B.y >= 0) cB = 1;
	else if(B.x < 0 && B.y >= 0) cB = 2;
	else if(B.x < 0 && B.y < 0) cB = 3;
	else if(B.x >= 0 && B.y < 0) cB = 4;
	if(cA != cB) return cA < cB;
	else return B.x*A.y < A.x*B.y;
}

int main(){
	cin>>n;
	for(int i = 0; i < n; i++){
		cin>>m[i].x>>m[i].y;
		m[i].i = i + 1;
	}
	sort(m, m+n, cmp);

//	for(int i = 0; i < n; i++) cout<<m[i].i<<"    "<<m[i].x<<" "<<m[i].y<<"    "<<cA(m[i])<<"\n";
//	cout<<endl;

	for(int i = 0; i < n; i++){
		//cout<<i<<" "<<cosA<<endl;
		int j = (i+1)%n;
		double ab = m[i].x*m[j].x + m[i].y*m[j].y, a = sqrt(m[i].x*m[i].x+m[i].y*m[i].y), b = sqrt(m[j].x*m[j].x+m[j].y*m[j].y);

		if(ab/a > cosA*b){
			cosA = ab/a/b;
			a1 = m[i].i;
			a2 = m[j].i;
		}
	}
	cout<<a1<<" "<<a2;
	return 0;
}


#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <cmath>

#define ABS(a) ((a)>0?(a):-(a))
#define LONG 100

int* newNum(){
	int *A = new int[LONG];
	for(int i = 0; i < LONG; i++) A[i] = 0;
	return A;
}
int* newNum(long long a){
	int *A = new int[LONG];
	for(int i = 0; i < LONG; i++) A[i] = 0;
	while(a){
		A[++A[0]] = a%10;
		a/=10;
	}
	return A;
}
bool isBigger(int *A, int *B){//A>B
	if(A[0]==B[0])
		for(int i = A[0]; i > 0; i--)
			if(A[i]!=B[i]) return A[i]>B[i];
	return A[0]>B[0];
}
int* mul(int* A, int* B){//�������� ����� � �� � � ��������� � �
	int tmp, *R = newNum();

	for(int i = A[0]; i > 0; i--){
		for(int j = B[0]; j > 0; j--){
			R[i+j-1]+=A[i]*B[j];
		}
	}

	R[0] = A[0] + B[0] - 1;

	for(int i = 1; i <= R[0]; i++){
		if(R[i]>9){
			if(i == R[0]) R[0]++;
			R[i+1]+=R[i]/10;
			R[i]%=10;
		}
	}

	for(int i = 0; i <= R[0]; i++){
		A[i] = R[i];
	}

	return A;
}
using namespace std;

struct v{
	int x, y, i;
} m[100100];

int a1 = -1, a2 = -1, n;
long long l1 = 1, l2 = 1, l12 = -2;

int cA(v A){
	int cA;
	if(A.x >= 0 && A.y >= 0) cA = 1;
	else if(A.x < 0 && A.y >= 0) cA = 2;
	else if(A.x < 0 && A.y < 0) cA = 3;
	else if(A.x >= 0 && A.y < 0) cA = 4;

	return cA;
}

int cmp(v A, v B){
	int cA, cB;
	if(A.x >= 0 && A.y >= 0) cA = 1;
	else if(A.x < 0 && A.y >= 0) cA = 2;
	else if(A.x < 0 && A.y < 0) cA = 3;
	else if(A.x >= 0 && A.y < 0) cA = 4;

	if(B.x >= 0 && B.y >= 0) cB = 1;
	else if(B.x < 0 && B.y >= 0) cB = 2;
	else if(B.x < 0 && B.y < 0) cB = 3;
	else if(B.x >= 0 && B.y < 0) cB = 4;
	if(cA != cB) return cA < cB;
	else return B.x*A.y < A.x*B.y;
}

int main(){
	cin>>n;
	for(int i = 0; i < n; i++){
		cin>>m[i].x>>m[i].y;
		m[i].i = i + 1;
	}
	sort(m, m+n, cmp);

//	for(int i = 0; i < n; i++) cout<<m[i].i<<"    "<<m[i].x<<" "<<m[i].y<<"    "<<cA(m[i])<<"\n";
//	cout<<endl;

	for(int i = 0; i < n; i++){
		//cout<<i<<" "<<cosA<<endl;
		int j = (i+1)%n;
		long long ab = m[i].x*m[j].x + m[i].y*m[j].y, a = m[i].x*m[i].x+m[i].y*m[i].y, b = m[j].x*m[j].x+m[j].y*m[j].y;

		if(l12 < 0){
			if(ab >= 0){
				l12 = ab;
				l1 = a;
				l2 = b;
				a1 = m[i].i;
				a2 = m[j].i;
			}else{
				if(isBigger(mul(newNum(a*l12), newNum(b*l12)), mul(newNum(ab*l1), newNum(ab*l2)))){
					l12 = ab;
					l1 = a;
					l2 = b;
					a1 = m[i].i;
					a2 = m[j].i;
				}
			}
		}else{
			if(ab >= 0){
				if(isBigger(mul(newNum(ab*l1), newNum(ab*l2)), mul(newNum(a*l12), newNum(b*l12)))){
					l12 = ab;
					l1 = a;
					l2 = b;
					a1 = m[i].i;
					a2 = m[j].i;
				}
			}else{
				//do nothing
			}
		}

	}

	cout<<a1<<" "<<a2;
	return 0;
}


#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <cmath>

#define ABS(a) ((a)>0?(a):-(a))

using namespace std;

struct v{
	int x, y, i;
} m[100100];

int a1 = -1, a2 = -1, n;
double cosA = -1;

int cA(v A){
	int cA;
	if(A.x >= 0 && A.y >= 0) cA = 1;
	else if(A.x < 0 && A.y >= 0) cA = 2;
	else if(A.x < 0 && A.y < 0) cA = 3;
	else if(A.x >= 0 && A.y < 0) cA = 4;

	return cA;
}

int cmp(v A, v B){
	int cA, cB;
	if(A.x >= 0 && A.y >= 0) cA = 1;
	else if(A.x < 0 && A.y >= 0) cA = 2;
	else if(A.x < 0 && A.y < 0) cA = 3;
	else if(A.x >= 0 && A.y < 0) cA = 4;

	if(B.x >= 0 && B.y >= 0) cB = 1;
	else if(B.x < 0 && B.y >= 0) cB = 2;
	else if(B.x < 0 && B.y < 0) cB = 3;
	else if(B.x >= 0 && B.y < 0) cB = 4;
	if(cA != cB) return cA < cB;
	else return B.x*A.y < A.x*B.y;
}

int main(){
	cin>>n;
	for(int i = 0; i < n; i++){
		cin>>m[i].x>>m[i].y;
		m[i].i = i + 1;
	}
	sort(m, m+n, cmp);

//	for(int i = 0; i < n; i++) cout<<m[i].i<<"    "<<m[i].x<<" "<<m[i].y<<"    "<<cA(m[i])<<"\n";
//	cout<<endl;

	for(int i = 0; i < n; i++){
		//cout<<i<<" "<<cosA<<endl;
		int j = (i+1)%n;
		double ab = m[i].x*m[j].x + m[i].y*m[j].y, a = sqrt(m[i].x*m[i].x+m[i].y*m[i].y), b = sqrt(m[j].x*m[j].x+m[j].y*m[j].y);

		if(ab/a/b > cosA){
			cosA = ab/a/b;
			a1 = m[i].i;
			a2 = m[j].i;
		}
	}
	cout<<a1<<" "<<a2;
	return 0;
}


#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <cmath>

#define ABS(a) ((a)>0?(a):-(a))

using namespace std;

struct v{
	int x, y, i;
} m[100100];

int a1 = -1, a2 = -1, n;
long long l1 = 1, l2 = 1, l12 = -1;
double cosA = -1;

int cA(v A){
	int cA;
	if(A.x >= 0 && A.y >= 0) cA = 1;
	else if(A.x < 0 && A.y >= 0) cA = 2;
	else if(A.x < 0 && A.y < 0) cA = 3;
	else if(A.x >= 0 && A.y < 0) cA = 4;

	return cA;
}

int cmp(v A, v B){
	int cA, cB;
	if(A.x >= 0 && A.y >= 0) cA = 1;
	else if(A.x < 0 && A.y >= 0) cA = 2;
	else if(A.x < 0 && A.y < 0) cA = 3;
	else if(A.x >= 0 && A.y < 0) cA = 4;

	if(B.x >= 0 && B.y >= 0) cB = 1;
	else if(B.x < 0 && B.y >= 0) cB = 2;
	else if(B.x < 0 && B.y < 0) cB = 3;
	else if(B.x >= 0 && B.y < 0) cB = 4;
	if(cA != cB) return cA < cB;
	else return B.x*A.y < A.x*B.y;
}

int main(){
	cin>>n;
	for(int i = 0; i < n; i++){
		cin>>m[i].x>>m[i].y;
		m[i].i = i + 1;
	}
	sort(m, m+n, cmp);

//	for(int i = 0; i < n; i++) cout<<m[i].i<<"    "<<m[i].x<<" "<<m[i].y<<"    "<<cA(m[i])<<"\n";
//	cout<<endl;

	for(int i = 0; i < n; i++){
		//cout<<i<<" "<<cosA<<endl;
		int j = (i+1)%n;
		long long ab = m[i].x*m[j].x + m[i].y*m[j].y, a = m[i].x*m[i].x+m[i].y*m[i].y, b = m[j].x*m[j].x+m[j].y*m[j].y;

		if(l12 < 0){
			if(ab >= 0){
				l12 = ab;
				l1 = a;
				l2 = b;
				a1 = m[i].i;
				a2 = m[j].i;
			}else{
				if(ab*ab*l1*l2<l12*l12*a*b){
					l12 = ab;
					l1 = a;
					l2 = b;
					a1 = m[i].i;
					a2 = m[j].i;
				}
			}
		}else{
			if(ab >= 0){
				if(((double)ab*ab)*l1*l2>((double)l12*l12)*a*b){
					l12 = ab;
					l1 = a;
					l2 = b;
					a1 = m[i].i;
					a2 = m[j].i;
				}
			}else{
				//do nothing
			}
		}

	}
	//cout<<cosA<<endl;
	cout<<a1<<" "<<a2;
	return 0;
}


#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <cmath>

#define ABS(a) ((a)>0?(a):-(a))

using namespace std;

struct v{
	int x, y, i;
} m[100100];

int a1 = -1, a2 = -1, n;
long long l1 = 1, l2 = 1, l12 = -1;
double cosA = -2;

int cA(v A){
	int cA;
	if(A.x >= 0 && A.y >= 0) cA = 1;
	else if(A.x < 0 && A.y >= 0) cA = 2;
	else if(A.x < 0 && A.y < 0) cA = 3;
	else if(A.x >= 0 && A.y < 0) cA = 4;

	return cA;
}

int cmp(v A, v B){
	int cA, cB;
	if(A.x >= 0 && A.y >= 0) cA = 1;
	else if(A.x < 0 && A.y >= 0) cA = 2;
	else if(A.x < 0 && A.y < 0) cA = 3;
	else if(A.x >= 0 && A.y < 0) cA = 4;

	if(B.x >= 0 && B.y >= 0) cB = 1;
	else if(B.x < 0 && B.y >= 0) cB = 2;
	else if(B.x < 0 && B.y < 0) cB = 3;
	else if(B.x >= 0 && B.y < 0) cB = 4;
	if(cA != cB) return cA < cB;
	else return B.x*A.y < A.x*B.y;
}

int main(){
	cin>>n;
	for(int i = 0; i < n; i++){
		cin>>m[i].x>>m[i].y;
		m[i].i = i + 1;
	}
	sort(m, m+n, cmp);

//	for(int i = 0; i < n; i++) cout<<m[i].i<<"    "<<m[i].x<<" "<<m[i].y<<"    "<<cA(m[i])<<"\n";
//	cout<<endl;

	for(int i = 0; i < n; i++){
		//cout<<i<<" "<<cosA<<endl;
		int j = (i+1)%n;
		long long ab = m[i].x*m[j].x + m[i].y*m[j].y, a = m[i].x*m[i].x+m[i].y*m[i].y, b = m[j].x*m[j].x+m[j].y*m[j].y;

		if(l12 < 0){
			if(ab >= 0){
				l12 = ab;
				l1 = a;
				l2 = b;
				a1 = m[i].i;
				a2 = m[j].i;
			}else{
				if(ab*ab*l1*l2<l12*l12*a*b){
					l12 = ab;
					l1 = a;
					l2 = b;
					a1 = m[i].i;
					a2 = m[j].i;
				}
			}
		}else{
			if(ab >= 0){
				if(((double)ab*ab)*l1*l2>((double)l12*l12)*a*b){
					l12 = ab;
					l1 = a;
					l2 = b;
					a1 = m[i].i;
					a2 = m[j].i;
				}
			}else{
				//do nothing
			}
		}

	}
	//cout<<cosA<<endl;
	cout<<a1<<" "<<a2;
	return 0;
}


/*
*/

#include <stdio.h>
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

#define LSOne(S) (S & (-S))
#define EPS 1e-9

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<int, string> ps;
typedef pair<char, int> pc;
typedef pair<pi, int> pii;
typedef pair<double, double> pd;
typedef pair<ll, ll> pll;
typedef pair<double, int> pdi;
typedef pair<ull, int> puli;

typedef
tree<
  string,
  null_type,
  less<string>,
  rb_tree_tag,
  tree_order_statistics_node_update>
ordered_multiset;

typedef ll T; // For geom template
const ld PI = 3.141592653589793;

struct Pt{
    T x, y;
    int idx;
    Pt(T x, T y, int idx) : x(x), y(y), idx(idx) {}
    Pt operator+(Pt p){ return {x+p.x, y+p.y, idx};}
    Pt operator-(Pt p){ return {x-p.x, y-p.y, idx};}
    Pt operator*(Pt p){ return {x*p.x, y*p.y, idx};}
    Pt operator/(Pt p){ return {x/p.x, y/p.y, idx};} // Use floating point if this operator is called
};

T Dot(Pt v, Pt w){return v.x*w.x + v.y*w.y;}
T Cross(Pt v, Pt w){return v.x*w.y - v.y*w.x;}
T Orientation(Pt a, Pt b, Pt c){return Cross(b-a, c-a);} // Positive: ccw, Zero: Collinear, Negative: cw
T SquareLength(Pt p){return p.x*p.x + p.y*p.y;} // If true length is not needed, use squared length with integer type.
T Length(Pt p){ return sqrt(SquareLength(p));}

// True if point is in upper half of cartesian plane. Y == 0, X > 0 is considered 4th quadrant
bool IsUpperQuadrant(Pt p){return p.y > 0 || (p.y == 0 && p.x < 0);}

// Sort ccw w.r.t origin o
void PolarSort(vector<Pt>& vec, Pt o)
{
    sort(vec.begin(), vec.end(), [=](Pt v, Pt w){
         return make_tuple(IsUpperQuadrant(v-o), 0) < make_tuple(IsUpperQuadrant(w-o), Cross(v-o, w-o));
    });
}

// Smallest angle between two vector. This is more accurate than using acos and dot product formula.
ld Angle(Pt v, Pt w)
{
    ld angle1 = atan2(v.y, v.x);
    ld angle2 = atan2(w.y, w.x);
    ld angle = abs(angle1-angle2);
    return min(angle, 2*PI-angle);
}

const int MAXN = 1e5;
int n;
vector<Pt> vec;

int main()
{
    std::ios::sync_with_stdio(false);
    //cin.tie(0); // FOR QUERY PROBLEM DON'T FORGET TO UNCOMMENT THIS
    cin >> n;

    for(int i = 0; i < n; ++i)
    {
        int x, y;
        cin >> x >> y;
        vec.push_back(Pt(x, y, i+1));
    }

    PolarSort(vec, Pt(0, 0, 0));
    ld ans = 1e9;
    int ans1, ans2;

    for(int i = 0; i < vec.size(); ++i)
    {
        ld temp = Angle(vec[i], vec[(i+1)%n]);

        if(temp < ans)
        {
            ans = temp;
            ans1 = vec[i].idx;
            ans2 = vec[(i+1)%n].idx;
        }
    }
    cout << ans1 << " " << ans2 << "\n";
    return 0;
}


/*
    https://www.mathworks.com/help/matlab/ref/atan2.html
*/

#include <stdio.h>
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

#define LSOne(S) (S & (-S))
#define EPS 1e-9

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<int, string> ps;
typedef pair<int, char> pc;
typedef pair<pi, int> pii;
typedef pair<double, double> pd;
typedef pair<ll, ll> pll;
typedef pair<double, int> pdi;
typedef pair<ull, int> puli;

typedef
tree<
  string,
  null_type,
  less<string>,
  rb_tree_tag,
  tree_order_statistics_node_update>
ordered_multiset;

const ld PI = 3.141592653589793;
const int MAXN = 1e5;
pair<ld, int> angleList[MAXN+5];
int n;

inline ld minAngle(ld& angle1, ld& angle2)
{
    return min(angle2-angle1, 2*PI-(angle2-angle1));
}

int main()
{
    std::ios::sync_with_stdio(false);
    //cin.tie(0); // FOR QUERY PROBLEM DON'T FORGET TO UNCOMMENT THIS
    cin >> n;

    for(int i = 0; i < n; ++i)
    {
        int x, y;
        cin >> x >> y;
        ld angle = atan2(y, x);
        angleList[i].first = angle;
        angleList[i].second = i+1;
    }

    sort(angleList, angleList+n);
    ld ans = minAngle(angleList[n-1].first, angleList[0].first);
    int ans1 = angleList[n-1].second, ans2 = angleList[0].second;

    for(int i = 1; i < n; ++i)
    {
        ld temp = minAngle(angleList[i].first, angleList[i-1].first);
        if(temp < ans)
        {
            ans = temp;
            ans1 = angleList[i].second, ans2 = angleList[i-1].second;
        }
    }
    cout << ans1 << " " << ans2 << "\n";
    return 0;
}


/*
*/

#include <stdio.h>
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

#define LSOne(S) (S & (-S))
#define EPS 1e-9

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<int, string> ps;
typedef pair<char, int> pc;
typedef pair<pi, int> pii;
typedef pair<double, double> pd;
typedef pair<ll, ll> pll;
typedef pair<double, int> pdi;
typedef pair<ull, int> puli;

typedef
tree<
  string,
  null_type,
  less<string>,
  rb_tree_tag,
  tree_order_statistics_node_update>
ordered_multiset;

typedef ll T; // For geom template
const ld PI = 3.141592653589793;

struct Pt{
    T x, y;
    int idx;
    Pt(T x, T y, int idx) : x(x), y(y), idx(idx) {}
    Pt operator+(Pt p){ return {x+p.x, y+p.y, idx};}
    Pt operator-(Pt p){ return {x-p.x, y-p.y, idx};}
    Pt operator*(Pt p){ return {x*p.x, y*p.y, idx};}
    Pt operator/(Pt p){ return {x/p.x, y/p.y, idx};} // Use floating point if this operator is called
};

T Dot(Pt v, Pt w){return v.x*w.x + v.y*w.y;}
T Cross(Pt v, Pt w){return v.x*w.y - v.y*w.x;}
T Orientation(Pt a, Pt b, Pt c){return Cross(b-a, c-a);} // Positive: ccw, Zero: Collinear, Negative: cw
T SquareLength(Pt p){return p.x*p.x + p.y*p.y;} // If true length is not needed, use squared length with integer type.
T Length(Pt p){ return sqrt(SquareLength(p));}

// True if point is in upper half of cartesian plane. Y == 0, X > 0 is considered 4th quadrant
bool IsUpperQuadrant(Pt p){return p.y > 0 || (p.y == 0 && p.x < 0);}

// Sort ccw w.r.t origin o
void PolarSort(vector<Pt>& vec, Pt o)
{
    sort(vec.begin(), vec.end(), [=](Pt v, Pt w){
         return make_tuple(IsUpperQuadrant(v-o), 0) < make_tuple(IsUpperQuadrant(w-o), Cross(v-o, w-o));
    });
}

// Smallest angle between two vector. This is more accurate than using acos and dot product formula.
ld Angle(Pt v, Pt w)
{
    ld angle1 = atan2(v.y, v.x);
    ld angle2 = atan2(w.y, w.x);
    ld angle = abs(angle1-angle2);
    return min(angle, 2*PI-angle);
}

const int MAXN = 1e5;
int n;
vector<Pt> vec;

int main()
{
    std::ios::sync_with_stdio(false);
    //cin.tie(0); // FOR QUERY PROBLEM DON'T FORGET TO UNCOMMENT THIS
    cin >> n;

    for(int i = 0; i < n; ++i)
    {
        int x, y;
        cin >> x >> y;
        vec.push_back(Pt(x, y, i+1));
    }

    PolarSort(vec, Pt(0, 0, 0));
    T ans = 1e9;
    int ans1, ans2;

    for(int i = 0; i < vec.size(); ++i)
    {
        T temp = Angle(vec[i], vec[(i+1)%n]);

        if(temp < ans)
        {
            ans = temp;
            ans1 = vec[i].idx;
            ans2 = vec[(i+1)%n].idx;
        }
    }
    cout << ans1 << " " << ans2 << "\n";
    return 0;
}


/*
*/

#include <stdio.h>
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

#define LSOne(S) (S & (-S))
#define EPS 1e-9

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<int, string> ps;
typedef pair<char, int> pc;
typedef pair<pi, int> pii;
typedef pair<double, double> pd;
typedef pair<ll, ll> pll;
typedef pair<double, int> pdi;
typedef pair<ull, int> puli;

typedef
tree<
  string,
  null_type,
  less<string>,
  rb_tree_tag,
  tree_order_statistics_node_update>
ordered_multiset;

typedef long double T; // For geom template

struct Pt{
    T x, y;
    int idx;
    Pt(T x, T y, int idx) : x(x), y(y), idx(idx) {}
    Pt operator+(Pt p){ return {x+p.x, y+p.y, idx};}
    Pt operator-(Pt p){ return {x-p.x, y-p.y, idx};}
    Pt operator*(Pt p){ return {x*p.x, y*p.y, idx};}
    Pt operator/(Pt p){ return {x/p.x, y/p.y, idx};} // Use floating point if this operator is called
};

T Dot(Pt v, Pt w){return v.x*w.x + v.y*w.y;}
T Cross(Pt v, Pt w){return v.x*w.y - v.y*w.x;}
T Orientation(Pt a, Pt b, Pt c){return Cross(b-a, c-a);} // Positive: ccw, Zero: Collinear, Negative: cw
T SquareLength(Pt p){return p.x*p.x + p.y*p.y;} // If true length is not needed, use squared length with integer type.
T Length(Pt p){ return sqrtl(SquareLength(p));}

// True if point is in upper half of cartesian plane. Y == 0, X > 0 is considered 4th quadrant
bool IsUpperQuadrant(Pt p){return p.y > 0 || (p.y == 0 && p.x < 0);}

// Sort ccw w.r.t origin o
void PolarSort(vector<Pt>& vec, Pt o)
{
    sort(vec.begin(), vec.end(), [=](Pt v, Pt w){
         return make_tuple(IsUpperQuadrant(v-o), 0) < make_tuple(IsUpperQuadrant(w-o), Cross(v-o, w-o));
    });
}

// Smallest angle between two vector
T Angle(Pt v, Pt w)
{
    T cosTheta = Dot(v, w) / Length(v) / Length(w);
    if(cosTheta < -1) cosTheta = -1;
    if(cosTheta > 1) cosTheta = 1;
    return acosl(cosTheta);
}

const int MAXN = 1e5;
int n;
vector<Pt> vec;

int main()
{
    std::ios::sync_with_stdio(false);
    //cin.tie(0); // FOR QUERY PROBLEM DON'T FORGET TO UNCOMMENT THIS
    cin >> n;

    for(int i = 0; i < n; ++i)
    {
        int x, y;
        cin >> x >> y;
        vec.push_back(Pt(x, y, i+1));
    }

    PolarSort(vec, Pt(0, 0, 0));
    T ans = 1e9;
    int ans1, ans2;

    for(int i = 0; i < vec.size(); ++i)
    {
        T temp = Angle(vec[i], vec[(i+1)%n]);

        if(temp < ans)
        {
            ans = temp;
            ans1 = vec[i].idx;
            ans2 = vec[(i+1)%n].idx;
        }
    }
    cout << ans1 << " " << ans2 << "\n";
    return 0;
}


/*
*/

#include <stdio.h>
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

#define LSOne(S) (S & (-S))
#define EPS 1e-9

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<int, string> ps;
typedef pair<char, int> pc;
typedef pair<pi, int> pii;
typedef pair<double, double> pd;
typedef pair<ll, ll> pll;
typedef pair<double, int> pdi;
typedef pair<ull, int> puli;

typedef
tree<
  string,
  null_type,
  less<string>,
  rb_tree_tag,
  tree_order_statistics_node_update>
ordered_multiset;

typedef long double T; // For geom template

struct Pt{
    T x, y;
    int idx;
    Pt(T x, T y, int idx) : x(x), y(y), idx(idx) {}
    Pt operator+(Pt p){ return {x+p.x, y+p.y, idx};}
    Pt operator-(Pt p){ return {x-p.x, y-p.y, idx};}
    Pt operator*(Pt p){ return {x*p.x, y*p.y, idx};}
    Pt operator/(Pt p){ return {x/p.x, y/p.y, idx};} // Use floating point if this operator is called
};

T Dot(Pt v, Pt w){return v.x*w.x + v.y*w.y;}
T Cross(Pt v, Pt w){return v.x*w.y - v.y*w.x;}
T Orientation(Pt a, Pt b, Pt c){return Cross(b-a, c-a);} // Positive: ccw, Zero: Collinear, Negative: cw
T SquareLength(Pt p){return p.x*p.x + p.y*p.y;} // If true length is not needed, use squared length with integer type.
T Length(Pt p){ return sqrtl(SquareLength(p));}

// True if point is in upper half of cartesian plane. Y == 0, X > 0 is considered 4th quadrant
bool IsUpperQuadrant(Pt p){return p.y > 0 || (p.y == 0 && p.x < 0);}

// Sort ccw w.r.t origin o
void PolarSort(vector<Pt>& vec, Pt o)
{
    sort(vec.begin(), vec.end(), [=](Pt v, Pt w){
         return make_tuple(IsUpperQuadrant(v-o), 0) < make_tuple(IsUpperQuadrant(w-o), Cross(v-o, w-o));
    });
}

// Smallest angle between two vector
T Angle(Pt v, Pt w)
{
    T cosTheta = Dot(v, w) / Length(v) / Length(w);
    if(cosTheta < -1) cosTheta = -1;
    if(cosTheta > 1) cosTheta = 1;
    return acos(cosTheta);
}

const int MAXN = 1e5; n
int n;
vector<Pt> vec;

int main()
{
    std::ios::sync_with_stdio(false);
    //cin.tie(0); // FOR QUERY PROBLEM DON'T FORGET TO UNCOMMENT THIS
    cin >> n;

    for(int i = 0; i < n; ++i)
    {
        int x, y;
        cin >> x >> y;
        vec.push_back(Pt(x, y, i+1));
    }

    PolarSort(vec, Pt(0, 0, 0));
    T ans = 1e9;
    int ans1, ans2;

    for(int i = 0; i < vec.size(); ++i)
    {
        T temp = Angle(vec[i], vec[(i+1)%n]);

        if(temp < ans)
        {
            ans = temp;
            ans1 = vec[i].idx;
            ans2 = vec[(i+1)%n].idx;
        }
    }
    cout << ans1 << " " << ans2 << "\n";
    return 0;
}


/*
*/

#include <stdio.h>
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

#define LSOne(S) (S & (-S))
#define EPS 1e-9

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<int, string> ps;
typedef pair<char, int> pc;
typedef pair<pi, int> pii;
typedef pair<double, double> pd;
typedef pair<ll, ll> pll;
typedef pair<double, int> pdi;
typedef pair<ull, int> puli;

typedef
tree<
  string,
  null_type,
  less<string>,
  rb_tree_tag,
  tree_order_statistics_node_update>
ordered_multiset;

typedef long double T; // For geom template

struct Pt{
    T x, y;
    int idx;
    Pt(int x, int y, int idx) : x(x), y(y), idx(idx) {}
    Pt operator+(Pt p){ return {x+p.x, y+p.y, idx};}
    Pt operator-(Pt p){ return {x-p.x, y-p.y, idx};}
    Pt operator*(Pt p){ return {x*p.x, y*p.y, idx};}
    Pt operator/(Pt p){ return {x/p.x, y/p.y, idx};} // Use floating point if this operator is called
};

T Dot(Pt v, Pt w){return v.x*w.x + v.y*w.y;}
T Cross(Pt v, Pt w){return v.x*w.y - v.y*w.x;}
T Orientation(Pt a, Pt b, Pt c){return Cross(b-a, c-a);} // Positive: ccw, Zero: Collinear, Negative: cw
T SquareLength(Pt p){return p.x*p.x + p.y*p.y;} // If true length is not needed, use squared length with integer type.
T Length(Pt p){ return sqrt(SquareLength(p));}

// True if point is in upper half of cartesian plane. Y == 0, X > 0 is considered 4th quadrant
bool IsUpperQuadrant(Pt p){return p.y > 0 || (p.y == 0 && p.x < 0);}

// Sort ccw w.r.t origin o
void PolarSort(vector<Pt>& vec, Pt o)
{
    sort(vec.begin(), vec.end(), [=](Pt v, Pt w){
         return make_tuple(IsUpperQuadrant(v-o), 0) < make_tuple(IsUpperQuadrant(w-o), Cross(v-o, w-o));
    });
}

// Smallest angle between two vector
T Angle(Pt v, Pt w)
{
    T cosTheta = Dot(v, w) / Length(v) / Length(w);
    if(cosTheta < -1) cosTheta = -1;
    if(cosTheta > 1) cosTheta = 1;
    return acos(cosTheta);
}

const int MAXN = 1e5;
int n;
vector<Pt> vec;

int main()
{
    std::ios::sync_with_stdio(false);
    //cin.tie(0); // FOR QUERY PROBLEM DON'T FORGET TO UNCOMMENT THIS
    cin >> n;

    for(int i = 0; i < n; ++i)
    {
        int x, y;
        cin >> x >> y;
        vec.push_back(Pt(x, y, i+1));
    }

    PolarSort(vec, Pt(0, 0, 0));
    T ans = 1e9;
    int ans1, ans2;

    for(int i = 0; i < vec.size(); ++i)
    {
        T temp = Angle(vec[i], vec[(i+1)%n]);

        if(temp < ans)
        {
            ans = temp;
            ans1 = vec[i].idx;
            ans2 = vec[(i+1)%n].idx;
        }
    }
    cout << ans1 << " " << ans2 << "\n";
    return 0;
}


/*
*/

#include <stdio.h>
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

#define LSOne(S) (S & (-S))
#define EPS 1e-9

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<int, string> ps;
typedef pair<char, int> pc;
typedef pair<pi, int> pii;
typedef pair<double, double> pd;
typedef pair<ll, ll> pll;
typedef pair<double, int> pdi;
typedef pair<ull, int> puli;

typedef
tree<
  string,
  null_type,
  less<string>,
  rb_tree_tag,
  tree_order_statistics_node_update>
ordered_multiset;

typedef ll T; // For geom template
const ld PI = 3.141592653589793;

struct Pt{
    T x, y;
    int idx;
    Pt(T x, T y, int idx) : x(x), y(y), idx(idx) {}
    Pt operator+(Pt p){ return {x+p.x, y+p.y, idx};}
    Pt operator-(Pt p){ return {x-p.x, y-p.y, idx};}
    Pt operator*(Pt p){ return {x*p.x, y*p.y, idx};}
    Pt operator/(Pt p){ return {x/p.x, y/p.y, idx};} // Use floating point if this operator is called
};

T Dot(Pt v, Pt w){return v.x*w.x + v.y*w.y;}
T Cross(Pt v, Pt w){return v.x*w.y - v.y*w.x;}
T Orientation(Pt a, Pt b, Pt c){return Cross(b-a, c-a);} // Positive: ccw, Zero: Collinear, Negative: cw
T SquareLength(Pt p){return p.x*p.x + p.y*p.y;} // If true length is not needed, use squared length with integer type.
T Length(Pt p){ return sqrt(SquareLength(p));}

// True if point is in upper half of cartesian plane. Y == 0, X > 0 is considered 4th quadrant
bool IsUpperQuadrant(Pt p){return p.y > 0 || (p.y == 0 && p.x < 0);}

// Sort ccw w.r.t origin o
void PolarSort(vector<Pt>& vec, Pt o)
{
    sort(vec.begin(), vec.end(), [=](Pt v, Pt w){
         return make_tuple(IsUpperQuadrant(v-o), 0) < make_tuple(IsUpperQuadrant(w-o), Cross(v-o, w-o));
    });
}

// Smallest angle between two vector. This is more accurate than using acos and dot product formula.
ld Angle(Pt v, Pt w)
{
    ld angle1 = atan2((ld)v.y, (ld)v.x);
    ld angle2 = atan2((ld)w.y, (ld)w.x);
    ld angle = abs(angle1-angle2);
    return min(angle, 2*PI-angle);
}

const int MAXN = 1e5;
int n;
vector<Pt> vec;

int main()
{
    std::ios::sync_with_stdio(false);
    //cin.tie(0); // FOR QUERY PROBLEM DON'T FORGET TO UNCOMMENT THIS
    cin >> n;

    for(int i = 0; i < n; ++i)
    {
        int x, y;
        cin >> x >> y;
        vec.push_back(Pt(x, y, i+1));
    }

    PolarSort(vec, Pt(0, 0, 0));
    ld ans = 1e9;
    int ans1, ans2;

    for(int i = 0; i < vec.size(); ++i)
    {
        ld temp = Angle(vec[i], vec[(i+1)%n]);

        if(temp < ans)
        {
            ans = temp;
            ans1 = vec[i].idx;
            ans2 = vec[(i+1)%n].idx;
        }
    }
    cout << ans1 << " " << ans2 << "\n";
    return 0;
}


/*
    https://www.mathworks.com/help/matlab/ref/atan2.html
*/

#include <stdio.h>
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

#define LSOne(S) (S & (-S))
#define EPS 1e-9

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<int, string> ps;
typedef pair<int, char> pc;
typedef pair<pi, int> pii;
typedef pair<double, double> pd;
typedef pair<ll, ll> pll;
typedef pair<double, int> pdi;
typedef pair<ull, int> puli;

typedef
tree<
  string,
  null_type,
  less<string>,
  rb_tree_tag,
  tree_order_statistics_node_update>
ordered_multiset;

const ld PI = 3.141592653589793;
const int MAXN = 1e5;
pair<ld, int> angleList[MAXN+5];
int n;

int main()
{
    std::ios::sync_with_stdio(false);
    //cin.tie(0); // FOR QUERY PROBLEM DON'T FORGET TO UNCOMMENT THIS
    cin >> n;

    for(int i = 0; i < n; ++i)
    {
        int x, y;
        cin >> x >> y;
        ld angle = atan2(y, x);
        angleList[i].first = angle;
        angleList[i].second = i+1;
    }

    sort(angleList, angleList+n);
    ld ans = angleList[n-1].first-angleList[0].first;
    int ans1 = angleList[n-1].second, ans2 = angleList[0].second;

    for(int i = 1; i < n; ++i)
    {
        ld temp = angleList[i].first-angleList[i-1].first;
        if(temp < ans)
        {
            ans = temp;
            ans1 = angleList[i].second, ans2 = angleList[i-1].second;
        }
    }
    cout << ans1 << " " << ans2 << "\n";
    return 0;
}


/*
*/

#include <stdio.h>
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

#define LSOne(S) (S & (-S))
#define EPS 1e-9

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<int, string> ps;
typedef pair<char, int> pc;
typedef pair<pi, int> pii;
typedef pair<double, double> pd;
typedef pair<ll, ll> pll;
typedef pair<double, int> pdi;
typedef pair<ull, int> puli;

typedef
tree<
  string,
  null_type,
  less<string>,
  rb_tree_tag,
  tree_order_statistics_node_update>
ordered_multiset;

typedef long double T; // For geom template

const ld PI = 3.141592653589793;

struct Pt{
    T x, y;
    int idx;
    Pt(T x, T y, int idx) : x(x), y(y), idx(idx) {}
    Pt operator+(Pt p){ return {x+p.x, y+p.y, idx};}
    Pt operator-(Pt p){ return {x-p.x, y-p.y, idx};}
    Pt operator*(Pt p){ return {x*p.x, y*p.y, idx};}
    Pt operator/(Pt p){ return {x/p.x, y/p.y, idx};} // Use floating point if this operator is called
};

T Dot(Pt v, Pt w){return v.x*w.x + v.y*w.y;}
T Cross(Pt v, Pt w){return v.x*w.y - v.y*w.x;}
T Orientation(Pt a, Pt b, Pt c){return Cross(b-a, c-a);} // Positive: ccw, Zero: Collinear, Negative: cw
T SquareLength(Pt p){return p.x*p.x + p.y*p.y;} // If true length is not needed, use squared length with integer type.
T Length(Pt p){ return sqrt(SquareLength(p));}

// True if point is in upper half of cartesian plane. Y == 0, X > 0 is considered 4th quadrant
bool IsUpperQuadrant(Pt p){return p.y > 0 || (p.y == 0 && p.x < 0);}

// Sort ccw w.r.t origin o
void PolarSort(vector<Pt>& vec, Pt o)
{
    sort(vec.begin(), vec.end(), [=](Pt v, Pt w){
         return make_tuple(IsUpperQuadrant(v-o), 0) < make_tuple(IsUpperQuadrant(w-o), Cross(v-o, w-o));
    });
}

// Smallest angle between two vector
ld Angle(Pt v, Pt w)
{
    ld angle1 = atan2(v.y, v.x);
    ld angle2 = atan2(w.y, w.x);
    ld angle = abs(angle1-angle2);
    return min(angle, 2*PI-angle);
}

const int MAXN = 1e5;
int n;
vector<Pt> vec;

int main()
{
    std::ios::sync_with_stdio(false);
    //cin.tie(0); // FOR QUERY PROBLEM DON'T FORGET TO UNCOMMENT THIS
    cin >> n;

    for(int i = 0; i < n; ++i)
    {
        int x, y;
        cin >> x >> y;
        vec.push_back(Pt(x, y, i+1));
    }

    PolarSort(vec, Pt(0, 0, 0));
    T ans = 1e9;
    int ans1, ans2;

    for(int i = 0; i < vec.size(); ++i)
    {
        T temp = Angle(vec[i], vec[(i+1)%n]);

        if(temp < ans)
        {
            ans = temp;
            ans1 = vec[i].idx;
            ans2 = vec[(i+1)%n].idx;
        }
    }
    cout << ans1 << " " << ans2 << "\n";
    return 0;
}


/*
    https://www.mathworks.com/help/matlab/ref/atan2.html
*/

#include <stdio.h>
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

#define LSOne(S) (S & (-S))
#define EPS 1e-9

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<int, string> ps;
typedef pair<int, char> pc;
typedef pair<pi, int> pii;
typedef pair<double, double> pd;
typedef pair<ll, ll> pll;
typedef pair<double, int> pdi;
typedef pair<ull, int> puli;

typedef
tree<
  string,
  null_type,
  less<string>,
  rb_tree_tag,
  tree_order_statistics_node_update>
ordered_multiset;

const ld PI = 3.141592653589793;
const int MAXN = 1e5;
pair<ld, int> angleList[MAXN+5];
int n;

inline ld minAngle(ld& big, ld& small)
{
    return min(big-small, 2*PI-(big-small));
}

int main()
{
    std::ios::sync_with_stdio(false);
    //cin.tie(0); // FOR QUERY PROBLEM DON'T FORGET TO UNCOMMENT THIS
    cin >> n;

    for(int i = 0; i < n; ++i)
    {
        int x, y;
        cin >> x >> y;
        ld angle = atan2(y, x);
        angleList[i].first = angle;
        angleList[i].second = i+1;
    }

    sort(angleList, angleList+n);
    ld ans = minAngle(angleList[n-1].first, angleList[0].first);
    int ans1 = angleList[n-1].second, ans2 = angleList[0].second;

    for(int i = 1; i < n; ++i)
    {
        ld temp = minAngle(angleList[i].first, angleList[i-1].first);
        if(temp < ans)
        {
            ans = temp;
            ans1 = angleList[i].second, ans2 = angleList[i-1].second;
        }
    }
    cout << ans1 << " " << ans2 << "\n";
    return 0;
}


/*
    https://www.mathworks.com/help/matlab/ref/atan2.html
*/

#include <stdio.h>
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

#define LSOne(S) (S & (-S))
#define EPS 1e-9

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<int, string> ps;
typedef pair<int, char> pc;
typedef pair<pi, int> pii;
typedef pair<double, double> pd;
typedef pair<ll, ll> pll;
typedef pair<double, int> pdi;
typedef pair<ull, int> puli;

typedef
tree<
  string,
  null_type,
  less<string>,
  rb_tree_tag,
  tree_order_statistics_node_update>
ordered_multiset;

const ld PI = 3.141592653589793;
const int MAXN = 1e5;
pair<ld, int> angleList[MAXN+5];
int n;

int main()
{
    std::ios::sync_with_stdio(false);
    //cin.tie(0); // FOR QUERY PROBLEM DON'T FORGET TO UNCOMMENT THIS
    cout << fixed << setprecision(10);
    cin >> n;

    for(int i = 0; i < n; ++i)
    {
        int x, y;
        cin >> x >> y;
        ld angle = atan2(y, x);
        angleList[i].first = angle;
        angleList[i].second = i+1;
    }

    sort(angleList, angleList+n);
    ld ans = angleList[n-1].first-angleList[0].first;
    int ans1 = angleList[n-1].second, ans2 = angleList[0].second;

    for(int i = 1; i < n; ++i)
    {
        ld temp = angleList[i].first-angleList[i-1].first;
        if(temp < ans)
        {
            ans = temp;
            ans1 = angleList[i].second, ans2 = angleList[i-1].second;
        }
    }
    cout << ans1 << " " << ans2 << "\n";
    return 0;
}


/*
*/

#include <stdio.h>
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

#define LSOne(S) (S & (-S))
#define EPS 1e-9

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<int, string> ps;
typedef pair<char, int> pc;
typedef pair<pi, int> pii;
typedef pair<double, double> pd;
typedef pair<ll, ll> pll;
typedef pair<double, int> pdi;
typedef pair<ull, int> puli;

typedef
tree<
  string,
  null_type,
  less<string>,
  rb_tree_tag,
  tree_order_statistics_node_update>
ordered_multiset;

typedef long double T; // For geom template

struct Pt{
    T x, y;
    int idx;
    Pt(T x, T y, int idx) : x(x), y(y), idx(idx) {}
    Pt operator+(Pt p){ return {x+p.x, y+p.y, idx};}
    Pt operator-(Pt p){ return {x-p.x, y-p.y, idx};}
    Pt operator*(Pt p){ return {x*p.x, y*p.y, idx};}
    Pt operator/(Pt p){ return {x/p.x, y/p.y, idx};} // Use floating point if this operator is called
};

T Dot(Pt v, Pt w){return v.x*w.x + v.y*w.y;}
T Cross(Pt v, Pt w){return v.x*w.y - v.y*w.x;}
T Orientation(Pt a, Pt b, Pt c){return Cross(b-a, c-a);} // Positive: ccw, Zero: Collinear, Negative: cw
T SquareLength(Pt p){return p.x*p.x + p.y*p.y;} // If true length is not needed, use squared length with integer type.
T Length(Pt p){ return sqrtl(SquareLength(p));}

// True if point is in upper half of cartesian plane. Y == 0, X > 0 is considered 4th quadrant
bool IsUpperQuadrant(Pt p){return p.y > 0 || (p.y == 0 && p.x < 0);}

// Sort ccw w.r.t origin o
void PolarSort(vector<Pt>& vec, Pt o)
{
    sort(vec.begin(), vec.end(), [=](Pt v, Pt w){
         return make_tuple(IsUpperQuadrant(v-o), 0) < make_tuple(IsUpperQuadrant(w-o), Cross(v-o, w-o));
    });
}

// Smallest angle between two vector
T Angle(Pt v, Pt w)
{
    T cosTheta = Dot(v, w) / Length(v) / Length(w);
    if(cosTheta < -1) cosTheta = -1;
    if(cosTheta > 1) cosTheta = 1;
    return acos(cosTheta);
}

const int MAXN = 1e5;
int n;
vector<Pt> vec;

int main()
{
    std::ios::sync_with_stdio(false);
    //cin.tie(0); // FOR QUERY PROBLEM DON'T FORGET TO UNCOMMENT THIS
    cin >> n;

    for(int i = 0; i < n; ++i)
    {
        int x, y;
        cin >> x >> y;
        vec.push_back(Pt(x, y, i+1));
    }

    PolarSort(vec, Pt(0, 0, 0));
    T ans = 1e9;
    int ans1, ans2;

    for(int i = 0; i < vec.size(); ++i)
    {
        T temp = Angle(vec[i], vec[(i+1)%n]);

        if(temp < ans)
        {
            ans = temp;
            ans1 = vec[i].idx;
            ans2 = vec[(i+1)%n].idx;
        }
    }
    cout << ans1 << " " << ans2 << "\n";
    return 0;
}


/*
*/

#include <stdio.h>
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

#define LSOne(S) (S & (-S))
#define EPS 1e-9

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<int, string> ps;
typedef pair<char, int> pc;
typedef pair<pi, int> pii;
typedef pair<double, double> pd;
typedef pair<ll, ll> pll;
typedef pair<double, int> pdi;
typedef pair<ull, int> puli;

typedef
tree<
  string,
  null_type,
  less<string>,
  rb_tree_tag,
  tree_order_statistics_node_update>
ordered_multiset;

typedef long double T; // For geom template

struct Pt{
    T x, y;
    int idx;
    Pt(T x, T y, int idx) : x(x), y(y), idx(idx) {}
    Pt operator+(Pt p){ return {x+p.x, y+p.y, idx};}
    Pt operator-(Pt p){ return {x-p.x, y-p.y, idx};}
    Pt operator*(Pt p){ return {x*p.x, y*p.y, idx};}
    Pt operator/(Pt p){ return {x/p.x, y/p.y, idx};} // Use floating point if this operator is called
};

T Dot(Pt v, Pt w){return v.x*w.x + v.y*w.y;}
T Cross(Pt v, Pt w){return v.x*w.y - v.y*w.x;}
T Orientation(Pt a, Pt b, Pt c){return Cross(b-a, c-a);} // Positive: ccw, Zero: Collinear, Negative: cw
T SquareLength(Pt p){return p.x*p.x + p.y*p.y;} // If true length is not needed, use squared length with integer type.
T Length(Pt p){ return (T)sqrt(SquareLength(p));}

// True if point is in upper half of cartesian plane. Y == 0, X > 0 is considered 4th quadrant
bool IsUpperQuadrant(Pt p){return p.y > 0 || (p.y == 0 && p.x < 0);}

// Sort ccw w.r.t origin o
void PolarSort(vector<Pt>& vec, Pt o)
{
    sort(vec.begin(), vec.end(), [=](Pt v, Pt w){
         return make_tuple(IsUpperQuadrant(v-o), 0) < make_tuple(IsUpperQuadrant(w-o), Cross(v-o, w-o));
    });
}

// Smallest angle between two vector
T Angle(Pt v, Pt w)
{
    T cosTheta = Dot(v, w) / Length(v) / Length(w);
    if(cosTheta < -1) cosTheta = -1;
    if(cosTheta > 1) cosTheta = 1;
    return acos(cosTheta);
}

const int MAXN = 1e5;
int n;
vector<Pt> vec;

int main()
{
    std::ios::sync_with_stdio(false);
    //cin.tie(0); // FOR QUERY PROBLEM DON'T FORGET TO UNCOMMENT THIS
    cin >> n;

    for(int i = 0; i < n; ++i)
    {
        T x, y;
        cin >> x >> y;
        vec.push_back(Pt(x, y, i+1));
    }

    PolarSort(vec, Pt(0, 0, 0));
    T ans = 1e9;
    int ans1, ans2;

    for(int i = 0; i < vec.size(); ++i)
    {
        T temp = Angle(vec[i], vec[(i+1)%n]);

        if(temp < ans)
        {
            ans = temp;
            ans1 = vec[i].idx;
            ans2 = vec[(i+1)%n].idx;
        }
    }
    cout << ans1 << " " << ans2 << "\n";
    return 0;
}


#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define EPS 1e-9
#define MOD 1000000007
#define int long long
using namespace __gnu_pbds;
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update> ost;

#define pi 3.141592653589793238462643383279

int32_t main(){
	int n;
	cin >> n;
	vector<pair<double,int>> v(n);
	for(int i = 0;i < n; i++){
		int x, y;
		cin >> x >> y;
		if(x == 0){
			if(y > 0){
				v[i] = {pi/2.0,i};
			}
			else v[i] = {1.5*pi,i};
		}
		else if(y == 0){
			if(x > 0){
				v[i] = {0.0, i};
			}
			else{
				v[i] = {pi,i};
			}
		}
		else{
			if(x > 0 && y > 0){
				v[i] = {atan2(1.0*y,1.0*x),i};
			}
			else if(x > 0 && y < 0){
				v[i] = {2*pi - atan2(-1.0*y,1.0*x),i};
			}
			else if(x < 0 && y > 0){
				v[i] = {pi-atan2(1.0*y,(-1.0*x)),i};
			}
			else{
				v[i] = {pi+atan2(-1.0*y,-1.0*x),i};
			}
		}
	}
	sort(v.begin(),v.end());
	int ans1 = -1, ans2 = -1;
	double best = 1000.0;
	for(int i = 0; i < n-1; i++){
		if(best - (v[i+1].F - v[i].F) > 0.0){
			best = (v[i+1].F - v[i].F);
			ans1 = v[i+1].S;
			ans2 = v[i].S;
		}
	}
	double last = 2*pi - v[n-1].F;
	if(best - (last + v[0].F) > 0.0){
		ans1 = v[0].S;
		ans2 = v[n-1].S;
	}

	cout << ans1+1 << " "  << ans2+1 <<"\n";

	return 0;
}


#include<bits/stdc++.h>
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define EPS 1e-9
#define MOD 1000000007
#define int long long
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;

int32_t main(){
	long double pi = acos(-1.0);
	int n;
	cin >> n;
	vector<pair<long double,int>> v(n);
	for(int i = 0; i < n; i++){
		long double x, y;
		cin >> x >> y;
		long double angle = atan2(y,x);
		if(angle < 0)
			angle += 2*pi;
		v[i] = {angle,i+1};
	}
	sort(v.begin(),v.end());

	long double mini = 1000.0;
	int x, y;
	for(int i = 0; i < n; i++){
		long double diff = v[(i+1)%n].F - v[i].F;
		if(diff < 0)
			diff = -diff;
		diff = min(diff,2*pi-diff);
		if(diff < mini){
			mini = diff;
			x = v[i].S;
			y = v[(i+1)%n].S;
		}
	}

	cout << x << " " << y << "\n";

	return 0;
}


#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define EPS 1e-9
#define MOD 1000000007
#define int long long
using namespace __gnu_pbds;
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update> ost;

#define pi 3.1415926535897932

int32_t main(){
	int n;
	cin >> n;
	vector<pair<double,int>> v(n);
	for(int i = 0;i < n; i++){
		int x, y;
		cin >> x >> y;
		if(x == 0){
			if(y > 0){
				v[i] = {pi/2.0,i};
			}
			else v[i] = {1.5*pi,i};
		}
		else if(y == 0){
			if(x > 0){
				v[i] = {0.0, i};
			}
			else{
				v[i] = {pi,i};
			}
		}
		else{
			if(x > 0 && y > 0){
				v[i] = {atan(y/x),i};
			}
			else if(x > 0 && y < 0){
				v[i] = {2*pi - atan(-1.0*y/x),i};
			}
			else if(x < 0 && y > 0){
				v[i] = {pi-atan(y/(-1.0*x)),i};
			}
			else{
				v[i] = {pi+atan(y/x),i};
			}
		}
	}
	sort(v.begin(),v.end());

	//for(auto x : v){
		//cout << x.F << " " << x.S << "\n";
	//}

	int ans1 = -1, ans2 = -1;
	double best = 1e9;
	for(int i = 0; i < n-1; i++){
		if(best > (v[i+1].F - v[i].F)){
			best = (v[i+1].F - v[i].F);
			ans1 = v[i+1].S;
			ans2 = v[i].S;
		}
	}
	double last = 2*pi - v[n-1].F;
	if(last + v[0].F < best){
		ans1 = v[0].S;
		ans2 = v[n-1].S;
	}

	cout << ans1+1 << " "  << ans2+1 <<"\n";

	return 0;
}


#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define EPS 1e-9
#define MOD 1000000007
#define int long long
using namespace __gnu_pbds;
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update> ost;

#define pi 3.1415926535897932

int32_t main(){
	int n;
	cin >> n;
	vector<pair<double,int>> v(n);
	for(int i = 0;i < n; i++){
		int x, y;
		cin >> x >> y;
		if(x == 0){
			if(y > 0){
				v[i] = {pi/2.0,i};
			}
			else v[i] = {1.5*pi,i};
		}
		else if(y == 0){
			if(x > 0){
				v[i] = {0.0, i};
			}
			else{
				v[i] = {pi,i};
			}
		}
		else{
			if(x > 0 && y > 0){
				v[i] = {atan(y/x),i};
			}
			else if(x > 0 && y < 0){
				v[i] = {2*pi - atan(-1.0*y/x),i};
			}
			else if(x < 0 && y > 0){
				v[i] = {pi-atan(y/(-1.0*x)),i};
			}
			else{
				v[i] = {pi+atan(y/x),i};
			}
		}
	}
	sort(v.begin(),v.end());

	int ans1 = -1, ans2 = -1;
	double best = 1000.0;
	for(int i = 0; i < n-1; i++){
		if(best - (v[i+1].F - v[i].F) > EPS){
			best = (v[i+1].F - v[i].F);
			ans1 = v[i+1].S;
			ans2 = v[i].S;
		}
	}
	double last = 2*pi - v[n-1].F;
	if(best - (last + v[0].F) > EPS){
		ans1 = v[0].S;
		ans2 = v[n-1].S;
	}

	cout << ans1+1 << " "  << ans2+1 <<"\n";

	return 0;
}


#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define EPS 1e-9
#define MOD 1000000007
#define int long long
using namespace __gnu_pbds;
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update> ost;

#define pi 3.1415926535897932

int32_t main(){
	int n;
	cin >> n;
	vector<pair<double,int>> v(n);
	for(int i = 0;i < n; i++){
		int x, y;
		cin >> x >> y;
		if(x == 0){
			if(y > 0){
				v[i] = {pi/2.0,i};
			}
			else v[i] = {1.5*pi,i};
		}
		else if(y == 0){
			if(x > 0){
				v[i] = {0.0, i};
			}
			else{
				v[i] = {pi,i};
			}
		}
		else{
			if(x > 0 && y > 0){
				v[i] = {atan2(1.0*y,1.0*x),i};
			}
			else if(x > 0 && y < 0){
				v[i] = {2*pi - atan2(-1.0*y,1.0*x),i};
			}
			else if(x < 0 && y > 0){
				v[i] = {pi-atan2(1.0*y,(-1.0*x)),i};
			}
			else{
				v[i] = {pi+atan2(-1.0*y,-1.0*x),i};
			}
		}
	}
	sort(v.begin(),v.end());
	int ans1 = -1, ans2 = -1;
	double best = 1000.0;
	for(int i = 0; i < n-1; i++){
		if(best - (v[i+1].F - v[i].F) > EPS){
			best = (v[i+1].F - v[i].F);
			ans1 = v[i+1].S;
			ans2 = v[i].S;
		}
	}
	double last = 2*pi - v[n-1].F;
	if(best - (last + v[0].F) > EPS){
		ans1 = v[0].S;
		ans2 = v[n-1].S;
	}

	cout << ans1+1 << " "  << ans2+1 <<"\n";

	return 0;
}


#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define EPS 1e-9
#define MOD 1000000007
#define int long long
using namespace __gnu_pbds;
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update> ost;

#define pi 3.1415926535897932

int32_t main(){
	int n;
	cin >> n;
	vector<pair<double,int>> v(n);
	for(int i = 0;i < n; i++){
		int x, y;
		cin >> x >> y;
		if(x == 0){
			if(y > 0){
				v[i] = {pi/2.0,i};
			}
			else v[i] = {1.5*pi,i};
		}
		else if(y == 0){
			if(x > 0){
				v[i] = {0.0, i};
			}
			else{
				v[i] = {pi,i};
			}
		}
		else{
			if(x > 0 && y > 0){
				v[i] = {atan2(y,x),i};
			}
			else if(x > 0 && y < 0){
				v[i] = {2*pi - atan2(-1.0*y,x),i};
			}
			else if(x < 0 && y > 0){
				v[i] = {pi-atan2(y,(-1.0*x)),i};
			}
			else{
				v[i] = {pi+atan2(y,x),i};
			}
		}
	}
	sort(v.begin(),v.end());

	int ans1 = -1, ans2 = -1;
	double best = 1000.0;
	for(int i = 0; i < n-1; i++){
		if(best - (v[i+1].F - v[i].F) > EPS){
			best = (v[i+1].F - v[i].F);
			ans1 = v[i+1].S;
			ans2 = v[i].S;
		}
	}
	double last = 2*pi - v[n-1].F;
	if(best - (last + v[0].F) > EPS){
		ans1 = v[0].S;
		ans2 = v[n-1].S;
	}

	cout << ans1+1 << " "  << ans2+1 <<"\n";

	return 0;
}


#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define EPS 1e-9
#define MOD 1000000007
#define int long long
using namespace __gnu_pbds;
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update> ost;

int32_t main(){

	long double pi = acos(-1.0);
	int n;
	cin >> n;
	vector<pair<long double,int>> v(n);
	for(int i = 0;i < n; i++){
		int x, y;
		cin >> x >> y;
		if(x == 0){
			if(y > 0){
				v[i] = {pi/2.0,i};
			}
			else v[i] = {1.5*pi,i};
		}
		else if(y == 0){
			if(x > 0){
				v[i] = {0.0, i};
			}
			else{
				v[i] = {pi,i};
			}
		}
		else{
			if(x > 0 && y > 0){
				v[i] = {atan(1.0*y/(1.0*x)),i};
			}
			else if(x > 0 && y < 0){
				v[i] = {2*pi - atan(-1.0*y/(1.0*x)),i};
			}
			else if(x < 0 && y > 0){
				v[i] = {pi-atan(1.0*y/(-1.0*x)),i};
			}
			else{
				v[i] = {pi+atan(-1.0*y/(-1.0*x)),i};
			}
		}
	}
	sort(v.begin(),v.end());
	int ans1 = -1, ans2 = -1;
	long double best = 1000.0;
	for(int i = 0; i < n-1; i++){
		if(best - (v[i+1].F - v[i].F) > 0.0){
			best = (v[i+1].F - v[i].F);
			ans1 = v[i+1].S;
			ans2 = v[i].S;
		}
	}
	double last = 2*pi - v[n-1].F;
	if(best - (last + v[0].F) > 0.0){
		ans1 = v[0].S;
		ans2 = v[n-1].S;
	}

	cout << ans1+1 << " "  << ans2+1 <<"\n";

	return 0;
}


#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define EPS 1e-9
#define MOD 1000000007
#define int long long
using namespace __gnu_pbds;
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update> ost;

int32_t main(){

	long double pi = 2 * acos(-1.0);
	int n;
	cin >> n;
	vector<pair<long double,int>> v(n);
	for(int i = 0;i < n; i++){
		int x, y;
		cin >> x >> y;
		if(x == 0){
			if(y > 0){
				v[i] = {pi/2.0,i};
			}
			else v[i] = {1.5*pi,i};
		}
		else if(y == 0){
			if(x > 0){
				v[i] = {0.0, i};
			}
			else{
				v[i] = {pi,i};
			}
		}
		else{
			if(x > 0 && y > 0){
				v[i] = {atan2(1.0*y,1.0*x),i};
			}
			else if(x > 0 && y < 0){
				v[i] = {2*pi - atan2(-1.0*y,1.0*x),i};
			}
			else if(x < 0 && y > 0){
				v[i] = {pi-atan2(1.0*y,(-1.0*x)),i};
			}
			else{
				v[i] = {pi+atan2(-1.0*y,-1.0*x),i};
			}
		}
	}
	sort(v.begin(),v.end());
	int ans1 = -1, ans2 = -1;
	long double best = 1000.0;
	for(int i = 0; i < n-1; i++){
		if(best - (v[i+1].F - v[i].F) > 0.0){
			best = (v[i+1].F - v[i].F);
			ans1 = v[i+1].S;
			ans2 = v[i].S;
		}
	}
	double last = 2*pi - v[n-1].F;
	if(best - (last + v[0].F) > 0.0){
		ans1 = v[0].S;
		ans2 = v[n-1].S;
	}

	cout << ans1+1 << " "  << ans2+1 <<"\n";

	return 0;
}


#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define EPS 1e-9
#define MOD 1000000007
#define int long long
using namespace __gnu_pbds;
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update> ost;

int32_t main(){

	long double pi = acos(-1.0);
	int n;
	cin >> n;
	vector<pair<long double,int>> v(n);
	for(int i = 0;i < n; i++){
		int x, y;
		cin >> x >> y;
		if(x == 0){
			if(y > 0){
				v[i] = {pi/2.0,i};
			}
			else v[i] = {1.5*pi,i};
		}
		else if(y == 0){
			if(x > 0){
				v[i] = {0.0, i};
			}
			else{
				v[i] = {pi,i};
			}
		}
		else{
			if(x > 0 && y > 0){
				v[i] = {atan2(1.0*y,1.0*x),i};
			}
			else if(x > 0 && y < 0){
				v[i] = {2*pi - atan2(-1.0*y,1.0*x),i};
			}
			else if(x < 0 && y > 0){
				v[i] = {pi-atan2(1.0*y,(-1.0*x)),i};
			}
			else{
				v[i] = {pi+atan2(-1.0*y,-1.0*x),i};
			}
		}
	}
	sort(v.begin(),v.end());
	int ans1 = -1, ans2 = -1;
	long double best = 1000.0;
	for(int i = 0; i < n-1; i++){
		if(best - (v[i+1].F - v[i].F) > 0.0){
			best = (v[i+1].F - v[i].F);
			ans1 = v[i+1].S;
			ans2 = v[i].S;
		}
	}
	double last = 2*pi - v[n-1].F;
	if(best - (last + v[0].F) > 0.0){
		ans1 = v[0].S;
		ans2 = v[n-1].S;
	}

	cout << ans1+1 << " "  << ans2+1 <<"\n";

	return 0;
}


//Create Time: 2017-08-20 23:44:21
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
#include <cstdlib>
#include <sstream>
#include <fstream>
#include <functional>
#include <list>
#include <deque>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <bitset>
#include <cctype>
#include <ctime>
#include <utility>
#include <complex>
#include <cassert>
using namespace std;
#define snuke(i,x) for (__typeof((x).begin()) i = (x).begin(); i != (x).end(); ++i)
#define rep(i,a,n) for (int i=(a);i<(n);i++)
#define per(i,a,n) for (int i=(n)-1;i>=(a);i--)
#define OUT(x) std::cout<<(#x)<<":"<<(x)<<std::endl
#define SZ(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
#define unq(x) sort(ALL(x)),(x).erase(unique(ALL(x)),(x).end())
#define mem(f,x) memset((f), (x), sizeof(f))
#define clr(f) mem(f,0)
#define x first
#define y second
#define mp make_pair
#define pb push_back
#define debug
template<class T> void rd(T&ret){ret=0;bool ok=0,u=0;for(;;){int c=getchar();if(c>='0'&&c<='9')ret=(ret<<3)+(ret<<1)+c-'0',ok=1;else if(c=='-')u=1;else if(ok){if(u)ret*=-1;return;}}}
long long pow_mod(long long p,long long n,long long mod){long long ret=1;for(;n;n>>=1){if(n&1)ret=ret*p%mod;p=p*p%mod;}return ret;}
template <class T> bool chmin(T& a, const T &b) {return b < a? a = b, 1: 0;}
template <class T> bool chmax(T& a, const T &b) {return b > a? a = b, 1: 0;}
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii > vii;
typedef vector<pair<int,pii > > viii;
/****head****/
typedef pair<long double, long double> pdd;
const int Max_N = (int)1e5 + 9;
struct oo {
    long double angle, x, y;
    int idx;
    long double norm() {
        return sqrt(x*x + y*y);
    }
}an[Max_N];
bool cmp(oo a, oo b) {
    return a.angle < b.angle;
}
bool gao(oo a, oo b, pdd& mx) {
    long double x = a.x * b.x + a.y * b.y;
    long double y = a.norm() * b.norm();
    if(mx.x * y < mx.y * x) {
        mx.x = x; mx.y = y;
        return true;
    }
    return false;
}
int main() {
    int n; cin >> n;
    rep(i, 0, n) {
        cin >> an[i].x >> an[i].y;
        an[i].angle = atan2(an[i].y, an[i].x);
        an[i].idx = i;
    }
    sort(an, an + n, cmp);
    an[n] = an[0];
    pdd mx = pdd(-2.0l, 1.0l);
    pii ans;
    rep(i, 0, n) {
        if(gao(an[i], an[i+1], mx)) {
            ans = pii(an[i].idx, an[i+1].idx);
        }
    }
    cout << ans.x+1 << " " << ans.y+1 << endl;
    return 0;
}


//Create Time: 2017-08-20 23:44:21
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
#include <cstdlib>
#include <sstream>
#include <fstream>
#include <functional>
#include <list>
#include <deque>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <bitset>
#include <cctype>
#include <ctime>
#include <utility>
#include <complex>
#include <cassert>
using namespace std;
#define snuke(i,x) for (__typeof((x).begin()) i = (x).begin(); i != (x).end(); ++i)
#define rep(i,a,n) for (int i=(a);i<(n);i++)
#define per(i,a,n) for (int i=(n)-1;i>=(a);i--)
#define OUT(x) std::cout<<(#x)<<":"<<(x)<<std::endl
#define SZ(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
#define unq(x) sort(ALL(x)),(x).erase(unique(ALL(x)),(x).end())
#define mem(f,x) memset((f), (x), sizeof(f))
#define clr(f) mem(f,0)
#define x first
#define y second
#define mp make_pair
#define pb push_back
#define debug
template<class T> void rd(T&ret){ret=0;bool ok=0,u=0;for(;;){int c=getchar();if(c>='0'&&c<='9')ret=(ret<<3)+(ret<<1)+c-'0',ok=1;else if(c=='-')u=1;else if(ok){if(u)ret*=-1;return;}}}
long long pow_mod(long long p,long long n,long long mod){long long ret=1;for(;n;n>>=1){if(n&1)ret=ret*p%mod;p=p*p%mod;}return ret;}
template <class T> bool chmin(T& a, const T &b) {return b < a? a = b, 1: 0;}
template <class T> bool chmax(T& a, const T &b) {return b > a? a = b, 1: 0;}
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii > vii;
typedef vector<pair<int,pii > > viii;
/****head****/
typedef pair<long double, long double> pdd;
const int Max_N = (int)1e5 + 9;
struct oo {
    long double angle, x, y;
    int idx;
    long double norm() {
        return sqrt(x*x + y*y);
    }
}an[Max_N];
bool cmp(oo a, oo b) {
    return a.angle < b.angle;
}
bool gao(oo a, oo b, pdd& mx) {
    long double x = a.x * b.x + a.y * b.y;
    long double y = a.norm() * b.norm();
    //if(mx.x * y < mx.y * x) {
    if((mx.x / mx.y) < (x / y)) {
        mx.x = x; mx.y = y;
        return true;
    }
    return false;
}
int main() {
    int n; cin >> n;
    rep(i, 0, n) {
        cin >> an[i].x >> an[i].y;
        an[i].angle = atan2(an[i].y, an[i].x);
        an[i].idx = i;
    }
    sort(an, an + n, cmp);
    an[n] = an[0];
    pdd mx = pdd(-2.0l, 1.0l);
    pii ans;
    rep(i, 0, n) {
        if(gao(an[i], an[i+1], mx)) {
            ans = pii(an[i].idx, an[i+1].idx);
        }
    }
    cout << ans.x+1 << " " << ans.y+1 << endl;
    return 0;
}


//Create Time: 2017-08-20 22:37:18
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
#include <cstdlib>
#include <sstream>
#include <fstream>
#include <functional>
#include <list>
#include <deque>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <bitset>
#include <cctype>
#include <ctime>
#include <utility>
#include <complex>
#include <cassert>
using namespace std;
#define snuke(i,x) for (__typeof((x).begin()) i = (x).begin(); i != (x).end(); ++i)
#define rep(i,a,n) for (int i=(a);i<(n);i++)
#define per(i,a,n) for (int i=(n)-1;i>=(a);i--)
#define OUT(x) std::cout<<(#x)<<":"<<(x)<<std::endl
#define SZ(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
#define unq(x) sort(ALL(x)),(x).erase(unique(ALL(x)),(x).end())
#define mem(f,x) memset((f), (x), sizeof(f))
#define clr(f) mem(f,0)
#define x first
#define y second
#define mp make_pair
#define pb push_back
#define debug
template<class T> void rd(T&ret){ret=0;bool ok=0,u=0;for(;;){int c=getchar();if(c>='0'&&c<='9')ret=(ret<<3)+(ret<<1)+c-'0',ok=1;else if(c=='-')u=1;else if(ok){if(u)ret*=-1;return;}}}
long long pow_mod(long long p,long long n,long long mod){long long ret=1;for(;n;n>>=1){if(n&1)ret=ret*p%mod;p=p*p%mod;}return ret;}
template <class T> bool chmin(T& a, const T &b) {return b < a? a = b, 1: 0;}
template <class T> bool chmax(T& a, const T &b) {return b > a? a = b, 1: 0;}
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii > vii;
typedef vector<pair<int,pii > > viii;
/****head****/
const int Max_N = (int)1e5 + 9;
pair<int, pair<pair<ll, ll>, int> > an[Max_N];
int gao2(pair<ll,ll> a, pair<ll,ll> b, pair<long double, long double>& mx) {
    long double x = (long double)(a.x * b.x + a.y * b.y);
    long double y = sqrt(0.0l + a.x*a.x + a.y*a.y) * sqrt(0.0l + b.x*b.x + b.y*b.y);
    if(mx.x * y < mx.y * x) {
        mx.x = x; mx.y = y;
        return 1;
    }
    return 0;
}
int gao(pair<ll, ll> a) {
    if((a.y == 0 && a.x > 0) || (a.x > 0 && a.y > 0)) return 1;
    if(a.x == 0 && a.y > 0) return 2;
    if(a.x < 0) return 3;
    if(a.x == 0 && a.y < 0) return 4;
    return 5;
}
bool cmp(pair<int, pair<pair<ll,ll>, int> > a, pair<int, pair<pair<ll,ll>, int> > b) {
    if(a.x == b.x) {
        return b.y.x.x * a.y.x.y < a.y.x.x * b.y.x.y;
    }
    return a.x < b.x;
}
int main() {
    int n; cin >> n;
    rep(i,0,n) {
        pair<ll, ll> tmp;
        cin >> tmp.x >> tmp.y;
        an[i].x = gao(tmp);
        an[i].y.x = tmp;
        an[i].y.y = i;
    }
    sort(an, an + n, cmp);
    an[n] = an[0];
    //mx.x = x1 * x2 + y1 * y2
    //mx.y = |x1| * |x2|
    pair<long double, long double> mx = pair<long double, long double>(-2.0l, 1.0l);
    pii ans;
    rep(i, 0, n) {
        if(gao2(an[i].y.x, an[i+1].y.x, mx)) {
            ans = pii(an[i].y.y, an[i+1].y.y);
        }
    }
    cout << ans.x+1 << " " << ans.y+1 << endl;
    return 0;
}


//Create Time: 2017-08-20 22:37:18
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
#include <cstdlib>
#include <sstream>
#include <fstream>
#include <functional>
#include <list>
#include <deque>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <bitset>
#include <cctype>
#include <ctime>
#include <utility>
#include <complex>
#include <cassert>
using namespace std;
#define snuke(i,x) for (__typeof((x).begin()) i = (x).begin(); i != (x).end(); ++i)
#define rep(i,a,n) for (int i=(a);i<(n);i++)
#define per(i,a,n) for (int i=(n)-1;i>=(a);i--)
#define OUT(x) std::cout<<(#x)<<":"<<(x)<<std::endl
#define SZ(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
#define unq(x) sort(ALL(x)),(x).erase(unique(ALL(x)),(x).end())
#define mem(f,x) memset((f), (x), sizeof(f))
#define clr(f) mem(f,0)
#define x first
#define y second
#define mp make_pair
#define pb push_back
#define debug
template<class T> void rd(T&ret){ret=0;bool ok=0,u=0;for(;;){int c=getchar();if(c>='0'&&c<='9')ret=(ret<<3)+(ret<<1)+c-'0',ok=1;else if(c=='-')u=1;else if(ok){if(u)ret*=-1;return;}}}
long long pow_mod(long long p,long long n,long long mod){long long ret=1;for(;n;n>>=1){if(n&1)ret=ret*p%mod;p=p*p%mod;}return ret;}
template <class T> bool chmin(T& a, const T &b) {return b < a? a = b, 1: 0;}
template <class T> bool chmax(T& a, const T &b) {return b > a? a = b, 1: 0;}
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii > vii;
typedef vector<pair<int,pii > > viii;
/****head****/
const int Max_N = (int)1e5 + 9;
pair<int, pair<pii, int> > an[Max_N];
double gao2(pii a, pii b) {
    return (a.x * b.x + a.y * b.y) / sqrt(0.0 + a.x*a.x + a.y*a.y) / sqrt(0.0 + b.x*b.x + b.y*b.y);
}
int gao(pii a) {
    if((a.y == 0 && a.x > 0) || (a.x > 0 && a.y > 0)) return 1;
    if(a.x == 0 && a.y > 0) return 2;
    if(a.x < 0) return 3;
    if(a.x == 0 && a.y < 0) return 4;
    return 5;
}
bool cmp(pair<int, pair<pii, int> > a, pair<int, pair<pii, int> > b) {
    if(a.x == b.x) {
        return b.y.x.x * a.y.x.y < a.y.x.x * b.y.x.y;
    }
    return a.x < b.x;
}
int main() {
    int n; cin >> n;
    rep(i,0,n) {
        pii tmp;
        //cin >> tmp.x >> tmp.y;
        scanf("%d%d", &tmp.x, &tmp.y);
        an[i].x = gao(tmp);
        an[i].y.x = tmp;
        an[i].y.y = i;
    }
    sort(an, an + n, cmp);
    an[n] = an[0];
    double mx = -1;
    pii ans;
    rep(i, 0, n) {
        double val = gao2(an[i].y.x, an[i+1].y.x);
        if(val > mx) {
            mx = val;
            ans = pii(an[i].y.y, an[i+1].y.y);
        }
    }
    cout << ans.x+1 << " " << ans.y+1 << endl;
    return 0;
}


//Create Time: 2017-08-20 23:44:21
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
#include <cstdlib>
#include <sstream>
#include <fstream>
#include <functional>
#include <list>
#include <deque>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <bitset>
#include <cctype>
#include <ctime>
#include <utility>
#include <complex>
#include <cassert>
using namespace std;
#define snuke(i,x) for (__typeof((x).begin()) i = (x).begin(); i != (x).end(); ++i)
#define rep(i,a,n) for (int i=(a);i<(n);i++)
#define per(i,a,n) for (int i=(n)-1;i>=(a);i--)
#define OUT(x) std::cout<<(#x)<<":"<<(x)<<std::endl
#define SZ(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
#define unq(x) sort(ALL(x)),(x).erase(unique(ALL(x)),(x).end())
#define mem(f,x) memset((f), (x), sizeof(f))
#define clr(f) mem(f,0)
#define x first
#define y second
#define mp make_pair
#define pb push_back
#define debug
template<class T> void rd(T&ret){ret=0;bool ok=0,u=0;for(;;){int c=getchar();if(c>='0'&&c<='9')ret=(ret<<3)+(ret<<1)+c-'0',ok=1;else if(c=='-')u=1;else if(ok){if(u)ret*=-1;return;}}}
long long pow_mod(long long p,long long n,long long mod){long long ret=1;for(;n;n>>=1){if(n&1)ret=ret*p%mod;p=p*p%mod;}return ret;}
template <class T> bool chmin(T& a, const T &b) {return b < a? a = b, 1: 0;}
template <class T> bool chmax(T& a, const T &b) {return b > a? a = b, 1: 0;}
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii > vii;
typedef vector<pair<int,pii > > viii;
/****head****/
typedef pair<long double, long double> pdd;
const int Max_N = (int)1e5 + 9;
struct oo {
    long double angle, x, y;
    int idx;
    long double norm() {
        return sqrt(x*x + y*y);
    }
}an[Max_N];
bool cmp(oo a, oo b) {
    return a.angle < b.angle;
}
bool gao(oo a, oo b, pdd& mx) {
    long double x = a.x * b.x + a.y * b.y;
    long double y = a.norm() * b.norm();
    //if(mx.x * y < mx.y * x) {
    if((mx.x / mx.y) < (x / y)) {
        mx.x = x; mx.y = y;
        return true;
    }
    return false;
}
int main() {
    int n; cin >> n;
    rep(i, 0, n) {
        cin >> an[i].x >> an[i].y;
        an[i].angle = atan2(an[i].y, an[i].x);
        an[i].idx = i;
    }
    sort(an, an + n, cmp);
    an[n] = an[0];

    const long double PI = acos(-1.0l);
    long double mx = PI + 0.1l;
    pii ans;
    rep(i, 0, n) {
        long double diff = an[i+1].angle - an[i].angle;
        if(i == n-1) diff += PI * 2.0l;
        if(diff < mx) {
            ans = pii(an[i].idx, an[i+1].idx);
            mx = diff;
        }
    }
    cout << ans.x+1 << " " << ans.y+1 << endl;
    return 0;
}


//Create Time: 2017-08-20 22:37:18
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
#include <cstdlib>
#include <sstream>
#include <fstream>
#include <functional>
#include <list>
#include <deque>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <bitset>
#include <cctype>
#include <ctime>
#include <utility>
#include <complex>
#include <cassert>
using namespace std;
#define snuke(i,x) for (__typeof((x).begin()) i = (x).begin(); i != (x).end(); ++i)
#define rep(i,a,n) for (int i=(a);i<(n);i++)
#define per(i,a,n) for (int i=(n)-1;i>=(a);i--)
#define OUT(x) std::cout<<(#x)<<":"<<(x)<<std::endl
#define SZ(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
#define unq(x) sort(ALL(x)),(x).erase(unique(ALL(x)),(x).end())
#define mem(f,x) memset((f), (x), sizeof(f))
#define clr(f) mem(f,0)
#define x first
#define y second
#define mp make_pair
#define pb push_back
#define debug
template<class T> void rd(T&ret){ret=0;bool ok=0,u=0;for(;;){int c=getchar();if(c>='0'&&c<='9')ret=(ret<<3)+(ret<<1)+c-'0',ok=1;else if(c=='-')u=1;else if(ok){if(u)ret*=-1;return;}}}
long long pow_mod(long long p,long long n,long long mod){long long ret=1;for(;n;n>>=1){if(n&1)ret=ret*p%mod;p=p*p%mod;}return ret;}
template <class T> bool chmin(T& a, const T &b) {return b < a? a = b, 1: 0;}
template <class T> bool chmax(T& a, const T &b) {return b > a? a = b, 1: 0;}
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii > vii;
typedef vector<pair<int,pii > > viii;
/****head****/
const int Max_N = (int)1e5 + 9;
pair<int, pair<pii, int> > an[Max_N];
int gao2(pii a, pii b, pair<ll, long double>& mx) {
    ll x = a.x * b.x + a.y * b.y;
    long double y = sqrt(0.0l + a.x*a.x + a.y*a.y) * sqrt(0.0l + b.x*b.x + b.y*b.y);
    if(mx.x * y < mx.y * x) {
        mx.x = x; mx.y = y;
        return 1;
    }
    return 0;
}
int gao(pii a) {
    if((a.y == 0 && a.x > 0) || (a.x > 0 && a.y > 0)) return 1;
    if(a.x == 0 && a.y > 0) return 2;
    if(a.x < 0) return 3;
    if(a.x == 0 && a.y < 0) return 4;
    return 5;
}
bool cmp(pair<int, pair<pii, int> > a, pair<int, pair<pii, int> > b) {
    if(a.x == b.x) {
        return b.y.x.x * a.y.x.y < a.y.x.x * b.y.x.y;
    }
    return a.x < b.x;
}
int main() {
    int n; cin >> n;
    rep(i,0,n) {
        pii tmp;
        //cin >> tmp.x >> tmp.y;
        scanf("%d%d", &tmp.x, &tmp.y);
        an[i].x = gao(tmp);
        an[i].y.x = tmp;
        an[i].y.y = i;
    }
    sort(an, an + n, cmp);
    an[n] = an[0];
    //mx.x = x1 * x2 + y1 * y2
    //mx.y = |x1| * |x2|
    pair<ll, long double> mx = pair<ll, long double>(-1, 1.0l);
    pii ans;
    rep(i, 0, n) {
        if(gao2(an[i].y.x, an[i+1].y.x, mx)) {
            ans = pii(an[i].y.y, an[i+1].y.y);
        }
    }
    cout << ans.x+1 << " " << ans.y+1 << endl;
    return 0;
}


//Create Time: 2017-08-20 22:37:18
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
#include <cstdlib>
#include <sstream>
#include <fstream>
#include <functional>
#include <list>
#include <deque>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <bitset>
#include <cctype>
#include <ctime>
#include <utility>
#include <complex>
#include <cassert>
using namespace std;
#define snuke(i,x) for (__typeof((x).begin()) i = (x).begin(); i != (x).end(); ++i)
#define rep(i,a,n) for (int i=(a);i<(n);i++)
#define per(i,a,n) for (int i=(n)-1;i>=(a);i--)
#define OUT(x) std::cout<<(#x)<<":"<<(x)<<std::endl
#define SZ(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
#define unq(x) sort(ALL(x)),(x).erase(unique(ALL(x)),(x).end())
#define mem(f,x) memset((f), (x), sizeof(f))
#define clr(f) mem(f,0)
#define x first
#define y second
#define mp make_pair
#define pb push_back
#define debug
template<class T> void rd(T&ret){ret=0;bool ok=0,u=0;for(;;){int c=getchar();if(c>='0'&&c<='9')ret=(ret<<3)+(ret<<1)+c-'0',ok=1;else if(c=='-')u=1;else if(ok){if(u)ret*=-1;return;}}}
long long pow_mod(long long p,long long n,long long mod){long long ret=1;for(;n;n>>=1){if(n&1)ret=ret*p%mod;p=p*p%mod;}return ret;}
template <class T> bool chmin(T& a, const T &b) {return b < a? a = b, 1: 0;}
template <class T> bool chmax(T& a, const T &b) {return b > a? a = b, 1: 0;}
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii > vii;
typedef vector<pair<int,pii > > viii;
/****head****/
const int Max_N = (int)1e5 + 9;
pair<int, pair<pii, int> > an[Max_N];
int gao2(pii a, pii b, pair<ll, long double>& mx) {
    ll x = a.x * b.x + a.y * b.y;
    x = x > 0 ? x : -x;
    long double y = sqrt(0.0l + a.x*a.x + a.y*a.y) * sqrt(0.0l + b.x*b.x + b.y*b.y);
    if(mx.x * y < mx.y * x) {
        mx.x = x; mx.y = y;
        return 1;
    }
    return 0;
}
int gao(pii a) {
    if((a.y == 0 && a.x > 0) || (a.x > 0 && a.y > 0)) return 1;
    if(a.x == 0 && a.y > 0) return 2;
    if(a.x < 0) return 3;
    if(a.x == 0 && a.y < 0) return 4;
    return 5;
}
bool cmp(pair<int, pair<pii, int> > a, pair<int, pair<pii, int> > b) {
    if(a.x == b.x) {
        return b.y.x.x * a.y.x.y < a.y.x.x * b.y.x.y;
    }
    return a.x < b.x;
}
int main() {
    int n; cin >> n;
    rep(i,0,n) {
        pii tmp;
        //cin >> tmp.x >> tmp.y;
        scanf("%d%d", &tmp.x, &tmp.y);
        an[i].x = gao(tmp);
        an[i].y.x = tmp;
        an[i].y.y = i;
    }
    sort(an, an + n, cmp);
    an[n] = an[0];
    //mx.x = x1 * x2 + y1 * y2
    //mx.y = |x1| * |x2|
    pair<ll, long double> mx = pair<ll, long double>(-1, 1.0l);
    pii ans;
    rep(i, 0, n) {
        if(gao2(an[i].y.x, an[i+1].y.x, mx)) {
            ans = pii(an[i].y.y, an[i+1].y.y);
        }
    }
    cout << ans.x+1 << " " << ans.y+1 << endl;
    return 0;
}


//Create Time: 2017-08-20 22:37:18
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
#include <cstdlib>
#include <sstream>
#include <fstream>
#include <functional>
#include <list>
#include <deque>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <bitset>
#include <cctype>
#include <ctime>
#include <utility>
#include <complex>
#include <cassert>
using namespace std;
#define snuke(i,x) for (__typeof((x).begin()) i = (x).begin(); i != (x).end(); ++i)
#define rep(i,a,n) for (int i=(a);i<(n);i++)
#define per(i,a,n) for (int i=(n)-1;i>=(a);i--)
#define OUT(x) std::cout<<(#x)<<":"<<(x)<<std::endl
#define SZ(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
#define unq(x) sort(ALL(x)),(x).erase(unique(ALL(x)),(x).end())
#define mem(f,x) memset((f), (x), sizeof(f))
#define clr(f) mem(f,0)
#define x first
#define y second
#define mp make_pair
#define pb push_back
#define debug
template<class T> void rd(T&ret){ret=0;bool ok=0,u=0;for(;;){int c=getchar();if(c>='0'&&c<='9')ret=(ret<<3)+(ret<<1)+c-'0',ok=1;else if(c=='-')u=1;else if(ok){if(u)ret*=-1;return;}}}
long long pow_mod(long long p,long long n,long long mod){long long ret=1;for(;n;n>>=1){if(n&1)ret=ret*p%mod;p=p*p%mod;}return ret;}
template <class T> bool chmin(T& a, const T &b) {return b < a? a = b, 1: 0;}
template <class T> bool chmax(T& a, const T &b) {return b > a? a = b, 1: 0;}
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii > vii;
typedef vector<pair<int,pii > > viii;
/****head****/
const int Max_N = (int)1e5 + 9;
pair<int, pair<pii, int> > an[Max_N];
int gao2(pii a, pii b, pair<ll, long double>& mx) {
    ll x = a.x * b.x + a.y * b.y;
    x = x > 0 ? x : -x;
    long double y = sqrt(0.0 + a.x*a.x + a.y*a.y) * sqrt(0.0 + b.x*b.x + b.y*b.y);
    if(mx.x * y < mx.y * x) {
        mx.x = x; mx.y = y;
        return 1;
    }
    return 0;
}
int gao(pii a) {
    if((a.y == 0 && a.x > 0) || (a.x > 0 && a.y > 0)) return 1;
    if(a.x == 0 && a.y > 0) return 2;
    if(a.x < 0) return 3;
    if(a.x == 0 && a.y < 0) return 4;
    return 5;
}
bool cmp(pair<int, pair<pii, int> > a, pair<int, pair<pii, int> > b) {
    if(a.x == b.x) {
        return b.y.x.x * a.y.x.y < a.y.x.x * b.y.x.y;
    }
    return a.x < b.x;
}
int main() {
    int n; cin >> n;
    rep(i,0,n) {
        pii tmp;
        //cin >> tmp.x >> tmp.y;
        scanf("%d%d", &tmp.x, &tmp.y);
        an[i].x = gao(tmp);
        an[i].y.x = tmp;
        an[i].y.y = i;
    }
    sort(an, an + n, cmp);
    an[n] = an[0];
    //mx.x = x1 * x2 + y1 * y2
    //mx.y = |x1| * |x2|
    pair<ll, long double> mx = pair<ll, long double>(-1, 1.0);
    pii ans;
    rep(i, 0, n) {
        if(gao2(an[i].y.x, an[i+1].y.x, mx)) {
            ans = pii(an[i].y.y, an[i+1].y.y);
        }
    }
    cout << ans.x+1 << " " << ans.y+1 << endl;
    return 0;
}


//Create Time: 2017-08-20 22:37:18
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
#include <cstdlib>
#include <sstream>
#include <fstream>
#include <functional>
#include <list>
#include <deque>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <bitset>
#include <cctype>
#include <ctime>
#include <utility>
#include <complex>
#include <cassert>
using namespace std;
#define snuke(i,x) for (__typeof((x).begin()) i = (x).begin(); i != (x).end(); ++i)
#define rep(i,a,n) for (int i=(a);i<(n);i++)
#define per(i,a,n) for (int i=(n)-1;i>=(a);i--)
#define OUT(x) std::cout<<(#x)<<":"<<(x)<<std::endl
#define SZ(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
#define unq(x) sort(ALL(x)),(x).erase(unique(ALL(x)),(x).end())
#define mem(f,x) memset((f), (x), sizeof(f))
#define clr(f) mem(f,0)
#define x first
#define y second
#define mp make_pair
#define pb push_back
#define debug
template<class T> void rd(T&ret){ret=0;bool ok=0,u=0;for(;;){int c=getchar();if(c>='0'&&c<='9')ret=(ret<<3)+(ret<<1)+c-'0',ok=1;else if(c=='-')u=1;else if(ok){if(u)ret*=-1;return;}}}
long long pow_mod(long long p,long long n,long long mod){long long ret=1;for(;n;n>>=1){if(n&1)ret=ret*p%mod;p=p*p%mod;}return ret;}
template <class T> bool chmin(T& a, const T &b) {return b < a? a = b, 1: 0;}
template <class T> bool chmax(T& a, const T &b) {return b > a? a = b, 1: 0;}
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii > vii;
typedef vector<pair<int,pii > > viii;
/****head****/
const int Max_N = (int)1e5 + 9;
pair<int, pair<pii, int> > an[Max_N];
int gao2(pii a, pii b, pair<ll, long double>& mx) {
    ll x = a.x * b.x + a.y * b.y;
    long double y = sqrt(0.0l + a.x*a.x + a.y*a.y) * sqrt(0.0l + b.x*b.x + b.y*b.y);
    if(mx.x * y < mx.y * x) {
        mx.x = x; mx.y = y;
        return 1;
    }
    return 0;
}
int gao(pii a) {
    if((a.y == 0 && a.x > 0) || (a.x > 0 && a.y > 0)) return 1;
    if(a.x == 0 && a.y > 0) return 2;
    if(a.x < 0) return 3;
    if(a.x == 0 && a.y < 0) return 4;
    return 5;
}
bool cmp(pair<int, pair<pii, int> > a, pair<int, pair<pii, int> > b) {
    if(a.x == b.x) {
        return b.y.x.x * a.y.x.y < a.y.x.x * b.y.x.y;
    }
    return a.x < b.x;
}
int main() {
    int n; cin >> n;
    rep(i,0,n) {
        pii tmp;
        //cin >> tmp.x >> tmp.y;
        scanf("%d%d", &tmp.x, &tmp.y);
        an[i].x = gao(tmp);
        an[i].y.x = tmp;
        an[i].y.y = i;
    }
    sort(an, an + n, cmp);
    an[n] = an[0];
    //mx.x = x1 * x2 + y1 * y2
    //mx.y = |x1| * |x2|
    pair<ll, long double> mx = pair<ll, long double>(-2, 1.0l);
    pii ans;
    rep(i, 0, n) {
        if(gao2(an[i].y.x, an[i+1].y.x, mx)) {
            ans = pii(an[i].y.y, an[i+1].y.y);
        }
    }
    cout << ans.x+1 << " " << ans.y+1 << endl;
    return 0;
}


//Create Time: 2017-08-20 22:37:18
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
#include <cstdlib>
#include <sstream>
#include <fstream>
#include <functional>
#include <list>
#include <deque>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <bitset>
#include <cctype>
#include <ctime>
#include <utility>
#include <complex>
#include <cassert>
using namespace std;
#define snuke(i,x) for (__typeof((x).begin()) i = (x).begin(); i != (x).end(); ++i)
#define rep(i,a,n) for (int i=(a);i<(n);i++)
#define per(i,a,n) for (int i=(n)-1;i>=(a);i--)
#define OUT(x) std::cout<<(#x)<<":"<<(x)<<std::endl
#define SZ(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
#define unq(x) sort(ALL(x)),(x).erase(unique(ALL(x)),(x).end())
#define mem(f,x) memset((f), (x), sizeof(f))
#define clr(f) mem(f,0)
#define x first
#define y second
#define mp make_pair
#define pb push_back
#define debug
template<class T> void rd(T&ret){ret=0;bool ok=0,u=0;for(;;){int c=getchar();if(c>='0'&&c<='9')ret=(ret<<3)+(ret<<1)+c-'0',ok=1;else if(c=='-')u=1;else if(ok){if(u)ret*=-1;return;}}}
long long pow_mod(long long p,long long n,long long mod){long long ret=1;for(;n;n>>=1){if(n&1)ret=ret*p%mod;p=p*p%mod;}return ret;}
template <class T> bool chmin(T& a, const T &b) {return b < a? a = b, 1: 0;}
template <class T> bool chmax(T& a, const T &b) {return b > a? a = b, 1: 0;}
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii > vii;
typedef vector<pair<int,pii > > viii;
/****head****/
const int Max_N = (int)1e5 + 9;
pair<int, pair<pii, int> > an[Max_N];
int gao2(pii a, pii b, pair<ll,double>& mx) {
    ll x = a.x * b.x + a.y * b.y;
    x = x > 0 ? x : -x;
    double y = sqrt(0.0 + a.x*a.x + a.y*a.y) * sqrt(0.0 + b.x*b.x + b.y*b.y);
    if(mx.x * y < mx.y * x) {
        mx.x = x; mx.y = y;
        return 1;
    }
    return 0;
}
int gao(pii a) {
    if((a.y == 0 && a.x > 0) || (a.x > 0 && a.y > 0)) return 1;
    if(a.x == 0 && a.y > 0) return 2;
    if(a.x < 0) return 3;
    if(a.x == 0 && a.y < 0) return 4;
    return 5;
}
bool cmp(pair<int, pair<pii, int> > a, pair<int, pair<pii, int> > b) {
    if(a.x == b.x) {
        return b.y.x.x * a.y.x.y < a.y.x.x * b.y.x.y;
    }
    return a.x < b.x;
}
int main() {
    int n; cin >> n;
    rep(i,0,n) {
        pii tmp;
        //cin >> tmp.x >> tmp.y;
        scanf("%d%d", &tmp.x, &tmp.y);
        an[i].x = gao(tmp);
        an[i].y.x = tmp;
        an[i].y.y = i;
    }
    sort(an, an + n, cmp);
    an[n] = an[0];
    //mx.x = x1 * x2 + y1 * y2
    //mx.y = |x1| * |x2|
    pair<ll, double> mx = pair<ll,double>(-1,1);
    pii ans;
    rep(i, 0, n) {
        if(gao2(an[i].y.x, an[i+1].y.x, mx)) {
            ans = pii(an[i].y.y, an[i+1].y.y);
        }
    }
    cout << ans.x+1 << " " << ans.y+1 << endl;
    return 0;
}


//Create Time: 2017-08-20 22:37:18
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
#include <cstdlib>
#include <sstream>
#include <fstream>
#include <functional>
#include <list>
#include <deque>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <bitset>
#include <cctype>
#include <ctime>
#include <utility>
#include <complex>
#include <cassert>
using namespace std;
#define snuke(i,x) for (__typeof((x).begin()) i = (x).begin(); i != (x).end(); ++i)
#define rep(i,a,n) for (int i=(a);i<(n);i++)
#define per(i,a,n) for (int i=(n)-1;i>=(a);i--)
#define OUT(x) std::cout<<(#x)<<":"<<(x)<<std::endl
#define SZ(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
#define unq(x) sort(ALL(x)),(x).erase(unique(ALL(x)),(x).end())
#define mem(f,x) memset((f), (x), sizeof(f))
#define clr(f) mem(f,0)
#define x first
#define y second
#define mp make_pair
#define pb push_back
#define debug
template<class T> void rd(T&ret){ret=0;bool ok=0,u=0;for(;;){int c=getchar();if(c>='0'&&c<='9')ret=(ret<<3)+(ret<<1)+c-'0',ok=1;else if(c=='-')u=1;else if(ok){if(u)ret*=-1;return;}}}
long long pow_mod(long long p,long long n,long long mod){long long ret=1;for(;n;n>>=1){if(n&1)ret=ret*p%mod;p=p*p%mod;}return ret;}
template <class T> bool chmin(T& a, const T &b) {return b < a? a = b, 1: 0;}
template <class T> bool chmax(T& a, const T &b) {return b > a? a = b, 1: 0;}
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii > vii;
typedef vector<pair<int,pii > > viii;
/****head****/
const int Max_N = (int)1e5 + 9;
pair<int, pair<pair<ll, ll>, int> > an[Max_N];
int gao2(pair<ll,ll> a, pair<ll,ll> b, pair<long double, long double>& mx) {
    long double x = (long double)(a.x * b.x + a.y * b.y);
    long double y = sqrt(0.0l + a.x*a.x + a.y*a.y) * sqrt(0.0l + b.x*b.x + b.y*b.y);
    if(mx.x * y < mx.y * x) {
        mx.x = x; mx.y = y;
        return 1;
    }
    return 0;
}
int gao(pair<ll, ll> a) {
    if((a.y == 0 && a.x > 0) || (a.x > 0 && a.y > 0)) return 1;
    if(a.x == 0 && a.y > 0) return 2;
    if(a.x < 0) return 3;
    if(a.x == 0 && a.y < 0) return 4;
    return 5;
}
bool cmp(pair<int, pair<pair<ll,ll>, int> > a, pair<int, pair<pair<ll,ll>, int> > b) {
    if(a.x == b.x) {
        return b.y.x.x * a.y.x.y < a.y.x.x * b.y.x.y;
    }
    return a.x < b.x;
}
int main() {
    int n; cin >> n;
    rep(i,0,n) {
        pair<ll, ll> tmp;
        cin >> tmp.x >> tmp.y;
        an[i].x = gao(tmp);
        an[i].y.x = tmp;
        an[i].y.y = i;
    }
    sort(an, an + n, cmp);
    an[n] = an[0];
    //mx.x = x1 * x2 + y1 * y2
    //mx.y = |x1| * |x2|
    pair<long double, long double> mx = pair<long double, long double>(-1.0l, 1.0l);
    pii ans;
    rep(i, 0, n) {
        if(gao2(an[i].y.x, an[i+1].y.x, mx)) {
            ans = pii(an[i].y.y, an[i+1].y.y);
        }
    }
    cout << ans.x+1 << " " << ans.y+1 << endl;
    return 0;
}


//Create Time: 2017-08-20 22:37:18
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
#include <cstdlib>
#include <sstream>
#include <fstream>
#include <functional>
#include <list>
#include <deque>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <bitset>
#include <cctype>
#include <ctime>
#include <utility>
#include <complex>
#include <cassert>
using namespace std;
#define snuke(i,x) for (__typeof((x).begin()) i = (x).begin(); i != (x).end(); ++i)
#define rep(i,a,n) for (int i=(a);i<(n);i++)
#define per(i,a,n) for (int i=(n)-1;i>=(a);i--)
#define OUT(x) std::cout<<(#x)<<":"<<(x)<<std::endl
#define SZ(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
#define unq(x) sort(ALL(x)),(x).erase(unique(ALL(x)),(x).end())
#define mem(f,x) memset((f), (x), sizeof(f))
#define clr(f) mem(f,0)
#define x first
#define y second
#define mp make_pair
#define pb push_back
#define debug
template<class T> void rd(T&ret){ret=0;bool ok=0,u=0;for(;;){int c=getchar();if(c>='0'&&c<='9')ret=(ret<<3)+(ret<<1)+c-'0',ok=1;else if(c=='-')u=1;else if(ok){if(u)ret*=-1;return;}}}
long long pow_mod(long long p,long long n,long long mod){long long ret=1;for(;n;n>>=1){if(n&1)ret=ret*p%mod;p=p*p%mod;}return ret;}
template <class T> bool chmin(T& a, const T &b) {return b < a? a = b, 1: 0;}
template <class T> bool chmax(T& a, const T &b) {return b > a? a = b, 1: 0;}
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii > vii;
typedef vector<pair<int,pii > > viii;
/****head****/
const int Max_N = (int)1e5 + 9;
pair<int, pair<pii, int> > an[Max_N];
int gao2(pii a, pii b, pair<ll,double>& mx) {
    ll x = a.x * b.x + a.y * b.y;
    double y = sqrt(0.0 + a.x*a.x + a.y*a.y) * sqrt(0.0 + b.x*b.x + b.y*b.y);
    if(mx.x * y < mx.y * x) {
        mx.x = x; mx.y = y;
        return 1;
    }
    return 0;
}
int gao(pii a) {
    if((a.y == 0 && a.x > 0) || (a.x > 0 && a.y > 0)) return 1;
    if(a.x == 0 && a.y > 0) return 2;
    if(a.x < 0) return 3;
    if(a.x == 0 && a.y < 0) return 4;
    return 5;
}
bool cmp(pair<int, pair<pii, int> > a, pair<int, pair<pii, int> > b) {
    if(a.x == b.x) {
        return b.y.x.x * a.y.x.y < a.y.x.x * b.y.x.y;
    }
    return a.x < b.x;
}
int main() {
    int n; cin >> n;
    rep(i,0,n) {
        pii tmp;
        //cin >> tmp.x >> tmp.y;
        scanf("%d%d", &tmp.x, &tmp.y);
        an[i].x = gao(tmp);
        an[i].y.x = tmp;
        an[i].y.y = i;
    }
    sort(an, an + n, cmp);
    an[n] = an[0];
    //mx.x = x1 * x2 + y1 * y2
    //mx.y = |x1| * |x2|
    pair<ll, double> mx = pair<ll,double>(-1,1);
    pii ans;
    rep(i, 0, n) {
        if(gao2(an[i].y.x, an[i+1].y.x, mx)) {
            ans = pii(an[i].y.y, an[i+1].y.y);
        }
    }
    cout << ans.x+1 << " " << ans.y+1 << endl;
    return 0;
}


// qdd on Mar 29, 2018

#include <bits/stdc++.h>
using namespace std;

const int MAXN = 1e5 + 7;
const double PI = acos(-1);

pair<int, int> vec[MAXN];
pair<int, double> orz[MAXN];

bool cmp(const pair<int, double> &v1, const pair<int, double> &v2)
{
    if (v1.second != v2.second) return v1.second < v2.second;
    return v1.first < v2.first;
}

int main()
{
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++)
    {
        scanf("%d%d", &vec[i].first, &vec[i].second);
    }
    for (int i = 1; i <= n; i++)
    {
        orz[i].first = i;
        orz[i].second = atan2(vec[i].second, vec[i].first);
        if (orz[i].second < 0) orz[i].second += 2 * PI;
    }
    sort(orz + 1, orz + n + 1, cmp);
    pair<int, int> res = {orz[1].first, orz[n].first};
    double min_orz = orz[1].second + 2 * PI - orz[n].second;
    for (int i = 2; i <= n; i++)
    {
        if (orz[i].second - orz[i - 1].second < min_orz)
        {
            res = {orz[i - 1].first, orz[i].first};
            min_orz = orz[i].second - orz[i - 1].second;
        }
    }
    printf("%d %d\n", res.first, res.second);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
const int tmax=1e5+5;
const long double epx=1e-16,one=1.0;
int n,num1,num2,index1,index2;
long double ans=-1;
int cmp(long double a,long double b)
{
	if(a-b>epx) return 1;
	if(b-a>epx) return -1;
	return 0;
}
struct node{
	long double cos,sin;
	int ori;
	bool operator <(node b)const
	{
		return (cmp(cos,b.cos)==-1);
	}
};
node pos[tmax],neg[tmax];
int main()
{
	int i;
	long long x,y;
	long double r,tmp;
	scanf("%d",&n);
	for(i=1;i<=n;i++)
	{
		scanf("%I64d%I64d",&x,&y);
		r=sqrt(one*x*x+one*y*y);
		if(y>=0)
		{
			num1++;
			pos[num1].cos=(one*x)/r;
			pos[num1].sin=(one*y)/r;
			pos[num1].ori=i;
		}
		else
		{
			num2++;
			neg[num2].cos=(one*x)/r;
			neg[num2].sin=(one*y)/r;
			neg[num2].ori=i;
		}
	}
	sort(pos+1,pos+1+num1);
	sort(neg+1,neg+1+num2);
	for(i=2;i<=num1;i++)
	{
		tmp=pos[i].cos*pos[i-1].cos+pos[i].sin*pos[i-1].sin;
		if(cmp(tmp,ans)>-1)
		{
			ans=tmp;
			index1=pos[i].ori;
			index2=pos[i-1].ori;
		}
	}
	for(i=2;i<=num2;i++)
	{
		tmp=neg[i].cos*neg[i-1].cos+neg[i].sin*neg[i-1].sin;
		if(cmp(tmp,ans)>-1)
		{
			ans=tmp;
			index1=neg[i].ori;
			index2=neg[i-1].ori;
		}
	}
	if(num1>=1&&num2>=1)
	{
		tmp=pos[num1].cos*neg[num2].cos+pos[num1].sin*neg[num2].sin;
		if(cmp(tmp,ans)>-1)
		{
			ans=tmp;
			index1=pos[num1].ori;
			index2=neg[num2].ori;
		}
		tmp=pos[1].cos*neg[1].cos+pos[1].sin*neg[1].sin;
		if(cmp(tmp,ans)>-1)
		{
			index1=pos[1].ori;
			index2=neg[1].ori;
		}
	}
	printf("%d %d",index1,index2);
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1.0);

vector<pair<long double, int> > P;
int main()
{
    int n;
    scanf("%d", &n);

    for(int i = 0; i < n; i++)
    {
        long double x, y;
        cin >> x >> y;
        pair<long double, int> tmp;
        tmp.first = atan2(y, x);
        tmp.second = i + 1;
        P.push_back(tmp);
    }

    sort(P.begin(), P.end());
    long double minn = 2 * PI;
    int a = 0, b = 0;

    for(int i = 0; i < n; i++)
    {
        long double tmp = (P[(i + 1) % n].first - P[i].first);

        if(tmp < 0)
            tmp += 2 * PI;

        if(tmp < minn)
        {
            minn = tmp;
            a = P[(i + 1) % n].second, b = P[i].second;
        }
    }

    printf("%d %d\n", a, b);

    //cin >> n;
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
const int tmax=1e5+5;
const long double epx=1e-16,one=1.0;
int n,num1,num2,index1,index2;
long double ans=-1;
int cmp(long double a,long double b)
{
	if(a-b>epx) return 1;
	if(b-a>epx) return -1;
	return 0;
}
struct node{
	long double cos,sin;
	int ori;
	bool operator <(node b)const
	{
		return (cmp(cos,b.cos)==-1);
	}
};
node pos[tmax],neg[tmax];
int main()
{
	int i,x,y;
	long double r,tmp;
	scanf("%d",&n);
	for(i=1;i<=n;i++)
	{
		scanf("%d%d",&x,&y);
		r=sqrt(one*x*x+one*y*y);
		if(y>=0)
		{
			num1++;
			pos[num1].cos=(one*x)/r;
			pos[num1].sin=(one*y)/r;
			pos[num1].ori=i;
		}
		else
		{
			num2++;
			neg[num2].cos=(one*x)/r;
			neg[num2].sin=(one*y)/r;
			neg[num2].ori=i;
		}
	}
	sort(pos+1,pos+1+num1);
	sort(neg+1,neg+1+num2);
	for(i=2;i<num1;i++)
	{
		tmp=pos[i].cos*pos[i-1].cos+pos[i].sin*pos[i-1].sin;
		if(cmp(tmp,ans)>-1)
		{
			ans=tmp;
			index1=pos[i].ori;
			index2=pos[i-1].ori;
		}
		tmp=pos[i].cos*pos[i+1].cos+pos[i].sin*pos[i+1].sin;
		if(cmp(tmp,ans)>-1)
		{
			ans=tmp;
			index1=pos[i].ori;
			index2=pos[i+1].ori;
		}
	}
	for(i=2;i<num2;i++)
	{
		tmp=neg[i].cos*neg[i-1].cos+neg[i].sin*neg[i-1].sin;
		if(cmp(tmp,ans)>-1)
		{
			ans=tmp;
			index1=neg[i].ori;
			index2=neg[i-1].ori;
		}
		tmp=neg[i].cos*neg[i+1].cos+neg[i].sin*neg[i+1].sin;
		if(cmp(tmp,ans)>-1)
		{
			ans=tmp;
			index1=neg[i].ori;
			index2=neg[i+1].ori;
		}
	}
	tmp=pos[num1].cos*neg[num2].cos+pos[num1].sin*neg[num2].sin;
	if(cmp(tmp,ans)>-1)
	{
		ans=tmp;
		index1=pos[num1].ori;
		index2=neg[num2].ori;
	}
	if(num1>=1&&num2>=1)
	{
		tmp=pos[1].cos*neg[1].cos+pos[1].sin*neg[1].sin;
		if(cmp(tmp,ans)>-1)
		{
			index1=pos[1].ori;
			index2=neg[1].ori;
		}
	}
	printf("%d %d",index1,index2);
	return 0;
}


// qdd on Mar 29, 2018

#include <bits/stdc++.h>
using namespace std;

const int MAXN = 1e5 + 7;
const long double PI = acos(-1);

pair<int, int> vec[MAXN];
pair<int, long double> orz[MAXN];

bool cmp(const pair<int, long double> &v1, const pair<int, long double> &v2)
{
    if (v1.second != v2.second) return v1.second < v2.second;
    return v1.first < v2.first;
}

int main()
{
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++)
    {
        scanf("%d%d", &vec[i].first, &vec[i].second);
    }
    for (int i = 1; i <= n; i++)
    {
        orz[i].first = i;
        orz[i].second = atan2(vec[i].second, vec[i].first);
        if (orz[i].second < 0) orz[i].second += 2 * PI;
    }
    sort(orz + 1, orz + n + 1, cmp);
    pair<int, int> res = {orz[1].first, orz[n].first};
    long double min_orz = orz[1].second + 2 * PI - orz[n].second;
    for (int i = 2; i <= n; i++)
    {
        if (orz[i].second - orz[i - 1].second < min_orz)
        {
            res = {orz[i - 1].first, orz[i].first};
            min_orz = orz[i].second - orz[i - 1].second;
        }
    }
    printf("%d %d\n", res.first, res.second);
    return 0;
}


#include <bits/stdc++.h>
// using namespace std;
const int N = 100005;
const long double PI = acos(-1.0);

int a, b;

struct node
{
    int id;
    long double x, y;
    long double angle;
} P[N];

int cmp(node a, node b)
{
    return a.angle < b.angle;
}

int main()
{
    int n;
    scanf("%d", &n);

    long double x1, y1, x2, y2;

    for(int i = 1; i <= n; i++)
    {
        double x, y;
        std::cin >> x >> y;
        P[i].id = i;
        P[i].x = x;
        P[i].y = y;
        P[i].angle = atan2(y, x);
    }

    std::sort(P + 1, P + n + 1, cmp);
    long double minn = 90, w;

    for(int i = 2; i <= n; i++)
    {

        x1 = P[i].x;
        y1 = P[i].y;
        x2 = P[i - 1].x;
        y2 = P[i - 1].y;
        w = atan2(y1, x1) - atan2(y2, x2);

        if(w < 0)
            w += 2 * PI;

        if(w <= minn)
        {
            a = P[i - 1].id;
            b = P[i].id;
            minn = w;
        }
    }

    x1 = P[1].x;
    y1 = P[1].y;
    x2 = P[n].x;
    y2 = P[n].y;
    w = atan2(y1, x1) - atan2(y2, x2);

    if(w < 0)
        w += 2 * PI;

    if(w < minn)
    {
        a = P[1].id;
        b = P[n].id;
        minn = w;
    }

    printf("%d %d\n", a, b);

    //std::cin >> x1;
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
const int tmax=1e5+5;
const long double epx=1e-30,one=1.0;
int n,num1,num2,index1,index2;
long double ans=-100000000000000000000;
int cmp(long double a,long double b)
{
	if(fabs(a-b)<=epx) return 0;
	if(a-b>epx) return  1;
	return -1;
}
struct node{
	long double cos;
	long long x,y;
	int ori;
	bool operator <(node b)const
	{
		return (cmp(cos,b.cos)==-1);
	}
};
node pos[tmax],neg[tmax];
long double sign(long long abcd)
{
	if(abcd>=0) return one*abcd*abcd;
	else return -one*abcd*abcd;
}
int main()
{
	int i;
	long long tx,ty;
	long double r,tmp;
	scanf("%d",&n);
	for(i=1;i<=n;i++)
	{
		scanf("%I64d%I64d",&tx,&ty);
		r=sqrt(one*tx*tx+one*ty*ty);
		if(ty>=0)
		{
			num1++;
			pos[num1].cos=(one*tx)/r;
			//pos[num1].sin=(one*y)/r;
			pos[num1].x=tx;pos[num1].y=ty;
			pos[num1].ori=i;
		}
		else
		{
			num2++;
			neg[num2].cos=(one*tx)/r;
			//neg[num2].sin=(one*y)/r;
			neg[num2].x=tx;neg[num2].y=ty;
			neg[num2].ori=i;
		}
	}
	if(num1>0) sort(pos+1,pos+1+num1);
	if(num2>0) sort(neg+1,neg+1+num2);
	for(i=2;i<=num1;i++)
	{
		tmp=sign(pos[i].x*pos[i-1].x+pos[i].y*pos[i-1].y)/(one*(pos[i].x*pos[i].x+pos[i].y*pos[i].y)*(pos[i-1].x*pos[i-1].x+pos[i-1].y*pos[i-1].y));
		if(cmp(tmp,ans)>-1)
		{
			ans=tmp;
			index1=pos[i].ori;
			index2=pos[i-1].ori;
		}
	}
	for(i=2;i<=num2;i++)
	{
		tmp=sign(neg[i].x*neg[i-1].x+neg[i].y*neg[i-1].y)/(one*(neg[i].x*neg[i].x+neg[i].y*neg[i].y)*(neg[i-1].x*neg[i-1].x+neg[i-1].y*neg[i-1].y));
		if(cmp(tmp,ans)>-1)
		{
			ans=tmp;
			index1=neg[i].ori;
			index2=neg[i-1].ori;
		}
	}
	if(num1>=1&&num2>=1)
	{
		tmp=sign(pos[num1].x*neg[num2].x+pos[num1].y*neg[num2].y)/(one*(pos[num1].x*pos[num1].x+pos[num1].y*pos[num1].y)*(neg[num2].x*neg[num2].x+neg[num2].y*neg[num2].y));
		//tmp=pos[num1].cos*neg[num2].cos+pos[num1].sin*neg[num2].sin;
		if(cmp(tmp,ans)>-1)
		{
			ans=tmp;
			index1=pos[num1].ori;
			index2=neg[num2].ori;
		}
		tmp=sign(pos[1].x*neg[1].x+pos[1].y*neg[1].y)/(one*(pos[1].x*pos[1].x+pos[1].y*pos[1].y)*(neg[1].x*neg[1].x+neg[1].y*neg[1].y));
		//tmp=pos[1].cos*neg[1].cos+pos[1].sin*neg[1].sin;
		if(cmp(tmp,ans)>-1)
		{
			index1=pos[1].ori;
			index2=neg[1].ori;
		}
	}
	printf("%d %d",index1,index2);
	return 0;
}