Problem: Sha, Nero, Eri, and Ko, who entered the University of Aizu Elementary School (Aizu University and Small), decided to participate in a programming contest called IPPC in order to play an active role as a competition programmer. However, IPPCs are required to participate in the contest as a team of three people, and it is not possible to form a team of four people. Therefore, they decided to form a team of two people and participate in a programming contest called IPOCH where two people can participate in one group.

Although the teams have been separated, their abilities are competing and they are good practice partners for each other.

One day their coach bought a whole cake to put in. They decided to eat it at Sha's house. However, when I got home and opened the box, the cake was deformed, and when viewed from above, it looked like a convex polygon instead of a circle. It seems that it was bad to have Nero carry it. There is a strawberry on top of the cake. For the time being, it was decided to cut this cake with a knife in half along a straight line through the strawberries in order to divide it into two teams. It is against their aesthetic sense to take the strawberries first before cutting the cake.

Your job is to divide a convex polygon K given on a two-dimensional plane by a straight line L passing through the origin (0, 0), and then divide the straight line L so that the areas of the two convex polygons created by the division are equal. To determine. If there are more than one, one of them will do.
<image>

Constraints

* All inputs are integers
* 3 ≤ N ≤ 20
* -100 ≤ xi ≤ 100 (1 ≤ i ≤ N)
* -100 ≤ yi ≤ 100 (1 ≤ i ≤ N)
* The number of test cases does not exceed 1,000.

Input

The input consists of multiple test cases. Each test case follows the format below.


N
x1 y1
x2 y2
...
xN yN


N is the number of vertices of the given convex polygon K. The points (xi, yi) (1 ≤ i ≤ N) are all the coordinates of the vertices that make up the convex polygon K and are different from each other. These are given in counterclockwise order. Also, a point on any side of the convex polygon K has a distance of 1 or more from the origin, and the convex polygon K always contains the origin. The end of input is indicated by one line containing one 0. Note that the three different points given by the input, including the origin, can be collinear.

Output

Output the point A (Ax, Ay) on the straight line L in the following format. However, the distance between point A and the origin must be 1 or more.


Ax Ay


When the convex polygon K is divided by the origin and a straight line passing through this point A, the difference in area between the two convex polygons must be less than 10-5. I want the coordinates of point A to be output 15 digits after the decimal point.

Example

Input

4
-100 -100
100 -100
100 100
-100 100
4
-99 -100
100 -100
100 100
-99 100
4
-100 -99
100 -99
100 100
-100 100
14
-99 -70
-92 -79
10 -98
37 -100
62 -95
77 -69
88 -47
92 -10
96 28
100 91
42 92
-62 92
-88 91
-98 64
0


Output

100.000000000000000 0.000000000000000
100.000000000000000 0.000000000000000
0.000000000000000 100.000000000000000
-96.983291994836122 66.745111613942484

Solution (in CPP):

Solution:
#include <ctime>
#include <iostream>
#include <cstdio>
#include <vector>
#include <complex>
#include <cmath>
#include <algorithm>
using namespace std;

const double EPS = 1e-8;
const double INF = 1e12;
const double PI = acos(-1.0);

// 2つのスカラーが等しいかどうか
bool equal(double a, double b) {
	return fabs(a - b) < EPS;
}
// 点クラス
struct P {
	double x, y;
	P(double x_, double y_) { x = x_; y = y_; }
	P(){}
	// 加算, 減算, スカラー倍
	P operator+(const P& a) const {
		return P(x + a.x, y + a.y);
	}
	P operator-(const P& a) const {
		return P(x - a.x, y - a.y);
	}
	P operator*(const P& a) const {
		return P(x * a.x - y * a.y, x * a.y + y * a.y);
	}
	P operator*(double c) const {
		return P(x * c, y * c);
	}
	P operator/(const P& a) const {
		double norm = a.x * a.x + a.y * a.y;
		double x_ = (x * a.x + y * a.y) / norm;
		double y_ = (y * a.x - x * a.y) / norm;
		return P(x_, y_);
	}
	P operator/(double c) const {
		return P(x / c, y / c);
	}
	P& operator+=(const P& a) {
		x += a.x; y += a.y;
	}
	P& operator-=(const P& a) {
		x -= a.x; y -= a.y;
	}
	P& operator*=(const P& a) {
		*this = P(x * a.x - y * a.y, x * a.y + y * a.y);
	}
	P& operator*=(double c) {
		*this = P(x * c, y * c);
	}
	P& operator/=(const P& a) {
		double norm = a.x * a.x + a.y * a.y;
		double x_ = (x * a.x + y * a.y) / norm;
		double y_ = (y * a.x - x * a.y) / norm;
		*this = P(x_, y_);
	}
	P& operator/=(double c) {
		*this = P(x / c, y / c);
	}
	// デバッグ出力
	void print() { printf("(%f,%f)", x, y); }
};
P operator*(double c, P a){
	return P(a.x * c, a.y * c);
}
// 比較演算子
bool operator==(const P& a, const P& b) {
	return equal(a.x, b.x) && equal(a.y, b.y);
}
bool operator!=(const P& a, const P& b) {
	return !(a == b);
}
bool operator<(const P& a, const P& b) {
	return (a.x != b.x)? a.x < b.x : a.y < b.y;
}

const P INF_P = P(INF, INF);

// 原点からの距離(絶対値)
double abs(P a) {
	return sqrt(a.x * a.x + a.y * a.y);
}
// 2点間の距離
double dist(P a, P b) {
	return abs(a - b);
}
// ノルム
double norm(const P& z){
	return z.x * z.x + z.y * z.y;
}
// 偏角
double arg(const P& z) {
	return atan2(z.y, z.x);
}
// ベクトル a の単位ベクトルを求める
P unit(P a) {
	return a / abs(a);
}
// ベクトル a の法線ベクトルを求める
vector<P> normal(P a) {
	vector<P> vp;
	vp.push_back( a * P(0, +1) );
	vp.push_back( a * P(0, -1) );
	return vp;
}
// 内積 (dot product) : a・b = |a||b|cosΘ
double dot(P a, P b) {
	return a.x * b.x + a.y * b.y;
}
// 外積 (cross product) : a×b = |a||b|sinΘ
double cross(P a, P b) {
	return a.x * b.y - a.y * b.x;
}

// CCW : 反時計回り (Counter Clock Wise)
// CW : 時計回り (Clock Wise)
enum {CCW=1, CW=-1, ON=0};
// * 3点がどちら回りであるか返す, 3点が1直線に乗っているときは ON を返す
int ccw(const P &a, P b, P c) {
	b -= a, c -= a;
	if( cross(b,c) >  EPS ) return CCW; // CCW : 反時計回り
	if( cross(b,c) < -EPS ) return CW;  // CW : 時計回り
	if( dot(b, c)  < -EPS ) return +2;  // c--a--b on line
	if( dot(b, b)  + EPS < dot(c, c) ) return -2; // a--b--c on line 
	return ON;
}

// ラジアンから度数へ変換して返す
double to_deg(double rad) {
	return rad * 180.0 / PI;
}
// 度数からラジアンに変換して返す
double to_rad(double deg) {
	return deg * PI / 180.0;
}

// 原点を軸に点 p を角度 a (ラジアン)だけ回転させた点を返す
P rot(P p, double a){
	return P(p.x * cos(a) - p.y * sin(a), p.x * sin(a) + p.y * cos(a));
}
// 点 a を軸に点 b を角度 angle (ラジアン)だけ回転させた点を返す
P rot(P a, P b, double angle){
	return rot(b - a, angle) + a;
}

// 点 c を点 a, b を通る直線の線対称に移動させる
P symmetry(P a, P b, P c) {
	P res;
	if( b.x == a.x ) {
		res.x = -c.x; res.y = c.y;
	}else{
		double m = (b.y - a.y) / (b.x - a.x);
		double z = b.y - m * b.x;
		res.x = (2 * m * c.y - c.x * (m * m - 1) - 2 * m * z) / (m * m + 1);
		res.y = (2 * m * c.x + c.y * (m * m - 1) + 2 * z) / (m * m + 1);
	}
	return res;
}

// 直線クラス
struct Line : public vector<P> {
	Line(){}
	Line(const P& a, const P& b) {
		push_back(a); push_back(b);
	}
	Line(const vector<P>& vp){
		(*this) = vp;
	}
	// デバッグ出力 (線分を出力)
	void print_s() const {
		printf("line(%f,%f,%f,%f); \n", (*this)[0].x, (*this)[0].y, (*this)[1].x, (*this)[1].y);
	}
	// デバッグ出力 (直線を出力, 途中で直線が途切れているときは適当にlenの値を大きくする)
	void print_l() const {
		const double len = 100;
		P p1 = (*this)[0], p2 = (*this)[1];
		double dx = p1.x - p2.x, dy = p1.y - p2.y;
		p1.print();
		p2.print();
		p1.x += len * dx;
		p1.y += len * dy;
		p2.x -= len * dx;
		p2.y -= len * dy;
		Line l( p1 , p2 );
		l.print_s();
	}
};

// 2つの直線の直交判定
bool is_orthogonal(const Line& a, const Line& b) {
	return equal( dot( a[0] - a[1] , b[0] - b[1] ) , 0.0 );
}
// 2つの直線の平行判定
bool is_parallel(const Line& a, const Line& b) {
	return equal( cross( a[0] - a[1] , b[0] - b[1] ), 0.0 );
}

// 直線 a と直線 b の交差判定
bool intersectLL(const Line& a, const Line& b) {
	return abs(cross(a[1] - a[0], b[1] - b[0])) > EPS || abs(cross(a[1] - a[0], b[0] - a[0])) < EPS;
}
// 直線 l と 線分 s の交差判定
bool intersectLS(const Line& l, const Line& s) {
	return cross(l[1] - l[0], s[0] - l[0]) * cross(l[1] - l[0], s[1] - l[0]) < EPS;
}
// 直線 l 上に点 p があるかどうか
bool intersectLP(const Line& l, const P& p) {
	return abs(cross(l[1] - p, l[0] - p)) < EPS;
}
// 線分 s と 線分 t の交差判定
bool intersectSS(const Line& s, const Line& t) {
	return ccw(s[0], s[1], t[0]) * ccw(s[0], s[1], t[1]) <= 0 &&
		   ccw(t[0], t[1], s[0]) * ccw(t[0], t[1], s[1]) <= 0;
}
// 線分 s 上に点 p があるかどうか
bool intersectSP(const Line& s, const P& p) {
	return abs(s[0] - p) + abs(s[1] - p) - abs(s[1] - s[0]) < EPS;
}

P projection(const Line& l, const P& p) {
	double t = dot(p - l[0], l[0] - l[1]) / norm(l[0] - l[1]);
	return l[0] + (l[0] - l[1]) * t;
}
P reflection(const Line& l, const P& p) {
	return p + 2 * (projection(l, p) - p);
}
// 直線と点の距離
double distanceLP(const Line& l, const P& p) {
	return abs(p - projection(l, p));
}
// 直線と直線の距離
double distanceLL(const Line& l, const Line& m) {
	return intersectLL(l, m) ? 0 : distanceLP(l, m[0]);
}
// 直線と線分の距離
double distanceLS(const Line& l, const Line& s) {
	if (intersectLS(l, s)) return 0;
	return min(distanceLP(l, s[0]), distanceLP(l, s[1]));
}
// 線分と点の距離
double distanceSP(const Line& s, const P& p) {
	const P r = projection(s, p);
	if (intersectSP(s, r)) return abs(r - p);
	return min(abs(s[0] - p), abs(s[1] - p));
}
// 線分と線分の距離
double distanceSS(const Line& s, const Line& t) {
	if (intersectSS(s, t)) return 0;
	double a = min(distanceSP(s, t[0]), distanceSP(s, t[1]));
	double b = min(distanceSP(t, s[0]), distanceSP(t, s[1]));
	return min(a, b);
}
// 交点計算
P crosspoint(const Line& l, const Line& m) {
	double A = cross(l[1] - l[0], m[1] - m[0]);
	double B = cross(l[1] - l[0], l[1] - m[0]);
	if (abs(A) < EPS && abs(B) < EPS) return m[0]; // same line
	// if (abs(A) < EPS) assert(false); // !!!PRECONDITION NOT SATISFIED!!!
	return m[0] + B / A * (m[1] - m[0]);
}

// 円クラス
struct Circle{
	P p;
	double r;
	// コンストラクタで初期化
	Circle(P p_, double r_) { p = p_; r = r_; }
	// 点 a が円の内部にあるかどうか
	bool is_inside(P a) const {
		return dist(p, a) <= r;
	}
	// 点 a が円周上にあるかどうか
	bool on_boundary(P a) const {
		return equal( dist(p, a) , r );
	}// 等しいかどうか
	bool operator==(const Circle& c) const {
		return p == c.p && r == c.r;
	}// デバッグ出力
	void print() { printf("circle(%f,%f,%f); \n", p.x, p.y, r ); }
};

struct Triangle{
private:
	// 余弦定理から 3 つの角の角度を求める (内部の関数で使用)
	double law_of_cos(double a, double b, double c) {
		return acos( (b*b + c*c - a*a) / (2.0 * b * c) );
	}
	// 点 a , b を端点とする線分に点 c が含まれているかどうか
	bool contain(P a, P b, P c) {
		return abs(a - c) + abs(b - c) - abs(b - a) < EPS;
	}
public:
	// 3 つの頂点
	P a, b, c;
	// 3 つの辺の長さ
	double edgeA, edgeB, edgeC;
	// 3 つの角の角度 (ラジアン)
	double angleA,angleB,angleC;
	// コンストラクタで初期化
	Triangle(P p1, P p2, P p3) {
		a = p1; b = p2; c = p3;
		edgeB = abs(c-a);
		edgeA = abs(b-c);
		edgeC = abs(a-b);
		angleA = law_of_cos( edgeA, edgeB, edgeC );
		angleB = law_of_cos( edgeB, edgeC, edgeA );
		angleC = law_of_cos( edgeC, edgeA, edgeB );
	}
	// 三角形の面積を返す (ヘロンの公式)
	double get_area() {
		double s = 0.5 * (edgeA + edgeB + edgeC);
		return sqrt( s * (s - edgeA) * (s - edgeB) * (s - edgeC) );
	}
	// 点 p が三角形の辺上にあるかどうか
	bool on_boundary(P p) {
		return contain(a, b, p) || contain(b, c, p) || contain(c, a, p);
	}
	// 三角形の重心を返す
	P gravity() {
		return P( (a.x + b.x + c.x) / 3.0 , (a.y + b.y + c.y) / 3.0 );
	}
	// 三角形の外接円を返す (AOJ 0010 で検証済み)
	Circle circumscribed_circle() {
		double r = ( edgeA / sin(angleA) / 2.0 );
		double A = sin( 2.0 * angleA );
		double B = sin( 2.0 * angleB );
		double C = sin( 2.0 * angleC );
		double cx = ( (a.x * A + b.x * B + c.x * C) / (A + B + C) );
		double cy = ( (a.y * A + b.y * B + c.y * C) / (A + B + C) );
		return Circle( P(cx,cy) , r );
	}
	// 三角形の内接円を返す
	Circle inscribed_circle() {
		// 三角形の外周の長さ
		double ABC = edgeA + edgeB + edgeC;
		
		double cx = (a.x * edgeA + b.x * edgeB + c.x * edgeC) / ABC;
		double cy = (a.y * edgeA + b.y * edgeB + c.y * edgeC) / ABC;
		double r  = (2.0 * get_area()) / ABC ;
		return Circle( P(cx,cy) , r );
	}
	// 点 p が三角形の内部にあるかどうか ( AOJ 0012 で検証済み )
	bool is_inside(P p) {
		// 辺上にあるとき
		if( this->on_boundary(p) ) return true;
		
		Triangle t1( a , b , p );
		Triangle t2( b , c , p );
		Triangle t3( c , a , p );
		// 角APB + 角BPB + 角CPA が 360度なら 点 p は三角形の内部にある
		return equal( t1.angleC + t2.angleC + t3.angleC , 2.0*PI );
	}
	// デバッグ出力
	void print() {
		Line AB(a,b), BC(b,c), CA(c,a);
		AB.print_s();
		BC.print_s();
		CA.print_s();
	}
};

typedef vector<P> Polygon;

// 点 p が単純多角形の内部・外部・境界のどこにあるか判定する.
enum { OUT, IN };
int contains(const Polygon& g, const P& p) {
	int n = g.size();
	bool in = false;
	for(int i = 0 ; i < n ; i++ ){
		P a = g[i] - p;
		P b = g[(i+1)%n] - p;
		if( a.y > b.y ){
			swap(a, b);
		}
		if( a.y <= 0 && 0 < b.y ){
			if( cross(a, b) < 0 ){
				in = !in;
			}
		}
		if( cross(a, b) == 0 && dot(a, b) <= 0 ){
			return ON;
		}
  }
  return in? IN : OUT;
}
// (凸とは限らない) 多角形の面積を返す.
double get_area(const Polygon& g) {
	int n = g.size();
	double s = 0;
	for(int i = 0 ; i < n ; i++ )
		s += cross(g[i], g[(i+1) % n]);
	return fabs(s) * 0.5;
}

// 凸多角形かどうか
bool is_convex(const Polygon& g) {
	int n = g.size();
	for(int i = 0 ; i < n ; i++ ){
		if( ccw(g[(i+n-1) % n], g[i % n], g[(i+1) % n]) > 0 )
			return false;
	}
	return true;
}

// 凸包を求める. (ps.size() >= 3 と仮定する)
vector<P> convex_hull(vector<P> ps) {
	int n = ps.size();
    sort( ps.begin() , ps.end() );
     
    // 上部を求める
    vector<P> ch_u( n );
    int n_u = 0;
    for(int i = n-1 ; i >= 0 ; i-- ) {
        ch_u[n_u++] = ps[i];
        while( n_u >= 3 && ccw( ch_u[n_u-3] , ch_u[n_u-2] , ch_u[n_u-1] ) != CCW ) {
            ch_u[n_u-2] = ch_u[n_u-1];
            n_u--;
        }
    }
  
    vector<P> ch_l( n );
    int n_l = 0;
    for(int i = 0 ; i < n ; i++ ) {
        ch_l[n_l++] = ps[i];
        while( n_l >= 3 && ccw( ch_l[n_l-3] , ch_l[n_l-2] , ch_l[n_l-1]) != CCW ) {
            ch_l[n_l-2] = ch_l[n_l-1];
            n_l--;
        }
    }
  
    Polygon ch;
    for(int i=0 ; i<n_u-1 ; i++ ) ch.push_back(ch_u[i]);
    for(int i=0 ; i<n_l-1 ; i++ ) ch.push_back(ch_l[i]);
    return ch;
}

// 凸多角形をある直線で切断し，その左側だけ残す．
Polygon convex_cut(const Polygon& g, const Line& l) {
	Polygon Q;
	int n = g.size();
	for(int i = 0 ; i < n ; i++ ){
		P A = g[i], B = g[(i+1) % n];
		if( ccw(l[0], l[1], A) != -1 ){
			Q.push_back(A);
		}
		if( ccw(l[0], l[1], A) * ccw(l[0], l[1], B) < 0 ){
			Q.push_back(crosspoint(Line(A, B), l));
		}
	}
	return Q;
}
// 凸多角形の重心を返す
P gravity(const Polygon& g) {
	P sg(0,0);
	double s = 0.0;
	for(int i=2 ; i < g.size() ; i++ ) {
		Triangle t( g[0] , g[i-1] , g[i] );
		s += t.get_area();
		sg += t.get_area() * t.gravity();
	};
	return sg / s;
}

// 点 p が凸多角形の内部・外部・境界のどれにあるか判定する.
int convex_contains(const Polygon& g, const P& p) {
	const int n = g.size();
	P pp = (g[0] + g[n/3] + g[2*n/3]) / 3.0;
	int a = 0, b = n;
	while( a + 1 < b ){
		int c = (a + b) / 2;
		if( cross(g[a] - pp, g[c] - pp) > 0 ){
			if( cross(g[a] - pp, p - pp) > 0 && cross(g[c] - pp, p - pp) < 0 ){
				b = c;
			}else{
				a = c;
			}
		}else{
			if( cross(g[a] - pp, p - pp) < 0 && cross(g[c] - pp, p - pp) > 0 ){
				a = c;
			}else{
				b = c;
			}
		}
	}
	b %= n;
	if( cross(g[a] - p, g[b] - p) < 0 ) return OUT;
	if( cross(g[a] - p, g[b] - p) > 0 ) return IN;
	return ON;
}

// 2つの凸多角形の共通部分の凸多角形を返す
bool intersect_1pt(const P& a, const P& b, const P& c, const P& d, P &r) {
	double D =  cross(b - a, d - c);
	if( equal(D,0) ) return false;
	double t =  cross(c - a, d - c) / D;
	double s = -cross(a - c, b - a) / D;
	r = a + t * (b - a);
	return ( t >= 0 && t <= 1 && s >= 0 && s <= 1 );
}
Polygon convex_intersect(Polygon p, Polygon q) {
	const int n = p.size();
	const int m = q.size();
	int a = 0, b = 0, aa = 0, ba = 0;
	enum { Pin, Qin, Unknown } in = Unknown;
	Polygon R;
	do {
		int a1 = (a+n-1) % n;
		int b1 = (b+m-1) % m;
		double C = cross( p[a] - p[a1] , q[b] - q[b1] );
		double A = cross( p[a1] - q[b], p[a] - q[b] );
		double B = cross( q[b1] - p[a], q[b] - p[a] );
		P r;
		if( intersect_1pt( p[a1], p[a], q[b1], q[b], r ) ) {
			if( in == Unknown ) aa = ba = 0;
			R.push_back( r );
			in = (B > 0) ? Pin : (A > 0)? Qin : in ;
		}
		if( C == 0 && B == 0 && A == 0 ) {
			if( in == Pin ) {
				b = (b + 1) % m;
				++ba;
			}else {
				a = (a + 1) % m;
				++aa;
			}
		}else if( C >= 0 ) {
			if( A > 0 ) {
				if( in == Pin ) R.push_back( p[a] );
				a = (a+1) % n;
				++aa;
			}else {
				if( in == Qin ) R.push_back( q[b] );
				b = (b+1) % m;
				++ba;
			}
		}else {
			if( B > 0 ) { 
				if( in == Qin ) R.push_back( q[b] );
				b = (b+1) % m;
				++ba;
			}else {
				if( in == Pin ) R.push_back( p[a] );
				a = (a+1) % n;
				++aa;
			}
		}
	}while( (aa < n || ba < m) && aa < 2*n && ba < 2*m );
	if( in == Unknown ) {
		if( convex_contains(q, p[0]) ) return p;
		if( convex_contains(p, q[0]) ) return q;
	}
	return R;
}

// 凸多角形の直径を求める. (最遠頂点対は pp に入る)
P diff(const Polygon& g, int i){
	return g[(i+1) % g.size()] - g[i];
}
double convex_diameter(const Polygon& pt, pair<P,P>& pp) {
	const int n = pt.size();
	int is = 0, js = 0;
	for(int i = 1 ; i < n ; i++ ){
		if( pt[i].y > pt[is].y ) is = i;
		if( pt[i].y < pt[js].y ) js = i;
	}
	double maxd = norm(pt[is] - pt[js]);
	int i, maxi, j, maxj;
	i = maxi = is;
	j = maxj = js;
	do{
		if( cross(diff(pt,i), diff(pt,j)) >= 0){
			j = (j+1) % n;
		}else{
			i = (i+1) % n;
		}
		
		if( norm(pt[i] - pt[j]) > maxd ){
			maxd = norm(pt[i] - pt[j]);
			maxi = i;
			maxj = j;
		}
	}while( i != is || j != js );
	pp = pair<P,P>(pt[maxi], pt[maxj]);
	return maxd;
}

// 直線 l の方向( l[0] から l[1] へのベクトル ) と 最も遠い点を返す
double d(int k, const Polygon& g, const Line& l) {
	return dot(g[k], l[1] - l[0]);
}
P convex_extreme(const Polygon& g, const Line& l) {
	int a = 0, b = g.size(), n = g.size();
	if( d(0,g,l) >= d(n-1,g,l) && d(0,g,l) >= d(1,g,l) ){
		return g[0];
	}
	while( a < b ) {
		int c = (a + b) / 2;
		if( d(c,g,l) >= d(c-1,g,l) && d(c,g,l) >= d(c+1,g,l) ){
			return g[c];
		}
		if( d(a+1,g,l) > d(a,g,l) ){
			if( d(c+1,g,l) <= d(c,g,l) || d(a,g,l) > d(c,g,l) ){
				b = c;
			}else{
				a = c;
			}
		}else{
			if( d(c+1,g,l) > d(c,g,l) || d(a,g,l) >= d(c,g,l) ){
				a = c;
			}else{
				b = c;
			}
		}
	}
}

int random(int a, int b){
    int range = b - a + 1;
    return rand() % range + a;
}
double random_2(){
    return (double)rand() / RAND_MAX ;
}

int main(){
	srand((unsigned int)time(NULL));
	int n;
	while( cin >> n , n ){
		vector<P> v;
		for(int i=0 ; i < n ; i++ ){
			double x, y;
			cin >> x >> y;
			v.push_back( P(x,y) );
		}
        double s = get_area(v);
         
        double low = PI * 0.5, high = PI * 1.5, mid = (low + high) / 2.0;
        bool flag1 = false, flag2 = false;
        for(int i=0 ; i < 100 ; i++ ){
            if( flag1 && flag2 ) break;
             
            mid = random_2() * 2.0 * PI ;
            Line l( P(0, 0), P(sin(mid), cos(mid)) );
            double s1 = get_area(convex_cut(v, l));
            double s2 = s - s1;
             
            if( s1 - s2 > 0 ){
                low = mid;
                flag1 = true;
            }else{
                high = mid;
                flag2 = true;
            }
        }
        while( low > high ) high += 2.0 * PI ;
         
        for(int i=0 ; i < 100 ; i++ ){
            mid = (low + high) / 2.0;
            Line l( P(0, 0), P(sin(mid), cos(mid)) );
            double s1 = get_area(convex_cut(v, l));
            double s2 = s - s1;
             
            if( s1-s2 > 0 ){
                low = mid;
            }else{
                high = mid;
            }
        }
        {
            double ax = sin(mid);
            double ay = cos(mid);
            printf("%.15f %.15f\n", ax , ay );
        }
	}
}