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<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(cin >> N && N){
    //scanf("%d", &N) != EOF && N){
    elem K,_K;
    vector<point> vp, evp;
    point res;

    for(int i = 0; i < N; ++i){
      int 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;
}