#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
typedef  vector<int> vi; typedef  vector<ll> vl; typedef  vector<bool> vb;
typedef  vector<double> vd;
typedef  vector<vd> vvd;

#define REP(i,n) for(ll i = 0; i < (n); ++i)
#define ALL(c) (c).begin(), (c).end()
#define FOR(i,s,e) for (ll i = s; i < (ll)e; i++)
#define TEN(x) ((ll)1e##x)

template<typename F> ld bsearch(ld lower, ld upper, ld k, ll max_loop, F f) {
	if (upper < lower) swap(upper, lower);
	ld nu = upper - lower, nl = 0;
	if (k < f(0)) swap(nl, nu); // ??????????°??????´???
	REP(_, max_loop) {
		ld mid = (nl + nu) / 2;
		(f(mid + lower) > k ? nu : nl) = mid;
	}
	return (nl + nu) / 2 + lower;
}

// ?????°
#define EPS (1e-10)

// ?????????
#define X real()
#define Y imag()
#define SZ size()
#define PB(x) push_back(x)
#define PREV(x, i) (x[(i+x.SZ-1) % x.SZ])
#define NEXT(x, i) (x[(i + 1) % x.SZ])

// ??????????????£??????
using ld = long double;
template<class T> using CR = const T &;

// ?¬??????¢??°
int sgn(ld a, ld b = 0) {
	if (a > b + EPS) return 1;
	if (a < b - EPS) return -1;
	return 0;
}

///////////////////////

// ???
using P = complex<ld>;
using G = vector<P>; // ???????¨???????
struct L : public vector<P> {
	L(P a, P b) { PB(a); PB(b); }
};

// ????????¢??°
namespace std {
	bool operator < (P a, P b) { return sgn(a.X, b.X) ? a.X < b.X : a.Y < b.Y; }
}

ld dot  (P a, P b) { return (conj(a)*b).X; }
ld cross(P a, P b) { return (conj(a)*b).Y; }

int ccw(P a, P b, P c) { // Verified : AOJCGL1C
	b -= a;
	c -= a;
	if (sgn(cross(b, c))) return sgn(cross(b, c)); // clockwise(-1) or counter clockwise(1)
	if (sgn(dot(b, c)) == -1) return 2;            // c--a--b
	if (sgn(norm(b), norm(c)) == -1) return -2;    // a--b--c
	return 0;                                      // a--c--b
}

bool iLS(CR<L> l, CR<L> s, bool strict = false) {
	int a = sgn(cross(l[1] - l[0], s[0] - l[0]))
	      * sgn(cross(l[1] - l[0], s[1] - l[0]));
	return strict ? a == -1 // strict
	              : a <= 0; // not strict
}
P pLL(CR<L> l, CR<L> m) {
	ld a = cross(l[1] - l[0], m[1] - m[0]);
	ld b = cross(l[1] - l[0], l[1] - m[0]);
	assert(sgn(a)); // parallel or same line
	return m[0] + b / a * (m[1] - m[0]);
}
G convex_cut(CR<G> g, CR<L> l) {
	G q;
	REP(i, g.size()) {
		if (ccw(l[0], l[1], g[i]) != -1) q.PB(g[i]);
		L s = { g[i], NEXT(g,i) };
		if (iLS(l, s, true)) q.PB(pLL(l, s));
	}
	return q;
}
ld area2(CR<G> g) {
	ld s = 0;
	REP(i, g.size()) s += cross(g[i], NEXT(g, i));
	return s;
}
L half_convex(CR<G> g, P p, ld lower, ld upper, ll max_loop) {
	ld ans = bsearch(lower, upper, area2(g) / 2, max_loop, [&](ld x){
		return area2(convex_cut(g, {p, p + polar<ld>(1, x)}));
	});
	
	return {p, p + polar<ld>(max_loop, ans)};
}

int main() {
#ifdef _WIN32
	ifstream cin("sample.in");
	ofstream cout("sample.out");
#endif
	cin.tie(0); // cin??¨cout?????£????????????
	ios_base::sync_with_stdio(false);
	cout << fixed << setprecision(50);

	while (true) {
		int n;
		cin >> n;
		if (n == 0) break;
		G g(n);
		REP (i, n) {
			ld x,y; cin >> x >> y;
			g[i].real(x);
			g[i].imag(y);
		}
		vector<ld> angles;
		angles.push_back(0);
		angles.push_back(acos(-1));
		REP (i, n) {
			ld angle = arg(g[i]);
			if (angle < 0) angle += acos(-1);
			angles.push_back(angle);
		}
		sort(ALL(angles));
		REP (i, angles.size() - 1) {
			L l = half_convex(g, 0, angles[i], angles[i + 1], 100);
			G cc = convex_cut(g, l);
			if (!sgn(area2(g)/2, area2(cc))) {
				cout << l[1].X << " " << l[1].Y << endl;
				break;
			}
		}
	}
	return 0;
}

Measured memory_bytes: 3656