#include<iostream>
#include<fstream>
#include<vector>
#include<algorithm>
#include<complex>
#include<map>
#include<math.h>
using namespace std;
namespace geo{

	typedef complex<double> P;
	typedef vector<P> Poly;
	const double eps = 1e-8;
	typedef pair<P, P> Line;
	typedef pair<P, double> Circle;
#define mp(a,b) make_pair(a,b)

	//?????????????????????????????????????????¨???
	inline void x(P& p, double n){ p.real(n); }
	inline void y(P& p, double n){ p.imag(n); }
	inline double x(P& p){ return p.real(); }
	inline double y(P& p){ return p.imag(); }

	//????????????a??¨b?????????
	inline double dot(const P a, const  P b){//A dot B
		return a.real()*b.real() + a.imag()*b.imag();
	}

	//????????????a??¨b?????????
	inline double cross(const P a, const P b){//A cross B
		return a.real()*b.imag() - a.imag()*b.real();
	}


	// ???a,b???????????´?????¨???c??¨????????¢
	double distance(P p, Line l) {
		auto c = p;
		auto a = l.first;
		auto b = l.second;
		return abs(cross(b - a, c - a)) / abs(b - a);
	}

	// ?????????????????¨??????????????????????????????????????????
	int comp(const P &l, const P &r){
		if (l.real() == r.real())
			return(l.imag() < r.imag());
		return(l.real() < r.real());
	}

	// ??????p??????????????????????¨?????????§Poly???????´?
	// Poly p : ?????¨????????????
	// ???????????§O(nlogn)
	inline Poly convex_hull(Poly& p){
		int n = (int)p.size();
		Poly res(2 * n);
		int k = 0, t;
		sort(p.begin(), p.end(), comp);
		for (int i = 0; i < n; i++){
			while (k > 1 && (cross(res[k - 1] - res[k - 2], p[i] - res[k - 1]) < eps))k--;
			res[k++] = p[i];
		}
		t = k;
		for (int i = n - 2; i >= 0; i--){
			while (k > t && (cross(res[k - 1] - res[k - 2], p[i] - res[k - 1]) < eps))k--;
			res[k++] = p[i];
		}
		res.resize(k - 1);
		return res;
	}


	// ???p?????????????????¨????????¨????????????true
	// Poly l : ???????¨????????????????,????????°n
	// P p    : ???????????????????????????
	// ?????¨??§????????¢?´¢ O(log n)
	inline bool convex_in(const Poly& l, const P& p){
		int a = 0, b = (int)l.size(), c;
		double A, C;
		const P g = (l[a] + l[b - 1] + l[b / 2]) / 3.0;
		while (b - a > 1){
			c = (a + b) / 2;
			A = cross(l[a] - g, p - l[a]);
			C = cross(l[c] - g, p - l[c]);
			if (cross(l[a] - g, l[c] - g) >= 0){
				if (A > -eps&&C < -eps)b = c;
				else a = c;
			}
			else {

				if (C < -eps || A > -eps)b = c;
				else a = c;
			}
		}
		return(cross(l[b%l.size()] - l[a], p - l[b%l.size()]) > -eps);
	}


	// ??????l?????¢????????????
	// Poly l : ???????¨????????????????,????????°n
	// O(n)
	inline double convex_area(const Poly& l){
		double res = 0;
		int n = (int)l.size();
		for (int i = 2; i < n; i++)
			res += (abs(cross(l[i - 1] - l[0], l[i] - l[i - 1]))) / 2.0;
		return res;
	}

	//???p????????????c?????\?????????????±?????????????
	inline vector<Line> tangent_line(Circle c, P p){
		vector<Line> res;
		P Mp = c.first;
		double r = c.second;
		P v = p - Mp, e;
		double dist = abs(v);
		if (dist > r + eps){
			double _cos = r / dist;
			double _sin = sqrt(1.0 - _cos*_cos);
			v *= r / dist;
			x(e, _cos*x(v) - _sin*y(v));
			y(e, _sin*x(v) + _cos*y(v));
			res.push_back(mp(p, Mp + e));
			x(e, _cos*x(v) + _sin*y(v));
			y(e, -_sin*x(v) + _cos*y(v));
			res.push_back(mp(p, Mp + e));
		}

		return res;
	}

	inline vector<Line> inner_common_tangent_line(Circle p, Circle q){
		vector<Line> res;
		P Mp = p.first, Mq = q.first;
		double Rp = p.second, Rq = q.second;
		double dist = abs(Mp - Mq);
		if (dist > Rp + Rq + eps){
			P mid = (Rp*Mq + Rq*Mp) / (Rp + Rq);
			res = tangent_line(p, mid);
		}

		return res;
	}

	inline vector<Line> outer_common_tangent_line(Circle p, Circle q){
		vector<Line> res;
		P Mp = p.first, Mq = q.first;
		double Rp = p.second, Rq = q.second;
		P v = Mp - Mq;
		double dist = abs(v);
		if (dist > Rp - Rq + eps){
			if (abs(Rp - Rq) < eps){
				P e = v*P(0, 1);
				e /= dist;
				res.push_back(mp(Mp + e, Mq + e));
				res.push_back(mp(Mp - e, Mq - e));
			}
			else{
				P mid = Mp + (Mq - Mp) * Rp / (Rp - Rq);
				res = tangent_line(p, mid);
			}
		}
		return res;
	}

}
using namespace std;

inline int check(geo::Line l,vector<geo::Circle>& cd, vector<geo::Circle>& cm){
	int res = 0;
	int n = (int)cd.size();
	for (int i = 0; i < n; i++){
		double d = geo::distance( cd[i].first,l);
	//	cout << d << " ";
		if (d<cm[i].second +geo::eps&&d>cd[i].second-geo::eps)
			res++;
	}
	//cout << endl;
	return res;


}
int main(){
	//ifstream cin("in.txt");ofstream cout("out.txt");
	while (1){
		int N;
		cin >> N;
		if (N == 0)break;

		vector<geo::Circle> cd(N);
		vector<geo::Circle> cm(N);
		for (int i = 0; i < N; i++){
			double x, y, d, m;
			cin >> x >> y >> d >> m;
			geo::x(cd[i].first, x);
			geo::y(cd[i].first, y);
			geo::x(cm[i].first, x);
			geo::y(cm[i].first, y);
			cd[i].second = d;
			cm[i].second = d+m;
		}
		if (N == 1){
			if (cm[0].second < geo::eps)cout << 0 << endl;
			else cout << 1 << endl;
			continue;
		}
		int res = 0;
		for (int i = 0; i < N; i++){
			for (int j = 0; j < N; j++){
				if (i != j){
					//cout << i << j << endl << endl;
					//cout << "inner1" << endl;
					auto p1 = geo::inner_common_tangent_line(cd[i], cd[j]);
					for (auto& it : p1){
						res=max(check(it, cd, cm),res);
					}
				//	cout << "inner2" << endl;
					auto p2 = geo::inner_common_tangent_line(cd[i], cm[j]);
					for (auto& it : p2){
						res = max(check(it, cd, cm), res);
					}
				//	cout << "inner3" << endl;
					auto p3 = geo::inner_common_tangent_line(cm[i], cm[j]);
					for (auto& it : p3){
						res = max(check(it, cd, cm), res);
					}
				//	cout << "outer1" << endl;
					auto q1 = geo::outer_common_tangent_line(cd[i], cd[j]);
					for (auto& it : q1){
						res = max(check(it, cd, cm), res);
					}
				//	cout << "outer2" << endl;
					auto q2 = geo::outer_common_tangent_line(cd[i], cm[j]);
					for (auto& it : q2){
						res = max(check(it, cd, cm), res);
					}
				//	cout << "outer3" << endl;
					auto q3 = geo::outer_common_tangent_line(cm[i], cm[j]);
					for (auto& it : q3){
						res = max(check(it, cd, cm), res);
					}

				}
			}
		}
		cout << res << endl;
	}
	//cin.close();	cout.close();
	return(0);
}

Measured memory_bytes: 1268