#include <bits/stdc++.h>
 
using namespace std;
 
const double EPS = 1e-8, PI = acos(-1);
 
inline bool eq(double a, double b) { return fabs(b - a) < EPS; }
 
struct Point
{
  double x, y;
 
  Point() {}
 
  Point(double x, double y) : x(x), y(y) {}
 
  Point operator+(const Point &b) const { return Point(x + b.x, y + b.y); }
 
  Point operator-(const Point &b) const { return Point(x - b.x, y - b.y); }
 
  Point operator*(const double b) const { return Point(x * b, y * b); }
 
  Point operator*(const Point &b) const { return Point(x * b.x - y * b.y, x * b.y + y * b.x); }
 
  Point operator/(const double b) const { return Point(x / b, y / b); }
 
  bool operator<(const Point &b) const { return x != b.x ? x < b.x : y < b.y; }
 
  bool operator==(const Point &b) const { return eq(x, b.x) && eq(y, b.y); }
 
  double norm() { return x * x + y * y; }
 
  double arg() { return atan2(x, y); }
 
  double abs() { return sqrt(norm()); }
 
  Point rotate(double theta) { return Point(cos(theta) * x - sin(theta) * y, sin(theta) * x + cos(theta) * y); }
 
  Point rotate90() { return Point(-y, x); }
 
  friend ostream &operator<<(ostream &os, Point &p) { return os << "(" << p.x << "," << p.y << ")"; }
 
  friend istream &operator>>(istream &is, Point &a) { return is >> a.x >> a.y; }
};
 
double cross(const Point &a, const Point &b)
{
  return a.x * b.y - a.y * b.x;
}
 
double dot(const Point &a, const Point &b)
{
  return a.x * b.x + a.y * b.y;
}
 
double RadianToDegree(double r)
{
  return (r * 180.0 / acos(-1));
}
 
double DegreeToRadian(double d)
{
  return (d * acos(-1) / 180.0);
}
 
double GetAngle(const Point &a, const Point &b, const Point &c)
{
  const Point v = b - a, w = c - b;
  double alpha = atan2(v.y, v.x), beta = atan2(w.y, w.x);
  if(alpha > beta) swap(alpha, beta);
  double theta = (beta - alpha);
  return min(theta, 2 * acos(-1) - theta);
}
 
struct Line
{
  Point a, b;
 
  Line() {};
 
  Line(Point a, Point b) : a(a), b(b) {};
 
  // Ax + By = C
  Line(double A, double B, double C)
  {
    if(eq(A, 0)) {
      a = Point(0, C / B);
      b = Point(1, C / B);
    } else if(eq(B, 0)) {
      a = Point(C / A, 0);
      b = Point(C / A, 1);
    } else {
      a = Point(0, C / B);
      b = Point(C / A, 0);
    }
  }
 
  friend ostream &operator<<(ostream &os, Line &p) { return os << "(" << p.a.x << "," << p.a.y << ") to (" << p.b.x << "," << p.b.y << ")"; }
 
  friend istream &operator>>(istream &is, Line &a) { return is >> a.a.x >> a.a.y >> a.b.x >> a.b.y; }
};
 
struct Segment
{
  Point a, b;
 
  Segment() {};
 
  Segment(Point a, Point b) : a(a), b(b) {};
 
  friend ostream &operator<<(ostream &os, Segment &p) { return os << "(" << p.a.x << "," << p.a.y << ") to (" << p.b.x << "," << p.b.y << ")"; }
 
  friend istream &operator>>(istream &is, Segment &a) { return is >> a.a.x >> a.a.y >> a.b.x >> a.b.y; }
};
 
struct Circle
{
  Point p;
  double r;
 
  Circle() {};
 
  Circle(Point p, double r) : p(p), r(r) {};
};
 
int ccw(const Point &a, Point b, Point c)
{
  b = b - a, c = c - a;
  if(cross(b, c) > EPS) return +1;
  if(cross(b, c) < -EPS) return -1;
  if(dot(b, c) < 0) return +2;
  if(b.norm() < c.norm()) return -2;
  return 0;
}
 
bool Intersect(const Segment &s, const Point &p)
{
  return ccw(s.a, s.b, p) == 0;
}
 
Point Projection(const Segment &l, const Point &p)
{
  double t = dot(p - l.a, l.a - l.b) / (l.a - l.b).norm();
  return l.a + (l.a - l.b) * t;
}
 
double Distance(const Segment &s, const Point &p)
{
  Point r = Projection(s, p);
  if(Intersect(s, r)) return (r - p).abs();
  return min((s.a - p).abs(), (s.b - p).abs());
}
 
 
int main()
{
  int N;
  cin >> N;
  vector< Segment > segs(N);
  vector< double > r(N);
  for(int i = 0; i < N; i++) {
    cin >> r[i] >> segs[i];
  }
  vector< int > dp(1 << N, -1);
  function< int(int) > rec = [&](int bit)
  {
    if(~dp[bit]) return (dp[bit]);
    int ret = 0;
    for(int i = 0; i < N; i++) {
      if((bit >> i) & 1) continue;
      bool flag = true;
      for(int j = 0; j < N; j++) {
        if(i == j) continue;
        double p = Distance(segs[i], ((bit >> j) & 1) ? segs[j].b : segs[j].a);
        if(r[j] + r[i] > p) flag = false;
      }
      if(flag) ret = max(ret, rec(bit | (1 << i)) + 1);
    }
    return (dp[bit] = ret);
  };
  cout << rec(0) << endl;
}

Measured memory_bytes: 3280