#include <bits/stdc++.h>
using namespace std;

#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define RFOR(i, a, b) for(int i = (a) - 1; i >= (b); i--)
#define SZ(a) int(a.size())
#define ALL(a) a.begin(), a.end()
#define PB push_back
#define MP make_pair
#define F first
#define S second

typedef long long LL;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef long double db;

const db PI = acos(-1.0);
const db EPS = 1e-9;

struct Pt
{
	db x, y;
	Pt operator+(const Pt& p) const
	{
		return {x + p.x, y + p.y};
	}
	Pt operator-(const Pt& p) const
	{
		return {x - p.x, y - p.y};
	}
	Pt operator*(db d) const
	{
		return {x * d, y * d};
	}
	Pt operator/(db d) const
	{
		return {x / d, y / d};
	}
};
db sq(const Pt& p)
{
	return p.x * p.x + p.y * p.y;
}
db abs(const Pt& p)
{
	return sqrt(sq(p));
}
int sgn(db x)
{
	return (EPS < x) - (x < -EPS);
}
// Returns `p` rotated counter-clockwise by `a`
Pt rot(const Pt& p, db a)
{
	db co = cos(a), si = sin(a);
	return {p.x * co - p.y * si,
		p.x * si + p.y * co};
}
// Returns `p` rotated counter-clockwise by 90 degrees
Pt perp(const Pt& p)
{
	return {-p.y, p.x};
}
db dot(const Pt& p, const Pt& q)
{
	return p.x * q.x + p.y * q.y;
}
// Returns the angle between `p` and `q` in [0, pi]
db angle(const Pt& p, const Pt& q)
{
	return acos(clamp(dot(p, q) / abs(p) /
		abs(q), (db)-1.0, (db)1.0));
}
db cross(const Pt& p, const Pt& q)
{
	return p.x * q.y - p.y * q.x;
}
// Positive if R is on the left side of PQ,
// negative on the right side,
// and zero if R is on the line containing PQ
db orient(const Pt& p, const Pt& q, const Pt& r)
{
	return cross(q - p, r - p) / abs(q - p);
}
// Checks if argument of `p` is in [-pi, 0)
bool half(const Pt& p)
{
	assert(sgn(p.x) != 0 || sgn(p.y) != 0);
	return sgn(p.y) == -1 ||
		(sgn(p.y) == 0 && sgn(p.x) == -1);
}
void polarSortAround(const Pt& o, vector<Pt>& v)
{
	sort(ALL(v), [o](Pt p, Pt q)
	{
		p = p - o;
		q = q - o;
		bool hp = half(p), hq = half(q);
		if (hp != hq)
			return hp < hq;
		int s = sgn(cross(p, q));
		if (s != 0)
			return s == 1;
		return sq(p) < sq(q);
	});
}
ostream& operator<<(ostream& os, const Pt& p)
{
	return os << "(" << p.x << "," << p.y << ")";
}
struct Line
{
	// Equation of the line is dot(n, p) + c = 0
	Pt n;
	db c;
	Line() {}
	Line (const Pt& _n, db _c): n(_n), c(_c) {}
	// n is the normal vector to the left of PQ
	Line(const Pt& p, const Pt& q):
		n(perp(q - p)), c(-dot(n, p)) {}
	// The "positive side": dot(n, p) + c > 0
	// The "negative side": dot(n, p) + c < 0
	db side(const Pt& p) const
	{
		return dot(n, p) + c;
	}
	db dist(const Pt& p) const
	{
		return abs(side(p)) / abs(n);
	}
	db sqDist(const Pt& p) const
	{
		return side(p) * side(p) / (db)sq(n);
	}
	Line perpThrough(const Pt& p) const
	{
		return {p, p + n};
	}
	bool cmpProj(const Pt& p, const Pt& q) const
	{
		return sgn(cross(p, n) - cross(q, n)) < 0;
	}
	Pt proj(const Pt& p) const
	{
		return p - n * side(p) / sq(n);
	}
	Pt reflect(const Pt& p) const
	{
		return p - n * 2 * side(p) / sq(n);
	}
};
bool parallel(const Line& l1, const Line& l2)
{
	return sgn(cross(l1.n, l2.n)) == 0;
}
Pt inter(const Line& l1, const Line& l2)
{
	db d = cross(l1.n, l2.n);
	assert(sgn(d) != 0);
	return perp(l2.n * l1.c - l1.n * l2.c) / d;
}
// Checks if `p` is in the disk (the region in a plane
// bounded by a circle) of diameter [ab]
bool inDisk(const Pt& a, const Pt& b, const Pt& p)
{
	return sgn(dot(a - p, b - p)) <= 0;
}
// Checks if `p` lies on segment [ab]
bool onSegment(const Pt& a, const Pt& b, const Pt& p)
{
	return sgn(orient(a, b, p)) == 0 && inDisk(a, b, p);
}
// Checks if the segments [ab] and [cd] intersect
// properly (their intersection is one point
// which is not an endpoint of either segment)
bool properInter(const Pt& a, const Pt& b, const Pt& c, const Pt& d)
{
	db oa = orient(c, d, a);
	db ob = orient(c, d, b);
	db oc = orient(a, b, c);
	db od = orient(a, b, d);
	return sgn(oa) * sgn(ob) == -1 && sgn(oc) * sgn(od) == -1;
}
// Returns the distance between [ab] and `p`
db segPt(const Pt& a, const Pt& b, const Pt& p)
{
	Line l(a, b);
	assert(sgn(sq(l.n)) != 0);
	if (l.cmpProj(a, p) && l.cmpProj(p, b))
		return l.dist(p);
	return min(abs(p - a), abs(p - b));
}
// Returns the distance between [ab] and [cd]
db segSeg(const Pt& a, const Pt& b, const Pt& c, const Pt& d)
{
	if (properInter(a, b, c, d))
		return 0;
	return min({segPt(a, b, c), segPt(a, b, d),
			segPt(c, d, a), segPt(c, d, b)});
}
// Returns the circumcenter of triangle abc.
// The circumcircle of a triangle is a circle that passes through all three vertices.
Pt circumCenter(const Pt& a, Pt b, Pt c)
{
	b = b - a;
	c = c - a;
	assert(sgn(cross(b, c)) != 0);
	return a + perp(b * sq(c) - c * sq(b)) / cross(b, c) / 2;
}
// Returns circle-line intersection points
vector<Pt> circleLine(const Pt& o, db r, const Line& l)
{
	db h2 = r * r - l.sqDist(o);
	if (sgn(h2) == -1)
		return {};
	Pt p = l.proj(o);
	if (sgn(h2) == 0)
		return {p};
	Pt h = perp(l.n) * sqrt(h2) / abs(l.n);
	return {p - h, p + h};
}
// Returns circle-circle intersection points
vector<Pt> circleCircle(const Pt& o1, db r1, const Pt& o2, db r2)
{
	Pt d = o2 - o1;
	db d2 = sq(d);
	if (sgn(sqrt(d2)) == 0)
		return {};
	db pd = (d2 + r1 * r1 - r2 * r2) / 2;
	db h2 = r1 * r1 - pd * pd / d2;
	if (sgn(h2) == -1)
		return {};
	Pt p = o1 + d * pd / d2;
	if (sgn(h2) == 0)
		return {p};
	Pt h = perp(d) * sqrt(h2 / d2);
	return {p - h, p + h};
}

struct Sector
{
	Pt c;
	db r, s, theta;
	Line l[2];
	void read()
	{
		cin >> c.x >> c.y >> r >> s >> theta;
	}
	bool contains(const Pt& p) const
	{
		db d = abs(p - c);
		if (sgn(d) == 0)
			return true;
		if (sgn(d - r) > 0)
			return false;
		db phi = atan2(p.y - c.y, p.x - c.x);
		FOR(i, 0, 3)
		{
			if (sgn(s - phi) <= 0 && sgn(phi - (s + theta)) <= 0)
				return true;
			phi += 2 * PI;
		}
		return false;
	}
};

vector<Pt> getPtsOnSeg(const Pt& p1, const Pt& p2, const Sector& s)
{
	Line l(p1, p2);
	vector<Pt> res = {p1, p2};
	vector<Pt> qq = circleLine(s.c, s.r, l);
	qq.PB(s.c);
	FOR(i, 0, 2)
	{
		if (parallel(l, s.l[i]))
			continue;
		qq.PB(inter(l, s.l[i]));
	}
	for (const Pt& q : qq)
	{
		if (onSegment(p1, p2, q) && s.contains(q))
			res.PB(q);
	}
	sort(ALL(res), [&](const Pt& q1, const Pt& q2)
	{
		return sgn(abs(q1 - p1) - abs(q2 - p1)) < 0;
	});
	return res;
}

vector<db> getPhisOnArc(const Sector& s1, const Sector& s2)
{
	vector<Pt> qq = circleCircle(s1.c, s1.r, s2.c, s2.r);
	FOR(i, 0, 2)
	{
		vector<Pt> qqq = circleLine(s1.c, s1.r, s2.l[i]);
		qq.insert(qq.end(), ALL(qqq));
	}
	vector<db> res = {s1.s, s1.s + s1.theta};
	for (const Pt& q : qq)
	{
		if (!s1.contains(q) || !s2.contains(q))
			continue;
		db phi = atan2(q.y - s1.c.y, q.x - s1.c.x);
		while (sgn(s1.s - phi) > 0)
			phi += 2 * PI;
		assert(sgn(s1.s - phi) <= 0 && sgn(phi - (s1.s + s1.theta)) <= 0);
		res.PB(phi);
	}
	if (sgn(abs(s2.c - s1.c)) == 0 && sgn(s2.r - s1.r) == 0)
	{
		for (db phi : {s2.s - 2 * PI, s2.s + s2.theta - 2 * PI})
		{
			while (sgn(s1.s - phi) > 0)
				phi += 2 * PI;
			assert(sgn(s1.s - phi) <= 0);
			if (sgn(phi - (s1.s + s1.theta)) <= 0)
				res.PB(phi);
		}
	}
	sort(ALL(res));
	return res;
}

vector<pair<Pt, Pt>> getUsefulOnSeg(const Sector& s2, const vector<Pt>& v, int i, int j, const Pt& p)
{
	vector<pair<Pt, Pt>> res;
	FOR(k, 0, SZ(v) - 1)
	{
		Pt midPoint = (v[k] + v[k + 1]) / 2;
		if (!s2.contains(midPoint) || (j < i && onSegment(s2.c, p, midPoint)))
			res.PB({v[k], v[k + 1]});
	}
	return res;
}

vector<pair<db, db>> getUsefulOnArc(const Sector& s1, const Sector& s2, int i, int j)
{
	const auto& v = getPhisOnArc(s1, s2);
	vector<pair<db, db>> res;
	FOR(k, 0, SZ(v) - 1)
	{
		db phi = (v[k] + v[k + 1]) / 2;
		const Pt& p = {s1.c.x + s1.r * cos(phi), s1.c.y + s1.r * sin(phi)};
		if (!s2.contains(p) || (j < i && sgn(abs(s2.c - s1.c)) == 0 && sgn(s2.r - s1.r) == 0))
			res.PB({v[k], v[k + 1]});
	}
	return res;
}
int n;

void solve()
{
	vector<Sector> sectors(n);
	vector<vector<Pt>> p(n, vector<Pt>(2));
	FOR(i, 0, n)
	{
		Sector& sector = sectors[i];
		sector.read();
		FOR(j, 0, 2)
		{
			db phi = sector.s + j * sector.theta;
			p[i][j] = {sector.c.x + sector.r * cos(phi), sector.c.y + sector.r * sin(phi)};
			sector.l[j] = {sector.c, p[i][j]};
		}
	}
	db ans = 0;
	FOR(i, 0, n)
	{
		vector<pair<Pt, int>> eventsSeg[2] = {
			{{sectors[i].c, 1}, {p[i][0], -1}},
			{{sectors[i].c, 1}, {p[i][1], -1}}};
		vector<pair<db, int>> eventsArc = {{sectors[i].s, 1}, {sectors[i].s + sectors[i].theta, -1}};
		FOR(j, 0, n)
		{
			if (i == j)
				continue;
			FOR(ii, 0, 2)
			{
				auto ptsOnSeg = getPtsOnSeg(sectors[i].c, p[i][ii], sectors[j]);
				auto usefulOnSeg = getUsefulOnSeg(sectors[j], ptsOnSeg, i, j, p[j][ii]);
				for (const auto& [p1, p2] : usefulOnSeg)
				{
					eventsSeg[ii].PB({p1, 1});
					eventsSeg[ii].PB({p2, -1});
				}
			}
			auto usefulOnArc = getUsefulOnArc(sectors[i], sectors[j], i, j);
			for (auto [phi1, phi2] : usefulOnArc)
			{
				eventsArc.PB({phi1, 1});
				eventsArc.PB({phi2, -1});
			}
		}
		FOR(ii, 0, 2)
		{
			sort(ALL(eventsSeg[ii]), [&](const pair<Pt, int>& p1, const pair<Pt, int>& p2)
			{
				return sgn(abs(p1.F - sectors[i].c) - abs(p2.F - sectors[i].c)) < 0;
			});
			int bal = 0;
			db sum = 0;
			FOR(k, 0, SZ(eventsSeg[ii]))
			{
				bal += eventsSeg[ii][k].S;
				if (bal == n)
				{
					sum += cross(eventsSeg[ii][k].F, eventsSeg[ii][k + 1].F);
				}
			}
			ans += (ii == 0 ? 1 : -1) * sum;
		}
		sort(ALL(eventsArc));
		int bal = 0;
		FOR(k, 0, SZ(eventsArc))
		{
			bal += eventsArc[k].S;
			if (bal == n)
			{
				db phi1 = eventsArc[k].F, phi2 = eventsArc[k + 1].F;
				ans += sectors[i].r * (sectors[i].c.x * (sin(phi2) - sin(phi1))
					- sectors[i].c.y * (cos(phi2) - cos(phi1))
					+ sectors[i].r * (phi2 - phi1));
			}
		}
	}
	ans /= 2;
	cout << ans << "\n";
}

int main()
{
	ios::sync_with_stdio(0); 
	cin.tie(0);
	cout << fixed << setprecision(10);
	while (cin >> n)
	{
		solve();
	}
	return 0;
}