#include <iostream>
#include <algorithm>
#include <cmath>
#include <complex>
#include <vector>
#include <cstdio>
using namespace std;

typedef complex<double> P;

const double EPS = 1e-5;
const double PI = acos(-1);
const int INF = 1<<24;

bool equals(double a, double b) { return fabs(a - b) < EPS; }

namespace std {
  bool operator < (const P &a, const P b) {
    return ( a.real() != b.real()
	     ? a.real() < b.real() : a.imag() < b.imag() );
  }
}

struct L : public vector<P> {
  L(P a, P b) {
    push_back(a), push_back(b);
  }
};

struct C {
  P o;
  double r;
  C() {}
  C(P o, double r) : o(o), r(r) {}
};

double norm(P a) { return a.real()*a.real() + a.imag() * a.imag(); }
double abs (P a) { return sqrt(norm(a)); }
double dot  (P a, P b) { return a.real()*b.real() + a.imag()*b.imag(); }
double cross(P a, P b) { return a.real()*b.imag() - a.imag()*b.real(); }

bool isOrthogonal(P a, P b) { return equals(dot(a, b), 0.0); }
bool isParallel  (P a, P b) { return equals(cross(a, b), 0.0); }

P project(P s1, P s2, P p) {
  P base = s2 - s1;
  double t = dot(p - s1, base)/norm(base);
  return s1 + base*t;
}

P reflect(P s1, P s2, P p) { return p + (project(s1, s2, p) - p)*2.0; }

double getDistanceLP(P s1, P s2, P p) {
  return fabs(cross(s2 - s1, p - s1)/abs(s2 - s1));
}

P getRotateP(P p, double rad, P o = P(0, 0)) {
  P q = p - o;
  return o + P(q.real()*cos(rad) - q.imag()*sin(rad),
	   q.real()*sin(rad) + q.imag()*cos(rad));
}

namespace CCW {
  enum { COUNTER_CLOCKWISE = 1, CLOCKWISE = -1,
	 ONLINE_BACK = 2, ONLINE_FRONT = -2,
	 ONSEGMENT = 0 };
}
int ccw(P p0, P a, P b) {
  a -= p0;
  b -= p0;
  if(cross(a, b) > EPS) return CCW::COUNTER_CLOCKWISE;
  if(cross(a, b) < -EPS) return CCW::CLOCKWISE;
  if(dot(a, b) < -EPS) return CCW::ONLINE_BACK;
  if(norm(a) < norm(b)) return CCW::ONLINE_FRONT;
  return CCW::ONSEGMENT;
}

// üªÆüªÌð·»èB
bool isIntersect(P a1, P a2, P b1, P b2) {
  return ( ccw(a1, a2, b1) * ccw(a1, a2, b2) <= 0 &&
	   ccw(b1, b2, a1) * ccw(b1, b2, a2) <= 0 );
}

// ¼üÆ~Ìð·»èBßèlÍð_ÌB
int isIntersect(P s1, P s2, C c) {
  double d = getDistanceLP(s1, s2, c.o);
  if(equals(d, c.r)) return 1;
  else if(d < c.r) return 2;
  else return 0;
}

// ~Æ~Ìð·»èB
//  0 : ð·AàïÈµ
//  1 : OÅ1_ÆÚ·é
//  2 : 2_Åð·
// -1 : àïµÄÚ·é
// -2 : ®SÉàï
int isIntersect(C a, C b) {
  double x = a.o.real() - b.o.real();
  double y = a.o.imag() - b.o.imag();
  double s = a.r + b.r;
  double d = x*x + y*y;
  s *= s;
  if(equals(d, s)) return 1;
  if(d > s) return 0;
  double r = abs(a.r - b.r);
  r *= r;
  if(equals(d, r)) return -1;
  if(d > r) return 2;
  return -2;
}

// ¼üÆ¼üÌð_B
P getCrossP(P a1, P a2, P b1, P b2) {
  P a = a2 - a1;
  P b = b2 - b1;
  // cross ÌÖW è
  return a1 + a * cross(b, b1 - a1)/cross(b, a);
}

// ¼üÆ~Ìð_B
vector<P> getCrossP(P s1, P s2, C c) {
  vector<P> v;
  P p = project(s1, s2, c.o);
  if(isIntersect(s1, s2, c) == 1) {
    v.push_back(p);
  } else {
    double h = abs(p-c.o);
    double d = sqrt(c.r*c.r - h*h);
    P base = s2 - s1;
    v.push_back(p + d*base/abs(base));
    v.push_back(p - d*base/abs(base));
  }
  return v;
}

// xNg(1, 0)ðîÆµ½xNgÌpx(-PI <= rad <= PI)
double getAngle(P a) {
  return atan2(a.imag(), a.real());
}

// 2ÂÌxNgÌÈ·p(0 <= rad <= PI)
double getAngle(P a, P b) {
  double rad1 = getAngle(a);
  double rad2 = getAngle(b);
  if(rad1 < 0) rad1 += 2*PI;
  if(rad2 < 0) rad2 += 2*PI;
  double res = fabs(rad1 - rad2);
  return res > PI ? 2*PI-res : res;
  //if(cross(a, b) < 0.0) swap(a, b);
  //return getAngle(b) - getAngle(a);
  //return acos(dot(a, b)/abs(a)/abs(b));
}

// 2ÂÌ¼üÉÚ·é¼arÌ~
C getC(P a1, P a2, P b1, P b2, double r) {
  P a = a2 - a1;
  P b = b2 - b1;
  if(cross(a, b) < 0) swap(a, b);
  P p = getCrossP(a1, a2, b1, b2);
  double rad = getAngle(a, b) / 2.0;
  double alpha = getAngle(a);
  C res;
  res.r = r;
  res.o = p + (P(cos(alpha + rad), sin(alpha + rad)) * r) / sin(rad);
  return res;
}

// wÌö®ðp¢ÄOp`Ì3ÓÌ·³©çÊÏðßé
double heron(double a, double b, double c) {
  double s = (a+b+c)/2.0;
  return sqrt(s*(s-a)*(s-b)*(s-c));
}

// ½p`ÌÊÏ
double getArea(vector<P> &G) {
  int n = G.size();
  double S = 0;
  for(int i = 0; i < n; ++i) {
    S += cross(G[i], G[(i+1)%n]);
  }
  return S/2.0;
}

// Op`ÌàÚ~Ì¼a
double getIncircleR(P p1, P p2, P p3) {
  double a = abs(p1 - p2);
  double b = abs(p2 - p3);
  double c = abs(p3 - p1);
  return heron(a,b,c)*2.0/(a+b+c);
}

C getIncircle(P p1, P p2, P p3) {
  return getC(p1, p2, p1, p3, getIncircleR(p1, p2, p3));
}

vector<P> convex_hull(vector<P> ps) {
  int n = ps.size(), k = 0;
  sort(ps.begin(), ps.end());
  vector<P> ch(2*n);
  for(int i = 0; i < n; ch[k++] = ps[i++])
    while(k >= 2 && ccw(ch[k-2], ch[k-1], ps[i]) <= 0) --k;
  for(int i = n-2, t = k+1; i >= 0; ch[k++] = ps[i--])
    while(k >= t && ccw(ch[k-2], ch[k-1], ps[i]) <= 0) --k;
  ch.resize(k-1);
  return ch;
}

vector<P> convex_cut(vector<P> ps, P p1, P p2, int dir = CCW::CLOCKWISE) {
  vector<P> v;
  for(int i = 0; i < ps.size(); ++i) {
    P a = ps[i];
    P b = ps[(i+1)%ps.size()];
    if(ccw(p1, p2, a) != dir) v.push_back(a);
    if(ccw(p1, p2, a)*ccw(p1, p2, b) == -1)
      v.push_back(getCrossP(a, b, p1, p2));
  }
  return v;
}

P p[3];
C incircle;

C calc(P a1, P a2, P b1, P b2, C c) {
  C res;
  double s, t;
  double br = -1;
  s = 0.0, t = incircle.r;
  while(1) {
    double r = (s+t)/2.0;
    res = getC(a1, a2, b1, b2, r);
    if(r == br) return res;
    br = r;
    int tmp = isIntersect(c, res);
    if(tmp == 0) {
      s = r;
    } else if(tmp == 1) {
      return res;
    } else {
      t = r;
    }
  }
}

void solve() {
  incircle = getIncircle(p[0], p[1], p[2]);
  double s, t;
  double br = -1;
  C c[3];
  s = 0.0, t = incircle.r;
  while(1) {
    double r = (s+t)/2.0;

    c[0] = getC(p[0], p[1], p[0], p[2], r);

    if(!isIntersect(c[0], incircle)) {
      s = r;
      continue;
    }

    c[1] = calc(p[1], p[2], p[1], p[0], c[0]);
    c[2] = calc(p[2], p[0], p[2], p[1], c[0]);

    int tmp = isIntersect(c[1], c[2]);

    if(r == br || tmp == 1) {
      for(int i = 0; i < 3; ++i) {
	if(i) printf(" ");
	printf("%.6f", c[i].r);
      }
      printf("\n");
      return;
    } else if(tmp == 0) {
      t = r;
    } else {
      s = r;
    }
    br = r;
  }
}

int main() {
  while(1) {
    bool allZero = true;
    for(int i = 0; i < 3; ++i) {
      cin >> p[i].real() >> p[i].imag();
      if(p[i].real() != 0 || p[i].imag() != 0) allZero = false;
    }
    if(allZero) break;
    solve();
  }
  return 0;
}

Measured memory_bytes: 0