#include<bits/stdc++.h>
using std::cin;
using std::cout;
using ll = long long;
using u64 = unsigned long long;
using db = double;
const int N = 200005;
const db eps = 1e-8;
db sgn(db x) {
	return x < -eps ? -1 : x > eps;
}
struct p3 {
	db x, y, z;
	db norm() {
		return x * x + y * y + z * z;
	}
};
p3 operator + (p3 x, p3 y) { return {x.x + y.x, x.y + y.y, x.z + y.z}; }
p3 operator - (p3 x, p3 y) { return {x.x - y.x, x.y - y.y, x.z - y.z}; }
p3 operator * (p3 x, db y) { return {x.x * y, x.y * y, x.z * y}; }
p3 operator / (p3 x, db y) { return {x.x / y, x.y / y, x.z / y}; }
db operator % (p3 x, p3 y) { return x.x * y.x + x.y * y.y + x.z * y.z; }
p3 operator * (p3 x, p3 y) {
	return {x.y * y.z - x.z * y.y,
		x.z * y.x - x.x * y.z,
		x.x * y.y - x.y * y.x};
}
struct plane {
	p3 n; db d;
	plane(p3 v, db d) : n(v), d(d) {}
	db side(p3 x) const { return n % x + d; }
	plane(p3 a, p3 b, p3 c) : n((c - a) * (b - a)) {
		d = -(n % a);
	}
};
struct line3 {
	p3 d, o;
	line3(plane p1, plane p2) : d(p1.n * p2.n) {
		o = (p2.n * p1.d - p1.n * p2.d) * (-1.) * d / d.norm();
	}
	p3 operator & (const plane & p) const {
		return o - d * p.side(o) / (p.n % d);
	}
};
struct p2 {
	db x, y;
	db abs() const {
		return sqrt(x * x + y * y);
	}
};
p2 r90(p2 x) {
	return {-x.y, x.x};
}
p2 operator + (p2 x, p2 y) { return {x.x + y.x, x.y + y.y}; }
p2 operator - (p2 x, p2 y) { return {x.x - y.x, x.y - y.y}; }
p2 operator / (p2 x, db y) { return {x.x / y, x.y / y}; }
db operator * (p2 x, p2 y) { return x.x * y.y - x.y * y.x; }
struct line  : p2 {
	db z;
	line() {}
	line(p2 a, p2 b) : p2(r90(b - a)), z(a * b) {

	}
	db operator () (p2 a) const {
		return a.x * x + a.y * y + z;
	}
	void red() {
		db v = abs();
		x /= v;
		y /= v;
		z /= v;
	}
};
p2 operator & (line x, line y) {
	return p2{p2{x.z, x.y} * p2{y.z, y.y}, p2{x.x, x.z} * p2{y.x, y.z}} / -(p2(x) * p2(y));
}
std::vector<p2> cut(std::vector<p2> & o, line l) {
	static std::vector<p2> res;
	res.clear();
	int n = size(o);
	l.red();
	for(int i = 0;i < n;++i) {
		p2 a = o[i], b = o[i == n - 1 ? 0 : i + 1];
		int va = sgn(l(a));
		int vb = sgn(l(b));
		if(va >= 0) res.push_back(a);
		if(va * vb < 0) res.push_back(line(a, b) & l);
	}
	if(res.size() <= 2) return {};
	return res;
}
std::vector<plane> ps;
std::vector<line> ls;
void init() {
	ls.resize(ps.size());
	for(int i = 0;i < (int) ps.size();++i) {
		ls[i].x = ps[i].n.x;
		ls[i].y = ps[i].n.y;
		ls[i].z = ps[i].d;
	}
}

db area(db z) {
	std::vector<p2> v = {
		p2{-500, -500},
		p2{500, -500},
		p2{500, 500},
		p2{-500, 500}
	};
	for(int i = 0;i < (int) ps.size();++i) {
		line tmp = ls[i];
		tmp.z += ps[i].n.z * z;
		if(tmp.abs() > eps) {
			v = cut(v, tmp); } else {
			if(tmp.z < -eps) {
				return 0;
			}
		}
		if(v.empty()) return 0;
	}
	db sum = 0;
	for(int i = 2;i < (int) v.size();++i) {
		sum += (v[i - 1] - v[0]) * (v[i] - v[0]);
	}
	return sum;
}


db g(db a, db b, db c) {
	return (a + b * 4 + c) / 6;
}
db simp(db l, db m, db r, db vl, db vm, db vr) {
	db ml = (l + m) / 2, vml = area(ml);
	db mr = (r + m) / 2, vmr = area(mr);
	if(fabs(g(vl, vml, vm) + g(vm, vmr, vr) - g(vl, vm, vr) * 2) * (r - l) < 1e-6) {
		return (g(vl, vml, vm) + g(vm, vmr, vr)) / 2 * (r - l);
	}
	return simp(l, ml, m, vl, vml, vm) + simp(m, mr, r, vm, vmr, vr);
}
int main() {
#ifdef zqj
	//freopen("1.in", "r", stdin);
#endif
	std::ios::sync_with_stdio(false), cin.tie(0);
	int x[5], y[5], z[5];
	for(;cin >> x[1] >> y[1] >> z[1];) {
		for(int j = 2;j <= 4;++j) {
			cin >> x[j] >> y[j] >> z[j];
		}
		for(int * a : {x, y, z}) if(a[2] < a[1])
			for(int j = 1;j <= 4;++j) {
				a[j] *= -1;
			}
		p3 D {x[1], y[1], z[1]};
		p3 A {x[2], y[1], z[1]};
		p3 B {x[1], y[2], z[1]};
		p3 C {x[1], y[1], z[2]};
		if(x[3] > x[4]) std::swap(x[3], x[4]);
		if(y[3] > y[4]) std::swap(y[3], y[4]);
		if(z[3] > z[4]) std::swap(z[3], z[4]);
		auto volume = [&](p3 d, p3 a, p3 b, p3 c) {
			return (d - a) % ((b - a) * (c - a));
		};
		if(volume(D, A, B, C) < 0) {
			std::swap(A, C);
		}

		plane P(A, B, C);
		db sum = 0;
		db sideD = -P.side(D);
		for(int j = 0;j < 8;++j) {
			int u = x[1], v = y[1], w = z[1];
			u = std::max(u, x[3 + (j >> 0 & 1)]);
			v = std::max(v, y[3 + (j >> 1 & 1)]);
			w = std::max(w, z[3 + (j >> 2 & 1)]);
			p3 p{u,v,w};
			db sidep = -P.side(p);
			if(sidep >= 0) {
				db S = sidep / sideD;
				S *= S * S;
				sum += (__builtin_popcount(j) % 2 ? -1 : 1) * S;
			}
		}
		printf("%.10lf\n", sum * volume(D, A, B, C) / 6);

	}
}