#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
#include<cassert>
using namespace std;

typedef long long ll;

typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = mod * mod;
typedef pair<int, int> P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
typedef pair<ll, ll> LP;
typedef vector<int> vec;
typedef vector<string> svec;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-8;

#include<complex>
typedef complex<ld> Point;
const ld pi = acos(-1.0);
ld dot(Point a, Point b) { return real(conj(a)*b); }
ld cross(Point a, Point b) { return imag(conj(a)*b); }
namespace std {
	bool operator<(const Point &lhs, const Point &rhs) {
		return lhs.real() == rhs.real() ? lhs.imag() < rhs.imag() : lhs.real() < rhs.real();
	}
}
struct Line {
	Point a, b;
};
struct Circle {
	Point p; ld r;
};
int ccw(Point a, Point b, Point c) {
	b -= a; c -= a;
	if (cross(b, c) > eps)return 1;//counter clockwise
	if (cross(b, c) < -eps)return -1;//clock wise
	if (dot(b, c) < 0)return 2;//c--a--b on line
	if (norm(b) < norm(c))return -2;//a--b--c on line
	return 0; //a--c--b on line
}
Point proj(Line l, Point p) {
	ld t = dot(p - l.a, l.a - l.b) / norm(l.a - l.b);
	return l.a + t * (l.a - l.b);
}
//直線と点の距離
ld dist_lp(Line l, Point p) {
	return abs(p - proj(l, p));
}
vector<Line> tangent_cp(Circle c, Point p) {
	vector<Line> res;
	Point v = c.p - p;
	ld d = abs(v);
	ld l = sqrt(norm(v) - c.r*c.r);
	if (isnan(l))return res;
	Point v1 = v * Point(l / d, c.r / d);
	Point v2 = v * Point(l / d, -c.r / d);
	res.push_back(Line{ p, p + v1 });
	if (l < eps)return res;
	res.push_back(Line{ p,p + v2 });
	return res;
}
vector<Line> tangent_cc(Circle c1, Circle c2) {
	vector<Line> res;
	if (abs(c1.p - c2.p) - (c1.r + c2.r) > -eps) {
		Point center = (c1.p*c2.r + c2.p*c1.r) / (c1.r + c2.r);
		res = tangent_cp(c1, center);
	}
	if (abs(c1.r - c2.r) > eps) {
		Point out = (-c1.p*c2.r + c2.p*c1.r) / (c1.r - c2.r);
		vector<Line> nres = tangent_cp(c1, out);
		res.insert(res.end(), nres.begin(), nres.end());
	}
	else {
		Point v = c2.p - c1.p; v /= abs(v);
		Point q1 = c1.p + v * Point(0, 1)*c1.r;
		Point q2 = c1.p + v * Point(0, -1)*c1.r;
		res.push_back(Line{ q1,q1 + v });
		res.push_back(Line{ q2,q2 + v });
	}
	return res;
}
int n;
int calc(Line &l, vector<Circle> &c, vector<ld> &adr) {
	int ret = 0;
	rep(i, n) {
		ld dist = dist_lp(l, c[i].p);
		if (c[i].r - eps <= dist && dist <= c[i].r + adr[i] + eps)ret++;
	}
	return ret;
}
void solve() {
	vector<Circle> c(n);
	vector<ld> adr(n);
	rep(i, n) {
		ld x, y, r, m; cin >> x >> y >> r >> m;
		c[i] = { {x,y},r };
		adr[i] = m;
	}
	int ans = 1;
	rep(i, n) {
		rep(j, i) {
			rep(k, 2) {
				rep(l, 2) {
					Circle le = c[i];
					le.r += adr[i] * k;
					Circle ri = c[j];
					ri.r += adr[j] * l;
					vector<Line> v = tangent_cc(le, ri);
					rep(x, v.size()) {
						Line &L = v[x];
						int num = calc(L, c, adr);
						ans = max(ans, num);
					}
				}
			}
		}
	}
	cout << ans << endl;
}

signed main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(10);
	//init();
	while (cin >> n, n) {
		solve();
	}
	//solve();
	//stop
	return 0;
}



Measured memory_bytes: 3416