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

using std::vector;
using std::string;

typedef long double ldouble;

const ldouble eps = 1E-15;

typedef struct _vector {

    ldouble x, y, z;

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

} my_vector;

typedef vector<my_vector> points;

typedef struct _plane {

    ldouble a, b, c, d;

    _plane(ldouble x1 = 0., ldouble y1 = 0., ldouble z1 = 0.,
        ldouble x2 = 0., ldouble y2 = 0., ldouble z2 = 0.,
        ldouble x3 = 0., ldouble y3 = 0., ldouble 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(ldouble _a, ldouble _b, ldouble _c, ldouble _d) {
        a = _a;
        b = _b;
        c = _c;
        d = _d;
    }

} plane;

typedef struct _line {
    my_vector a, b;

    _line(ldouble x1 = 0., ldouble y1 = 0., ldouble z1 = 0.,
        ldouble x2 = 0., ldouble y2 = 0., ldouble 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(ldouble x2 = 0., ldouble y2 = 0., ldouble 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(ldouble x1 = 0., ldouble y1 = 0., ldouble z1 = 0.,
        ldouble x2 = 0., ldouble y2 = 0., ldouble z2 = 0.,
        ldouble x3 = 0., ldouble y3 = 0., ldouble 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;

ldouble 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) {
    ldouble 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 {

    ldouble 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) {
    ldouble 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);
}

ldouble dot_vectors(my_vector a, my_vector b) {
    ldouble res = 0;
    res += a.x * b.x;
    res +=