// #ifdef DEBUG
// #define _GLIBCXX_DEBUG
// #endif
#include <iostream>
#include <iomanip>
#include <vector>
#include <valarray>
#include <map>
#include <set>
#include <list>
#include <queue>
#include <stack>
#include <bitset>
#include <utility>
#include <numeric>
#include <algorithm>
#include <functional>
#include <complex>
#include <string>
#include <sstream>

#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <cstring>

// these require C++11
#include <unordered_set>
#include <unordered_map>
#include <random>
#include <thread>
#include <chrono>

using namespace std;

#define int long long

#define all(c) c.begin(), c.end()
#define repeat(i, n) for (int i = 0; i < static_cast<int>(n); i++)
#define debug(x) #x << "=" << (x)

#ifdef DEBUG
#define dump(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define dump(x) 
#endif

template<typename A,typename B>
ostream &operator<<(ostream&os,const pair<A,B>& p){
    os << "(" << p.first << "," << p.second << ")";
    return os;
}

typedef complex<double> point;

// template<typename T,std::size_t N>
// struct _v_traits {using type = std::vector<typename _v_traits<T,N-1>::type>;};
// template<typename T>
// struct _v_traits<T,1> {using type = std::vector<T>;};
// template<typename T,std::size_t N=1>
// using vec = typename _v_traits<T,N>::type;

template <typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
    os << "[";
    for (const auto &v : vec) {
        os << v << ",";
    }
    os << "]";
    return os;
}

typedef complex<double> point;
typedef vector<point> vertex;

namespace std{
    bool operator < (const point &lhs,const point &rhs){
        if(real(lhs) == real(rhs)){
            return imag(lhs) < imag(rhs);
        }else{
            return real(lhs) < real(rhs);
        }
    }
}



// 内積 (dot product) : a・b = |a||b|cosΘ
double dot(point a,point b){
    return real(conj(a)*b);
}

// 外積 (cross product) : |a×b| = |a||b|sinΘ
double cross(point a,point b){
    return imag(conj(a)*b);
}

// 直線と点との距離
double dist_line_and_point(point a1,point a2,point b){
    return abs(cross(a2-a1,b-a1)) / abs(a2-a1);
}

// rotate by theta (-pi,+pi)
// arg will return angle of point
point rotate(point p,double theta){
    double cos_theta = cos(theta),
           sin_theta = sin(theta);
    return point(p.real()*cos_theta - p.imag()*sin_theta,
                 p.real()*sin_theta + p.imag()*cos_theta);
}
const double EPS = 1e-6;
// 二つの円の共通接線
//  ふつうは4つ？
vector<pair<point,point> > common_tangent_of_two_circles(point c1,double r1,point c2,double r2){
    // shift c2 by c1.
    point nc = c2 - c1;
    // c.img == 0
    double ar = arg(nc);
    point c = rotate(nc,-ar);

    vector<pair<point,point> > ret;
    vector<double> xs;
    for(int sign=-1;sign<=1;sign+=2){
        xs.push_back((r1*r1 + sign*r1*r2)/c.real());
    }
    for(double x1 : xs){
        double y2 = r1*r1 - x1*x1;
        if(y2 < EPS) continue; // maybe two circle is crossed
        for(int sign=-1;sign<=1;sign+=2){
            double y1 = sign*sqrt(y2);
            // x1*x + y1*y = r1*r1 is such line
            point h = point(x1,y1);
            point t = point(x1+1,(-x1*(x1+1)+r1*r1)/y1); // tekito
            if(abs(y1) < EPS){
                t = point(x1,y1);
            }

            ret.push_back(make_pair(h,t));
        }
    }
    transform(ret.begin(),ret.end(),ret.begin(),[ar,c1](pair<point,point> p){
            return make_pair(rotate(p.first,ar)+c1,
                             rotate(p.second,ar)+c1);
        });
    return ret;
}

struct Jewel {
    point p;
    double r;
    double m;
};

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);

    while(true){
        int N; cin >> N;
        if(N == 0) break;
        vector<Jewel> jewels;
        for(int i=0;i<N;i++){
            double x,y,r,m;
            cin >> x >> y >> r >> m;
            jewels.push_back(Jewel{point(x,y),r,m});
        }

        vector<pair<point,double> > circles;
        for(auto& j : jewels){
            circles.push_back(make_pair(j.p,j.r));
            circles.push_back(make_pair(j.p,j.r + j.m));
        }
        int maxi = min(2ll,N);
        for(int i=0;i<circles.size();i++){
            int skip = (i%2 == 0)?2:1;
            for(int j=i+skip;j<circles.size();j++){
                auto lines = common_tangent_of_two_circles(circles[i].first,circles[i].second,
                                                           circles[j].first,circles[j].second);
                for(pair<point,point>& line : lines){
                    int cnt = 0;
                    for(auto& jewel : jewels){
                        double d = dist_line_and_point(line.first,line.second,jewel.p);
                        if(jewel.r < d + EPS and d < jewel.r + jewel.m + EPS){
                            cnt++;
                        }
                    }
                    maxi = max(maxi,cnt);
                }
            }
        }
        cout << maxi << endl;
    }
    return 0;
}

Measured memory_bytes: 1364