object Main extends App {
  import scala.io.StdIn._

  val efs = 0.0000001


  solve
  def solve: Unit ={
    val Array(n, r, q) = readLine.trim.split(' ').map(_.toInt)
    if (n == 0) return
    val circle = Circle(Point(0, 0), r)
    val convex = Array.tabulate(n){_ ⇒
      val Array(x, y) = readLine.trim.split(' ').map(_.toInt)
      Point(x, y)
    }
    var current = convex.indices.find(p ⇒ math.abs(convex(p).distanceFrom(circle.center) - circle.radius) < efs).get
    var angle = Vector(circle.center, convex(current)).angle
    for (_ ← 0 until q){
      val next = findNext(convex, circle, current)
      angle -= circle.angleByChord(convex(current).distanceFrom(convex(next)))
      current = next
      println(s"${angle.cos * r} ${angle.sin * r}")
    }
    solve
  }
  def findNext(convex: Array[Point], circle: Circle, current: Int): Int = {
    //convex(current)がcircleの円周上にある場合に時計回りで次に接するconvex上の点
    //circle上の点で、ここにconvex(current)があるとする
    val basePosition = Vector(convex(current), circle.center).let(v ⇒ circle.center + Vector(v.x / v.norm * circle.radius, v.y / v.norm * circle.radius))
    //basePositionから見たcircle.centerの角度
    val baseAngle = Vector(basePosition, circle.center).angle
    //convex上の点をconvex(current)がbasePointに来るようにシフトしたもの
    val shifted = convex.map(c ⇒ c - convex(current) + basePosition)
    //求める点の候補
    var suspect = (current + 1) % convex.length
    var fromAngle = Vector(basePosition, shifted(suspect)).angle
    //Edge(basePoint, shifted(suspects)) がcircle上の時計回りの弦であるときの basePointから見たconvex(suspect)の角度。toAngle - fromAngleが回転すべき角度
    var toAngle = Angle.byCos(basePosition.distanceFrom(shifted(suspect)) / 2 / circle.radius) + baseAngle
    while (!shifted.map(c ⇒ c.rotateWith(basePosition, toAngle - fromAngle)).forall(p ⇒ circle.contains(p))){
      suspect = (suspect + 1) % convex.length
      fromAngle = Vector(basePosition, shifted(suspect)).angle
      toAngle = Angle.byCos(basePosition.distanceFrom(shifted(suspect)) / 2 / circle.radius) + baseAngle
    }
    suspect
  }

  object Vector{
    def apply(from: Point, to: Point): Vector = (to - from).let(p ⇒ Vector(p.x, p.y))
  }
  case class Vector(x: Double, y: Double) {
    def norm: Double = math.sqrt(x * x + y * y)
    def angle: Angle = Angle(this)
    def rotate(angle: Angle): Vector = Vector(x * angle.cos - y * angle.sin, x * angle.sin + y * angle.cos)
  }
  case class Point(x: Double, y: Double) {
    def distanceFrom(that: Point): Double = math.sqrt((x - that.x) * (x - that.x) + (y - that.y) * (y - that.y))
    def +(that: Point): Point = Point(x + that.x, y + that.y)
    def +(vector: Vector): Point = Point(x + vector.x, y + vector.y)
    def -(that: Point): Point = Point(x - that.x, y - that.y)
    def rotateWith(origin: Point, angle: Angle): Point = origin + Vector(origin, this).rotate(angle)
  }
  object Angle {
    def apply(vector: Vector): Angle = {
      new Angle(vector.y / vector.norm, vector.x / vector.norm)
    }
    def byCos(cos: Double): Angle = {
      new Angle(math.sqrt(1 - cos * cos), cos)
    }
    def bySin(sin: Double): Angle = {
      new Angle(sin, math.sqrt(1 - sin * sin))
    }
  }
  class Angle private (val sin: Double, val cos: Double) {
    def +(that: Angle): Angle = new Angle(sin * that.cos + cos * that.sin, cos * that.cos - sin * that.sin)
    def -(that: Angle): Angle = new Angle(sin * that.cos - cos * that.sin, cos * that.cos + sin * that.sin)
    def complementaryAngle: Angle = new Angle(cos, sin)
  }
  case class Edge(from: Point, to: Point) {
    def length: Double = from.distanceFrom(to)
  }
  case class Circle(center: Point, radius: Double) {
    def contains(point: Point): Boolean = center.distanceFrom(point) <= radius + efs
    def angleByChord(chord: Double): Angle = {
      Angle.bySin(chord / 2 / radius).let(a ⇒ a + a)
    }
  }
  implicit class Scope[T](val value: T) extends AnyVal{
    @inline
    def also(@inline func: T ⇒ Unit): T = {
      func(value)
      value
    }
    @inline
    def let[A](func: T ⇒ A): A = func(value)
  }
}


Measured memory_bytes: 469152