#include<bits/stdc++.h>
using namespace std;

#define FOR(i,bg,ed) for(int i=(bg);i<(ed);i++)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(),(v).end()
#define fi first
#define se second
#define pb push_back

#define IL inline 
namespace geo {
	typedef double D;
	typedef bool B;
	typedef complex<D> P;
#define X real()
#define Y imag()
	B comp(const P& l, const P& r) { return (l.X == r.X) ? l.Y < r.Y : l.X < r.X; }
	typedef pair<P, P> L;  //line
	typedef pair<P, P> LS; //line segment
	typedef pair<P, D> C;  //circle
	typedef vector<P> Poly;
	const D EPS = 1e-8;
	//Decompotision Macro
#define DCl(a,b,l) P (a),(b);tie(a,b)=l; 
#define DCc(a,b,c) P (a);D (b);tie(a,b)=c; 

	//A dot B
	IL D dot(P a, P b) { return a.X*b.X + a.Y*b.Y; }
	//A cross B
	IL D cross(P a, P b) { return a.X*b.Y - a.Y*b.X; }

	IL int sgn(P a, P b, P c) {
		if (cross(b - a, c - a) > EPS)return 1;
		if (cross(b - a, c - a) < -EPS)return -1;
		if (dot(b - a, c - a) < -EPS)return 2; // b-a-c
		if (dot(a - b, c - b) < -EPS)return -2; // a-b-c
		return 0;
	}
	IL D signed_distance_P_L(P p, L l) {
		DCl(a, b, l);
		return cross(b - a, p - a) / abs(b - a);
	}

	IL D distance_P_L(P p, L l) {
		return abs(signed_distance_P_L(p, l));
	}

	IL D distance_P_LS(P p, LS ls) {
		DCl(a, b, ls);
		if (dot(b - a, p - a) < EPS) return abs(p - a);
		if (dot(a - b, p - b) < EPS) return abs(p - b);
		return abs(cross(b - a, p - a)) / abs(b - a);
	}


	IL B is_L_L(L p, L q) {
		DCl(a, b, p);
		DCl(c, d, q);
		return
			abs(cross(a - b, c - d)) > EPS ||
			abs(cross(a - b, d - b)) < EPS;
	}
	IL B is_L_LS(L l, LS ls) {
		DCl(a, b, l);
		DCl(c, d, ls);
		return cross(a - b, c - b) * cross(a - b, d - b) <EPS;
	}
	IL B is_LS_LS(LS p, LS q) {
		DCl(a, b, p);
		DCl(c, d, q);
		return sgn(a, b, c)*sgn(a, b, d) <= 0
			&& sgn(c, d, a)*sgn(c, d, b) <= 0;
	}

	IL D distance_LS_LS(LS p, LS q) {
		if (is_LS_LS(p, q))return 0;
		return min({
			distance_P_LS(p.fi,q),
			distance_P_LS(p.se,q),
			distance_P_LS(q.fi,p),
			distance_P_LS(q.se,p)
		});
	}

	//caution: have to use isintersected_L_L before this function
	IL P cross_point_L_L(L p, L q) {
		DCl(a, b, p);
		D d1 = signed_distance_P_L(a, q);
		D d2 = signed_distance_P_L(b, q);
		return (a * d2 - b * d1) / (d2 - d1);
	}

	IL B is_C_C(C p, C q) {
		DCc(cp, rp, p);
		DCc(cq, rq, q);
		D d = abs(cp - cq);
		return abs(rp - rq) - d <EPS &&
			rp + rq - d > -EPS;
	}
	IL LS cross_C_C(C p, C q) {
		DCc(cp, rp, p);
		DCc(cq, rq, q);
		D d = abs(cp - cq);
		D rc = (d*d + rp*rp - rq*rq) / (2 * d);
		D rs = sqrt(rp*rp - rc*rc);
		P diff = (cq - cp) / d;
		return{ cp + P(rc, rs)*diff, cp + P(rc, -rs)*diff };
	}
	IL D ccw(P a, P b, P c) {
		return cross(b - a, c - a);
	}
	IL Poly convex_hull(Poly& p) {
		int n = (int)p.size();
		Poly res(2 * n);
		int k = 0, t;
		sort(ALL(p),comp);
		REP(i, n) {
			while (k > 1 && ccw(res[k - 2], res[k - 1], p[i]) < EPS)k--;
			res[k++] = p[i];
		}
		t = k;
		REP(j, n - 1) {
			int i = n - 2 - j;
			while (k > t && ccw(res[k - 2], res[k - 1], p[i]) < EPS)k--;
			res[k++] = p[i];
		}
		res.resize(k - 1);
		return res;
	}
	IL B convex_in(Poly& l, P& p) {
		int a = 0, b = (int)l.size(), c;
		D A, C;
		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);
	}
	IL D convex_area(Poly& l) {
		double res = 0;
		int n = l.size();
		FOR(i, 2, n)
			res += (abs(cross(l[i - 1] - l[0], l[i] - l[i - 1]))) / 2.0;
		return res;
	}
	inline vector<L> tangent_line(C c, P p) {
		vector<L> res;
		DCc(cp, r, c);
		P v = p - cp;
		D dist = abs(v);
		if (dist > r + EPS) {
			double _cos = r / dist;
			double _sin = sqrt(1.0 - _cos*_cos);
			v = v * (r / dist);
			{
				P e = P(_cos * v.X - _sin * v.Y, _sin*v.X + _cos*v.Y);
				res.push_back({ p, cp + e });
			}
			{
				P e = P(_cos*v.X + _sin*v.Y, -_sin*v.X + _cos*v.Y);
				res.push_back({ p, cp + e });
			}
		}
		return res;
	}
	IL vector<L> inner_common_tangent_line(C p, C q) {
		vector<L> res;
		DCc(Mp, Rp, p);
		DCc(Mq, Rq, q);
		D dist = abs(Mp - Mq);
		if (dist > Rp + Rq + EPS) {
			P mid = (Mq*Rp + Mp*Rq) / (Rp + Rq);
			res = tangent_line(p, mid);
		}
		return res;
	}
	inline vector<L> outer_common_tangent_line(C p, C q) {
		vector<L> res;
		DCc(Mp, Rp, p);
		DCc(Mq, Rq, q);
		P v = Mp - Mq;
		D dist = abs(v);
		if (dist > Rp - Rq + EPS) {
			if (abs(Rp - Rq) < EPS) {
				P e = v*P(0, 1);
				e = e / dist;
				res.pb(L(Mp + e, Mq + e));
				res.pb(L(Mp - e, Mq - e));
			}
			else {
				P mid = Mp + (Mq - Mp) * Rp / (Rp - Rq);
				res = tangent_line(p, mid);
			}
		}
		return res;
	}
}

IL int check(geo::L l, vector<geo::C>& cd, vector<geo::C>& cm) {
	int res = 0;
	int n = (int)cd.size();
	for (int i = 0; i < n; i++) {
		double d = geo::distance_P_L(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() {
	while (1) {
		int N;
		cin >> N;
		if (N == 0)break;

		vector<geo::C> cd(N);
		vector<geo::C> cm(N);
		for (int i = 0; i < N; i++) {
			double x, y, d, m;
			cin >> x >> y >> d >> m;
			cd[i].first = geo::P(x, y);
			cm[i].first = geo::P(x, 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: 3048