### constant

DELTA = 1.0e-6

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

def cross(v0x, v0y, p0x, p0y, v1x, v1y)
  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]
end

def divpol(k, t, lines, areas)
  n = lines.length
  lk = lines[k]
  vx = lk[0] * t + lk[2]
  vy = lk[1] * t + lk[3]

  ak = areas[k]
  s0 = ak * t
  s1 = ak - s0

  for h in (1...n)
    st = cross(*lines[(k + h) % n], vx, vy)
    if ! st.nil?
      sh, th = st
      break if th >= 0.0 && th <= 1.0 && sh < 0.0
    end
  end
  #p [h, sh, th]

  ah = areas[(k + h) % n]
  s1 += ah * th
  s0 += ah * (1.0 - th)

  for i in (1...h)
    s1 += areas[(k + i) % n]
  end

  for i in ((h + 1)...n)
    s0 += areas[(k + i) % n]
  end

  s1 - s0
end

### main

#p cross(100.0, -100.0, 0.0, 100.0, 1.0, 0.0); exit

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

  pts = n.times.map{gets.split.map(&:to_f)}
  #p pts

  lines = []
  areas = []
  for i in (0...n)
    j = (i + 1) % n
    vx = pts[j][0] - pts[i][0]
    vy = pts[j][1] - pts[i][1]
    lines << [vx, vy, *pts[i]]
    areas << tarea(*pts[i], *pts[j])
  end
  #p lines
  #p areas

  dps = []
  fisnished = false

  for i in (0...n)
    dpi = divpol(i, 0.0, lines, areas)
    dps << dpi
    if dpi.abs < DELTA
      puts [lines[i][2], lines[i][3]].join(' ')
      finished = true
      break
    end
  end
  next if finished
  dps[n] = dps[0]

  for k in (0...n)
    break if dps[k] * dps[k + 1] < 0.0
  end
  #p [k, k + 1]

  t0 = 0.0
  t1 = 1.0

  while t1 - t0 > DELTA
    th = (t0 + t1) / 2
    dpt = divpol(k, th, lines, areas)
    if dpt.abs < DELTA
      t0 = t1 = th
      break
    elsif dpt < 0.0
      t0 = th
    else
      t1 = th
    end
  end
  th = (t0 + t1) / 2

  lk = lines[k]
  px = lk[0] * th + lk[2]
  py = lk[1] * th + lk[3]
  puts [px, py].join(' ')
end