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

typedef long long LL;
typedef long double LD;
typedef pair < int, int > PII;
typedef pair < LL, LL > PLL;

#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()

#define cerr if(0)cerr

struct point {
	LD x, y;
};

point operator+(point a, point b) {
	return point {a.x + b.x, a.y + b.y};
}

point operator-(point a, point b) {
	return point {a.x - b.x, a.y - b.y};
}

point operator*(point a, LD b) {
	return point {a.x * b, a.y * b};
}

LD vecp(point a, point b)
{
	return a.x * b.y - a.y * b.x;
}

LD scap(point a, point b) {
	return a.x * b.x + a.y * b.y;
}

const LD C_PI = acosl(-1.0);

int a, b, r, a1, b1, a2, b2, in[4];

namespace Anadi{
	point origin = {0, 0};
	bool cmp(const point &a, const point &b){
		bool fa = (a.x > origin.x || (a.x == origin.x && a.y > origin.y));
		bool fb = (b.x > origin.x || (b.x == origin.x && b.y > origin.y));
		
		if(fa == fb)
			return a.x * b.y - a.y * b.x > 0.0;
		return fa;
	}
	
	vector <point> Sort(vector <point> in){
		origin.x = origin.y = 0.0;
		for(auto v: in)
			origin.x += v.x, origin.y += v.y;

		origin.x /= in.size();
		origin.y /= in.size();
		
		sort(in.begin(), in.end(), cmp);
		return in;
	}
}

vector < point > vec;

bool check(int x, int y)
{
	return (x - a) * (x - a) + (y - b) * (y - b) <= r * r;
}

const LD eps = 1e-12;

void calcX(LD x, LD y1, LD y2)
{
	LD val = r * r - x * x;
	if(val < 0) return;
	val = sqrtl(val);
	LD e1 = -val, e2 = val;
	if(y1 + eps < e1 && e1 + eps < y2)
	{
		vec.push_back({x, e1});
	}
	if(e1 + eps < e2 && y1 + eps < e2 && e2 + eps < y2)
	{
		vec.push_back({x, e2});
	}
}

void calcY(LD y, LD x1, LD x2)
{
	LD val = r * r - y * y;
	if(val < 0) return;
	val = sqrtl(val);
	LD e1 = -val, e2 = val;
	if(x1 + eps < e1 && e1 + eps < x2)
	{
		vec.push_back({e1, y});
	}
	if(e1 + eps < e2 && x1 + eps < e2 && e2 + eps < x2)
	{
		vec.push_back({e2, y});
	}
}

point rot90(point v)
{
	return point{v.y, -v.x};
}

bool in_rect(point v)
{
	return a1 < v.x && v.x < a2 && b1 < v.y && v.y < b2;
}

LD inter(point a, point b)
{
	if(vecp(a, b) > 0)
	{
		return (LD)r * (LD)r * 0.5 * acosl(scap(a, b) / (LD)r / (LD)r); 
	}
	else
	{
		return C_PI * (LD)r * (LD)r - (LD)r * (LD)r * 0.5 * acosl(scap(a, b) / (LD)r / (LD)r);
	}
}

LD sgn(LD x)
{
	if(x > eps)
		return 1.0;
	if(x < -eps)
		return -1.0;
	return 0;
}

int main()
{
	ios_base::sync_with_stdio(0); cin.tie(0);

	cin >> a >> b >> r >> a1 >> b1 >> a2 >> b2;
	
	if(a1 > a2)
		swap(a1, a2);
	if(b1 > b2)
		swap(b1, b2);
	
	in[0] = check(a1, b1);
	in[1] = check(a2, b1);
	in[2] = check(a2, b2);
	in[3] = check(a1, b2);

	a1 -= a;
	a2 -= a;
	b1 -= b;
	b2 -= b;
	a = b = 0;

	vector < point > vv = {{a1, b1}, {a2, b1}, {a2, b2}, {a1, b2}};
	
	for(int i = 0; i < 4; i++)
		if(in[i]) vec.push_back(vv[i]);
	
	calcX(a1, b1, b2);
	calcX(a2, b1, b2);
	calcY(b1, a1, a2);
	calcY(b2, a1, a2);
	
	if(sz(vec) == 0)
	{
		cout << fixed << setprecision(10) << 0 << "\n";
		return 0;
	}
	
	vec = Anadi::Sort(vec);

	for(auto p: vec)
		cerr << p.x << " " << p.y << "\n";
	
	LD ans = 0;
	vec.push_back(vec[0]);
	for(int i = 0; i + 1 < sz(vec); i++)
	{
		point a = vec[i], b = vec[i + 1];
		point v = b - a;
		point u = a + (v * 0.5) + (rot90(v) * eps);
		if(in_rect(u))
		{
			cerr << "Kolo\n";
			LD mul = sgn(vecp(a, b));
			if(mul == 0)
			{
				mul = 1;
			}
			ans += inter(a, b) * mul;
		}
		else
		{
			cerr << "Prostoakt\n";
			ans += vecp(a, b) * 0.5;
		}
	}	
	cout << fixed << setprecision(10) << ans + 5e-5 << "\n";

	return 0;
}