// 2009模擬地区予選 G : Neko's Treasure

#include <iostream>
#include <vector>
#include <complex>
#include <algorithm>
#include <cstring>

using namespace std;

typedef complex<double> P;
typedef pair<P, double> circle;
typedef vector< vector<int> > graph;

const double EPS = 1e-8;

void visit(graph &g, vector<int> &order, vector<bool> &mark, int pos){
	for(int i=0;i<g[pos].size();i++){
		int next = g[pos][i];
		if(mark[next]) continue;
		visit(g, order, mark, next);
	}
	mark[pos] = true;
	order.push_back(pos);
}

vector<int> topologicalSort(graph &g){
	vector<int> res;
	vector<bool> mark(g.size(), false);
	for(int i=0;i<g.size();i++){
		if(mark[i]) continue;
		visit(g, res, mark, i);
	}
	reverse(res.begin(), res.end());
	return res;
}

bool overlap(circle c1, circle c2){
	double d = abs(c1.first-c2.first);
	return c2.second - (d+c1.second) > EPS;
}

bool inCircle(circle c, P p){
	return c.second-abs(c.first-p) > EPS;
}

bool crossCircle(circle c1, circle c2){
	double r1 = c1.second;
	double r2 = c2.second;
	double d = abs(c1.first-c2.first);
	if(d<r1||d<r2) return d-abs(r1-r2)>EPS;
	return r1+r2-d > -EPS;
}

int main(){
	int n; 
	while(cin >> n, n){
		double xs, ys, xt, yt; cin >> xs >> ys >> xt >> yt;
		P rat = P(xs,ys), cat = P(xt,yt);
		vector<circle> vc;
		for(int i=0;i<n;i++){
			double x, y, r; cin >> x >> y >> r;
			circle c = make_pair(P(x,y),r);
			bool cRat = inCircle(c, rat);
			bool cCat = inCircle(c, cat);
			// ネズミか宝の一方だけを囲う壁のみが使う壁の候補になる
			if(cRat^cCat) vc.push_back(c);
		}
		graph g(vc.size());
		// 2つの壁の順序関係を調べ，DAGを構築する
		// 順序関係は，宝の位置->ネズミの位置に向かったときに乗り越える順で定義｡
		for(int i=0;i<vc.size();i++){
			for(int j=0;j<vc.size();j++){
				if(i==j) continue;
				bool cA = inCircle(vc[i], cat);
				bool cB = inCircle(vc[j], cat);
				// 円iと円jがどちらも宝を囲う
				if(cA==true&&cB==true){
					// 円jが円iを完全に囲えばi->jに枝を張る
					if(overlap(vc[i], vc[j])) g[i].push_back(j);
				}
				// 円iが宝を，円jがネズミを囲う
				if(cA==true&&cB==false){
					// 円iと円jが交差しなければi->jに枝を張る
					if(!crossCircle(vc[i], vc[j])) g[i].push_back(j);
				}
				// 円iと円jがどちらもネズミを囲う
				if(cA==false&&cB==false){
					// 円jが円iに完全に囲われればi->jに枝を張る
					if(overlap(vc[j], vc[i])) g[i].push_back(j);
				}
			}
		}
		int step[1000];
		int ans = 0;
		memset(step, -1, sizeof(step));
		// 構築したDAGをトポロジカルソート
		vector<int> order = topologicalSort(g);
		// DAG上の最長距離ルートが答えになる
		for(int i=0;i<order.size();i++){
			int cur = order[i];
			// 未到達のノードはルート長1とする
			if(step[cur] == -1) step[cur] = 1;
			// 次に行けるノードの距離を更新
			for(int j=0;j<g[cur].size();j++){
				int next = g[cur][j];
				step[next] = max(step[next], step[cur]+1);
			}
		}
		for(int i=0;i<vc.size();i++) ans = max(ans, step[i]);
		cout << ans << endl;
	}
}