class Combination
  def initialize(a, b, d)
    @a, @b, @d, @x, @y = a, b, d, 0, 0
  end

  def measure
    @a * @x - @b * @y
  end

  def go_next
    @x += 1 until measure >= @d
    @y += 1 until measure <= @d
  end

  def total_number
    @x + @y
  end

  def total_mass
    @a * @x + @b * @y
  end

  def ok?
    measure == @d
  end

  def to_a
    [@x, @y]
  end

  def movable?
    return true
  end
end

class Combination2 < Combination
  def initialize(a, b, d)
    @a, @b, @d, @x, @y = a, b, d, 0, 0
    if @a < @b
      @y += 1 until measure >= @d
    else
      @x += 1 until measure >= @d
    end
  end

  def measure
    @a * @x + @b * @y
  end

  def go_next
    if @a < @b
      @x += 1
      @y -= 1 if measure - @b >= @d
    else 
      @y += 1
      @x -= 1 if measure - @a >= @d
    end
  end

  def movable?
    if @a < @b
      @y > 0
    else
      @x > 0
    end
  end
end

def select_best(cs)
  return c1.ok? ? c1 : c2 if c1.ok? ^ c2.ok?
  return c1 if c1.total_number < c2.total_number
  return c2 if c1.total_number > c2.total_number
  return c1 if c1.total_mass < c2.total_mass
  return c2 if c1.total_mass > c2.total_mass
  return c1
end

loop do
  a, b, d = gets.split.map(&:to_i)
  break if a == 0
  c1, c2, c3 = Combination.new(a, b, d), Combination.new(b, a, d), Combination2.new(a, b, d)
  cs = [c1, c2, c3]
  loop do
    if cs.any?(&:ok?)
      n = cs.map {|c| c.ok? ? c.total_number : Float::INFINITY}.min
      cs.each {|c| c.go_next until c.ok? or c.total_number > n or !c.movable?}
      c = cs.min_by {|c| [c.ok? ? 0 : 1, c.total_number, c.total_mass]}
      puts (c == c1 ? c1.to_a : c == c2 ? c2.to_a.reverse : c3.to_a) * " "
      break
    else
      c1.go_next
      c2.go_next
      c3.go_next if c3.movable?
    end
  end
end
