Language: C++

#include <bits/stdc++.h>

using namespace std;
using ll = long long;
using ld = long double;

#define REP(i,n) for(ll i = 0; i < (n); ++i)
#define ALL(c) (c).begin(), (c).end()

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() {
	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, va.size() - 1) {
			L l = half_convex(g, 0, angles[i], angles[i + 1], 1000);
			G cc = convex_cut(g, l);
			if (!sig(area2(g)/2, area2(cc))) {
				printf("%.15Lf %.15Lf\n", l[1].X, l[0].Y);
				break;
			}
		}
	}
	return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:123:25: error: 'va' was not declared in this scope
  123 |                 REP (i, va.size() - 1) {
      |                         ^~
a.cc:7:37: note: in definition of macro 'REP'
    7 | #define REP(i,n) for(ll i = 0; i < (n); ++i)
      |                                     ^
a.cc:126:30: error: 'sig' was not declared in this scope; did you mean 'sin'?
  126 |                         if (!sig(area2(g)/2, area2(cc))) {
      |                              ^~~
      |                              sin