#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;

using ld = long double;

istream& operator>>(istream& in, array<ld, 3>& p) {
  for (int i = 0; i < 3; ++i) {
    in >> p[i];
  }
  return in;
}

const ld EPS = 1e-9;

void solve(array<ld, 3> p1, array<ld, 3> p2) {
  array<ld, 3> l, r;
  cin >> l >> r;
  for (int i = 0; i < 3; ++i) {
    if (p1[i] > p2[i]) {
      p1[i] *= -1;
      p2[i] *= -1;
      l[i] *= -1;
      r[i] *= -1;
    }
    if (l[i] > r[i]) swap(l[i], r[i]);
    l[i] = max(l[i], p1[i]);
    r[i] = min(r[i], p2[i]);
    if (l[i] >= r[i]) {
      cout << "0\n";
      return;
    }
    if (p1[i] < l[i]) {
      ld k = (p2[i] - l[i]) / (p2[i] - p1[i]);
      for (int j = 0; j < 3; ++j) {
        if (j == i) continue;
        p2[j] = p1[j] + (p2[j] - p1[j]) * k;
      }
      p1[i] = l[i];
    }
    ld d = p1[i];
    p1[i] -= d;
    p2[i] -= d;
    l[i] -= d;
    r[i] -= d;
  }
  /// now p1 = l = 0; p2, r > 0
  vector<ld> zs = {l[2], r[2]};
  for (int mask = 1; mask <= 3; ++mask) {
    ld x = l[0], y = l[1];
    if (mask & 1) {
      x = r[0];
    }
    if (mask & 2) {
      y = r[1];
    }
    ld z = p2[2] * (1 - x / p2[0] - y / p2[1]);
    if (z > l[2] && z < r[2]) {
      zs.push_back(z);
    }
  }
  sort(zs.begin(), zs.end());

  auto get_s = [&](ld z) {
    ld x1 = r[0], y1 = r[1];
    ld x2 = p2[0] * (p2[2] - z) / (p2[2] - p1[2]);
    ld y2 = p2[1] * (p2[2] - z) / (p2[2] - p1[2]);
    x1 = min(x1, x2);
    y1 = min(y1, y2);
    if (x1 < EPS || y1 < EPS) return (ld)0;
    if (x1 / x2 + y1 / y2 < 1) {
      return x1 * y1;
    }
    ld k1 = (x2 - x1) / x2;
    ld k2 = (y2 - y1) / y2;
    ld ans = x2 * y2 / 2 * (1 - k1 * k1 - k2 * k2);
    return ans;
  };

  ld ans = 0;
  for (int i = 1; i < (int)zs.size(); ++i) {
    if (zs[i] - zs[i - 1] < EPS) continue;
    array<ld, 3> z = {zs[i - 1], zs[i], (zs[i - 1] + zs[i]) / 2};
    array<ld, 3> s;
    for (int j = 0; j < 3; ++j) {
      s[j] = get_s(z[j]);
    }
    array<ld, 3> P = {0, 0, 0};
    for (int j = 0; j < 3; ++j) {
      ld y = s[j];

      ld sum = 0, prod = 1;
      for (int k = 0; k < 3; ++k) {
        if (k == j) continue;
        /// cerr << "div: " << z[j] - z[k] << endl;
        y /= (z[j] - z[k]);
        sum += z[k];
        prod *= z[k];
      }

      P[2] += y;
      P[1] -= sum * y;
      P[0] += prod * y;
    }
    ld l = zs[i - 1], r = zs[i];
    /// cerr << l << " " << r << " " << P[0] << " " << P[1] << " " << P[2] << endl;
    ld res = P[0] * (r - l) + P[1] * (r - l) * (r + l) / 2 + P[2] * (r - l) * (r * r + r * l + l * l) / 3;
    ans += res;
  }
  cout << ans << "\n";
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);

  cout << fixed << setprecision(20);

  array<ld, 3> p1, p2;
  while (cin >> p1 >> p2) {
    solve(p1, p2);
  }
  
  return 0;
}