#include <iostream>
#include <cstdio>
#include <cassert>
#include <cstring>
#include <vector>
#include <valarray>
#include <array>
#include <queue>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <algorithm>
#include <cmath>
#include <complex>
#include <random>

using namespace std;
typedef long long ll;

typedef long double R;
typedef complex<R> P;

const R EPS = 1e-10;
const R PI = acos((R)(-1));

/*
 -1 -> neg
  0 -> near 0
  1 -> pos
  */
int sgn(R a) {
    if (a < -EPS) return -1;
    if (a > EPS) return 1;
    return 0;
}

int sgn(R a, R b) {
    return sgn(b-a);
}

bool near(P a, P b) {
    return !sgn(abs(a-b));
}

bool lessP(const P &l, const P &r) {
    if (sgn(l.real(), r.real())) return l.real() < r.real();
    if (sgn(l.imag(), r.imag())) return l.imag() < r.imag();
    return false;
}

R cross(P a, P b) { return a.real()*b.imag() - a.imag()*b.real(); }
R dot(P a, P b) { return a.real()*b.real() + a.imag()*b.imag(); }

/* 1->cclock
  -1->clock
   0->on
   2->back
  -2->front
  */
int ccw(P a, P b, P c) {
    assert(!near(a, b));
    if (near(a, c) || near(b, c)) return 0;
    int s = sgn(cross(b-a, c-a));
    if (s) return s;
    if (dot(b-a, c-a) < 0) return 2;
    if (dot(a-b, c-b) < 0) return -2;
    return 0;
}

R ssqrt(R d) {
    d = max<R>(0, d);
    return sqrt(d);
}

R sacos(R d) {
    d = max<R>(-1, d);
    d = min<R>(1, d);
    return acos(d);
}

R deg2rad(R x) {
    return x/180*PI;
}

R rad2deg(R x) {
    return x/PI*180;
}

//?§???????[0, 2*PI)???
R radNorP(R x) {
    return fmod(fmod(x, 2*PI) + 2*PI, 2*PI);
}

//?§???????[-PI, PI)???
R radNorN(R x) {
    x = radNorP(x);
    if (x >= PI) x -= 2*PI;
    return x;
}

/**
 * radian??§???x???[l, r]?????\??£????????????????????\??????
 * 0:OFF
 * 1:IN
 * 2:ON
 */
bool inR(R l, R r, R x) {
    l = radNorP(l);
    r = radNorP(r);
    x = radNorP(x);
    if (!sgn(l, x) || !sgn(r, x)) return 2;
    if (!sgn(l, r)) return 0;
    if (sgn(l, r) == 1) {
        if (sgn(l, x) == 1 && sgn(x, r) == 1) return 1;
    } else {
        if (sgn(x, r) == 1 || sgn(l, x) == 1) return 1;
    }
    return 0;
}



struct L {
    P x, y;
    L() {};
    L(P x, P y) :x(x), y(y) {};
};

P vec(const L &l) {
    return l.y - l.x;
}

R abs(const L &l) {
    return abs(vec(l));
}

struct C {
    P p;
    R r;
    C() {}
    C(P p, R r) : p(p), r(r) {}
};


//return number of cross point
int crossCC(const C &c, const C &d, L &l) {
    if (near(c.p, d.p) && !sgn(c.r, d.r)) {
        l.x = l.y = c.p+P(c.r, 0);
        return -1;
    }
    R di = abs(c.p - d.p);
    if (sgn(c.r+d.r, di) == 1) return 0;
    if (sgn(di, abs(c.r-d.r)) == 1) return 0;
    R bth = arg(d.p - c.p);
    R th = sacos((c.r*c.r + di*di - d.r*d.r) / (2*c.r*di));
    l.x = c.p+polar<R>(c.r, bth+th);
    l.y = c.p+polar<R>(c.r, bth-th);
    if (sgn(th) == 0) return 1;
    return 2;
}

struct T {
    P d[3];
    T() {}
    T(P x, P y, P z) {
        d[0] = x; d[1] = y; d[2] = z;
    }
};

typedef vector<P> Pol;

P cu(const T &t, int i) {
    return t.d[(i%3+3)%3];
}

P cu(const Pol &p, int i) { 
    int s = p.size();
    return p[(i%s+s)%s];
};

T t;
R ars[3], are[3], ar[3], arb[3], dist[3];
C c[3];

bool calc() {
    R l = 0, r = min(dist[0], dist[2]);
    for (int i = 0; i < 100; i++) {
        R md = (l+r)/2;
        c[1] = C(cu(t, 1) + polar<R>(md, arb[1]), md*sin(ar[1]));
        if (abs(c[0].p-c[1].p) > c[0].r+c[1].r) {
            l = md;
        } else {
            r = md;
        }
    }
    l = 0, r = min(dist[0], dist[1]);
    for (int i = 0; i < 100; i++) {
        R md = (l+r)/2;
        c[2] = C(cu(t, 2) + polar<R>(md, arb[2]), md*sin(ar[2]));
        if (abs(c[0].p-c[2].p) > c[0].r+c[2].r) {
            l = md;
        } else {
            r = md;
        }
    }
    return abs(c[1].p-c[2].p) < c[1].r + c[2].r;
}

bool solve() {
    for (int i = 0; i < 3; i++) {
        R x, y;
        cin >> x >> y;
        t.d[i] = P(x, y);
    }
    if (cu(t, 0) == cu(t, 1) && cu(t, 1) == cu(t, 2)) return false;
    for (int i = 0; i < 3; i++) {
        ars[i] = radNorP(arg(cu(t, i+1) - cu(t, i)));
        are[i] = radNorP(arg(cu(t, i+2) - cu(t, i)));
        if (ars[i] > are[i]) are[i] += 2*PI;
        ar[i] = (are[i] - ars[i]) / 2;
        arb[i] = (are[i] + ars[i])/2;
        dist[i] = abs(cu(t, i+1) - cu(t, i+2));
    }
    R l = 0, r = min(dist[1], dist[2]) / cos(ar[0]);
    for (int i = 0; i < 100; i++) {
        R md = (l+r)/2;
        c[0] = C(cu(t,0) + polar<R>(md, arb[0]), md*sin(ar[0]));
        if (calc()) {
            l = md;
        } else {
            r = md;
        }
    }
    printf("%.20Lf %.20Lf %.20Lf\n", c[0].r, c[1].r, c[2].r);
    return true;
}

int main() {
    while (solve()) {}
    return 0;
}

Measured memory_bytes: 1244