### constant

PI2 = Math::PI * 2

DELTA = 1.0e-16
N_DIV = 100
DIVPI = Math::PI / N_DIV

### classes

class ConvexPolygon
  def initialize(pts)
    npts = pts.length

    ths = []
    for pt in pts
      thi = Math.atan2(pt[1], pt[0])
      thi += PI2 if thi < 0.0
      ths << thi
    end

    @area = 0.0
    @lines = []

    for i in (0...npts)
      j = (i + 1) % npts

      pix, piy = pts[i]
      pjx, pjy = pts[j]
      vx = pjx - pix
      vy = pjy - piy
      thi = ths[i]
      thj = ths[j]
      ar = _tarea(pix, piy, pjx, pjy)
      @area += ar

      if thi <= thj
        @lines << [thi, thj, vx, vy, pix, piy, ar]
      else
        ti = _cross_line(vx, vy, pix, piy, 0.0)
        p0x = vx * ti + pix
        p0y = vy * ti + piy
        @lines << [thi, PI2, p0x - pix, p0y - piy, pix, piy, ar * ti]
        if ti < 1.0
          @lines << [0.0, thj, pjx - p0x, pjy - p0y, p0x, p0y, ar * (1.0 - ti)]
        end
      end
    end

    @lines.sort!
    @n = @lines.length
  end

  def cut(th0)	# 0.0 <= th0 < PI
    th1 = th0 + Math::PI
    harea = 0.0

    for k in (0...@n)
      thi, thj, vx, vy, px, py, ar = @lines[k]
      next if thj < th0

      if thi <= th0 && th0 <= thj
        ti = _cross_line(vx, vy, px, py, th0)
        harea += ar * (1.0 - ti)
      elsif th0 <= thi && thj <= th1
        harea += ar
      elsif thi <= th1 && th1 <= thj
        ti = _cross_line(vx, vy, px, py, th1)
        harea += ar * ti
        break
      end
    end
    harea / @area
  end

  def cross_pt(th)
    for line in @lines
      if line[0] <= th && th <= line[1]
        ti = _cross_line(*line[2, 4], th)
        px = line[2] * ti + line[4]
        py = line[3] * ti + line[5]
        return [px, py]
      end
    end
    nil
  end

  def _tarea(p0x, p0y, p1x, p1y)
    (p0x * p1y - p0y * p1x).abs / 2
  end

  def _cross_line(v0x, v0y, p0x, p0y, th)
    v1x = Math.cos(th)
    v1y = Math.sin(th)

    d = v0x * v1y - v0y * v1x
    return nil if d == 0.0

    sd = -v0y * p0x + v0x * p0y
    td = -v1y * p0x + v1x * p0y
    #[s * v1x, s * v1y]
    #(t >= 0.0 && t <= 1.0) ? s : nil
    #[sd / d, td / d]
    td / d
  end
end

### main

dths = (0..N_DIV).map{|i| DIVPI * i}

loop do
  n = gets.to_i
  break if n == 0

  pts = n.times.map{gets.split.map(&:to_f)}
  cp = ConvexPolygon.new(pts)
  #p cp
  #p cp.cut(0.0)

  cuts = dths.map{|th| cp.cut(th) - 0.5}
  th = nil

  for i in (0...N_DIV)
    th0 = dths[i]
    cut0 = cuts[i]
    if cut0.abs < DELTA
      th = th0
      break
    end

    th1 = dths[i + 1]
    cut1 = cuts[i + 1]
    if cut1.abs < DELTA
      th = th1
      break
    end

    next if cut0 * cut1 > 0.0

    while th1 - th0 > DELTA
      th2 = (th0 + th1) / 2
      cut2 = cp.cut(th2) - 0.5
      if cut2.abs < DELTA
        th0 = th1 = th2
        break
      end

      if cut0 * cut2 > 0.0
        th0 = th2
      else
        th1 = th2
      end
    end

    th = th2
    break
  end

  cpt = cp.cross_pt(th)
  printf("%.15f %.15f\n", *cpt)
end