#include <bits/stdc++.h>
using namespace std;
const long double ERROR = 1e-9;
const long double M_2PI = 2 * acos(-1);
bool Igual(long double a, double b) { return fabs(a - b) < ERROR; }
long double RadAGrad(double rad) { return (rad * 180.0) / acos(-1); }
struct Punto {
  long double x, y;
  Punto() : x(), y() {}
  Punto(long double X, double Y) : x(X), y(Y) {}
  bool operator<(const Punto& cmp) const {
    if (!Igual(x, cmp.x)) return x < cmp.x;
    return Igual(y, cmp.y) ? false : y < cmp.y;
  }
  bool operator==(const Punto& cmp) const {
    return Igual(x, cmp.x) && Igual(y, cmp.y);
  }
  Punto operator-(const Punto& o) const { return Punto(x - o.x, y - o.y); }
  Punto operator-() const { return Punto(-x, -y); }
};
long double Distancia(const Punto& p, const Punto& q) {
  return hypot(p.x - q.x, p.y - q.y);
}
long double Magnitud(const Punto& v) { return hypot(v.x, v.y); }
long double Dot(const Punto& v, const Punto& w) {
  return v.x * w.x + v.y * w.y;
}
long double Cruz(const Punto& v, const Punto& w) {
  return v.x * w.y - v.y * w.x;
}
Punto Rotar(const Punto& p, long double rad) {
  return Punto(p.x * cos(rad) - p.y * sin(rad),
               p.x * sin(rad) + p.y * cos(rad));
}
Punto Trasladar(const Punto& o, const Punto& p) {
  return Punto(p.x - o.x, p.y - o.y);
}
Punto Escalar(const Punto& v, long double s) { return Punto(v.x * s, v.y * s); }
Punto Opuesto(const Punto& v) { return Punto(-v.x, -v.y); }
long double Angulo(const Punto& v, const Punto& w) {
  long double aux = (270.0 * acos(-1)) / 180.0;
  return atan2(Dot(v, w), Cruz(v, w)) + aux;
}
long double Angulo2(const Punto& v, const Punto& w) {
  return acos(Dot(v, w) / (Magnitud(v) * Magnitud(w)));
}
int ManoDerecha(const Punto& o, const Punto& p, const Punto& q) {
  long double ccw = Cruz(Trasladar(o, p), Trasladar(o, q));
  return Igual(ccw, 0) ? 0 : (ccw < 0) ? -1 : 1;
}
struct Linea {
  Punto p, q;
  long double a, b, c;
  Linea() : p(), q(), a(), b(), c() {}
  Linea(const Punto& P, const Punto& Q) : p(P), q(Q), a(), b(), c() {
    if (q < p) swap(p, q);
    a = q.y - p.y;
    b = p.x - q.x;
    if (!a)
      c = p.y, b = -1;
    else if (!b)
      c = p.x, a = -1;
    else {
      c = -a * p.x - b * p.y;
    }
  }
};
Punto ProyeccionEnRecta(const Punto& v, const Linea& r) {
  Punto a = Trasladar(r.p, v), b = Trasladar(r.p, r.q);
  return Trasladar(Opuesto(r.p), Escalar(b, Dot(a, b) / pow(Magnitud(b), 2)));
}
long double DistanciaPuntoRecta(const Punto& p, const Linea& r) {
  return Distancia(ProyeccionEnRecta(p, r), p);
}
bool PuntoEnRecta(const Punto& p, const Linea& r) {
  return !ManoDerecha(r.p, r.q, p);
}
bool PuntoEnSegmento(const Punto& p, const Linea& s) {
  return PuntoEnRecta(p, s) && !(p < s.p || s.q < p);
}
Linea PerpendicularEnPunto(const Linea& l, const Punto& p) {
  return Linea(p, Punto(p.x + l.a, p.y + l.b));
}
Punto PuntoInterseccion(const Linea& l, const Linea& m) {
  if (Igual(l.a, 0)) return Punto((long double)(l.c * m.b + m.c) / -m.a, l.c);
  long double y = (double)(m.a * l.c - l.a * m.c) / (m.b * l.a - m.a * l.b);
  return Punto((long double)(l.c + l.b * y) / -l.a, y);
}
Linea solve(Punto a, Punto b, Punto c) {
  Punto p = b - a;
  Punto q = c - a;
  long double alfa = Angulo(p, q);
  Punto medA = Rotar(q, alfa / 2.0);
  return Linea(a, medA);
}
struct Circulo {
  Punto c;
  long double r;
  Circulo() : c(), r() {}
  Circulo(const Punto& C, long double R) : c(C), r(R) {}
};
vector<Punto> PuntoCirculo(const Circulo& c, const Circulo& d) {
  int mano;
  vector<Punto> ret;
  long double angulo = 0.0, dist, X, Y;
  Circulo C = Circulo(Punto(0, 0), c.r);
  Circulo D = Circulo(Trasladar(c.c, d.c), d.r);
  mano = ManoDerecha(Punto(0, 0), Punto(1, 0), D.c);
  if (mano == 1)
    angulo = M_2PI - Angulo(Punto(1, 0), D.c);
  else if (mano == -1)
    angulo = Angulo(Punto(1, 0), D.c);
  D.c = Rotar(D.c, angulo);
  dist = Distancia(D.c, C.c);
  if (Igual(dist, C.r + D.r)) {
    ret.push_back(Punto(C.r, 0));
    ret[0] = Rotar(ret[0], M_2PI - angulo);
    ret[0] = Trasladar(Punto(-c.c.x, -c.c.y), ret[0]);
  } else if (dist < (C.r + D.r) && dist > fabs(C.r - D.r)) {
    X = (dist * dist - D.r * D.r + C.r * C.r) / (2.0 * dist);
    Y = sqrt(C.r * C.r - X * X);
    ret.push_back(Punto(X, Y));
    ret.push_back(Punto(X, -Y));
    for (int i = 0; i < 2; ++i) {
      ret[i] = Rotar(ret[i], M_2PI - angulo);
      ret[i] = Trasladar(Punto(-c.c.x, -c.c.y), ret[i]);
    }
  }
  return ret;
}
bool valid(const vector<Punto>& data, const Circulo& a, const Circulo& b) {
  for (int i = 0; i < data.size(); ++i) {
    if (fabs(Distancia(a.c, data[i]) - a.r) < 1e-12 &&
        fabs(Distancia(b.c, data[i]) - b.r) < 1e-12)
      continue;
    else
      return false;
  }
  return true;
}
int InterCirculo_Circulo(Circulo a, Circulo b, vector<Punto>& ans) {
  if (a.r < b.r) swap(a, b);
  if (a.c == b.c && a.r == b.r)
    return -1;
  else if (Distancia(a.c, b.c) + b.r == a.r) {
    Punto hori(a.r, 0);
    Punto w(b.c.x - a.c.x, b.c.y - a.c.y);
    long double rad = Angulo(w, hori);
    Punto one = Rotar(hori, rad);
    long double x = one.x + a.c.x;
    long double y = one.y + a.c.y;
    ans.push_back(Punto(x, y));
  } else {
    auto pre = PuntoCirculo(a, b);
    if (!valid(pre, a, b)) {
      swap(a, b);
      pre = PuntoCirculo(a, b);
    }
    set<Punto> valid;
    for (const auto& var : pre) valid.insert(Punto(var.x, var.y));
    for (const auto& var : valid) ans.push_back(var);
  }
  return ans.size();
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  int n;
  cin >> n;
  Circulo a, b, c;
  cin >> a.c.x >> a.c.y >> a.r;
  if (n >= 2)
    cin >> b.c.x >> b.c.y >> b.r;
  else {
    b.c.x = -1e9;
    b.c.y = -1e9;
    b.r = 1;
  }
  if (n >= 3)
    cin >> c.c.x >> c.c.y >> c.r;
  else {
    c.c.x = 1e9;
    c.c.y = 1e9;
    c.r = 1;
  }
  vector<Punto> AB;
  int ab = InterCirculo_Circulo(a, b, AB);
  vector<Punto> AC;
  int ac = InterCirculo_Circulo(a, c, AC);
  vector<Punto> BC;
  int bc = InterCirculo_Circulo(b, c, BC);
  int ans = n + 1;
  if (AC.size() == 2) ans++;
  if (AB.size() == 2) ans++;
  if (BC.size() == 2) ans++;
  if (AC.size() == 2 && BC.size() == 2 && AB.size() == 2) ans++;
  if (AC.size() == 1 && BC.size() == 1 && AB.size() == 1) ans++;
  if (ans == n + 1) {
    cout << ans << '\n';
    return 0;
  }
  map<Punto, int> check;
  int maxi = 0;
  for (int i = 0; i < AB.size(); ++i) {
    check[AB[i]]++;
    maxi = max(maxi, check[AB[i]]);
  }
  for (int i = 0; i < AC.size(); ++i) {
    check[AC[i]]++;
    maxi = max(maxi, check[AC[i]]);
  }
  for (int i = 0; i < BC.size(); ++i) {
    check[BC[i]]++;
    maxi = max(maxi, check[BC[i]]);
  }
  if (ac + ab + bc == 5 && check.size() == 5) ans++;
  if (ac + ab + bc == 4 && min(ac, min(ab, bc)) == 1 && check.size() == 4)
    ans++;
  if (ac == 1 && ab == 1 && bc == 1 && check.size() == 1) ans--;
  if (ac > 1 && ab > 1 && bc > 1)
    if (check.size() == 2)
      ans -= 2;
    else if (maxi == 3)
      ans--;
  cout << ans << '\n';
  return 0;
}
