#include <math.h>
#include <iostream>
#include <vector>
#include <iomanip>
//#define M_PI acos(-1.0)

using namespace std;
class Point{
public:
	double x,y;
	Point(double xx=0.0,double yy=0.0){
		x=xx;
		y=yy;
	}
	Point operator-(Point p){
		return Point(x-p.x,y-p.y);
	}
	Point& operator=(const Point p){
		x=p.x;
		y=p.y;
		return *this;
	}
	double distance()
	{
		return sqrt(x*x+y*y);
	}
	double angle()
	{
		return atan2(y,x);
	}
};

int main()
{
	for (;;)
	{
		int n,i,j;
		cin>>n;
		if (!n) break;
		double xx[100],yy[100],rr[100];
		bool enclosed[100]={false};
		vector <double> x,y,r;
		for (i=0;i<n;i++)
			cin>>xx[i]>>yy[i]>>rr[i];
		for (i=0;i<n;i++)
			for (j=0;j<n;j++)
			if (i!=j)
			{
			if (rr[i]+1.0e-10>=rr[j]+Point(xx[i]-xx[j],yy[i]-yy[j]).distance()) 
					enclosed[j]=true;
			}
		for (i=0;i<n;i++)
		if (!enclosed[i])
		{
			x.push_back(xx[i]);
			y.push_back(yy[i]);
			r.push_back(rr[i]);
		}
		n=x.size();
/*		for (i=0;i<n;i++)
			cout<<i<<" "<<x[i]<<" "<<y[i]<<" "<<r[i]<<endl;
*/		if (n==1)
		{
				cout<<fixed<<setprecision(5)<<2*M_PI*r[0]<<endl;
				continue;
		}
		int indexi=0;
		double minx=x[0]-r[0],miny=y[0]-r[0];
		for (i=1;i<n;i++)
			if (y[i]-r[i]<miny||((y[i]-r[i]==miny)&&(x[i]-r[i]<minx)))
			{
				miny=y[i]-r[i];
				minx=x[i]-r[i];
				indexi=i;
			}
		vector <int> circles;
		vector <Point> points;

		circles.push_back(indexi);
		points.push_back(Point(x[indexi],miny));

		int best;
		double alpha,betta,gamma,dist,cosine,minangle;

		Point besti,bestj,bestv,pi,pj,v,lastp;

		for (;;)
		{
			j=circles.back();
			lastp=points.back();
			minangle=2.0*M_PI;
			for (i=0;i<n;i++)
				if (j!=i)
				{
					dist=Point(x[i]-x[j],y[i]-y[j]).distance();
					cosine=(r[j]-r[i])/dist;
					alpha=atan2(y[i]-y[j],x[i]-x[j]);
					betta=acos(cosine);
					pj=Point(x[j]+r[j]*cos(alpha-betta),y[j]+r[j]*sin(alpha-betta));
					alpha=atan2(y[j]-y[i],x[j]-x[i]);
					betta=acos(-cosine);
					pi=Point(x[i]+r[i]*cos(alpha+betta),y[i]+r[i]*sin(alpha+betta));

					alpha=(lastp-Point(x[j],y[j])).angle();
					betta=(pj-Point(x[j],y[j])).angle();
					gamma=betta-alpha;
					if (gamma<0.0) gamma+=2.0*M_PI;

					if (gamma<minangle)
					{	
						best=i;
						besti=pi;
						bestj=pj;
						minangle=gamma;
					}	
				}
			if (circles.size()>2&&circles[0]==j&&circles[1]==best) break;
			points.push_back(bestj);
			points.push_back(besti);
			circles.push_back(best);
		}
		vector <int> C;
		C.push_back(circles[0]);
		for (i=1;i<circles.size();i++)
		{
			C.push_back(circles[i]);
			C.push_back(circles[i]);
		}
		points.erase(points.begin());
		points.push_back(points[0]);
/*
		//showing points of convex hull!
		for (i=0;i<points.size();i++)
		{
			cout<<"Circle["<<C[i]<<"]\tx="<<points[i].x<<"\ty="<<points[i].y<<endl;
		}
*/		double result=0.0;
		for (i=1;i<points.size();i++)
		{
			if (C[i]==C[i-1])
			{
				alpha=(points[i]-Point(x[C[i]],y[C[i]])).angle();
				betta=(points[i-1]-Point(x[C[i]],y[C[i]])).angle();
				gamma=alpha-betta;
				if (gamma<0.0) gamma+=2*M_PI;
				result+=gamma*r[C[i]];		
			}
			else
			{
				result+=(points[i]-points[i-1]).distance();
			}
		}
		cout<<fixed<<setprecision(5)<<result<<endl;
	}
	return 0;
}