#include <cstdio>
#include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <deque>
#include <string>
#include <cmath>
#include <cctype>
#include <locale>
#include <queue>
#include <utility>
#include <iomanip>

#define forn(n) for(int i = 0; i < n; i++)
#define fornm(n, m) for(int i = 0; i < n; i++) for(int j = 0; j < m; j++)
#define pb push_back
#define pf push_front
#define ll long long
#define ld long double
#define pi 3.141592653589793238462643383

using namespace std;

ll dist(ll x1, ll y1, ll x2, ll y2)
{
   ll dx = x1-x2;
   ll dy = y1-y2;
   return dx*dx+dy*dy;
}

bool cmp(pair<ld, ld> a, pair<ld, ld> b)
{
   if(abs(a.second-b.second) < 1e-9) return a.first < b.first;
   return a.second < b.second;
}

int main()
{
   ll x0, y0, v, T; cin >> x0 >> y0 >> v >> T;
   ll r0 = v*T;
   int n; cin >> n;
   ll x[n], y[n], r[n]; forn(n) cin >> x[i] >> y[i] >> r[i];
   //Check if I am contained in a circle
   bool f = false;
   forn(n)
   {
      if(dist(x0, y0, x[i], y[i]) <= r[i]*r[i]) f = true;
   }
   if(f)
   {
      //cout << "what" << endl;
      cout << 1 << endl;
   }
   else
   {
      vector<pair<ld, ld>> list;
      forn(n)
      {
         ll d = dist(x0, y0, x[i], y[i]);
         //cout << "enter" << endl;
         if(sqrt(d) >= (r0+r[i])) continue;
         //cout << "what" << endl;
         // circle is contained inside of a circle
         ld base = atan2(y[i]-y0,x[i]-x0);
         if(base < 0) base += 2*pi;
         ld angle = 0;
         // fix this
         ld A = r[i]*2;
         ld E = sqrt(d)-r[i];
         ld C = sqrt(E*(A+E));
         if(C <= r0)
         {
            angle = asin(r[i]/sqrt(d));
         }
         //circles intersect
         else
         {
            ld a = r0*r0-r[i]*r[i]+d;
            a /= 2*sqrt(d);
            angle = acos(a/r0);
         }
         //cout << base << ' ' << angle << endl;
         ld op1 = base-angle;
         ld op2 = base+angle;
         if(op1 < 0) op1 += 2*pi;
         if(op2 < 0) op2 += 2*pi;

         if(op1 > op2)
         {
            list.pb(make_pair(op1, 2*pi));
            list.pb(make_pair(0, op2));
         }
         else list.pb(make_pair(op1, op2));
      }
      sort(list.begin(), list.end(), cmp);
      //for(pair<ld,ld> p : list) cout << p.first << ' ' << p.second << endl;
      deque<pair<ld, ld>> stack;
      for(pair<ld, ld> p : list)
      {
         if(stack.size() == 0) stack.push_front(p);
         else
         {
            if(p.first <= stack.front().second)
            {
               pair<ld, ld> top = stack.front(); stack.pop_front();
               stack.push_front(make_pair(top.first, p.second));
            }
            else
            {
               stack.push_front(p);
            }
         }
      }
      ld ret = 0;
      while(stack.size() > 0)
      {
         pair<ld, ld> p = stack.front(); stack.pop_front();
         ret += p.second-p.first;
      }
      cout << setprecision(32) << (ret/(2*pi)) << endl;
   }
   return 0;
}


#include <cstdio>
#include <cmath>
#include <vector>
#include <algorithm>
using namespace std;
const int MAXN=100000;
const double pi=acos(-1);
long long x0,y0,v,T;
int n;
vector<pair<double,double> > V;
double dist(double a,double b)
{
	return sqrt(a*a+b*b);
}
int read(void)
{
	scanf("%lld%lld%lld%lld%lld",&x0,&y0,&v,&T,&n);
	return 0;
}
int init(void)
{
	v*=T;
	return 0;
}
int solve(void)
{
	for(int i=1;i<=n;i++)
	{
		long long tempx=0,tempy=0,tempr=0;
		scanf("%lld%lld%lld",&tempx,&tempy,&tempr);
		tempx-=x0;
		tempy-=y0;
		if(tempx*tempx+tempy*tempy<=tempr*tempr)
		{
			printf("1\n");
			return 0;
		}
		double tempa=dist((double)tempx,(double)tempy);
		double tempb=atan2((double)tempy,(double)tempx);
		if(tempb<0.0)
			tempb+=2.0*pi;
		double tempc;
		if((double)v+(double)tempr<=tempa)
			tempc=0;
		else if(dist((double)tempr,(double)v)<tempa)
			tempc=acos((double)(v*v+tempa*tempa-tempr*tempr)/(double)(2*v*tempa));
		else
			tempc=asin((double)tempr/tempa);
		double pa=tempb-tempc,pb=tempb+tempc;
		if(pa<0.0)
		{
			V.push_back(make_pair(pi*2+pa,pi*2));
			pa=0.0;
		}
		if(pb>pi*2)
		{
			V.push_back(make_pair(0,pb-pi*2));
			pb=2*pi;
		}
		V.push_back(make_pair(pa,pb));
	}
	sort(V.begin(),V.end());
	double last=0,ans=0;
	for(int i=0;i<V.size();i++)
	{
		ans+=max(last,V[i].second)-max(last,V[i].first);
		last=max(last,V[i].second);
	}
	printf("%lf\n",ans/(pi*2));
	return 0;
}
int main(void)
{
	read();
	init();
	solve();
	return 0;
}


#include <cstdio>
#include <cmath>
#include <vector>
#include <algorithm>
using namespace std;
const int MAXN=100000;
const double pi=acos(-1);
double x0,y0,v,T;
int n;
vector<pair<double,double> > V;
double dist(double a,double b)
{
	return sqrt(a*a+b*b);
}
int read(void)
{
	return 0;
}
int main(void)
{
	scanf("%lf%lf%lf%lf%d",&x0,&y0,&v,&T,&n);
	v=v*T;
	for(int i=1;i<=n;i++)
	{
		double tempx,tempy,tempr;
		scanf("%lf%lf%lf",&tempx,&tempy,&tempr);
		tempx-=x0;
		tempy-=y0;
		double tempa=dist(tempx,tempy);
		if(tempa<=tempr)
		{
			printf("%lf\n",1.0);
			return 0;
		}
		double tempb=asin(fabs(tempy)/tempa);
		if(tempx<0.0&&tempy>=0.0)
			tempb=pi-tempb;
		else if(tempx<0.0&&tempy<0.0)
			tempb=pi+tempb;
		else if(tempx>0.0&&tempy<0.0)
			tempb=(pi*2)-tempb;
		double tempc=asin(tempr/tempa);
		if(tempa+tempr<v);
		else if(tempa-tempr>v)
			tempc=0.0;
		else if(dist(tempr,v)<tempa)
			tempc=acos((v*v+tempa*tempa-tempr*tempr)/(2*v*tempa));
		double pa=tempb-tempc,pb=tempb+tempc;
		if(pa<0)
		{
			V.push_back(make_pair((pi*2)+pa,(pi*2)));
			pa=0;
		}
		if(pb>(pi*2))
		{
			V.push_back(make_pair(0,pb-(pi*2)));
			pb=pi;
		}
		V.push_back(make_pair(pa,pb));
	}
	sort(V.begin(),V.end());
	double last=0;
	double ans=0;
	for(int i=0;i<V.size();i++)
	{
		ans+=max(last,V[i].second)-max(last,V[i].first);
		last=max(last,V[i].second);
	}
	printf("%lf\n",ans/(pi*2));
	return 0;
}


#include <cstdio>
#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
using namespace std;
const int MAXN=100000;
const double pi=acos(-1);
double x0,y0,v,T;
int n;
vector<pair<double,int> > V;
double dist(double a,double b)
{
	return sqrt(a*a+b*b);
}
int read(void)
{
	cin>>x0>>y0>>v>>T>>n;
	for(int i=1;i<=n;i++)
	{
		double tempx,tempy,tempr;
		cin>>tempx>>tempy>>tempr;
		tempx-=x0;
		tempy-=y0;
		double tempa=dist(tempx,tempy);
		if(tempa<=tempr)
		{
			printf("%lf\n",1.0);
			return 0;
		}
		double tempb=asin(fabs(tempy)/tempa);
		if(tempx<0.0&&tempy>0.0)
			tempb=pi/2.0-tempb;
		else if(tempx<0.0&&tempy<0.0)
			tempb=pi/2.0+tempb;
		else if(tempx>0.0&&tempy<0.0)
			tempb=pi-tempb;
		double tempc=asin(tempr/tempa);
		if(tempa+tempr<v*T);
		else if(tempa-tempr>v*T)
			tempc=0.0;
		else if(dist(tempr,v*T)<tempa)
			tempc=acos((v*v*T*T+tempa*tempa-tempr*tempr)/(2*v*T*tempa));
		double pa=tempb-tempc,pb=tempb+tempc;
		if(pa<0)
		{
			V.push_back(make_pair(pi-pa,1));
			V.push_back(make_pair(pi,-1));
			pa=0;
		}
		if(pb>pi)
		{
			V.push_back(make_pair(0,1));
			V.push_back(make_pair(pb-pi,-1));
			pb=pi;
		}
		V.push_back(make_pair(pa,1));
		V.push_back(make_pair(pb,-1));
	}
	sort(V.begin(),V.end());
	int flag=1;
	double begin=V[0].first;
	double ans=0;
	for(int i=1;i<V.size()-1;i++)
	{
		if(flag==0)
			begin=V[i].first;
		flag+=V[i].second;
		if(flag==0)
			ans+=V[i].first-begin;
	}
	cout<<ans/pi<<endl;
	return 0;
}
int init(void)
{
	return 0;
}
int solve(void)
{
	return 0;
}
int main(void)
{
	read();
	init();
	solve();
	return 0;
}


#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
using namespace std;
const int MAXN=100000;
const double pi=acos(-1);
long long x0,y0,v,T;
int n;
vector<pair<double,double> > V;
double dist(double a,double b)
{
	return sqrt(a*a+b*b);
}
int read(void)
{
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	cin>>x0>>y0>>v>>T>>n;
	return 0;
}
int init(void)
{
	v*=T;
	return 0;
}
int solve(void)
{
	for(int i=1;i<=n;i++)
	{
		long long tempx=0,tempy=0,tempr=0;
		cin>>tempx>>tempy>>tempr;
		tempx-=x0;
		tempy-=y0;
		if(tempx*tempx+tempy*tempy<=tempr*tempr)
		{
			cout<<1<<endl;
			return 0;
		}
		double tempa=dist((double)tempx,(double)tempy);
		double tempb=atan2((double)tempy,(double)tempx);
		if(tempb<0.0)
			tempb+=2.0*pi;
		double tempc;
		if((double)v+(double)tempr<=tempa)
			tempc=0;
		else if(dist((double)tempr,(double)v)<tempa)
			tempc=acos((double)(v*v+tempa*tempa-tempr*tempr)/(double)(2*v*tempa));
		else
			tempc=asin((double)tempr/tempa);
		double pa=tempb-tempc,pb=tempb+tempc;
		if(pa<0.0)
		{
			V.push_back(make_pair(pi*2+pa,pi*2));
			pa=0.0;
		}
		if(pb>pi*2)
		{
			V.push_back(make_pair(0,pb-pi*2));
			pb=2*pi;
		}
		V.push_back(make_pair(pa,pb));
	}
	sort(V.begin(),V.end());
	double last=0,ans=0;
	for(int i=0;i<V.size();i++)
	{
		ans+=max(last,V[i].second)-max(last,V[i].first);
		last=max(last,V[i].second);
	}
	cout<<ans/(pi*2)<<endl;
	return 0;
}
int main(void)
{
	read();
	init();
	solve();
	return 0;
}


#include <cstdio>
#include <cmath>
#include <vector>
#include <algorithm>
using namespace std;
const int MAXN=100000;
const double pi=acos(-1);
double x0,y0,v,T;
int n;
vector<pair<double,double> > V;
double dist(double a,double b)
{
	return sqrt(a*a+b*b);
}
int read(void)
{
	return 0;
}
int main(void)
{
	scanf("%lf%lf%lf%lf%d",&x0,&y0,&v,&T,&n);
	v=v*T;
	for(int i=1;i<=n;i++)
	{
		double tempx,tempy,tempr;
		scanf("%lf%lf%lf",&tempx,&tempy,&tempr);
		tempx-=x0;
		tempy-=y0;
		double tempa=dist(tempx,tempy);
		if(tempa<=tempr)
		{
			printf("%lf\n",1.0);
			return 0;
		}
		double tempb=atan2(tempx,tempy);
		double tempc=asin(tempr/tempa);
		if(tempa+tempr<v);
		else if(tempa-tempr>v)
			tempc=0.0;
		else if(dist(tempr,v)<tempa)
			tempc=acos((v*v+tempa*tempa-tempr*tempr)/(2*v*tempa));
		double pa=tempb-tempc,pb=tempb+tempc;
		if(pa<0)
		{
			V.push_back(make_pair((pi*2)+pa,(pi*2)));
			pa=0;
		}
		if(pb>(pi*2))
		{
			V.push_back(make_pair(0,pb-(pi*2)));
			pb=pi;
		}
		V.push_back(make_pair(pa,pb));
	}
	sort(V.begin(),V.end());
	double last=0;
	double ans=0;
	for(int i=0;i<V.size();i++)
	{
		ans+=max(last,V[i].second)-max(last,V[i].first);
		last=max(last,V[i].second);
	}
	printf("%lf\n",ans/(pi*2));
	return 0;
}


#include <cstdio>
#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
using namespace std;
const int MAXN=100000;
const double pi=acos(-1);
double x0,y0,v,T;
int n;
vector<pair<double,int> > V;
double dist(double a,double b)
{
	return sqrt(a*a+b*b);
}
int read(void)
{
	cin>>x0>>y0>>v>>T>>n;
	for(int i=1;i<=n;i++)
	{
		double tempx,tempy,tempr;
		cin>>tempx>>tempy>>tempr;
		tempx-=x0;
		tempy-=y0;
		double tempa=dist(tempx,tempy);
		if(tempa<=tempr)
		{
			printf("%lf\n",1.0);
			return 0;
		}
		double tempb=asin(fabs(tempy)/tempa);
		if(tempx<0.0&&tempy>=0.0)
			tempb=pi-tempb;
		else if(tempx<0.0&&tempy<0.0)
			tempb=pi+tempb;
		else if(tempx>0.0&&tempy<0.0)
			tempb=(pi*2)-tempb;
		double tempc=asin(tempr/tempa);
		if(tempa+tempr<v*T);
		else if(tempa-tempr>v*T)
			tempc=0.0;
		else if(dist(tempr,v*T)<tempa)
			tempc=acos((v*v*T*T+tempa*tempa-tempr*tempr)/(2*v*T*tempa));
		double pa=tempb-tempc,pb=tempb+tempc;
		if(pa<0)
		{
			V.push_back(make_pair((pi*2)-pa,1));
			V.push_back(make_pair((pi*2),-1));
			pa=0;
		}
		if(pb>(pi*2))
		{
			V.push_back(make_pair(0,1));
			V.push_back(make_pair(pb-(pi*2),-1));
			pb=pi;
		}
		V.push_back(make_pair(pa,1));
		V.push_back(make_pair(pb,-1));
	}
	sort(V.begin(),V.end());
	int flag=1;
	double begin=V[0].first;
	double ans=0;
	for(int i=1;i<V.size();i++)
	{
		if(flag==0)
			begin=V[i].first;
		flag+=V[i].second;
		if(flag==0)
			ans+=V[i].first-begin;
	}
	cout<<ans/(pi*2)<<endl;
	return 0;
}
int init(void)
{
	return 0;
}
int solve(void)
{
	return 0;
}
int main(void)
{
	read();
	init();
	solve();
	return 0;
}


#include <cstdio>
#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
using namespace std;
const int MAXN=100000;
const double pi=acos(-1);
double x0,y0,v,T;
int n;
vector<pair<double,int> > V;
double dist(double a,double b)
{
	return sqrt(a*a+b*b);
}
int read(void)
{
	cin>>x0>>y0>>v>>T>>n;
	for(int i=1;i<=n;i++)
	{
		double tempx,tempy,tempr;
		cin>>tempx>>tempy>>tempr;
		tempx-=x0;
		tempy-=y0;
		double tempa=dist(tempx,tempy);
		if(tempa<=tempr)
		{
			printf("%lf\n",1.0);
			return 0;
		}
		double tempb=asin(fabs(tempy)/tempa);
		if(tempx<0.0&&tempy>=0.0)
			tempb=pi-tempb;
		else if(tempx<0.0&&tempy<0.0)
			tempb=pi+tempb;
		else if(tempx>0.0&&tempy<0.0)
			tempb=(pi*2)-tempb;
		double tempc=asin(tempr/tempa);
		if(tempa+tempr<v*T);
		else if(tempa-tempr>v*T)
			tempc=0.0;
		else if(dist(tempr,v*T)<tempa)
			tempc=acos((v*v*T*T+tempa*tempa-tempr*tempr)/(2*v*T*tempa));
		double pa=tempb-tempc,pb=tempb+tempc;
		if(pa<0)
		{
			V.push_back(make_pair((pi*2)-pa,-1));
			V.push_back(make_pair((pi*2),1));
			pa=0;
		}
		if(pb>(pi*2))
		{
			V.push_back(make_pair(0,-1));
			V.push_back(make_pair(pb-(pi*2),1));
			pb=pi;
		}
		V.push_back(make_pair(pa,-1));
		V.push_back(make_pair(pb,1));
	}
	sort(V.begin(),V.end());
	int flag=1;
	double begin=V[0].first;
	double ans=0;
	for(int i=1;i<V.size();i++)
	{
		if(flag==0)
			begin=V[i].first;
		flag-=V[i].second;
		if(flag==0)
			ans+=V[i].first-begin;
	}
	cout<<ans/(pi*2)<<endl;
	return 0;
}
int init(void)
{
	return 0;
}
int solve(void)
{
	return 0;
}
int main(void)
{
	read();
	init();
	solve();
	return 0;
}


#include <cstdio>
#include <cmath>
#include <vector>
#include <algorithm>
using namespace std;
const int MAXN=100000;
const double pi=acos(-1);
double x0,y0,v,T;
int n;
vector<pair<double,int> > V;
double dist(double a,double b)
{
	return sqrt(a*a+b*b);
}
int read(void)
{
	return 0;
}
int main(void)
{
	scanf("%lf%lf%lf%lf%d",&x0,&y0,&v,&T,&n);
	v=v*T;
	for(int i=1;i<=n;i++)
	{
		double tempx,tempy,tempr;
		scanf("%lf%lf%lf",&tempx,&tempy,&tempr);
		tempx-=x0;
		tempy-=y0;
		double tempa=dist(tempx,tempy);
		if(tempa<=tempr)
		{
			printf("%lf\n",1.0);
			return 0;
		}
		double tempb=asin(fabs(tempy)/tempa);
		if(tempx<0.0&&tempy>=0.0)
			tempb=pi-tempb;
		else if(tempx<0.0&&tempy<0.0)
			tempb=pi+tempb;
		else if(tempx>0.0&&tempy<0.0)
			tempb=(pi*2)-tempb;
		double tempc=asin(tempr/tempa);
		if(tempa+tempr<v);
		else if(tempa-tempr>v)
			tempc=0.0;
		else if(dist(tempr,v)<tempa)
			tempc=acos((v*v+tempa*tempa-tempr*tempr)/(2*v*tempa));
		double pa=tempb-tempc,pb=tempb+tempc;
		if(pa<0)
		{
			V.push_back(make_pair((pi*2)-pa,-1));
			V.push_back(make_pair((pi*2),1));
			pa=0;
		}
		if(pb>(pi*2))
		{
			V.push_back(make_pair(0,-1));
			V.push_back(make_pair(pb-(pi*2),1));
			pb=pi;
		}
		V.push_back(make_pair(pa,-1));
		V.push_back(make_pair(pb,1));
	}
	sort(V.begin(),V.end());
	int flag=1;
	double begin=V[0].first;
	double ans=0;
	for(int i=1;i<V.size();i++)
	{
		if(flag==0)
			begin=V[i].first;
		flag-=V[i].second;
		if(flag==0)
			ans+=V[i].first-begin;
	}
	printf("%lf\n",ans/(pi*2));
	return 0;
}


#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <iomanip>
#include <stack>
#include <sstream>
#include <queue>
#include <set>
#include <functional>
#include <utility>

#define endl '\n'
#define eps 1e-9
#define ll long long int

using namespace std;

const double pi = 3.14159265358979323846;

class point{
public:
	double x, y;
	point(){
		x = y = 0;
	}
	point(double a, double b){
		x = a;
		y = b;
	}
	point operator +(const point b){
		return point(x+b.x, y+b.y);
	}
	point operator -(const point b){
		return point(x-b.x, y-b.y);
	}
	point operator -(){
		return point(-x, -y);
	}
	double operator *(const point b){
		return x*b.x+y*b.y;
	}
	double operator ^(const point b){
		return x*b.y-y*b.x;
	}
	point invert(){
		return point(-y, x);
	}
};

point operator *(int lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, int lambda){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(double lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, double lambda){
	return point(lambda*a.x, lambda*a.y);
}

double len(point a){
	return sqrt(a*a);
}

double angle(point a) {
	double ret = atan2(a.y, a.x);
	if (ret < 0) ret += 2*pi;
	return ret;
}

set<pair<double, double> > S;

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(15);
	ll X, Y, v, t;
	int n;
	cin >> X >> Y >> v >> t >> n;
	double R = 1.0*v*t;
	point O(X, Y);
	for (int i = 0; i < n; i++) {
		int x, y;
		ll r;
		cin >> x >> y >> r;
		if (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y)) {
			cout << 1 << endl;
			return 0;
		}
		point P(x, y);
		double L = len(P-O);
		if (L+1e-9 >= r+R) continue;
		else {
			// cout << "here\n";
			double tLen = sqrt(L*L-r*r);
			double ang = angle(P-O);
			double add;
			if (tLen - 1e-9 <= R)
				add = asin(r/L);
			else
				add = acos((R*R+L*L-r*r)/(2*R*L));
			double start = ang-add;
			double end = ang+add;
			if (end > 2*pi) {
				S.insert(make_pair(0, end-2*pi));
				end = 2*pi;
			}
			if (start < 0) {
				start += 2*pi;
				S.insert(make_pair(start, 2*pi));
				start = 0;
			}
			S.insert(make_pair(start, end));
		}
	}
	double ret = -1;
	double start, end;
	for (auto a : S) {
		// cout << "angles from " << a.first*180/pi << " to " << a.second*180/pi << endl;
		if (ret < 0) {
			ret = 0;
			start = a.first;
			end = a.second;
		}
		else {
			if (a.first < end) {
				end = a.second;
			}
			else {
				// cout << start*180/pi << ' ' << end*180/pi << endl;
				ret += end-start;
				start = a.first;
				end = a.second;
			}
		}
		// cout << ret*180/pi << endl;
	}
	if (ret > -0.5)
		ret += end-start;
	else {
		ret = 0;
	}
	// cout << ret*180/pi << endl;
	ret /= 2*pi;
	cout << ret << endl;

}


#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <iomanip>
#include <stack>
#include <sstream>
#include <queue>
#include <set>
#include <functional>
#include <utility>

#define endl '\n'
#define eps 1e-9
#define ll long long int

using namespace std;

const double pi = 3.14159265358979323846;

class point{
public:
	double x, y;
	point(){
		x = y = 0;
	}
	point(double a, double b){
		x = a;
		y = b;
	}
	point operator +(const point b){
		return point(x+b.x, y+b.y);
	}
	point operator -(const point b){
		return point(x-b.x, y-b.y);
	}
	point operator -(){
		return point(-x, -y);
	}
	double operator *(const point b){
		return x*b.x+y*b.y;
	}
	double operator ^(const point b){
		return x*b.y-y*b.x;
	}
	point invert(){
		return point(-y, x);
	}
};

point operator *(int lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, int lambda){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(double lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, double lambda){
	return point(lambda*a.x, lambda*a.y);
}

double len(point a){
	return sqrt(a*a);
}

double angle(point a) {
	double ret = atan2(a.y, a.x);
	if (ret < 0) ret += 2*pi;
	return ret;
}

set<pair<double, double> > S;

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(15);
	ll X, Y, v, t;
	int n;
	cin >> X >> Y >> v >> t >> n;
	double R = 1.0*v*t;
	if (v == 0 || t == 0) {
		for (int i = 0; i < n; i++) {
			ll x, y, r;
			cin >> x >> y >> r;
			if ((x == X && y == Y) || (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y))) {
				cout << 1 << endl;
				return 0;
			}
		}
		cout << 0 << endl;
		return 0;
	}
	point O(X, Y);
	for (int i = 0; i < n; i++) {
		int x, y;
		ll r;
		cin >> x >> y >> r;
		if (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y)) {
			cout << 1 << endl;
			return 0;
		}
		point P(x, y);
		double L = len(P-O);
		if (L+1e-9 >= r+R) continue;
		else {
			if (L <= R+1e-9) {
				// cout << "here\n";
				double ang = angle(P-O);
				double add = abs(asin(r/L));
				double start = ang-add;
				double end = ang+add;
				if (end > 2*pi) {
					S.insert(make_pair(0, end-2*pi));
					end = 2*pi;
				}
				if (start < 0) {
					start += 2*pi;
					S.insert(make_pair(start, 2*pi));
					start = 0;
				}
				S.insert(make_pair(start, end));
			}
			else {
				// cout << "then it's here\n";
				double ang = angle(P-O);
				double add = acos((R*R+L*L-r*r)/(2*R*L));
				double start = ang-add;
				double end = ang+add;
				if (end > 2*pi) {
					S.insert(make_pair(0, end-2*pi));
					end = 2*pi;
				}
				if (start < 0) {
					start += 2*pi;
					S.insert(make_pair(start, 2*pi));
					start = 0;
				}
				S.insert(make_pair(start, end));
			}
		}
	}
	double ret = -1;
	double start, end;
	for (auto a : S) {
		// cout << "angles from " << a.first*180/pi << " to " << a.second*180/pi << endl;
		if (ret < 0) {
			ret = 0;
			start = a.first;
			end = a.second;
		}
		else {
			if (a.first < end) {
				end = a.second;
			}
			else {
				// cout << start*180/pi << ' ' << end*180/pi << endl;
				ret += end-start;
				start = a.first;
				end = a.second;
			}
		}
		// cout << ret*180/pi << endl;
	}
	if (ret > -0.5)
		ret += end-start;
	else {
		ret = 0;
	}
	// cout << ret*180/pi << endl;
	ret /= 2*pi;
	cout << ret << endl;

}


#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <iomanip>
#include <stack>
#include <sstream>
#include <queue>
#include <set>
#include <functional>
#include <utility>

#define endl '\n'
#define eps 1e-9
#define ll long long int

using namespace std;

const double pi = M_PI;

class point{
public:
	double x, y;
	point(){
		x = y = 0;
	}
	point(double a, double b){
		x = a;
		y = b;
	}
	point operator +(const point b){
		return point(x+b.x, y+b.y);
	}
	point operator -(const point b){
		return point(x-b.x, y-b.y);
	}
	point operator -(){
		return point(-x, -y);
	}
	double operator *(const point b){
		return x*b.x+y*b.y;
	}
	double operator ^(const point b){
		return x*b.y-y*b.x;
	}
	point invert(){
		return point(-y, x);
	}
};

point operator *(int lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, int lambda){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(double lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, double lambda){
	return point(lambda*a.x, lambda*a.y);
}

double len(point a){
	return sqrt(a*a);
}

double angle(point a) {
	double ret = atan(a.y/a.x);
	if (a.x < 0) ret += pi;
	if (ret < 0) ret += 2*pi;
	return ret;
}

set<pair<double, double> > S;

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(15);
	int X, Y, v, t;
	int n;
	cin >> X >> Y >> v >> t >> n;
	double R = 1ll*v*t;
	if (v == 0 || t == 0) {
		for (int i = 0; i < n; i++) {
			int x, y, r;
			cin >> x >> y >> r;
			if ((x == X && y == Y) || (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y))) {
				cout << 1 << endl;
				return 0;
			}
		}
		cout << 0 << endl;
		return 0;
	}
	point O(X, Y);
	for (int i = 0; i < n; i++) {
		int x, y;
		double r;
		cin >> x >> y >> r;
		if ((x == X && y == Y) || (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y))) {
			cout << 1 << endl;
			return 0;
		}
		point P(x, y);
		double L = len(P-O);
		if (L > r+R) continue;
		else {
			if (L + min(r, R) < max(r, R)) {
				if (r > R) {
					cout << 1 << endl;
					return 0;
				}
				double ang = angle(P-O);
				double add = abs(atan(r/L));
				double start = ang-add;
				double end = ang+add;
				if (end > 2*pi) {
					S.insert(make_pair(0, start));
					end = 2*pi;
				}
				if (start < 0) start += 2*pi;
				S.insert(make_pair(start, end));
			}
			else {
				double ang = angle(P-O);
				double add = acos((R*R+L*L-r*r)/(2*R*L));
				double start = ang-add;
				double end = ang+add;
				if (end > 2*pi) {
					S.insert(make_pair(0, start));
					end = 2*pi;
				}
				if (start < 0) start += 2*pi;
				S.insert(make_pair(start, end));
			}
		}
	}
	double ret = -1;
	double start, end;
	for (auto a : S) {
		if (ret < 0) {
			ret = 0;
			start = a.first;
			end = a.second;
		}
		else {
			if (a.first < end) {
				end = a.second;
			}
			else {
				ret += end-start;
				start = a.first;
				end = a.second;
			}
		}
		cout << ret << endl;
	}
	ret += end-start;
	cout << ret << endl;
	ret /= 2*pi;
	cout << ret << endl;

}


#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <iomanip>
#include <stack>
#include <sstream>
#include <queue>
#include <set>
#include <functional>
#include <utility>

#define endl '\n'
#define eps 1e-9
#define ll long long int

using namespace std;

const double pi = 3.14159265358979323846;

class point{
public:
	double x, y;
	point(){
		x = y = 0;
	}
	point(double a, double b){
		x = a;
		y = b;
	}
	point operator +(const point b){
		return point(x+b.x, y+b.y);
	}
	point operator -(const point b){
		return point(x-b.x, y-b.y);
	}
	point operator -(){
		return point(-x, -y);
	}
	double operator *(const point b){
		return x*b.x+y*b.y;
	}
	double operator ^(const point b){
		return x*b.y-y*b.x;
	}
	point invert(){
		return point(-y, x);
	}
};

point operator *(int lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, int lambda){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(double lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, double lambda){
	return point(lambda*a.x, lambda*a.y);
}

double len(point a){
	return sqrt(a*a);
}

double angle(point a) {
	double ret = atan2(a.y, a.x);
	if (ret < 0) ret += 2*pi;
	return ret;
}

set<pair<double, double> > S;

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(15);
	int X, Y, v, t;
	int n;
	cin >> X >> Y >> v >> t >> n;
	double R = 1.0*v*t;
	if (v == 0 || t == 0) {
		for (int i = 0; i < n; i++) {
			int x, y, r;
			cin >> x >> y >> r;
			if ((x == X && y == Y) || (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y))) {
				cout << 1 << endl;
				return 0;
			}
		}
		cout << 0 << endl;
		return 0;
	}
	point O(X, Y);
	for (int i = 0; i < n; i++) {
		int x, y;
		ll r;
		cin >> x >> y >> r;
		if (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y)) {
			cout << 1 << endl;
			return 0;
		}
		point P(x, y);
		double L = len(P-O);
		if (L+1e-9 >= r+R) continue;
		else {
			if (L + min(r, 1ll*v*t) < max(r, 1ll*v*t)) {
				double ang = angle(P-O);
				double add = abs(asin(r/L));
				double start = ang-add;
				double end = ang+add;
				if (end > 2*pi) {
					S.insert(make_pair(0, end-2*pi));
					end = 2*pi;
				}
				if (start < 0) {
					start += 2*pi;
					S.insert(make_pair(start, 2*pi));
					start = 0;
				}
				S.insert(make_pair(start, end));
			}
			else {
				double ang = angle(P-O);
				double add = max(asin(r/L), acos((R*R+L*L-r*r)/(2*R*L)));
				double start = ang-add;
				double end = ang+add;
				if (end > 2*pi) {
					S.insert(make_pair(0, end-2*pi));
					end = 2*pi;
				}
				if (start < 0) {
					start += 2*pi;
					S.insert(make_pair(start, 2*pi));
					start = 0;
				}
				S.insert(make_pair(start, end));
			}
		}
	}
	double ret = -1;
	double start, end;
	for (auto a : S) {
		// cout << "angles from " << a.first*180/pi << " to " << a.second*180/pi << endl;
		if (ret < 0) {
			ret = 0;
			start = a.first;
			end = a.second;
		}
		else {
			if (a.first < end) {
				end = a.second;
			}
			else {
				// cout << start*180/pi << ' ' << end*180/pi << endl;
				ret += end-start;
				start = a.first;
				end = a.second;
			}
		}
		// cout << ret*180/pi << endl;
	}
	if (ret > -0.5)
		ret += end-start;
	else {
		ret = 0;
	}
	// cout << ret*180/pi << endl;
	ret /= 2*pi;
	cout << ret << endl;

}


#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <iomanip>
#include <stack>
#include <sstream>
#include <queue>
#include <set>
#include <functional>
#include <utility>

#define endl '\n'
#define eps 1e-9
#define ll long long int

using namespace std;

const double pi = 3.14159265358979323846;

class point{
public:
	double x, y;
	point(){
		x = y = 0;
	}
	point(double a, double b){
		x = a;
		y = b;
	}
	point operator +(const point b){
		return point(x+b.x, y+b.y);
	}
	point operator -(const point b){
		return point(x-b.x, y-b.y);
	}
	point operator -(){
		return point(-x, -y);
	}
	double operator *(const point b){
		return x*b.x+y*b.y;
	}
	double operator ^(const point b){
		return x*b.y-y*b.x;
	}
	point invert(){
		return point(-y, x);
	}
};

point operator *(int lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, int lambda){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(double lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, double lambda){
	return point(lambda*a.x, lambda*a.y);
}

double len(point a){
	return sqrt(a*a);
}

double angle(point a) {
	double ret = atan2(a.y, a.x);
	if (ret < 0) ret += 2*pi;
	return ret;
}

set<pair<double, double> > S;

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(15);
	ll X, Y, v, t;
	int n;
	cin >> X >> Y >> v >> t >> n;
	double R = 1.0*v*t;
	point O(X, Y);
	for (int i = 0; i < n; i++) {
		ll x, y;
		ll r;
		cin >> x >> y >> r;
		if (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y)) {
			cout << 1 << endl;
			return 0;
		}
		point P(x, y);
		double L = len(P-O);
		if (L > r+R) continue;
		else {
			//cout << "here\n";
			double tLen = sqrt(L*L-1.0*r*r);
			double ang = angle(P-O);
			double add;
			if (tLen < R)
				add = asin(r/L);
			else
				add = acos((R*R+L*L-1.0*r*r)/(2*R*L));
			double start = ang-add;
			double end = ang+add;
			if (end > 2*pi) {
				S.insert(make_pair(0, end-2*pi));
				end = 2*pi;
			}
			if (start < 0) {
				start += 2*pi;
				S.insert(make_pair(start, 2*pi));
				start = 0;
			}
			S.insert(make_pair(start, end));
		}
	}
	double ret = 0;
	double start = 0, end = 0;
	for (auto a : S) {
		// cout << "angles from " << a.first*180/pi << " to " << a.second*180/pi << endl;
		if (a == *S.begin()) {
			start = a.first;
			end = a.second;
		}
		else {
			if (a.first < end) {
				end = max(end, a.second);
			}
			else {
				// cout << start*180/pi << ' ' << end*180/pi << endl;
				ret += end-start;
				start = a.first;
				end = a.second;
			}
		}
		// cout << ret*180/pi << endl;
	}
	ret += end-start;
	// cout << ret*180/pi << endl;
	ret /= 2*pi;
	cout << ret << endl;

}


#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <iomanip>
#include <stack>
#include <sstream>
#include <queue>
#include <set>
#include <functional>
#include <utility>

#define endl '\n'
#define eps 1e-9
#define ll long long int

using namespace std;

const double pi = 3.14159265358979323846;

class point{
public:
	double x, y;
	point(){
		x = y = 0;
	}
	point(double a, double b){
		x = a;
		y = b;
	}
	point operator +(const point b){
		return point(x+b.x, y+b.y);
	}
	point operator -(const point b){
		return point(x-b.x, y-b.y);
	}
	point operator -(){
		return point(-x, -y);
	}
	double operator *(const point b){
		return x*b.x+y*b.y;
	}
	double operator ^(const point b){
		return x*b.y-y*b.x;
	}
	point invert(){
		return point(-y, x);
	}
};

point operator *(int lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, int lambda){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(double lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, double lambda){
	return point(lambda*a.x, lambda*a.y);
}

double len(point a){
	return sqrt(a*a);
}

double angle(point a) {
	double ret = atan2(a.y, a.x);
	if (ret < 0) ret += 2*pi;
	return ret;
}

set<pair<double, double> > S;

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(15);
	ll X, Y, v, t;
	int n;
	cin >> X >> Y >> v >> t >> n;
	double R = 1.0*v*t;
	if (v == 0 || t == 0) {
		for (int i = 0; i < n; i++) {
			ll x, y, r;
			cin >> x >> y >> r;
			if ((x == X && y == Y) || (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y))) {
				cout << 1 << endl;
				return 0;
			}
		}
		cout << 0 << endl;
		return 0;
	}
	point O(X, Y);
	for (int i = 0; i < n; i++) {
		int x, y;
		ll r;
		cin >> x >> y >> r;
		if (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y)) {
			cout << 1 << endl;
			return 0;
		}
		point P(x, y);
		double L = len(P-O);
		if (L+1e-9 >= r+R) continue;
		else {
			if (L + min(r, 1ll*v*t) < max(r, 1ll*v*t)) {
				double ang = angle(P-O);
				double add = abs(asin(r/L));
				double start = ang-add;
				double end = ang+add;
				if (end > 2*pi) {
					S.insert(make_pair(0, end-2*pi));
					end = 2*pi;
				}
				if (start < 0) {
					start += 2*pi;
					S.insert(make_pair(start, 2*pi));
					start = 0;
				}
				S.insert(make_pair(start, end));
			}
			else {
				double ang = angle(P-O);
				double add = max(asin(r/L), acos((R*R+L*L-r*r)/(2*R*L)));
				double start = ang-add;
				double end = ang+add;
				if (end > 2*pi) {
					S.insert(make_pair(0, end-2*pi));
					end = 2*pi;
				}
				if (start < 0) {
					start += 2*pi;
					S.insert(make_pair(start, 2*pi));
					start = 0;
				}
				S.insert(make_pair(start, end));
			}
		}
	}
	double ret = -1;
	double start, end;
	for (auto a : S) {
		// cout << "angles from " << a.first*180/pi << " to " << a.second*180/pi << endl;
		if (ret < 0) {
			ret = 0;
			start = a.first;
			end = a.second;
		}
		else {
			if (a.first < end) {
				end = a.second;
			}
			else {
				// cout << start*180/pi << ' ' << end*180/pi << endl;
				ret += end-start;
				start = a.first;
				end = a.second;
			}
		}
		// cout << ret*180/pi << endl;
	}
	if (ret > -0.5)
		ret += end-start;
	else {
		ret = 0;
	}
	// cout << ret*180/pi << endl;
	ret /= 2*pi;
	cout << ret << endl;

}


#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <iomanip>
#include <stack>
#include <sstream>
#include <queue>
#include <set>
#include <functional>
#include <utility>

#define endl '\n'
#define eps 1e-9
#define ll long long int

using namespace std;

const double pi = 3.14159265358979323846;

class point{
public:
	double x, y;
	point(){
		x = y = 0;
	}
	point(double a, double b){
		x = a;
		y = b;
	}
	point operator +(const point b){
		return point(x+b.x, y+b.y);
	}
	point operator -(const point b){
		return point(x-b.x, y-b.y);
	}
	point operator -(){
		return point(-x, -y);
	}
	double operator *(const point b){
		return x*b.x+y*b.y;
	}
	double operator ^(const point b){
		return x*b.y-y*b.x;
	}
	point invert(){
		return point(-y, x);
	}
};

point operator *(int lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, int lambda){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(double lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, double lambda){
	return point(lambda*a.x, lambda*a.y);
}

double len(point a){
	return sqrt(a*a);
}

double angle(point a) {
	double ret = atan2(a.y, a.x);
	if (ret < 0) ret += 2*pi;
	return ret;
}

set<pair<double, double> > S;

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(15);
	ll X, Y, v, t;
	int n;
	cin >> X >> Y >> v >> t >> n;
	double R = 1.0*v*t;
	point O(X, Y);
	for (int i = 0; i < n; i++) {
		int x, y;
		ll r;
		cin >> x >> y >> r;
		if (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y)) {
			cout << 1 << endl;
			return 0;
		}
		point P(x, y);
		double L = len(P-O);
		if (L - 1e-9 > r+R) continue;
		else {
			//cout << "here\n";
			double tLen = sqrt(L*L-1.0*r*r);
			double ang = angle(P-O);
			double add;
			if (tLen < R+1e-9)
				add = asin(r/L);
			else
				add = acos((R*R+L*L-1.0*r*r)/(2*R*L));
			double start = ang-add;
			double end = ang+add;
			if (end > 2*pi) {
				S.insert(make_pair(0, end-2*pi));
				end = 2*pi;
			}
			if (start < 0) {
				start += 2*pi;
				S.insert(make_pair(start, 2*pi));
				start = 0;
			}
			S.insert(make_pair(start, end));
		}
	}
	double ret = -1;
	double start, end;
	for (auto a : S) {
		// cout << "angles from " << a.first*180/pi << " to " << a.second*180/pi << endl;
		if (ret < 0) {
			ret = 0;
			start = a.first;
			end = a.second;
		}
		else {
			if (a.first < end && a.second > end) {
				end = a.second;
			}
			else {
				// cout << start*180/pi << ' ' << end*180/pi << endl;
				ret += end-start;
				start = a.first;
				end = a.second;
			}
		}
		// cout << ret*180/pi << endl;
	}
	if (ret > -0.5)
		ret += end-start;
	else {
		ret = 0;
	}
	// cout << ret*180/pi << endl;
	ret /= 2*pi;
	cout << ret << endl;

}


#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <iomanip>
#include <stack>
#include <sstream>
#include <queue>
#include <set>
#include <functional>
#include <utility>

#define endl '\n'
#define eps 1e-9
#define ll long long int

using namespace std;

const double pi = 3.14159265358979323846;

class point{
public:
	double x, y;
	point(){
		x = y = 0;
	}
	point(double a, double b){
		x = a;
		y = b;
	}
	point operator +(const point b){
		return point(x+b.x, y+b.y);
	}
	point operator -(const point b){
		return point(x-b.x, y-b.y);
	}
	point operator -(){
		return point(-x, -y);
	}
	double operator *(const point b){
		return x*b.x+y*b.y;
	}
	double operator ^(const point b){
		return x*b.y-y*b.x;
	}
	point invert(){
		return point(-y, x);
	}
};

point operator *(int lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, int lambda){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(double lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, double lambda){
	return point(lambda*a.x, lambda*a.y);
}

double len(point a){
	return sqrt(a*a);
}

double angle(point a) {
	double ret = atan2(a.y, a.x);
	if (ret < 0) ret += 2*pi;
	return ret;
}

set<pair<double, double> > S;

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(15);
	ll X, Y, v, t;
	int n;
	cin >> X >> Y >> v >> t >> n;
	double R = 1.0*v*t;
	point O(X, Y);
	for (int i = 0; i < n; i++) {
		ll x, y;
		ll r;
		cin >> x >> y >> r;
		if (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y)) {
			cout << 1 << endl;
			return 0;
		}
		point P(x, y);
		double L = len(P-O);
		if (L > r+R) continue;
		else {
			//cout << "here\n";
			double tLen = sqrt(L*L-1.0*r*r);
			double ang = angle(P-O);
			double add;
			if (tLen < R)
				add = asin(r/L);
			else
				add = acos((R*R+L*L-1.0*r*r)/(2*R*L));
			double start = ang-add;
			double end = ang+add;
			if (end > 2*pi) {
				S.insert(make_pair(0, end-2*pi));
				end = 2*pi;
			}
			if (start < 0) {
				start += 2*pi;
				S.insert(make_pair(start, 2*pi));
				start = 0;
			}
			S.insert(make_pair(start, end));
		}
	}
	double ret = 0;
	double start, end;
	for (auto a : S) {
		// cout << "angles from " << a.first*180/pi << " to " << a.second*180/pi << endl;
		if (a == *S.begin()) {
			start = a.first;
			end = a.second;
		}
		else {
			if (a.first < end) {
				end = max(end, a.second);
			}
			else {
				// cout << start*180/pi << ' ' << end*180/pi << endl;
				ret += end-start;
				start = a.first;
				end = a.second;
			}
		}
		// cout << ret*180/pi << endl;
	}
	ret += end-start;
	// cout << ret*180/pi << endl;
	ret /= 2*pi;
	cout << ret << endl;

}


#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <iomanip>
#include <stack>
#include <sstream>
#include <queue>
#include <set>
#include <functional>
#include <utility>

#define endl '\n'
#define eps 1e-9
#define ll long long int

using namespace std;

const double pi = 3.14159265358979323846;

class point{
public:
	double x, y;
	point(){
		x = y = 0;
	}
	point(double a, double b){
		x = a;
		y = b;
	}
	point operator +(const point b){
		return point(x+b.x, y+b.y);
	}
	point operator -(const point b){
		return point(x-b.x, y-b.y);
	}
	point operator -(){
		return point(-x, -y);
	}
	double operator *(const point b){
		return x*b.x+y*b.y;
	}
	double operator ^(const point b){
		return x*b.y-y*b.x;
	}
	point invert(){
		return point(-y, x);
	}
};

point operator *(int lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, int lambda){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(double lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, double lambda){
	return point(lambda*a.x, lambda*a.y);
}

double len(point a){
	return sqrt(a*a);
}

double angle(point a) {
	double ret = atan2(a.y, a.x);
	if (ret < 0) ret += 2*pi;
	return ret;
}

set<pair<double, double> > S;

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(15);
	ll X, Y, v, t;
	int n;
	cin >> X >> Y >> v >> t >> n;
	double R = 1.0*v*t;
	point O(X, Y);
	for (int i = 0; i < n; i++) {
		int x, y;
		ll r;
		cin >> x >> y >> r;
		if (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y)) {
			cout << 1 << endl;
			return 0;
		}
		point P(x, y);
		double L = len(P-O);
		if (L > r+R) continue;
		else {
			//cout << "here\n";
			double tLen = sqrt(L*L-1.0*r*r);
			double ang = angle(P-O);
			double add;
			if (tLen < R)
				add = asin(r/L);
			else
				add = acos((R*R+L*L-1.0*r*r)/(2*R*L));
			double start = ang-add;
			double end = ang+add;
			if (end > 2*pi) {
				S.insert(make_pair(0, end-2*pi));
				end = 2*pi;
			}
			if (start < 0) {
				start += 2*pi;
				S.insert(make_pair(start, 2*pi));
				start = 0;
			}
			S.insert(make_pair(start, end));
		}
	}
	double ret = -1;
	double start, end;
	for (auto a : S) {
		// cout << "angles from " << a.first*180/pi << " to " << a.second*180/pi << endl;
		if (ret < 0) {
			ret = 0;
			start = a.first;
			end = a.second;
		}
		else {
			if (a.first < end) {
				end = a.second;
			}
			else {
				// cout << start*180/pi << ' ' << end*180/pi << endl;
				ret += end-start;
				start = a.first;
				end = a.second;
			}
		}
		// cout << ret*180/pi << endl;
	}
	if (ret > -0.5)
		ret += end-start;
	else {
		ret = 0;
	}
	// cout << ret*180/pi << endl;
	ret /= 2*pi;
	cout << ret << endl;

}


#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <iomanip>
#include <stack>
#include <sstream>
#include <queue>
#include <set>
#include <functional>
#include <utility>

#define endl '\n'
#define eps 1e-9
#define ll long long int

using namespace std;

const double pi = 3.14159265359;

class point{
public:
	double x, y;
	point(){
		x = y = 0;
	}
	point(double a, double b){
		x = a;
		y = b;
	}
	point operator +(const point b){
		return point(x+b.x, y+b.y);
	}
	point operator -(const point b){
		return point(x-b.x, y-b.y);
	}
	point operator -(){
		return point(-x, -y);
	}
	double operator *(const point b){
		return x*b.x+y*b.y;
	}
	double operator ^(const point b){
		return x*b.y-y*b.x;
	}
	point invert(){
		return point(-y, x);
	}
};

point operator *(int lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, int lambda){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(double lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, double lambda){
	return point(lambda*a.x, lambda*a.y);
}

double len(point a){
	return sqrt(a*a);
}

double angle(point a) {
	double ret = atan(a.y/a.x);
	if (a.x < 0) ret += pi;
	if (ret < 0) ret += 2*pi;
	return ret;
}

set<pair<double, double> > S;

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(15);
	int X, Y, v, t;
	int n;
	cin >> X >> Y >> v >> t >> n;
	double R = 1ll*v*t;
	if (v == 0 || t == 0) {
		for (int i = 0; i < n; i++) {
			int x, y, r;
			cin >> x >> y >> r;
			if ((x == X && y == Y) || (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y))) {
				cout << 1 << endl;
				return 0;
			}
		}
		cout << 0 << endl;
		return 0;
	}
	point O(X, Y);
	for (int i = 0; i < n; i++) {
		int x, y;
		double r;
		cin >> x >> y >> r;
		if ((x == X && y == Y) || (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y))) {
			cout << 1 << endl;
			return 0;
		}
		point P(x, y);
		double L = len(P-O);
		if (L > r+R) continue;
		else {
			if (L + min(r, R) < max(r, R)) {
				if (r > R) {
					cout << 1 << endl;
					return 0;
				}
				double ang = angle(P-O);
				double add = abs(atan(r/L));
				double start = ang-add;
				double end = ang+add;
				if (end > 2*pi) {
					S.insert(make_pair(0, start));
					end = 2*pi;
				}
				if (start < 0) start += 2*pi;
				S.insert(make_pair(start, end));
			}
			else {
				double ang = angle(P-O);
				double add = acos((R*R+L*L-r*r)/(2*R*L));
				double start = ang-add;
				double end = ang+add;
				if (end > 2*pi) {
					S.insert(make_pair(0, start));
					end = 2*pi;
				}
				if (start < 0) start += 2*pi;
				S.insert(make_pair(start, end));
			}
		}
	}
	double ret = -1;
	double start, end;
	for (auto a : S) {
		if (ret < 0) {
			ret = 0;
			start = a.first;
			end = a.second;
		}
		else {
			if (a.first < end) {
				end = a.second;
			}
			else {
				ret += end-start;
				start = a.first;
				end = a.second;
			}
		}
		cout << ret << endl;
	}
	ret += end-start;
	cout << ret << endl;
	ret /= 2*pi;
	cout << ret << endl;

}


#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <iomanip>
#include <stack>
#include <sstream>
#include <queue>
#include <set>
#include <functional>
#include <utility>

#define endl '\n'
#define eps 1e-9
#define ll long long int

using namespace std;

const double pi = 3.14159265359;

class point{
public:
	double x, y;
	point(){
		x = y = 0;
	}
	point(double a, double b){
		x = a;
		y = b;
	}
	point operator +(const point b){
		return point(x+b.x, y+b.y);
	}
	point operator -(const point b){
		return point(x-b.x, y-b.y);
	}
	point operator -(){
		return point(-x, -y);
	}
	double operator *(const point b){
		return x*b.x+y*b.y;
	}
	double operator ^(const point b){
		return x*b.y-y*b.x;
	}
	point invert(){
		return point(-y, x);
	}
};

point operator *(int lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, int lambda){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(double lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, double lambda){
	return point(lambda*a.x, lambda*a.y);
}

double len(point a){
	return sqrt(a*a);
}

double angle(point a) {
	double ret = atan(a.y/a.x);
	if (a.x < 0) ret += pi;
	if (ret < 0) ret += 2*pi;
	return ret;
}

set<pair<double, double> > S;

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(15);
	int X, Y, v, t;
	int n;
	cin >> X >> Y >> v >> t >> n;
	double R = 1ll*v*t;
	if (v == 0 || t == 0) {
		for (int i = 0; i < n; i++) {
			int x, y, r;
			cin >> x >> y >> r;
			if ((x == X && y == Y) || (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y))) {
				cout << 1 << endl;
				return 0;
			}
		}
		cout << 0 << endl;
		return 0;
	}
	point O(X, Y);
	for (int i = 0; i < n; i++) {
		int x, y;
		double r;
		cin >> x >> y >> r;
		if ((x == X && y == Y) || (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y))) {
			cout << 1 << endl;
			return 0;
		}
		point P(x, y);
		double L = len(P-O);
		if (L > r+R) continue;
		else {
			if (L + min(r, R) < max(r, R)) {
				if (r > R) {
					cout << 1 << endl;
					return 0;
				}
				double ang = angle(P-O);
				double add = abs(atan(r/L));
				double start = ang-add;
				double end = ang+add;
				if (end > 2*pi) {
					S.insert(make_pair(0, end-2*pi));
					end = 2*pi;
				}
				if (start < 0) {
					start += 2*pi;
					S.insert(make_pair(start, 2*pi));
					start = 0;
				}
				S.insert(make_pair(start, end));
			}
			else {
				double ang = angle(P-O);
				double add = acos((R*R+L*L-r*r)/(2*R*L));
				double start = ang-add;
				double end = ang+add;
				if (end > 2*pi) {
					S.insert(make_pair(0, end-2*pi));
					end = 2*pi;
				}
				if (start < 0) {
					start += 2*pi;
					S.insert(make_pair(start, 2*pi));
					start = 0;
				}
				S.insert(make_pair(start, end));
			}
		}
	}
	double ret = -1;
	double start, end;
	for (auto a : S) {
		if (ret < 0) {
			ret = 0;
			start = a.first;
			end = a.second;
		}
		else {
			if (a.first < end) {
				end = a.second;
			}
			else {
				ret += end-start;
				start = a.first;
				end = a.second;
			}
		}
		cout << ret << endl;
	}
	ret += end-start;
	//cout << ret << endl;
	ret /= 2*pi;
	cout << ret << endl;

}


#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <iomanip>
#include <stack>
#include <sstream>
#include <queue>
#include <set>
#include <functional>
#include <utility>

#define endl '\n'
#define eps 1e-9
#define ll long long int

using namespace std;

const double pi = 3.14159265358979323846;

class point{
public:
	double x, y;
	point(){
		x = y = 0;
	}
	point(double a, double b){
		x = a;
		y = b;
	}
	point operator +(const point b){
		return point(x+b.x, y+b.y);
	}
	point operator -(const point b){
		return point(x-b.x, y-b.y);
	}
	point operator -(){
		return point(-x, -y);
	}
	double operator *(const point b){
		return x*b.x+y*b.y;
	}
	double operator ^(const point b){
		return x*b.y-y*b.x;
	}
	point invert(){
		return point(-y, x);
	}
};

point operator *(int lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, int lambda){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(double lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, double lambda){
	return point(lambda*a.x, lambda*a.y);
}

double len(point a){
	return sqrt(a*a);
}

double angle(point a) {
	double ret = atan2(a.y, a.x);
	if (ret < 0) ret += 2*pi;
	return ret;
}

set<pair<double, double> > S;

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(15);
	ll X, Y, v, t;
	int n;
	cin >> X >> Y >> v >> t >> n;
	double R = 1.0*v*t;
	point O(X, Y);
	for (int i = 0; i < n; i++) {
		ll x, y;
		ll r;
		cin >> x >> y >> r;
		if (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y)) {
			cout << 1 << endl;
			return 0;
		}
		point P(x, y);
		double L = len(P-O);
		if (L > r+R) continue;
		else {
			//cout << "here\n";
			double tLen = sqrt(L*L-1.0*r*r);
			double ang = angle(P-O);
			double add;
			if (tLen < R)
				add = asin(r/L);
			else
				add = acos((R*R+L*L-1.0*r*r)/(2*R*L));
			double start = ang-add;
			double end = ang+add;
			if (end > 2*pi) {
				S.insert(make_pair(0, end-2*pi));
				end = 2*pi;
			}
			if (start < 0) {
				start += 2*pi;
				S.insert(make_pair(start, 2*pi));
				start = 0;
			}
			S.insert(make_pair(start, end));
		}
	}
	double ret = 0;
	double start, end;
	for (auto a : S) {
		// cout << "angles from " << a.first*180/pi << " to " << a.second*180/pi << endl;
		if (ret < 0) {
			ret = 0;
			start = a.first;
			end = a.second;
		}
		else {
			if (a.first < end) {
				end = max(end, a.second);
			}
			else {
				// cout << start*180/pi << ' ' << end*180/pi << endl;
				ret += end-start;
				start = a.first;
				end = a.second;
			}
		}
		// cout << ret*180/pi << endl;
	}
	if (ret > -0.5)
		ret += end-start;
	else {
		ret = 0;
	}
	// cout << ret*180/pi << endl;
	ret /= 2*pi;
	cout << ret << endl;

}


#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <iomanip>
#include <stack>
#include <sstream>
#include <queue>
#include <set>
#include <functional>
#include <utility>

#define endl '\n'
#define eps 1e-9
#define ll long long int

using namespace std;

const double pi = 3.14159265358979323846;

class point{
public:
	double x, y;
	point(){
		x = y = 0;
	}
	point(double a, double b){
		x = a;
		y = b;
	}
	point operator +(const point b){
		return point(x+b.x, y+b.y);
	}
	point operator -(const point b){
		return point(x-b.x, y-b.y);
	}
	point operator -(){
		return point(-x, -y);
	}
	double operator *(const point b){
		return x*b.x+y*b.y;
	}
	double operator ^(const point b){
		return x*b.y-y*b.x;
	}
	point invert(){
		return point(-y, x);
	}
};

point operator *(int lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, int lambda){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(double lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, double lambda){
	return point(lambda*a.x, lambda*a.y);
}

double len(point a){
	return sqrt(a*a);
}

double angle(point a) {
	double ret = atan2(a.y, a.x);
	if (ret < 0) ret += 2*pi;
	return ret;
}

set<pair<double, double> > S;

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(15);
	ll X, Y, v, t;
	int n;
	cin >> X >> Y >> v >> t >> n;
	double R = 1.0*v*t;
	point O(X, Y);
	for (int i = 0; i < n; i++) {
		int x, y;
		ll r;
		cin >> x >> y >> r;
		if (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y)) {
			cout << 1 << endl;
			return 0;
		}
		point P(x, y);
		double L = len(P-O);
		if (L - 1e-9 > r+R) continue;
		else {
			//cout << "here\n";
			double tLen = sqrt(L*L-1.0*r*r);
			double ang = angle(P-O);
			double add;
			if (tLen < R+1e-9)
				add = asin(r/L);
			else
				add = acos((R*R+L*L-1.0*r*r)/(2*R*L));
			double start = ang-add;
			double end = ang+add;
			if (end > 2*pi) {
				S.insert(make_pair(0, end-2*pi));
				end = 2*pi;
			}
			if (start < 0) {
				start += 2*pi;
				S.insert(make_pair(start, 2*pi));
				start = 0;
			}
			S.insert(make_pair(start, end));
		}
	}
	double ret = -1;
	double start, end;
	for (auto a : S) {
		// cout << "angles from " << a.first*180/pi << " to " << a.second*180/pi << endl;
		if (ret < 0) {
			ret = 0;
			start = a.first;
			end = a.second;
		}
		else {
			if (a.first < end) {
				end = max(end, a.second);
			}
			else {
				// cout << start*180/pi << ' ' << end*180/pi << endl;
				ret += end-start;
				start = a.first;
				end = a.second;
			}
		}
		// cout << ret*180/pi << endl;
	}
	if (ret > -0.5)
		ret += end-start;
	else {
		ret = 0;
	}
	// cout << ret*180/pi << endl;
	ret /= 2*pi;
	cout << ret << endl;

}


#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <iomanip>
#include <stack>
#include <sstream>
#include <queue>
#include <set>
#include <functional>
#include <utility>

#define endl '\n'
#define eps 1e-9
#define ll long long int

using namespace std;

const double pi = 3.14159265358979323846;

class point{
public:
	double x, y;
	point(){
		x = y = 0;
	}
	point(double a, double b){
		x = a;
		y = b;
	}
	point operator +(const point b){
		return point(x+b.x, y+b.y);
	}
	point operator -(const point b){
		return point(x-b.x, y-b.y);
	}
	point operator -(){
		return point(-x, -y);
	}
	double operator *(const point b){
		return x*b.x+y*b.y;
	}
	double operator ^(const point b){
		return x*b.y-y*b.x;
	}
	point invert(){
		return point(-y, x);
	}
};

point operator *(int lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, int lambda){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(double lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, double lambda){
	return point(lambda*a.x, lambda*a.y);
}

double len(point a){
	return sqrt(a*a);
}

double angle(point a) {
	double ret = atan2(a.y, a.x);
	if (ret < 0) ret += 2*pi;
	return ret;
}

set<pair<double, double> > S;

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(15);
	int X, Y, v, t;
	int n;
	cin >> X >> Y >> v >> t >> n;
	double R = 1.0*v*t;
	if (v == 0 || t == 0) {
		for (int i = 0; i < n; i++) {
			int x, y, r;
			cin >> x >> y >> r;
			if ((x == X && y == Y) || (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y))) {
				cout << 1 << endl;
				return 0;
			}
		}
		cout << 0 << endl;
		return 0;
	}
	point O(X, Y);
	for (int i = 0; i < n; i++) {
		int x, y;
		ll r;
		cin >> x >> y >> r;
		if (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y)) {
			cout << 1 << endl;
			return 0;
		}
		point P(x, y);
		double L = len(P-O);
		if (L > r+R) continue;
		else {
			if (L + min(r, 1ll*v*t) < max(r, 1ll*v*t)) {
				double ang = angle(P-O);
				double add = abs(asin(r/L));
				double start = ang-add;
				double end = ang+add;
				if (end > 2*pi) {
					S.insert(make_pair(0, end-2*pi));
					end = 2*pi;
				}
				if (start < 0) {
					start += 2*pi;
					S.insert(make_pair(start, 2*pi));
					start = 0;
				}
				S.insert(make_pair(start, end));
			}
			else {
				double ang = angle(P-O);
				double add = max(asin(r/L), acos((R*R+L*L-r*r)/(2*R*L)));
				double start = ang-add;
				double end = ang+add;
				if (end > 2*pi) {
					S.insert(make_pair(0, end-2*pi));
					end = 2*pi;
				}
				if (start < 0) {
					start += 2*pi;
					S.insert(make_pair(start, 2*pi));
					start = 0;
				}
				S.insert(make_pair(start, end));
			}
		}
	}
	double ret = -1;
	double start, end;
	for (auto a : S) {
		// cout << "angles from " << a.first*180/pi << " to " << a.second*180/pi << endl;
		if (ret < 0) {
			ret = 0;
			start = a.first;
			end = a.second;
		}
		else {
			if (a.first < end) {
				end = a.second;
			}
			else {
				// cout << start*180/pi << ' ' << end*180/pi << endl;
				ret += end-start;
				start = a.first;
				end = a.second;
			}
		}
		// cout << ret*180/pi << endl;
	}
	ret += end-start;
	// cout << ret*180/pi << endl;
	ret /= 2*pi;
	cout << ret << endl;

}


#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <iomanip>
#include <stack>
#include <sstream>
#include <queue>
#include <set>
#include <functional>
#include <utility>

#define endl '\n'
#define eps 1e-9
#define ll long long int

using namespace std;

const double pi = 3.14159265359;

class point{
public:
	double x, y;
	point(){
		x = y = 0;
	}
	point(double a, double b){
		x = a;
		y = b;
	}
	point operator +(const point b){
		return point(x+b.x, y+b.y);
	}
	point operator -(const point b){
		return point(x-b.x, y-b.y);
	}
	point operator -(){
		return point(-x, -y);
	}
	double operator *(const point b){
		return x*b.x+y*b.y;
	}
	double operator ^(const point b){
		return x*b.y-y*b.x;
	}
	point invert(){
		return point(-y, x);
	}
};

point operator *(int lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, int lambda){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(double lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, double lambda){
	return point(lambda*a.x, lambda*a.y);
}

double len(point a){
	return sqrt(a*a);
}

double angle(point a) {
	double ret = atan(a.y/a.x);
	if (a.x < 0) ret += pi;
	if (ret < 0) ret += 2*pi;
	return ret;
}

set<pair<double, double> > S;

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(15);
	int X, Y, v, t;
	int n;
	cin >> X >> Y >> v >> t >> n;
	double R = 1ll*v*t;
	if (v == 0 || t == 0) {
		for (int i = 0; i < n; i++) {
			int x, y, r;
			cin >> x >> y >> r;
			if ((x == X && y == Y) || (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y))) {
				cout << 1 << endl;
				return 0;
			}
		}
		cout << 0 << endl;
		return 0;
	}
	point O(X, Y);
	for (int i = 0; i < n; i++) {
		int x, y;
		double r;
		cin >> x >> y >> r;
		if ((x == X && y == Y) || (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y))) {
			cout << 1 << endl;
			return 0;
		}
		point P(x, y);
		double L = len(P-O);
		if (L > r+R) continue;
		else {
			if (L + min(r, R) < max(r, R)) {
				if (r > R) {
					cout << 1 << endl;
					return 0;
				}
				double ang = angle(P-O);
				double add = abs(atan(r/L));
				double start = ang-add;
				double end = ang+add;
				if (end > 2*pi) {
					S.insert(make_pair(0, start));
					end = 2*pi;
				}
				if (start < 0) start += 2*pi;
				S.insert(make_pair(start, end));
			}
			else {
				double ang = angle(P-O);
				double add = acos((R*R+L*L-r*r)/(2*R*L));
				double start = ang-add;
				double end = ang+add;
				if (end > 2*pi) {
					S.insert(make_pair(0, start));
					end = 2*pi;
				}
				if (start < 0) start += 2*pi;
				S.insert(make_pair(start, end));
			}
		}
	}
	double ret = -1;
	double start, end;
	for (auto a : S) {
		if (ret < 0) {
			ret = 0;
			start = a.first;
			end = a.second;
		}
		else {
			if (a.first < end) {
				end = a.second;
			}
			else {
				ret += end-start;
				start = a.first;
				end = a.second;
			}
		}
		//cout << ret << endl;
	}
	ret += end-start;
	//cout << ret << endl;
	ret /= 2*pi;
	cout << ret << endl;

}


#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <iomanip>
#include <stack>
#include <sstream>
#include <queue>
#include <set>
#include <functional>
#include <utility>

#define endl '\n'
#define eps 1e-9
#define ll long long int

using namespace std;

const double pi = 3.14159265358979323846;

class point{
public:
	double x, y;
	point(){
		x = y = 0;
	}
	point(double a, double b){
		x = a;
		y = b;
	}
	point operator +(const point b){
		return point(x+b.x, y+b.y);
	}
	point operator -(const point b){
		return point(x-b.x, y-b.y);
	}
	point operator -(){
		return point(-x, -y);
	}
	double operator *(const point b){
		return x*b.x+y*b.y;
	}
	double operator ^(const point b){
		return x*b.y-y*b.x;
	}
	point invert(){
		return point(-y, x);
	}
};

point operator *(int lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, int lambda){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(double lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, double lambda){
	return point(lambda*a.x, lambda*a.y);
}

double len(point a){
	return sqrt(a*a);
}

double angle(point a) {
	double ret = atan2(a.y, a.x);
	if (ret < 0) ret += 2*pi;
	return ret;
}

set<pair<double, double> > S;

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(15);
	ll X, Y, v, t;
	int n;
	cin >> X >> Y >> v >> t >> n;
	double R = 1.0*v*t;
	if (v == 0 || t == 0) {
		for (int i = 0; i < n; i++) {
			ll x, y, r;
			cin >> x >> y >> r;
			if ((x == X && y == Y) || (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y))) {
				cout << 1 << endl;
				return 0;
			}
		}
		cout << 0 << endl;
		return 0;
	}
	point O(X, Y);
	for (int i = 0; i < n; i++) {
		int x, y;
		ll r;
		cin >> x >> y >> r;
		if (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y)) {
			cout << 1 << endl;
			return 0;
		}
		point P(x, y);
		double L = len(P-O);
		if (L+1e-9 >= r+R) continue;
		else {
			// cout << "here\n";
			double tLen = sqrt(L*L-r*r);
			double ang = angle(P-O);
			double add;
			if (tLen - 1e-9 <= R)
				add = abs(asin(r/L));
			else
				add = acos((R*R+L*L-r*r)/(2*R*L));
			double start = ang-add;
			double end = ang+add;
			if (end > 2*pi) {
				S.insert(make_pair(0, end-2*pi));
				end = 2*pi;
			}
			if (start < 0) {
				start += 2*pi;
				S.insert(make_pair(start, 2*pi));
				start = 0;
			}
			S.insert(make_pair(start, end));
		}
	}
	double ret = -1;
	double start, end;
	for (auto a : S) {
		// cout << "angles from " << a.first*180/pi << " to " << a.second*180/pi << endl;
		if (ret < 0) {
			ret = 0;
			start = a.first;
			end = a.second;
		}
		else {
			if (a.first < end) {
				end = a.second;
			}
			else {
				// cout << start*180/pi << ' ' << end*180/pi << endl;
				ret += end-start;
				start = a.first;
				end = a.second;
			}
		}
		// cout << ret*180/pi << endl;
	}
	if (ret > -0.5)
		ret += end-start;
	else {
		ret = 0;
	}
	// cout << ret*180/pi << endl;
	ret /= 2*pi;
	cout << ret << endl;

}


#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <iomanip>
#include <stack>
#include <sstream>
#include <queue>
#include <set>
#include <functional>
#include <utility>

#define endl '\n'
#define eps 1e-9
#define ll long long int

using namespace std;

const double pi = 3.14159265359;

class point{
public:
	double x, y;
	point(){
		x = y = 0;
	}
	point(double a, double b){
		x = a;
		y = b;
	}
	point operator +(const point b){
		return point(x+b.x, y+b.y);
	}
	point operator -(const point b){
		return point(x-b.x, y-b.y);
	}
	point operator -(){
		return point(-x, -y);
	}
	double operator *(const point b){
		return x*b.x+y*b.y;
	}
	double operator ^(const point b){
		return x*b.y-y*b.x;
	}
	point invert(){
		return point(-y, x);
	}
};

point operator *(int lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, int lambda){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(double lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, double lambda){
	return point(lambda*a.x, lambda*a.y);
}

double len(point a){
	return sqrt(a*a);
}

double angle(point a) {
	double ret = atan(a.y/a.x);
	if (a.x < 0) ret += pi;
	if (ret < 0) ret += 2*pi;
	return ret;
}

set<pair<double, double> > S;

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(15);
	int X, Y, v, t;
	int n;
	cin >> X >> Y >> v >> t >> n;
	double R = 1ll*v*t;
	if (v == 0 || t == 0) {
		for (int i = 0; i < n; i++) {
			int x, y, r;
			cin >> x >> y >> r;
			if ((x == X && y == Y) || (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y))) {
				cout << 1 << endl;
				return 0;
			}
		}
		cout << 0 << endl;
		return 0;
	}
	point O(X, Y);
	for (int i = 0; i < n; i++) {
		int x, y;
		double r;
		cin >> x >> y >> r;
		if ((x == X && y == Y) || (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y))) {
			cout << 1 << endl;
			return 0;
		}
		point P(x, y);
		double L = len(P-O);
		if (L > r+R) continue;
		else {
			if (L + min(r, R) < max(r, R)) {
				if (r > R) {
					cout << 1 << endl;
					return 0;
				}
				double ang = angle(P-O);
				double add = abs(atan(r/L));
				double start = ang-add;
				double end = ang+add;
				if (end > 2*pi) {
					S.insert(make_pair(0, end-2*pi));
					end = 2*pi;
				}
				if (start < 0) {
					start += 2*pi;
					S.insert(make_pair(start, 2*pi));
					start = 0;
				}
				S.insert(make_pair(start, end));
			}
			else {
				double ang = angle(P-O);
				double add = acos((R*R+L*L-r*r)/(2*R*L));
				double start = ang-add;
				double end = ang+add;
				if (end > 2*pi) {
					S.insert(make_pair(0, end-2*pi));
					end = 2*pi;
				}
				if (start < 0) {
					start += 2*pi;
					S.insert(make_pair(start, 2*pi));
					start = 0;
				}
				S.insert(make_pair(start, end));
			}
		}
	}
	double ret = -1;
	double start, end;
	for (auto a : S) {
		if (ret < 0) {
			ret = 0;
			start = a.first;
			end = a.second;
		}
		else {
			if (a.first < end) {
				end = a.second;
			}
			else {
				ret += end-start;
				start = a.first;
				end = a.second;
			}
		}
		// cout << ret << endl;
	}
	ret += end-start;
	//cout << ret << endl;
	ret /= 2*pi;
	cout << ret << endl;

}


#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <iomanip>
#include <stack>
#include <sstream>
#include <queue>
#include <set>
#include <functional>
#include <utility>

#define endl '\n'
#define eps 1e-9
#define ll long long int

using namespace std;

const double pi = 3.14159265358979323846;

class point{
public:
	double x, y;
	point(){
		x = y = 0;
	}
	point(double a, double b){
		x = a;
		y = b;
	}
	point operator +(const point b){
		return point(x+b.x, y+b.y);
	}
	point operator -(const point b){
		return point(x-b.x, y-b.y);
	}
	point operator -(){
		return point(-x, -y);
	}
	double operator *(const point b){
		return x*b.x+y*b.y;
	}
	double operator ^(const point b){
		return x*b.y-y*b.x;
	}
	point invert(){
		return point(-y, x);
	}
};

point operator *(int lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, int lambda){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(double lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, double lambda){
	return point(lambda*a.x, lambda*a.y);
}

double len(point a){
	return sqrt(a*a);
}

double angle(point a) {
	double ret = atan2(a.y, a.x);
	if (ret < 0) ret += 2*pi;
	return ret;
}

set<pair<double, double> > S;

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(15);
	int X, Y, v, t;
	int n;
	cin >> X >> Y >> v >> t >> n;
	double R = 1.0*v*t;
	if (v == 0 || t == 0) {
		for (int i = 0; i < n; i++) {
			int x, y, r;
			cin >> x >> y >> r;
			if ((x == X && y == Y) || (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y))) {
				cout << 1 << endl;
				return 0;
			}
		}
		cout << 0 << endl;
		return 0;
	}
	point O(X, Y);
	for (int i = 0; i < n; i++) {
		int x, y;
		ll r;
		cin >> x >> y >> r;
		if (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y)) {
			cout << 1 << endl;
			return 0;
		}
		point P(x, y);
		double L = len(P-O);
		if (L > r+R) continue;
		else {
			if (L + min(r, 1ll*v*t) < max(r, 1ll*v*t)) {
				double ang = angle(P-O);
				double add = abs(asin(r/L));
				double start = ang-add;
				double end = ang+add;
				if (end > 2*pi) {
					S.insert(make_pair(0, end-2*pi));
					end = 2*pi;
				}
				if (start < 0) {
					start += 2*pi;
					S.insert(make_pair(start, 2*pi));
					start = 0;
				}
				S.insert(make_pair(start, end));
			}
			else {
				double ang = angle(P-O);
				double add = max(asin(r/L), acos((R*R+L*L-r*r)/(2*R*L)));
				double start = ang-add;
				double end = ang+add;
				if (end > 2*pi) {
					S.insert(make_pair(0, end-2*pi));
					end = 2*pi;
				}
				if (start < 0) {
					start += 2*pi;
					S.insert(make_pair(start, 2*pi));
					start = 0;
				}
				S.insert(make_pair(start, end));
			}
		}
	}
	double ret = -1;
	double start, end;
	for (auto a : S) {
		cout << "angles from " << a.first*180/pi << " to " << a.second*180/pi << endl;
		if (ret < 0) {
			ret = 0;
			start = a.first;
			end = a.second;
		}
		else {
			if (a.first < end) {
				end = a.second;
			}
			else {
				cout << start*180/pi << ' ' << end*180/pi << endl;
				ret += end-start;
				start = a.first;
				end = a.second;
			}
		}
		cout << ret*180/pi << endl;
	}
	ret += end-start;
	cout << ret*180/pi << endl;
	ret /= 2*pi;
	cout << ret << endl;

}


#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <iomanip>
#include <stack>
#include <sstream>
#include <queue>
#include <set>
#include <functional>
#include <utility>

#define endl '\n'
#define eps 1e-9
#define ll long long int

using namespace std;

const double pi = 3.14159265358979323846;

class point{
public:
	double x, y;
	point(){
		x = y = 0;
	}
	point(double a, double b){
		x = a;
		y = b;
	}
	point operator +(const point b){
		return point(x+b.x, y+b.y);
	}
	point operator -(const point b){
		return point(x-b.x, y-b.y);
	}
	point operator -(){
		return point(-x, -y);
	}
	double operator *(const point b){
		return x*b.x+y*b.y;
	}
	double operator ^(const point b){
		return x*b.y-y*b.x;
	}
	point invert(){
		return point(-y, x);
	}
};

point operator *(int lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, int lambda){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(double lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, double lambda){
	return point(lambda*a.x, lambda*a.y);
}

double len(point a){
	return sqrt(a*a);
}

double angle(point a) {
	double ret = atan2(a.y, a.x);
	if (ret < 0) ret += 2*pi;
	return ret;
}

set<pair<double, double> > S;

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(15);
	ll X, Y, v, t;
	int n;
	cin >> X >> Y >> v >> t >> n;
	double R = 1.0*v*t;
	point O(X, Y);
	for (int i = 0; i < n; i++) {
		int x, y;
		ll r;
		cin >> x >> y >> r;
		if (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y)) {
			cout << 1 << endl;
			return 0;
		}
		point P(x, y);
		double L = len(P-O);
		if (L - 1e-9 > r+R) continue;
		else {
			//cout << "here\n";
			double tLen = sqrt(L*L-1.0*r*r);
			double ang = angle(P-O);
			double add;
			if (tLen < R+1e-9)
				add = asin(r/L);
			else
				add = acos((R*R+L*L-1.0*r*r)/(2*R*L));
			double start = ang-add;
			double end = ang+add;
			if (end > 2*pi) {
				S.insert(make_pair(0, end-2*pi));
				end = 2*pi;
			}
			if (start < 0) {
				start += 2*pi;
				S.insert(make_pair(start, 2*pi));
				start = 0;
			}
			S.insert(make_pair(start, end));
		}
	}
	double ret = -1;
	double start, end;
	for (auto a : S) {
		// cout << "angles from " << a.first*180/pi << " to " << a.second*180/pi << endl;
		if (ret < 0) {
			ret = 0;
			start = a.first;
			end = a.second;
		}
		else {
			if (a.first < end) {
				end = a.second;
			}
			else {
				// cout << start*180/pi << ' ' << end*180/pi << endl;
				ret += end-start;
				start = a.first;
				end = a.second;
			}
		}
		// cout << ret*180/pi << endl;
	}
	if (ret > -0.5)
		ret += end-start;
	else {
		ret = 0;
	}
	// cout << ret*180/pi << endl;
	ret /= 2*pi;
	cout << ret << endl;

}


#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <iostream>
#include <map>
#include <iomanip>
#include <stack>
#include <sstream>
#include <queue>
#include <set>
#include <functional>
#include <utility>

#define endl '\n'
#define eps 1e-9
#define ll long long int

using namespace std;

const double pi = 3.14159265358979323846;

class point{
public:
	double x, y;
	point(){
		x = y = 0;
	}
	point(double a, double b){
		x = a;
		y = b;
	}
	point operator +(const point b){
		return point(x+b.x, y+b.y);
	}
	point operator -(const point b){
		return point(x-b.x, y-b.y);
	}
	point operator -(){
		return point(-x, -y);
	}
	double operator *(const point b){
		return x*b.x+y*b.y;
	}
	double operator ^(const point b){
		return x*b.y-y*b.x;
	}
	point invert(){
		return point(-y, x);
	}
};

point operator *(int lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, int lambda){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(double lambda, point a){
	return point(lambda*a.x, lambda*a.y);
}
point operator *(point a, double lambda){
	return point(lambda*a.x, lambda*a.y);
}

double len(point a){
	return sqrt(a*a);
}

double angle(point a) {
	double ret = atan2(a.y, a.x);
	if (ret < 0) ret += 2*pi;
	return ret;
}

set<pair<double, double> > S;

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(15);
	ll X, Y, v, t;
	int n;
	cin >> X >> Y >> v >> t >> n;
	double R = 1.0*v*t;
	if (v == 0 || t == 0) {
		for (int i = 0; i < n; i++) {
			ll x, y, r;
			cin >> x >> y >> r;
			if ((x == X && y == Y) || (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y))) {
				cout << 1 << endl;
				return 0;
			}
		}
		cout << 0 << endl;
		return 0;
	}
	point O(X, Y);
	for (int i = 0; i < n; i++) {
		int x, y;
		ll r;
		cin >> x >> y >> r;
		if (r*r >= (x-X)*(x-X)+(y-Y)*(y-Y)) {
			cout << 1 << endl;
			return 0;
		}
		point P(x, y);
		double L = len(P-O);
		if (L+1e-9 >= r+R) continue;
		else {
			if (L + 1e-9 <= R) {
				// cout << "here\n";
				double ang = angle(P-O);
				double add = abs(asin(r/L));
				double start = ang-add;
				double end = ang+add;
				if (end > 2*pi) {
					S.insert(make_pair(0, end-2*pi));
					end = 2*pi;
				}
				if (start < 0) {
					start += 2*pi;
					S.insert(make_pair(start, 2*pi));
					start = 0;
				}
				S.insert(make_pair(start, end));
			}
			else {
				// cout << "then it's here\n";
				double ang = angle(P-O);
				double add = acos((R*R+L*L-r*r)/(2*R*L));
				double start = ang-add;
				double end = ang+add;
				if (end > 2*pi) {
					S.insert(make_pair(0, end-2*pi));
					end = 2*pi;
				}
				if (start < 0) {
					start += 2*pi;
					S.insert(make_pair(start, 2*pi));
					start = 0;
				}
				S.insert(make_pair(start, end));
			}
		}
	}
	double ret = -1;
	double start, end;
	for (auto a : S) {
		// cout << "angles from " << a.first*180/pi << " to " << a.second*180/pi << endl;
		if (ret < 0) {
			ret = 0;
			start = a.first;
			end = a.second;
		}
		else {
			if (a.first < end) {
				end = a.second;
			}
			else {
				// cout << start*180/pi << ' ' << end*180/pi << endl;
				ret += end-start;
				start = a.first;
				end = a.second;
			}
		}
		// cout << ret*180/pi << endl;
	}
	if (ret > -0.5)
		ret += end-start;
	else {
		ret = 0;
	}
	// cout << ret*180/pi << endl;
	ret /= 2*pi;
	cout << ret << endl;

}


#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

#define pii pair<int,int>
#define pll pair<ll,ll>
#define pdd pair<double,double>
#define PB push_back
#define MP make_pair
#define N 100001

pll a[N];
ll r[N];
double PI = 4*atan(1);
vector< pdd > s;

ll dis2(pll b){
	return b.first * b.first + b.second * b.second;
}

double dis(pll b){
	return sqrt(dis2(b));
}

void update(double theta1, double theta2){
	if(theta2 <= 2*PI){
		if(theta1 >= 0)
			s.PB(MP(theta1,theta2));
		else{
			s.PB(MP(2*PI + theta1, 2*PI));
			s.PB(MP(0,theta2));
		}
	}
	else{
		s.PB(MP(theta1,2*PI));
		s.PB(MP(0,theta2 - PI));
	}
}

int main(){
	ll n, i, j, k, v, t, x, y, z, R;
	pll p0;
	bool f;
	double ans, theta0, theta, theta1, theta2, angle1, angle2, d, p;

	cin >> p0.first >> p0.second >> v >> t;

	cin >> n;

	for(i = 1; i <= n; i++){
		cin >> a[i].first >> a[i].second >> r[i];
		a[i].first -= p0.first;
		a[i].second -= p0.second;
	}

	for(i = 1, f = 0; i <= n && f == 0; i++)
		f = (dis2(a[i]) <= r[i] * r[i]);

	if(f == 1)
		ans = 1;
	else{
		R = v * t;
		for(i = 1; i <= n; i++){
			d = dis(a[i]);

			if(R + r[i] < d)
				continue;

			if(a[i].first == 0)
				if(a[i].second > 0)
					theta0 = PI/2;
				else
					theta0 = - PI/2;
			else{
				if(a[i].second == 0){
					if(a[i].first > 0)
						theta0 = 0;
					else
						theta0 = PI;
				}
				else{
					theta0 = atan(abs(1.0 * a[i].second / a[i].first));

					if(a[i].first > 0)
						if(a[i].second > 0);
						else
							theta0 = 2*PI - theta0;
					else
						if(a[i].second > 0)
							theta0 = PI - theta0;
						else
							theta0 = PI + theta0;
				}
			}

			x = r[i]*r[i] - R*R - dis2(a[i]);
			y = x + 2*dis2(a[i]);

			if(x == 0 || y == 0)
				angle2 = 2*PI;
			else{
				x /= abs(x);
				y /= abs(y);

				if(x == y)
					angle2 = 2*PI;
				else{
					p = d + (r[i]*r[i] - R*R) / d;
					p /= 2;
					p = abs(p);

					angle2 = atan(sqrt(abs(d*d - p*p)) / abs(d - p));
				}
			}

			angle1 = asin(r[i] / d);

			theta = min(angle1, angle2);

			theta1 = theta0 - theta;
			theta2 = theta0 + theta;

			// cout << i << ' ' << theta0 << ' ' << theta1 << ' ' << theta2 << '\n';

			update(theta1,theta2);
		}

		sort(s.begin(), s.end());

		for(i = 0, ans = 0; i < s.size(); i++){
			angle1 = s[i].first;

			for(j = i + 1; j < s.size() && s[j].first <= s[i].second; j++);

			j--;
			angle2 = s[j].second;

			ans += (angle2 - angle1);

			i = j;
		}

		ans /= (2*PI);
	}

	printf("%.15lf\n", ans);

	return 0;
}


#include <bits/stdc++.h>

typedef long long ll;

using namespace std;

#define pii pair<int,int>
#define pdd pair<double,double>
#define PB push_back
#define MP make_pair
#define N 100001

pdd a[N];
double r[N];
double PI = 4*atan(1);
vector< pdd > s;

double dis2(pdd b){
	return b.first * b.first + b.second * b.second;
}

double dis(pdd b){
	return sqrt(dis2(b));
}

int main(){
	ll n, i, j, k;
	double v, t, x, y, z, R;
	pdd p0;
	bool f;
	double ans, theta0, theta, theta1, theta2, angle1, angle2, d, p, p1, p2;

	scanf("%lf%lf%lf%lf", &p0.first, &p0.second, &v, &t);

	cin >> n;

	for(i = 1; i <= n; i++){
		scanf("%lf%lf%lf", &a[i].first, &a[i].second, &r[i]);
		a[i].first -= p0.first;
		a[i].second -= p0.second;
	}

	for(i = 1, f = 0; i <= n && f == 0; i++)
		f = (dis2(a[i]) <= r[i] * r[i]);

	if(f == 1)
		ans = 1;
	else{
		R = v * t;
		for(i = 1; i <= n; i++){
			d = dis(a[i]);

			// cout << d << '\n';

			if(R + r[i] < d)
				continue;

			theta0 = atan2(a[i].second, a[i].first);

			if(R * R + r[i] * r[i] < dis2(a[i]))
				theta = acos(abs(R*R + dis2(a[i]) - r[i] * r[i]) / (2 * R * d));
			else
				theta = abs(asin(r[i] / d));

			theta1 = theta0 - theta;
			theta2 = theta0 + theta;

			// cout << i << ' ' << theta0 << ' ' << theta1 << ' ' << theta2 << '\n';

			if(theta2 < 0){
				theta1 += 2*PI;
				theta2 += 2*PI;
				s.PB(MP(theta1, theta2));
			}
			else{
				if(theta1 < 0){
					s.PB(MP(2*PI + theta1, 2*PI));
					s.PB(MP(0,theta2));
				}
				else{
					if(theta2 > 2*PI){
						s.PB(MP(theta1, 2*PI));
						s.PB(MP(0,theta2 - 2*PI));
					}
					else
						s.PB(MP(theta1,theta2));
				}
			}
		}

		sort(s.begin(), s.end());

		for(i = 0, ans = 0; i < s.size(); i++){
			for(j = i + 1; j < s.size() && s[j].first <= s[i].second; j++);

			j--;

			angle1 = s[i].first;
			angle2 = s[j].second;

			ans += (angle2 - angle1);

			i = j;
		}

		ans /= (2*PI);

		ans = min(1.0,ans);
	}

	printf("%.15lf\n", ans);

	return 0;
}


#include <bits/stdc++.h>

typedef long long ll;

using namespace std;

#define pii pair<int,int>
#define pdd pair<double,double>
#define PB push_back
#define MP make_pair

double PI = 4*atan(1);
vector< pdd > s;

double dis(pdd b){
	return sqrt(b.first * b.first + b.second * b.second);
}

int main(){
	int n, i, j, k;
	double v, t, x, y, z, r, R;
	pdd p0, p;
	double ans, theta0, theta, theta1, theta2, angle1, angle2, d;

	scanf("%lf%lf%lf%lf", &p0.first, &p0.second, &v, &t);

	scanf("%d", &n);

	R = v * t;

	for(i = 1; i <= n; i++){
		scanf("%lf%lf%lf", &p.first, &p.second, &r);

		p.first -= p0.first;
		p.second -= p0.second;

		d = dis(p);

		if(d <= r){
			ans = 1;
			printf("%.15lf\n", ans);
			return 0;
		}

		// cout << d << '\n';

		if(R + r < d)
			continue;

		theta0 = atan2(p.second, p.first);

		if(R * R + r * r < d * d)
			theta = acos(abs(R*R + d * d - r * r) / (2 * R * d));
		else
			theta = abs(asin(r / d));

		theta1 = theta0 - theta;
		theta2 = theta0 + theta;

		// cout << i << ' ' << theta0 << ' ' << theta1 << ' ' << theta2 << '\n';

		if(theta1 < 0){
			theta1 += 2*PI;
			theta2 += 2*PI;
		}

		if(theta2 > 2*PI){
			s.PB(MP(theta1,2*PI));
			s.PB(MP(0,theta2 - 2*PI));
		}
		else
			s.PB(MP(theta1,theta2));
	}

	sort(s.begin(), s.end());

	// for(i = 0; i < s.size(); i++)
		// cout << s[i].first << ' ' << s[i].second << '\n';

	for(i = 0, ans = 0; i < s.size(); ){
		angle1 = s[i].first;
		angle2 = s[i].second;

		for(i++; i < s.size(); i++){
			if(s[i].first <= angle2)
				angle2 = max(angle2, s[i].second);
			else
				break;
		}

		ans += (angle2 - angle1);
	}

	ans /= (2*PI);

	ans = min(1.0,ans);

	printf("%.15lf\n", ans);

	return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

#define pii pair<int,int>
#define pll pair<ll,ll>
#define pdd pair<double,double>
#define PB push_back
#define MP make_pair
#define N 100001

pll a[N];
ll r[N];
double PI = 4*atan(1);
vector< pdd > s;

ll dis2(pll b){
	return b.first * b.first + b.second * b.second;
}

double dis(pll b){
	return sqrt(dis2(b));
}

int main(){
	ll n, i, j, k, v, t, x, y, z, R;
	pll p0;
	bool f;
	double ans, theta0, theta, theta1, theta2, angle1, angle2, d, p, p1, p2;

	cin >> p0.first >> p0.second >> v >> t;

	cin >> n;

	for(i = 1; i <= n; i++){
		cin >> a[i].first >> a[i].second >> r[i];
		a[i].first -= p0.first;
		a[i].second -= p0.second;
	}

	for(i = 1, f = 0; i <= n && f == 0; i++)
		f = (dis2(a[i]) <= r[i] * r[i]);

	if(f == 1)
		ans = 1;
	else{
		R = v * t;
		for(i = 1; i <= n; i++){
			d = dis(a[i]);

			// cout << d << '\n';

			if(R + r[i] < d)
				continue;

			theta0 = atan2(a[i].second, a[i].first);

			if(R * R + r[i] * r[i] < dis2(a[i]))
				theta = acos(abs(R*R + dis2(a[i]) - r[i] * r[i]) / (2 * R * d));
			else
				theta = abs(asin(r[i] / d));

			theta1 = theta0 - theta;
			theta2 = theta0 + theta;

			// cout << i << ' ' << theta0 << ' ' << theta1 << ' ' << theta2 << '\n';

			s.PB(MP(theta1,theta2));
		}

		sort(s.begin(), s.end());

		if(s.size() > 0)
			theta = 2*PI + s[0].first;

		for(i = 0, ans = 0; i < s.size(); i++){
			for(j = i + 1; j < s.size() && s[j].first <= s[i].second; j++);

			j--;

			angle1 = min(s[i].first, theta);
			angle2 = min(s[j].second, theta);

			ans += (angle2 - angle1);

			i = j;
		}

		ans /= (2*PI);

		ans = min(1.0,ans);
	}

	printf("%.15lf\n", ans);

	return 0;
}


#include <bits/stdc++.h>

typedef long long ll;

using namespace std;

#define pii pair<int,int>
#define pdd pair<double,double>
#define PB push_back
#define MP make_pair
#define N 100001

pdd a[N];
double r[N];
double PI = 4*atan(1);
vector< pdd > s;

double dis2(pdd b){
	return b.first * b.first + b.second * b.second;
}

double dis(pdd b){
	return sqrt(dis2(b));
}

int main(){
	ll n, i, j, k;
	double v, t, x, y, z, R;
	pdd p0;
	bool f;
	double ans, theta0, theta, theta1, theta2, angle1, angle2, d, p, p1, p2;

	cin >> p0.first >> p0.second >> v >> t;

	cin >> n;

	for(i = 1; i <= n; i++){
		cin >> a[i].first >> a[i].second >> r[i];
		a[i].first -= p0.first;
		a[i].second -= p0.second;
	}

	for(i = 1, f = 0; i <= n && f == 0; i++)
		f = (dis2(a[i]) <= r[i] * r[i]);

	if(f == 1)
		ans = 1;
	else{
		R = v * t;
		for(i = 1; i <= n; i++){
			d = dis(a[i]);

			// cout << d << '\n';

			if(R + r[i] < d)
				continue;

			theta0 = atan2(a[i].second, a[i].first);

			if(R * R + r[i] * r[i] < dis2(a[i]))
				theta = acos(abs(R*R + dis2(a[i]) - r[i] * r[i]) / (2 * R * d));
			else
				theta = abs(asin(r[i] / d));

			theta1 = theta0 - theta;
			theta2 = theta0 + theta;

			while(theta1 < 0){
				theta1 += 2*PI;
				theta2 += 2*PI;
			}

			// cout << i << ' ' << theta0 << ' ' << theta1 << ' ' << theta2 << '\n';

			if(theta2 <= 2*PI)
				s.PB(MP(theta1,theta2));
			else{
				s.PB(MP(theta1,2*PI));
				s.PB(MP(0,theta2 - 2*PI));
			}
		}

		sort(s.begin(), s.end());

		if(s.size() > 0)
			theta = 2*PI + s[0].first;

		for(i = 0, ans = 0; i < s.size(); i++){
			for(j = i + 1; j < s.size() && s[j].first <= s[i].second; j++);

			j--;

			angle1 = min(s[i].first, theta);
			angle2 = min(s[j].second, theta);

			ans += (angle2 - angle1);

			i = j;
		}

		ans /= (2*PI);

		ans = min(1.0,ans);
	}

	printf("%.15lf\n", ans);

	return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

#define pii pair<int,int>
#define pll pair<ll,ll>
#define pdd pair<double,double>
#define PB push_back
#define MP make_pair
#define N 100001

pll a[N];
ll r[N];
double PI = 4*atan(1);
vector< pdd > s;

ll dis2(pll b){
	return b.first * b.first + b.second * b.second;
}

double dis(pll b){
	return sqrt(dis2(b));
}

void update(double theta1, double theta2){
	if(theta2 <= 2*PI){
		if(theta1 >= 0)
			s.PB(MP(theta1,theta2));
		else{
			s.PB(MP(2*PI + theta1, 2*PI));
			s.PB(MP(0,theta2));
		}
	}
	else{
		s.PB(MP(theta1,2*PI));
		s.PB(MP(0,theta2 - PI));
	}
}

int main(){
	ll n, i, j, k, v, t, x, y, z, R;
	pll p0;
	bool f;
	double ans, theta0, theta, theta1, theta2, angle1, angle2, d, p, p1, p2;

	cin >> p0.first >> p0.second >> v >> t;

	cin >> n;

	for(i = 1; i <= n; i++){
		cin >> a[i].first >> a[i].second >> r[i];
		a[i].first -= p0.first;
		a[i].second -= p0.second;
	}

	for(i = 1, f = 0; i <= n && f == 0; i++)
		f = (dis2(a[i]) <= r[i] * r[i]);

	if(f == 1)
		ans = 1;
	else{
		R = v * t;
		for(i = 1; i <= n; i++){
			d = dis(a[i]);

			// cout << d << '\n';

			if(R + r[i] < d)
				continue;

			if(a[i].first == 0)
				if(a[i].second > 0)
					theta0 = PI/2;
				else
					theta0 = - PI/2;
			else{
				if(a[i].second == 0){
					if(a[i].first > 0)
						theta0 = 0;
					else
						theta0 = PI;
				}
				else{
					theta0 = atan(abs(1.0 * a[i].second / a[i].first));

					if(a[i].first > 0)
						if(a[i].second > 0);
						else
							theta0 = 2*PI - theta0;
					else
						if(a[i].second > 0)
							theta0 = PI - theta0;
						else
							theta0 = PI + theta0;
				}
			}

			x = r[i]*r[i] - R*R - dis2(a[i]);
			y = x + 2*dis2(a[i]);

			if(x == 0 || y == 0)
				angle2 = 2*PI;
			else{
				x /= abs(x);
				y /= abs(y);

				if(x == y)
					angle2 = 2*PI;
				else{
					p = d + (r[i]*r[i] - R*R) / d;
					p /= 2;
					p = abs(p);

					p1 = p;
					p2 = r[i] * r[i] / d;

					if(p1 > p2)
						angle2 = atan(sqrt(abs(r[i] * r[i] - p*p)) / abs(d - p));
					else
						angle2 = 2*PI;
				}
			}

			angle1 = asin(r[i] / d);

			theta = min(angle1, angle2);

			theta1 = theta0 - theta;
			theta2 = theta0 + theta;

			// cout << i << ' ' << theta0 << ' ' << theta1 << ' ' << theta2 << '\n';

			update(theta1,theta2);
		}

		sort(s.begin(), s.end());

		for(i = 0, ans = 0; i < s.size(); i++){
			angle1 = s[i].first;

			for(j = i + 1; j < s.size() && s[j].first <= s[i].second; j++);

			j--;
			angle2 = s[j].second;

			ans += (angle2 - angle1);

			i = j;
		}

		ans /= (2*PI);
	}

	printf("%.15lf\n", ans);

	return 0;
}


#include <bits/stdc++.h>

typedef long long ll;

using namespace std;

#define pii pair<int,int>
#define pdd pair<double,double>
#define PB push_back
#define MP make_pair
#define N 100001

pdd a[N];
double r[N];
double PI = 4*atan(1);
vector< pdd > s;

double dis2(pdd b){
	return b.first * b.first + b.second * b.second;
}

double dis(pdd b){
	return sqrt(dis2(b));
}

int main(){
	ll n, i, j, k;
	double v, t, x, y, z, R;
	pdd p0;
	bool f;
	double ans, theta0, theta, theta1, theta2, angle1, angle2, d, p, p1, p2;

	scanf("%lf%lf%lf%lf", &p0.first, &p0.second, &v, &t);

	cin >> n;

	for(i = 1; i <= n; i++){
		scanf("%lf%lf%lf", &a[i].first, &a[i].second, &r[i]);
		a[i].first -= p0.first;
		a[i].second -= p0.second;
	}

	for(i = 1, f = 0; i <= n && f == 0; i++)
		f = (dis2(a[i]) <= r[i] * r[i]);

	if(f == 1)
		ans = 1;
	else{
		R = v * t;
		for(i = 1; i <= n; i++){
			d = dis(a[i]);

			// cout << d << '\n';

			if(R + r[i] < d)
				continue;

			theta0 = atan2(a[i].second, a[i].first);

			if(R * R + r[i] * r[i] < dis2(a[i]))
				theta = acos(abs(R*R + dis2(a[i]) - r[i] * r[i]) / (2 * R * d));
			else
				theta = abs(asin(r[i] / d));

			theta1 = theta0 - theta;
			theta2 = theta0 + theta;

			while(theta1 < 0){
				theta1 += 2*PI;
				theta2 += 2*PI;
			}

			// cout << i << ' ' << theta0 << ' ' << theta1 << ' ' << theta2 << '\n';

			if(theta2 <= 2*PI)
				s.PB(MP(theta1,theta2));
			else{
				s.PB(MP(theta1,2*PI));
				s.PB(MP(0,theta2 - 2*PI));
			}
		}

		sort(s.begin(), s.end());

		for(i = 0, ans = 0; i < s.size(); i++){
			for(j = i + 1; j < s.size() && s[j].first <= s[i].second; j++);

			j--;

			angle1 = s[i].first;
			angle2 = s[j].second;

			ans += (angle2 - angle1);

			i = j;
		}

		ans /= (2*PI);

		ans = min(1.0,ans);
	}

	printf("%.15lf\n", ans);

	return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

#define pii pair<int,int>
#define pll pair<ll,ll>
#define pdd pair<double,double>
#define PB push_back
#define MP make_pair
#define N 100001

pll a[N];
ll r[N];
double PI = 4*atan(1);
vector< pdd > s;

ll dis2(pll b){
	return b.first * b.first + b.second * b.second;
}

double dis(pll b){
	return sqrt(dis2(b));
}

int main(){
	ll n, i, j, k, v, t, x, y, z, R;
	pll p0;
	bool f;
	double ans, theta0, theta, theta1, theta2, angle1, angle2, d, p, p1, p2;

	cin >> p0.first >> p0.second >> v >> t;

	cin >> n;

	for(i = 1; i <= n; i++){
		cin >> a[i].first >> a[i].second >> r[i];
		a[i].first -= p0.first;
		a[i].second -= p0.second;
	}

	for(i = 1, f = 0; i <= n && f == 0; i++)
		f = (dis2(a[i]) <= r[i] * r[i]);

	if(f == 1)
		ans = 1;
	else{
		R = v * t;
		for(i = 1; i <= n; i++){
			d = dis(a[i]);

			// cout << d << '\n';

			if(R + r[i] < d)
				continue;

			if(a[i].first == 0)
				if(a[i].second > 0)
					theta0 = PI/2;
				else
					theta0 = - PI/2;
			else{
				if(a[i].second == 0){
					if(a[i].first > 0)
						theta0 = 0;
					else
						theta0 = PI;
				}
				else{
					theta0 = atan(abs(1.0 * a[i].second / a[i].first));

					if(a[i].first > 0)
						if(a[i].second > 0);
						else
							theta0 = 2*PI - theta0;
					else
						if(a[i].second > 0)
							theta0 = PI - theta0;
						else
							theta0 = PI + theta0;
				}
			}

			x = r[i]*r[i] - R*R - dis2(a[i]);
			y = x + 2*dis2(a[i]);

			if(x == 0 || y == 0)
				angle2 = 2*PI;
			else{
				x /= abs(x);
				y /= abs(y);

				if(x == y)
					angle2 = 2*PI;
				else{
					p = d + (r[i]*r[i] - R*R) / d;
					p /= 2;
					p = abs(p);

					p1 = p;
					p2 = r[i] * r[i] / d;

					if(p1 > p2)
						angle2 = atan(sqrt(abs(r[i] * r[i] - p*p)) / abs(d - p));
					else
						angle2 = 2*PI;
				}
			}

			angle1 = asin(r[i] / d);

			theta = min(angle1, angle2);

			theta1 = theta0 - theta;
			theta2 = theta0 + theta;

			// cout << i << ' ' << theta0 << ' ' << theta1 << ' ' << theta2 << '\n';

			s.PB(MP(theta1,theta2));
		}

		sort(s.begin(), s.end());

		if(s.size() > 0)
			theta = 2*PI + s[0].first;

		for(i = 0, ans = 0; i < s.size(); i++){
			for(j = i + 1; j < s.size() && s[j].first <= s[i].second; j++);

			j--;

			angle1 = min(s[i].first, theta);
			angle2 = min(s[j].second, theta);

			ans += (angle2 - angle1);

			i = j;
		}

		ans /= (2*PI);
	}

	printf("%.15lf\n", ans);

	return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

#define pii pair<int,int>
#define pll pair<ll,ll>
#define pdd pair<double,double>
#define PB push_back
#define MP make_pair
#define N 100001

pll a[N];
ll r[N];
double PI = 4*atan(1);
vector< pdd > s;

ll dis2(pll b){
	return b.first * b.first + b.second * b.second;
}

double dis(pll b){
	return sqrt(dis2(b));
}

void update(double theta1, double theta2){
	if(theta2 <= 2*PI){
		if(theta1 >= 0)
			s.PB(MP(theta1,theta2));
		else{
			s.PB(MP(2*PI + theta1, 2*PI));
			s.PB(MP(0,theta2));
		}
	}
	else{
		s.PB(MP(theta1,2*PI));
		s.PB(MP(0,theta2 - PI));
	}
}

int main(){
	ll n, i, j, k, v, t, x, y, z, R;
	pll p0;
	bool f;
	double ans, theta0, theta, theta1, theta2, angle1, angle2, d, p;

	cin >> p0.first >> p0.second >> v >> t;

	cin >> n;

	for(i = 1; i <= n; i++){
		cin >> a[i].first >> a[i].second >> r[i];
		a[i].first -= p0.first;
		a[i].second -= p0.second;
	}

	for(i = 1, f = 0; i <= n && f == 0; i++)
		f = (dis2(a[i]) <= r[i] * r[i]);

	if(f == 1)
		ans = 1;
	else{
		R = v * t;
		for(i = 1; i <= n; i++){
			d = dis(a[i]);

			// cout << d << '\n';

			if(R + r[i] < d)
				continue;

			if(a[i].first == 0)
				if(a[i].second > 0)
					theta0 = PI/2;
				else
					theta0 = - PI/2;
			else{
				if(a[i].second == 0){
					if(a[i].first > 0)
						theta0 = 0;
					else
						theta0 = PI;
				}
				else{
					theta0 = atan(abs(1.0 * a[i].second / a[i].first));

					if(a[i].first > 0)
						if(a[i].second > 0);
						else
							theta0 = 2*PI - theta0;
					else
						if(a[i].second > 0)
							theta0 = PI - theta0;
						else
							theta0 = PI + theta0;
				}
			}

			x = r[i]*r[i] - R*R - dis2(a[i]);
			y = x + 2*dis2(a[i]);

			if(x == 0 || y == 0)
				angle2 = 2*PI;
			else{
				x /= abs(x);
				y /= abs(y);

				if(x == y)
					angle2 = 2*PI;
				else{
					p = d + (r[i]*r[i] - R*R) / d;
					p /= 2;
					p = abs(p);

					angle2 = atan(sqrt(abs(r[i] * r[i] - p*p)) / abs(d - p));
				}
			}

			angle1 = asin(r[i] / d);

			theta = min(angle1, angle2);

			theta1 = theta0 - theta;
			theta2 = theta0 + theta;

			// cout << i << ' ' << theta0 << ' ' << theta1 << ' ' << theta2 << '\n';

			update(theta1,theta2);
		}

		sort(s.begin(), s.end());

		for(i = 0, ans = 0; i < s.size(); i++){
			angle1 = s[i].first;

			for(j = i + 1; j < s.size() && s[j].first <= s[i].second; j++);

			j--;
			angle2 = s[j].second;

			ans += (angle2 - angle1);

			i = j;
		}

		ans /= (2*PI);
	}

	printf("%.15lf\n", ans);

	return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

#define pii pair<int,int>
#define pll pair<ll,ll>
#define pdd pair<double,double>
#define PB push_back
#define MP make_pair
#define N 100001

pll a[N];
ll r[N];
double PI = 4*atan(1);
vector< pdd > s;

ll dis2(pll b){
	return b.first * b.first + b.second * b.second;
}

double dis(pll b){
	return sqrt(dis2(b));
}

int main(){
	ll n, i, j, k, v, t, x, y, z, R;
	pll p0;
	bool f;
	double ans, theta0, theta, theta1, theta2, angle1, angle2, d, p, p1, p2;

	cin >> p0.first >> p0.second >> v >> t;

	cin >> n;

	for(i = 1; i <= n; i++){
		cin >> a[i].first >> a[i].second >> r[i];
		a[i].first -= p0.first;
		a[i].second -= p0.second;
	}

	for(i = 1, f = 0; i <= n && f == 0; i++)
		f = (dis2(a[i]) <= r[i] * r[i]);

	if(f == 1)
		ans = 1;
	else{
		R = v * t;
		for(i = 1; i <= n; i++){
			d = dis(a[i]);

			// cout << d << '\n';

			if(R + r[i] < d)
				continue;

			if(a[i].first == 0)
				if(a[i].second > 0)
					theta0 = PI/2;
				else
					theta0 = - PI/2;
			else{
				if(a[i].second == 0){
					if(a[i].first > 0)
						theta0 = 0;
					else
						theta0 = PI;
				}
				else{
					theta0 = atan(abs(1.0 * a[i].second / a[i].first));

					if(a[i].first > 0)
						if(a[i].second > 0);
						else
							theta0 = 2*PI - theta0;
					else
						if(a[i].second > 0)
							theta0 = PI - theta0;
						else
							theta0 = PI + theta0;
				}
			}

			x = r[i]*r[i] - R*R - dis2(a[i]);
			y = x + 2*dis2(a[i]);

			if(x == 0 || y == 0)
				angle2 = 2*PI;
			else{
				x /= abs(x);
				y /= abs(y);

				if(x == y)
					angle2 = 2*PI;
				else{
					p = d + (r[i]*r[i] - R*R) / d;
					p /= 2;
					p = abs(p);

					p1 = p;
					p2 = r[i] * r[i] / d;

					if(p1 > p2)
						angle2 = atan(sqrt(abs(r[i] * r[i] - p*p)) / abs(d - p));
					else
						angle2 = 2*PI;
				}
			}

			angle1 = asin(r[i] / d);

			theta = min(angle1, angle2);

			theta1 = theta0 - theta;
			theta2 = theta0 + theta;

			// cout << i << ' ' << theta0 << ' ' << theta1 << ' ' << theta2 << '\n';

			s.PB(MP(theta1,theta2));
		}

		sort(s.begin(), s.end());

		theta = 2*PI + s[0].first;

		for(i = 0; i < s.size(); i++){
			for(j = i + 1; j < s.size() && s[j].first <= s[i].second; j++);

			j--;

			angle1 = min(s[i].first, theta);
			angle2 = min(s[j].second, theta);

			ans += (angle2 - angle1);

			i = j;
		}

		ans /= (2*PI);
	}

	printf("%.15lf\n", ans);

	return 0;
}