#include <bits/stdc++.h>
using namespace std;
struct point {
  long long x, y;
  point() : x(0), y(0) {}
  point(long long _x, long long _y) : x(_x), y(_y) {}
  point operator-(point other) { return point(x - other.x, y - other.y); }
};
long long dot(point p1, point p2) { return p1.x * p2.x + p1.y * p2.y; }
long long norm2(point p) { return dot(p, p); }
struct circle {
  point c;
  long long r;
  circle() : c(), r(0) {}
  circle(point _c, long long _r) : c(_c), r(_r) {}
  bool inside(circle other) {
    return r < other.r && norm2(c - other.c) < other.r * other.r;
  }
};
struct edge {
  int v, w, next_id;
  edge(int _v, int _w, int _next_id) : v(_v), w(_w), next_id(_next_id) {}
};
struct graph {
  int n;
  vector<int> LE;
  vector<edge> E;
  graph(int _n) : n(_n) { LE.assign(n, -1); }
  void add_edge(int v, int w) {
    E.push_back(edge(v, w, LE[v]));
    LE[v] = E.size() - 1;
  }
};
double dp[1000][2][2];
double spaciousness(vector<circle>& cs, graph& g, int v, bool lp, bool rp) {
  if (dp[v][lp][rp] == 0) {
    double R = cs[v].r;
    double a = M_PI * R * R;
    double l = lp ? -a : a;
    double r = rp ? -a : a;
    for (int id = g.LE[v]; id != -1; id = g.E[id].next_id) {
      edge e = g.E[id];
      l += spaciousness(cs, g, e.w, !lp, rp);
      r += spaciousness(cs, g, e.w, lp, !rp);
    }
    dp[v][lp][rp] = max(l, r);
  }
  return dp[v][lp][rp];
}
int main() {
  ios_base::sync_with_stdio(false);
  cout << setprecision(12);
  int n;
  cin >> n;
  ;
  vector<circle> cs(n);
  for (int i = 0; i < n; i++) {
    cin >> cs[i].c.x >> cs[i].c.y >> cs[i].r;
  }
  vector<int> roots;
  graph g(n);
  for (int i = 0; i < n; i++) {
    int parent = -1;
    long long min_radius = LLONG_MAX;
    for (int j = 0; j < n; j++) {
      if (i == j) continue;
      if (cs[i].inside(cs[j]) && cs[j].r < min_radius) {
        parent = j;
        min_radius = cs[j].r;
      }
    }
    if (parent == -1) {
      roots.push_back(i);
    } else {
      g.add_edge(parent, i);
    }
  }
  double result = 0;
  for (int root : roots) {
    result += spaciousness(cs, g, root, 0, 0);
  }
  cout << result << endl;
}
