#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <cmath>
#include <vector>
#include <algorithm>

using namespace std;

typedef struct _vector {

    long double x, y, z;

    _vector(long double _x = 0., long double _y = 0., long double _z = 0.) {
        x = _x;
        y = _y;
        z = _z;
    }

} my_vector;

typedef vector<my_vector> points;

typedef struct _plane {

    long double a, b, c, d;

    _plane(long double x1 = 0., long double y1 = 0., long double z1 = 0.,
        long double x2 = 0., long double y2 = 0., long double z2 = 0.,
        long double x3 = 0., long double y3 = 0., long double z3 = 0.) {
        a = -y2 * z1 + y3 * z1 + y1 * z2 - y3 * z2 - y1 * z3 + y2 * z3;
        b = x2 * z1 - x3 * z1 - x1 * z2 + x3 * z2 + x1 * z3 - x2 * z3;
        c = -x2 * y1 + x3 * y1 + x1 * y2 - x3 * y2 - x1 * y3 + x2 * y3;
        d = x3 * y2 * z1 - x2 * y3 * z1 - x3 * y1 * z2 +
            x1 * y3 * z2 + x2 * y1 * z3 - x1 * y2 * z3;
    }

    void set(long double _a, long double _b, long double _c, long double _d) {
        a = _a;
        b = _b;
        c = _c;
        d = _d;
    }

} plane;

typedef struct _line {
    my_vector a, b;

    _line(long double x1 = 0., long double y1 = 0., long double z1 = 0.,
        long double x2 = 0., long double y2 = 0., long double z2 = 0.) {
        a = my_vector(x1, y1, z1);
        b = my_vector(x2 - x1, y2 - y1, z2 - z1);
    }

} line;

typedef struct _parallelepiped {

    plane planes[6];

    _parallelepiped(long double x2 = 0., long double y2 = 0., long double z2 = 0.) {
        planes[0].set(1, 0, 0, 0);
        planes[1].set(0, 1, 0, 0);
        planes[2].set(0, 0, 1, 0);
        planes[3].set(-1, 0, 0, x2);
        planes[4].set(0, -1, 0, y2);
        planes[5].set(0, 0, -1, z2);
    }

} parallelepiped;

typedef struct _triangle {

    line a, b, c;

    plane p;

    _triangle(long double x1 = 0., long double y1 = 0., long double z1 = 0.,
        long double x2 = 0., long double y2 = 0., long double z2 = 0.,
        long double x3 = 0., long double y3 = 0., long double z3 = 0.) {
        my_vector temp = my_vector(x2 - x1, y2 - y1, z2 - z1);
        a = line(x1, y1, z1, x2, y2, z2);
        b = line(x2, y2, z2, x3, y3, z3);
        c = line(x3, y3, z3, x1, y1, z1);
        p = plane(x1, y1, z1, x2, y2, z2, x3, y3, z3);
    }

} triangle;

long double length(my_vector a) {
    return sqrt(a.x * a.x + a.y * a.y + a.z * a.z);
}

my_vector norm_vector(my_vector v) {
    long double l = length(v);
    v = my_vector(v.x / l, v.y / l, v.z / l);
    return v;
}

my_vector cross_vectors(my_vector a, my_vector b) {
    my_vector temp;
    temp.x = a.y * b.z - a.z * b.y;
    temp.y = a.z * b.x - a.x * b.z;
    temp.z = a.x * b.y - a.y * b.x;
    return temp;
}

typedef struct _basis {

    my_vector x, y, z;

    _basis(triangle t) {
        z = norm_vector(my_vector(t.p.a, t.p.b, t.p.c));
        y = norm_vector(t.a.b);
        x = norm_vector(my_vector(cross_vectors(z, y)));
    }

} basis;

typedef struct _matrix {

    long double values[3][3];

    _matrix(basis b) {
        values[0][0] = b.x.x; values[0][1] = b.x.y; values[0][2] = b.x.z;
        values[1][0] = b.y.x; values[1][1] = b.y.y; values[1][2] = b.y.z;
        values[2][0] = b.z.x; values[2][1] = b.z.y; values[2][2] = b.z.z;
    };

} matrix;

my_vector mul(my_vector v, matrix m) {
    my_vector res;
    res.x = v.x * m.values[0][0] + v.y * m.values[0][1] + v.z * m.values[0][2];
    res.y = v.x * m.values[1][0] + v.y * m.values[1][1] + v.z * m.values[1][2];
    res.z = v.x * m.values[2][0] + v.y * m.values[2][1] + v.z * m.values[2][2];
    return res;
}

my_vector line_plane_intersection(line l, plane p) {
    long double t = -(p.d + p.a * l.a.x + p.b * l.a.y + p.c * l.a.z) /
        (p.a * l.b.x + p.b * l.b.y + p.c * l.b.z);
    if (t != t) return my_vector(t, t, t);
    return my_vector(l.a.x + l.b.x * t, l.a.y + l.b.y * t, l.a.z + l.b.z * t);
}

long double dot_vectors(my_vector a, my_vector b) {
    long double res = 0;
    res += a.x * b.x;
    res += a.x * b.x;
    res += a.y * b.y;
    res += a.z * b.z;
    return res;
}

long double area(points pt) {
    if (pt.size() <= 2) return 0.;
    long double sum = 0.;
    for (size_t i = 0; i < pt.size() - 1; ++i) sum +=
        (pt[i].x + pt[i + 1].x) * (pt[i].y - pt[i + 1].y);
    sum += (pt[pt.size() - 1].x + pt[0].x) * (pt[pt.size() - 1].y - pt[0].y);
    return fabs(sum) / 2.0;
}

void cut(plane pl, parallelepiped p, int i, points* pt) {
    vector<my_vector> new_points;
    for (size_t i = 0; i < pt->size(); ++i) {
        my_vector a = (*pt)[i], b = i == pt->size() - 1 ? (*pt)[0] : (*pt)[i + 1];
        int ain = dot_vectors(a, my_vector(pl.a, pl.b, pl.c)) + pl.d >= 0, bin = dot_vectors(b, my_vector(pl.a, pl.b, pl.c)) + pl.d >= 0;
        if (ain && !bin) new_points.push_back(line_plane_intersection(line(a.x, a.y, a.z, b.x, b.y, b.z), pl));
        else if (!ain && bin) {
            new_points.push_back(line_plane_intersection(line(a.x, a.y, a.z, b.x, b.y, b.z), pl));
            new_points.push_back(b);
        }
        else if (bin) new_points.push_back(b);
    }
    pt->clear();
    pt->resize(new_points.size());
    for (size_t i = 0; i < new_points.size(); ++i) (*pt)[i] = new_points[i];
}

triangle t;
parallelepiped p;
points pt;

int main() {
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    long double x1, y1, z1, x2, y2, z2, x3, y3, z3;
    scanf("%Lf%Lf%Lf%Lf%Lf%Lf", &x1, &y1, &z1, &x2, &y2, &z2);
    p = parallelepiped(x2 - x1, y2 - y1, z2 - z1);
    long double dx = x1, dy = y1, dz = z1;
    scanf("%Lf%Lf%Lf%Lf%Lf%Lf%Lf%Lf%Lf", &x1, &y1, &z1, &x2, &y2, &z2, &x3, &y3, &z3);
    t = triangle(x1 - dx, y1 - dy, z1 - dz, x2 - dx, y2 - dy, z2 - dz, x3 - dx, y3 - dy, z3 - dz);
    pt.push_back(t.a.a);
    pt.push_back(t.b.a);
    pt.push_back(t.c.a);
    my_vector temp;
    for (int i = 0; i < 6; ++i) cut(p.planes[i], p, i, &pt);
    basis b(t);
    matrix m(b);
    for (size_t i = 0; i < pt.size(); ++i) pt[i] = mul(pt[i], m);
    long double s = area(pt);
    printf("%.5lf", s);
    return 0;
}