#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>

using namespace std;

#define all(v) v.begin(), v.end()
typedef long long ll;
typedef long double ld;
const int NMAX = 1005;
const int b = 1 << 18;
int dx[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
int dy[8] = {1, 0, -1, -1, -1, 0, 1, 1};
int ddx[4] = {0, 1, 0, 1};
int ddy[4] = {0, 0, 1, 1};
set<pair<int, int>> B;
int n, x[NMAX], y[NMAX], w[NMAX], h[NMAX];
ll Black, Gray, mn, mx;
vector<pair<int, int>> W;
vector<pair<ll, ll>> arr, V;
vector<ll> tmp;
int seg[b * 2];

void upd(int ix, int v){
	ix += b;
	while(ix){
		seg[ix] += v;
		ix >>= 1;
	}
	return;
}

int sum(int l, int r){
	l += b; r += b;
	int ret = 0;
	while(l <= r){
		if(l & 1) ret += seg[l++];
		if(!(r & 1)) ret += seg[r--];
		l >>= 1; r >>= 1;
	}
	return ret;
}

void calc(ll i, ll j){
	mn = 6e18; mx = -6e18;
	for(int k = 0; k < 4; k++){
		ll y = i + ddy[k];
		ll x = j + ddx[k];
		mx = max(mx, y * y + x * x);
		mn = min(mn, y * y + x * x);
	}
	arr.emplace_back(mn, mx);
	return;
}

int main(void){
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cout << fixed; cout.precision(10);
	cin >> n;
	for(int j = 0; j < n; j++){
		cin >> x[j] >> y[j] >> w[j] >> h[j];
		for(int i = y[j]; i < y[j] + h[j]; i++){
			B.emplace(i, x[j]);
			B.emplace(i, x[j] + w[j] - 1);
		}
		for(int i = x[j]; i < x[j] + w[j]; i++){
			B.emplace(y[j], i);
			B.emplace(y[j] + h[j] - 1, i);
		}
	}
	for(auto& [y, x] : B) {
		calc(y, x);
		for(int k = 0; k < 8; k++){
			int ny = y + dy[k];
			int nx = x + dx[k];
			if(B.find({ny, nx}) == B.end()) W.emplace_back(nx, ny);
		}
	}
	sort(all(arr));
	swap(arr, V);
	
	sort(all(W));
	W.erase(unique(all(W)), W.end());
	for(auto& [x, y] : W) tmp.emplace_back(y);
	sort(all(tmp));
	tmp.erase(unique(all(tmp)),tmp.end());
	assert(tmp.size() <= b);

	vector<tuple<int, int, int>> P;
	for(int i = 0; i < n; i++) {
		int d = lower_bound(all(tmp), y[i]) - tmp.begin();
		int u = lower_bound(all(tmp), y[i] + h[i]) - tmp.begin();
		if(d == u) continue;

		assert(u < tmp.size());
		P.emplace_back(x[i], d, 1);
		P.emplace_back(x[i], u, -1);
		P.emplace_back(x[i] + w[i], d, -1);
		P.emplace_back(x[i] + w[i], u, 1);
	}

	sort(all(P));
	int ix = 0;
	for(auto&[x, y] : W){
		int Y = lower_bound(all(tmp), y) - tmp.begin();
		while(ix < P.size()){
			auto&[xx, yy, v] = P[ix];
			if(xx > x) break;
			upd(yy, v);
			ix++;
		}
		if(!sum(0, Y)) calc(y, x);
	}

	sort(all(arr));
	ll e = 0, ee = 0;
	ix = 0;
	for(auto& [l, r] : V){
		if(r <= e) continue;
		l = max(l, e);
		Gray += r - l;
		while(ix < arr.size() && arr[ix].first <= l) ee = max(ee, arr[ix++].second);
		ee = max(ee, l);
		while(ix < arr.size() && arr[ix].first <= r){
			auto&[ll, rr] = arr[ix++];
			if(ee < ll) Black += ll - ee;
			ee = max(ee, rr);
		}
		if(!ix) Black += r - e, Gray += l - e;
		else if(ee < r) Black += r - ee;
		e = r;
	}
	cout << Black * acos(-1) << '\n';
	cout << (Gray - Black) * acos(-1) << '\n';
	return 0;
}