using namespace std;

#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>

#define DEBUG

#ifdef DEBUG
#define debug(args...)            {dbg,args; cerr<<endl;}
#else
#define debug(args...)              // Just strip off all debug tokens
#endif

struct debugger
{
  template<typename T> debugger& operator , (const T& v)
  {
  cerr<<v<<" ";
  return *this;
  }
} dbg;

// templates
template<typename T> int size(const T& c) { return int(c.size()); }
template<typename T> T abs(T x) { return x < 0 ? -x : x; }
template<typename T> T sqr(T x) { return x*x; }
template<typename T> bool remin(T& x, T y) { if (x <= y) return false; x = y; return true; }
template<typename T> bool remax(T& x, T y) { if (x >= y) return false; x = y; return true; }

// misc
#define EPSILON 1e-4

// types
typedef long long int64;
typedef unsigned long long uint64;

// shortcuts
#define ALL(_xx) _xx.begin(), _xx.end()

#define pb push_back
#define vi vector<int>
#define vpii vector<pair<int,int> >

#define pii pair<int,int>
#define pdd pair<double, double>
#define mp(XX, YY) make_pair(XX, YY)
#define fi first
#define se second

#define SS stringstream

// for loops
#define re(II, NN) for (int II(0), _NN(NN); (II) < (NN); ++(II))
#define fod(II, XX, YY) for (int II(XX), _YY(YY); (II) >= (_YY); --(II))
#define fo(II, XX, YY) for (int II(XX), _YY(YY); (II) <= (_YY); ++(II))

const string filein = "evil.in";
const string fileout = "evil.out";

const int N = 3;
int counter;
int cx[3], cy[3], rx[3], ry[3];

inline bool in_elipse(const pdd & p, int index) {
  return 1.0 * sqr(cx[index] - p.fi) * sqr(ry[index]) +
         1.0 * sqr(cy[index] - p.se) * sqr(rx[index]) + EPSILON < sqr(rx[index] * ry[index]);
}

inline int fast_in_elipses(const pdd & p) {
  re (i, N)
    if (in_elipse(p, i))
      return 1;
  return 0;
}

inline int in_elipses(const pdd & p, int * msk) {
  int val = 0;
  re (i, N) {
    if (!in_elipse(p, i))
      msk[i] = 0;
    else
      val = 1;
  }
  return val;
}

inline void monte() {
  const int iter = 30000000;
  
  int lim = 30, ok = 0;
  
  re (i, iter) {
    double px = (rand() % (1000001)) / (1e6);
    double py = (rand() % (1000001)) / (1e6);
    px = -lim + 2 * lim * px;
    py = -lim + 2 * lim * py;
  
    ok += fast_in_elipses(mp(px, py));
  }
  
  debug("monte: ", iter, ok, (1.0 * ok / iter) * sqr(2*lim));
}

inline double rec(double x, double y, double l) {
  double area = l * l;
  
  if (area <= EPSILON * EPSILON)
    return area / 2;
  
  ++counter;
/*
  int msk[3] = {1, 1, 1};

  int sum = in_elipses(mp(x, y), msk) +
            in_elipses(mp(x + l, y), msk) +
            in_elipses(mp(x, y + l), msk) +
            in_elipses(mp(x + l, y + l), msk);

  // all in same elipse
  if(msk[0] + msk[1] + msk[2])
    return area;
  else if (sum == 0)
    return 0.0;
*/
  int sum = fast_in_elipses(mp(x, y)) +
  fast_in_elipses(mp(x + l, y)) +
  fast_in_elipses(mp(x, y + l)) +
  fast_in_elipses(mp(x + l, y + l));
  
  // all in same elipse
  if(sum == 4)
    return area;
  else if (sum == 0)
    return 0.0;

  
  return rec(x, y, l / 2) +
  rec(x + l / 2, y, l / 2) +
  rec(x, y + l / 2, l / 2) +
  rec(x + l / 2, y + l / 2, l / 2);
}

void solve_rec() {
  int lim = 80;
  
  double area = 0.0;
  fo (xx, -lim - 1, lim) {
    fo (yy, -lim - 1, lim) {
      area += rec(xx, yy, 1.0);
    }
  }
  
  cout << std::fixed << std::setprecision(6);
  cout << area << endl;
}

int main() {
  re (i, N)
    cin >> cx[i] >> cy[i] >> rx[i] >> ry[i];
  
  //monte();
  solve_rec();
  
  return 0;
}