#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <vector>
#include <complex>

#define pb push_back
#define clr clear()
#define sz size()
#define fs first
#define sc second
#define rep(i,a) for(int i=0;i<(int)(a);i++)
#define rrep(i,a) for(int i=(int)(a)-1;i>=0;i--)
#define all(a) (a).begin(),(a).end()
#define EQ(a,b) (abs((a)-(b)) < EPS)
#define INIT(a) memset(a,0,sizeof(a))
using namespace std;
typedef double D;
//typedef pair<int,int> P;
//typedef long long ll;
//typedef vector<int> vi;
//typedef vector<string> vs;
const D EPS = 1e-8;
const int INF = 1e8;
const D PI =acos(-1);

typedef complex<D>P;
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;
int ccw(P a,P b,P c){
    b-=a;c-=a;
    if (cross(b,c)>EPS) return 1; //counter clockwise
    if (cross(b,c)<-EPS) return -1; //clockwise
    if (dot(b, c)<-EPS) return 2; //c−−a−−b on line
    if (abs(b)<abs(c)) return -2; //a−−b−−c on line
    return 0; //on segment
}

D line_dis(L a,P x){return abs(cross(a.sc-a.fs,x-a.fs))/abs(a.sc-a.fs);}

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<P> cp_cir_to_line(C a, L l){
    vector<P> v;
    D d = line_dis(l,a.fs);
    if(d < a.sc + EPS){
        P x = a.sc*unit(l.sc - l.fs);
        if(ccw(l.fs,l.sc,a.fs) == 1)x = a.fs + x*P(0,-1);
        else x = a.fs + x*P(0,1);
        if(d + EPS < a.sc){
            D y = sqrt(a.sc*a.sc - d*d);
            D s = arg(y,d,a.sc);
            v.pb(rotate(x,s));
            v.pb(rotate(x,-s));
        }else if(EQ(d,a.sc))v.pb(x);
    }
    return v;
}

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;
}

int N;
C R[50], M[50];

int check(L l){
    int cnt = 0;
    for(int i=0;i<N;i++){
        if(cp_cir_to_line(R[i], l).size() <= 1 && cp_cir_to_line(M[i], l).size() >= 1){
            cnt++;
        }
    }
    return cnt;
}

int main(){

    while(cin>>N,N){
        for(int i=0;i<N;i++){
            int x, y, r, m;
            cin>>x>>y>>r>>m;
            R[i].fs = P(x, y);
            R[i].sc = r;
            M[i] = R[i];
            M[i].sc += m;
        }
        int ans = 1;
        for(int i=0;i<N;i++){
            for(int j=i+1;j<N;j++){
                vector<L>v;
                v = common_adj_line(R[i], R[j]);
                for(int k=0;k<v.size();k++){
                    ans = max(ans, check(v[k]));
                }
                v = common_adj_line(R[i], M[j]);
                for(int k=0;k<v.size();k++){
                    ans = max(ans, check(v[k]));
                }
                v = common_adj_line(M[i], R[j]);
                for(int k=0;k<v.size();k++){
                    ans = max(ans, check(v[k]));
                }
                v = common_adj_line(M[i], M[j]);
                for(int k=0;k<v.size();k++){
                    ans = max(ans, check(v[k]));
                }
                
            }
        }
        cout<<ans<<endl;
    }

    return 0;
}


Measured memory_bytes: 3360