Language: C++

#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 operator<(const P& l, const P& r) const{ 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));
		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);
}

Compiler output:
a.cc:18:45: error: non-member function 'geo::B geo::operator<(const P&, const P&)' cannot have cv-qualifier
   18 |         B operator<(const P& l, const P& r) const{ return (l.X == r.X) ? l.Y < r.Y : l.X < r.X; }
      |                                             ^~~~~
In file included from /usr/include/c++/14/bits/stl_algobase.h:71,
                 from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:1:
/usr/include/c++/14/bits/predefined_ops.h: In instantiation of 'constexpr bool __gnu_cxx::__ops::_Iter_less_iter::operator()(_Iterator1, _Iterator2) const [with _Iterator1 = __gnu_cxx::__normal_iterator<std::complex<double>*, std::vector<std::complex<double> > >; _Iterator2 = __gnu_cxx::__normal_iterator<std::complex<double>*, std::vector<std::complex<double> > >]':
/usr/include/c++/14/bits/stl_algo.h:1777:14:   required from 'void std::__insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<complex<double>*, vector<complex<double> > >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]'
 1777 |           if (__comp(__i, __first))
      |               ~~~~~~^~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1817:25:   required from 'void std::__final_insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<complex<double>*, vector<complex<double> > >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]'
 1817 |           std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
      |           ~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1908:31:   required from 'void std::__sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<complex<double>*, vector<complex<double> > >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]'
 1908 |           std::__final_insertion_sort(__first, __last, __comp);
      |           ~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4772:18:   required from 'void std::sort(_RAIter, _RAIter) [with _RAIter = __gnu_cxx::__normal_iterator<complex<double>*, vector<complex<double> > >]'
 4772 |       std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
      |       ~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
a.cc:117:7:   required from here
  117 |                 sort(ALL(p));
      |                 ~~~~^~~~~~~~
/usr/include/c++/14/bits/predefined_ops.h:45:23: error: no match for 'operator<' (operand types are 'std::complex<double>' and 'std::complex<double>')
   45 |       { return *__it1 < *__it2; }
      |                ~~~~~~~^~~~~~~~
In file included from /usr/include/c++/14/bits/stl_algobase.h:67:
/usr/include/c++/14/bits/stl_iterator.h:1241:5: note: candidate: 'template<class _IteratorL, class _IteratorR, class _Container> bool __gnu_cxx::operator<(const __normal_iterator<_IteratorL, _Container>&, const __normal_iterator<_IteratorR, _Container>&)'
 1241 |     operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
      |     ^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:1241:5: note:   template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note:   'std::complex<double>' is not derived from 'const __gnu_cxx::__normal_iterator<_IteratorL, _Container>'
   45 |       { return *__it1 < *__it2; }
      |                ~~~~~~~^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:1249:5: note: candidate: 'template<class _Iterator, class _Container> bool __gnu_cxx::operator<(const __normal_iterator<_Iterator, _Container>&, const __normal_iterator<_Iterator, _Container>&)'
 1249 |     operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
      |     ^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:1249:5: note:   template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note:   'std::complex<double>' is not derived from 'const __gnu_cxx::__normal_iterator<_Iterator, _Container>'
   45 |       { return *__it1 < *__it2; }
      |                ~~~~~~~^~~~~~~~
In file included from /usr/include/c++/14/regex:68,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:181:
/usr/include/c++/14/bits/regex.h:1143:5: note: candidate: 'template<class _BiIter> bool std::__cxx11::operator<(const sub_match<_BiIter>&, const sub_match<_BiIter>&)'
 1143 |     operator<(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
      |     ^~~~~~~~
/usr/include/c++/14/bits/regex.h:1143:5: note:   template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note:   'std::complex<double>' is not derived from 'const std::__cxx11::sub_match<_BiIter>'
   45 |       { return *__it1 < *__it2; }
      |                ~~~~~~~^~~~~~~~
/usr/include/c++/14/bits/regex.h:1224:5: note: candidate: 'template<class _Bi_iter, class _Ch_traits, class _Ch_alloc> bool std::__cxx11::operator<(__sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>&, const sub_match<_BiIter>&)'
 1224 |     operator<(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
      |     ^~~~~~~~
/usr/include/c++/14/bits/regex.h:1224:5: note:   template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note:   'std::complex<double>' is not derived from 'std::__cxx11::__sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>'
   45 |       { return *__it1 < *__it2; }
      |                ~~~~~~~^~~~~~~~
/usr/include/c++/14/bits/regex.h:1317:5: note: candidate: 'template<class _Bi_iter, class _Ch_traits, class _Ch_alloc> bool std::__cxx11::operator<(const sub_match<_BiIter>&, __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>&)'
 1317 |     operator<(const sub_match<_Bi_iter>& __lhs,
      |     ^~~~~~~~
/usr/include/c++/14/bits/regex.h:1317:5: note:   template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note:   'std::complex<double>' is not derived from 'const std::__cxx11::sub_match<_BiIter>'
   45 |       { return *__it1 < *__it2; }
      |                ~~~~~~~^~~~~~~~
/usr/include/c++/14/bits/regex.h:1391:5: note: candidate: 'template<class _Bi_iter> bool std::__cxx11::operator<(const typename std::iterator_traits<_Iter>::value_type*, const sub_match<_BiIter>&)'
 1391 |     operator<(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
      |     ^~~~~~~~
/usr/include/c++/14/bits/regex.h:1391:5: note:   template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note:   'std::complex<double>' is not derived from 'const std::__cxx11::sub_match<_BiIter>'
   45 |       { return *__it1 < *__it2; }
      |                ~~~~~~~^~~~~~~~
/usr/include/c++/14/bits/regex.h:1485:5: note: candidate: 'template<class _Bi_iter> bool std::__cxx11::operator<(const sub_match<_BiIter>&, const typename std::iterator_traits<_Iter>::value_type*)'
 1485 |     operator<(const sub_match<_Bi_iter>& __lhs,
      |     ^~~~~~~~
/usr/include/c++/14/bits/regex.h:1485:5: note:   template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note:   'std::complex<double>' is not derived from 'const std::__cxx11::sub_match<_BiIter>'
   45 |       { return *__it1 < *__it2; }
      |                ~~~~~~~^~~~~~~~
/usr/include/c++/14/bits/regex.h:1560:5: note: candidate: 'template<class _Bi_iter> bool std::__cxx11::operator<(const typename std::iterator_traits<_Iter>::value_type&, const sub_match<_BiIter>&)'
 1560 |     operator<(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
      |     ^~~~~~~~
/usr/include/c++/14/bits/regex.h:1560:5: note:   template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note:   'std::complex<double>' is not derived from 'const std::__cxx11::sub_match<_BiIter>'
   45 |       { return *__it1 < *__it2; }
      |                ~~~~~~~^~~~~~~~
/usr/include/c++/14/bits/regex.h:1660:5: note: candidate: 'template<class _Bi_iter> bool std::__cxx11::operator<(const sub_match<_BiIter>&, const typename std::iterator_traits<_Iter>::value_type&)'
 1660 |     operator<(const sub_match<_Bi_iter>& __lhs,
      |     ^~~~~~~~
/usr/include/c++/14/bits/regex.h:1660:5: note:   template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note:   'std::complex<double>' is not derived from 'const std::__cxx11::sub_match<_BiIter>'
   45 |       { return *__it1 < *__it2; }
      |                ~~~~~~~^~~~~~~~
In file included from /usr/include/c++/14/bits/stl_algobase.h:64:
/usr/include/c++/14/bits/stl_pair.h:1045:5: note: candidate: 'template<class _T1, class _T2> constexpr bool std::operator<(const pair<_T1, _T2>&, const pair<_T1, _T2>&)'
 1045 |     operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
      |     ^~~~~~~~
/usr/include/c++/14/bits/stl_pair.h:1045:5: note:   template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note:   'std::complex<double>' is not derived from 'const std::pair<_T1, _T2>'
   45 |       { return *__it1 < *__it2; }
      |                ~~~~~~~^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:448:5: note: candidate: 'template<class _Iterator> constexpr bool std::operator<(const reverse_iterator<_Iterator>&, const reverse_iterator<_Iterator>&)'
  448 |     operator<(const reverse_iterator<_Iterator>& __x,
      |     ^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:448:5: note:   template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note:   'std::complex<double>' is not derived from 'const std::reverse_iterator<_Iterator>'
   45 |       { return *__it1 < *__it2; }
      |                ~~~~~~~^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:493:5: note: candidate: 'template<class _IteratorL, class _IteratorR> constexpr bool std::operator<(const reverse_iterator<_Iterator>&, const reverse_iterator<_IteratorR>&)'
  493 |