/*******************************************************************************************************************************************
* File Name   : j.cpp
* Development : Wed 19 Oct 2011 09:40:46 PM IST
* Author      : Xeronix
*******************************************************************************************************************************************/

#include <iostream>
#include <cstdio>
#include <vector>
#include <math.h>
#include <algorithm>
#include <string>
#include <cstring>
#include <string.h>
#include <cstdlib>
#include <sstream>
#include <stack>
#include <queue>
#include <numeric>
#include <utility>
#include <cctype>
#include <list>
#include <limits.h>
#include <signal.h>
#include <time.h>
#include <map>
#include <set>
#include <float.h>

#define TR(c, i) for ( typeof((c).begin()) i = (c).begin(); i != (c).end(); i++ )
#define FOR(i, a, b) for ( i = a; i <= b; i++ )
#define ROF(i, a, b) for ( i = a; i >= b; i-- )
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort( ALL(v) )
#define MAX(a, b) ((a) >= (b) ? (a) : (b))
#define MIN(a, b) ((a) <= (b) ? (a) : (b))
#define ABS(a) ((a) < (0) ? (a)*(-1) : (a))
#define SWAP(a, b) typeof(a) T; T=a; a=b; b=T;
#define SET(x,a) memset(x,a,sizeof(x))

//#define LIM
#ifdef LIM
	int S, D, Y;
	char *inp, *out, *ipos, *opos, DIG[30];
	#define FRMI inp=( char * )malloc( LIM*sizeof( char ) );fread_unlocked( inp,1,LIM,stdin );ipos=inp;
	#define FWM out=( char * )malloc( LIM*sizeof( char ) );opos=out;
	#define FWO fwrite_unlocked( out,opos-out,1,stdout );
        #define GETI(n) n=0;while(*ipos<33){ipos++;}if(*ipos=='-'){S=-1;ipos++;}else{S=1;}while(*ipos>='0'){n=10*n+(*ipos-'0');ipos++;}n*=S;
	#define PUTI(n) D=0;if(n<0){*opos++='-';n*=-1;}if(!n)*opos++='0';else{while(n){Y=n/10;DIG[D++]=n-Y*10+'0';n=Y;}\
	while(D--)*opos++=DIG[D];}
	#define PUTC(c) *opos++=c;
#endif

#define SQ(x) (x)*(x)
#define DIST( a,b ) ( SQ(a.x-b.x) + SQ(a.y-b.y) )
#define DISTI( a,b,c,d ) ( SQ(a+c) + SQ(b+d) )

using namespace std;
using namespace __gnu_cxx;

struct point {
	int x, y;
	int v;
	int id;
};

bool comparex( point p, point q )
{
	return p.x < q.x;
}

bool comparey( point p, point q )
{
	return p.y < q.y;
}

point min_p1, min_p2;
int min_dist = INT_MAX;

void closest_pair( point *px, point *py, int n )
{
	int i, j;
	int d;

	if( n <= 3 ) {
		if( n >= 2 ) {
			FOR( i,0,n-2 ) {
				FOR( j,i+1,n-1 ) {
					if( px[i].id != px[j].id && ( d = DIST( px[i], px[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = px[i];
						min_p2 = px[j];
					}
				}
			}
		}
	} else {
		int mid, divider;

		mid = n >> 1;

		point pxl[mid+1], pxr[mid+1];
		point pyl[mid+1], pyr[mid+1];

		int pyl_len, pyr_len;

		FOR( i,0,mid ) {
			pxl[i] = px[i];
			if( mid+i+1 < n ) {
				pxr[i] = px[mid+i+1];
			}
		}

		divider = px[mid].x;
		pyl_len = pyr_len = 0;

		FOR( i,0,n-1 ) {
			if( py[i].x <= divider ) {
				pyl[pyl_len++] = py[i];
			} else {
				pyr[pyr_len++] = py[i];
			}
		}

		closest_pair( pxl, pyl, mid );
		closest_pair( pxr, pyr, n-mid-1 );

		point pyd[n];
		int pyd_len = 0;

		FOR( i,0,n-1 ) {
			if( ABS( py[i].x-divider ) <= sqrt( min_dist ) ) {
				pyd[pyd_len++] = py[i];
			}
		}

		if( pyd_len > 1 ) {
			FOR( i,0,pyd_len-1 ) {
				for( j=i+1; j <= i+7 && j < pyd_len; j++ ) {
					if( pyd[i].id != pyd[j].id && ( d = DIST( pyd[i], pyd[j] ) ) <= min_dist ) {
						min_dist = d;
						min_p1 = pyd[i];
						min_p2 = pyd[j];
					}
				}
			}
		}
	}
}

inline int version( int a, int b, int x, int y )
{
	if( a == x && b == y ) {
		return 1;
	} else if( a == -x && b == y ) {
		return 2;
	} else if( a == x && b == -y ) {
		return 3;
	} else {
		return 4;
	}
}

int main()
{
	int i, j;
	int n, m, a, b;
	point pt;

	freopen( "input.txt", "r", stdin );
	freopen( "output.txt", "w", stdout );

	scanf( "%d", &n );

//	m = n << 2;
	point px[n], py[n];

	j = 0;

	FOR( i,0,n-1 ) {
		scanf( "%d%d", &a, &b );
		pt.x = ABS(a);
		pt.y = ABS(b);
		pt.id = i+1;
		//	a = ABS(a); b = ABS(b);
	/*	pt.id = i+1;
		pt.x = a; pt.y = b; pt.v = 1; px[j] = py[j] = pt; j++;
		pt.x = a*-1; pt.y = b; pt.v = 2; px[j] = py[j] = pt; j++;
		pt.x = a; pt.y = b*-1; pt.v = 3; px[j] = py[j] = pt; j++;
		pt.x = a*-1; pt.y = b*-1; pt.v = 4; px[j] = py[j] = pt; j++;
		*/
//		pt.v = version( a, b, pt.x, pt.y );
		px[j] = py[j] = pt;
		j++;
	}

	sort( px, px+j, comparex );
	sort( py, py+j, comparey );

	closest_pair( px, py, n );

	int ans[4];

	ans[0] = min_p1.x;
	ans[1] = min_p1.y;
	ans[2] = min_p2.x;
	ans[3] = min_p2.y;

	int d, ver1, ver2;

	ver1 = 1;
	ver2 = 1;

	min_dist = DISTI( min_p1.x, min_p1.y, min_p2.x, min_p2.y );

	FOR( i,0,15 ) {
		FOR( j,0,3 ) {
			if ( i & (1<<j) ) {
				ans[j] = ABS(ans[0])*-1;
			}
		}

		if( ( d = DISTI( ans[0], ans[1], ans[2], ans[3] ) ) < min_dist ) {
			min_dist = d;
			min_p1.x = ans[0];
			min_p1.y = ans[1];
			min_p2.x = ans[2];
			min_p2.y = ans[3];
			ver1 = version( ans[0], ans[1], ABS(ans[0]), ABS(ans[1] ) );
			ver2 = version( ans[2], ans[3], ABS(ans[2]), ABS(ans[3] ) );
		}
	}

	printf( "%d %d %d %d\n", min_p1.id, ver1, min_p2.id, ver2 );

	return 0;
}


/*******************************************************************************************************************************************
* File Name   : j.cpp
* Development : Wed 19 Oct 2011 09:40:46 PM IST
* Author      : Xeronix
*******************************************************************************************************************************************/

#include <iostream>
#include <cstdio>
#include <vector>
#include <math.h>
#include <algorithm>
#include <string>
#include <cstring>
#include <string.h>
#include <cstdlib>
#include <sstream>
#include <stack>
#include <queue>
#include <numeric>
#include <utility>
#include <cctype>
#include <list>
#include <limits.h>
#include <signal.h>
#include <time.h>
#include <map>
#include <set>
#include <float.h>

#define TR(c, i) for ( typeof((c).begin()) i = (c).begin(); i != (c).end(); i++ )
#define FOR(i, a, b) for ( i = a; i <= b; i++ )
#define ROF(i, a, b) for ( i = a; i >= b; i-- )
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort( ALL(v) )
#define MAX(a, b) ((a) >= (b) ? (a) : (b))
#define MIN(a, b) ((a) <= (b) ? (a) : (b))
#define ABS(a) ((a) < (0) ? (a)*(-1) : (a))
#define SWAP(a, b) typeof(a) T; T=a; a=b; b=T;
#define SET(x,a) memset(x,a,sizeof(x))

//#define LIM
#ifdef LIM
	int S, D, Y;
	char *inp, *out, *ipos, *opos, DIG[30];
	#define FRMI inp=( char * )malloc( LIM*sizeof( char ) );fread_unlocked( inp,1,LIM,stdin );ipos=inp;
	#define FWM out=( char * )malloc( LIM*sizeof( char ) );opos=out;
	#define FWO fwrite_unlocked( out,opos-out,1,stdout );
        #define GETI(n) n=0;while(*ipos<33){ipos++;}if(*ipos=='-'){S=-1;ipos++;}else{S=1;}while(*ipos>='0'){n=10*n+(*ipos-'0');ipos++;}n*=S;
	#define PUTI(n) D=0;if(n<0){*opos++='-';n*=-1;}if(!n)*opos++='0';else{while(n){Y=n/10;DIG[D++]=n-Y*10+'0';n=Y;}\
	while(D--)*opos++=DIG[D];}
	#define PUTC(c) *opos++=c;
#endif

#define SQ(x) (x)*(x)
#define DIST( a,b ) ( SQ(a.x-b.x) + SQ(a.y-b.y) )
#define DISTI( a,b,c,d ) ( SQ(a+c) + SQ(b+d) )

using namespace std;
using namespace __gnu_cxx;

struct point {
	int x, y;
	int id;
};

bool comparex( point p, point q )
{
	return p.x < q.x;
}

bool comparey( point p, point q )
{
	return p.y < q.y;
}

point min_p1, min_p2;
int min_dist = INT_MAX;

void closest_pair( point *px, point *py, int n )
{
	int i, j;
	int d;

	if( n <= 3 ) {
		if( n >= 2 ) {
			FOR( i,0,n-2 ) {
				FOR( j,i+1,n-1 ) {
					if( px[i].id != px[j].id && ( d = DIST( px[i], px[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = px[i];
						min_p2 = px[j];
					}
				}
			}
		}
	} else {
		int mid, divider;

		mid = n >> 1;

		point *pxl, *pxr;
		point *pyl, *pyr;
		pxl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pxr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );

		int pyl_len, pyr_len;

		FOR( i,0,mid ) {
			pxl[i] = px[i];
			if( mid+i+1 < n ) {
				pxr[i] = px[mid+i+1];
			}
		}

		divider = px[mid].x;
		pyl_len = pyr_len = 0;

		FOR( i,0,n-1 ) {
			if( py[i].x <= divider ) {
				pyl[pyl_len++] = py[i];
			} else {
				pyr[pyr_len++] = py[i];
			}
		}

		closest_pair( pxl, pyl, mid );
		closest_pair( pxr, pyr, n-mid-1 );

		point *pyd;
		pyd = ( struct point * )malloc( n*sizeof( struct point ) );
		int pyd_len = 0;

		FOR( i,0,n-1 ) {
			if( ABS( py[i].x-divider ) <= sqrt( min_dist ) ) {
				pyd[pyd_len++] = py[i];
			}
		}

		if( pyd_len > 1 ) {
			FOR( i,0,pyd_len-1 ) {
				for( j=i+1; j <= i+7 && j < pyd_len; j++ ) {
					if( pyd[i].id != pyd[j].id && ( d = DIST( pyd[i], pyd[j] ) ) <= min_dist ) {
						min_dist = d;
						min_p1 = pyd[i];
						min_p2 = pyd[j];
					}
				}
			}
		}
	}
}

inline int version( int a, int b, int x, int y )
{
	if( a == x && b == y ) {
		return 1;
	} else if( a == -x && b == y ) {
		return 2;
	} else if( a == x && b == -y ) {
		return 3;
	} else {
		return 4;
	}
}

int main()
{
	int i, j;
	int n, m, a, b;
	point pt;

	freopen( "input.txt", "r", stdin );
	freopen( "output.txt", "w", stdout );

	scanf( "%d", &n );

//	m = n << 2;
//	point px[n], py[n],  temp[n];;

	point *px, *py, *temp;

	px = ( struct point * )malloc( n*sizeof( struct point ) );
	py = ( struct point * )malloc( n*sizeof( struct point ) );
	temp = ( struct point * )malloc( n*sizeof( struct point ) );

	j = 0;

	FOR( i,0,n-1 ) {
		scanf( "%d%d", &a, &b );
		temp[i].x = a;
		temp[i].y = b;
		temp[i].id = i+1;
		pt.x = ABS(a);
		pt.y = ABS(b);
		pt.id = i+1;
		//	a = ABS(a); b = ABS(b);
	/*	pt.id = i+1;
		pt.x = a; pt.y = b; pt.v = 1; px[j] = py[j] = pt; j++;
		pt.x = a*-1; pt.y = b; pt.v = 2; px[j] = py[j] = pt; j++;
		pt.x = a; pt.y = b*-1; pt.v = 3; px[j] = py[j] = pt; j++;
		pt.x = a*-1; pt.y = b*-1; pt.v = 4; px[j] = py[j] = pt; j++;
		*/
//		pt.v = version( a, b, pt.x, pt.y );
		px[j] = py[j] = pt;
		j++;
	}

	sort( px, px+j, comparex );
	sort( py, py+j, comparey );

	closest_pair( px, py, n );

	int ans[4];

	ans[0] = min_p1.x;
	ans[1] = min_p1.y;
	ans[2] = min_p2.x;
	ans[3] = min_p2.y;

	int d, ver1, ver2;

	ver1 = 1;
	ver2 = 1;

	min_dist = DISTI( min_p1.x, min_p1.y, min_p2.x, min_p2.y );

	FOR( i,0,15 ) {
		FOR( j,0,3 ) {
			if ( i & (1<<j) ) {
				ans[j] = ABS(ans[j])*-1;
			}
		}

		if( ( d = DISTI( ans[0], ans[1], ans[2], ans[3] ) ) < min_dist ) {
			min_dist = d;
			ver1 = version( ans[0], ans[1], temp[min_p1.id-1].x, temp[min_p1.id-1].y );
			ver2 = version( ans[2], ans[3], temp[min_p2.id-1].x, temp[min_p2.id-1].y );
//			cout << ans[0] << " " << ans[1] << " " << ans[2] << " " << ans[3] << endl;
//			cout << temp[min_p1.id-1].x << " " << temp[min_p1.id-1].y << endl;
//			cout << temp[min_p2.id-1].x << " " << temp[min_p2.id-1].y << endl;
		}
	}

//	cout << min_dist << endl;
	printf( "%d %d %d %d\n", min_p1.id, ver1, min_p2.id, ver2 );

	return 0;
}


/*******************************************************************************************************************************************
* File Name   : j.cpp
* Development : Wed 19 Oct 2011 09:40:46 PM IST
* Author      : Xeronix
*******************************************************************************************************************************************/

#include <iostream>
#include <cstdio>
#include <vector>
#include <math.h>
#include <algorithm>
#include <string>
#include <cstring>
#include <string.h>
#include <cstdlib>
#include <sstream>
#include <stack>
#include <queue>
#include <numeric>
#include <utility>
#include <cctype>
#include <list>
#include <limits.h>
#include <signal.h>
#include <time.h>
#include <map>
#include <set>
#include <float.h>

#define TR(c, i) for ( typeof((c).begin()) i = (c).begin(); i != (c).end(); i++ )
#define FOR(i, a, b) for ( i = a; i <= b; i++ )
#define ROF(i, a, b) for ( i = a; i >= b; i-- )
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort( ALL(v) )
#define MAX(a, b) ((a) >= (b) ? (a) : (b))
#define MIN(a, b) ((a) <= (b) ? (a) : (b))
#define ABS(a) ((a) < (0) ? (a)*(-1) : (a))
#define SWAP(a, b) typeof(a) T; T=a; a=b; b=T;
#define SET(x,a) memset(x,a,sizeof(x))

//#define LIM
#ifdef LIM
	int S, D, Y;
	char *inp, *out, *ipos, *opos, DIG[30];
	#define FRMI inp=( char * )malloc( LIM*sizeof( char ) );fread_unlocked( inp,1,LIM,stdin );ipos=inp;
	#define FWM out=( char * )malloc( LIM*sizeof( char ) );opos=out;
	#define FWO fwrite_unlocked( out,opos-out,1,stdout );
        #define GETI(n) n=0;while(*ipos<33){ipos++;}if(*ipos=='-'){S=-1;ipos++;}else{S=1;}while(*ipos>='0'){n=10*n+(*ipos-'0');ipos++;}n*=S;
	#define PUTI(n) D=0;if(n<0){*opos++='-';n*=-1;}if(!n)*opos++='0';else{while(n){Y=n/10;DIG[D++]=n-Y*10+'0';n=Y;}\
	while(D--)*opos++=DIG[D];}
	#define PUTC(c) *opos++=c;
#endif

#define SQ(x) (x)*(x)
#define DIST( a,b ) ( SQ(a.x-b.x) + SQ(a.y-b.y) )
#define DISTI( a,b,c,d ) ( SQ(a+c) + SQ(b+d) )

using namespace std;
using namespace __gnu_cxx;

struct point {
	int x, y;
	int id;
};

bool comparex( point p, point q )
{
	return p.x < q.x;
}

bool comparey( point p, point q )
{
	return p.y < q.y;
}

point min_p1, min_p2;
int min_dist = INT_MAX;

void closest_pair( point *px, point *py, int n )
{
	int i, j;
	int d;

	if( n <= 3 ) {
		if( n >= 2 ) {
			FOR( i,0,n-2 ) {
				FOR( j,i+1,n-1 ) {
					if( px[i].id != px[j].id && ( d = DIST( px[i], px[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = px[i];
						min_p2 = px[j];
					}
				}
			}
		}
	} else {
		int mid, divider;

		mid = n >> 1;

		point pxl[mid+1], pxr[mid+1];
		point pyl[mid+1], pyr[mid+1];
/*		point *pxl, *pxr;
		point *pyl, *pyr;
		pxl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pxr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
*/
		int pyl_len, pyr_len;

		FOR( i,0,mid ) {
			pxl[i] = px[i];
			if( mid+i+1 < n ) {
				pxr[i] = px[mid+i+1];
			}
		}

		divider = px[mid].x;
		pyl_len = pyr_len = 0;

		FOR( i,0,n-1 ) {
			if( py[i].x <= divider ) {
				pyl[pyl_len++] = py[i];
			} else {
				pyr[pyr_len++] = py[i];
			}
		}

		closest_pair( pxl, pyl, mid );
		closest_pair( pxr, pyr, n-mid-1 );

		point pyd[100];
//		point *pyd;
//		pyd = ( struct point * )malloc( n*sizeof( struct point ) );
		int pyd_len = 0;

		FOR( i,0,n-1 ) {
			if( ABS( py[i].x-divider ) <= sqrt( min_dist ) ) {
				pyd[pyd_len++] = py[i];
			}
		}

		if( pyd_len > 1 ) {
			FOR( i,0,pyd_len-1 ) {
				for( j=i+1; j <= i+7 && j < pyd_len; j++ ) {
					if( pyd[i].id != pyd[j].id && ( d = DIST( pyd[i], pyd[j] ) ) <= min_dist ) {
						min_dist = d;
						min_p1 = pyd[i];
						min_p2 = pyd[j];
					}
				}
			}
		}
	}
}

inline int version( int a, int b, int x, int y )
{
	if( a == x && b == y ) {
		return 1;
	} else if( a == -x && b == y ) {
		return 2;
	} else if( a == x && b == -y ) {
		return 3;
	} else {
		return 4;
	}
}

int main()
{
	int i, j;
	int n, m, a, b;
	point pt;

	freopen( "input.txt", "r", stdin );
	freopen( "output.txt", "w", stdout );

	scanf( "%d", &n );

//	m = n << 2;
//	point px[n], py[n],  temp[n];;

//	point *px, *py, *temp;

	point px[n], py[n], temp[n];
//	px = ( struct point * )malloc( n*sizeof( struct point ) );
//	py = ( struct point * )malloc( n*sizeof( struct point ) );
//	temp = ( struct point * )malloc( n*sizeof( struct point ) );

	j = 0;

	FOR( i,0,n-1 ) {
		scanf( "%d%d", &a, &b );
		temp[i].x = a;
		temp[i].y = b;
		temp[i].id = i+1;
		pt.x = ABS(a);
		pt.y = ABS(b);
		pt.id = i+1;
		//	a = ABS(a); b = ABS(b);
	/*	pt.id = i+1;
		pt.x = a; pt.y = b; pt.v = 1; px[j] = py[j] = pt; j++;
		pt.x = a*-1; pt.y = b; pt.v = 2; px[j] = py[j] = pt; j++;
		pt.x = a; pt.y = b*-1; pt.v = 3; px[j] = py[j] = pt; j++;
		pt.x = a*-1; pt.y = b*-1; pt.v = 4; px[j] = py[j] = pt; j++;
		*/
//		pt.v = version( a, b, pt.x, pt.y );
		px[j] = py[j] = pt;
		j++;
	}

	sort( px, px+j, comparex );
	sort( py, py+j, comparey );

	closest_pair( px, py, n );

	int ans[4];

	ans[0] = min_p1.x;
	ans[1] = min_p1.y;
	ans[2] = min_p2.x;
	ans[3] = min_p2.y;

	int d, ver1, ver2;

	ver1 = 1;
	ver2 = 1;

	min_dist = DISTI( min_p1.x, min_p1.y, min_p2.x, min_p2.y );

	FOR( i,0,15 ) {
		FOR( j,0,3 ) {
			if ( i & (1<<j) ) {
				ans[j] = ABS(ans[j])*-1;
			}
		}

		if( ( d = DISTI( ans[0], ans[1], ans[2], ans[3] ) ) < min_dist ) {
			min_dist = d;
			ver1 = version( ans[0], ans[1], temp[min_p1.id-1].x, temp[min_p1.id-1].y );
			ver2 = version( ans[2], ans[3], temp[min_p2.id-1].x, temp[min_p2.id-1].y );
//			cout << ans[0] << " " << ans[1] << " " << ans[2] << " " << ans[3] << endl;
//			cout << temp[min_p1.id-1].x << " " << temp[min_p1.id-1].y << endl;
//			cout << temp[min_p2.id-1].x << " " << temp[min_p2.id-1].y << endl;
		}
	}

//	cout << min_dist << endl;
	printf( "%d %d %d %d\n", min_p1.id, ver1, min_p2.id, ver2 );

//	free( px );
//	free( py );
//	free( temp );

	return 0;
}


/*******************************************************************************************************************************************
* File Name   : j.cpp
* Development : Wed 19 Oct 2011 09:40:46 PM IST
* Author      : Xeronix
*******************************************************************************************************************************************/

#include <iostream>
#include <cstdio>
#include <vector>
#include <math.h>
#include <algorithm>
#include <string>
#include <cstring>
#include <string.h>
#include <cstdlib>
#include <sstream>
#include <stack>
#include <queue>
#include <numeric>
#include <utility>
#include <cctype>
#include <list>
#include <limits.h>
#include <signal.h>
#include <time.h>
#include <map>
#include <set>
#include <float.h>

#define TR(c, i) for ( typeof((c).begin()) i = (c).begin(); i != (c).end(); i++ )
#define FOR(i, a, b) for ( i = a; i <= b; i++ )
#define ROF(i, a, b) for ( i = a; i >= b; i-- )
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort( ALL(v) )
#define MAX(a, b) ((a) >= (b) ? (a) : (b))
#define MIN(a, b) ((a) <= (b) ? (a) : (b))
#define ABS(a) ((a) < (0) ? (a)*(-1) : (a))
#define SWAP(a, b) typeof(a) T; T=a; a=b; b=T;
#define SET(x,a) memset(x,a,sizeof(x))

//#define LIM
#ifdef LIM
	int S, D, Y;
	char *inp, *out, *ipos, *opos, DIG[30];
	#define FRMI inp=( char * )malloc( LIM*sizeof( char ) );fread_unlocked( inp,1,LIM,stdin );ipos=inp;
	#define FWM out=( char * )malloc( LIM*sizeof( char ) );opos=out;
	#define FWO fwrite_unlocked( out,opos-out,1,stdout );
        #define GETI(n) n=0;while(*ipos<33){ipos++;}if(*ipos=='-'){S=-1;ipos++;}else{S=1;}while(*ipos>='0'){n=10*n+(*ipos-'0');ipos++;}n*=S;
	#define PUTI(n) D=0;if(n<0){*opos++='-';n*=-1;}if(!n)*opos++='0';else{while(n){Y=n/10;DIG[D++]=n-Y*10+'0';n=Y;}\
	while(D--)*opos++=DIG[D];}
	#define PUTC(c) *opos++=c;
#endif

#define SQ(x) (x)*(x)
#define DIST( a,b ) ( SQ(a.x-b.x) + SQ(a.y-b.y) )
#define DISTI( a,b,c,d ) ( SQ(a+c) + SQ(b+d) )

using namespace std;
using namespace __gnu_cxx;

struct point {
	int x, y;
	int id;
};

bool comparex( point p, point q )
{
	return p.x < q.x;
}

bool comparey( point p, point q )
{
	return p.y < q.y;
}

point min_p1, min_p2;
int min_dist = INT_MAX;

void closest_pair( point *px, int n, point *py, int m )
{
	int i, j;
	int d;

	if( n <= 10 ) {
		if( n >= 2 ) {
			FOR( i,0,n-2 ) {
				FOR( j,i+1,n-1 ) {
					if( ( d = DIST( px[i], px[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = px[i];
						min_p2 = px[j];
					}
				}
			}
		}
	} else {
		int mid, divider;

		mid = n >> 1;

//		point pyl[mid+1], pyr[mid+1];
		point *pyl, *pyr;
		pyl = ( struct point * )malloc( m*sizeof( struct point ) );
		pyr = ( struct point * )malloc( m*sizeof( struct point ) );

		int pyl_len, pyr_len;

		divider = px[mid].x;
		pyl_len = pyr_len = 0;

		FOR( i,0,m-1 ) {
			if( py[i].x <= divider ) {
				pyl[pyl_len++] = py[i];
			} else {
				pyr[pyr_len++] = py[i];
			}
		}

		closest_pair( px, mid+1, pyl, pyl_len );
		closest_pair( px+mid+1, n-mid-1, pyr, pyr_len );

//		point pyd[n];
		point *pyd;
		pyd = ( struct point * )malloc( m*sizeof( struct point ) );
		int pyd_len = 0;

		FOR( i,0,m-1 ) {
			if( ABS( py[i].x-divider ) <= sqrt( min_dist ) ) {
				pyd[pyd_len++] = py[i];
			}
		}

		if( pyd_len > 1 ) {
			FOR( i,0,pyd_len-1 ) {
				for( j=i+1; j <= i+7 && j < pyd_len; j++ ) {
					if( ( d = DIST( pyd[i], pyd[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = pyd[i];
						min_p2 = pyd[j];
					}
				}
			}
		}

		free( pyd );
		free( pyl );
		free( pyr );
	}
}

inline int version( int a, int b, int x, int y )
{
	if( a == x && b == y ) {
		return 1;
	} else if( a == -x && b == y ) {
		return 2;
	} else if( a == x && b == -y ) {
		return 3;
	} else {
		return 4;
	}
}

int main()
{
	int i, j;
	int n, m, a, b;
	point pt;

	freopen( "input.txt", "r", stdin );
	freopen( "output.txt", "w", stdout );

	scanf( "%d", &n );

	point *px, *py;
	int *ver;

//	point px[n], py[n];
//	int ver[n];
	px = ( struct point * )malloc( n*sizeof( struct point ) );
	py = ( struct point * )malloc( n*sizeof( struct point ) );
	ver = ( int * )malloc( n*sizeof( int ) );

	j = 0;

	FOR( i,0,n-1 ) {
		scanf( "%d%d", &a, &b );
		pt.x = ABS(a);
		pt.y = ABS(b);
		pt.id = i+1;
		ver[i] = version( a, b, pt.x, pt.y );
		px[j] = py[j] = pt;
		j++;
	}

	sort( px, px+j, comparex );
	sort( py, py+j, comparey );

	closest_pair( px, n, py, n );

	printf( "%d %d %d %d\n", min_p1.id, ver[min_p1.id-1], min_p2.id, 5-ver[min_p2.id-1] );

	free( px );
	free( py );
	free( ver );

	return 0;
}


/*******************************************************************************************************************************************
* File Name   : j.cpp
* Development : Wed 19 Oct 2011 09:40:46 PM IST
* Author      : Xeronix
*******************************************************************************************************************************************/

#include <iostream>
#include <cstdio>
#include <vector>
#include <math.h>
#include <algorithm>
#include <string>
#include <cstring>
#include <string.h>
#include <cstdlib>
#include <sstream>
#include <stack>
#include <queue>
#include <numeric>
#include <utility>
#include <cctype>
#include <list>
#include <limits.h>
#include <signal.h>
#include <time.h>
#include <map>
#include <set>
#include <float.h>

#define TR(c, i) for ( typeof((c).begin()) i = (c).begin(); i != (c).end(); i++ )
#define FOR(i, a, b) for ( i = a; i <= b; i++ )
#define ROF(i, a, b) for ( i = a; i >= b; i-- )
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort( ALL(v) )
#define MAX(a, b) ((a) >= (b) ? (a) : (b))
#define MIN(a, b) ((a) <= (b) ? (a) : (b))
#define ABS(a) ((a) < (0) ? (a)*(-1) : (a))
#define SWAP(a, b) typeof(a) T; T=a; a=b; b=T;
#define SET(x,a) memset(x,a,sizeof(x))

//#define LIM
#ifdef LIM
	int S, D, Y;
	char *inp, *out, *ipos, *opos, DIG[30];
	#define FRMI inp=( char * )malloc( LIM*sizeof( char ) );fread_unlocked( inp,1,LIM,stdin );ipos=inp;
	#define FWM out=( char * )malloc( LIM*sizeof( char ) );opos=out;
	#define FWO fwrite_unlocked( out,opos-out,1,stdout );
        #define GETI(n) n=0;while(*ipos<33){ipos++;}if(*ipos=='-'){S=-1;ipos++;}else{S=1;}while(*ipos>='0'){n=10*n+(*ipos-'0');ipos++;}n*=S;
	#define PUTI(n) D=0;if(n<0){*opos++='-';n*=-1;}if(!n)*opos++='0';else{while(n){Y=n/10;DIG[D++]=n-Y*10+'0';n=Y;}\
	while(D--)*opos++=DIG[D];}
	#define PUTC(c) *opos++=c;
#endif

#define SQ(x) (x)*(x)
#define DIST( a,b ) ( SQ(a.x-b.x) + SQ(a.y-b.y) )

using namespace std;
using namespace __gnu_cxx;

struct point {
	int x, y;
	int v;
	int id;
};

bool comparex( point p, point q )
{
	return p.x < q.x;
}

bool comparey( point p, point q )
{
	return p.y < q.y;
}

point min_p1, min_p2;
int min_dist = INT_MAX;

void closest_pair( point *px, point *py, int n )
{
	int i, j;
	int d;

	if( n <= 3 ) {
		if( n >= 2 ) {
			FOR( i,0,n-2 ) {
				FOR( j,i+1,n-1 ) {
					if( px[i].id != px[j].id && ( d = DIST( px[i], px[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = px[i];
						min_p2 = px[j];
					}
				}
			}
		}
	} else {
		int mid, divider;

		mid = n >> 1;

		point pxl[mid+1], pxr[mid+1];
		point pyl[mid+1], pyr[mid+1];

		int pyl_len, pyr_len;

		FOR( i,0,mid ) {
			pxl[i] = px[i];
			if( mid+i+1 < n ) {
				pxr[i] = px[mid+i+1];
			}
		}

		divider = px[mid].x;
		pyl_len = pyr_len = 0;

		FOR( i,0,n-1 ) {
			if( py[i].x <= divider ) {
				pyl[pyl_len++] = py[i];
			} else {
				pyr[pyr_len++] = py[i];
			}
		}

		closest_pair( pxl, pyl, mid );
		closest_pair( pxr, pyr, n-mid-1 );

		point pyd[n];
		int pyd_len = 0;

		FOR( i,0,n-1 ) {
			if( ABS( py[i].x-divider ) <= sqrt( min_dist ) ) {
				pyd[pyd_len++] = py[i];
			}
		}

		if( pyd_len > 1 ) {
			FOR( i,0,pyd_len-1 ) {
				for( j=i+1; j <= i+7 && j < pyd_len; j++ ) {
					if( pyd[i].id != pyd[j].id && ( d = DIST( pyd[i], pyd[j] ) ) <= min_dist ) {
						min_dist = d;
						min_p1 = pyd[i];
						min_p2 = pyd[j];
					}
				}
			}
		}
	}
}

int main()
{
	int i, j;
	int n, m, a, b;
	point pt;

	scanf( "%d", &n );

	m = n << 2;
	point px[m], py[m];

	j = 0;

	FOR( i,0,n-1 ) {
		scanf( "%d%d", &a, &b );
		a = ABS(a);
		b = ABS(b);
		pt.id = i+1;
		pt.x = a; pt.y = b; pt.v = 1; px[j] = py[j] = pt; j++;
		pt.x *= -1; pt.v = 2; px[j] = py[j] = pt; j++;
		pt.y *= -1; pt.v = 4; px[j] = py[j] = pt; j++;
		pt.x *= -1; pt.v = 3; px[j] = py[j] = pt; j++;
	}

	sort( px, px+j, comparex );
	sort( py, py+j, comparey );

	closest_pair( px, py, m );

	printf( "%d %d %d %d\n", min_p1.id, min_p1.v, min_p2.id, min_p2.v );

	return 0;
}


/*******************************************************************************************************************************************
* File Name   : j.cpp
* Development : Wed 19 Oct 2011 09:40:46 PM IST
* Author      : Xeronix
*******************************************************************************************************************************************/

#include <iostream>
#include <cstdio>
#include <vector>
#include <math.h>
#include <algorithm>
#include <string>
#include <cstring>
#include <string.h>
#include <cstdlib>
#include <sstream>
#include <stack>
#include <queue>
#include <numeric>
#include <utility>
#include <cctype>
#include <list>
#include <limits.h>
#include <signal.h>
#include <time.h>
#include <map>
#include <set>
#include <float.h>

#define TR(c, i) for ( typeof((c).begin()) i = (c).begin(); i != (c).end(); i++ )
#define FOR(i, a, b) for ( i = a; i <= b; i++ )
#define ROF(i, a, b) for ( i = a; i >= b; i-- )
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort( ALL(v) )
#define MAX(a, b) ((a) >= (b) ? (a) : (b))
#define MIN(a, b) ((a) <= (b) ? (a) : (b))
#define ABS(a) ((a) < (0) ? (a)*(-1) : (a))
#define SWAP(a, b) typeof(a) T; T=a; a=b; b=T;
#define SET(x,a) memset(x,a,sizeof(x))

//#define LIM
#ifdef LIM
	int S, D, Y;
	char *inp, *out, *ipos, *opos, DIG[30];
	#define FRMI inp=( char * )malloc( LIM*sizeof( char ) );fread_unlocked( inp,1,LIM,stdin );ipos=inp;
	#define FWM out=( char * )malloc( LIM*sizeof( char ) );opos=out;
	#define FWO fwrite_unlocked( out,opos-out,1,stdout );
        #define GETI(n) n=0;while(*ipos<33){ipos++;}if(*ipos=='-'){S=-1;ipos++;}else{S=1;}while(*ipos>='0'){n=10*n+(*ipos-'0');ipos++;}n*=S;
	#define PUTI(n) D=0;if(n<0){*opos++='-';n*=-1;}if(!n)*opos++='0';else{while(n){Y=n/10;DIG[D++]=n-Y*10+'0';n=Y;}\
	while(D--)*opos++=DIG[D];}
	#define PUTC(c) *opos++=c;
#endif

#define SQ(x) (x)*(x)
#define DIST( a,b ) ( SQ(a.x-b.x) + SQ(a.y-b.y) )
#define DISTI( a,b,c,d ) ( SQ(a+c) + SQ(b+d) )

using namespace std;
using namespace __gnu_cxx;

struct point {
	int x, y;
	int id;
};

bool comparex( point p, point q )
{
	return p.x < q.x;
}

bool comparey( point p, point q )
{
	return p.y < q.y;
}

point min_p1, min_p2;
int min_dist = INT_MAX;

void closest_pair( point *px, point *py, int n )
{
	int i, j;
	int d;

	if( n <= 3 ) {
		if( n >= 2 ) {
			FOR( i,0,n-2 ) {
				FOR( j,i+1,n-1 ) {
					if( px[i].id != px[j].id && ( d = DIST( px[i], px[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = px[i];
						min_p2 = px[j];
					}
				}
			}
		}
	} else {
		int mid, divider;

		mid = n >> 1;

		point pxl[mid+1], pxr[mid+1];
		point pyl[mid+1], pyr[mid+1];
/*		point *pxl, *pxr;
		point *pyl, *pyr;
		pxl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pxr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
*/
		int pyl_len, pyr_len;

		FOR( i,0,mid ) {
			pxl[i] = px[i];
			if( mid+i+1 < n ) {
				pxr[i] = px[mid+i+1];
			}
		}

		divider = px[mid].x;
		pyl_len = pyr_len = 0;

		FOR( i,0,n-1 ) {
			if( py[i].x <= divider ) {
				pyl[pyl_len++] = py[i];
			} else {
				pyr[pyr_len++] = py[i];
			}
		}

		closest_pair( pxl, pyl, mid );
		closest_pair( pxr, pyr, n-mid-1 );

//		point pyd[100];
		point *pyd;
		pyd = ( struct point * )malloc( n*sizeof( struct point ) );
		int pyd_len = 0;

		FOR( i,0,n-1 ) {
			if( ABS( py[i].x-divider ) <= sqrt( min_dist ) ) {
				pyd[pyd_len++] = py[i];
			}
		}

		if( pyd_len > 1 ) {
			FOR( i,0,pyd_len-1 ) {
				for( j=i+1; j <= i+7 && j < pyd_len; j++ ) {
					if( pyd[i].id != pyd[j].id && ( d = DIST( pyd[i], pyd[j] ) ) <= min_dist ) {
						min_dist = d;
						min_p1 = pyd[i];
						min_p2 = pyd[j];
					}
				}
			}
		}
	}
}

inline int version( int a, int b, int x, int y )
{
	if( a == x && b == y ) {
		return 1;
	} else if( a == -x && b == y ) {
		return 2;
	} else if( a == x && b == -y ) {
		return 3;
	} else {
		return 4;
	}
}

int main()
{
	int i, j;
	int n, m, a, b;
	point pt;

	freopen( "input.txt", "r", stdin );
	freopen( "output.txt", "w", stdout );

	scanf( "%d", &n );

//	m = n << 2;
//	point px[n], py[n],  temp[n];;

//	point *px, *py, *temp;

	point px[n], py[n], temp[n];
	int ver[n];
	//	px = ( struct point * )malloc( n*sizeof( struct point ) );
//	py = ( struct point * )malloc( n*sizeof( struct point ) );
//	temp = ( struct point * )malloc( n*sizeof( struct point ) );

	j = 0;

	FOR( i,0,n-1 ) {
		scanf( "%d%d", &a, &b );
		temp[i].x = a;
		temp[i].y = b;
		temp[i].id = i+1;
		pt.x = ABS(a);
		pt.y = ABS(b);
		pt.id = i+1;
		//	a = ABS(a); b = ABS(b);
	/*	pt.id = i+1;
		pt.x = a; pt.y = b; pt.v = 1; px[j] = py[j] = pt; j++;
		pt.x = a*-1; pt.y = b; pt.v = 2; px[j] = py[j] = pt; j++;
		pt.x = a; pt.y = b*-1; pt.v = 3; px[j] = py[j] = pt; j++;
		pt.x = a*-1; pt.y = b*-1; pt.v = 4; px[j] = py[j] = pt; j++;
		*/
		ver[i] = version( a, b, pt.x, pt.y );
		px[j] = py[j] = pt;
		j++;
	}

	sort( px, px+j, comparex );
	sort( py, py+j, comparey );

	closest_pair( px, py, n );

//	cout << min_dist << endl;
	printf( "%d %d %d %d\n", min_p1.id, ver[min_p1.id-1], min_p2.id, 5-ver[min_p2.id-1] );

//	free( px );
//	free( py );
//	free( temp );

	return 0;
}


/*******************************************************************************************************************************************
* File Name   : j.cpp
* Development : Wed 19 Oct 2011 09:40:46 PM IST
* Author      : Xeronix
*******************************************************************************************************************************************/

#include <iostream>
#include <cstdio>
#include <vector>
#include <math.h>
#include <algorithm>
#include <string>
#include <cstring>
#include <string.h>
#include <cstdlib>
#include <sstream>
#include <stack>
#include <queue>
#include <numeric>
#include <utility>
#include <cctype>
#include <list>
#include <limits.h>
#include <signal.h>
#include <time.h>
#include <map>
#include <set>
#include <float.h>

#define TR(c, i) for ( typeof((c).begin()) i = (c).begin(); i != (c).end(); i++ )
#define FOR(i, a, b) for ( i = a; i <= b; i++ )
#define ROF(i, a, b) for ( i = a; i >= b; i-- )
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort( ALL(v) )
#define MAX(a, b) ((a) >= (b) ? (a) : (b))
#define MIN(a, b) ((a) <= (b) ? (a) : (b))
#define ABS(a) ((a) < (0) ? (a)*(-1) : (a))
#define SWAP(a, b) typeof(a) T; T=a; a=b; b=T;
#define SET(x,a) memset(x,a,sizeof(x))

//#define LIM
#ifdef LIM
	int S, D, Y;
	char *inp, *out, *ipos, *opos, DIG[30];
	#define FRMI inp=( char * )malloc( LIM*sizeof( char ) );fread_unlocked( inp,1,LIM,stdin );ipos=inp;
	#define FWM out=( char * )malloc( LIM*sizeof( char ) );opos=out;
	#define FWO fwrite_unlocked( out,opos-out,1,stdout );
        #define GETI(n) n=0;while(*ipos<33){ipos++;}if(*ipos=='-'){S=-1;ipos++;}else{S=1;}while(*ipos>='0'){n=10*n+(*ipos-'0');ipos++;}n*=S;
	#define PUTI(n) D=0;if(n<0){*opos++='-';n*=-1;}if(!n)*opos++='0';else{while(n){Y=n/10;DIG[D++]=n-Y*10+'0';n=Y;}\
	while(D--)*opos++=DIG[D];}
	#define PUTC(c) *opos++=c;
#endif

#define SQ(x) (x)*(x)
#define DIST( a,b ) ( SQ(a.x-b.x) + SQ(a.y-b.y) )
#define DISTI( a,b,c,d ) ( SQ(a+c) + SQ(b+d) )

using namespace std;
using namespace __gnu_cxx;

struct point {
	int x, y;
	int id;
};

bool comparex( point p, point q )
{
	return p.x < q.x;
}

bool comparey( point p, point q )
{
	return p.y < q.y;
}

point min_p1, min_p2;
int min_dist = INT_MAX;

void closest_pair( point *px,  point *py, int n )
{
	int i, j;
	int d;

	if( n <= 10 ) {
		if( n >= 2 ) {
			FOR( i,0,n-2 ) {
				FOR( j,i+1,n-1 ) {
					if( ( d = DIST( px[i], px[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = px[i];
						min_p2 = px[j];
					}
				}
			}
		}
	} else {
		int mid, divider;

		mid = n >> 1;

//		point pxl[mid+1], pxr[mid+1];
//		point pyl[mid+1], pyr[mid+1];
	//	point *pxl, *pxr;
		point *pyl, *pyr;
	//	pxl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
	//	pxr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );

		int pyl_len, pyr_len;
/*
		FOR( i,0,mid ) {
			pxl[i] = px[i];
			if( mid+i+1 < n ) {
				pxr[i] = px[mid+i+1];
			}
		}
*/
		divider = px[mid].x;
		pyl_len = pyr_len = 0;

		FOR( i,0,n-1 ) {
			if( py[i].x <= divider ) {
				pyl[pyl_len++] = py[i];
			} else {
				pyr[pyr_len++] = py[i];
			}
		}

		closest_pair( px, pyl, mid+1 );
		closest_pair( px+mid+1, pyr, n-mid-1 );

		point *pyd;
		pyd = ( struct point * )malloc( n*sizeof( struct point ) );
		int pyd_len = 0;

		FOR( i,0,n-1 ) {
			if( ABS( py[i].x-divider ) <= sqrt( min_dist ) ) {
				pyd[pyd_len++] = py[i];
			}
		}

		if( pyd_len > 1 ) {
			FOR( i,0,pyd_len-1 ) {
				for( j=i+1; j <= i+7 && j < pyd_len; j++ ) {
					if( ( d = DIST( pyd[i], pyd[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = pyd[i];
						min_p2 = pyd[j];
					}
				}
			}
		}

		free( pyd );
		free( pyl );
		free( pyr );
	}
}

inline int version( int a, int b, int x, int y )
{
	if( a == x && b == y ) {
		return 1;
	} else if( a == -x && b == y ) {
		return 2;
	} else if( a == x && b == -y ) {
		return 3;
	} else {
		return 4;
	}
}

int main()
{
	int i, j;
	int n, m, a, b;
	point pt;

	freopen( "input.txt", "r", stdin );
	freopen( "output.txt", "w", stdout );

	scanf( "%d", &n );

	point *px, *py;
	int *ver;

//	point px[n], py[n];
//	int ver[n];
	px = ( struct point * )malloc( n*sizeof( struct point ) );
	py = ( struct point * )malloc( n*sizeof( struct point ) );
	ver = ( int * )malloc( n*sizeof( int ) );

	j = 0;

	FOR( i,0,n-1 ) {
		scanf( "%d%d", &a, &b );
		pt.x = ABS(a);
		pt.y = ABS(b);
		pt.id = i+1;
		ver[i] = version( a, b, pt.x, pt.y );
		px[j] = py[j] = pt;
		j++;
	}

	sort( px, px+j, comparex );
	sort( py, py+j, comparey );

	closest_pair( px, py, n );

	printf( "%d %d %d %d\n", min_p1.id, ver[min_p1.id-1], min_p2.id, 5-ver[min_p2.id-1] );

	free( px );
	free( py );
	free( ver );

	return 0;
}


/*******************************************************************************************************************************************
* File Name   : j.cpp
* Development : Wed 19 Oct 2011 09:40:46 PM IST
* Author      : Xeronix
*******************************************************************************************************************************************/

#include <iostream>
#include <cstdio>
#include <vector>
#include <math.h>
#include <algorithm>
#include <string>
#include <cstring>
#include <string.h>
#include <cstdlib>
#include <sstream>
#include <stack>
#include <queue>
#include <numeric>
#include <utility>
#include <cctype>
#include <list>
#include <limits.h>
#include <signal.h>
#include <time.h>
#include <map>
#include <set>
#include <float.h>

#define TR(c, i) for ( typeof((c).begin()) i = (c).begin(); i != (c).end(); i++ )
#define FOR(i, a, b) for ( i = a; i <= b; i++ )
#define ROF(i, a, b) for ( i = a; i >= b; i-- )
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort( ALL(v) )
#define MAX(a, b) ((a) >= (b) ? (a) : (b))
#define MIN(a, b) ((a) <= (b) ? (a) : (b))
#define ABS(a) ((a) < (0) ? (a)*(-1) : (a))
#define SWAP(a, b) typeof(a) T; T=a; a=b; b=T;
#define SET(x,a) memset(x,a,sizeof(x))

//#define LIM
#ifdef LIM
	int S, D, Y;
	char *inp, *out, *ipos, *opos, DIG[30];
	#define FRMI inp=( char * )malloc( LIM*sizeof( char ) );fread_unlocked( inp,1,LIM,stdin );ipos=inp;
	#define FWM out=( char * )malloc( LIM*sizeof( char ) );opos=out;
	#define FWO fwrite_unlocked( out,opos-out,1,stdout );
        #define GETI(n) n=0;while(*ipos<33){ipos++;}if(*ipos=='-'){S=-1;ipos++;}else{S=1;}while(*ipos>='0'){n=10*n+(*ipos-'0');ipos++;}n*=S;
	#define PUTI(n) D=0;if(n<0){*opos++='-';n*=-1;}if(!n)*opos++='0';else{while(n){Y=n/10;DIG[D++]=n-Y*10+'0';n=Y;}\
	while(D--)*opos++=DIG[D];}
	#define PUTC(c) *opos++=c;
#endif

#define SQ(x) (x)*(x)
#define DIST( a,b ) ( SQ(a.x-b.x) + SQ(a.y-b.y) )
#define DISTI( a,b,c,d ) ( SQ(a+c) + SQ(b+d) )

using namespace std;
using namespace __gnu_cxx;

struct point {
	int x, y;
	int id;
};

bool comparex( point p, point q )
{
	return p.x < q.x;
}

bool comparey( point p, point q )
{
	return p.y < q.y;
}

point min_p1, min_p2;
int min_dist = INT_MAX;

void closest_pair( point *px, point *py, int n )
{
	int i, j;
	int d;

	if( n <= 3 ) {
		if( n >= 2 ) {
			FOR( i,0,n-2 ) {
				FOR( j,i+1,n-1 ) {
					if( ( d = DIST( px[i], px[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = px[i];
						min_p2 = px[j];
					}
				}
			}
		}
	} else {
		int mid, divider;

		mid = n >> 1;

		point pxl[mid+1], pxr[mid+1];
		point pyl[mid+1], pyr[mid+1];
/*		point *pxl, *pxr;
		point *pyl, *pyr;
		pxl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pxr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
*/
		int pyl_len, pyr_len;

		FOR( i,0,mid ) {
			pxl[i] = px[i];
			if( mid+i+1 < n ) {
				pxr[i] = px[mid+i+1];
			}
		}

		divider = px[mid].x;
		pyl_len = pyr_len = 0;

		FOR( i,0,n-1 ) {
			if( py[i].x <= divider ) {
				pyl[pyl_len++] = py[i];
			} else {
				pyr[pyr_len++] = py[i];
			}
		}

		closest_pair( pxl, pyl, mid );
		closest_pair( pxr, pyr, n-mid-1 );

//		point pyd[100];
		point *pyd;
		pyd = ( struct point * )malloc( n*sizeof( struct point ) );
		int pyd_len = 0;

		FOR( i,0,n-1 ) {
			if( ABS( py[i].x-divider ) <= sqrt( min_dist ) ) {
				pyd[pyd_len++] = py[i];
			}
		}

		if( pyd_len > 1 ) {
			FOR( i,0,pyd_len-1 ) {
				for( j=i+1; j <= i+7 && j < pyd_len; j++ ) {
					if( ( d = DIST( pyd[i], pyd[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = pyd[i];
						min_p2 = pyd[j];
					}
				}
			}
		}
	}
}

inline int version( int a, int b, int x, int y )
{
	if( a == x && b == y ) {
		return 1;
	} else if( a == -x && b == y ) {
		return 2;
	} else if( a == x && b == -y ) {
		return 3;
	} else {
		return 4;
	}
}

int main()
{
	int i, j;
	int n, m, a, b;
	point pt;

	freopen( "input.txt", "r", stdin );
	freopen( "output.txt", "w", stdout );

	scanf( "%d", &n );

//	m = n << 2;
//	point px[n], py[n],  temp[n];;

//	point *px, *py, *temp;

	point px[n], py[n];
	int ver[n];
	//	px = ( struct point * )malloc( n*sizeof( struct point ) );
//	py = ( struct point * )malloc( n*sizeof( struct point ) );
//	temp = ( struct point * )malloc( n*sizeof( struct point ) );

	j = 0;

	FOR( i,0,n-1 ) {
		scanf( "%d%d", &a, &b );
		pt.x = ABS(a);
		pt.y = ABS(b);
		pt.id = i+1;
		ver[i] = version( a, b, pt.x, pt.y );
		px[j] = py[j] = pt;
		j++;
	}

	sort( px, px+j, comparex );
	sort( py, py+j, comparey );

	closest_pair( px, py, n );

//	cout << min_dist << endl;
	printf( "%d %d %d %d\n", min_p1.id, ver[min_p1.id-1], min_p2.id, 5-ver[min_p2.id-1] );

//	free( px );
//	free( py );
//	free( temp );

	return 0;
}


/*******************************************************************************************************************************************
* File Name   : j.cpp
* Development : Wed 19 Oct 2011 09:40:46 PM IST
* Author      : Xeronix
*******************************************************************************************************************************************/

#include <iostream>
#include <cstdio>
#include <vector>
#include <math.h>
#include <algorithm>
#include <string>
#include <cstring>
#include <string.h>
#include <cstdlib>
#include <sstream>
#include <stack>
#include <queue>
#include <numeric>
#include <utility>
#include <cctype>
#include <list>
#include <limits.h>
#include <signal.h>
#include <time.h>
#include <map>
#include <set>
#include <float.h>

#define TR(c, i) for ( typeof((c).begin()) i = (c).begin(); i != (c).end(); i++ )
#define FOR(i, a, b) for ( i = a; i <= b; i++ )
#define ROF(i, a, b) for ( i = a; i >= b; i-- )
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort( ALL(v) )
#define MAX(a, b) ((a) >= (b) ? (a) : (b))
#define MIN(a, b) ((a) <= (b) ? (a) : (b))
#define ABS(a) ((a) < (0) ? (a)*(-1) : (a))
#define SWAP(a, b) typeof(a) T; T=a; a=b; b=T;
#define SET(x,a) memset(x,a,sizeof(x))

//#define LIM
#ifdef LIM
	int S, D, Y;
	char *inp, *out, *ipos, *opos, DIG[30];
	#define FRMI inp=( char * )malloc( LIM*sizeof( char ) );fread_unlocked( inp,1,LIM,stdin );ipos=inp;
	#define FWM out=( char * )malloc( LIM*sizeof( char ) );opos=out;
	#define FWO fwrite_unlocked( out,opos-out,1,stdout );
        #define GETI(n) n=0;while(*ipos<33){ipos++;}if(*ipos=='-'){S=-1;ipos++;}else{S=1;}while(*ipos>='0'){n=10*n+(*ipos-'0');ipos++;}n*=S;
	#define PUTI(n) D=0;if(n<0){*opos++='-';n*=-1;}if(!n)*opos++='0';else{while(n){Y=n/10;DIG[D++]=n-Y*10+'0';n=Y;}\
	while(D--)*opos++=DIG[D];}
	#define PUTC(c) *opos++=c;
#endif

#define SQ(x) (x)*(x)
#define DIST( a,b ) ( SQ(a.x-b.x) + SQ(a.y-b.y) )
#define DISTI( a,b,c,d ) ( SQ(a+c) + SQ(b+d) )

using namespace std;
using namespace __gnu_cxx;

struct point {
	int x, y;
	int id;
};

bool comparex( point p, point q )
{
	return p.x < q.x;
}

bool comparey( point p, point q )
{
	return p.y < q.y;
}

point min_p1, min_p2;
int min_dist = INT_MAX;

void closest_pair( point *px, point *py, int n )
{
	int i, j;
	int d;

	if( n <= 3 ) {
		if( n >= 2 ) {
			FOR( i,0,n-2 ) {
				FOR( j,i+1,n-1 ) {
					if( ( d = DIST( px[i], px[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = px[i];
						min_p2 = px[j];
					}
				}
			}
		}
	} else {
		int mid, divider;

		mid = n >> 1;

		point pxl[mid+1], pxr[mid+1];
		point pyl[mid+1], pyr[mid+1];
/*		point *pxl, *pxr;
		point *pyl, *pyr;
		pxl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pxr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
*/
		int pyl_len, pyr_len;

		FOR( i,0,mid ) {
			pxl[i] = px[i];
			if( mid+i+1 < n ) {
				pxr[i] = px[mid+i+1];
			}
		}

		divider = px[mid].x;
		pyl_len = pyr_len = 0;

		FOR( i,0,n-1 ) {
			if( py[i].x <= divider ) {
				pyl[pyl_len++] = py[i];
			} else {
				pyr[pyr_len++] = py[i];
			}
		}

		closest_pair( pxl, pyl, mid );
		closest_pair( pxr, pyr, n-mid-1 );

//		point pyd[100];
		point *pyd;
		pyd = ( struct point * )malloc( n*sizeof( struct point ) );
		int pyd_len = 0;

		FOR( i,0,n-1 ) {
			if( ABS( py[i].x-divider ) <= sqrt( min_dist ) ) {
				pyd[pyd_len++] = py[i];
			}
		}

		if( pyd_len > 1 ) {
			FOR( i,0,pyd_len-1 ) {
				for( j=i+1; j <= i+7 && j < pyd_len; j++ ) {
					if( ( d = DIST( pyd[i], pyd[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = pyd[i];
						min_p2 = pyd[j];
					}
				}
			}
		}

		free( pyd );
	}
}

inline int version( int a, int b, int x, int y )
{
	if( a == x && b == y ) {
		return 1;
	} else if( a == -x && b == y ) {
		return 2;
	} else if( a == x && b == -y ) {
		return 3;
	} else {
		return 4;
	}
}

int main()
{
	int i, j;
	int n, m, a, b;
	point pt;

	freopen( "input.txt", "r", stdin );
	freopen( "output.txt", "w", stdout );

	scanf( "%d", &n );

//	m = n << 2;
//	point px[n], py[n],  temp[n];;

//	point *px, *py, *temp;

	point px[n], py[n];
	int ver[n];
//	px = ( struct point * )malloc( n*sizeof( struct point ) );
//	py = ( struct point * )malloc( n*sizeof( struct point ) );

	j = 0;

	FOR( i,0,n-1 ) {
		scanf( "%d%d", &a, &b );
		pt.x = ABS(a);
		pt.y = ABS(b);
		pt.id = i+1;
		ver[i] = version( a, b, pt.x, pt.y );
		px[j] = py[j] = pt;
		j++;
	}

	sort( px, px+j, comparex );
	sort( py, py+j, comparey );

	closest_pair( px, py, n );

//	cout << min_dist << endl;
	printf( "%d %d %d %d\n", min_p1.id, ver[min_p1.id-1], min_p2.id, 5-ver[min_p2.id-1] );

//	free( px );
//	free( py );

	return 0;
}


/*******************************************************************************************************************************************
* File Name   : j.cpp
* Development : Wed 19 Oct 2011 09:40:46 PM IST
* Author      : Xeronix
*******************************************************************************************************************************************/

#include <iostream>
#include <cstdio>
#include <vector>
#include <math.h>
#include <algorithm>
#include <string>
#include <cstring>
#include <string.h>
#include <cstdlib>
#include <sstream>
#include <stack>
#include <queue>
#include <numeric>
#include <utility>
#include <cctype>
#include <list>
#include <limits.h>
#include <signal.h>
#include <time.h>
#include <map>
#include <set>
#include <float.h>

#define TR(c, i) for ( typeof((c).begin()) i = (c).begin(); i != (c).end(); i++ )
#define FOR(i, a, b) for ( i = a; i <= b; i++ )
#define ROF(i, a, b) for ( i = a; i >= b; i-- )
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort( ALL(v) )
#define MAX(a, b) ((a) >= (b) ? (a) : (b))
#define MIN(a, b) ((a) <= (b) ? (a) : (b))
#define ABS(a) ((a) < (0) ? (a)*(-1) : (a))
#define SWAP(a, b) typeof(a) T; T=a; a=b; b=T;
#define SET(x,a) memset(x,a,sizeof(x))

//#define LIM
#ifdef LIM
	int S, D, Y;
	char *inp, *out, *ipos, *opos, DIG[30];
	#define FRMI inp=( char * )malloc( LIM*sizeof( char ) );fread_unlocked( inp,1,LIM,stdin );ipos=inp;
	#define FWM out=( char * )malloc( LIM*sizeof( char ) );opos=out;
	#define FWO fwrite_unlocked( out,opos-out,1,stdout );
        #define GETI(n) n=0;while(*ipos<33){ipos++;}if(*ipos=='-'){S=-1;ipos++;}else{S=1;}while(*ipos>='0'){n=10*n+(*ipos-'0');ipos++;}n*=S;
	#define PUTI(n) D=0;if(n<0){*opos++='-';n*=-1;}if(!n)*opos++='0';else{while(n){Y=n/10;DIG[D++]=n-Y*10+'0';n=Y;}\
	while(D--)*opos++=DIG[D];}
	#define PUTC(c) *opos++=c;
#endif

#define SQ(x) (x)*(x)
#define DIST( a,b ) ( SQ(a.x-b.x) + SQ(a.y-b.y) )
#define DISTI( a,b,c,d ) ( SQ(a+c) + SQ(b+d) )

using namespace std;
using namespace __gnu_cxx;

struct point {
	int x, y;
	int id;
};

bool comparex( point p, point q )
{
	return p.x < q.x;
}

bool comparey( point p, point q )
{
	return p.y < q.y;
}

point min_p1, min_p2;
int min_dist = INT_MAX;

void closest_pair( point *px, point *py, int n )
{
	int i, j;
	int d;

	if( n <= 3 ) {
		if( n >= 2 ) {
			FOR( i,0,n-2 ) {
				FOR( j,i+1,n-1 ) {
					if( px[i].id != px[j].id && ( d = DIST( px[i], px[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = px[i];
						min_p2 = px[j];
					}
				}
			}
		}
	} else {
		int mid, divider;

		mid = n >> 1;

		point pxl[mid+1], pxr[mid+1];
		point pyl[mid+1], pyr[mid+1];
/*		point *pxl, *pxr;
		point *pyl, *pyr;
		pxl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pxr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
*/
		int pyl_len, pyr_len;

		FOR( i,0,mid ) {
			pxl[i] = px[i];
			if( mid+i+1 < n ) {
				pxr[i] = px[mid+i+1];
			}
		}

		divider = px[mid].x;
		pyl_len = pyr_len = 0;

		FOR( i,0,n-1 ) {
			if( py[i].x <= divider ) {
				pyl[pyl_len++] = py[i];
			} else {
				pyr[pyr_len++] = py[i];
			}
		}

		closest_pair( pxl, pyl, mid );
		closest_pair( pxr, pyr, n-mid-1 );

		point *pyd;
		pyd = ( struct point * )malloc( n*sizeof( struct point ) );
		int pyd_len = 0;

		FOR( i,0,n-1 ) {
			if( ABS( py[i].x-divider ) <= sqrt( min_dist ) ) {
				pyd[pyd_len++] = py[i];
			}
		}

		if( pyd_len > 1 ) {
			FOR( i,0,pyd_len-1 ) {
				for( j=i+1; j <= i+7 && j < pyd_len; j++ ) {
					if( pyd[i].id != pyd[j].id && ( d = DIST( pyd[i], pyd[j] ) ) <= min_dist ) {
						min_dist = d;
						min_p1 = pyd[i];
						min_p2 = pyd[j];
					}
				}
			}
		}
	}
}

inline int version( int a, int b, int x, int y )
{
	if( a == x && b == y ) {
		return 1;
	} else if( a == -x && b == y ) {
		return 2;
	} else if( a == x && b == -y ) {
		return 3;
	} else {
		return 4;
	}
}

int main()
{
	int i, j;
	int n, m, a, b;
	point pt;

	freopen( "input.txt", "r", stdin );
	freopen( "output.txt", "w", stdout );

	scanf( "%d", &n );

//	m = n << 2;
//	point px[n], py[n],  temp[n];;

	point *px, *py, *temp;

	px = ( struct point * )malloc( n*sizeof( struct point ) );
	py = ( struct point * )malloc( n*sizeof( struct point ) );
	temp = ( struct point * )malloc( n*sizeof( struct point ) );

	j = 0;

	FOR( i,0,n-1 ) {
		scanf( "%d%d", &a, &b );
		temp[i].x = a;
		temp[i].y = b;
		temp[i].id = i+1;
		pt.x = ABS(a);
		pt.y = ABS(b);
		pt.id = i+1;
		//	a = ABS(a); b = ABS(b);
	/*	pt.id = i+1;
		pt.x = a; pt.y = b; pt.v = 1; px[j] = py[j] = pt; j++;
		pt.x = a*-1; pt.y = b; pt.v = 2; px[j] = py[j] = pt; j++;
		pt.x = a; pt.y = b*-1; pt.v = 3; px[j] = py[j] = pt; j++;
		pt.x = a*-1; pt.y = b*-1; pt.v = 4; px[j] = py[j] = pt; j++;
		*/
//		pt.v = version( a, b, pt.x, pt.y );
		px[j] = py[j] = pt;
		j++;
	}

	sort( px, px+j, comparex );
	sort( py, py+j, comparey );

	closest_pair( px, py, n );

	int ans[4];

	ans[0] = min_p1.x;
	ans[1] = min_p1.y;
	ans[2] = min_p2.x;
	ans[3] = min_p2.y;

	int d, ver1, ver2;

	ver1 = 1;
	ver2 = 1;

	min_dist = DISTI( min_p1.x, min_p1.y, min_p2.x, min_p2.y );

	FOR( i,0,15 ) {
		FOR( j,0,3 ) {
			if ( i & (1<<j) ) {
				ans[j] = ABS(ans[j])*-1;
			}
		}

		if( ( d = DISTI( ans[0], ans[1], ans[2], ans[3] ) ) < min_dist ) {
			min_dist = d;
			ver1 = version( ans[0], ans[1], temp[min_p1.id-1].x, temp[min_p1.id-1].y );
			ver2 = version( ans[2], ans[3], temp[min_p2.id-1].x, temp[min_p2.id-1].y );
//			cout << ans[0] << " " << ans[1] << " " << ans[2] << " " << ans[3] << endl;
//			cout << temp[min_p1.id-1].x << " " << temp[min_p1.id-1].y << endl;
//			cout << temp[min_p2.id-1].x << " " << temp[min_p2.id-1].y << endl;
		}
	}

//	cout << min_dist << endl;
	printf( "%d %d %d %d\n", min_p1.id, ver1, min_p2.id, ver2 );

	free( px );
	free( py );
	free( temp );

	return 0;
}


/*******************************************************************************************************************************************
* File Name   : j.cpp
* Development : Wed 19 Oct 2011 09:40:46 PM IST
* Author      : Xeronix
*******************************************************************************************************************************************/

#include <iostream>
#include <cstdio>
#include <vector>
#include <math.h>
#include <algorithm>
#include <string>
#include <cstring>
#include <string.h>
#include <cstdlib>
#include <sstream>
#include <stack>
#include <queue>
#include <numeric>
#include <utility>
#include <cctype>
#include <list>
#include <limits.h>
#include <signal.h>
#include <time.h>
#include <map>
#include <set>
#include <float.h>

#define TR(c, i) for ( typeof((c).begin()) i = (c).begin(); i != (c).end(); i++ )
#define FOR(i, a, b) for ( i = a; i <= b; i++ )
#define ROF(i, a, b) for ( i = a; i >= b; i-- )
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort( ALL(v) )
#define MAX(a, b) ((a) >= (b) ? (a) : (b))
#define MIN(a, b) ((a) <= (b) ? (a) : (b))
#define ABS(a) ((a) < (0) ? (a)*(-1) : (a))
#define SWAP(a, b) typeof(a) T; T=a; a=b; b=T;
#define SET(x,a) memset(x,a,sizeof(x))

//#define LIM
#ifdef LIM
	int S, D, Y;
	char *inp, *out, *ipos, *opos, DIG[30];
	#define FRMI inp=( char * )malloc( LIM*sizeof( char ) );fread_unlocked( inp,1,LIM,stdin );ipos=inp;
	#define FWM out=( char * )malloc( LIM*sizeof( char ) );opos=out;
	#define FWO fwrite_unlocked( out,opos-out,1,stdout );
        #define GETI(n) n=0;while(*ipos<33){ipos++;}if(*ipos=='-'){S=-1;ipos++;}else{S=1;}while(*ipos>='0'){n=10*n+(*ipos-'0');ipos++;}n*=S;
	#define PUTI(n) D=0;if(n<0){*opos++='-';n*=-1;}if(!n)*opos++='0';else{while(n){Y=n/10;DIG[D++]=n-Y*10+'0';n=Y;}\
	while(D--)*opos++=DIG[D];}
	#define PUTC(c) *opos++=c;
#endif

#define SQ(x) (x)*(x)
#define DIST( a,b ) ( SQ(a.x-b.x) + SQ(a.y-b.y) )
#define DISTI( a,b,c,d ) ( SQ(a+c) + SQ(b+d) )

using namespace std;
using namespace __gnu_cxx;

struct point {
	int x, y;
	int id;
};

bool comparex( point p, point q )
{
	return p.x < q.x;
}

bool comparey( point p, point q )
{
	return p.y < q.y;
}

point min_p1, min_p2;
int min_dist = INT_MAX;

void closest_pair( point *px,  point *py, int n )
{
	int i, j;
	int d;

	if( n <= 10 ) {
		if( n >= 2 ) {
			FOR( i,0,n-2 ) {
				FOR( j,i+1,n-1 ) {
					if( ( d = DIST( px[i], px[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = px[i];
						min_p2 = px[j];
					}
				}
			}
		}
	} else {
		int mid, divider;

		mid = n >> 1;

//		point pxl[mid+1], pxr[mid+1];
//		point pyl[mid+1], pyr[mid+1];
	//	point *pxl, *pxr;
		point *pyl, *pyr;
	//	pxl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
	//	pxr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );

		int pyl_len, pyr_len;
/*
		FOR( i,0,mid ) {
			pxl[i] = px[i];
			if( mid+i+1 < n ) {
				pxr[i] = px[mid+i+1];
			}
		}
*/
		divider = px[mid].x;
		pyl_len = pyr_len = 0;

		FOR( i,0,n-1 ) {
			if( py[i].x <= divider ) {
				pyl[pyl_len++] = py[i];
			} else {
				pyr[pyr_len++] = py[i];
			}
		}

		closest_pair( px, pyl, mid );
		closest_pair( px+mid, pyr, n-mid-1 );

		point *pyd;
		pyd = ( struct point * )malloc( n*sizeof( struct point ) );
		int pyd_len = 0;

		FOR( i,0,n-1 ) {
			if( ABS( py[i].x-divider ) <= sqrt( min_dist ) ) {
				pyd[pyd_len++] = py[i];
			}
		}

		if( pyd_len > 1 ) {
			FOR( i,0,pyd_len-1 ) {
				for( j=i+1; j <= i+7 && j < pyd_len; j++ ) {
					if( ( d = DIST( pyd[i], pyd[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = pyd[i];
						min_p2 = pyd[j];
					}
				}
			}
		}

		free( pyd );
		free( pyl );
		free( pyr );
	}
}

inline int version( int a, int b, int x, int y )
{
	if( a == x && b == y ) {
		return 1;
	} else if( a == -x && b == y ) {
		return 2;
	} else if( a == x && b == -y ) {
		return 3;
	} else {
		return 4;
	}
}

int main()
{
	int i, j;
	int n, m, a, b;
	point pt;

	freopen( "input.txt", "r", stdin );
	freopen( "output.txt", "w", stdout );

	scanf( "%d", &n );

//	point *px, *py;
//	int *ver;

	point px[n], py[n];
	int ver[n];
//	px = ( struct point * )malloc( n*sizeof( struct point ) );
//	py = ( struct point * )malloc( n*sizeof( struct point ) );
//	ver = ( int * )malloc( n*sizeof( int ) );

	j = 0;

	FOR( i,0,n-1 ) {
		scanf( "%d%d", &a, &b );
		pt.x = ABS(a);
		pt.y = ABS(b);
		pt.id = i+1;
		ver[i] = version( a, b, pt.x, pt.y );
		px[j] = py[j] = pt;
		j++;
	}

	sort( px, px+j, comparex );
	sort( py, py+j, comparey );

	closest_pair( px, py, n );

	printf( "%d %d %d %d\n", min_p1.id, ver[min_p1.id-1], min_p2.id, 5-ver[min_p2.id-1] );

//	free( px );
//	free( py );
//	free( ver );

	return 0;
}


/*******************************************************************************************************************************************
* File Name   : j.cpp
* Development : Wed 19 Oct 2011 09:40:46 PM IST
* Author      : Xeronix
*******************************************************************************************************************************************/

#include <iostream>
#include <cstdio>
#include <vector>
#include <math.h>
#include <algorithm>
#include <string>
#include <cstring>
#include <string.h>
#include <cstdlib>
#include <sstream>
#include <stack>
#include <queue>
#include <numeric>
#include <utility>
#include <cctype>
#include <list>
#include <limits.h>
#include <signal.h>
#include <time.h>
#include <map>
#include <set>
#include <float.h>

#define TR(c, i) for ( typeof((c).begin()) i = (c).begin(); i != (c).end(); i++ )
#define FOR(i, a, b) for ( i = a; i <= b; i++ )
#define ROF(i, a, b) for ( i = a; i >= b; i-- )
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort( ALL(v) )
#define MAX(a, b) ((a) >= (b) ? (a) : (b))
#define MIN(a, b) ((a) <= (b) ? (a) : (b))
#define ABS(a) ((a) < (0) ? (a)*(-1) : (a))
#define SWAP(a, b) typeof(a) T; T=a; a=b; b=T;
#define SET(x,a) memset(x,a,sizeof(x))

//#define LIM
#ifdef LIM
	int S, D, Y;
	char *inp, *out, *ipos, *opos, DIG[30];
	#define FRMI inp=( char * )malloc( LIM*sizeof( char ) );fread_unlocked( inp,1,LIM,stdin );ipos=inp;
	#define FWM out=( char * )malloc( LIM*sizeof( char ) );opos=out;
	#define FWO fwrite_unlocked( out,opos-out,1,stdout );
        #define GETI(n) n=0;while(*ipos<33){ipos++;}if(*ipos=='-'){S=-1;ipos++;}else{S=1;}while(*ipos>='0'){n=10*n+(*ipos-'0');ipos++;}n*=S;
	#define PUTI(n) D=0;if(n<0){*opos++='-';n*=-1;}if(!n)*opos++='0';else{while(n){Y=n/10;DIG[D++]=n-Y*10+'0';n=Y;}\
	while(D--)*opos++=DIG[D];}
	#define PUTC(c) *opos++=c;
#endif

#define SQ(x) (x)*(x)
#define DIST( a,b ) ( SQ(a.x-b.x) + SQ(a.y-b.y) )
#define DISTI( a,b,c,d ) ( SQ(a+c) + SQ(b+d) )

using namespace std;
using namespace __gnu_cxx;

struct point {
	int x, y;
	int id;
};

bool comparex( point p, point q )
{
	return p.x < q.x;
}

bool comparey( point p, point q )
{
	return p.y < q.y;
}

point min_p1, min_p2;
int min_dist = INT_MAX;

void closest_pair( point *px, point *py, int n )
{
	int i, j;
	int d;

	if( n <= 3 ) {
		if( n >= 2 ) {
			FOR( i,0,n-2 ) {
				FOR( j,i+1,n-1 ) {
					if( px[i].id != px[j].id && ( d = DIST( px[i], px[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = px[i];
						min_p2 = px[j];
					}
				}
			}
		}
	} else {
		int mid, divider;

		mid = n >> 1;

		point pxl[mid+1], pxr[mid+1];
		point pyl[mid+1], pyr[mid+1];
/*		point *pxl, *pxr;
		point *pyl, *pyr;
		pxl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pxr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
*/
		int pyl_len, pyr_len;

		FOR( i,0,mid ) {
			pxl[i] = px[i];
			if( mid+i+1 < n ) {
				pxr[i] = px[mid+i+1];
			}
		}

		divider = px[mid].x;
		pyl_len = pyr_len = 0;

		FOR( i,0,n-1 ) {
			if( py[i].x <= divider ) {
				pyl[pyl_len++] = py[i];
			} else {
				pyr[pyr_len++] = py[i];
			}
		}

		closest_pair( pxl, pyl, mid );
		closest_pair( pxr, pyr, n-mid-1 );

		point *pyd;
		pyd = ( struct point * )malloc( n*sizeof( struct point ) );
		int pyd_len = 0;

		FOR( i,0,n-1 ) {
			if( ABS( py[i].x-divider ) <= sqrt( min_dist ) ) {
				pyd[pyd_len++] = py[i];
			}
		}

		if( pyd_len > 1 ) {
			FOR( i,0,pyd_len-1 ) {
				for( j=i+1; j <= i+7 && j < pyd_len; j++ ) {
					if( pyd[i].id != pyd[j].id && ( d = DIST( pyd[i], pyd[j] ) ) <= min_dist ) {
						min_dist = d;
						min_p1 = pyd[i];
						min_p2 = pyd[j];
					}
				}
			}
		}

		free( pyd );
	}
}

inline int version( int a, int b, int x, int y )
{
	if( a == x && b == y ) {
		return 1;
	} else if( a == -x && b == y ) {
		return 2;
	} else if( a == x && b == -y ) {
		return 3;
	} else {
		return 4;
	}
}

int main()
{
	int i, j;
	int n, m, a, b;
	point pt;

	freopen( "input.txt", "r", stdin );
	freopen( "output.txt", "w", stdout );

	scanf( "%d", &n );

//	m = n << 2;
//	point px[n], py[n],  temp[n];;

	point *px, *py, *temp;

	px = ( struct point * )malloc( n*sizeof( struct point ) );
	py = ( struct point * )malloc( n*sizeof( struct point ) );
	temp = ( struct point * )malloc( n*sizeof( struct point ) );

	j = 0;

	FOR( i,0,n-1 ) {
		scanf( "%d%d", &a, &b );
		temp[i].x = a;
		temp[i].y = b;
		temp[i].id = i+1;
		pt.x = ABS(a);
		pt.y = ABS(b);
		pt.id = i+1;
		//	a = ABS(a); b = ABS(b);
	/*	pt.id = i+1;
		pt.x = a; pt.y = b; pt.v = 1; px[j] = py[j] = pt; j++;
		pt.x = a*-1; pt.y = b; pt.v = 2; px[j] = py[j] = pt; j++;
		pt.x = a; pt.y = b*-1; pt.v = 3; px[j] = py[j] = pt; j++;
		pt.x = a*-1; pt.y = b*-1; pt.v = 4; px[j] = py[j] = pt; j++;
		*/
//		pt.v = version( a, b, pt.x, pt.y );
		px[j] = py[j] = pt;
		j++;
	}

	sort( px, px+j, comparex );
	sort( py, py+j, comparey );

	closest_pair( px, py, n );

	int ans[4];

	ans[0] = min_p1.x;
	ans[1] = min_p1.y;
	ans[2] = min_p2.x;
	ans[3] = min_p2.y;

	int d, ver1, ver2;

	ver1 = 1;
	ver2 = 1;

	min_dist = DISTI( min_p1.x, min_p1.y, min_p2.x, min_p2.y );

	FOR( i,0,15 ) {
		FOR( j,0,3 ) {
			if ( i & (1<<j) ) {
				ans[j] = ABS(ans[j])*-1;
			}
		}

		if( ( d = DISTI( ans[0], ans[1], ans[2], ans[3] ) ) < min_dist ) {
			min_dist = d;
			ver1 = version( ans[0], ans[1], temp[min_p1.id-1].x, temp[min_p1.id-1].y );
			ver2 = version( ans[2], ans[3], temp[min_p2.id-1].x, temp[min_p2.id-1].y );
//			cout << ans[0] << " " << ans[1] << " " << ans[2] << " " << ans[3] << endl;
//			cout << temp[min_p1.id-1].x << " " << temp[min_p1.id-1].y << endl;
//			cout << temp[min_p2.id-1].x << " " << temp[min_p2.id-1].y << endl;
		}
	}

//	cout << min_dist << endl;
	printf( "%d %d %d %d\n", min_p1.id, ver1, min_p2.id, ver2 );

	free( px );
	free( py );
	free( temp );

	return 0;
}


/*******************************************************************************************************************************************
* File Name   : j.cpp
* Development : Wed 19 Oct 2011 09:40:46 PM IST
* Author      : Xeronix
*******************************************************************************************************************************************/

#include <iostream>
#include <cstdio>
#include <vector>
#include <math.h>
#include <algorithm>
#include <string>
#include <cstring>
#include <string.h>
#include <cstdlib>
#include <sstream>
#include <stack>
#include <queue>
#include <numeric>
#include <utility>
#include <cctype>
#include <list>
#include <limits.h>
#include <signal.h>
#include <time.h>
#include <map>
#include <set>
#include <float.h>

#define TR(c, i) for ( typeof((c).begin()) i = (c).begin(); i != (c).end(); i++ )
#define FOR(i, a, b) for ( i = a; i <= b; i++ )
#define ROF(i, a, b) for ( i = a; i >= b; i-- )
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort( ALL(v) )
#define MAX(a, b) ((a) >= (b) ? (a) : (b))
#define MIN(a, b) ((a) <= (b) ? (a) : (b))
#define ABS(a) ((a) < (0) ? (a)*(-1) : (a))
#define SWAP(a, b) typeof(a) T; T=a; a=b; b=T;
#define SET(x,a) memset(x,a,sizeof(x))

//#define LIM
#ifdef LIM
	int S, D, Y;
	char *inp, *out, *ipos, *opos, DIG[30];
	#define FRMI inp=( char * )malloc( LIM*sizeof( char ) );fread_unlocked( inp,1,LIM,stdin );ipos=inp;
	#define FWM out=( char * )malloc( LIM*sizeof( char ) );opos=out;
	#define FWO fwrite_unlocked( out,opos-out,1,stdout );
        #define GETI(n) n=0;while(*ipos<33){ipos++;}if(*ipos=='-'){S=-1;ipos++;}else{S=1;}while(*ipos>='0'){n=10*n+(*ipos-'0');ipos++;}n*=S;
	#define PUTI(n) D=0;if(n<0){*opos++='-';n*=-1;}if(!n)*opos++='0';else{while(n){Y=n/10;DIG[D++]=n-Y*10+'0';n=Y;}\
	while(D--)*opos++=DIG[D];}
	#define PUTC(c) *opos++=c;
#endif

#define SQ(x) (x)*(x)
#define DIST( a,b ) ( SQ(a.x-b.x) + SQ(a.y-b.y) )
#define DISTI( a,b,c,d ) ( SQ(a+c) + SQ(b+d) )

using namespace std;
using namespace __gnu_cxx;

struct point {
	int x, y;
	int id;
};

bool comparex( point p, point q )
{
	return p.x < q.x;
}

bool comparey( point p, point q )
{
	return p.y < q.y;
}

point min_p1, min_p2;
int min_dist = INT_MAX;

void closest_pair( point *px, point *py, int n )
{
	int i, j;
	int d;

	if( n <= 3 ) {
		if( n >= 2 ) {
			FOR( i,0,n-2 ) {
				FOR( j,i+1,n-1 ) {
					if( ( d = DIST( px[i], px[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = px[i];
						min_p2 = px[j];
					}
				}
			}
		}
	} else {
		int mid, divider;

		mid = n >> 1;

//		point pxl[mid+1], pxr[mid+1];
//		point pyl[mid+1], pyr[mid+1];
		point *pxl, *pxr;
		point *pyl, *pyr;
		pxl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pxr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );

		int pyl_len, pyr_len;

		FOR( i,0,mid ) {
			pxl[i] = px[i];
			if( mid+i+1 < n ) {
				pxr[i] = px[mid+i+1];
			}
		}

		divider = px[mid].x;
		pyl_len = pyr_len = 0;

		FOR( i,0,n-1 ) {
			if( py[i].x <= divider ) {
				pyl[pyl_len++] = py[i];
			} else {
				pyr[pyr_len++] = py[i];
			}
		}

		closest_pair( pxl, pyl, mid );
		closest_pair( pxr, pyr, n-mid-1 );

		point *pyd;
		pyd = ( struct point * )malloc( n*sizeof( struct point ) );
		int pyd_len = 0;

		FOR( i,0,n-1 ) {
			if( ABS( py[i].x-divider ) <= sqrt( min_dist ) ) {
				pyd[pyd_len++] = py[i];
			}
		}

		if( pyd_len > 1 ) {
			FOR( i,0,pyd_len-1 ) {
				for( j=i+1; j <= i+7 && j < pyd_len; j++ ) {
					if( ( d = DIST( pyd[i], pyd[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = pyd[i];
						min_p2 = pyd[j];
					}
				}
			}
		}

		free( pyd );
		free (pxl );
		free( pxr );
		free( pyl );
		free( pyr );
	}
}

inline int version( int a, int b, int x, int y )
{
	if( a == x && b == y ) {
		return 1;
	} else if( a == -x && b == y ) {
		return 2;
	} else if( a == x && b == -y ) {
		return 3;
	} else {
		return 4;
	}
}

int main()
{
	int i, j;
	int n, m, a, b;
	point pt;

	freopen( "input.txt", "r", stdin );
	freopen( "output.txt", "w", stdout );

	scanf( "%d", &n );

	point *px, *py;
	int *ver;

//	point px[n], py[n];
//	int ver[n];
	px = ( struct point * )malloc( n*sizeof( struct point ) );
	py = ( struct point * )malloc( n*sizeof( struct point ) );
	ver = ( int * )malloc( n*sizeof( int ) );

	j = 0;

	FOR( i,0,n-1 ) {
		scanf( "%d%d", &a, &b );
		pt.x = ABS(a);
		pt.y = ABS(b);
		pt.id = i+1;
		ver[i] = version( a, b, pt.x, pt.y );
		px[j] = py[j] = pt;
		j++;
	}

	sort( px, px+j, comparex );
	sort( py, py+j, comparey );

	closest_pair( px, py, n );

	printf( "%d %d %d %d\n", min_p1.id, ver[min_p1.id-1], min_p2.id, 5-ver[min_p2.id-1] );

	free( px );
	free( py );
	free( ver );

	return 0;
}


/*******************************************************************************************************************************************
* File Name   : j.cpp
* Development : Wed 19 Oct 2011 09:40:46 PM IST
* Author      : Xeronix
*******************************************************************************************************************************************/

#include <iostream>
#include <cstdio>
#include <vector>
#include <math.h>
#include <algorithm>
#include <string>
#include <cstring>
#include <string.h>
#include <cstdlib>
#include <sstream>
#include <stack>
#include <queue>
#include <numeric>
#include <utility>
#include <cctype>
#include <list>
#include <limits.h>
#include <signal.h>
#include <time.h>
#include <map>
#include <set>
#include <float.h>

#define TR(c, i) for ( typeof((c).begin()) i = (c).begin(); i != (c).end(); i++ )
#define FOR(i, a, b) for ( i = a; i <= b; i++ )
#define ROF(i, a, b) for ( i = a; i >= b; i-- )
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort( ALL(v) )
#define MAX(a, b) ((a) >= (b) ? (a) : (b))
#define MIN(a, b) ((a) <= (b) ? (a) : (b))
#define ABS(a) ((a) < (0) ? (a)*(-1) : (a))
#define SWAP(a, b) typeof(a) T; T=a; a=b; b=T;
#define SET(x,a) memset(x,a,sizeof(x))

//#define LIM
#ifdef LIM
	int S, D, Y;
	char *inp, *out, *ipos, *opos, DIG[30];
	#define FRMI inp=( char * )malloc( LIM*sizeof( char ) );fread_unlocked( inp,1,LIM,stdin );ipos=inp;
	#define FWM out=( char * )malloc( LIM*sizeof( char ) );opos=out;
	#define FWO fwrite_unlocked( out,opos-out,1,stdout );
        #define GETI(n) n=0;while(*ipos<33){ipos++;}if(*ipos=='-'){S=-1;ipos++;}else{S=1;}while(*ipos>='0'){n=10*n+(*ipos-'0');ipos++;}n*=S;
	#define PUTI(n) D=0;if(n<0){*opos++='-';n*=-1;}if(!n)*opos++='0';else{while(n){Y=n/10;DIG[D++]=n-Y*10+'0';n=Y;}\
	while(D--)*opos++=DIG[D];}
	#define PUTC(c) *opos++=c;
#endif

#define SQ(x) (x)*(x)
#define DIST( a,b ) ( SQ(a.x-b.x) + SQ(a.y-b.y) )
#define DISTI( a,b,c,d ) ( SQ(a+c) + SQ(b+d) )

using namespace std;
using namespace __gnu_cxx;

struct point {
	int x, y;
	int id;
};

bool comparex( point p, point q )
{
	return p.x < q.x;
}

bool comparey( point p, point q )
{
	return p.y < q.y;
}

point min_p1, min_p2;
int min_dist = INT_MAX;

void closest_pair( point *px, point *py, int n )
{
	int i, j;
	int d;

	if( n <= 3 ) {
		if( n >= 2 ) {
			FOR( i,0,n-2 ) {
				FOR( j,i+1,n-1 ) {
					if( px[i].id != px[j].id && ( d = DIST( px[i], px[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = px[i];
						min_p2 = px[j];
					}
				}
			}
		}
	} else {
		int mid, divider;

		mid = n >> 1;

		point pxl[mid+1], pxr[mid+1];
		point pyl[mid+1], pyr[mid+1];
/*		point *pxl, *pxr;
		point *pyl, *pyr;
		pxl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pxr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
*/
		int pyl_len, pyr_len;

		FOR( i,0,mid ) {
			pxl[i] = px[i];
			if( mid+i+1 < n ) {
				pxr[i] = px[mid+i+1];
			}
		}

		divider = px[mid].x;
		pyl_len = pyr_len = 0;

		FOR( i,0,n-1 ) {
			if( py[i].x <= divider ) {
				pyl[pyl_len++] = py[i];
			} else {
				pyr[pyr_len++] = py[i];
			}
		}

		closest_pair( pxl, pyl, mid );
		closest_pair( pxr, pyr, n-mid-1 );

		point pyd[100];
//		point *pyd;
//		pyd = ( struct point * )malloc( n*sizeof( struct point ) );
		int pyd_len = 0;

		FOR( i,0,n-1 ) {
			if( ABS( py[i].x-divider ) <= sqrt( min_dist ) ) {
				pyd[pyd_len++] = py[i];
			}
		}

		if( pyd_len > 1 ) {
			FOR( i,0,pyd_len-1 ) {
				for( j=i+1; j <= i+7 && j < pyd_len; j++ ) {
					if( pyd[i].id != pyd[j].id && ( d = DIST( pyd[i], pyd[j] ) ) <= min_dist ) {
						min_dist = d;
						min_p1 = pyd[i];
						min_p2 = pyd[j];
					}
				}
			}
		}
	}
}

inline int version( int a, int b, int x, int y )
{
	if( a == x && b == y ) {
		return 1;
	} else if( a == -x && b == y ) {
		return 2;
	} else if( a == x && b == -y ) {
		return 3;
	} else {
		return 4;
	}
}

int main()
{
	int i, j;
	int n, m, a, b;
	point pt;

//	freopen( "input.txt", "r", stdin );
//	freopen( "output.txt", "w", stdout );

	scanf( "%d", &n );

//	m = n << 2;
//	point px[n], py[n],  temp[n];;

//	point *px, *py, *temp;

	point px[n], py[n], temp[n];
//	px = ( struct point * )malloc( n*sizeof( struct point ) );
//	py = ( struct point * )malloc( n*sizeof( struct point ) );
//	temp = ( struct point * )malloc( n*sizeof( struct point ) );

	j = 0;

	FOR( i,0,n-1 ) {
		scanf( "%d%d", &a, &b );
		temp[i].x = a;
		temp[i].y = b;
		temp[i].id = i+1;
		pt.x = ABS(a);
		pt.y = ABS(b);
		pt.id = i+1;
		//	a = ABS(a); b = ABS(b);
	/*	pt.id = i+1;
		pt.x = a; pt.y = b; pt.v = 1; px[j] = py[j] = pt; j++;
		pt.x = a*-1; pt.y = b; pt.v = 2; px[j] = py[j] = pt; j++;
		pt.x = a; pt.y = b*-1; pt.v = 3; px[j] = py[j] = pt; j++;
		pt.x = a*-1; pt.y = b*-1; pt.v = 4; px[j] = py[j] = pt; j++;
		*/
//		pt.v = version( a, b, pt.x, pt.y );
		px[j] = py[j] = pt;
		j++;
	}

	sort( px, px+j, comparex );
	sort( py, py+j, comparey );

	closest_pair( px, py, n );

	int ans[4];

	ans[0] = min_p1.x;
	ans[1] = min_p1.y;
	ans[2] = min_p2.x;
	ans[3] = min_p2.y;

	int d, ver1, ver2;

	ver1 = 1;
	ver2 = 1;

	min_dist = DISTI( min_p1.x, min_p1.y, min_p2.x, min_p2.y );

	FOR( i,0,15 ) {
		FOR( j,0,3 ) {
			if ( i & (1<<j) ) {
				ans[j] = ABS(ans[j])*-1;
			}
		}

		if( ( d = DISTI( ans[0], ans[1], ans[2], ans[3] ) ) < min_dist ) {
			min_dist = d;
			ver1 = version( ans[0], ans[1], temp[min_p1.id-1].x, temp[min_p1.id-1].y );
			ver2 = version( ans[2], ans[3], temp[min_p2.id-1].x, temp[min_p2.id-1].y );
//			cout << ans[0] << " " << ans[1] << " " << ans[2] << " " << ans[3] << endl;
//			cout << temp[min_p1.id-1].x << " " << temp[min_p1.id-1].y << endl;
//			cout << temp[min_p2.id-1].x << " " << temp[min_p2.id-1].y << endl;
		}
	}

//	cout << min_dist << endl;
	printf( "%d %d %d %d\n", min_p1.id, ver1, min_p2.id, ver2 );

//	free( px );
//	free( py );
//	free( temp );

	return 0;
}


/*******************************************************************************************************************************************
* File Name   : j.cpp
* Development : Wed 19 Oct 2011 09:40:46 PM IST
* Author      : Xeronix
*******************************************************************************************************************************************/

#include <iostream>
#include <cstdio>
#include <vector>
#include <math.h>
#include <algorithm>
#include <string>
#include <cstring>
#include <string.h>
#include <cstdlib>
#include <sstream>
#include <stack>
#include <queue>
#include <numeric>
#include <utility>
#include <cctype>
#include <list>
#include <limits.h>
#include <signal.h>
#include <time.h>
#include <map>
#include <set>
#include <float.h>

#define TR(c, i) for ( typeof((c).begin()) i = (c).begin(); i != (c).end(); i++ )
#define FOR(i, a, b) for ( i = a; i <= b; i++ )
#define ROF(i, a, b) for ( i = a; i >= b; i-- )
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort( ALL(v) )
#define MAX(a, b) ((a) >= (b) ? (a) : (b))
#define MIN(a, b) ((a) <= (b) ? (a) : (b))
#define ABS(a) ((a) < (0) ? (a)*(-1) : (a))
#define SWAP(a, b) typeof(a) T; T=a; a=b; b=T;
#define SET(x,a) memset(x,a,sizeof(x))

//#define LIM
#ifdef LIM
	int S, D, Y;
	char *inp, *out, *ipos, *opos, DIG[30];
	#define FRMI inp=( char * )malloc( LIM*sizeof( char ) );fread_unlocked( inp,1,LIM,stdin );ipos=inp;
	#define FWM out=( char * )malloc( LIM*sizeof( char ) );opos=out;
	#define FWO fwrite_unlocked( out,opos-out,1,stdout );
        #define GETI(n) n=0;while(*ipos<33){ipos++;}if(*ipos=='-'){S=-1;ipos++;}else{S=1;}while(*ipos>='0'){n=10*n+(*ipos-'0');ipos++;}n*=S;
	#define PUTI(n) D=0;if(n<0){*opos++='-';n*=-1;}if(!n)*opos++='0';else{while(n){Y=n/10;DIG[D++]=n-Y*10+'0';n=Y;}\
	while(D--)*opos++=DIG[D];}
	#define PUTC(c) *opos++=c;
#endif

#define SQ(x) (x)*(x)
#define DIST( a,b ) ( SQ(a.x-b.x) + SQ(a.y-b.y) )
#define DISTI( a,b,c,d ) ( SQ(a+c) + SQ(b+d) )

using namespace std;
using namespace __gnu_cxx;

struct point {
	int x, y;
	int id;
};

bool comparex( point p, point q )
{
	return p.x < q.x;
}

bool comparey( point p, point q )
{
	return p.y < q.y;
}

point min_p1, min_p2;
int min_dist = INT_MAX;

void closest_pair( point *px,  point *py, int n )
{
	int i, j;
	int d;

	if( n <= 10 ) {
		if( n >= 2 ) {
			FOR( i,0,n-2 ) {
				FOR( j,i+1,n-1 ) {
					if( ( d = DIST( px[i], px[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = px[i];
						min_p2 = px[j];
					}
				}
			}
		}
	} else {
		int mid, divider;

		mid = n >> 1;

//		point pxl[mid+1], pxr[mid+1];
//		point pyl[mid+1], pyr[mid+1];
	//	point *pxl, *pxr;
		point *pyl, *pyr;
	//	pxl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
	//	pxr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );

		int pyl_len, pyr_len;
/*
		FOR( i,0,mid ) {
			pxl[i] = px[i];
			if( mid+i+1 < n ) {
				pxr[i] = px[mid+i+1];
			}
		}
*/
		divider = px[mid].x;
		pyl_len = pyr_len = 0;

		FOR( i,0,n-1 ) {
			if( py[i].x <= divider ) {
				pyl[pyl_len++] = py[i];
			} else {
				pyr[pyr_len++] = py[i];
			}
		}

		closest_pair( px, pyl, mid );
		closest_pair( px+mid, pyr, n-mid-1 );

		point *pyd;
		pyd = ( struct point * )malloc( n*sizeof( struct point ) );
		int pyd_len = 0;

		FOR( i,0,n-1 ) {
			if( ABS( py[i].x-divider ) <= sqrt( min_dist ) ) {
				pyd[pyd_len++] = py[i];
			}
		}

		if( pyd_len > 1 ) {
			FOR( i,0,pyd_len-1 ) {
				for( j=i+1; j <= i+7 && j < pyd_len; j++ ) {
					if( ( d = DIST( pyd[i], pyd[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = pyd[i];
						min_p2 = pyd[j];
					}
				}
			}
		}

		free( pyd );
		free( pyl );
		free( pyr );
	}
}

inline int version( int a, int b, int x, int y )
{
	if( a == x && b == y ) {
		return 1;
	} else if( a == -x && b == y ) {
		return 2;
	} else if( a == x && b == -y ) {
		return 3;
	} else {
		return 4;
	}
}

int main()
{
	int i, j;
	int n, m, a, b;
	point pt;

	freopen( "input.txt", "r", stdin );
	freopen( "output.txt", "w", stdout );

	scanf( "%d", &n );

	point *px, *py;
	int *ver;

//	point px[n], py[n];
//	int ver[n];
	px = ( struct point * )malloc( n*sizeof( struct point ) );
	py = ( struct point * )malloc( n*sizeof( struct point ) );
	ver = ( int * )malloc( n*sizeof( int ) );

	j = 0;

	FOR( i,0,n-1 ) {
		scanf( "%d%d", &a, &b );
		pt.x = ABS(a);
		pt.y = ABS(b);
		pt.id = i+1;
		ver[i] = version( a, b, pt.x, pt.y );
		px[j] = py[j] = pt;
		j++;
	}

	sort( px, px+j, comparex );
	sort( py, py+j, comparey );

	closest_pair( px, py, n );

	printf( "%d %d %d %d\n", min_p1.id, ver[min_p1.id-1], min_p2.id, 5-ver[min_p2.id-1] );

	free( px );
	free( py );
	free( ver );

	return 0;
}


/*******************************************************************************************************************************************
* File Name   : j.cpp
* Development : Wed 19 Oct 2011 09:40:46 PM IST
* Author      : Xeronix
*******************************************************************************************************************************************/

#include <iostream>
#include <cstdio>
#include <vector>
#include <math.h>
#include <algorithm>
#include <string>
#include <cstring>
#include <string.h>
#include <cstdlib>
#include <sstream>
#include <stack>
#include <queue>
#include <numeric>
#include <utility>
#include <cctype>
#include <list>
#include <limits.h>
#include <signal.h>
#include <time.h>
#include <map>
#include <set>
#include <float.h>

#define TR(c, i) for ( typeof((c).begin()) i = (c).begin(); i != (c).end(); i++ )
#define FOR(i, a, b) for ( i = a; i <= b; i++ )
#define ROF(i, a, b) for ( i = a; i >= b; i-- )
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort( ALL(v) )
#define MAX(a, b) ((a) >= (b) ? (a) : (b))
#define MIN(a, b) ((a) <= (b) ? (a) : (b))
#define ABS(a) ((a) < (0) ? (a)*(-1) : (a))
#define SWAP(a, b) typeof(a) T; T=a; a=b; b=T;
#define SET(x,a) memset(x,a,sizeof(x))

//#define LIM
#ifdef LIM
	int S, D, Y;
	char *inp, *out, *ipos, *opos, DIG[30];
	#define FRMI inp=( char * )malloc( LIM*sizeof( char ) );fread_unlocked( inp,1,LIM,stdin );ipos=inp;
	#define FWM out=( char * )malloc( LIM*sizeof( char ) );opos=out;
	#define FWO fwrite_unlocked( out,opos-out,1,stdout );
        #define GETI(n) n=0;while(*ipos<33){ipos++;}if(*ipos=='-'){S=-1;ipos++;}else{S=1;}while(*ipos>='0'){n=10*n+(*ipos-'0');ipos++;}n*=S;
	#define PUTI(n) D=0;if(n<0){*opos++='-';n*=-1;}if(!n)*opos++='0';else{while(n){Y=n/10;DIG[D++]=n-Y*10+'0';n=Y;}\
	while(D--)*opos++=DIG[D];}
	#define PUTC(c) *opos++=c;
#endif

#define SQ(x) (x)*(x)
#define DIST( a,b ) ( SQ(a.x-b.x) + SQ(a.y-b.y) )
#define DISTI( a,b,c,d ) ( SQ(a+c) + SQ(b+d) )

using namespace std;
using namespace __gnu_cxx;

struct point {
	int x, y;
	int id;
};

bool comparex( point p, point q )
{
	return p.x < q.x;
}

bool comparey( point p, point q )
{
	return p.y < q.y;
}

point min_p1, min_p2;
int min_dist = INT_MAX;

void closest_pair( point *px, point *py, int n )
{
	int i, j;
	int d;

	if( n <= 3 ) {
		if( n >= 2 ) {
			FOR( i,0,n-2 ) {
				FOR( j,i+1,n-1 ) {
					if( ( d = DIST( px[i], px[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = px[i];
						min_p2 = px[j];
					}
				}
			}
		}
	} else {
		int mid, divider;

		mid = n >> 1;

//		point pxl[mid+1], pxr[mid+1];
//		point pyl[mid+1], pyr[mid+1];
		point *pxl, *pxr;
		point *pyl, *pyr;
		pxl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pxr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );

		int pyl_len, pyr_len;

		FOR( i,0,mid ) {
			pxl[i] = px[i];
			if( mid+i+1 < n ) {
				pxr[i] = px[mid+i+1];
			}
		}

		divider = px[mid].x;
		pyl_len = pyr_len = 0;

		FOR( i,0,n-1 ) {
			if( py[i].x <= divider ) {
				pyl[pyl_len++] = py[i];
			} else {
				pyr[pyr_len++] = py[i];
			}
		}

		closest_pair( pxl, pyl, mid );
		closest_pair( pxr, pyr, n-mid-1 );

		point *pyd;
		pyd = ( struct point * )malloc( n*sizeof( struct point ) );
		int pyd_len = 0;

		FOR( i,0,n-1 ) {
			if( ABS( py[i].x-divider ) <= sqrt( min_dist ) ) {
				pyd[pyd_len++] = py[i];
			}
		}

		if( pyd_len > 1 ) {
			FOR( i,0,pyd_len-1 ) {
				for( j=i+1; j <= i+7 && j < pyd_len; j++ ) {
					if( ( d = DIST( pyd[i], pyd[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = pyd[i];
						min_p2 = pyd[j];
					}
				}
			}
		}

		free( pyd );
		free (pxl );
		free( pxr );
		free( pyl );
		free( pyr );
	}
}

inline int version( int a, int b, int x, int y )
{
	if( a == x && b == y ) {
		return 1;
	} else if( a == -x && b == y ) {
		return 2;
	} else if( a == x && b == -y ) {
		return 3;
	} else {
		return 4;
	}
}

int main()
{
	int i, j;
	int n, m, a, b;
	point pt;

	freopen( "input.txt", "r", stdin );
	freopen( "output.txt", "w", stdout );

	scanf( "%d", &n );

//	m = n << 2;
//	point px[n], py[n],  temp[n];;

	point *px, *py, *ver;

//	point px[n], py[n];
//	int ver[n];
	px = ( struct point * )malloc( n*sizeof( struct point ) );
	py = ( struct point * )malloc( n*sizeof( struct point ) );
	ver = ( int * )malloc( n*sizeof( int ) );

	j = 0;

	FOR( i,0,n-1 ) {
		scanf( "%d%d", &a, &b );
		pt.x = ABS(a);
		pt.y = ABS(b);
		pt.id = i+1;
		ver[i] = version( a, b, pt.x, pt.y );
		px[j] = py[j] = pt;
		j++;
	}

	sort( px, px+j, comparex );
	sort( py, py+j, comparey );

	closest_pair( px, py, n );

//	cout << min_dist << endl;
	printf( "%d %d %d %d\n", min_p1.id, ver[min_p1.id-1], min_p2.id, 5-ver[min_p2.id-1] );

	free( px );
	free( py );
	free( ver );

	return 0;
}


/*******************************************************************************************************************************************
* File Name   : j.cpp
* Development : Wed 19 Oct 2011 09:40:46 PM IST
* Author      : Xeronix
*******************************************************************************************************************************************/

#include <iostream>
#include <cstdio>
#include <vector>
#include <math.h>
#include <algorithm>
#include <string>
#include <cstring>
#include <string.h>
#include <cstdlib>
#include <sstream>
#include <stack>
#include <queue>
#include <numeric>
#include <utility>
#include <cctype>
#include <list>
#include <limits.h>
#include <signal.h>
#include <time.h>
#include <map>
#include <set>
#include <float.h>

#define TR(c, i) for ( typeof((c).begin()) i = (c).begin(); i != (c).end(); i++ )
#define FOR(i, a, b) for ( i = a; i <= b; i++ )
#define ROF(i, a, b) for ( i = a; i >= b; i-- )
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort( ALL(v) )
#define MAX(a, b) ((a) >= (b) ? (a) : (b))
#define MIN(a, b) ((a) <= (b) ? (a) : (b))
#define ABS(a) ((a) < (0) ? (a)*(-1) : (a))
#define SWAP(a, b) typeof(a) T; T=a; a=b; b=T;
#define SET(x,a) memset(x,a,sizeof(x))

//#define LIM
#ifdef LIM
	int S, D, Y;
	char *inp, *out, *ipos, *opos, DIG[30];
	#define FRMI inp=( char * )malloc( LIM*sizeof( char ) );fread_unlocked( inp,1,LIM,stdin );ipos=inp;
	#define FWM out=( char * )malloc( LIM*sizeof( char ) );opos=out;
	#define FWO fwrite_unlocked( out,opos-out,1,stdout );
        #define GETI(n) n=0;while(*ipos<33){ipos++;}if(*ipos=='-'){S=-1;ipos++;}else{S=1;}while(*ipos>='0'){n=10*n+(*ipos-'0');ipos++;}n*=S;
	#define PUTI(n) D=0;if(n<0){*opos++='-';n*=-1;}if(!n)*opos++='0';else{while(n){Y=n/10;DIG[D++]=n-Y*10+'0';n=Y;}\
	while(D--)*opos++=DIG[D];}
	#define PUTC(c) *opos++=c;
#endif

#define SQ(x) (x)*(x)
#define DIST( a,b ) ( SQ(a.x-b.x) + SQ(a.y-b.y) )
#define DISTI( a,b,c,d ) ( SQ(a+c) + SQ(b+d) )

using namespace std;
using namespace __gnu_cxx;

struct point {
	int x, y;
	int id;
};

bool comparex( point p, point q )
{
	return p.x < q.x;
}

bool comparey( point p, point q )
{
	return p.y < q.y;
}

point min_p1, min_p2;
int min_dist = INT_MAX;

void closest_pair( point *px, point *py, int n )
{
	int i, j;
	int d;

	if( n <= 3 ) {
		if( n >= 2 ) {
			FOR( i,0,n-2 ) {
				FOR( j,i+1,n-1 ) {
					if( ( d = DIST( px[i], px[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = px[i];
						min_p2 = px[j];
					}
				}
			}
		}
	} else {
		int mid, divider;

		mid = n >> 1;

//		point pxl[mid+1], pxr[mid+1];
		point pyl[mid+1], pyr[mid+1];
		point *pxl, *pxr;
//		point *pyl, *pyr;
		pxl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pxr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
//		pyl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
//		pyr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );

		int pyl_len, pyr_len;

		FOR( i,0,mid ) {
			pxl[i] = px[i];
			if( mid+i+1 < n ) {
				pxr[i] = px[mid+i+1];
			}
		}

		divider = px[mid].x;
		pyl_len = pyr_len = 0;

		FOR( i,0,n-1 ) {
			if( py[i].x <= divider ) {
				pyl[pyl_len++] = py[i];
			} else {
				pyr[pyr_len++] = py[i];
			}
		}

		closest_pair( pxl, pyl, mid );
		closest_pair( pxr, pyr, n-mid-1 );

//		point pyd[100];
		point *pyd;
		pyd = ( struct point * )malloc( n*sizeof( struct point ) );
		int pyd_len = 0;

		FOR( i,0,n-1 ) {
			if( ABS( py[i].x-divider ) <= sqrt( min_dist ) ) {
				pyd[pyd_len++] = py[i];
			}
		}

		if( pyd_len > 1 ) {
			FOR( i,0,pyd_len-1 ) {
				for( j=i+1; j <= i+7 && j < pyd_len; j++ ) {
					if( ( d = DIST( pyd[i], pyd[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = pyd[i];
						min_p2 = pyd[j];
					}
				}
			}
		}

		free( pyd );
		free(pxl);
		free(pxr);
//		free(pyl);
//		free(pyr);
	}
}

inline int version( int a, int b, int x, int y )
{
	if( a == x && b == y ) {
		return 1;
	} else if( a == -x && b == y ) {
		return 2;
	} else if( a == x && b == -y ) {
		return 3;
	} else {
		return 4;
	}
}

int main()
{
	int i, j;
	int n, m, a, b;
	point pt;

	freopen( "input.txt", "r", stdin );
	freopen( "output.txt", "w", stdout );

	scanf( "%d", &n );

//	m = n << 2;
//	point px[n], py[n],  temp[n];;

//	point *px, *py, *temp;

	point px[n], py[n];
	int ver[n];
//	px = ( struct point * )malloc( n*sizeof( struct point ) );
//	py = ( struct point * )malloc( n*sizeof( struct point ) );

	j = 0;

	FOR( i,0,n-1 ) {
		scanf( "%d%d", &a, &b );
		pt.x = ABS(a);
		pt.y = ABS(b);
		pt.id = i+1;
		ver[i] = version( a, b, pt.x, pt.y );
		px[j] = py[j] = pt;
		j++;
	}

	sort( px, px+j, comparex );
	sort( py, py+j, comparey );

	closest_pair( px, py, n );

//	cout << min_dist << endl;
	printf( "%d %d %d %d\n", min_p1.id, ver[min_p1.id-1], min_p2.id, 5-ver[min_p2.id-1] );

//	free( px );
//	free( py );

	return 0;
}


/*******************************************************************************************************************************************
* File Name   : j.cpp
* Development : Wed 19 Oct 2011 09:40:46 PM IST
* Author      : Xeronix
*******************************************************************************************************************************************/

#include <iostream>
#include <cstdio>
#include <vector>
#include <math.h>
#include <algorithm>
#include <string>
#include <cstring>
#include <string.h>
#include <cstdlib>
#include <sstream>
#include <stack>
#include <queue>
#include <numeric>
#include <utility>
#include <cctype>
#include <list>
#include <limits.h>
#include <signal.h>
#include <time.h>
#include <map>
#include <set>
#include <float.h>

#define TR(c, i) for ( typeof((c).begin()) i = (c).begin(); i != (c).end(); i++ )
#define FOR(i, a, b) for ( i = a; i <= b; i++ )
#define ROF(i, a, b) for ( i = a; i >= b; i-- )
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort( ALL(v) )
#define MAX(a, b) ((a) >= (b) ? (a) : (b))
#define MIN(a, b) ((a) <= (b) ? (a) : (b))
#define ABS(a) ((a) < (0) ? (a)*(-1) : (a))
#define SWAP(a, b) typeof(a) T; T=a; a=b; b=T;
#define SET(x,a) memset(x,a,sizeof(x))

//#define LIM
#ifdef LIM
	int S, D, Y;
	char *inp, *out, *ipos, *opos, DIG[30];
	#define FRMI inp=( char * )malloc( LIM*sizeof( char ) );fread_unlocked( inp,1,LIM,stdin );ipos=inp;
	#define FWM out=( char * )malloc( LIM*sizeof( char ) );opos=out;
	#define FWO fwrite_unlocked( out,opos-out,1,stdout );
        #define GETI(n) n=0;while(*ipos<33){ipos++;}if(*ipos=='-'){S=-1;ipos++;}else{S=1;}while(*ipos>='0'){n=10*n+(*ipos-'0');ipos++;}n*=S;
	#define PUTI(n) D=0;if(n<0){*opos++='-';n*=-1;}if(!n)*opos++='0';else{while(n){Y=n/10;DIG[D++]=n-Y*10+'0';n=Y;}\
	while(D--)*opos++=DIG[D];}
	#define PUTC(c) *opos++=c;
#endif

#define SQ(x) (x)*(x)
#define DIST( a,b ) ( SQ(a.x-b.x) + SQ(a.y-b.y) )
#define DISTI( a,b,c,d ) ( SQ(a+c) + SQ(b+d) )

using namespace std;
using namespace __gnu_cxx;

struct point {
	int x, y;
	int id;
};

bool comparex( point p, point q )
{
	return p.x < q.x;
}

bool comparey( point p, point q )
{
	return p.y < q.y;
}

point min_p1, min_p2;
int min_dist = INT_MAX;

void closest_pair( point *px, point *py, int n )
{
	int i, j;
	int d;

	if( n <= 3 ) {
		if( n >= 2 ) {
			FOR( i,0,n-2 ) {
				FOR( j,i+1,n-1 ) {
					if( px[i].id != px[j].id && ( d = DIST( px[i], px[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = px[i];
						min_p2 = px[j];
					}
				}
			}
		}
	} else {
		int mid, divider;

		mid = n >> 1;

		point pxl[mid+1], pxr[mid+1];
		point pyl[mid+1], pyr[mid+1];
/*		point *pxl, *pxr;
		point *pyl, *pyr;
		pxl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pxr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
*/
		int pyl_len, pyr_len;

		FOR( i,0,mid ) {
			pxl[i] = px[i];
			if( mid+i+1 < n ) {
				pxr[i] = px[mid+i+1];
			}
		}

		divider = px[mid].x;
		pyl_len = pyr_len = 0;

		FOR( i,0,n-1 ) {
			if( py[i].x <= divider ) {
				pyl[pyl_len++] = py[i];
			} else {
				pyr[pyr_len++] = py[i];
			}
		}

		closest_pair( pxl, pyl, mid );
		closest_pair( pxr, pyr, n-mid-1 );

//		point pyd[100];
		point *pyd;
		pyd = ( struct point * )malloc( n*sizeof( struct point ) );
		int pyd_len = 0;

		FOR( i,0,n-1 ) {
			if( ABS( py[i].x-divider ) <= sqrt( min_dist ) ) {
				pyd[pyd_len++] = py[i];
			}
		}

		if( pyd_len > 1 ) {
			FOR( i,0,pyd_len-1 ) {
				for( j=i+1; j <= i+7 && j < pyd_len; j++ ) {
					if( pyd[i].id != pyd[j].id && ( d = DIST( pyd[i], pyd[j] ) ) <= min_dist ) {
						min_dist = d;
						min_p1 = pyd[i];
						min_p2 = pyd[j];
					}
				}
			}
		}
	}
}

inline int version( int a, int b, int x, int y )
{
	if( a == x && b == y ) {
		return 1;
	} else if( a == -x && b == y ) {
		return 2;
	} else if( a == x && b == -y ) {
		return 3;
	} else {
		return 4;
	}
}

int main()
{
	int i, j;
	int n, m, a, b;
	point pt;

	freopen( "input.txt", "r", stdin );
	freopen( "output.txt", "w", stdout );

	scanf( "%d", &n );

//	m = n << 2;
//	point px[n], py[n],  temp[n];;

//	point *px, *py, *temp;

	point px[n], py[n], temp[n];
//	px = ( struct point * )malloc( n*sizeof( struct point ) );
//	py = ( struct point * )malloc( n*sizeof( struct point ) );
//	temp = ( struct point * )malloc( n*sizeof( struct point ) );

	j = 0;

	FOR( i,0,n-1 ) {
		scanf( "%d%d", &a, &b );
		temp[i].x = a;
		temp[i].y = b;
		temp[i].id = i+1;
		pt.x = ABS(a);
		pt.y = ABS(b);
		pt.id = i+1;
		//	a = ABS(a); b = ABS(b);
	/*	pt.id = i+1;
		pt.x = a; pt.y = b; pt.v = 1; px[j] = py[j] = pt; j++;
		pt.x = a*-1; pt.y = b; pt.v = 2; px[j] = py[j] = pt; j++;
		pt.x = a; pt.y = b*-1; pt.v = 3; px[j] = py[j] = pt; j++;
		pt.x = a*-1; pt.y = b*-1; pt.v = 4; px[j] = py[j] = pt; j++;
		*/
//		pt.v = version( a, b, pt.x, pt.y );
		px[j] = py[j] = pt;
		j++;
	}

	sort( px, px+j, comparex );
	sort( py, py+j, comparey );

	closest_pair( px, py, n );

	int ans[4];

	ans[0] = min_p1.x;
	ans[1] = min_p1.y;
	ans[2] = min_p2.x;
	ans[3] = min_p2.y;

	int d, ver1, ver2;

	ver1 = 1;
	ver2 = 1;

	min_dist = DISTI( min_p1.x, min_p1.y, min_p2.x, min_p2.y );

	FOR( i,0,15 ) {
		FOR( j,0,3 ) {
			if ( i & (1<<j) ) {
				ans[j] = ABS(ans[j])*-1;
			}
		}

		if( ( d = DISTI( ans[0], ans[1], ans[2], ans[3] ) ) < min_dist ) {
			min_dist = d;
			ver1 = version( ans[0], ans[1], temp[min_p1.id-1].x, temp[min_p1.id-1].y );
			ver2 = version( ans[2], ans[3], temp[min_p2.id-1].x, temp[min_p2.id-1].y );
//			cout << ans[0] << " " << ans[1] << " " << ans[2] << " " << ans[3] << endl;
//			cout << temp[min_p1.id-1].x << " " << temp[min_p1.id-1].y << endl;
//			cout << temp[min_p2.id-1].x << " " << temp[min_p2.id-1].y << endl;
		}
	}

//	cout << min_dist << endl;
	printf( "%d %d %d %d\n", min_p1.id, ver1, min_p2.id, ver2 );

//	free( px );
//	free( py );
//	free( temp );

	return 0;
}


/*******************************************************************************************************************************************
* File Name   : j.cpp
* Development : Wed 19 Oct 2011 09:40:46 PM IST
* Author      : Xeronix
*******************************************************************************************************************************************/

#include <iostream>
#include <cstdio>
#include <vector>
#include <math.h>
#include <algorithm>
#include <string>
#include <cstring>
#include <string.h>
#include <cstdlib>
#include <sstream>
#include <stack>
#include <queue>
#include <numeric>
#include <utility>
#include <cctype>
#include <list>
#include <limits.h>
#include <signal.h>
#include <time.h>
#include <map>
#include <set>
#include <float.h>

#define TR(c, i) for ( typeof((c).begin()) i = (c).begin(); i != (c).end(); i++ )
#define FOR(i, a, b) for ( i = a; i <= b; i++ )
#define ROF(i, a, b) for ( i = a; i >= b; i-- )
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort( ALL(v) )
#define MAX(a, b) ((a) >= (b) ? (a) : (b))
#define MIN(a, b) ((a) <= (b) ? (a) : (b))
#define ABS(a) ((a) < (0) ? (a)*(-1) : (a))
#define SWAP(a, b) typeof(a) T; T=a; a=b; b=T;
#define SET(x,a) memset(x,a,sizeof(x))

//#define LIM
#ifdef LIM
	int S, D, Y;
	char *inp, *out, *ipos, *opos, DIG[30];
	#define FRMI inp=( char * )malloc( LIM*sizeof( char ) );fread_unlocked( inp,1,LIM,stdin );ipos=inp;
	#define FWM out=( char * )malloc( LIM*sizeof( char ) );opos=out;
	#define FWO fwrite_unlocked( out,opos-out,1,stdout );
        #define GETI(n) n=0;while(*ipos<33){ipos++;}if(*ipos=='-'){S=-1;ipos++;}else{S=1;}while(*ipos>='0'){n=10*n+(*ipos-'0');ipos++;}n*=S;
	#define PUTI(n) D=0;if(n<0){*opos++='-';n*=-1;}if(!n)*opos++='0';else{while(n){Y=n/10;DIG[D++]=n-Y*10+'0';n=Y;}\
	while(D--)*opos++=DIG[D];}
	#define PUTC(c) *opos++=c;
#endif

#define SQ(x) (x)*(x)
#define DIST( a,b ) ( SQ(a.x-b.x) + SQ(a.y-b.y) )
#define DISTI( a,b,c,d ) ( SQ(a+c) + SQ(b+d) )

using namespace std;
using namespace __gnu_cxx;

struct point {
	int x, y;
	int id;
};

bool comparex( point p, point q )
{
	return p.x < q.x;
}

bool comparey( point p, point q )
{
	return p.y < q.y;
}

point min_p1, min_p2;
int min_dist = INT_MAX;

void closest_pair( point *px,  point *py, int n )
{
	int i, j;
	int d;

	if( n <= 10 ) {
		if( n >= 2 ) {
			FOR( i,0,n-2 ) {
				FOR( j,i+1,n-1 ) {
					if( ( d = DIST( px[i], px[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = px[i];
						min_p2 = px[j];
					}
				}
			}
		}
	} else {
		int mid, divider;

		mid = n >> 1;

//		point pxl[mid+1], pxr[mid+1];
//		point pyl[mid+1], pyr[mid+1];
	//	point *pxl, *pxr;
		point *pyl, *pyr;
	//	pxl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
	//	pxr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyl = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );
		pyr = ( struct point * )malloc( (mid+1)*sizeof( struct point ) );

		int pyl_len, pyr_len;
/*
		FOR( i,0,mid ) {
			pxl[i] = px[i];
			if( mid+i+1 < n ) {
				pxr[i] = px[mid+i+1];
			}
		}
*/
		divider = px[mid].x;
		pyl_len = pyr_len = 0;

		FOR( i,0,n-1 ) {
			if( py[i].x <= divider ) {
				pyl[pyl_len++] = py[i];
			} else {
				pyr[pyr_len++] = py[i];
			}
		}

		closest_pair( px, pyl, mid );
		closest_pair( px+mid, pyr, n-mid );

		point *pyd;
		pyd = ( struct point * )malloc( n*sizeof( struct point ) );
		int pyd_len = 0;

		FOR( i,0,n-1 ) {
			if( ABS( py[i].x-divider ) <= sqrt( min_dist ) ) {
				pyd[pyd_len++] = py[i];
			}
		}

		if( pyd_len > 1 ) {
			FOR( i,0,pyd_len-1 ) {
				for( j=i+1; j <= i+7 && j < pyd_len; j++ ) {
					if( ( d = DIST( pyd[i], pyd[j] ) ) < min_dist ) {
						min_dist = d;
						min_p1 = pyd[i];
						min_p2 = pyd[j];
					}
				}
			}
		}

		free( pyd );
		free( pyl );
		free( pyr );
	}
}

inline int version( int a, int b, int x, int y )
{
	if( a == x && b == y ) {
		return 1;
	} else if( a == -x && b == y ) {
		return 2;
	} else if( a == x && b == -y ) {
		return 3;
	} else {
		return 4;
	}
}

int main()
{
	int i, j;
	int n, m, a, b;
	point pt;

	freopen( "input.txt", "r", stdin );
	freopen( "output.txt", "w", stdout );

	scanf( "%d", &n );

	point *px, *py;
	int *ver;

//	point px[n], py[n];
//	int ver[n];
	px = ( struct point * )malloc( n*sizeof( struct point ) );
	py = ( struct point * )malloc( n*sizeof( struct point ) );
	ver = ( int * )malloc( n*sizeof( int ) );

	j = 0;

	FOR( i,0,n-1 ) {
		scanf( "%d%d", &a, &b );
		pt.x = ABS(a);
		pt.y = ABS(b);
		pt.id = i+1;
		ver[i] = version( a, b, pt.x, pt.y );
		px[j] = py[j] = pt;
		j++;
	}

	sort( px, px+j, comparex );
	sort( py, py+j, comparey );

	closest_pair( px, py, n );

	printf( "%d %d %d %d\n", min_p1.id, ver[min_p1.id-1], min_p2.id, 5-ver[min_p2.id-1] );

	free( px );
	free( py );
	free( ver );

	return 0;
}