//////// Kelvin 2016
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <complex>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
const double PI = (acos(-1.0));
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

struct Point
{
	int x, y;
	int i, j;
	Point(ll ix = 0, ll iy = 0):x(ix),y(iy) {}

	ll dot(const Point &a, const Point &b) //|a||b|cosθ // 0 90 180 270 360 //y
	{													// 1  0  -1  0  1
		return a.x*b.x + a.y*b.y;
	}
	ll cross(const Point &a, const Point &b)  //-|a||b|sinθ // 0 90 180 270 360 //x
	{														// 0  1  0  -1  0
		return a.x*1ll*b.y - b.x*1ll*a.y;
	}

	Point& operator = (const Point &b)
	{
		x = b.x;
		y = b.y;
		i = b.i;
		j = b.j;
		return *this;
	}
	Point& operator -= (const Point &b)
	{
		x -= b.x;
		y -= b.y;
		return *this;
	}
	Point& operator += (const Point &b)
	{
		x += b.x;
		y += b.y;
		return *this;
	}
	Point& operator *= (const Point &b)
	{
		ll tx = cross(b, *this);
		y = dot(*this, b);
		x = abs(tx);
		j = b.i;
		return *this;
	}
	bool operator < (const Point &b)
	{
		bool ka=   y>0 ||   y==0 &&   x>=0;
		bool kb= b.y>0 || b.y==0 && b.x>=0;
		return ka > kb || ka==kb && cross(b, *this)>0;
	}
	Point operator - (const Point &b){ Point res = *this; res -= b; return res; }
	Point operator + (const Point &b){ Point res = *this; res += b; return res; }
	Point operator * (const Point &b){ Point res = *this; res *= b; return res; }
};

int main()
{
	int n, i, j;
	cin>>n;
	Point *p = new Point[n+1];
	forn(i,0,n)
	{
		cin>>p[i].x>>p[i].y;
		p[i].i = i+1;
	}
	sort(p, p+n);
	p[n] = p[0];
	forn(i,0,n)
	{
		p[i] *= p[i+1];
	}
	j = 0;
	forn(i,1,n)
	{
		if(p[i] < p[j]) j = i;
	}
	cout<<p[j].i<<" "<<p[j].j<<endl;
	return 0;
}


//////// Kelvin 2015
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
#define PI  acos(-1.0)
typedef long long ll;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

#define BIN__N(x) (x) | x>>3 | x>>6 | x>>9
#define BIN__B(x) (x) & 0xf | (x)>>12 & 0xf0
#define BIN8(v) (BIN__B(BIN__N(0x##v)))
//#define _CRT_SECURE_NO_WARNINGS

int main()
{
    int n, i;
    cin>>n;
    double x, y;
    pair<double, int> *ans = new pair<double, int>[n];
    forn(i,0,n)
    {
        cin>>x>>y;
        ans[i] = make_pair((x*x/(x*x+y*y)*((x>=0.)?1.:-1.)+1.)*((y>=0.)?1.:-1.),i+1);
    }

    sort(ans,ans+n);
    double mdelta = 10., delta;
    int ind = 0;
    forn(i,0,n-1)
    {
        delta = ans[i+1].first - ans[i].first;
        if(delta<mdelta){ mdelta = delta; ind = i;}
    }
    delta = ans[0].first+4. - ans[n-1].first;
    if(delta<mdelta){ mdelta = delta; ind = n-1;}

    cout<<ans[ind].second<<" "<<ans[(ind+1)%n].second<<endl;

    return 0;
}


//////// Kelvin 2016
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <complex>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
const double PI = (acos(-1.0));
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

struct Point
{
	ll x, y;
	int i, j;
	Point(ll ix = 0, ll iy = 0):x(ix),y(iy) {}

	ll dot(const Point &a, const Point &b) //|a||b|cosθ // 0 90 180 270 360 //y
	{													// 1  0  -1  0  1
		return a.x*b.x + a.y*b.y;
	}
	ll cross(const Point &a, const Point &b)  //-|a||b|sinθ // 0 90 180 270 360 //x
	{														// 0  1  0  -1  0
		return a.x*b.y - b.x*a.y;
	}

	Point& operator = (const Point &b)
	{
		x = b.x;
		y = b.y;
		i = b.i;
		j = b.j;
		return *this;
	}
	Point& operator -= (const Point &b)
	{
		x -= b.x;
		y -= b.y;
		return *this;
	}
	Point& operator += (const Point &b)
	{
		x += b.x;
		y += b.y;
		return *this;
	}
	Point& operator *= (const Point &b)
	{
		x = abs(cross(b, *this));
		y = dot(*this, b);
		j = b.i;
		return *this;
	}
	bool operator < (const Point &b)
	{
		bool ka=   y>0 ||   y==0 &&   x>=0;
		bool kb= b.y>0 || b.y==0 && b.x>=0;
		return ka > kb || ka==kb && cross(b, *this)>0;
	}
	Point operator - (const Point &b){ Point res = *this; res -= b; return res; }
	Point operator + (const Point &b){ Point res = *this; res += b; return res; }
	Point operator * (const Point &b){ Point res = *this; res *= b; return res; }
};

int main()
{
	int n, i, j;
	cin>>n;
	Point *p = new Point[n+1];
	forn(i,0,n)
	{
		cin>>p[i].x>>p[i].y;
		p[i].i = i+1;
	}
	sort(p, p+n);
	p[n] = p[0];
	forn(i,0,n)
	{
		p[i] *= p[i+1];
	}
	j = 0;
	forn(i,1,n)
	{
		if(p[i] < p[j]) j = i;
	}
	cout<<p[j].i<<" "<<p[j].j<<endl;
	return 0;
}


//////// Kelvin 2015
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
#define PI  acos(-1.0)
typedef long long ll;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

#define BIN__N(x) (x) | x>>3 | x>>6 | x>>9
#define BIN__B(x) (x) & 0xf | (x)>>12 & 0xf0
#define BIN8(v) (BIN__B(BIN__N(0x##v)))
//#define _CRT_SECURE_NO_WARNINGS

int main()
{
    int n, i;
    cin>>n;
    double x, y;
    pair<double, int> *ans = new pair<double, int>[n];
    forn(i,0,n)
    {
        cin>>x>>y;
        ans[i] = make_pair((/*x*/x/sqrt((x*x+y*y))/**((x>=0.)?1.:-1.)*/+1.)*((y>=0.)?1.:-1.),i+1);
    }

    sort(ans,ans+n);
    double mdelta = 10., delta;
    int ind = 0;
    forn(i,0,n-1)
    {
        delta = ans[i+1].first - ans[i].first;
        if(delta<mdelta){ mdelta = delta; ind = i;}
    }
    delta = ans[0].first+4. - ans[n-1].first;
    if(delta<mdelta){ mdelta = delta; ind = n-1;}

    cout<<ans[ind].second<<" "<<ans[(ind+1)%n].second<<endl;

    return 0;
}


//////// Kelvin 2015
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
#define PI  acos(-1.0)
typedef long long ll;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

#define BIN__N(x) (x) | x>>3 | x>>6 | x>>9
#define BIN__B(x) (x) & 0xf | (x)>>12 & 0xf0
#define BIN8(v) (BIN__B(BIN__N(0x##v)))
//#define _CRT_SECURE_NO_WARNINGS

int main()
{
    int n, i;
    cin>>n;
    double x, y;
    pair<double, int> *ans = new pair<double, int>[n];
    forn(i,0,n)
    {
        cin>>x>>y;
        ans[i] = make_pair((x*x/(x*x+y*y)*((x>=0.)?1.:-1.)+1.)*((y>=0.)?1.:-1.)),i+1);
    }

    sort(ans,ans+n);
    double mdelta = 10., delta;
    int ind = 0;
    forn(i,0,n-1)
    {
        delta = ans[i+1].first - ans[i].first;
        if(delta<mdelta){ mdelta = delta; ind = i;}
    }
    delta = ans[0].first+4. - ans[n-1].first;
    if(delta<mdelta){ mdelta = delta; ind = n-1;}

    cout<<ans[ind].second<<" "<<ans[(ind+1)%n].second<<endl;

    return 0;
}


//////// Kelvin 2016
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <complex>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
const double PI = (acos(-1.0));
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

struct Point
{
	ll x, y;
	int i, j;
	Point(ll ix = 0, ll iy = 0):x(ix),y(iy) {}

	ll dot(const Point &a, const Point &b) //|a||b|cosθ // 0 90 180 270 360 //y
	{													// 1  0  -1  0  1
		return a.x*b.x + a.y*b.y;
	}
	ll cross(const Point &a, const Point &b)  //-|a||b|sinθ // 0 90 180 270 360 //x
	{														// 0  1  0  -1  0
		return a.x*b.y - b.x*a.y;
	}

	Point& operator = (const Point &b)
	{
		x = b.x;
		y = b.y;
		i = b.i;
		j = b.j;
		return *this;
	}
	Point& operator -= (const Point &b)
	{
		x -= b.x;
		y -= b.y;
		return *this;
	}
	Point& operator += (const Point &b)
	{
		x += b.x;
		y += b.y;
		return *this;
	}
	Point& operator *= (const Point &b)
	{
		x = cross(b, *this);
		y = dot(*this, b);
		j = b.i;
		return *this;
	}
	bool operator < (const Point &b)
	{
		bool ka=   y>0 ||   y==0 &&   x>=0;
		bool kb= b.y>0 || b.y==0 && b.x>=0;
		return ka > kb || ka==kb && cross(b, *this)>0;
	}
	Point operator - (const Point &b){ Point res = *this; res -= b; return res; }
	Point operator + (const Point &b){ Point res = *this; res += b; return res; }
	Point operator * (const Point &b){ Point res = *this; res *= b; return res; }
};

int main()
{
	int n, i, j;
	cin>>n;
	Point *p = new Point[n+1];
	forn(i,0,n)
	{
		cin>>p[i].x>>p[i].y;
		p[i].i = i+1;
	}
	sort(p, p+n);
	p[n] = p[0];
	forn(i,0,n)
	{
		p[i] *= p[i+1];
	}
	j = 0;
	forn(i,1,n)
	{
		if(p[i] < p[j]) j = i;
	}
	cout<<p[j].i<<" "<<p[j].j<<endl;
	return 0;
}


//////// Kelvin 2016
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <complex>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
const double PI = (acos(-1.0));
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

struct Point
{
	ll x, y;
	int i, j;
	Point(ll ix = 0, ll iy = 0):x(ix),y(iy) {}

	Point& operator = (const Point &b)
	{
		x = b.x;
		y = b.y;
		i = b.i;
		j = b.j;
		return *this;
	}
	Point& operator -= (const Point &b)
	{
		x -= b.x;
		y -= b.y;
		return *this;
	}
	Point& operator += (const Point &b)
	{
		x += b.x;
		y += b.y;
		return *this;
	}
	Point& operator *= (const Point &b)
	{
		ll tx;
		tx= b.x * y - x * b.y;
		y = b.x * x + y * b.y;
		x = abs(tx);
		j = b.i;
		return *this;
	}
	bool operator < (const Point &b)
	{
		return x*b.y < b.x*y;
	}
	Point operator - (const Point &b){ Point res = *this; res -= b; return res; }
	Point operator + (const Point &b){ Point res = *this; res += b; return res; }
	Point operator * (const Point &b){ Point res = *this; res *= b; return res; }
};

ll scalar(Point a, Point b) //|a||b|cosθ // 0 90 180 270 360 //y
{										 // 1  0  -1  0  1
	return a.x*b.x + a.y*b.y;
}
ll skew(Point a, Point b)  // -|a||b|sinθ // 0 90 180 270 360 //x
{										    // 0  1  0  -1  0
	return a.x*b.y - b.x*a.y;
}
ll length2(Point a)
{
	return a.x * a.x + a.y * a.y;
}

int main()
{
	int n, i, j;
	cin>>n;
	Point *p = new Point[n+1];
	forn(i,0,n)
	{
		cin>>p[i].x>>p[i].y;
		p[i].i = i+1;
	}
	sort(p, p+n);
	p[n] = p[0];
	forn(i,0,n)
	{
		p[i] *= p[i+1];
	}
	j = 0;
	forn(i,1,n)
	{
		if(p[i] < p[j]) j = i;
	}
	cout<<p[j].i<<" "<<p[j].j<<endl;
	return 0;
}


//////// Kelvin 2015
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
#define PI  acos(-1.0)
typedef long long ll;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

#define BIN__N(x) (x) | x>>3 | x>>6 | x>>9
#define BIN__B(x) (x) & 0xf | (x)>>12 & 0xf0
#define BIN8(v) (BIN__B(BIN__N(0x##v)))
//#define _CRT_SECURE_NO_WARNINGS

int main()
{
    int n, i;
    cin>>n;
    int x, y;
    pair<double, int> *ans = new pair<double, int>[n];
    forn(i,0,n)
    {
        cin>>x>>y;
        ans[i] = make_pair(((x*x*((x>=0)?1.:-1.)/((double)(x*x+y*y))+1.)*((y>=0)?1.:-1.)),i+1);
    }

    sort(ans,ans+n);
    double mdelta = 10., delta;
    int ind = 0;
    forn(i,0,n-1)
    {
        delta = ans[i+1].first - ans[i].first;
        if(delta<mdelta){ mdelta = delta; ind = i;}
    }
    delta = ans[0].first+4. - ans[n-1].first;
    if(delta<mdelta){ mdelta = delta; ind = n-1;}

    cout<<ans[ind].second<<" "<<ans[(ind+1)%n].second<<endl;

    return 0;
}


//////// Kelvin 2015
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
#define PI  (acos(-1.0))
typedef long long ll;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

#define BIN__N(x) (x) | x>>3 | x>>6 | x>>9
#define BIN__B(x) (x) & 0xf | (x)>>12 & 0xf0
#define BIN8(v) (BIN__B(BIN__N(0x##v)))
//#define _CRT_SECURE_NO_WARNINGS

int const N = 1e5+1;

int iX[N], iY[N], id[N];

int getFourth (int x, int y) {
    if (x >= 0)
    {
        return y >= 0 ? 1 : 2;
    }
    else
    {
        return y < 0 ? 3 : 4;
    }
}

int comparer(int i, int j)
{
    int c = getFourth(iX[i], iY[i]) - getFourth(iX[j], iY[j]);
    if (c != 0) return c > 0;
    return iX[i] * iY[j] > iX[j] * iY[i];
}

int main() {
    int n, it;
    cin>>n;

    forn(it,0,n)
    {
        cin>>iX[it]>>iY[it];
        id[it] = it;
    }

    sort(id, id + n, comparer);

    ll best = 1e18;
    ll zeBest = 1;
    int ansi = -1;
    int ansj = -1;
    for (it = 0; it < n; it++)
    {
        int i = id[it];
        int j = id[(it + 1) % n];
        ll nBe = abs(iX[i] * iY[j] - iX[j] * iY[i]);
        nBe *= nBe;
        ll nZeBe = 1;
        nZeBe *= (iX[i] * iX[i] + iY[i] * iY[i]);
        nZeBe *= (iX[j] * iX[j] + iY[j] * iY[j]);

        if (best*nZeBe > nBe*zeBest)
        {
            ansi = i;
            ansj = j;
            best = nBe;
            zeBest = nZeBe;
        }
    }

    cout<< ansi + 1<<" "<< ansj + 1<<endl;

    return 0;
}


//////// Kelvin 2015
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
#define PI  (acos(-1.0))
typedef long long ll;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

#define BIN__N(x) (x) | x>>3 | x>>6 | x>>9
#define BIN__B(x) (x) & 0xf | (x)>>12 & 0xf0
#define BIN8(v) (BIN__B(BIN__N(0x##v)))
//#define _CRT_SECURE_NO_WARNINGS

int const N = 1e5+1;

int iX[N], iY[N], id[N];

int getFourth (int x, int y) {
    if (x >= 0)
    {
        return y >= 0 ? 1 : 2;
    }
    else
    {
        return y < 0 ? 3 : 4;
    }
}

int comparer(int i, int j)
{
    int c = getFourth(iX[i], iY[i]) - getFourth(iX[j], iY[j]);
    if (c != 0) return c > 0;
    return iX[i] * iY[j] > iX[j] * iY[i];
}

//
//
//void diff(ull2 &a, ull2 &b)
//{
//  a.val[0] -= b.val[0];
//  if(a.val[1]<b.val[1])
//  {
//      a.val[1] =  ~(0ull) - b.val[1] + a.val[1] + 1;
//      a.val[0]--;
//  }
//  else
//  {
//      a.val[1] -= b.val[1];
//  }
//}
//
//
//
//void shr(ull2 &b)
//{
//  b.val[1] >>= 1;
//  b.val[1] |= b.val[0]<<63;
//  b.val[0] >>= 1;
//}

struct ull2
{
    ull2()
    {
        val[0] = 0;
        val[1] = 0;
    }
    bool any()
    {
        return val[0] || val[1];
    }
    unsigned long long val[2];
};

bool cmp(ull2 &a, ull2 &b)
{
    return (a.val[0]>b.val[0] || a.val[0]==b.val[0] && a.val[1]>=b.val[1]);
}

void summ(ull2 &a, ull2 &b)
{
    if(a.val[1] + b.val[1] < a.val[1] || a.val[1] + b.val[1] < b.val[1]) a.val[0]++;
    a.val[1] += b.val[1];
    a.val[0] += b.val[0];
}

void shl(ull2 &b)
{
    b.val[0] <<= 1;
    b.val[0] |= b.val[1]>>63;
    b.val[1] <<= 1;
}

bool isLarger(ll a1, ll a2, ll b1, ll b2)
{
    ull2 bits[4];

    bits[1].val[1] = a1 & (~(1ll<<63));

    bits[3].val[1] = b1 & (~(1ll<<63));

    int i;
    forn(i,0,63)
    {
        if((1ll<<i)&a2)
        {
            summ(bits[0], bits[1]);
        }
        if((1ll<<i)&b2)
        {
            summ(bits[2], bits[3]);
        }
        shl(bits[1]);
        shl(bits[3]);
    }

    if(((a1>>63)^(a2>>63)) < ((b1>>63)^(b2>>63))) return true;

    if(((a1>>63)^(a2>>63))) return !cmp(bits[0], bits[2]);

    return cmp(bits[0], bits[2]);
}

int main() {
    int n, it;
    cin>>n;

    forn(it,0,n)
    {
        cin>>iX[it]>>iY[it];
        id[it] = it;
    }

    sort(id, id + n, comparer);

    ll best = 1e17;
    ll zeBest = 1;
    int ansi = 0;
    int ansj = 1;
    for (it = 0; it < n; it++)
    {
        int i = id[it];
        int j = id[(it + 1) % n];
        ll nBe = iX[i] * iY[j] - iX[j] * iY[i];
        nBe *= nBe;

        ll nZeBe = 1;
        nZeBe *= (iX[i] * iX[i] + iY[i] * iY[i]);
        nZeBe *= (iX[j] * iX[j] + iY[j] * iY[j]);

        int nCos = iX[i] * iX[j] + iY[j] * iY[i];
        if(nCos < 0) nBe = nZeBe*4 - nBe;

        if (isLarger(best, nZeBe, nBe, zeBest))
        {
            ansi = i;
            ansj = j;
            best = nBe;
            zeBest = nZeBe;
        }
    }

    cout<< ansi + 1<<" "<< ansj + 1<<endl;

    return 0;
}


//////// Kelvin 2016
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <complex>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
const double PI = (acos(-1.0));
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

struct Point
{
	ll x, y;
	int i, j;
	Point(ll ix = 0, ll iy = 0):x(ix),y(iy) {}

	Point& operator = (const Point &b)
	{
		x = b.x;
		y = b.y;
		i = b.i;
		j = b.j;
		return *this;
	}
	Point& operator -= (const Point &b)
	{
		x -= b.x;
		y -= b.y;
		return *this;
	}
	Point& operator += (const Point &b)
	{
		x += b.x;
		y += b.y;
		return *this;
	}
	Point& operator *= (const Point &b)
	{
		ll tx;
		tx= x * b.y - y * b.x;
		y = x * b.x + y * b.y;
		x = abs(tx);
		j = b.i;
		return *this;
	}
	bool operator < (const Point &b)
	{
		return y>0 && b.y<=0 || y>0 == b.y>0 && x*b.y < y*b.x;
	}
	Point operator - (const Point &b){ Point res = *this; res -= b; return res; }
	Point operator + (const Point &b){ Point res = *this; res += b; return res; }
	Point operator * (const Point &b){ Point res = *this; res *= b; return res; }
};

ll dot(Point &a, Point &b) //|a||b|cosθ // 0 90 180 270 360 //y
{										 // 1  0  -1  0  1
	return a.x*b.x + a.y*b.y;
}
ll cross(Point &a, Point &b)  // -|a||b|sinθ // 0 90 180 270 360 //x
{										    // 0  1  0  -1  0
	return a.x*b.y - b.x*a.y;
}
ll length2(Point a)
{
	return a.x * a.x + a.y * a.y;
}

int main()
{
	int n, i, j;
	cin>>n;
	Point *p = new Point[n+1];
	forn(i,0,n)
	{
		cin>>p[i].x>>p[i].y;
		p[i].i = i+1;
	}
	sort(p, p+n);
	p[n] = p[0];
	forn(i,0,n)
	{
		p[i] *= p[i+1];
	}
	j = 0;
	forn(i,1,n)
	{
		if(p[i] < p[j]) j = i;
	}
	cout<<p[j].i<<" "<<p[j].j<<endl;
	return 0;
}


//////// Kelvin 2016
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <complex>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
const double PI = (acos(-1.0));
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

struct Point
{
	int x, y;
	int i;
	Point(ll ix = 0, ll iy = 0):x(ix),y(iy) {}

	ll dot(const Point &a, const Point &b) //|a||b|cosθ // 0 90 180 270 360 //y
	{													// 1  0  -1  0  1
		return a.x*b.x + a.y*b.y;
	}
	ll cross(const Point &a, const Point &b)  //-|a||b|sinθ // 0 90 180 270 360 //x
	{														// 0  1  0  -1  0
		return a.x*1ll*b.y - b.x*1ll*a.y;
	}

	Point& operator = (const Point &b)
	{
		x = b.x;
		y = b.y;
		i = b.i;
		return *this;
	}
	Point& operator -= (const Point &b)
	{
		x -= b.x;
		y -= b.y;
		return *this;
	}
	Point& operator += (const Point &b)
	{
		x += b.x;
		y += b.y;
		return *this;
	}
	Point& operator *= (const Point &b)
	{
		ll tx = cross(b, *this);
		y = dot(*this, b);
		x = abs(tx);
		return *this;
	}
	bool operator < (const Point &b)
	{
		bool ka=   y>0 ||   y==0 &&   x>=0;
		bool kb= b.y>0 || b.y==0 && b.x>=0;
		return ka > kb || ka==kb && cross(b, *this)>0;
	}
	Point operator - (const Point &b){ Point res = *this; res -= b; return res; }
	Point operator + (const Point &b){ Point res = *this; res += b; return res; }
	Point operator * (const Point &b){ Point res = *this; res *= b; return res; }
};

int main()
{
	ios::sync_with_stdio(false);
	int n, i, j;
	cin>>n;
	Point *p = new Point[n+1];
	forn(i,0,n)
	{
		cin>>p[i].x>>p[i].y;
		p[i].i = i+1;
	}
	sort(p, p+n);
	p[n] = p[0];
	forn(i,0,n)
	{
		p[i] *= p[i+1];
	}
	j = 0;
	forn(i,1,n)
	{
		if(p[i] < p[j]) j = i;
	}
	cout<<p[j].i<<" "<<p[j+1].i<<endl;
	return 0;
}


//////// Kelvin 2015
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
#define PI  (acos(-1.0))
typedef long long ll;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

#define BIN__N(x) (x) | x>>3 | x>>6 | x>>9
#define BIN__B(x) (x) & 0xf | (x)>>12 & 0xf0
#define BIN8(v) (BIN__B(BIN__N(0x##v)))
//#define _CRT_SECURE_NO_WARNINGS

int const N = 1e5+1;

int iX[N], iY[N], id[N];

int getFourth (int x, int y) {
    if (x >= 0)
    {
        return y >= 0 ? 1 : 2;
    }
    else
    {
        return y < 0 ? 3 : 4;
    }
}

int comparer(int i, int j)
{
    int c = getFourth(iX[i], iY[i]) - getFourth(iX[j], iY[j]);
    if (c != 0) return c > 0;
    return iX[i] * iY[j] > iX[j] * iY[i];
}

//
//
//void diff(ull2 &a, ull2 &b)
//{
//  a.val[0] -= b.val[0];
//  if(a.val[1]<b.val[1])
//  {
//      a.val[1] =  ~(0ull) - b.val[1] + a.val[1] + 1;
//      a.val[0]--;
//  }
//  else
//  {
//      a.val[1] -= b.val[1];
//  }
//}
//
//
//
//void shr(ull2 &b)
//{
//  b.val[1] >>= 1;
//  b.val[1] |= b.val[0]<<63;
//  b.val[0] >>= 1;
//}

struct ull2
{
    ull2()
    {
        val[0] = 0;
        val[1] = 0;
    }
    bool any()
    {
        return val[0] || val[1];
    }
    unsigned long long val[2];
};

bool cmp(ull2 &a, ull2 &b)
{
    return (a.val[0]>b.val[0] || a.val[0]==b.val[0] && a.val[1]>=b.val[1]);
}

void summ(ull2 &a, ull2 &b)
{
    if(a.val[1] + b.val[1] < a.val[1] || a.val[1] + b.val[1] < b.val[1]) a.val[0]++;
    a.val[1] += b.val[1];
    a.val[0] += b.val[0];
}

void shl(ull2 &b)
{
    b.val[0] <<= 1;
    b.val[0] |= b.val[1]>>63;
    b.val[1] <<= 1;
}

bool isLarger(ll a1, ll a2, ll b1, ll b2)
{
    ull2 bits[4];
    bits[0].val[1] = a1 & (~(1ll<<63));
    bits[1].val[1] = a1 & (~(1ll<<63));
    bits[2].val[1] = b1 & (~(1ll<<63));
    bits[3].val[1] = b1 & (~(1ll<<63));

    int i;
    forn(i,0,64)
    {
        if((1ll<<i)&a2)
        {
            summ(bits[0], bits[1]);
        }
        if((1ll<<i)&b2)
        {
            summ(bits[2], bits[3]);
        }
        shl(bits[1]);
        shl(bits[3]);
    }

    if(((a1>>63)^(a2>>63)) < ((b1>>63)^(b2>>63))) return true;

    if(((a1>>63)^(a2>>63))) return !cmp(bits[0], bits[2]);

    return cmp(bits[0], bits[2]);
}

int main() {
    int n, it;
    cin>>n;

    forn(it,0,n)
    {
        cin>>iX[it]>>iY[it];
        id[it] = it;
    }

    sort(id, id + n, comparer);

    ll best = 1e17;
    ll zeBest = 1;
    int ansi = 0;
    int ansj = 1;
    for (it = 0; it < n; it++)
    {
        int i = id[it];
        int j = id[(it + 1) % n];
        ll nBe = iX[i] * iY[j] - iX[j] * iY[i];
        nBe *= nBe;

        ll nZeBe = 1;
        nZeBe *= (iX[i] * iX[i] + iY[i] * iY[i]);
        nZeBe *= (iX[j] * iX[j] + iY[j] * iY[j]);

        int nCos = iX[i] * iX[j] + iY[j] * iY[i];
        if(nCos < 0) nBe = nZeBe*4 - nBe;

        if (isLarger(best, nZeBe, nBe, zeBest))
        {
            ansi = i;
            ansj = j;
            best = nBe;
            zeBest = nZeBe;
        }
    }

    cout<< ansi + 1<<" "<< ansj + 1<<endl;

    return 0;
}


//////// Kelvin 2016
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <complex>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
const double PI = (acos(-1.0));
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

struct Point
{
	ll x, y;
	int i, j;
	Point(ll ix = 0, ll iy = 0):x(ix),y(iy) {}

	ll dot(const Point &a, const Point &b) //|a||b|cosθ // 0 90 180 270 360 //y
	{													// 1  0  -1  0  1
		return a.x*b.x + a.y*b.y;
	}
	ll cross(const Point &a, const Point &b)  //-|a||b|sinθ // 0 90 180 270 360 //x
	{														// 0  1  0  -1  0
		return a.x*b.y - b.x*a.y;
	}

	Point& operator = (const Point &b)
	{
		x = b.x;
		y = b.y;
		i = b.i;
		j = b.j;
		return *this;
	}
	Point& operator -= (const Point &b)
	{
		x -= b.x;
		y -= b.y;
		return *this;
	}
	Point& operator += (const Point &b)
	{
		x += b.x;
		y += b.y;
		return *this;
	}
	Point& operator *= (const Point &b)
	{
		ll tx = cross(b, *this);
		y = dot(*this, b);
		x = abs(tx);
		j = b.i;
		return *this;
	}
	bool operator < (const Point &b)
	{
		bool ka=   y>0 ||   y==0 &&   x>=0;
		bool kb= b.y>0 || b.y==0 && b.x>=0;
		return ka > kb || ka==kb && cross(b, *this)>0;
	}
	Point operator - (const Point &b){ Point res = *this; res -= b; return res; }
	Point operator + (const Point &b){ Point res = *this; res += b; return res; }
	Point operator * (const Point &b){ Point res = *this; res *= b; return res; }
};

int main()
{
	int n, i, j;
	cin>>n;
	Point *p = new Point[n+1];
	forn(i,0,n)
	{
		cin>>p[i].x>>p[i].y;
		p[i].i = i+1;
	}
	sort(p, p+n);
	p[n] = p[0];
	forn(i,0,n)
	{
		p[i] *= p[i+1];
	}
	j = 0;
	forn(i,1,n)
	{
		if(p[i] < p[j]) j = i;
	}
	cout<<p[j].i<<" "<<p[j].j<<endl;
	return 0;
}


//////// Kelvin 2015
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
#define PI  (acos(-1.0))
typedef long long ll;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

#define BIN__N(x) (x) | x>>3 | x>>6 | x>>9
#define BIN__B(x) (x) & 0xf | (x)>>12 & 0xf0
#define BIN8(v) (BIN__B(BIN__N(0x##v)))
//#define _CRT_SECURE_NO_WARNINGS

int const N = 1e5+1;

int iX[N], iY[N], id[N];

int getFourth (int x, int y) {
    if (x >= 0)
    {
        return y >= 0 ? 1 : 2;
    }
    else
    {
        return y < 0 ? 3 : 4;
    }
}

int comparer(int i, int j)
{
    int c = getFourth(iX[i], iY[i]) - getFourth(iX[j], iY[j]);
    if (c != 0) return c > 0;
    return iX[i] * iY[j] > iX[j] * iY[i];
}

int main() {
    int n, it;
    cin>>n;

    forn(it,0,n)
    {
        cin>>iX[it]>>iY[it];
        id[it] = it;
    }

    sort(id, id + n, comparer);

    ll best = 1e16;
    ll zeBest = 1;
    int ansi = 0;
    int ansj = 1;
    for (it = 0; it < n; it++)
    {
        int i = id[it];
        int j = id[(it + 1) % n];
        if(it == n-1) swap(i,j);
        ll nBe = iX[i] * iX[j] + iY[i] * iY[j];
        nBe *= -abs(nBe);

        ll nZeBe = 1;
        nZeBe *= (iX[i] * iX[i] + iY[i] * iY[i]);
        nZeBe *= (iX[j] * iX[j] + iY[j] * iY[j]);

        if (best*1.*nZeBe > nBe*1.*zeBest)
        {
            ansi = i;
            ansj = j;
            best = nBe;
            zeBest = nZeBe;
        }
    }

    cout<< ansi + 1<<" "<< ansj + 1<<endl;

    return 0;
}


//////// Kelvin 2015
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
#define PI  (acos(-1.0))
typedef long long ll;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

#define BIN__N(x) (x) | x>>3 | x>>6 | x>>9
#define BIN__B(x) (x) & 0xf | (x)>>12 & 0xf0
#define BIN8(v) (BIN__B(BIN__N(0x##v)))
//#define _CRT_SECURE_NO_WARNINGS

int const N = 1e5+1;

int iX[N], iY[N], id[N];

int getFourth (int x, int y) {
    if (x >= 0)
    {
        return y >= 0 ? 1 : 2;
    }
    else
    {
        return y < 0 ? 3 : 4;
    }
}

int comparer(int i, int j)
{
    int c = getFourth(iX[i], iY[i]) - getFourth(iX[j], iY[j]);
    if (c != 0) return c > 0;
    return iX[i] * iY[j] > iX[j] * iY[i];
}

int main() {
    int n, it;
    cin>>n;

    forn(it,0,n)
    {
        cin>>iX[it]>>iY[it];
        id[it] = it;
    }

    sort(id, id + n, comparer);

    ll best = 1e16;
    ll zeBest = 1;
    int ansi = 0;
    int ansj = 1;
    for (it = 0; it < n; it++)
    {
        int i = id[it];
        int j = id[(it + 1) % n];

        ll nBe = iX[i] * iX[j] + iY[i] * iY[j];
        nBe *= nBe>0ll?-nBe:nBe;

        ll nZeBe = 1;
        nZeBe *= (iX[i] * iX[i] + iY[i] * iY[i]);
        nZeBe *= (iX[j] * iX[j] + iY[j] * iY[j]);

        if (best*1.*nZeBe > nBe*1.*zeBest)
        {
            ansi = i;
            ansj = j;
            best = nBe;
            zeBest = nZeBe;
        }
    }

    cout<< ansi + 1<<" "<< ansj + 1<<endl;

    return 0;
}


//////// Kelvin 2015
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
#define PI  (acos(-1.0))
typedef long long ll;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

#define BIN__N(x) (x) | x>>3 | x>>6 | x>>9
#define BIN__B(x) (x) & 0xf | (x)>>12 & 0xf0
#define BIN8(v) (BIN__B(BIN__N(0x##v)))
//#define _CRT_SECURE_NO_WARNINGS

int const N = 1e5+1;

int iX[N], iY[N], id[N];

int getFourth (int x, int y) {
    if (x >= 0)
    {
        return y >= 0 ? 1 : 2;
    }
    else
    {
        return y < 0 ? 3 : 4;
    }
}

int comparer(int i, int j)
{
    int c = getFourth(iX[i], iY[i]) - getFourth(iX[j], iY[j]);
    if (c != 0) return c > 0;
    return iX[i] * iY[j] > iX[j] * iY[i];
}

int main() {
    int n, it;
    cin>>n;

    forn(it,0,n)
    {
        cin>>iX[it]>>iY[it];
        id[it] = it;
    }

    sort(id, id + n, comparer);

    ll best = 1e16;
    ll zeBest = 1;
    int ansi = 0;
    int ansj = 1;
    for (it = 0; it < n; it++)
    {
        int i = id[it];
        int j = id[(it + 1) % n];
        ll nBe = iX[i] * iY[j] - iX[j] * iY[i];
        nBe *= nBe;

        ll nZeBe = 1;
        nZeBe *= (iX[i] * iX[i] + iY[i] * iY[i]);
        nZeBe *= (iX[j] * iX[j] + iY[j] * iY[j]);

        if (best*1.*nZeBe > nBe*1.*zeBest)
        {
            ansi = i;
            ansj = j;
            best = nBe;
            zeBest = nZeBe;
        }
    }

    cout<< ansi + 1<<" "<< ansj + 1<<endl;

    return 0;
}


//////// Kelvin 2015
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
#define PI  acos(-1.0)
typedef long long ll;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

#define BIN__N(x) (x) | x>>3 | x>>6 | x>>9
#define BIN__B(x) (x) & 0xf | (x)>>12 & 0xf0
#define BIN8(v) (BIN__B(BIN__N(0x##v)))
//#define _CRT_SECURE_NO_WARNINGS

int main()
{
    int n, i;
    cin>>n;
    int x, y;
    pair<double, int> *ans = new pair<double, int>[n];
    forn(i,0,n)
    {
        cin>>x>>y;
        ans[i] = make_pair(((x*x*((x>=0)?1:-1)/((double)(x*x+y*y))-1.)*((y>=0)?1.:-1.)),i+1);
    }

    sort(ans,ans+n);
    double mdelta = 10., delta;
    int ind = 0;
    forn(i,0,n-1)
    {
        delta = ans[i+1].first - ans[i].first;
        if(delta<mdelta){ mdelta = delta; ind = i;}
    }
    delta = ans[0].first+4. - ans[n-1].first;
    if(delta<mdelta){ mdelta = delta; ind = n-1;}

    cout<<ans[ind].second<<" "<<ans[(ind+1)%n].second<<endl;

    return 0;
}


//////// Kelvin 2016
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <complex>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
const double PI = (acos(-1.0));
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

struct Point
{
	ll x, y;
	int i, j;
	Point(ll ix = 0, ll iy = 0):x(ix),y(iy) {}

	Point& operator = (const Point &b)
	{
		x = b.x;
		y = b.y;
		i = b.i;
		j = b.j;
		return *this;
	}
	Point& operator -= (const Point &b)
	{
		x -= b.x;
		y -= b.y;
		return *this;
	}
	Point& operator += (const Point &b)
	{
		x += b.x;
		y += b.y;
		return *this;
	}
	Point& operator *= (const Point &b)
	{
		ll tx;
		tx= x * b.y - y * b.x;
		y = x * b.x + y * b.y;
		x = abs(tx);
		j = b.i;
		return *this;
	}
	bool operator < (const Point &b)
	{
		bool ka=   y>0 ||   y==0 &&   x>=0;
		bool kb= b.y>0 || b.y==0 && b.x>=0;
		return ka < kb || ka==kb && x*b.y < y*b.x;
	}
	Point operator - (const Point &b){ Point res = *this; res -= b; return res; }
	Point operator + (const Point &b){ Point res = *this; res += b; return res; }
	Point operator * (const Point &b){ Point res = *this; res *= b; return res; }
};

/* void set_kv(){ // must be called before <
   if(y > 0 || y == 0 && x >= 0) kv = 0;
   else kv = 1;
               }
  bool operator==(const pointC& w) const{
   return x == w.x && y == w.y;
                                        }
  bool operator<(const pointC& w) const{
   if(kv != w.kv) return kv < w.kv;
   return vp(*this , w) > 0;*/

ll dot(Point &a, Point &b) //|a||b|cosθ // 0 90 180 270 360 //y
{										 // 1  0  -1  0  1
	return a.x*b.x + a.y*b.y;
}
ll cross(Point &a, Point &b)  // -|a||b|sinθ // 0 90 180 270 360 //x
{										    // 0  1  0  -1  0
	return a.x*b.y - b.x*a.y;
}
ll length2(Point a)
{
	return a.x * a.x + a.y * a.y;
}

int main()
{
	int n, i, j;
	cin>>n;
	Point *p = new Point[n+1];
	forn(i,0,n)
	{
		cin>>p[i].x>>p[i].y;
		p[i].i = i+1;
	}
	sort(p, p+n);
	p[n] = p[0];
	forn(i,0,n)
	{
		p[i] *= p[i+1];
	}
	j = 0;
	forn(i,1,n)
	{
		if(p[i] < p[j]) j = i;
	}
	cout<<p[j].i<<" "<<p[j].j<<endl;
	return 0;
}


//////// Kelvin 2016
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <complex>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
const double PI = (acos(-1.0));
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

struct Point
{
	ll x, y;
	int i, j;
	Point(ll ix = 0, ll iy = 0):x(ix),y(iy) {}

	Point& operator = (const Point &b)
	{
		x = b.x;
		y = b.y;
		i = b.i;
		j = b.j;
		return *this;
	}
	Point& operator -= (const Point &b)
	{
		x -= b.x;
		y -= b.y;
		return *this;
	}
	Point& operator += (const Point &b)
	{
		x += b.x;
		y += b.y;
		return *this;
	}
	Point& operator *= (const Point &b)
	{
		ll tx;
		tx= x * b.y - y * b.x;
		y = x * b.x + y * b.y;
		x = abs(tx);
		j = b.i;
		return *this;
	}
	bool operator < (const Point &b)
	{
		return y<0 != b.y<0 && y<0 || y<0 == b.y<0 && x*b.y < b.x*y;
	}
	Point operator - (const Point &b){ Point res = *this; res -= b; return res; }
	Point operator + (const Point &b){ Point res = *this; res += b; return res; }
	Point operator * (const Point &b){ Point res = *this; res *= b; return res; }
};

ll dot(Point &a, Point &b) //|a||b|cosθ // 0 90 180 270 360 //y
{										 // 1  0  -1  0  1
	return a.x*b.x + a.y*b.y;
}
ll cross(Point &a, Point &b)  // -|a||b|sinθ // 0 90 180 270 360 //x
{										    // 0  1  0  -1  0
	return a.x*b.y - b.x*a.y;
}
ll length2(Point a)
{
	return a.x * a.x + a.y * a.y;
}

int main()
{
	int n, i, j;
	cin>>n;
	Point *p = new Point[n+1];
	forn(i,0,n)
	{
		cin>>p[i].x>>p[i].y;
		p[i].i = i+1;
	}
	sort(p, p+n);
	p[n] = p[0];
	forn(i,0,n)
	{
		p[i] *= p[i+1];
	}
	j = 0;
	forn(i,1,n)
	{
		if(p[i] < p[j]) j = i;
	}
	cout<<p[j].i<<" "<<p[j].j<<endl;
	return 0;
}


//////// Kelvin 2016
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <complex>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
const double PI = (acos(-1.0));
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

struct Point
{
	int x, y;
	int i;
	Point(ll ix = 0, ll iy = 0):x(ix),y(iy) {}

	ll dot(const Point &a, const Point &b) //|a||b|cosθ // 0 90 180 270 360 //y
	{													// 1  0  -1  0  1
		return a.x*1ll*b.x + a.y*1ll*b.y;
	}
	ll cross(const Point &a, const Point &b)  //-|a||b|sinθ // 0 90 180 270 360 //x
	{														// 0  1  0  -1  0
		return a.x*1ll*b.y - b.x*1ll*a.y;
	}

	Point& operator = (const Point &b)
	{
		x = b.x;
		y = b.y;
		i = b.i;
		return *this;
	}
	Point& operator -= (const Point &b)
	{
		x -= b.x;
		y -= b.y;
		return *this;
	}
	Point& operator += (const Point &b)
	{
		x += b.x;
		y += b.y;
		return *this;
	}
	Point& operator *= (const Point &b)
	{
		ll tx = cross(b, *this);
		y = dot(*this, b);
		x = abs(tx);
		return *this;
	}
	bool operator < (const Point &b)
	{
		bool ka=   y>0 ||   y==0 &&   x>=0;
		bool kb= b.y>0 || b.y==0 && b.x>=0;
		return ka > kb || ka==kb && cross(b, *this)>0;
	}
	Point operator - (const Point &b){ Point res = *this; res -= b; return res; }
	Point operator + (const Point &b){ Point res = *this; res += b; return res; }
	Point operator * (const Point &b){ Point res = *this; res *= b; return res; }
};

int main()
{
	ios::sync_with_stdio(false);
	int n, i, j;
	cin>>n;
	Point **p = new Point*[n+1];
	forn(i,0,n)
	{
		int x, y;
		cin>>x>>y;
		p[i] = new Point(x, y);
		p[i]->i = i+1;
	}
	sort(p, p+n, [](Point *a, Point *b){return *a < *b;});
	p[n] = new Point(p[0]->x, p[0]->y); p[n]->i = p[0]->i;
	forn(i,0,n)
	{
		*p[i] *= *p[i+1];
	}
	j = 0;
	forn(i,1,n)
	{
		if(*p[i] < *p[j]) j = i;
	}
	cout<<p[j]->i<<" "<<p[j+1]->i<<endl;
	return 0;
}


//////// Kelvin 2016
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <complex>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
const double PI = (acos(-1.0));
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

struct Point
{
	ll x, y;
	int i, j;
	Point(ll ix = 0, ll iy = 0):x(ix),y(iy) {}

	ll dot(const Point &a, const Point &b) //|a||b|cosθ // 0 90 180 270 360 //y
	{													// 1  0  -1  0  1
		return a.x*b.x + a.y*b.y;
	}
	ll cross(const Point &a, const Point &b)  //-|a||b|sinθ // 0 90 180 270 360 //x
	{														// 0  1  0  -1  0
		return a.x*b.y - b.x*a.y;
	}

	Point& operator = (const Point &b)
	{
		x = b.x;
		y = b.y;
		i = b.i;
		j = b.j;
		return *this;
	}
	Point& operator -= (const Point &b)
	{
		x -= b.x;
		y -= b.y;
		return *this;
	}
	Point& operator += (const Point &b)
	{
		x += b.x;
		y += b.y;
		return *this;
	}
	Point& operator *= (const Point &b)
	{
		ll tx = cross(b, *this);
		y = dot(*this, b);
		x = tx;
		j = b.i;
		return *this;
	}
	bool operator < (const Point &b)
	{
		bool ka=   y>0 ||   y==0 &&   x>=0;
		bool kb= b.y>0 || b.y==0 && b.x>=0;
		return ka > kb || ka==kb && cross(b, *this)>0;
	}
	Point operator - (const Point &b){ Point res = *this; res -= b; return res; }
	Point operator + (const Point &b){ Point res = *this; res += b; return res; }
	Point operator * (const Point &b){ Point res = *this; res *= b; return res; }
};

int main()
{
	int n, i, j;
	cin>>n;
	Point *p = new Point[n+1];
	forn(i,0,n)
	{
		cin>>p[i].x>>p[i].y;
		p[i].i = i+1;
	}
	sort(p, p+n);
	p[n] = p[0];
	forn(i,0,n)
	{
		p[i] *= p[i+1];
	}
	j = 0;
	forn(i,1,n)
	{
		if(p[i] < p[j]) j = i;
	}
	cout<<p[j].i<<" "<<p[j].j<<endl;
	return 0;
}


//////// Kelvin 2016
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <complex>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
const double PI = (acos(-1.0));
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

struct Point
{
	ll x, y;
	int i, j;
	Point(ll ix = 0, ll iy = 0):x(ix),y(iy) {}

	Point& operator = (const Point &b)
	{
		x = b.x;
		y = b.y;
		i = b.i;
		j = b.j;
		return *this;
	}
	Point& operator -= (const Point &b)
	{
		x -= b.x;
		y -= b.y;
		return *this;
	}
	Point& operator += (const Point &b)
	{
		x += b.x;
		y += b.y;
		return *this;
	}
	Point& operator *= (const Point &b)
	{
		ll tx;
		tx= x * b.y - y * b.x;
		y = x * b.x + y * b.y;
		x = abs(tx);
		j = b.i;
		return *this;
	}
	bool operator < (const Point &b)
	{
		bool ka=   y>0 ||   y==0 &&   x>=0;
		bool kb= b.y>0 || b.y==0 && b.x>=0;
		return ka > kb || ka==kb && x*b.y < y*b.x;
	}
	Point operator - (const Point &b){ Point res = *this; res -= b; return res; }
	Point operator + (const Point &b){ Point res = *this; res += b; return res; }
	Point operator * (const Point &b){ Point res = *this; res *= b; return res; }
};

/* void set_kv(){ // must be called before <
   if(y > 0 || y == 0 && x >= 0) kv = 0;
   else kv = 1;
               }
  bool operator==(const pointC& w) const{
   return x == w.x && y == w.y;
                                        }
  bool operator<(const pointC& w) const{
   if(kv != w.kv) return kv < w.kv;
   return vp(*this , w) > 0;*/

ll dot(Point &a, Point &b) //|a||b|cosθ // 0 90 180 270 360 //y
{										 // 1  0  -1  0  1
	return a.x*b.x + a.y*b.y;
}
ll cross(Point &a, Point &b)  // -|a||b|sinθ // 0 90 180 270 360 //x
{										    // 0  1  0  -1  0
	return a.x*b.y - b.x*a.y;
}
ll length2(Point a)
{
	return a.x * a.x + a.y * a.y;
}

int main()
{
	int n, i, j;
	cin>>n;
	Point *p = new Point[n+1];
	forn(i,0,n)
	{
		cin>>p[i].x>>p[i].y;
		p[i].i = i+1;
	}
	sort(p, p+n);
	p[n] = p[0];
	forn(i,0,n)
	{
		p[i] *= p[i+1];
	}
	j = 0;
	forn(i,1,n)
	{
		if(p[i] < p[j]) j = i;
	}
	cout<<p[j].i<<" "<<p[j].j<<endl;
	return 0;
}


//////// Kelvin 2015
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
#define PI  (acos(-1.0))
typedef long long ll;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

#define BIN__N(x) (x) | x>>3 | x>>6 | x>>9
#define BIN__B(x) (x) & 0xf | (x)>>12 & 0xf0
#define BIN8(v) (BIN__B(BIN__N(0x##v)))
//#define _CRT_SECURE_NO_WARNINGS

int const N = 1e5+1;

int iX[N], iY[N], id[N];

int getFourth (int x, int y) {
    if (x >= 0)
    {
        return y >= 0 ? 1 : 2;
    }
    else
    {
        return y < 0 ? 3 : 4;
    }
}

int comparer(int i, int j)
{
    int c = getFourth(iX[i], iY[i]) - getFourth(iX[j], iY[j]);
    if (c != 0) return c > 0;
    return iX[i] * iY[j] > iX[j] * iY[i];
}

int main() {
    int n, it;
    cin>>n;

    forn(it,0,n)
    {
        cin>>iX[it]>>iY[it];
        id[it] = it;
    }

    sort(id, id + n, comparer);

    ll best = 1e16+100;
    ll zeBest = 1;
    int ansi = 0;
    int ansj = 1;
    for (it = 0; it < n; it++)
    {
        int i = id[it];
        int j = id[(it + 1) % n];

        ll nBe = iX[i] * iX[j] + iY[i] * iY[j];
        //nBe *= nBe>0ll?-nBe:nBe;
        nBe*=-1;
        ll nZeBe = 1;
        nZeBe *= (iX[i] * iX[i] + iY[i] * iY[i]);
        nZeBe *= (iX[j] * iX[j] + iY[j] * iY[j]);

        if (best*1.*nZeBe > nBe*1.*zeBest)
        {
            ansi = i;
            ansj = j;
            best = nBe;
            zeBest = nZeBe;
        }
    }

    cout<< ansi + 1<<" "<< ansj + 1<<endl;

    return 0;
}


//////// Kelvin 2015
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
#define PI  (acos(-1.0))
typedef long long ll;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

#define BIN__N(x) (x) | x>>3 | x>>6 | x>>9
#define BIN__B(x) (x) & 0xf | (x)>>12 & 0xf0
#define BIN8(v) (BIN__B(BIN__N(0x##v)))
//#define _CRT_SECURE_NO_WARNINGS

int const N = 1e5+1;

int iX[N], iY[N], id[N];

int getFourth (int x, int y) {
    if (x >= 0)
    {
        return y >= 0 ? 1 : 2;
    }
    else
    {
        return y < 0 ? 3 : 4;
    }
}

int comparer(int i, int j)
{
    int c = getFourth(iX[i], iY[i]) - getFourth(iX[j], iY[j]);
    if (c != 0) return c > 0;
    return iX[i] * iY[j] > iX[j] * iY[i];
}

int main() {
    int n, it;
    cin>>n;

    forn(it,0,n)
    {
        cin>>iX[it]>>iY[it];
        id[it] = it;
    }

    sort(id, id + n, comparer);

    ll best = 1e17;
    ll zeBest = 1;
    int ansi = 0;
    int ansj = 1;
    for (it = 0; it < n; it++)
    {
        int i = id[it];
        int j = id[(it + 1) % n];
        ll nBe = iX[i] * iY[j] - iX[j] * iY[i];
        nBe *= nBe;

        ll nZeBe = 1;
        nZeBe *= (iX[i] * iX[i] + iY[i] * iY[i]);
        nZeBe *= (iX[j] * iX[j] + iY[j] * iY[j]);

        int nCos = iX[i] * iX[j] + iY[j] * iY[i];
        if(nCos < 0) nBe = nZeBe*4 - nBe;

        if (best*1.*nZeBe > nBe*1.*zeBest)
        {
            ansi = i;
            ansj = j;
            best = nBe;
            zeBest = nZeBe;
        }
    }

    cout<< ansi + 1<<" "<< ansj + 1<<endl;

    return 0;
}


//////// Kelvin 2016
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <complex>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
const double PI = (acos(-1.0));
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

struct Point
{
	ll x, y;
	int i, j;
	Point(ll ix = 0, ll iy = 0):x(ix),y(iy) {}

	Point& operator = (const Point &b)
	{
		x = b.x;
		y = b.y;
		i = b.i;
		j = b.j;
		return *this;
	}
	Point& operator -= (const Point &b)
	{
		x -= b.x;
		y -= b.y;
		return *this;
	}
	Point& operator += (const Point &b)
	{
		x += b.x;
		y += b.y;
		return *this;
	}
	Point& operator *= (const Point &b)
	{
		ll t = x;
		x = b.x * y - x * b.y;
		y = b.x * t + y * b.y;
		j = b.i;
		return *this;
	}
	bool operator < (const Point &b)
	{
		return x*b.y < b.x*y;
	}
	Point operator - (const Point &b){ Point res = *this; res -= b; return res; }
	Point operator + (const Point &b){ Point res = *this; res += b; return res; }
	Point operator * (const Point &b){ Point res = *this; res *= b; return res; }
};

ll scalar(Point a, Point b) //|a||b|cosθ // 0 90 180 270 360 //y
{										 // 1  0  -1  0  1
	return a.x*b.x + a.y*b.y;
}
ll skew(Point a, Point b)  // -|a||b|sinθ // 0 90 180 270 360 //x
{										    // 0  1  0  -1  0
	return a.x*b.y - b.x*a.y;
}
ll length2(Point a)
{
	return a.x * a.x + a.y * a.y;
}

int main()
{
	int n, i, j;
	cin>>n;
	Point *p = new Point[n+1];
	forn(i,0,n)
	{
		cin>>p[i].x>>p[i].y;
		p[i].i = i+1;
	}
	sort(p, p+n);
	p[n] = p[0];
	forn(i,0,n)
	{
		p[i] *= p[i+1];
	}
	j = 0;
	forn(i,1,n)
	{
		if(p[i] < p[j]) j = i;
	}
	cout<<p[j].i<<" "<<p[j].j<<endl;
	return 0;
}


//////// Kelvin 2015
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <iomanip>
#include <unordered_map>
#include <ctime>
#include <fstream>
#include <sstream>
//#include <windows.h>
//#include <stdint.h>
using namespace std;
#define INF 0x3f3f3f3f
#define EPS 1e-9
#define PI  (acos(-1.0))
typedef long long ll;
typedef pair<int, int> ii;
#define forn(i,s,n) i = (s); for( int _n = (int)(n), _di = (i > _n)?-1:1; i != _n; i += _di)
#define foreach(it,c) for ( auto it = (c).begin(); it!=(c).end(); it++)

#define BIN__N(x) (x) | x>>3 | x>>6 | x>>9
#define BIN__B(x) (x) & 0xf | (x)>>12 & 0xf0
#define BIN8(v) (BIN__B(BIN__N(0x##v)))
//#define _CRT_SECURE_NO_WARNINGS

int const N = 1e5+1;

int iX[N], iY[N], id[N];

int getFourth (int x, int y) {
    if (x >= 0)
    {
        return y >= 0 ? 1 : 2;
    }
    else
    {
        return y < 0 ? 3 : 4;
    }
}

int comparer(int i, int j)
{
    int c = getFourth(iX[i], iY[i]) - getFourth(iX[j], iY[j]);
    if (c != 0) return c > 0;
    return iX[i] * iY[j] > iX[j] * iY[i];
}

int main() {
    int n, it;
    cin>>n;

    forn(it,0,n)
    {
        cin>>iX[it]>>iY[it];
        id[it] = it;
    }

    sort(id, id + n, comparer);

    ll best = 1e18;
    ll zeBest = 1;
    int ansi = -1;
    int ansj = -1;
    for (it = 0; it < n; it++)
    {
        int i = id[it];
        int j = id[(it + 1) % n];
        ll nBe = abs(iX[i] * iY[j] > iX[j] * iY[i]);
        nBe *= nBe;
        ll nZeBe = 1;
        nZeBe *= (iX[i] * iX[i] + iY[i] * iY[i]);
        nZeBe *= (iX[j] * iX[j] + iY[j] * iY[j]);

        if (best*nZeBe > nBe*zeBest)
        {
            ansi = i;
            ansj = j;
            best = nBe;
            zeBest = nZeBe;
        }
    }

    cout<< ansi + 1<<" "<< ansj + 1<<endl;

    return 0;
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <string>
#include <string>
#include <algorithm>
#include <iomanip>
#include <vector>
#include <queue>
#include <stack>
#include <list>
#include <map>
#include <set>

#define INF 1000000000
#define INFLL 1000000000000000000LL
#define EPS 0.000000000001
#define MOD 1000000007
#define PI acos(-1.0)

using namespace std;

typedef pair<long long, long long> v;
int n;
pair<v, int> arr[100000];

bool isUp(v a) {
	return (a.second > 0 || (a.second == 0 && a.first > 0));
}

long long cross(v a, v b) {
	return a.first * b.second - b.first * a.second;
}

long long dot(v a, v b) {
	return a.first * b.first + a.second * b.second;
}

bool cmp(pair<v, int> first, pair<v, int> second) {
	v a = first.first;
	v b = second.first;
	if (isUp(a) != isUp(b))
		return isUp(a);
	return (cross(a, b) >= 0);
}

int cmpV(v a, v b, v x, v y) {
	b = make_pair(dot(a, b), abs(cross(a, b)));
	y = make_pair(dot(x, y), abs(cross(x, y)));
	return cross(b, y) > 0;
}

int main() {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> arr[i].first.first >> arr[i].first.second;
		arr[i].second = i + 1;
	}
	sort(arr, arr + n, cmp);
	int index = 0;
	for (int i = 1; i < n; i++) {
		if (cmpV(arr[i].first, arr[(i + 1) % n].first,
			arr[index].first, arr[(index + 1) % n].first)) {
			index = i;
		}
	}
	cout << arr[index].second << " " << arr[(index + 1) % n].second << endl;
	return 0;
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <string>
#include <string>
#include <algorithm>
#include <iomanip>
#include <vector>
#include <queue>
#include <stack>
#include <list>
#include <map>
#include <set>

#define INF 1000000000
#define INFLL 1000000000000000000LL
#define EPS 0.000000000001
#define MOD 1000000007
#define PI acos(-1.0)

using namespace std;

typedef pair<int, int> v;
int n;
pair<v, int> arr[100000];

bool isUp(v a) {
	return (a.second > 0 || (a.second == 0 && a.first > 0));
}

int cross(v a, v b) {
	return a.first * b.second - b.first * a.second;
}

int dot(v a, v b) {
	return a.first * b.first + a.second * b.second;
}

bool cmp(pair<v, int> first, pair<v, int> second) {
	v a = first.first;
	v b = second.first;
	if (isUp(a) != isUp(b))
		return isUp(a);
	return (cross(a, b) >= 0);
}

int cmpV(v a, v b, v x, v y) {
	b = make_pair(dot(a, b), abs(cross(a, b)));
	y = make_pair(dot(x, y), abs(cross(x, y)));
	return cmp(make_pair(b, -1), make_pair(y, -1));
}

int main() {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> arr[i].first.first >> arr[i].first.second;
		arr[i].second = i + 1;
	}
	sort(arr, arr + n, cmp);
	int index = 0;
	for (int i = 0; i < n; i++) {
		if (cmpV(arr[i].first, arr[(i + 1) % n].first,
			arr[index].first, arr[(index + 1) % n].first)) {
			index = i;
		}
	}
	cout << arr[index].second << " " << arr[(index + 1) % n].second << endl;
	return 0;
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <string>
#include <string>
#include <algorithm>
#include <iomanip>
#include <vector>
#include <queue>
#include <stack>
#include <list>
#include <map>
#include <set>

#define INF 1000000000
#define INFLL 1000000000000000000LL
#define EPS 0.000000000001
#define MOD 1000000007
#define PI acos(-1.0)

using namespace std;

typedef pair<long long, long long> v;
int n;
pair<v, int> arr[100000];

bool isUp(v a) {
	return (a.second > 0 || (a.second == 0 && a.first > 0));
}

long long cross(v a, v b) {
	return a.first * b.second - b.first * a.second;
}

long long dot(v a, v b) {
	return a.first * b.first + a.second * b.second;
}

bool cmp(pair<v, int> first, pair<v, int> second) {
	v a = first.first;
	v b = second.first;
	if (isUp(a) != isUp(b))
		return isUp(a);
	return (cross(a, b) >= 0);
}

int cmpV(v a, v b, v x, v y) {
	b = make_pair(dot(a, b), abs(cross(a, b)));
	y = make_pair(dot(x, y), abs(cross(x, y)));
	return cross(b, y) > 0;
}

int main() {
	freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> arr[i].first.first >> arr[i].first.second;
		arr[i].second = i + 1;
	}
	sort(arr, arr + n, cmp);
	int index = 0;
	for (int i = 1; i < n; i++) {
		if (cmpV(arr[i].first, arr[(i + 1) % n].first,
			arr[index].first, arr[(index + 1) % n].first)) {
			index = i;
		}
	}
	cout << arr[index].second << " " << arr[(index + 1) % n].second << endl;
	return 0;
}


//#define MYDEBUG
#define _CRT_SECURE_NO_WARNINGS
#define TASK "deb"
#pragma comment(linker, "/STACK:134217728")
#include <cstdio>
#include <iostream>
#include <iomanip>
#include <cmath>
#include <ctime>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <string>
#include <functional>
#include <cassert>
#include <random>
#include <bitset>

const int MOD = 1000000007;
const int INF = 1000000001;
const int MAXN = 17;
const double EPS = 1e-6;
const int HASH_POW = 31;
const double PI = acos(-1.0);

using namespace std;

void my_return(int code)
{
#ifdef MYDEBUG
	cout << "\nTime = " << fixed << setprecision(3) << double(clock()) / CLOCKS_PER_SEC << endl;
#endif
	exit(code);
}

int n, id[100010];
pair <int, int> p[100010];

bool cmp(int a, int b)
{
	int q1, q2;
	if (p[a].first > 0 && p[a].second >= 0)
		q1 = 1;
	else if (p[a].first <= 0 && p[a].second > 0)
		q1 = 2;
	else if (p[a].first < 0 && p[a].second <= 0)
		q1 = 3;
	else
		q1 = 4;
	if (p[b].first > 0 && p[b].second >= 0)
		q2 = 1;
	else if (p[b].first <= 0 && p[b].second > 0)
		q2 = 2;
	else if (p[b].first < 0 && p[b].second <= 0)
		q2 = 3;
	else
		q2 = 4;
	if (q1 != q2)
		return q1 < q2;
	else
	{
		int x1 = p[a].first, y1 = p[a].second;
		int x2 = p[b].first, y2 = p[b].second;
		if (q1 == 2)
		{
			swap(x1, y1);
			y1 = -y1;
			swap(x2, y2);
			y2 = -y2;
		}
		else if (q1 == 3)
		{
			x1 = -x1;
			y1 = -y1;
			x2 = -x2;
			y2 = -y2;
		}
		else if (q1 == 4)
		{
			swap(x1, y1);
			y1 = -y1;
			swap(x2, y2);
			x2 = -x2;
		}
		return y1*1ll*x2 < y2*1ll*x1;
	}
}

const long long mod = 1000000000000000000ll;

pair <long long, long long> multbymod(long long a, long long b)
{
	pair <long long, long long> ans = make_pair(0, 0);
	long long tmp = 0;
	while (b)
	{
		if (b % 2)
		{
			ans.first = (ans.first + tmp) % mod;
			ans.second = (ans.second + a) % mod;
		}
		a = a*2;
		tmp = tmp*2;
		if (a > mod)
		{
			tmp += a/mod;
			a %= mod;
		}
		b /= 2;
	}
	return ans;
}

pair <long long, long long> mult(pair <long long, long long> x, int y)
{
	x.first *= y;
	pair <long long, long long> tmp = multbymod(x.second, y);
	x.first += tmp.first;
	x.second += tmp.second;
	if (x.second > mod)
	{
		x.first += x.second/mod;
		x.second = x.second % mod;
	}
	return x;
}

bool comp(int a, int b, int c, int d)
{
	pair <long long, long long> foo, bar;
	foo = make_pair(0, 1);
	bar = make_pair(0, 1);

	foo = mult(foo, p[a].first*p[b].first + p[a].second*p[b].second);
	foo = mult(foo, p[a].first*p[b].first + p[a].second*p[b].second);
	foo = mult(foo, p[c].first*p[c].first + p[c].second*p[c].second);
	foo = mult(foo, p[d].first*p[d].first + p[d].second*p[d].second);

	bar = mult(bar, p[c].first*p[d].first + p[c].second*p[d].second);
	bar = mult(bar, p[c].first*p[d].first + p[c].second*p[d].second);
	bar = mult(bar, p[a].first*p[a].first + p[a].second*p[a].second);
	bar = mult(bar, p[b].first*p[b].first + p[b].second*p[b].second);

	return bar < foo;
}

int main()
{
	cin.sync_with_stdio(0);
	cin.tie(0);
	mt19937 mt_rand(time(NULL));
	#ifdef MYDEBUG
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
	#else
	/*freopen(TASK".in", "rt", stdin);
	freopen(TASK".out", "wt", stdout);*/
	/*freopen("input.txt", "rt", stdin);
	freopen("output.txt", "wt", stdout);*/
	#endif

	scanf("%d", &n);
	for (int i = 1; i <= n; ++i)
	{
		scanf("%d %d", &p[i].first, &p[i].second);
		id[i - 1] = i;
	}
	sort(id, id + n, cmp);

	int ans = 0;
	for (int i = 1; i < n; ++i)
	{
		if (comp(id[i], id[(i + 1) % n], id[ans], id[(ans + 1) % n]))
			ans = i;
	}
	printf("%d %d\n", id[ans], id[(ans + 1) % n]);

	my_return(0);
}


//#define MYDEBUG
#define _CRT_SECURE_NO_WARNINGS
#define TASK "deb"
#pragma comment(linker, "/STACK:134217728")
#include <cstdio>
#include <iostream>
#include <iomanip>
#include <cmath>
#include <ctime>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <string>
#include <functional>
#include <cassert>
#include <random>
#include <bitset>

const int MOD = 1000000007;
const int INF = 1000000001;
const int MAXN = 17;
const double EPS = 1e-6;
const int HASH_POW = 31;
const double PI = acos(-1.0);

using namespace std;

void my_return(int code)
{
#ifdef MYDEBUG
	cout << "\nTime = " << fixed << setprecision(3) << double(clock()) / CLOCKS_PER_SEC << endl;
#endif
	exit(code);
}

int n, id[100010];
pair <int, int> p[100010];

bool cmp(int a, int b)
{
	int q1, q2;
	if (p[a].first > 0 && p[a].second >= 0)
		q1 = 1;
	else if (p[a].first <= 0 && p[a].second > 0)
		q1 = 2;
	else if (p[a].first < 0 && p[a].second <= 0)
		q1 = 3;
	else
		q1 = 4;
	if (p[b].first > 0 && p[b].second >= 0)
		q2 = 1;
	else if (p[b].first <= 0 && p[b].second > 0)
		q2 = 2;
	else if (p[b].first < 0 && p[b].second <= 0)
		q2 = 3;
	else
		q2 = 4;
	if (q1 != q2)
		return q1 < q2;
	else
	{
		int x1 = p[a].first, y1 = p[a].second;
		int x2 = p[b].first, y2 = p[b].second;
		if (q1 == 2)
		{
			swap(x1, y1);
			y1 = -y1;
			swap(x2, y2);
			y2 = -y2;
		}
		else if (q1 == 3)
		{
			x1 = -x1;
			y1 = -y1;
			x2 = -x2;
			y2 = -y2;
		}
		else if (q1 == 4)
		{
			swap(x1, y1);
			y1 = -y1;
			swap(x2, y2);
			x2 = -x2;
		}
		return y1*1ll*x2 < y2*1ll*x1;
	}
}

bool comp(int a, int b, int c, int d)
{
	double foo, bar;
	foo = (p[a].first*p[b].first + p[a].second*p[b].second)*1.0*(p[a].first*p[b].first + p[a].second*p[b].second)/((p[a].first*p[a].first + p[a].second*p[a].second)*(p[b].first*p[b].first + p[b].second*p[b].second));
	bar = (p[c].first*p[d].first + p[c].second*p[d].second)*1.0*(p[c].first*p[d].first + p[c].second*p[d].second)/((p[c].first*p[c].first + p[c].second*p[c].second)*(p[d].first*p[d].first + p[d].second*p[d].second));
	return foo > bar;
}

int main()
{
	cin.sync_with_stdio(0);
	cin.tie(0);
	mt19937 mt_rand(time(NULL));
	#ifdef MYDEBUG
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
	#else
	/*freopen(TASK".in", "rt", stdin);
	freopen(TASK".out", "wt", stdout);*/
	/*freopen("input.txt", "rt", stdin);
	freopen("output.txt", "wt", stdout);*/
	#endif

	scanf("%d", &n);
	for (int i = 1; i <= n; ++i)
	{
		scanf("%d %d", &p[i].first, &p[i].second);
		id[i - 1] = i;
	}
	sort(id, id + n, cmp);

	int ans = 0;
	for (int i = 1; i < n; ++i)
	{
		if (comp(id[i], id[(i + 1) % n], id[ans], id[(ans + 1) % n]))
			ans = i;
	}
	printf("%d %d\n", id[ans], id[(ans + 1) % n]);

	my_return(0);
}


//#define MYDEBUG
#define _CRT_SECURE_NO_WARNINGS
#define TASK "deb"
#pragma comment(linker, "/STACK:134217728")
#include <cstdio>
#include <iostream>
#include <iomanip>
#include <cmath>
#include <ctime>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <string>
#include <functional>
#include <cassert>
#include <random>
#include <bitset>

const int MOD = 1000000007;
const int INF = 1000000001;
const int MAXN = 17;
const double EPS = 1e-6;
const int HASH_POW = 31;
const double PI = acos(-1.0);

using namespace std;

void my_return(int code)
{
#ifdef MYDEBUG
	cout << "\nTime = " << fixed << setprecision(3) << double(clock()) / CLOCKS_PER_SEC << endl;
#endif
	exit(code);
}

int n, id[100010];
pair <int, int> p[100010];

bool cmp(int a, int b)
{
	int q1, q2;
	if (p[a].first > 0 && p[a].second >= 0)
		q1 = 1;
	else if (p[a].first <= 0 && p[a].second > 0)
		q1 = 2;
	else if (p[a].first < 0 && p[a].second <= 0)
		q1 = 3;
	else
		q1 = 4;
	if (p[b].first > 0 && p[b].second >= 0)
		q2 = 1;
	else if (p[b].first <= 0 && p[b].second > 0)
		q2 = 2;
	else if (p[b].first < 0 && p[b].second <= 0)
		q2 = 3;
	else
		q2 = 4;
	if (q1 != q2)
		return q1 < q2;
	else
	{
		int x1 = p[a].first, y1 = p[a].second;
		int x2 = p[b].first, y2 = p[b].second;
		if (q1 == 2)
		{
			swap(x1, y1);
			y1 = -y1;
			swap(x2, y2);
			y2 = -y2;
		}
		else if (q1 == 3)
		{
			x1 = -x1;
			y1 = -y1;
			x2 = -x2;
			y2 = -y2;
		}
		else if (q1 == 4)
		{
			swap(x1, y1);
			y1 = -y1;
			swap(x2, y2);
			x2 = -x2;
		}
		return y1*1ll*x2 < y2*1ll*x1;
	}
}

const long long mod = 100000000000000000ll;

pair <long long, long long> multbymod(long long a, long long b)
{
	pair <long long, long long> ans = make_pair(0, 0);
	long long tmp = 0;
	while (b)
	{
		if (b % 2)
		{
			ans.first = (ans.first + tmp) % mod;
			ans.second = ans.second + a;
			if (ans.second >= mod)
			{
				ans.first += ans.second/mod;
				ans.second %= mod;
			}
		}
		a = a*2;
		tmp = tmp*2;
		if (a >= mod)
		{
			tmp += a/mod;
			a %= mod;
		}
		b /= 2;
	}
	return ans;
}

pair <long long, long long> mult(pair <long long, long long> x, long long y)
{
	x.first *= y;
	pair <long long, long long> tmp = multbymod(x.second, y);
	x.first += tmp.first;
	x.second = tmp.second;
	return x;
}

bool comp(int a, int b, int c, int d)
{
	pair <long long, long long> foo, bar;
	foo = make_pair(0, 1);
	bar = make_pair(0, 1);

	foo = mult(foo, abs(p[a].first*p[b].first + p[a].second*p[b].second));
	foo = mult(foo, abs(p[a].first*p[b].first + p[a].second*p[b].second));
	foo = mult(foo, p[c].first*p[c].first + p[c].second*p[c].second);
	foo = mult(foo, p[d].first*p[d].first + p[d].second*p[d].second);

	bar = mult(bar, abs(p[c].first*p[d].first + p[c].second*p[d].second));
	bar = mult(bar, abs(p[c].first*p[d].first + p[c].second*p[d].second));
	bar = mult(bar, p[a].first*p[a].first + p[a].second*p[a].second);
	bar = mult(bar, p[b].first*p[b].first + p[b].second*p[b].second);

	return bar < foo;
}

int main()
{
	cin.sync_with_stdio(0);
	cin.tie(0);
	mt19937 mt_rand(time(NULL));
	#ifdef MYDEBUG
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
	#else
	/*freopen(TASK".in", "rt", stdin);
	freopen(TASK".out", "wt", stdout);*/
	/*freopen("input.txt", "rt", stdin);
	freopen("output.txt", "wt", stdout);*/
	#endif

	scanf("%d", &n);
	for (int i = 1; i <= n; ++i)
	{
		scanf("%d %d", &p[i].first, &p[i].second);
		id[i - 1] = i;
	}
	sort(id, id + n, cmp);

	int ans = 0;
	for (int i = 1; i < n; ++i)
	{
		if (comp(id[i], id[(i + 1) % n], id[ans], id[(ans + 1) % n]))
			ans = i;
	}
	printf("%d %d\n", id[ans], id[(ans + 1) % n]);

	my_return(0);
}


//#define MYDEBUG
#define _CRT_SECURE_NO_WARNINGS
#define TASK "deb"
#pragma comment(linker, "/STACK:134217728")
#include <cstdio>
#include <iostream>
#include <iomanip>
#include <cmath>
#include <ctime>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <string>
#include <functional>
#include <cassert>
#include <random>
#include <bitset>

const int MOD = 1000000007;
const int INF = 1000000001;
const int MAXN = 17;
const double EPS = 1e-6;
const int HASH_POW = 31;
const double PI = acos(-1.0);

using namespace std;

void my_return(int code)
{
#ifdef MYDEBUG
	cout << "\nTime = " << fixed << setprecision(3) << double(clock()) / CLOCKS_PER_SEC << endl;
#endif
	exit(code);
}

int n, id[100010];
pair <int, int> p[100010];

bool cmp(int a, int b)
{
	int q1, q2;
	if (p[a].first > 0 && p[a].second >= 0)
		q1 = 1;
	else if (p[a].first <= 0 && p[a].second > 0)
		q1 = 2;
	else if (p[a].first < 0 && p[a].second <= 0)
		q1 = 3;
	else
		q1 = 4;
	if (p[b].first > 0 && p[b].second >= 0)
		q2 = 1;
	else if (p[b].first <= 0 && p[b].second > 0)
		q2 = 2;
	else if (p[b].first < 0 && p[b].second <= 0)
		q2 = 3;
	else
		q2 = 4;
	if (q1 != q2)
		return q1 < q2;
	else
	{
		int x1 = p[a].first, y1 = p[a].second;
		int x2 = p[b].first, y2 = p[b].second;
		if (q1 == 2)
		{
			swap(x1, y1);
			y1 = -y1;
			swap(x2, y2);
			y2 = -y2;
		}
		else if (q1 == 3)
		{
			x1 = -x1;
			y1 = -y1;
			x2 = -x2;
			y2 = -y2;
		}
		else if (q1 == 4)
		{
			swap(x1, y1);
			y1 = -y1;
			swap(x2, y2);
			x2 = -x2;
		}
		return y1*1ll*x2 < y2*1ll*x1;
	}
}

const long long mod = 100000000000000000ll;

pair <long long, long long> multbymod(long long a, long long b)
{
	pair <long long, long long> ans = make_pair(0, 0);
	long long tmp = 0;
	while (b)
	{
		if (b % 2)
		{
			ans.first = (ans.first + tmp) % mod;
			ans.second = (ans.second + a) % mod;
		}
		a = a*2;
		tmp = tmp*2;
		if (a >= mod)
		{
			tmp += a/mod;
			a %= mod;
		}
		b /= 2;
	}
	return ans;
}

pair <long long, long long> mult(pair <long long, long long> x, long long y)
{
	x.first *= y;
	pair <long long, long long> tmp = multbymod(x.second, y);
	x.first += tmp.first;
	x.second += tmp.second;
	if (x.second >= mod)
	{
		x.first += x.second/mod;
		x.second = x.second % mod;
	}
	return x;
}

bool comp(int a, int b, int c, int d)
{
	pair <long long, long long> foo, bar;
	foo = make_pair(0, 1);
	bar = make_pair(0, 1);

	foo = mult(foo, abs(p[a].first*p[b].first + p[a].second*p[b].second));
	foo = mult(foo, abs(p[a].first*p[b].first + p[a].second*p[b].second));
	foo = mult(foo, p[c].first*p[c].first + p[c].second*p[c].second);
	foo = mult(foo, p[d].first*p[d].first + p[d].second*p[d].second);

	bar = mult(bar, abs(p[c].first*p[d].first + p[c].second*p[d].second));
	bar = mult(bar, abs(p[c].first*p[d].first + p[c].second*p[d].second));
	bar = mult(bar, p[a].first*p[a].first + p[a].second*p[a].second);
	bar = mult(bar, p[b].first*p[b].first + p[b].second*p[b].second);

	return bar < foo;
}

int main()
{
	cin.sync_with_stdio(0);
	cin.tie(0);
	mt19937 mt_rand(time(NULL));
	#ifdef MYDEBUG
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
	#else
	/*freopen(TASK".in", "rt", stdin);
	freopen(TASK".out", "wt", stdout);*/
	/*freopen("input.txt", "rt", stdin);
	freopen("output.txt", "wt", stdout);*/
	#endif

	scanf("%d", &n);
	for (int i = 1; i <= n; ++i)
	{
		scanf("%d %d", &p[i].first, &p[i].second);
		id[i - 1] = i;
	}
	sort(id, id + n, cmp);

	int ans = 0;
	for (int i = 1; i < n; ++i)
	{
		if (comp(id[i], id[(i + 1) % n], id[ans], id[(ans + 1) % n]))
			ans = i;
	}
	printf("%d %d\n", id[ans], id[(ans + 1) % n]);

	my_return(0);
}


//#define MYDEBUG
#define _CRT_SECURE_NO_WARNINGS
#define TASK "deb"
#pragma comment(linker, "/STACK:134217728")
#include <cstdio>
#include <iostream>
#include <iomanip>
#include <cmath>
#include <ctime>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <string>
#include <functional>
#include <cassert>
#include <random>
#include <bitset>

const int MOD = 1000000007;
const int INF = 1000000001;
const int MAXN = 17;
const double EPS = 1e-6;
const int HASH_POW = 31;
const double PI = acos(-1.0);

using namespace std;

void my_return(int code)
{
#ifdef MYDEBUG
	cout << "\nTime = " << fixed << setprecision(3) << double(clock()) / CLOCKS_PER_SEC << endl;
#endif
	exit(code);
}

int n, id[100010];
pair <int, int> p[100010];

bool cmp(int a, int b)
{
	int q1, q2;
	if (p[a].first > 0 && p[a].second >= 0)
		q1 = 1;
	else if (p[a].first <= 0 && p[a].second > 0)
		q1 = 2;
	else if (p[a].first < 0 && p[a].second <= 0)
		q1 = 3;
	else
		q1 = 4;
	if (p[b].first > 0 && p[b].second >= 0)
		q2 = 1;
	else if (p[b].first <= 0 && p[b].second > 0)
		q2 = 2;
	else if (p[b].first < 0 && p[b].second <= 0)
		q2 = 3;
	else
		q2 = 4;
	if (q1 != q2)
		return q1 < q2;
	else
	{
		int x1 = p[a].first, y1 = p[a].second;
		int x2 = p[b].first, y2 = p[b].second;
		return y1*1ll*x2 < y2*1ll*x1;
	}
}

const long long mod = 100000000000000000ll;

pair <long long, long long> multbymod(long long a, long long b)
{
	pair <long long, long long> ans = make_pair(0, 0);
	long long tmp = 0;
	while (b)
	{
		if (b % 2)
		{
			ans.first = (ans.first + tmp) % mod;
			ans.second = ans.second + a;
			if (ans.second >= mod)
			{
				ans.first += ans.second/mod;
				ans.second %= mod;
			}
		}
		a = a*2;
		tmp = tmp*2;
		if (a >= mod)
		{
			tmp += a/mod;
			a %= mod;
		}
		b /= 2;
	}
	return ans;
}

pair <long long, long long> mult(pair <long long, long long> x, long long y)
{
	x.first *= y;
	pair <long long, long long> tmp = multbymod(x.second, y);
	x.first += tmp.first;
	x.second = tmp.second;
	return x;
}

bool comp(int a, int b, int c, int d)
{
	pair <long long, long long> foo, bar;
	foo = make_pair(0, 1);
	bar = make_pair(0, 1);

	if (p[a].first*p[b].first + p[a].second*p[b].second >= 0 && p[c].first*p[d].first + p[c].second*p[d].second < 0)
		return true;
	if (p[a].first*p[b].first + p[a].second*p[b].second <= 0 && p[c].first*p[d].first + p[c].second*p[d].second > 0)
		return false;

	foo = mult(foo, abs(p[a].first*p[b].first + p[a].second*p[b].second));
	foo = mult(foo, abs(p[a].first*p[b].first + p[a].second*p[b].second));
	foo = mult(foo, p[c].first*p[c].first + p[c].second*p[c].second);
	foo = mult(foo, p[d].first*p[d].first + p[d].second*p[d].second);

	bar = mult(bar, abs(p[c].first*p[d].first + p[c].second*p[d].second));
	bar = mult(bar, abs(p[c].first*p[d].first + p[c].second*p[d].second));
	bar = mult(bar, p[a].first*p[a].first + p[a].second*p[a].second);
	bar = mult(bar, p[b].first*p[b].first + p[b].second*p[b].second);

	if (p[a].first*p[b].first + p[a].second*p[b].second > 0)
		return foo > bar;
	else
		return foo < bar;
}

int main()
{
	cin.sync_with_stdio(0);
	cin.tie(0);
	mt19937 mt_rand(time(NULL));
	#ifdef MYDEBUG
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
	#else
	/*freopen(TASK".in", "rt", stdin);
	freopen(TASK".out", "wt", stdout);*/
	/*freopen("input.txt", "rt", stdin);
	freopen("output.txt", "wt", stdout);*/
	#endif

	scanf("%d", &n);
	for (int i = 1; i <= n; ++i)
	{
		scanf("%d %d", &p[i].first, &p[i].second);
		id[i - 1] = i;
	}
	sort(id, id + n, cmp);

	int ans = 0;
	for (int i = 1; i < n; ++i)
	{
		if (comp(id[i], id[(i + 1) % n], id[ans], id[(ans + 1) % n]))
			ans = i;
	}
	printf("%d %d\n", id[ans], id[(ans + 1) % n]);

	my_return(0);
}


//#define MYDEBUG
#define _CRT_SECURE_NO_WARNINGS
#define TASK "deb"
#pragma comment(linker, "/STACK:134217728")
#include <cstdio>
#include <iostream>
#include <iomanip>
#include <cmath>
#include <ctime>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <string>
#include <functional>
#include <cassert>
#include <random>
#include <bitset>

const int MOD = 1000000007;
const int INF = 1000000001;
const int MAXN = 17;
const double EPS = 1e-6;
const int HASH_POW = 31;
const double PI = acos(-1.0);

using namespace std;

void my_return(int code)
{
#ifdef MYDEBUG
	cout << "\nTime = " << fixed << setprecision(3) << double(clock()) / CLOCKS_PER_SEC << endl;
#endif
	exit(code);
}

int n, id[100010];
pair <int, int> p[100010];

bool cmp(int a, int b)
{
	int q1, q2;
	if (p[a].first > 0 && p[a].second >= 0)
		q1 = 1;
	else if (p[a].first <= 0 && p[a].second > 0)
		q1 = 2;
	else if (p[a].first < 0 && p[a].second <= 0)
		q1 = 3;
	else
		q1 = 4;
	if (p[b].first > 0 && p[b].second >= 0)
		q2 = 1;
	else if (p[b].first <= 0 && p[b].second > 0)
		q2 = 2;
	else if (p[b].first < 0 && p[b].second <= 0)
		q2 = 3;
	else
		q2 = 4;
	if (q1 != q2)
		return q1 < q2;
	else
	{
		int x1 = p[a].first, y1 = p[a].second;
		int x2 = p[b].first, y2 = p[b].second;
		if (q1 == 2)
		{
			swap(x1, y1);
			y1 = -y1;
			swap(x2, y2);
			y2 = -y2;
		}
		else if (q1 == 3)
		{
			x1 = -x1;
			y1 = -y1;
			x2 = -x2;
			y2 = -y2;
		}
		else if (q1 == 4)
		{
			swap(x1, y1);
			y1 = -y1;
			swap(x2, y2);
			x2 = -x2;
		}
		return y1*1ll*x2 < y2*1ll*x1;
	}
}

const long long mod = 100000000000000000ll;

pair <long long, long long> multbymod(long long a, long long b)
{
	pair <long long, long long> ans = make_pair(0, 0);
	long long tmp = 0;
	while (b)
	{
		if (b % 2)
		{
			ans.first = (ans.first + tmp) % mod;
			ans.second = (ans.second + a) % mod;
		}
		a = a*2;
		tmp = tmp*2;
		if (a >= mod)
		{
			tmp += a/mod;
			a %= mod;
		}
		b /= 2;
	}
	return ans;
}

pair <long long, long long> mult(pair <long long, long long> x, long long y)
{
	x.first *= y;
	pair <long long, long long> tmp = multbymod(x.second, y);
	x.first += tmp.first;
	x.second = tmp.second;
	if (x.second >= mod)
	{
		x.first += x.second/mod;
		x.second = x.second % mod;
	}
	return x;
}

bool comp(int a, int b, int c, int d)
{
	pair <long long, long long> foo, bar;
	foo = make_pair(0, 1);
	bar = make_pair(0, 1);

	foo = mult(foo, abs(p[a].first*p[b].first + p[a].second*p[b].second));
	foo = mult(foo, abs(p[a].first*p[b].first + p[a].second*p[b].second));
	foo = mult(foo, p[c].first*p[c].first + p[c].second*p[c].second);
	foo = mult(foo, p[d].first*p[d].first + p[d].second*p[d].second);

	bar = mult(bar, abs(p[c].first*p[d].first + p[c].second*p[d].second));
	bar = mult(bar, abs(p[c].first*p[d].first + p[c].second*p[d].second));
	bar = mult(bar, p[a].first*p[a].first + p[a].second*p[a].second);
	bar = mult(bar, p[b].first*p[b].first + p[b].second*p[b].second);

	return bar < foo;
}

int main()
{
	cin.sync_with_stdio(0);
	cin.tie(0);
	mt19937 mt_rand(time(NULL));
	#ifdef MYDEBUG
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
	#else
	/*freopen(TASK".in", "rt", stdin);
	freopen(TASK".out", "wt", stdout);*/
	/*freopen("input.txt", "rt", stdin);
	freopen("output.txt", "wt", stdout);*/
	#endif

	scanf("%d", &n);
	for (int i = 1; i <= n; ++i)
	{
		scanf("%d %d", &p[i].first, &p[i].second);
		id[i - 1] = i;
	}
	sort(id, id + n, cmp);

	int ans = 0;
	for (int i = 1; i < n; ++i)
	{
		if (comp(id[i], id[(i + 1) % n], id[ans], id[(ans + 1) % n]))
			ans = i;
	}
	printf("%d %d\n", id[ans], id[(ans + 1) % n]);

	my_return(0);
}


//#define MYDEBUG
#define _CRT_SECURE_NO_WARNINGS
#define TASK "deb"
#pragma comment(linker, "/STACK:134217728")
#include <cstdio>
#include <iostream>
#include <iomanip>
#include <cmath>
#include <ctime>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <string>
#include <functional>
#include <cassert>
#include <random>
#include <bitset>

const int MOD = 1000000007;
const int INF = 1000000001;
const int MAXN = 17;
const double EPS = 1e-6;
const int HASH_POW = 31;
const double PI = acos(-1.0);

using namespace std;

void my_return(int code)
{
#ifdef MYDEBUG
	cout << "\nTime = " << fixed << setprecision(3) << double(clock()) / CLOCKS_PER_SEC << endl;
#endif
	exit(code);
}

int n, id[100010];
pair <int, int> p[100010];

bool cmp(int a, int b)
{
	int q1, q2;
	if (p[a].first > 0 && p[a].second >= 0)
		q1 = 1;
	else if (p[a].first <= 0 && p[a].second > 0)
		q1 = 2;
	else if (p[a].first < 0 && p[a].second <= 0)
		q1 = 3;
	else
		q1 = 4;
	if (p[b].first > 0 && p[b].second >= 0)
		q2 = 1;
	else if (p[b].first <= 0 && p[b].second > 0)
		q2 = 2;
	else if (p[b].first < 0 && p[b].second <= 0)
		q2 = 3;
	else
		q2 = 4;
	if (q1 != q2)
		return q1 < q2;
	else
	{
		int x1 = p[a].first, y1 = p[a].second;
		int x2 = p[b].first, y2 = p[b].second;
		if (q1 == 2)
		{
			swap(x1, y1);
			y1 = -y1;
			swap(x2, y2);
			y2 = -y2;
		}
		else if (q1 == 3)
		{
			x1 = -x1;
			y1 = -y1;
			x2 = -x2;
			y2 = -y2;
		}
		else if (q1 == 4)
		{
			swap(x1, y1);
			y1 = -y1;
			swap(x2, y2);
			x2 = -x2;
		}
		return y1*1ll*x2 < y2*1ll*x1;
	}
}

bool comp(int a, int b, int c, int d)
{
	double foo, bar;
	foo = (p[a].first*p[b].first + p[a].second*p[b].second)*1.0*(p[a].first*p[b].first + p[a].second*p[b].second)*(p[c].first*p[c].first + p[c].second*p[c].second)*(p[d].first*p[d].first + p[d].second*p[d].second);
	bar = (p[c].first*p[d].first + p[c].second*p[d].second)*1.0*(p[c].first*p[d].first + p[c].second*p[d].second)*(p[a].first*p[a].first + p[a].second*p[a].second)*(p[b].first*p[b].first + p[b].second*p[b].second);
	return foo > bar;
}

int main()
{
	cin.sync_with_stdio(0);
	cin.tie(0);
	mt19937 mt_rand(time(NULL));
	#ifdef MYDEBUG
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
	#else
	/*freopen(TASK".in", "rt", stdin);
	freopen(TASK".out", "wt", stdout);*/
	/*freopen("input.txt", "rt", stdin);
	freopen("output.txt", "wt", stdout);*/
	#endif

	scanf("%d", &n);
	for (int i = 1; i <= n; ++i)
	{
		scanf("%d %d", &p[i].first, &p[i].second);
		id[i - 1] = i;
	}
	sort(id, id + n, cmp);

	int ans = 0;
	for (int i = 1; i < n; ++i)
	{
		if (comp(id[i], id[(i + 1) % n], id[ans], id[(ans + 1) % n]))
			ans = i;
	}
	printf("%d %d\n", id[ans], id[(ans + 1) % n]);

	my_return(0);
}


//#define MYDEBUG
#define _CRT_SECURE_NO_WARNINGS
#define TASK "deb"
#pragma comment(linker, "/STACK:134217728")
#include <cstdio>
#include <iostream>
#include <iomanip>
#include <cmath>
#include <ctime>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <string>
#include <functional>
#include <cassert>
#include <random>
#include <bitset>

const int MOD = 1000000007;
const int INF = 1000000001;
const int MAXN = 17;
const double EPS = 1e-6;
const int HASH_POW = 31;
const double PI = acos(-1.0);

using namespace std;

void my_return(int code)
{
#ifdef MYDEBUG
	cout << "\nTime = " << fixed << setprecision(3) << double(clock()) / CLOCKS_PER_SEC << endl;
#endif
	exit(code);
}

int n, id[100010];
pair <int, int> p[100010];

bool cmp(int a, int b)
{
	int q1, q2;
	if (p[a].first > 0 && p[a].second >= 0)
		q1 = 1;
	else if (p[a].first <= 0 && p[a].second > 0)
		q1 = 2;
	else if (p[a].first < 0 && p[a].second <= 0)
		q1 = 3;
	else
		q1 = 4;
	if (p[b].first > 0 && p[b].second >= 0)
		q2 = 1;
	else if (p[b].first <= 0 && p[b].second > 0)
		q2 = 2;
	else if (p[b].first < 0 && p[b].second <= 0)
		q2 = 3;
	else
		q2 = 4;
	if (q1 != q2)
		return q1 < q2;
	else
	{
		int x1 = p[a].first, y1 = p[a].second;
		int x2 = p[b].first, y2 = p[b].second;
		if (q1 == 2)
		{
			swap(x1, y1);
			y1 = -y1;
			swap(x2, y2);
			y2 = -y2;
		}
		else if (q1 == 3)
		{
			x1 = -x1;
			y1 = -y1;
			x2 = -x2;
			y2 = -y2;
		}
		else if (q1 == 4)
		{
			swap(x1, y1);
			y1 = -y1;
			swap(x2, y2);
			x2 = -x2;
		}
		return y1*1ll*x2 < y2*1ll*x1;
	}
}

const long long mod = 1000000000000ll;
pair <long long, long long> mult(pair <long long, long long> x, int y)
{
	x.first *= y;
	x.second *= y;
	if (x.second > mod)
	{
		x.first += x.second/mod;
		x.second = x.second % mod;
	}
	return x;
}

bool comp(int a, int b, int c, int d)
{
	pair <long long, long long> foo, bar;
	foo = make_pair(0, 1);
	bar = make_pair(0, 1);

	foo = mult(foo, p[a].first*p[b].first + p[a].second*p[b].second);
	foo = mult(foo, p[a].first*p[b].first + p[a].second*p[b].second);
	foo = mult(foo, p[c].first*p[c].first + p[c].second*p[c].second);
	foo = mult(foo, p[d].first*p[d].first + p[d].second*p[d].second);

	bar = mult(bar, p[c].first*p[d].first + p[c].second*p[d].second);
	bar = mult(bar, p[c].first*p[d].first + p[c].second*p[d].second);
	bar = mult(bar, p[a].first*p[a].first + p[a].second*p[a].second);
	bar = mult(bar, p[b].first*p[b].first + p[b].second*p[b].second);

	return bar < foo;
}

int main()
{
	cin.sync_with_stdio(0);
	cin.tie(0);
	mt19937 mt_rand(time(NULL));
	#ifdef MYDEBUG
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
	#else
	/*freopen(TASK".in", "rt", stdin);
	freopen(TASK".out", "wt", stdout);*/
	/*freopen("input.txt", "rt", stdin);
	freopen("output.txt", "wt", stdout);*/
	#endif

	scanf("%d", &n);
	for (int i = 1; i <= n; ++i)
	{
		scanf("%d %d", &p[i].first, &p[i].second);
		id[i - 1] = i;
	}
	sort(id, id + n, cmp);

	int ans = 0;
	for (int i = 1; i < n; ++i)
	{
		if (comp(id[i], id[(i + 1) % n], id[ans], id[(ans + 1) % n]))
			ans = i;
	}
	printf("%d %d\n", id[ans], id[(ans + 1) % n]);

	my_return(0);
}


//#define MYDEBUG
#define _CRT_SECURE_NO_WARNINGS
#define TASK "deb"
#pragma comment(linker, "/STACK:134217728")
#include <cstdio>
#include <iostream>
#include <iomanip>
#include <cmath>
#include <ctime>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <string>
#include <functional>
#include <cassert>
#include <random>
#include <bitset>

const int MOD = 1000000007;
const int INF = 1000000001;
const int MAXN = 17;
const double EPS = 1e-6;
const int HASH_POW = 31;
const double PI = acos(-1.0);

using namespace std;

void my_return(int code)
{
#ifdef MYDEBUG
	cout << "\nTime = " << fixed << setprecision(3) << double(clock()) / CLOCKS_PER_SEC << endl;
#endif
	exit(code);
}

int n, id[100010];
pair <int, int> p[100010];

bool cmp(int a, int b)
{
	int q1, q2;
	if (p[a].first > 0 && p[a].second >= 0)
		q1 = 1;
	else if (p[a].first <= 0 && p[a].second > 0)
		q1 = 2;
	else if (p[a].first < 0 && p[a].second <= 0)
		q1 = 3;
	else
		q1 = 4;
	if (p[b].first > 0 && p[b].second >= 0)
		q2 = 1;
	else if (p[b].first <= 0 && p[b].second > 0)
		q2 = 2;
	else if (p[b].first < 0 && p[b].second <= 0)
		q2 = 3;
	else
		q2 = 4;
	if (q1 != q2)
		return q1 < q2;
	else
	{
		int x1 = p[a].first, y1 = p[a].second;
		int x2 = p[b].first, y2 = p[b].second;
		if (q1 == 2)
		{
			swap(x1, y1);
			y1 = -y1;
			swap(x2, y2);
			y2 = -y2;
		}
		else if (q1 == 3)
		{
			x1 = -x1;
			y1 = -y1;
			x2 = -x2;
			y2 = -y2;
		}
		else if (q1 == 4)
		{
			swap(x1, y1);
			y1 = -y1;
			swap(x2, y2);
			x2 = -x2;
		}
		return y1*1ll*x2 < y2*1ll*x1;
	}
}

const long long mod = 100000000000000000ll;

pair <long long, long long> multbymod(long long a, long long b)
{
	pair <long long, long long> ans = make_pair(0, 0);
	long long tmp = 0;
	while (b)
	{
		if (b % 2)
		{
			ans.first = (ans.first + tmp) % mod;
			ans.second = (ans.second + a) % mod;
		}
		a = a*2;
		tmp = tmp*2;
		if (a >= mod)
		{
			tmp += a/mod;
			a %= mod;
		}
		b /= 2;
	}
	return ans;
}

pair <long long, long long> mult(pair <long long, long long> x, long long y)
{
	x.first *= y;
	pair <long long, long long> tmp = multbymod(x.second, y);
	x.first += tmp.first;
	x.second += tmp.second;
	if (x.second >= mod)
	{
		x.first += x.second/mod;
		x.second = x.second % mod;
	}
	return x;
}

bool comp(int a, int b, int c, int d)
{
	pair <long long, long long> foo, bar;
	foo = make_pair(0, 1);
	bar = make_pair(0, 1);

	foo = mult(foo, p[a].first*p[b].first + p[a].second*p[b].second);
	foo = mult(foo, p[a].first*p[b].first + p[a].second*p[b].second);
	foo = mult(foo, p[c].first*p[c].first + p[c].second*p[c].second);
	foo = mult(foo, p[d].first*p[d].first + p[d].second*p[d].second);

	bar = mult(bar, p[c].first*p[d].first + p[c].second*p[d].second);
	bar = mult(bar, p[c].first*p[d].first + p[c].second*p[d].second);
	bar = mult(bar, p[a].first*p[a].first + p[a].second*p[a].second);
	bar = mult(bar, p[b].first*p[b].first + p[b].second*p[b].second);

	return bar < foo;
}

int main()
{
	cin.sync_with_stdio(0);
	cin.tie(0);
	mt19937 mt_rand(time(NULL));
	#ifdef MYDEBUG
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
	#else
	/*freopen(TASK".in", "rt", stdin);
	freopen(TASK".out", "wt", stdout);*/
	/*freopen("input.txt", "rt", stdin);
	freopen("output.txt", "wt", stdout);*/
	#endif

	scanf("%d", &n);
	for (int i = 1; i <= n; ++i)
	{
		scanf("%d %d", &p[i].first, &p[i].second);
		id[i - 1] = i;
	}
	sort(id, id + n, cmp);

	int ans = 0;
	for (int i = 1; i < n; ++i)
	{
		if (comp(id[i], id[(i + 1) % n], id[ans], id[(ans + 1) % n]))
			ans = i;
	}
	printf("%d %d\n", id[ans], id[(ans + 1) % n]);

	my_return(0);
}


#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <limits.h>
#include <vector>
#include <stdlib.h>
#include <algorithm>
#include <memory.h>
#include <string.h>
#include <math.h>
#include <string>
#include <algorithm>
#include <functional>
#include <cassert>

using namespace std;
typedef long long lli;
typedef vector<int> vi;
typedef pair<int, int> pii;

//#define _LOCAL_DEBUG_
#ifdef _LOCAL_DEBUG_
#define eprintf(...) fprintf(stderr,__VA_ARGS__)
#else
#define eprintf(...)
#endif

const int MAX = 1e5 + 10;
const double PI = 3.1415926535897932384626433832795;
int n;
double angle[MAX];
int idx[MAX];

void clear() {
}

void solve() {
    for (int i = 0; i < n; i++) {
        int x, y;
        scanf("%d%d", &x, &y);
        angle[i] = atan2(y, x);
        idx[i] = i;
    }

    sort(idx, idx + n, [](const int &ai, const int &bi) -> bool {
        return angle[ai] < angle[bi];
    });

    angle[n] = angle[0] + 2 * PI;
    idx[n] = n;
    n++;

    double ans = 1e9;
    int a = -1, b = -1;
    for (int i = 0; i < n; i++) {
        double tmp =  abs(angle[idx[i + 1]] - angle[idx[i]]);
        if (tmp < ans) {
            ans = tmp;
            a = idx[i], b = idx[i + 1] % n;
        }
    }

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

void main() {
#ifdef _LOCAL_VAN
    freopen("in.txt", "r", stdin);
#endif
    while (scanf("%d", &n) == 1) {
        clear();
        solve();
#ifndef _LOCAL_VAN
        return;
#endif
    }
    return;
}


#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <limits.h>
#include <vector>
#include <stdlib.h>
#include <algorithm>
#include <memory.h>
#include <string.h>
#include <math.h>
#include <string>
#include <algorithm>
#include <functional>
#include <cassert>

using namespace std;
typedef long long lli;
typedef vector<int> vi;
typedef pair<int, int> pii;

//#define _LOCAL_DEBUG_
#ifdef _LOCAL_DEBUG_
#define eprintf(...) fprintf(stderr,__VA_ARGS__)
#else
#define eprintf(...)
#endif

#pragma region geometry_int
// see http://e-maxx.ru/bookz/files/andreeva.pdf for geometry
// coords should be in [-1e9, 1e9]

bool between(lli l, lli r, lli x) {
    if (l > r) swap(l, r);
    return l <= x && x <= r;
}

struct Point {
    lli x, y;
    Point(lli _x, lli _y) : x(_x), y(_y) {}
    Point() {}

    Point operator +(const Point &b) const { return Point(x + b.x, y + b.y); }
    Point operator -(const Point &b) const { return Point(x - b.x, y - b.y); }
    bool operator ==(const Point b) const { return x == b.x && y == b.y; }
    bool operator<(const Point &p) const { return x != p.x ? x < p.x : y < p.y; }

    Point operator *(const lli m) const { return Point(x * m, y * m); }
    Point operator /(const lli m) const { assert(m != 0);  return Point(x / m, y / m); }
    lli lengthSqr() const { return x * x + y * y; }
    double length() const { return sqrt(1.0 * lengthSqr()); }

    // cross product
    lli operator>>(const Point &p) const { return x * p.y - y * p.x; }
    lli operator<<(const Point &p) const { return p.x * y - p.y * x; }
    bool operator||(const Point &p) const { return *this >> p == 0; }

    // scalar/dot product
    lli operator*(const Point &p) const { return x * p.x + y * p.y; }

    void eprint() {
        eprintf("DEBUG: (%lld, %lld)\n", x, y);
    }
};

// Check if two vectors are collinear
bool colinear(const Point p1, const Point p2) {
    return p1 || p2;
}

// Check if two vectors are unidirected
bool unidirected(const Point p1, const Point p2) {
    if (!(p1 || p2))
        return false;
    return p1.x * p2.x > 0 && p1.y * p2.y > 0;
}

// Check if two vectors are orthogonal
bool orthogonal(const Point p1, const Point p2) {
    return p1 * p2 == 0;
}
#pragma endregion geometry_int

const int MAX = 1e5 + 10;
int n;
Point p[MAX];
int idx[MAX];

void clear() {
}

int getQ(lli x, lli y) {
    if (x < 0 && y < 0)
        return 1;
    else if (x == 0 && y < 0)
        return 2;
    else if (x > 0 && y < 0)
        return 3;
    else if (x > 0 && y == 0)
        return 4;
    else if (x > 0 && y > 0)
        return 5;
    else if (x == 0 && y > 0)
        return 6;
    else if (x < 0 && y > 0)
        return 7;
    else if(x < 0 && y == 0)
        return 8;
}

bool cmp(lli x1, lli y1, lli x2, lli y2) {
    int q1 = getQ(x1, y1);
    int q2 = getQ(x2, y2);
    if (q1 != q2)
        return q1 < q2;
    return y1 * x2 < y2 * x1;
}

void solve() {
    for (int i = 0; i < n; i++) {
        int x, y;
        scanf("%d%d", &x, &y);
        p[i] = Point(x, y);
        idx[i] = i;
    }

    sort(idx, idx + n, [](const int &ai, const int &bi) -> bool {
        return cmp(p[ai].x, p[ai].y, p[bi].x, p[bi].y);
    });

    lli minX, minY;
    int a = -1, b = -1;
    for (int i = 0; i < n; i++) {
        Point A = p[idx[i]], B = p[idx[(i + 1) % n]];
        lli y = A >> B;
        lli x = A * B;
        if (a == -1 || cmp(x, y, minX, minY)) {
            minX = x, minY = y;
            a = idx[i], b = idx[(i + 1) % n];
        }
    }

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

int main() {
#ifdef _LOCAL_VAN
    freopen("in.txt", "r", stdin);
#endif
    while (scanf("%d", &n) == 1) {
        clear();
        solve();
#ifndef _LOCAL_VAN
        return 0;
#endif
    }
    return 0;
}