#include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
using namespace std;

const double EPS = 1e-12;

typedef complex< double > P;

int cmp(double a, double b)
{
  const double diff = a - b;

  if (fabs(diff) < EPS)
    return 0;
  else if (diff < 0)
    return -1;
  else
    return 1;
}

inline double cross(const P &a, const P &b)
{
  return a.real() * b.imag() - a.imag() * b.real();
}

struct line
{
  P a, b;

  line() {}
  line(const P &a, const P &b) : a(a), b(b) {}

  inline double distance(const P &p) const
  {
    return abs(cross(p - a, b - a)) / abs(b - a);
  }
};

struct circle
{
  P o;
  double r;

  circle() {}
  circle(const P &o, double r) : o(o), r(r) {}

  double distance(const line &l) const { return abs(l.distance(o)); }

  inline bool independent(const circle &c) const
  {
    return cmp(abs(o - c.o), r + c.r) > 0;
  }

  pair< P, P > tangent(const P &p) const
  {
    const double L = abs(o - p);
    const double M = sqrt(L * L - r * r);
    const double theta = asin(r / L);
    const P v = (o - p) / L;

    return make_pair(p + M * (v * polar(1.0, theta)),
                     p + M * (v * polar(1.0, -theta)));
  }

  pair< line, line > outer_tangent_parallel(const circle &c) const
  {
    const P d = o - c.o;
    const P v = d * P(0, 1) * r / abs(d);

    return make_pair(line(o + v, c.o + v), line(o - v, c.o - v));
  }

  pair< line, line > outer_tangent(const circle &c) const
  {
    if (cmp(r, c.r) == 0)
      return outer_tangent_parallel(c);
    if (r > c.r)
      return c.outer_tangent(*this);

    const P d = o - c.o;
    const double fact = c.r / r - 1;
    const P base = c.o + d + d / fact;
    const pair< P, P > t = tangent(base);

    return make_pair(line(base, t.first), line(base, t.second));
  }

  pair< line, line > inner_tangent(const circle &c) const
  {
    if (r > c.r)
      return c.inner_tangent(*this);

    const P d = c.o - o;
    const double fact = c.r / r + 1;
    const P base = o + d / fact;
    const pair< P, P > t = tangent(base);

    return make_pair(line(base, t.first), line(base, t.second));
  }

  inline bool intersects(const circle &c) const
  {
    return !contains(c) && !c.contains(*this) &&
           cmp(abs(o - c.o), r + c.r) <= 0;
  }

  inline bool contains(const circle &c) const
  {
    return cmp(abs(o - c.o) + c.r, r) < 0;
  }

  pair< P, P > intersection(const circle &c) const
  {
    const double d = abs(o - c.o);
    const double cos_ = (d * d + r * r - c.r * c.r) / (2 * d);
    const double sin_ = sqrt(r * r - cos_ * cos_);
    const P e = (c.o - o) / d;

    return make_pair(o + e * P(cos_, sin_), o + e * P(cos_, -sin_));
  }
};

int N;

void enum_event(circle &c1, circle &c2, vector< line > &lines)
{
  if (c1.independent(c2))
  {
    auto outer = c1.outer_tangent(c2);
    lines.push_back(outer.first);
    lines.push_back(outer.second);

    auto inner = c1.inner_tangent(c2);
    lines.push_back(inner.first);
    lines.push_back(inner.second);
  }
  else if (c1.intersects(c2))
  {
    auto outer = c1.outer_tangent(c2);
    lines.push_back(outer.first);
    lines.push_back(outer.second);

    auto inter = c1.intersection(c2);
    lines.push_back(line(inter.first, inter.second));
  }
}

void solve()
{
  vector< pair< circle, circle > > jewels;
  vector< line > lines;

  for (int i = 0; i < N; i++)
  {
    int x, y, r, m;
    scanf("%d%d%d%d", &x, &y, &r, &m);

    const P center(x, y);
    pair< circle, circle > jewel =
      make_pair(circle(center, r), circle(center, r + m));

    for (int j = 0; j < (int)jewels.size(); j++)
    {
      pair< circle, circle > &other = jewels[j];

      enum_event(jewel.first, other.first, lines);
      enum_event(jewel.first, other.second, lines);
      enum_event(jewel.second, other.first, lines);
      enum_event(jewel.second, other.second, lines);
    }

    jewels.push_back(jewel);
  }

  int ans = 1;
  for (int i = 0; i < (int)lines.size(); i++)
  {
    line &l = lines[i];

    ans = max(ans,
              (int)count_if(jewels.begin(), jewels.end(),
                            [&](const pair< circle, circle > &j) {
                              return cmp(j.first.r, j.first.distance(l)) <= 0 &&
                                     cmp(j.second.r, j.second.distance(l)) >= 0;
                            }));
  }

  printf("%d\n", ans);
}

int main()
{
  while (true)
  {
    scanf("%d", &N);
    if (N == 0)
      break;

    solve();
  }
  return 0;
}



Measured memory_bytes: 4360