#include<bits/stdc++.h>
using namespace std;
const double eps=1e-8;
const double pi=acos(-1);
const int maxn=111;
int sgn(double x){return (x>eps)-(x<-eps);}
int sgn(double a,double b){return sgn(a-b);}
double sqr(double x){return x*x;}
struct P{
	double x,y;
	P(){}
	P(double x,double y):x(x),y(y){}
	double len2(){
		return sqr(x)+sqr(y);
	}
	double len(){
		return sqrt(len2());
	}
	void print(){
		printf("(%.3f,%.3f)\n",x,y);
	}
	void read(){
		scanf("%lf%lf",&x,&y);
	}
	P turn90(){return P(-y,x);}
	P norm(){return P(x/len(),y/len());}
	P rot(double rad){
		return P(x*cos(rad)+y*sin(rad),x*sin(rad)-y*cos(rad));
	}
};
bool operator==(P a,P b){
	return !sgn(a.x-b.x) and !sgn(a.y-b.y);
}
P operator+(P a,P b){
	return P(a.x+b.x,a.y+b.y);
}
P operator-(P a,P b){
	return P(a.x-b.x,a.y-b.y);
}
P operator*(P a,double b){
	return P(a.x*b,a.y*b);
}
P operator/(P a,double b){
	return P(a.x/b,a.y/b);
}
double operator^(P a,P b){
	return a.x*b.x + a.y*b.y;
}
double operator*(P a,P b){
	return a.x*b.y - a.y*b.x;
}
double det(P a,P b,P c){
	return (b-a)*(c-a);
}
double dis(P a,P b){
	return (b-a).len();
}
double Area(vector<P>poly){
	double ans=0;
	for(int i=1;i<poly.size();i++)
		ans+=(poly[i]-poly[0])*(poly[(i+1)%poly.size()]-poly[0]);
	return fabs(ans)/2;
}
struct L{
	P a,b;
	L(){}
	L(P a,P b):a(a),b(b){}
	P v(){return b-a;}
};
bool onLine(P p,L l){
	return sgn((l.a-p)*(l.b-p))==0;
}
bool onSeg(P p,L s){
	return onLine(p,s) and sgn((s.b-s.a)^(p-s.a))>=0 and sgn((s.a-s.b)^(p-s.b))>=0;
}
bool parallel(L l1,L l2){
	return sgn(l1.v()*l2.v())==0;
}
P intersect(L l1,L l2){
	double s1=det(l1.a,l1.b,l2.a);
	double s2=det(l1.a,l1.b,l2.b);
	return (l2.a*s2-l2.b*s1)/(s2-s1);
}
P project(P p,L l){
	return l.a+l.v()*((p-l.a)^l.v())/l.v().len2();
}
double dis(P p,L l){
	return fabs((p-l.a)*l.v())/l.v().len();
}
struct C{
	P o;
	double r;
	C(){}
	C(P _o,double _r):o(_o),r(_r){}
	void read(){
		o.read();
		scanf("%lf",&r);
	}
}c[maxn];
bool operator<(C a,C b){
	return a.r>b.r;
}
bool operator==(C c1,C c2){
	return c1.o==c2.o && sgn(c1.r-c2.r)==0;
}
double fix(double x){return sgn(x)?x:0;}
bool intersect(C a, C b, P &p1, P &p2) { 
	double s1 = (a.o - b.o).len();
	if (sgn(s1 - a.r - b.r) > 0 || sgn(s1 - fabs(a.r - b.r)) < 0) return false;
	double s2 = (a.r * a.r - b.r * b.r) / s1;
	double aa = (s1 + s2) * 0.5, bb = (s1 - s2) * 0.5;
	P o = (b.o - a.o) * (aa / (aa + bb)) + a.o;
	P delta = (b.o - a.o).norm().turn90() * sqrt(fix(a.r * a.r - aa * aa));
	p1 = o + delta, p2 = o - delta;
	return true;
}
int n;
double r;

double calcR(P O){
	double mxr=0;
	for(int i=1;i<=n;i++){
		double ri=0;
		ri=dis(c[i].o,O)+c[i].r;
		mxr=max(mxr,ri);
	}
	return mxr;
}

bool check(P O){
	double mxr=0;
	for(int i=1;i<=n;i++){
		double ri=0;
		ri=dis(c[i].o,O)+c[i].r;
		if(sgn(ri-r)>0)
			return false;
	}
	return true;
}
P O;
vector<P>vecO;
bool in(P p){

	if(sgn(dis(p,O)-r)<=0)
		return true;

	for(int i=1;i<=n;i++){
		C c1=c[i],c2;
		c2.o=p;
		c1.r=r-c1.r;
		c2.r=r;
		P p1,p2;
		if(c1==c2||!intersect(c1,c2,p1,p2))
			continue;
		if(check(p1)||check(p2))
			return true;
	}

	return false;
}
P at(P O,P dir){
	dir=dir.norm();
	double l=::r,r=20000;
	while(r-l>1e-9){
		double mid=(l+r)/2;
		if(in(O+dir*mid))
			l=mid;
		else r=mid;
	}
	return O+dir*l;
}
double calc(P a,P b,P c){
	
	L l1,l2;
	l1.a=(a+b)/2;
	l1.b=l1.a+(b-a).turn90();
	
	l2.a=(b+c)/2;
	l2.b=l2.a+(b-c).turn90();
	
	
	
	
	if(parallel(l1,l2))
		return dis(a,c);
	
	P O=intersect(l1,l2);
	double r=dis(O,a);
	
	
	double theta;
	theta = acos(((c-O)^(a-O))/r/r);
	
	return r*theta;	
}
double calc(double l,double r){
	
	double p=0.45;

	double m=l+(r-l)*p;
	
	P pl=at(O,P(1,0).rot(l));
	P pm=at(O,P(1,0).rot(m));
	P pr=at(O,P(1,0).rot(r));
	
	return calc(pl,pm,pr);
	
}
double simpl(double l,double r){
	double mid=(l+r)/2;
	
	
	double Sl=calc(l,mid);
	double Sr=calc(mid,r);
	double S=calc(l,r);
	
	if(sgn(S-Sl-Sr)==0)
		return S;
	return simpl(l,mid)+simpl(mid,r);
}

int main(){
	while(scanf("%d%lf",&n,&r)&&n){
		vecO.clear();
		for(int i=1;i<=n;i++){
			c[i].read();
		}
		
		sort(c+1,c+1+n);
		
		int m=0;
		static C nC[maxn];
		nC[++m]=c[1];
		for(int i=2;i<=n;i++){
			int flag=0;
			for(int j=1;j<=m;j++){
				double d=dis(c[i].o,nC[j].o);
				if(sgn(d-(nC[j].r-c[i].r))<=0){
					flag=1;
					break;
				}
			}
			if(!flag){
				nC[++m]=c[i];
			}
		}
		n=m;
		for(int i=1;i<=n;i++)
			c[i]=nC[i];
			
		if(n==1){
		
			if(sgn(c[1].r-r)<=0){
				printf("%.8f\n",2*pi*(r*2-c[1].r));
			}else{
				puts("0.0");
			}
			continue;
		}
		
		int flag=0;
		for(int i=1;i<=n;i++)
		for(int j=i+1;j<=n;j++){
			C c1=c[i],c2=c[j];
			double d=dis(c[i].o,c[j].o);
			c1.r=r-c1.r;
			c2.r=r-c2.r;
			P p1,p2;
			if(c1==c2||!intersect(c1,c2,p1,p2))
				continue;
			
			if(sgn(calcR(p1)-r)<=0){
				vecO.push_back(p1);
			}
			if(sgn(calcR(p2)-r)<=0){
				vecO.push_back(p2);
			}
		}
		
		if(vecO.empty()){
			puts("0.0");
			continue;
		}
		//cerr<<n<<endl;
		O=vecO.front();
		
		double ans=0;
		ans+=simpl(0,pi);
		ans+=simpl(pi,pi*2);
		printf("%.8f\n",ans);
		
	}
	return 0;
}

Measured memory_bytes: 3500