#include<iostream>
#include<complex>
#include<vector>
#include<algorithm>
#include<cassert>
#include<cstdio>
#include<iomanip>
#include<cmath>
#include<cstdio>


using namespace std;

typedef double elem;
typedef complex<elem> point,vec;
typedef pair<point,point> line,seg;

const elem pi = 2.0 * acos(0.0);
const elem eps = 1e-10;
enum CCW{FRONT=0x01,RIGHT=0x02,BACK=0x04,LEFT=0x08,OVER=0x10};

point arcSortCenter;

bool eq(elem a, elem b){ return abs(b-a)<eps; }
bool ls(elem a, elem b){
  if( eq(a,b) ) return false;
  return a<b;
}
bool gt(elem a, elem b){
  if( eq(a,b) ) return false;
  return a>b;
}
bool le(elem a, elem b){
  return eq(a,b) || ls(a,b);
}
bool ge(elem a, elem b){
  return eq(a,b) || gt(a,b);
}

vec uvec(const vec &u){ return u/abs(u); }
elem dot(const point &a, const point &b){ return a.real() * b.real() + a.imag() * b.imag(); }
elem cross(const point &a, const point &b){ return a.real() * b.imag() - a.imag() * b.real(); }

bool cmpXy(const point &a, const point &b){
  if( !eq(a.real(),b.real() ) ) return ls(a.real(),b.real());
  if( !eq(a.imag(),b.imag() ) ) return ls(a.imag(),b.imag());
  return false;
}

elem varg(vec a, vec b){
  elem ret=arg(a)-arg(b);
  if(ret<0)ret+=2*pi;
  if(ret>2*pi)ret-=2*pi;
  if(eq(ret,2*pi))ret=0;
  return ret;
}

inline int ccw(const point &a, point b, point x){
  b -= a;
  x -= a;
  elem cr = cross(b,x);
  if( eq(cr,0.0) && ls(dot(b,x),0) ) return BACK;
  if( eq(cr,0.0) && ls(abs(b),abs(x)) ) return FRONT;
  if( eq(cr,0.0) ) return OVER;
  if( gt(cr,0) ) return LEFT;
  if( ls(cr,0) ) return RIGHT;
  assert(0);
}

bool lessArg(const point &a,const point &b){
  return ls(varg(vec(1,0),a-arcSortCenter),varg(vec(1,0),b-arcSortCenter));
}

void argSort(const point &O, vector<point> &vp){
  arcSortCenter = O;
  sort(vp.begin(),vp.end(),lessArg);
}

bool intersectedLL(const line &a, const line &b){ return !eq( cross(a.second-a.first,b.second-b.first), 0.0 ); }

point intersectionLL(const line &a, const line &b)
{
  vec va = a.second - a.first;
  vec vb = b.second - b.first;
  return a.first + va * ( cross(vb, b.first - a.first) / cross(vb,va) );
}

bool intersectionLL(const line &a, const line &b, point &ret){
  return intersectedLL( a, b ) ? ret = intersectionLL( a, b ), true : false;
}

bool intersectionLS(line l, seg s, point &ret){
  point tmp;
  return intersectionLL(l,s,tmp) ? ( ccw(s.first,s.second,tmp)&OVER ? ret=tmp, true : false ) : false;
}

elem areaOfPolygon(const vector<point> &vp){
  elem ret = 0;
  for(int i = 0; i < (int)vp.size(); ++i){
    ret += cross(vp[i],vp[(i+1)%vp.size()]);
  }
  return abs(ret/2.0);
}

elem areaOfTriangle(const point &a, const point &b, const point &c)
{
  return abs(cross(b-a,c-a)/2.);
}

void andrewConvexHull(const vector<point> &Q, vector<point> &CH)
{
  vector<point> T = Q;
  if(Q.size()<3){CH=Q;return ;}
  int n = T.size(), k = 0;
  sort( T.begin(), T.end(), cmpXy );
  CH.resize(2*n);
  for(int i = 0; i < n; CH[k++] = T[i++]){
    while( k >= 2 && ccw( CH[k-2], CH[k-1], T[i] )!=LEFT ) --k;
  }
  for(int i = n-2, t = k+1; i >= 0; CH[k++] = T[i--] ){
    while( k >= t && ccw( CH[k-2], CH[k-1], T[i] )!=LEFT ) --k;
  }
  CH.resize(k-1);
}

bool regularConvex(vector<point> &vp){
  vector<point> ret;
  for(int i = 0; i < (int)vp.size(); ++i){
    for(int j = i+1; j < (int)vp.size(); ++j){
      if( abs(vp[i]-vp[j])<eps ){
        vp.erase( vp.begin() + j );
        j = i;
      }
    }
  }
  andrewConvexHull( vp, ret );
  vp = ret;
  return true;
}

bool convexCut(const vector<point> &vp, // counter clock wise order
	       const line &l,
	       vector<point> &left)
{
  vector<point> tmp;
  for(int i = 0; i < (int)vp.size(); ++i){
    point is;
    seg s(vp[i],vp[(i+1)%vp.size()]);
    if( ccw(l.first, l.second, vp[i] )!=RIGHT ){
      tmp.push_back(vp[i]);
    }
    if(intersectionLS( l, s, is )&& gt(abs(is-s.first),0) && gt(abs(is-s.second),0) ){
      tmp.push_back(is);
    }
  }
  left = tmp;
  return true;
}

int main(){
  int tc=1;
  int N;
  while(1){
    //cin >> N && N){
    scanf("%d", &N);
    if( N == 0 ) break;
    // != EOF && N){
    elem K,_K;
    vector<point> vp, evp;
    point res;

    for(int i = 0; i < N; ++i){
      int x,y;
      scanf("%d%d", &x, &y);
      //cin >> x >> y;
      // int t = scanf("%d%d", &x, &y);
      vp.push_back( point(x,y) );
      // DEBUG( cout << x << ' ' << y << endl );
    }    
    
    for(int i = 0; i < N; ++i){
      evp.push_back( vp[i] );
      for(int j = 0; j < N; ++j){
        point is;
        if( intersectionLS(line(point(0,0),vp[i]),line(vp[j],vp[(j+1)%vp.size()]),is) ){
          evp.push_back( is );
        }
      }
    }
    
    argSort( point(0,0), evp );
    
    K = areaOfPolygon(vp);
    _K = areaOfPolygon(evp);

    //cout << K << ' ' << _K << endl;
    assert(eq(_K,K));
    
    for(int i = 0; i < (int)evp.size(); ++i){
      for(int j = i+1; j < (int)evp.size(); ++j){
        if( eq(abs(evp[i]-evp[j]),0) ){
          evp.erase( evp.begin() + j );
          j = i;
        }
      }
    }

    //for(int i = 0; i < (int)evp.size(); ++i){
      // DEBUG(cout << evp[i] << ' ');
    //}
    // DEBUG(cout << "\n----" << endl);

    // clockwise order

    for(int i = 0; i < (int)evp.size(); ++i){
      int i0=-1;
      vector<point> left;
      point A,B,C,D;
      elem a,b,c,d,S,T,F,M;      // s = (a k +b)/(c k +d)
      elem k1,k2;
      // elem s11;
      int answer_type = -1;

      for(int j = 0; j < (int)evp.size(); ++j){
        if( i != j && ccw(point(0,0),evp[i],evp[j]) == BACK ){
          i0 = j;
          break;
        }
      }
      assert(i0!=-1);

      convexCut( vp, line(point(0,0),evp[i]), left );

      A = evp[i];
      B = evp[(i+1)%evp.size()];
      C = evp[(i0+1)%evp.size()];
      D = evp[i0];

      // DEBUG(cout << A << ' ' << B << ' ' << C << ' ' << D << ' ' << (ccw(point(0,0),A,D) | ccw(point(0,0),B,C)) << endl);
      
      a = cross(D,A-B);
      b = cross(A,D);
      c = cross(D,A-B)+cross(C,B-A);
      d = cross(A,D)+cross(C,A);
      
      S = abs(cross(B,A))/2.;
      T = abs(cross(C,D))/2.;
      F = areaOfPolygon(left);
      M = F - K/2.;

      // DEBUG(cout << fixed << setprecision(9) << "a=" << a << " b=" << b << " c=" << c << " d=" << d << endl);
      // DEBUG(cout << "S = " << S << " T=" << T << " F=" << F << " M=" <<  M <<  endl);

      if( !eq(c,0) ){ // cS != 0 but S > 0
        // two solutions for k
        elem D = pow(-a*T+c*M+d*S,2.0)-4*c*S*(d*M-b*T);
        if( D >= 0 ){
          if( eq(D,0) ){
            k1 = (a*T-c*M-d*S)/(2*c*S);
            k2 = -1;
          }else{
            k1 = ( -sqrt(D)+a*T-c*M-d*S)/(2*c*S);
            k2 = (  sqrt(D)+a*T-c*M-d*S)/(2*c*S);
          } 
        }else{
          k1 = -1;
          k2 = -1;
        }
        answer_type=2;
      }else if(eq(c,0)){ // c == 0
        if( !eq(d*S,a*T) ){
          // one solution
          k1 = (d*M-b*T)/(a*T-d*S);
          k2 = -1;
          answer_type=1;
        }else{
          // infinite or no solutions
          k1 = 0.5;
          k2 = -1;
          answer_type=0;
        }
      }

      for(int j = 0; j < 2; ++j){
        elem k = j==0 ? k1 : k2;
        //cout << a*k+b << ' ' << c*k+d << endl;
	/*
	elem s;
        if( eq(c*k+d,0) ){
          s = k>0?0.5:-1;
        }else{
          s = (a*k+b)/(c*k+d);
        }
	*/
        if( k >= 0 && k <= 1 ){
          point kp = k*vec(B-A)+A;
          // point sp = s*vec(C-D)+D;
          // DEBUG(cout << "k = " << k << " s = " << s << ' ' << kp << ' ' << sp << ' ' << ccw(point(0,0),kp,sp) << endl);
          // DEBUG(cout << "ATYPE : " << answer_type << endl);
          
          convexCut(vp,line(kp,point(0,0)),left);
          // DEBUG(cout << "CUT POLYGON : " << endl);
          for(int l = 0; l < (int)left.size(); ++l){
            // DEBUG( cout << left[i] << ' ' );
          }
          // DEBUG(cout << endl);
          
          double Aleft = areaOfPolygon(left);
          
          if( answer_type==0 && !eq(Aleft,K/2.) ) goto next;
          // DEBUG(cout << "HALF : " << K/2. << ' ' << "LEFT PART : " << Aleft << endl);
          // DEBUG(cout << "ANSWER : " << kp << ' ' << point(0,0) << " TYPE : " << answer_type << endl);
          
          res = kp;
          // DEBUG(cout << tc << ' ' << fixed << setprecision(9) << K/2. << ' ' << Aleft << endl);
          assert(abs(K/2.-Aleft)<1e-8);
        }
      }
      // DEBUG(cout << endl);
    next:;
    }
    printf("%.15f %.15f\n", res.real(), res.imag());
    // DEBUG(cout << "----------" << endl);
    ++tc;
  }
  return 0;
}

Measured memory_bytes: 0