#include <iostream>
#include <algorithm>
#include <complex>
#include <vector>
#include <numeric>
#include <cmath>
#include <iterator>

using namespace std;

#define pb push_back
#define sz size()
#define fs first
#define sc second

#define rep(i, a) for(int i=0;i<(int)(a);i++)
#define EQ(a, b) (abs((a)-(b)) < EPS)


typedef double D;
const D EPS = 1e-12;
typedef complex<D> P;

namespace std{
  bool operator<(const P &a, const P &b){
    return real(a) == real(b) ? imag(a) < imag(b): real(a) < real(b);
  }
}

P unit(P p){ return p / abs(p);}
pair<P, P> norm(P p){ return make_pair(p*P(0, 1), p*P(0, -1));}

D dot(P x, P y){ return real(conj(x)*y);}
D cross(P x, P y){ return imag(conj(x)*y);}

P rotate(P v, double s){
  return P(real(v)*cos(s) - imag(v) * sin(s), real(v) * sin(s) + imag(v) * cos(s));
}

D arg(P a, P b, P c){ return acos(dot(b-a,c-a)/(abs(b-a)*abs(c-a)));}
D arg(D a, D b, D c){ return acos((b*b+c*c-a*a)/(2*b*c));}

typedef pair<P, P> L;
typedef pair<P, D> C;

bool in_cir(C c, P x){ return (abs(x-c.fs) + EPS < c.sc);}
bool on_cir(C c, P x){ return EQ(abs(x - c.fs), c.sc); }

vector<L>adj_line(C c, P p){
  vector<L>res;
  if(in_cir(c,p)) return res;
  if(on_cir(c, p)){
    pair<P, P> n = norm(c.fs-p);
    res.pb(L(n.fs + p, p));
    return res;
  }
  D x = c.sc, z = abs(c.fs-p);
  D y = sqrt(z*z-x*x);
  D s = arg(y, x, z);
  P v = unit(p -c.fs) * c.sc;

  res.pb(L(rotate(v, s) + c.fs, p));
  res.pb(L(rotate(v, -s) + c.fs, p));
  return res;
}

vector<L> common_adj_line(C a, C b){
  vector<L> res;
  if(a.sc + EPS < b.sc) return common_adj_line(b, a);
  if(EQ(real(a.fs), real(b.fs)) && EQ(imag(a.fs), imag(b.fs)) && EQ(a.sc, b.sc)) return res;
  P pos = (b.fs - a.fs) * a.sc/(a.sc + b.sc) + a.fs;
  if(!in_cir(a, pos)) res = adj_line(a, pos);

  if(EQ(a.sc, b.sc)){
    pair<P, P> n = norm(unit(b.fs - a.fs) * a.sc);
    res.pb(L(a.fs+n.fs, b.fs + n.fs));
    res.pb(L(a.fs + n.sc, b.fs + n.sc));
  }else{
    D c = abs(b.fs - a.fs);
    pos = unit(b.fs-a.fs)*( (a.sc * c) / (a.sc - b.sc) ) + a.fs;
    if(!in_cir(a, pos)){
      vector<L>tmp = adj_line(a, pos);
      rep(i, tmp.sz) res.pb(tmp[i]);
    }
  }
  return res;
}

D dis(L a, P x){
  return abs(cross(a.sc-a.fs,x-a.fs))/abs(a.sc-a.fs);
}
  
int main(){
  int N;
  while(cin >> N, N){
    vector<double> r(N);
    vector<double> m(N);
    vector<P> p(N);
    rep(i, N){
      int x, y;
      cin >> x >> y >> r[i] >> m[i];
      m[i] += r[i];
      p[i] = P(x, y);
    }

    vector<L>cans;
    for(int i=0;i<N;i++){
      for(int j=i+1;j<N;j++){
	auto c1 = common_adj_line(C(p[i], r[i]), C(p[j], r[j]));
	cans.insert(cans.end(), c1.begin(), c1.end());
	auto c2 = common_adj_line(C(p[i], m[i]), C(p[j], r[j]));
	cans.insert(cans.end(), c2.begin(), c2.end());	
	auto c3 = common_adj_line(C(p[i], r[i]), C(p[j], m[j]));
	cans.insert(cans.end(), c3.begin(), c3.end());	
	auto c4 = common_adj_line(C(p[i], m[i]), C(p[j], m[j]));
	cans.insert(cans.end(), c4.begin(), c4.end());	
      }
    }

    int res = 1;
    // cout << cans.size() << endl;
    for(const auto &can : cans){
      int cnt = 0;
      for(int i=0;i<N;i++){
	D d = dis(can, p[i]);
	// cout << r[i] - EPS << " " << d << " " << m[i] + EPS << endl;	
	if((r[i] + EPS < d || EQ(r[i], d)) && (d + EPS <  m[i] || EQ(d, m[i]))){
	  cnt++;
	}
      }
      res = max(res, cnt);
    }
    cout << res << endl;
  }
  return 0;
}



Measured memory_bytes: 5056