### constant

DELTA = 1e-10

### classes

class Pt
  attr_accessor :x, :y

  def initialize() end
  def initialize(_x, _y) @x = _x; @y = _y end

  def ==(pt) @x == pt.x && @y == pt.y end
  def +(pt) Pt.new(@x + pt.x, @y + pt.y) end
  def -(pt) Pt.new(@x - pt.x, @y - pt.y) end
  def -@() Pt.new(-@x, -@y) end
  def *(t) Pt.new(@x * t, @y * t) end
  def /(t) Pt.new(@x / t, @y / t) end
  def dot(v) @x * v.x + @y * v.y end
  def cross(v) @x * v.y - @y * v.x end
  def d2() @x * @x + @y * @y end
  def d() Math.sqrt(d2()) end
  def normalize() self / d() end
  def to_s() "(#{@x},#{@y})" end
  def to_a() [@x, @y] end
end

### subroutines

def calc_cr(c0, r0, pi, vi, ri, lb, ub)
  ci = rit = nil
  loop do
    t = (lb + ub) / 2
    ci = vi * t + pi
    rit = ri * t
    
    if (ci - c0).d > r0 + rit
      lb = t
    else
      ub = t
    end

    break if ub - lb <= DELTA
  end
  [ci, rit]
end

### main

loop do
  x0, y0, x1, y1, x2, y2 = gets.split.map(&:to_i)
  break if (x0 | y0 | x1 | y1 | x2 | y2) == 0

  pts = [
    Pt.new(x0.to_f, y0.to_f),
    Pt.new(x1.to_f, y1.to_f),
    Pt.new(x2.to_f, y2.to_f)
  ]
  #p pts.map{|pt| pt.to_a}

  ls = (0...3).map{|i| (pts[(i + 2) % 3] - pts[(i + 1) % 3]).d}
  lsum = ls.inject(:+)
  ipt = (0...3).map{|i| pts[i] * ls[i]}.inject(:+) / lsum
  r = (pts[1] - pts[0]).cross(pts[2] - pts[0]) / lsum
  
  divvs = []
  rs = []
  cts = []
  
  for i in (0...3)
    iv = ipt - pts[i]
    ivd = iv.d
    divvs << iv / ivd
    rs << r / iv.d
    cts << ivd
  end
  #p divvs.map{|v| v.to_a}
  #p rs

  lb = 0.0
  ub = cts[0]
  r0 = r1 = r2 = nil
  
  loop do
    t0 = (lb + ub) / 2
    c0 = divvs[0] * t0 + pts[0]
    r0 = rs[0] * t0

    c1, r1 = calc_cr(c0, r0, pts[1], divvs[1], rs[1], 0.0, cts[1])
    c2, r2 = calc_cr(c0, r0, pts[2], divvs[2], rs[2], 0.0, cts[2])

    if (c2 - c1).d2 > (r1 + r2) ** 2
      ub = t0
    else
      lb = t0
    end

    break if ub - lb <= DELTA
  end

  puts [r0, r1, r2].map{|r| "%.6f" % r}.join(' ')
end