#include <iostream>
#include <sstream>
#include <string>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cassert>

using namespace std;

#define FOR(i,k,n) for(int i=(k); i<(int)(n); ++i)
#define REP(i,n) FOR(i,0,n)
#define FORIT(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)

template<class T> void debug(T begin, T end){ for(T i = begin; i != end; ++i) cerr<<*i<<" "; cerr<<endl; }
inline bool valid(int x, int y, int W, int H){ return (x >= 0 && y >= 0 && x < W && y < H); }

typedef long long ll;
const int INF = 100000000;
const double EPS = 1e-8;
const int MOD = 1000000007;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};

#include <complex>
typedef complex<double> Point;

struct Line : public vector<Point> {
  Line(Point a, Point b){
    push_back(a); push_back(b);
  }
  Point vector() const {
    return back() - front();
  }
};

typedef vector<Point> Polygon;

int sign(double x){
  if(x > EPS) return 1;
  if(x < -EPS) return -1;
  return 0;
}
double dot(Point a, Point b){
  return real(conj(a) * b);
}
double cross(Point a, Point b){
  return imag(conj(a) * b);
}
int ccw(Point a, Point b, Point c){
  b -= a; c -= a;
  if(cross(b, c) > EPS) return 1;
  if(cross(b, c) < -EPS) return -1;
  if(dot(b, c) < 0) return +2;
  if(norm(b) < norm(c)) return -2;
  return 0;
}
Point crosspointLL(const Line& l, const Line& m){
  double A = cross(l.vector(), m.vector());
  double B = cross(l.vector(), l[1] - m[0]);
  if(sign(A) == 0 && sign(B) == 0) return m[0];
  if(sign(A) == 0) assert(false);
  return m[0] + m.vector() * B / A;
}
Polygon convex_cut(const Polygon& P, const Line& l){
  Polygon Q;
  REP(i, P.size()){
    Point A = P[i], B = P[(i + 1) % P.size()];
    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(crosspointLL(l, Line(A, B)));
    }
  }
  return Q;
}
double area(const Polygon& P){
  double A = 0;
  REP(i, P.size()){
    A += cross(P[i], P[(i + 1) % P.size()]);
  }
  return A / 2.0;
}
double f(const Polygon& P, double th){
  double A = area(P);
  Polygon Q = convex_cut(P, Line(Point(0,0), polar(2.0, th)));
  double B = area(Q);
  return B - A / 2;
}

int main(){
  int N;
  while(cin >> N && N){
    Polygon P(N);
    REP(i, N) cin >> P[i].real() >> P[i].imag();
    vector<double> args;
    args.push_back(0);
    args.push_back(M_PI);
    REP(i, N){
      double th = arg(P[i]);
      if(th < 0) th += M_PI;
      args.push_back(th);
      assert(th > -EPS && th < M_PI + EPS);
    }
    sort(args.begin(), args.end());
    Point ans;
    for(int i = 0; i < args.size() - 1; i++){
      if(f(P, args[i]) * f(P, args[i + 1]) <= 0){
        double lb = args[i], ub = args[i + 1];
        REP(iter, 100){
          double th = (lb + ub) * 0.5;
          if(f(P, th) * f(P, args[i + 1]) <= 0){
            lb = th;
          }else{
            ub = th;
          }
        }
        ans = polar(10.0, (lb + ub) * 0.5);
        goto OUTPUT;
      }
    }
OUTPUT:
    assert(abs(ans) > 1);
    assert(sign(f(P, arg(ans))) == 0);
    printf("%.15f %.15lf\n", ans.real(), ans.imag());
  }
  return 0;
}

Measured memory_bytes: 1372