//
//  main.cpp
//  SnowBlower
//
//  Created by Apple on 5/31/16.
//  Copyright © 2016 AMOSC. All rights reserved.
//

#include <iostream>
#include <cmath>

using namespace std;

long n;
double ax[100001],ay[100001];
double px,py;
const double pi=3.141592653589793238462643383279502884;

void readFile(){
    scanf("%ld%lf%lf",&n,&px,&py);
    for (int i=1; i<=n; i++){
        scanf("%lf%lf",&ax[i],&ay[i]);
    }

}
double distancetoPoint(long i){
    return (ax[i]-px)*(ax[i]-px) + (ay[i]-py)*(ay[i]-py);
}
void handleData(){
    double minD = 1e13;

    double maxD =0;
    double value;
    for (int i=1; i<=n; i++){
        value = distancetoPoint(i);

        if (minD>value) minD = value;
        if (value>maxD) maxD = value;
    }
    double result  = (maxD-minD)*pi;
    printf("%2.9f",result);

}
int main(int argc, const char * argv[]) {
    // insert code here...
    readFile();
    handleData();
    return 0;
}


#include <iostream>
#include <iomanip>
#include <cstdio>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <string>
#include <ctime>
#include <cassert>
#include <algorithm>
#include <cmath>

//#include <unordered_set>
//#include <unordered_map>

#define forn(i, n) for (int i = 0; i < int(n); i++)
#define for1(i, n) for (int i = 1; i < int(n); i++)
#define forft(i, from, to) for (int i = int(from); i < int(to); i++)
#define forr(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define X first
#define Y second
#define mp make_pair
#define pb push_back
#define sz(a) int(a.size())
#define all(a) a.begin(), a.end()
#define ms(a, v) memset(a, v, sizeof(a))
#define correct(x, y, n, m) (x >= 0 && x < n && y >= 0 && y < m)

using namespace std;

template<typename T> T sqr(const T &x) {
	return x * x;
}

typedef long long ll;
typedef long long li;
typedef pair<int, int> pt;
typedef long double ld;
typedef pair<ld, ld> pd;

const int INF = int(1e9);
const ll INF_LL = ll(4e18);
const ll INF64 = ll(4e18);
const ll LINF = ll(4e18);
const ld EPS = 1e-8;
const ld PI = 3.14159265358979323846264338;

int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};

const int N = 1e5 + 10;
const int M = 1e6 + 10;
const li MOD = li(1e9) + 7;

int n;
pd a[N];

ld dist(pd a, pd b) {
	return sqrt(sqr(a.X - b.X) + sqr(a.Y - b.Y));
}

pd operator + (pd a, pd b) {
	return mp(a.X + b.X, a.Y + b.Y);
}

pd operator - (pd a, pd b) {
	return mp(a.X - b.X, a.Y - b.Y);
}

ld operator *(pd a, pd b) {
	return a.X * b.X + a.Y * b.Y;
}

pd operator *(pd a, ld k) {
	return mp(a.X * k, a.Y * k);
}

void solve() {
	pd x;
	cin >> n >> x.X >> x.Y;

	forn(i, n) {
		int x, y;
		scanf("%d %d", &x, &y);
		a[i] = mp(x, y);
	}

	ld mini = INF_LL, maxi = -INF_LL;

	forn(i, n) {
		pd f = a[i], s = a[(i + 1) % n];

		ld now_min = min(dist(s, x), dist(f, x));
		maxi = max(maxi, max(dist(s, x), dist(f, x)));

		ld A = f.Y - s.Y;
		ld B = s.X - f.X;
		ld C = -A * f.X - B * f.Y;

		ld d = abs(A * x.X + B * x.Y + C) / sqrt(sqr(A) + sqr(B));
		ld k  = (d / sqrt(sqr(A) + sqr(B)));
		pd v = mp(A, B);
		pd add = v * k;
		pd p = x + add;

		if (abs(A * p.X + B * p.Y + C) > EPS) {
			p = x - add;
		}
		pd ff = f - p;
		pd ss = s - p;

		if (ff * ss < EPS) {
			now_min = min(now_min, d);
		}

		mini = min(mini, now_min);
	}

	cout << PI * sqr(maxi) - PI * sqr(mini) << endl;
}

int main() {
	//freopen("input.txt", "rt", stdin);
	//freopen("output.txt", "wt", stdout);

	srand((int) time(NULL));
	cout << setprecision(10) << fixed;

	solve();
	return 0;
}


#include <iostream>
#include <iomanip>
#include <cstdio>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <string>
#include <ctime>
#include <cassert>
#include <algorithm>
#include <cmath>

//#include <unordered_set>
//#include <unordered_map>

#define forn(i, n) for (int i = 0; i < int(n); i++)
#define for1(i, n) for (int i = 1; i < int(n); i++)
#define forft(i, from, to) for (int i = int(from); i < int(to); i++)
#define forr(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define X first
#define Y second
#define mp make_pair
#define pb push_back
#define sz(a) int(a.size())
#define all(a) a.begin(), a.end()
#define ms(a, v) memset(a, v, sizeof(a))
#define correct(x, y, n, m) (x >= 0 && x < n && y >= 0 && y < m)

using namespace std;

template<typename T> T sqr(const T &x) {
	return x * x;
}

typedef long long ll;
typedef long long li;
typedef pair<int, int> pt;
typedef long double ld;
typedef pair<ld, ld> pd;

const int INF = int(1e9);
const ll INF_LL = ll(4e18);
const ll INF64 = ll(4e18);
const ll LINF = ll(4e18);
const ld EPS = 1e-7;
const ld PI = 3.14159265358979323846264338;

int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};

const int N = 1e5 + 10;
const int M = 1e6 + 10;
const li MOD = li(1e9) + 7;

int n;
pd a[N];

ld dist(pd a, pd b) {
	return sqr(a.X - b.X) + sqr(a.Y - b.Y);
}

pd operator + (pd a, pd b) {
	return mp(a.X + b.X, a.Y + b.Y);
}

pd operator - (pd a, pd b) {
	return mp(a.X - b.X, a.Y - b.Y);
}

pd operator *(pd a, ld k) {
	return mp(a.X * k, a.Y * k);
}

ld operator *(pd a, pd b) {
	return a.X * b.X + a.Y * b.Y;
}

void solve() {
	pd x;
	cin >> n >> x.X >> x.Y;

	forn(i, n) {
		int x, y;
		scanf("%d %d", &x, &y);
		a[i] = mp(x, y);
	}

	ld mini = INF_LL, maxi = -INF_LL;

	forn(i, n) {
		pd f = a[i], s = a[(i + 1) % n];

		ld now_min = min(dist(s, x), dist(f, x));
		maxi = max(maxi, max(dist(s, x), dist(f, x)));

		ld A = f.Y - s.Y;
		ld B = s.X - f.X;
		ld C = -A * f.X - B * f.Y;

		ld d = (A * x.X + B * x.Y + C) / sqrt(sqr(A) + sqr(B));
		ld k  = (d / sqrt(sqr(A) + sqr(B)));
		pd v = mp(A, B);
		pd add = v * k;
		pd p = x - add;

		pd ff = p - f;
		pd ss = p - s;

		if (ff * ss < EPS) {
			ld nd = (A * x.X + B * x.Y + C) / (sqr(A) + sqr(B)) * (A * x.X + B * x.Y + C);
			now_min = min(now_min, abs(d));
		}

		mini = min(mini, now_min);
	}

	cout << PI * (maxi - mini) << endl;
}

int main() {
	//freopen("input.txt", "rt", stdin);
	//freopen("output.txt", "wt", stdout);

	srand((int) time(NULL));
	cout << setprecision(10) << fixed;

	solve();
	return 0;
}


#include <iostream>
#include <iomanip>
#include <cstdio>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <string>
#include <ctime>
#include <cassert>
#include <algorithm>
#include <cmath>

//#include <unordered_set>
//#include <unordered_map>

#define forn(i, n) for (int i = 0; i < int(n); i++)
#define for1(i, n) for (int i = 1; i < int(n); i++)
#define forft(i, from, to) for (int i = int(from); i < int(to); i++)
#define forr(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define X first
#define Y second
#define mp make_pair
#define pb push_back
#define sz(a) int(a.size())
#define all(a) a.begin(), a.end()
#define ms(a, v) memset(a, v, sizeof(a))
#define correct(x, y, n, m) (x >= 0 && x < n && y >= 0 && y < m)

using namespace std;

template<typename T> T sqr(const T &x) {
	return x * x;
}

typedef long long ll;
typedef long long li;
typedef pair<int, int> pt;
typedef long double ld;
typedef pair<ld, ld> pd;

const int INF = int(1e9);
const ll INF_LL = ll(4e18);
const ll INF64 = ll(4e18);
const ll LINF = ll(4e18);
const ld EPS = 1e-7;
const ld PI = 3.14159265358979323846264338;

int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};

const int N = 1e5 + 10;
const int M = 1e6 + 10;
const li MOD = li(1e9) + 7;

int n;
pd a[N];

ld dist(pd a, pd b) {
	return sqrt(sqr(a.X - b.X) + sqr(a.Y - b.Y));
}

pd operator + (pd a, pd b) {
	return mp(a.X + b.X, a.Y + b.Y);
}

pd operator - (pd a, pd b) {
	return mp(a.X - b.X, a.Y - b.Y);
}

pd operator *(pd a, ld k) {
	return mp(a.X * k, a.Y * k);
}

ld operator *(pd a, pd b) {
	return a.X * b.X + a.Y * b.Y;
}

void solve() {
	pd x;
	cin >> n >> x.X >> x.Y;

	forn(i, n) {
		int x, y;
		scanf("%d %d", &x, &y);
		a[i] = mp(x, y);
	}

	ld mini = INF_LL, maxi = -INF_LL;

	forn(i, n) {
		pd f = a[i], s = a[(i + 1) % n];

		ld now_min = min(dist(s, x), dist(f, x));
		maxi = max(maxi, max(dist(s, x), dist(f, x)));

		ld A = f.Y - s.Y;
		ld B = s.X - f.X;
		ld C = -A * f.X - B * f.Y;

		ld d = (A * x.X - B * x.Y + C) / sqrt(sqr(A) + sqr(B));
		ld k  = (d / sqrt(sqr(A) + sqr(B)));
		pd v = mp(A, B);
		pd add = v * k;
		pd p = x - add;

		pd ff = p - f;
		pd ss = p - s;

		if (ff * ss < EPS) {
			now_min = min(now_min, abs(d));
		}

		mini = min(mini, now_min);
	}

	cout << PI * (sqr(maxi) - sqr(mini)) << endl;
}

int main() {
	//freopen("input.txt", "rt", stdin);
	//freopen("output.txt", "wt", stdout);

	srand((int) time(NULL));
	cout << setprecision(10) << fixed;

	solve();
	return 0;
}


#include <iostream>
#include <iomanip>
#include <cstdio>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <string>
#include <ctime>
#include <cassert>
#include <algorithm>
#include <cmath>

//#include <unordered_set>
//#include <unordered_map>

#define forn(i, n) for (int i = 0; i < int(n); i++)
#define for1(i, n) for (int i = 1; i < int(n); i++)
#define forft(i, from, to) for (int i = int(from); i < int(to); i++)
#define forr(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define X first
#define Y second
#define mp make_pair
#define pb push_back
#define sz(a) int(a.size())
#define all(a) a.begin(), a.end()
#define ms(a, v) memset(a, v, sizeof(a))
#define correct(x, y, n, m) (x >= 0 && x < n && y >= 0 && y < m)

using namespace std;

template<typename T> T sqr(const T &x) {
	return x * x;
}

typedef long long ll;
typedef long long li;
typedef pair<int, int> pt;
typedef long double ld;
typedef pair<ld, ld> pd;

const int INF = int(1e9);
const ll INF_LL = ll(4e18);
const ll INF64 = ll(4e18);
const ll LINF = ll(4e18);
const ld EPS = 1e-8;
const ld PI = 3.14159265358979323846264338;

int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};

const int N = 1e5 + 10;
const int M = 1e6 + 10;
const li MOD = li(1e9) + 7;

int n;
pd a[N];

ld dist(pd a, pd b) {
	return sqrt(sqr(a.X - b.X) + sqr(a.Y - b.Y));
}

pd operator + (pd a, pd b) {
	return mp(a.X + b.X, a.Y + b.Y);
}

pd operator - (pd a, pd b) {
	return mp(a.X - b.X, a.Y - b.Y);
}

ld operator *(pd a, pd b) {
	return a.X * b.X + a.Y * b.Y;
}

pd operator *(pd a, ld k) {
	return mp(a.X * k, a.Y * k);
}

void solve() {
	pd x;
	cin >> n >> x.X >> x.Y;

	forn(i, n) {
		int x, y;
		scanf("%d %d", &x, &y);
		a[i] = mp(x, y);
	}

	ld mini = INF_LL, maxi = -INF_LL;

	forn(i, n) {
		pd f = a[i], s = a[(i + 1) % n];

		ld now_min = min(dist(s, x), dist(f, x));
		maxi = max(maxi, max(dist(s, x), dist(f, x)));

		ld A = f.Y - s.Y;
		ld B = s.X - f.X;
		ld C = -A * f.X - B * f.Y;

		ld d = (A * x.X + B * x.Y + C) / sqrt(sqr(A) + sqr(B));
		ld k  = (d / sqrt(sqr(A) + sqr(B)));
		pd v = mp(A, B);
		pd add = v * k;
		pd p = x - add;

		pd ff = f - p;
		pd ss = s - p;

		if (ff * ss < EPS) {
			now_min = min(now_min, abs(d));
		}

		mini = min(mini, now_min);
	}

	cout << PI * sqr(maxi) - PI * sqr(mini) << endl;
}

int main() {
	//freopen("input.txt", "rt", stdin);
	//freopen("output.txt", "wt", stdout);

	srand((int) time(NULL));
	cout << setprecision(10) << fixed;

	solve();
	return 0;
}


#include <iostream>
#include <iomanip>
#include <cstdio>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <string>
#include <ctime>
#include <cassert>
#include <algorithm>
#include <cmath>

//#include <unordered_set>
//#include <unordered_map>

#define forn(i, n) for (int i = 0; i < int(n); i++)
#define for1(i, n) for (int i = 1; i < int(n); i++)
#define forft(i, from, to) for (int i = int(from); i < int(to); i++)
#define forr(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define X first
#define Y second
#define mp make_pair
#define pb push_back
#define sz(a) int(a.size())
#define all(a) a.begin(), a.end()
#define ms(a, v) memset(a, v, sizeof(a))
#define correct(x, y, n, m) (x >= 0 && x < n && y >= 0 && y < m)

using namespace std;

template<typename T> T sqr(const T &x) {
	return x * x;
}

typedef long long ll;
typedef long long li;
typedef pair<int, int> pt;
typedef long double ld;
typedef pair<ld, ld> pd;

const int INF = int(1e9);
const ll INF_LL = ll(4e18);
const ll INF64 = ll(4e18);
const ll LINF = ll(4e18);
const ld EPS = 1e-7;
const ld PI = 3.14159265358979323846264338;

int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};

const int N = 1e5 + 10;
const int M = 1e6 + 10;
const li MOD = li(1e9) + 7;

int n;
pd a[N];

ld dist(pd a, pd b) {
	return sqr(a.X - b.X) + sqr(a.Y - b.Y);
}

pd operator + (pd a, pd b) {
	return mp(a.X + b.X, a.Y + b.Y);
}

pd operator - (pd a, pd b) {
	return mp(a.X - b.X, a.Y - b.Y);
}

pd operator *(pd a, ld k) {
	return mp(a.X * k, a.Y * k);
}

ld operator *(pd a, pd b) {
	return a.X * b.X + a.Y * b.Y;
}

void solve() {
	pd x;
	cin >> n >> x.X >> x.Y;

	forn(i, n) {
		int x, y;
		scanf("%d %d", &x, &y);
		a[i] = mp(x, y);
	}

	ld mini = INF_LL, maxi = -INF_LL;

	forn(i, n) {
		pd f = a[i], s = a[(i + 1) % n];

		ld now_min = min(dist(s, x), dist(f, x));
		maxi = max(maxi, max(dist(s, x), dist(f, x)));

		ld A = f.Y - s.Y;
		ld B = s.X - f.X;
		ld C = -A * f.X - B * f.Y;

		ld d = (A * x.X + B * x.Y + C) / sqrt(sqr(A) + sqr(B));
		ld k  = (d / sqrt(sqr(A) + sqr(B)));
		pd v = mp(A, B);
		pd add = v * k;
		pd p = x + add;

		if (abs(A * p.X + B * p.Y + C) > EPS) {
			p = x - add;
		}

		if (abs(dist(s, p) + dist(f, p) - dist(s, f)) < EPS) {
			now_min = min(now_min, sqr(d));
		}

		mini = min(mini, now_min);
	}

	cout << PI * (maxi - mini) << endl;
}

int main() {
	//freopen("input.txt", "rt", stdin);
	//freopen("output.txt", "wt", stdout);

	srand((int) time(NULL));
	cout << setprecision(10) << fixed;

	solve();
	return 0;
}


#include <iostream>
#include <iomanip>
#include <cstdio>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <string>
#include <ctime>
#include <cassert>
#include <algorithm>
#include <cmath>

//#include <unordered_set>
//#include <unordered_map>

#define forn(i, n) for (int i = 0; i < int(n); i++)
#define for1(i, n) for (int i = 1; i < int(n); i++)
#define forft(i, from, to) for (int i = int(from); i < int(to); i++)
#define forr(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define X first
#define Y second
#define mp make_pair
#define pb push_back
#define sz(a) int(a.size())
#define all(a) a.begin(), a.end()
#define ms(a, v) memset(a, v, sizeof(a))
#define correct(x, y, n, m) (x >= 0 && x < n && y >= 0 && y < m)

using namespace std;

template<typename T> T sqr(const T &x) {
	return x * x;
}

typedef long long ll;
typedef long long li;
typedef pair<int, int> pt;
typedef long double ld;
typedef pair<ld, ld> pd;

const int INF = int(1e9);
const ll INF_LL = ll(4e18);
const ll INF64 = ll(4e18);
const ll LINF = ll(4e18);
const ld EPS = 1e-8;
const ld PI = 3.14159265358979323846264338;

int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};

const int N = 1e5 + 10;
const int M = 1e6 + 10;
const li MOD = li(1e9) + 7;

int n;
pd a[N];

ld dist(pd a, pd b) {
	return sqrt(sqr(a.X - b.X) + sqr(a.Y - b.Y));
}

pd operator + (pd a, pd b) {
	return mp(a.X + b.X, a.Y + b.Y);
}

pd operator - (pd a, pd b) {
	return mp(a.X - b.X, a.Y - b.Y);
}

pd operator *(pd a, ld k) {
	return mp(a.X * k, a.Y * k);
}

void solve() {
	pd x;
	cin >> n >> x.X >> x.Y;

	forn(i, n) {
		int x, y;
		scanf("%d %d", &x, &y);
		a[i] = mp(x, y);
	}

	ld mini = INF_LL, maxi = -INF_LL;

	forn(i, n) {
		pd f = a[i], s = a[(i + 1) % n];

		ld now_min = min(dist(s, x), dist(f, x));
		maxi = max(maxi, max(dist(s, x), dist(f, x)));

		ld A = f.Y - s.Y;
		ld B = s.X - f.X;
		ld C = -A * f.X - B * f.Y;

		ld d = abs(A * x.X + B * x.Y + C) / sqrt(sqr(A) + sqr(B));
		ld k  = (d / sqrt(sqr(A) + sqr(B)));
		pd v = mp(A, B);
		pd add = v * k;
		pd p = x + add;

		if (abs(A * p.X + B * p.Y + C) > EPS) {
			p = x - add;
		}

		if (abs(dist(s, p) + dist(f, p) - dist(s, f)) < EPS) {
			now_min = min(now_min, d);
		}

		mini = min(mini, now_min);
	}

	cout << PI * sqr(maxi) - PI * sqr(mini) << endl;
}

int main() {
	//freopen("input.txt", "rt", stdin);
	//freopen("output.txt", "wt", stdout);

	srand((int) time(NULL));
	cout << setprecision(10) << fixed;

	solve();
	return 0;
}


#include <iostream>
#include <iomanip>
#include <cstdio>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <string>
#include <ctime>
#include <cassert>
#include <algorithm>
#include <cmath>

//#include <unordered_set>
//#include <unordered_map>

#define forn(i, n) for (int i = 0; i < int(n); i++)
#define for1(i, n) for (int i = 1; i < int(n); i++)
#define forft(i, from, to) for (int i = int(from); i < int(to); i++)
#define forr(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define X first
#define Y second
#define mp make_pair
#define pb push_back
#define sz(a) int(a.size())
#define all(a) a.begin(), a.end()
#define ms(a, v) memset(a, v, sizeof(a))
#define correct(x, y, n, m) (x >= 0 && x < n && y >= 0 && y < m)

using namespace std;

template<typename T> T sqr(const T &x) {
	return x * x;
}

typedef long long ll;
typedef long long li;
typedef pair<int, int> pt;
typedef long double ld;
typedef pair<ld, ld> pd;

const int INF = int(1e9);
const ll INF_LL = ll(4e18);
const ll INF64 = ll(4e18);
const ll LINF = ll(4e18);
const ld EPS = 1e-7;
const ld PI = 3.14159265358979323846264338;

int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};

const int N = 1e5 + 10;
const int M = 1e6 + 10;
const li MOD = li(1e9) + 7;

int n;
pd a[N];

ld dist(pd a, pd b) {
	return sqrt(sqr(a.X - b.X) + sqr(a.Y - b.Y));
}

pd operator + (pd a, pd b) {
	return mp(a.X + b.X, a.Y + b.Y);
}

pd operator - (pd a, pd b) {
	return mp(a.X - b.X, a.Y - b.Y);
}

pd operator *(pd a, ld k) {
	return mp(a.X * k, a.Y * k);
}

ld operator *(pd a, pd b) {
	return a.X * b.X + a.Y * b.Y;
}

void solve() {
	pd x;
	cin >> n >> x.X >> x.Y;

	forn(i, n) {
		int x, y;
		scanf("%d %d", &x, &y);
		a[i] = mp(x, y);
	}

	ld mini = INF_LL, maxi = -INF_LL;

	forn(i, n) {
		pd f = a[i], s = a[(i + 1) % n];

		ld now_min = min(dist(s, x), dist(f, x));
		maxi = max(maxi, max(dist(s, x), dist(f, x)));

		ld A = f.Y - s.Y;
		ld B = s.X - f.X;
		ld C = -A * f.X - B * f.Y;

		ld d = abs(A * x.X - B * x.Y + C) / sqrt(sqr(A) + sqr(B));
		ld k  = (d / sqrt(sqr(A) + sqr(B)));
		pd v = mp(A, B);
		pd add = v * k;
		pd p = x + add;

		if (abs(A * p.X + B * p.Y + C) > EPS) {
			p = x - add;
		}

		pd ff = p - f;
		pd ss = p - s;

		if (ff * ss < EPS) {
			now_min = min(now_min, d);
		}

		mini = min(mini, now_min);
	}

	cout << PI * (sqr(maxi) - sqr(mini)) << endl;
}

int main() {
	//freopen("input.txt", "rt", stdin);
	//freopen("output.txt", "wt", stdout);

	srand((int) time(NULL));
	cout << setprecision(10) << fixed;

	solve();
	return 0;
}


#include <iostream>
#include <iomanip>
#include <cstdio>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <string>
#include <ctime>
#include <cassert>
#include <algorithm>
#include <cmath>

//#include <unordered_set>
//#include <unordered_map>

#define forn(i, n) for (int i = 0; i < int(n); i++)
#define for1(i, n) for (int i = 1; i < int(n); i++)
#define forft(i, from, to) for (int i = int(from); i < int(to); i++)
#define forr(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define X first
#define Y second
#define mp make_pair
#define pb push_back
#define sz(a) int(a.size())
#define all(a) a.begin(), a.end()
#define ms(a, v) memset(a, v, sizeof(a))
#define correct(x, y, n, m) (x >= 0 && x < n && y >= 0 && y < m)

using namespace std;

template<typename T> T sqr(const T &x) {
	return x * x;
}

typedef long long ll;
typedef long long li;
typedef pair<int, int> pt;
typedef long double ld;
typedef pair<ld, ld> pd;

const int INF = int(1e9);
const ll INF_LL = ll(4e18);
const ll INF64 = ll(4e18);
const ll LINF = ll(4e18);
const ld EPS = 1e-8;
const ld PI = 3.14159265358979323846264338;

int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};

const int N = 1e5 + 10;
const int M = 1e6 + 10;
const li MOD = li(1e9) + 7;

int n;
pd a[N];

ld dist(pd a, pd b) {
	return sqrt(sqr(a.X - b.X) + sqr(a.Y - b.Y));
}

pd operator + (pd a, pd b) {
	return mp(a.X + b.X, a.Y + b.Y);
}

pd operator - (pd a, pd b) {
	return mp(a.X - b.X, a.Y - b.Y);
}

pd operator *(pd a, ld k) {
	return mp(a.X * k, a.Y * k);
}

void solve() {
	pd x;
	cin >> n >> x.X >> x.Y;

	forn(i, n) {
		int x, y;
		scanf("%d %d", &x, &y);
		a[i] = mp(x, y);
	}

	ld mini = INF_LL, maxi = -INF_LL;

	forn(i, n) {
		pd f = a[i], s = a[(i + 1) % n];

		ld now_min = min(dist(s, x), dist(f, x));
		maxi = max(maxi, max(dist(s, x), dist(f, x)));

		ld A = f.Y - s.Y;
		ld B = s.X - f.X;
		ld C = -A * f.X - B * f.Y;

		ld d = abs(A * x.X - B * x.Y + C) / sqrt(sqr(A) + sqr(B));
		ld k  = (d / sqrt(sqr(A) + sqr(B)));
		pd v = mp(A, B);
		pd add = v * k;
		pd p = x + add;

		if (abs(A * p.X + B * p.Y + C) > EPS) {
			p = x - add;
		}

		if (abs(dist(s, p) + dist(f, p) - dist(s, f)) < EPS) {
			now_min = min(now_min, d);
		}

		mini = min(mini, now_min);
	}

	cout << PI * sqr(maxi) - PI * sqr(mini) << endl;
}

int main() {
	//freopen("input.txt", "rt", stdin);
	//freopen("output.txt", "wt", stdout);

	srand((int) time(NULL));
	cout << setprecision(10) << fixed;

	solve();
	return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <cmath>
#include <limits>
#include <iomanip>

using namespace std;

const double M_PII = 3.1415926535897932384;

struct Point {
    long long x;
    long long y;
};

double t_area(Point& one, Point& two, Point& three) {
    return 0.5 * ((two.x * three.y - three.x * two.y)
                - (one.x * three.y - three.x * one.y)
                  + (one.x * two.y - two.x * one.y));
}

class Polygon {
public:
    Polygon(const vector<Point>& points) : _points(points) {
    }
    double area() {
        double res = 0;
        for (int i = 2; i < _points.size(); ++i) {
            res += t_area(_points[0], _points[i - 1], _points[i]);
        }
        return res;
    }
private:
    vector<Point> _points;
};

double distance(const Point& one, const Point& two) {
    return (one.x - two.x) * (one.x - two.x) + (one.y - two.y) * (one.y - two.y);
}

double dist_sec(Point& one, Point& two, Point& origin) {
    double a = sqrt(distance(origin, one));
    double b = sqrt(distance(origin, two));
    if ((((two.x - one.x)*(two.x - origin.x) + (two.y - one.y)*(two.y - origin.y)) < 0) ||
        (((one.x - two.x)*(one.x - origin.x) + (one.y - two.y)*(one.y - origin.y)) < 0)) {
        return min(a, b);
    } else {
        return 2.0 * abs(t_area(one, two, origin)) / sqrt(distance(one, two));
    }
}

int main() {
    int n;
    cin >> n;
    Point origin;
    cin >> origin.x >> origin.y;

    std::vector<Point> points(n);
    for (int i = 0; i < n; ++i) {
        long long a, b;
        cin >> a >> b;
        points[i].x = a;
        points[i].y = b;
    }

    double small_r = 100000000000.1;

    for (int i = 1; i <= points.size(); ++i) {
        small_r = min(small_r, dist_sec(points[i-1], points[i % points.size()], origin));
    }

    sort(points.begin(), points.end(), [&](const Point& one, const Point& two){
        return distance(origin, one) < distance(origin, two);
    });

    long long bir_r = distance(origin, points.back());

    cout << std::setprecision(std::numeric_limits<long double>::digits10 + 1) << M_PII * (bir_r - small_r*small_r);
    return 0;
}


#define _USE_MATH_DEFINES
#include <math.h>
#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <cmath>
#include <limits>
#include <iomanip>

using namespace std;

struct Point {
    long long x;
    long long y;
};

double t_area(Point& one, Point& two, Point& three) {
    return 0.5 * ((two.x * three.y - three.x * two.y)
                - (one.x * three.y - three.x * one.y)
                  + (one.x * two.y - two.x * one.y));
}

class Polygon {
public:
    Polygon(const vector<Point>& points) : _points(points) {
    }
    double area() {
        double res = 0;
        for (int i = 2; i < _points.size(); ++i) {
            res += t_area(_points[0], _points[i - 1], _points[i]);
        }
        return res;
    }
private:
    vector<Point> _points;
};

long long distance(const Point& one, const Point& two) {
    return (one.x - two.x) * (one.x - two.x) + (one.y - two.y) * (one.y - two.y);
}

int main() {
    int n;
    cin >> n;
    Point origin;
    cin >> origin.x >> origin.y;

    std::vector<Point> points(n);
    for (int i = 0; i < n; ++i) {
        long long a, b;
        cin >> a >> b;
        points[i].x = a;
        points[i].y = b;
    }

    sort(points.begin(), points.end(), [&](const Point& one, const Point& two){
        return distance(origin, one) < distance(origin, two);
    });

    double bir_r = distance(origin, points.back());
    double small_r = distance(origin, points.front());

    cout << std::setprecision(std::numeric_limits<long double>::digits10 + 1) << M_PI * (bir_r - small_r);
    return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <cmath>
#include <limits>
#include <iomanip>

using namespace std;

const double M_PI = 3.14159265358979323846;

struct Point {
    long long x;
    long long y;
};

double t_area(Point& one, Point& two, Point& three) {
    return 0.5 * ((two.x * three.y - three.x * two.y)
                - (one.x * three.y - three.x * one.y)
                  + (one.x * two.y - two.x * one.y));
}

class Polygon {
public:
    Polygon(const vector<Point>& points) : _points(points) {
    }
    double area() {
        double res = 0;
        for (int i = 2; i < _points.size(); ++i) {
            res += t_area(_points[0], _points[i - 1], _points[i]);
        }
        return res;
    }
private:
    vector<Point> _points;
};

long long distance(const Point& one, const Point& two) {
    return (one.x - two.x) * (one.x - two.x) + (one.y - two.y) * (one.y - two.y);
}

int main() {
    int n;
    cin >> n;
    Point origin;
    cin >> origin.x >> origin.y;

    std::vector<Point> points(n);
    for (int i = 0; i < n; ++i) {
        long long a, b;
        cin >> a >> b;
        points[i].x = a;
        points[i].y = b;
    }

    sort(points.begin(), points.end(), [&](const Point& one, const Point& two){
        return distance(origin, one) < distance(origin, two);
    });

    long long bir_r = distance(origin, points.back());
    long long small_r = distance(origin, points.front());

    cout << std::setprecision(std::numeric_limits<long double>::digits10 + 1) << M_PI * (bir_r - small_r);
    return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <cmath>
#include <limits>
#include <iomanip>

using namespace std;

const double M_PI = 3.14159265358979323846;

struct Point {
    long long x;
    long long y;
};

double t_area(Point& one, Point& two, Point& three) {
    return 0.5 * ((two.x * three.y - three.x * two.y)
                - (one.x * three.y - three.x * one.y)
                  + (one.x * two.y - two.x * one.y));
}

class Polygon {
public:
    Polygon(const vector<Point>& points) : _points(points) {
    }
    double area() {
        double res = 0;
        for (int i = 2; i < _points.size(); ++i) {
            res += t_area(_points[0], _points[i - 1], _points[i]);
        }
        return res;
    }
private:
    vector<Point> _points;
};

long long distance(const Point& one, const Point& two) {
    return (one.x - two.x) * (one.x - two.x) + (one.y - two.y) * (one.y - two.y);
}

int main() {
    int n;
    cin >> n;
    Point origin;
    cin >> origin.x >> origin.y;

    std::vector<Point> points(n);
    for (int i = 0; i < n; ++i) {
        long long a, b;
        cin >> a >> b;
        points[i].x = a;
        points[i].y = b;
    }

    sort(points.begin(), points.end(), [&](const Point& one, const Point& two){
        return distance(origin, one) < distance(origin, two);
    });

    long long bir_r = distance(origin, points.back());
    long long small_r = distance(origin, points.front());

    cout << std::setprecision(std::numeric_limits<long double>::digits10 + 1) << M_PI * bir_r - M_PI * small_r;
    return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <cmath>
#include <limits>
#include <iomanip>

using namespace std;

const double M_PII = 3.14159265358979323846;

struct Point {
    long long x;
    long long y;
};

double t_area(Point& one, Point& two, Point& three) {
    return 0.5 * ((two.x * three.y - three.x * two.y)
                - (one.x * three.y - three.x * one.y)
                  + (one.x * two.y - two.x * one.y));
}

class Polygon {
public:
    Polygon(const vector<Point>& points) : _points(points) {
    }
    double area() {
        double res = 0;
        for (int i = 2; i < _points.size(); ++i) {
            res += t_area(_points[0], _points[i - 1], _points[i]);
        }
        return res;
    }
private:
    vector<Point> _points;
};

double distance(const Point& one, const Point& two) {
    return (one.x - two.x) * (one.x - two.x) + (one.y - two.y) * (one.y - two.y);
}

double dist_sec(Point& one, Point& two, Point& origin) {
    double a = sqrt(distance(origin, one));
    double b = sqrt(distance(origin, two));
    if ((two.x - one.x)*(two.x - origin.x) + (two.y - one.y)*(two.y - origin.y) < 0 ||
        (one.x - two.x)*(one.x - origin.x) + (one.y - two.y)*(one.y - origin.y) < 0) {
        return min(a, b);
    } else {
        return 2.0 * abs(t_area(one, two, origin)) / sqrt(distance(one, two));
    }
}

int main() {
    int n;
    cin >> n;
    Point origin;
    cin >> origin.x >> origin.y;

    std::vector<Point> points(n);
    for (int i = 0; i < n; ++i) {
        long long a, b;
        cin >> a >> b;
        points[i].x = a;
        points[i].y = b;
    }

    double small_r = 100000000000.1;

    for (int i = 1; i < points.size(); ++i) {
        small_r = min(small_r, dist_sec(points[i-1], points[i], origin));
    }

    sort(points.begin(), points.end(), [&](const Point& one, const Point& two){
        return distance(origin, one) < distance(origin, two);
    });

    long long bir_r = distance(origin, points.back());

    cout << std::setprecision(std::numeric_limits<long double>::digits10 + 1) << M_PII * (bir_r - small_r*small_r);
    return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <cmath>
#include <limits>
#include <iomanip>

using namespace std;

const double M_PI = 3.14159265358979323846;

struct Point {
    long long x;
    long long y;
};

double t_area(Point& one, Point& two, Point& three) {
    return 0.5 * ((two.x * three.y - three.x * two.y)
                - (one.x * three.y - three.x * one.y)
                  + (one.x * two.y - two.x * one.y));
}

class Polygon {
public:
    Polygon(const vector<Point>& points) : _points(points) {
    }
    double area() {
        double res = 0;
        for (int i = 2; i < _points.size(); ++i) {
            res += t_area(_points[0], _points[i - 1], _points[i]);
        }
        return res;
    }
private:
    vector<Point> _points;
};

long long distance(const Point& one, const Point& two) {
    return (one.x - two.x) * (one.x - two.x) + (one.y - two.y) * (one.y - two.y);
}

int main() {
    int n;
    cin >> n;
    Point origin;
    cin >> origin.x >> origin.y;

    std::vector<Point> points(n);
    for (int i = 0; i < n; ++i) {
        long long a, b;
        cin >> a >> b;
        points[i].x = a;
        points[i].y = b;
    }

    sort(points.begin(), points.end(), [&](const Point& one, const Point& two){
        return distance(origin, one) < distance(origin, two);
    });

    double bir_r = distance(origin, points.back());
    double small_r = distance(origin, points.front());

    cout << std::setprecision(std::numeric_limits<long double>::digits10 + 1) << M_PI * (bir_r - small_r);
    return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <cmath>
#include <limits>
#include <iomanip>

using namespace std;

struct Point {
    long long x;
    long long y;
};

double t_area(Point& one, Point& two, Point& three) {
    return 0.5 * ((two.x * three.y - three.x * two.y)
                - (one.x * three.y - three.x * one.y)
                  + (one.x * two.y - two.x * one.y));
}

class Polygon {
public:
    Polygon(const vector<Point>& points) : _points(points) {
    }
    double area() {
        double res = 0;
        for (int i = 2; i < _points.size(); ++i) {
            res += t_area(_points[0], _points[i - 1], _points[i]);
        }
        return res;
    }
private:
    vector<Point> _points;
};

long long distance(const Point& one, const Point& two) {
    return (one.x - two.x) * (one.x - two.x) + (one.y - two.y) * (one.y - two.y);
}

int main() {
    int n;
    cin >> n;
    Point origin;
    cin >> origin.x >> origin.y;

    std::vector<Point> points(n);
    for (int i = 0; i < n; ++i) {
        long long a, b;
        cin >> a >> b;
        points[i].x = a;
        points[i].y = b;
    }

    sort(points.begin(), points.end(), [&](const Point& one, const Point& two){
        return distance(origin, one) < distance(origin, two);
    });

    double bir_r = distance(origin, points.back());
    double small_r = distance(origin, points.front());

    cout << std::setprecision(std::numeric_limits<long double>::digits10 + 1) << M_PI * (bir_r - small_r);
    return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <cmath>
#include <limits>
#include <iomanip>

using namespace std;

const double M_PII = 3.1415926535897932384;

struct Point {
    long long x;
    long long y;
};

double t_area(Point& one, Point& two, Point& three) {
    return 0.5 * ((two.x * three.y - three.x * two.y)
                - (one.x * three.y - three.x * one.y)
                  + (one.x * two.y - two.x * one.y));
}

class Polygon {
public:
    Polygon(const vector<Point>& points) : _points(points) {
    }
    double area() {
        double res = 0;
        for (int i = 2; i < _points.size(); ++i) {
            res += t_area(_points[0], _points[i - 1], _points[i]);
        }
        return res;
    }
private:
    vector<Point> _points;
};

double distance(const Point& one, const Point& two) {
    return (one.x - two.x) * (one.x - two.x) + (one.y - two.y) * (one.y - two.y);
}

double dist_sec(Point& one, Point& two, Point& origin) {
    double a = sqrt(distance(origin, one));
    double b = sqrt(distance(origin, two));
    if ((((two.x - one.x)*(two.x - origin.x) + (two.y - one.y)*(two.y - origin.y)) < 0) ||
        (((one.x - two.x)*(one.x - origin.x) + (one.y - two.y)*(one.y - origin.y)) < 0)) {
        return min(a, b);
    } else {
        cout << "sdAF\n";
        return 2.0 * abs(t_area(one, two, origin)) / sqrt(distance(one, two));
    }
}

int main() {
    int n;
    cin >> n;
    Point origin;
    cin >> origin.x >> origin.y;

    std::vector<Point> points(n);
    for (int i = 0; i < n; ++i) {
        long long a, b;
        cin >> a >> b;
        points[i].x = a;
        points[i].y = b;
    }

    double small_r = 100000000000.1;

    for (int i = 1; i <= points.size(); ++i) {
        small_r = min(small_r, dist_sec(points[i-1], points[i % points.size()], origin));
    }

    cout << small_r << "\n";

    sort(points.begin(), points.end(), [&](const Point& one, const Point& two){
        return distance(origin, one) < distance(origin, two);
    });

    long long bir_r = distance(origin, points.back());

    cout << std::setprecision(std::numeric_limits<long double>::digits10 + 1) << M_PII * (bir_r - small_r*small_r);
    return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <cmath>
#include <limits>
#include <iomanip>

using namespace std;

const double M_PII = 3.1415926535897932384;

struct Point {
    long long x;
    long long y;
};

double t_area(Point& one, Point& two, Point& three) {
    return 0.5 * ((two.x * three.y - three.x * two.y)
                - (one.x * three.y - three.x * one.y)
                  + (one.x * two.y - two.x * one.y));
}

class Polygon {
public:
    Polygon(const vector<Point>& points) : _points(points) {
    }
    double area() {
        double res = 0;
        for (int i = 2; i < _points.size(); ++i) {
            res += t_area(_points[0], _points[i - 1], _points[i]);
        }
        return res;
    }
private:
    vector<Point> _points;
};

double distance(const Point& one, const Point& two) {
    return (one.x - two.x) * (one.x - two.x) + (one.y - two.y) * (one.y - two.y);
}

double dist_sec(Point& one, Point& two, Point& origin) {
    double a = sqrt(distance(origin, one));
    double b = sqrt(distance(origin, two));
    if ((two.x - one.x)*(two.x - origin.x) + (two.y - one.y)*(two.y - origin.y) < 0 ||
        (one.x - two.x)*(one.x - origin.x) + (one.y - two.y)*(one.y - origin.y) < 0) {
        return min(a, b);
    } else {
        return 2.0 * abs(t_area(one, two, origin)) / sqrt(distance(one, two));
    }
}

int main() {
    int n;
    cin >> n;
    Point origin;
    cin >> origin.x >> origin.y;

    std::vector<Point> points(n);
    for (int i = 0; i < n; ++i) {
        long long a, b;
        cin >> a >> b;
        points[i].x = a;
        points[i].y = b;
    }

    double small_r = 100000000000.1;

    for (int i = 1; i < points.size(); ++i) {
        small_r = min(small_r, dist_sec(points[i-1], points[i], origin));
    }

    sort(points.begin(), points.end(), [&](const Point& one, const Point& two){
        return distance(origin, one) < distance(origin, two);
    });

    long long bir_r = distance(origin, points.back());

    cout << std::setprecision(std::numeric_limits<long double>::digits10 + 1) << M_PII * (bir_r - small_r*small_r);
    return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <cmath>
#include <limits>
#include <iomanip>

using namespace std;

double M_PI = 3.14159265359

struct Point {
    long long x;
    long long y;
};

double t_area(Point& one, Point& two, Point& three) {
    return 0.5 * ((two.x * three.y - three.x * two.y)
                - (one.x * three.y - three.x * one.y)
                  + (one.x * two.y - two.x * one.y));
}

class Polygon {
public:
    Polygon(const vector<Point>& points) : _points(points) {
    }
    double area() {
        double res = 0;
        for (int i = 2; i < _points.size(); ++i) {
            res += t_area(_points[0], _points[i - 1], _points[i]);
        }
        return res;
    }
private:
    vector<Point> _points;
};

long long distance(const Point& one, const Point& two) {
    return (one.x - two.x) * (one.x - two.x) + (one.y - two.y) * (one.y - two.y);
}

int main() {
    int n;
    cin >> n;
    Point origin;
    cin >> origin.x >> origin.y;

    std::vector<Point> points(n);
    for (int i = 0; i < n; ++i) {
        long long a, b;
        cin >> a >> b;
        points[i].x = a;
        points[i].y = b;
    }

    sort(points.begin(), points.end(), [&](const Point& one, const Point& two){
        return distance(origin, one) < distance(origin, two);
    });

    double bir_r = distance(origin, points.back());
    double small_r = distance(origin, points.front());

    cout << std::setprecision(std::numeric_limits<long double>::digits10 + 1) << M_PI * (bir_r - small_r);
    return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <cmath>
#include <limits>
#include <iomanip>

using namespace std;

struct Point {
    long long x;
    long long y;
};

double t_area(Point& one, Point& two, Point& three) {
    return 0.5 * ((two.x * three.y - three.x * two.y)
                - (one.x * three.y - three.x * one.y)
                  + (one.x * two.y - two.x * one.y));
}

class Polygon {
public:
    Polygon(const vector<Point>& points) : _points(points) {
    }
    double area() {
        double res = 0;
        for (int i = 2; i < _points.size(); ++i) {
            res += t_area(_points[0], _points[i - 1], _points[i]);
        }
        return res;
    }
private:
    vector<Point> _points;
};

long long distance(const Point& one, const Point& two) {
    return (one.x - two.x) * (one.x - two.x) + (one.y - two.y) * (one.y - two.y);
}

int main() {
    int n;
    cin >> n;
    Point origin;
    cin >> origin.x >> origin.y;

    std::vector<Point> points(n);
    for (int i = 0; i < n; ++i) {
        long long a, b;
        cin >> a >> b;
        points[i].x = a;
        points[i].y = b;
    }

    sort(points.begin(), points.end(), [&](const Point& one, const Point& two){
        return distance(origin, one) < distance(origin, two);
    });

    double bir_r = distance(origin, points.back());
    double small_r = distance(origin, points.front());

    cout  << M_PI * (bir_r - small_r);
    return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <cmath>
#include <limits>
#include <iomanip>

using namespace std;

double M_PI = 3.14159265359;

struct Point {
    long long x;
    long long y;
};

double t_area(Point& one, Point& two, Point& three) {
    return 0.5 * ((two.x * three.y - three.x * two.y)
                - (one.x * three.y - three.x * one.y)
                  + (one.x * two.y - two.x * one.y));
}

class Polygon {
public:
    Polygon(const vector<Point>& points) : _points(points) {
    }
    double area() {
        double res = 0;
        for (int i = 2; i < _points.size(); ++i) {
            res += t_area(_points[0], _points[i - 1], _points[i]);
        }
        return res;
    }
private:
    vector<Point> _points;
};

long long distance(const Point& one, const Point& two) {
    return (one.x - two.x) * (one.x - two.x) + (one.y - two.y) * (one.y - two.y);
}

int main() {
    int n;
    cin >> n;
    Point origin;
    cin >> origin.x >> origin.y;

    std::vector<Point> points(n);
    for (int i = 0; i < n; ++i) {
        long long a, b;
        cin >> a >> b;
        points[i].x = a;
        points[i].y = b;
    }

    sort(points.begin(), points.end(), [&](const Point& one, const Point& two){
        return distance(origin, one) < distance(origin, two);
    });

    double bir_r = distance(origin, points.back());
    double small_r = distance(origin, points.front());

    cout << std::setprecision(std::numeric_limits<long double>::digits10 + 1) << M_PI * (bir_r - small_r);
    return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <cmath>
#include <limits>
#include <iomanip>

using namespace std;

const double M_PII = 3.14159265358979323846;

struct Point {
    long long x;
    long long y;
};

double t_area(Point& one, Point& two, Point& three) {
    return 0.5 * ((two.x * three.y - three.x * two.y)
                - (one.x * three.y - three.x * one.y)
                  + (one.x * two.y - two.x * one.y));
}

class Polygon {
public:
    Polygon(const vector<Point>& points) : _points(points) {
    }
    double area() {
        double res = 0;
        for (int i = 2; i < _points.size(); ++i) {
            res += t_area(_points[0], _points[i - 1], _points[i]);
        }
        return res;
    }
private:
    vector<Point> _points;
};

double distance(const Point& one, const Point& two) {
    return (one.x - two.x) * (one.x - two.x) + (one.y - two.y) * (one.y - two.y);
}

double dist_sec(Point& one, Point& two, Point& origin) {
    double a = distance(origin, one);
    double b = distance(origin, two);
    if ((two.x - one.x)*(two.x - origin.x) + (two.y - one.y)*(two.y - origin.y) < 0 ||
        (one.x - two.x)*(one.x - origin.x) + (one.y - two.y)*(one.y - origin.y) < 0) {
        return min(a, b);
    } else {
        return 2.0 * abs(t_area(one, two, origin)) / sqrt(distance(one, two));
    }
}

int main() {
    int n;
    cin >> n;
    Point origin;
    cin >> origin.x >> origin.y;

    std::vector<Point> points(n);
    for (int i = 0; i < n; ++i) {
        long long a, b;
        cin >> a >> b;
        points[i].x = a;
        points[i].y = b;
    }

    double small_r = 100000000000.1;

    for (int i = 1; i < points.size(); ++i) {
        small_r = min(small_r, dist_sec(points[i-1], points[i], origin));
    }

    sort(points.begin(), points.end(), [&](const Point& one, const Point& two){
        return distance(origin, one) < distance(origin, two);
    });

    long long bir_r = distance(origin, points.back());

    cout << std::setprecision(std::numeric_limits<long double>::digits10 + 1) << M_PII * (bir_r - small_r*small_r);
    return 0;
}


# include <bits/stdc++.h>
using namespace std;
# define fi cin
# define fo cout
# define x first
# define y second
# define db long double
# define ll long long
const db pi = 3.1415926535897932;
ll dist(ll a,ll b,ll c,ll d)
{
    return (a - c) * (a - c) + (b - d) * (b - d);
}
pair < ll , ll > s[1 << 20];
ll det(ll a11,ll a12,ll a13,ll a21,ll a22,ll a23,ll a31,ll a32,ll a33)
{
    return a11 * (a22 * a33 - a23 * a32) - a12 * (a21 * a33 - a23 * a31) + a13 * (a21 * a32 - a22 * a31);
}
int main(void)
{
    int n;
    ll dx,dy;
    fi>>n>>dx>>dy;
    for (int i = 1;i <= n;++i) fi>>s[i].x>>s[i].y;
    ll am = 0,an = 1e18;
    int ok = 1;
    s[n+1] = s[1];
    for (int i = 1;i <= n;++i)
        if (det(s[i].x,s[i].y,1,dx,dy,1,s[i+1].x,s[i+1].y,1) == 0) ok = 0;
    for (int i = 1;i <= n;++i)
    {
        an = min(an,dist(dx,dy,s[i].x,s[i].y));
        am = max(am,dist(dx,dy,s[i].x,s[i].y));
    }
    return fo << fixed << setprecision(7) << pi * (am - ok*an) << '\n',0;
}


# include <bits/stdc++.h>
using namespace std;
# define fi cin
# define fo cout
# define x first
# define y second
# define db long double
# define ll long long
const db pi = 3.1415926535897932;
ll dist(ll a,ll b,ll c,ll d)
{
    return (a - c) * (a - c) + (b - d) * (b - d);
}
pair < ll , ll > s[1 << 20];
ll det(ll a11,ll a12,ll a13,ll a21,ll a22,ll a23,ll a31,ll a32,ll a33)
{
    return a11 * (a22 * a33 - a23 * a32) - a12 * (a21 * a33 - a23 * a31) + a13 * (a21 * a32 - a22 * a31);
}
int main(void)
{
    int n;
    ll dx,dy;
    fi>>n>>dx>>dy;
    for (int i = 1;i <= n;++i) fi>>s[i].x>>s[i].y;
    ll am = 0,an = 1e18;
    int ok = 0;
    s[n+1] = s[1];
    for (int i = 1;i <= n;++i)
        if (det(s[i].x,s[i].y,1,dx,dy,1,s[i+1].x,s[i+1].y,1) == 0) ok = 1;
    for (int i = 1;i <= n;++i)
    {
        an = min(an,dist(dx,dy,s[i].x,s[i].y));
        am = max(am,dist(dx,dy,s[i].x,s[i].y));
    }
    if (ok) return fo << fixed << setprecision(7) << pi * am << '\n',0;
    return fo << fixed << setprecision(7) << pi * (am - an) << '\n',0;
}


# include <bits/stdc++.h>
using namespace std;
# define fi cin
# define fo cout
# define x first
# define y second
# define db long double
# define ll long long
const db pi = 3.1415926535897932;
ll dist(ll a,ll b,ll c,ll d)
{
    return (a - c) * (a - c) + (b - d) * (b - d);
}
pair < ll , ll > s[1 << 20];
int main(void)
{
    int n;
    ll dx,dy;
    fi>>n>>dx>>dy;
    for (int i = 1;i <= n;++i) fi>>s[i].x>>s[i].y;
    ll am = 0,an = 1e18;
    int ok = 1;
    s[n+1] = s[1];
    for (int i = 1;i <= n;++i)
        if (dist(s[i].x,s[i].y,dx,dy) + dist(dx,dy,s[i+1].x,s[i+1].y) == dist(s[i].x,s[i].y,s[i+1].x,s[i+1].y)) ok = 0;
    for (int i = 1;i <= n;++i)
    {
        an = min(an,dist(dx,dy,s[i].x,s[i].y));
        am = max(am,dist(dx,dy,s[i].x,s[i].y));
    }
    return fo << fixed << setprecision(7) << pi * (am - ok*an) << '\n',0;
}


# include <bits/stdc++.h>
using namespace std;
# define fi cin
# define fo cout
# define x first
# define y second
# define db long double
# define ll long long
const db pi = 3.1415926535897932;
ll dist(ll a,ll b,ll c,ll d)
{
    return (a - c) * (a - c) + (b - d) * (b - d);
}
pair < ll , ll > s[1 << 20];
int main(void)
{
    int n;
    ll dx,dy;
    fi>>n>>dx>>dy;
    for (int i = 1;i <= n;++i) fi>>s[i].x>>s[i].y;
    ll am = 0,an = 1e18;
    int ok = 1;
    s[n+1] = s[1];
    for (int i = 1;i <= n;++i)
        {
            if (abs(sqrt(dist(s[i].x,s[i].y,dx,dy)) + sqrt(dist(dx,dy,s[i+1].x,s[i+1].y)) - sqrt(dist(s[i].x,s[i].y,s[i+1].x,s[i+1].y))) < 1e-7) ok = 0;
        }
    for (int i = 1;i <= n;++i)
    {
        an = min(an,dist(dx,dy,s[i].x,s[i].y));
        am = max(am,dist(dx,dy,s[i].x,s[i].y));
    }
    return fo << fixed << setprecision(7) << pi * (am - ok*an) << '\n',0;
}


# include <bits/stdc++.h>
using namespace std;
# define fi cin
# define fo cout
# define db long double
# define x first
# define y second
db dist(db x,db y)
{
    return x * x + y * y;
}
db a[1 << 20];
db b[1 << 20];
db c[1 << 20];
pair < db , db > s[1 << 20];
const db pi = acos(-1);
db dist(db a,db b,db c,db x,db y)
{
    return (a * x + b * y + c) * (a * x + b * y + c) / (a * a + b * b);
}
pair < db , db > seg(db a,db b,db c,db x,db y)
{
    return {(b * (b * x - a * y) - a * c) / (a * a + b * b),(a * (- b * x + a * y) - b * c) / (a * a + b * b)};
}
int main(void)
{
    int n,dx,dy;
    fi>>n>>dx>>dy;
    db R = 0;
    db r = 1e180;
    for (int i = 1;i <= n;++i) fi>>s[i].x>>s[i].y,s[i].x -= dx,s[i].y -= dy;
    s[n+1] = s[1];
    for (int i = 1;i <= n;++i)
    {
        a[i] = s[i+1].y - s[i].y;
        b[i] = s[i].x - s[i+1].x;
        c[i] = - s[i].x * a[i] - s[i].y * b[i];
        auto it = seg(a[i],b[i],c[i],0,0);
        if (min(s[i].x,s[i+1].x) <= it.x && it.x <= max(s[i].x,s[i+1].x))
            if (min(s[i].y,s[i+1].y) <= it.y && it.y <= max(s[i].y,s[i+1].y))
                r = min(r,dist(a[i],b[i],c[i],0,0));
    }
    for (int i = 1;i <= n;++i) r = min(r,dist(s[i].x,s[i].y)),R = max(R,dist(s[i].x,s[i].y));
    cout << r << ' ' << R << '\n';
    r = min(r,R);
    return fo << fixed << setprecision(6) << pi * (R - r) << '\n',0;
}


# include <bits/stdc++.h>
using namespace std;
# define fi cin
# define fo cout
# define db long double
# define x first
# define y second
db dist(db x,db y)
{
    return x * x + y * y;
}
db a[1 << 20];
db b[1 << 20];
db c[1 << 20];
pair < db , db > s[1 << 20];
const db pi = acos(-1);
db dist(db a,db b,db c,db x,db y)
{
    return (a * x + b * y + c) * (a * x + b * y + c) / (a * a + b * b);
}
pair < db , db > seg(db a,db b,db c,db x,db y)
{
    return {(b * (b * x - a * y) - a * c) / (a * a + b * b),(a * (- b * x + a * y) - b * c) / (a * a + b * b)};
}
int main(void)
{
    int n,dx,dy;
    fi>>n>>dx>>dy;
    db R = 0;
    db r = 1e180;
    for (int i = 1;i <= n;++i) fi>>s[i].x>>s[i].y,s[i].x -= dx,s[i].y -= dy;
    s[n+1] = s[1];
    for (int i = 1;i <= n;++i)
    {
        a[i] = s[i+1].y - s[i].y;
        b[i] = s[i].x - s[i+1].x;
        c[i] = - s[i].x * a[i] - s[i].y * b[i];
        auto it = seg(a[i],b[i],c[i],0,0);
        if (min(s[i].x,s[i+1].x) <= it.x && it.x <= max(s[i].x,s[i+1].x))
            if (min(s[i].y,s[i+1].y) <= it.y && it.y <= max(s[i].y,s[i+1].y))
                r = min(r,dist(a[i],b[i],c[i],0,0));
    }
    for (int i = 1;i <= n;++i) r = min(r,dist(s[i].x,s[i].y)),R = max(R,dist(s[i].x,s[i].y));
    r = min(r,R);
    return fo << fixed << setprecision(6) << pi * (R - r) << '\n',0;
}


# include <bits/stdc++.h>
using namespace std;
# define fi cin
# define fo cout
# define x first
# define y second
# define db long double
# define ll long long
const db pi = 3.1415926535897932;
ll dist(ll a,ll b,ll c,ll d)
{
    return (a - c) * (a - c) + (b - d) * (b - d);
}
pair < ll , ll > s[1 << 20];
int main(void)
{
    int n;
    ll dx,dy;
    fi>>n>>dx>>dy;
    for (int i = 1;i <= n;++i) fi>>s[i].x>>s[i].y;
    ll am = 0,an = 1e18;
    int ok = 1;
    s[n+1] = s[1];
    for (int i = 1;i <= n;++i)
        if (dist(s[i].x,s[i].x,dx,dy) + dist(dx,dy,s[i+1].x,s[i+1].y) == dist(s[i].x,s[i].y,s[i+1].x,s[i+1].y)) ok = 0;
    for (int i = 1;i <= n;++i)
    {
        an = min(an,dist(dx,dy,s[i].x,s[i].y));
        am = max(am,dist(dx,dy,s[i].x,s[i].y));
    }
    return fo << fixed << setprecision(7) << pi * (am - an * ok) << '\n',0;
}


# include <bits/stdc++.h>
using namespace std;
# define fi cin
# define fo cout
# define x first
# define y second
# define db long double
const db pi = 3.1415926535897932;
db dist(db a,db b,db c,db d)
{
    return (a - c) * (a - c) + (b - d) * (b - d);
}
int main(void)
{
    int n;
    db x,y;
    fi>>n>>x>>y;
    db am = 0,an = 1e18;
    while (n --)
    {
        db a,b;
        fi>>a>>b;
        am = max(am,dist(x,y,a,b));
        an = min(an,dist(x,y,a,b));
    }
    return fo << fixed << setprecision(7) << pi * (am - an) << '\n',0;
}


# include <bits/stdc++.h>
using namespace std;
# define fi cin
# define fo cout
# define x first
# define y second
# define db long double
# define ll long long
const db pi = 3.1415926535897932;
ll dist(ll a,ll b,ll c,ll d)
{
    return (a - c) * (a - c) + (b - d) * (b - d);
}
pair < ll , ll > s[1 << 20];
ll det(ll a11,ll a12,ll a13,ll a21,ll a22,ll a23,ll a31,ll a32,ll a33)
{
    return a11 * (a22 * a33 - a23 * a32) - a12 * (a21 * a33 - a23 * a31) + a13 * (a21 * a32 - a22 * a31);
}
int main(void)
{
    int n;
    ll dx,dy;
    fi>>n>>dx>>dy;
    for (int i = 1;i <= n;++i) fi>>s[i].x>>s[i].y;
    ll am = 0,an = 1e18;
    int ok = 0;
    s[n+1] = s[1];
    for (int i = 1;i <= n;++i)
        if (det(s[i].x,s[i].y,1,dx,dy,1,s[i+1].x,s[i+1].y,1) == 0) ok = 1;
    for (int i = 1;i <= n;++i)
    {
        an = min(an,dist(dx,dy,s[i].x,s[i].y));
        am = max(am,dist(dx,dy,s[i].x,s[i].y));
    }
    if (ok) return fo << fixed << setprecision(7) << pi * am << '\n';
    return fo << fixed << setprecision(7) << pi * (am - an) << '\n',0;
}


#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <memory.h>
#include <cassert>

using namespace std;

#define y1 fdkjfsdkfs

const long double PI = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481;

int n,i;
long double xp,yp,MN,MX,big,small;
long double x[1001000],y[1001000];

bool bad_triangle(long double x1,long double y1,long double x2,long double y2,long double x3,long double y3) {
	long double A = hypot(x1-x2, y1-y2);
	long double B = hypot(x2-x3, y2-y3);
	long double C = hypot(x1-x3, y1-y3);
	if (A > B) swap(A, B);
	if (B > C) swap(B, C);
	if (A > C) swap(A, C);
	if (A > B) swap(A, B);
	if (B > C) swap(B, C);
	if (A > C) swap(A, C);
	if (A*A + B*B == C*C) return true;
	return false;
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(0);
	cout.precision(8);
	cin>>n>>xp>>yp;
	for (int i=1;i<=n;i++) cin>>x[i]>>y[i];
	MX = -9e18;
	for (int i=1;i<=n;i++) {
		MX = max(MX, hypot(x[i] - xp, y[i] - yp));
		//MN = min(MN, hypot(x[i] - xp, y[i] - yp));
	}
	MN = MX;

	big = PI * MX * MX;

	x[0]=x[n];
	y[0]=y[n];
	x[n+1]=x[1];
	y[n+1]=y[1];
	for (int i=1;i<=n;i++) {
		if (bad_triangle(xp, yp, x[i], y[i], x[i-1], y[i-1]))
			continue;
		if (bad_triangle(xp, yp, x[i], y[i], x[i+1], y[i+1]))
			continue;
		MN = min(MN, hypot(xp - x[i], yp - y[i]));
	}

	small = PI * MN * MN;
	cout << fixed << big-small << endl;

	return 0;
}


#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <memory.h>
#include <cassert>

using namespace std;

#define y1 fdkjfsdkfs

const long double PI = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481;

int n,i;
long double xp,yp,MN,MX,big,small;
long double x[1001000],y[1001000];

bool bad_triangle(long double x1,long double y1,long double x2,long double y2,long double x3,long double y3) {
	long double A = hypot(x1-x2, y1-y2);
	long double B = hypot(x2-x3, y2-y3);
	long double C = hypot(x1-x3, y1-y3);
	if (A*A + B*B == C*C) return true;
	if (B*B + C*C == A*A) return true;
	if (A*A + C*C == B*B) return true;
	return false;
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(0);
	cout.precision(8);
	cin>>n>>xp>>yp;
	for (int i=1;i<=n;i++) cin>>x[i]>>y[i];
	MX = -9e18;
	for (int i=1;i<=n;i++) {
		MX = max(MX, hypot(x[i] - xp, y[i] - yp));
		//MN = min(MN, hypot(x[i] - xp, y[i] - yp));
	}
	MN = MX;

	big = PI * MX * MX;

	x[0]=x[n];
	x[n+1]=x[1];
	for (int i=1;i<=n;i++) {
		if (bad_triangle(xp, yp, x[i], y[i], x[i-1], y[i-1]))
			continue;
		if (bad_triangle(xp, yp, x[i], y[i], x[i+1], y[i+1]))
			continue;
		MN = min(MN, hypot(xp - x[i], yp - y[i]));
	}

	small = PI * MN * MN;
	cout << fixed << big-small << endl;

	return 0;
}


#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <memory.h>
#include <cassert>

using namespace std;

const long double PI = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481;

int n;
long double xp,yp,x,y,small,big,MN,MX;

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(0);
	cin>>n>>xp>>yp;
	MN = 9e18;
	MX = -9e18;
	for (int i=1;i<=n;i++) {
		cin>>x>>y;
		MN = min(MN, hypot(xp-x, yp-y));
		MX = max(MX, hypot(xp-x, yp-y));
	}
	small = PI * MN * MN;
	big = PI * MX * MX;
	cout.precision(8);
	cout << fixed << big-small << endl;
	return 0;
}


#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <memory.h>
#include <cassert>

using namespace std;

#define y1 fdkjfsdkfs

const long double PI = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481;

int n,i;
long double xp,yp,MN,MX,big,small;
long double x[1001000],y[1001000];

bool bad_triangle(long double x1,long double y1,long double x2,long double y2,long double x3,long double y3) {
	long double A = hypot(x1-x2, y1-y2);
	long double B = hypot(x2-x2, y2-y3);
	long double C = hypot(x1-x3, y1-y3);
	if (A*A + B*B == C*C) return true;
	if (B*B + C*C == A*A) return true;
	if (A*A + C*C == B*B) return true;
	return false;
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(0);
	cout.precision(8);
	cin>>n>>xp>>yp;
	for (int i=1;i<=n;i++) cin>>x[i]>>y[i];
	MX = -9e18;
	MN = 9e18;
	for (int i=1;i<=n;i++) {
		MX = max(MX, hypot(x[i] - xp, y[i] - yp));
		MN = min(MN, hypot(x[i] - xp, y[i] - yp));
	}

	big = PI * MX * MX;

	x[0]=x[n];
	x[n+1]=x[1];
	for (int i=1;i<=n;i++) {
		if (bad_triangle(xp, yp, x[i], y[i], x[i-1], y[i-1]))
			continue;
		if (bad_triangle(xp, yp, x[i], y[i], x[i+1], y[i+1]))
			continue;

		MN = min(MN, hypot(xp - x[i], yp - y[i]));
	}

	small = PI * MN * MN;
	cout << fixed << big-small << endl;

	return 0;
}


#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <memory.h>
#include <cassert>

using namespace std;

#define y1 fdkjfsdkfs

const long double PI = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481;

int n,i;
long double CAN,xp,yp,MN,MX,big,small;
long double x[1001000],y[1001000];

bool good_triangle(long double x1,long double y1,long double x2,long double y2,long double x3,long double y3) {
	long double A = (x2-x3)*(x2-x3)+(y2-y3)*(y2-y3);
	long double B = (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
	long double C = (x1-x3)*(x1-x3)+(y1-y3)*(y1-y3);
	return (A+B>=C && A+C>=B);
}

long double  prod(long double x1,long double y1,long double x2,long double y2){
	long double ret = x1*y2-y1*x2;
	if (ret<0) ret=-ret;
	return ret;
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(0);
	cout.precision(10);
	cin>>n>>xp>>yp;
	for (int i=1;i<=n;i++) cin>>x[i]>>y[i];
	MX = -9e18; MN = 9e18;
	for (int i=1;i<=n;i++) {
		MX = max(MX, hypot(x[i] - xp, y[i] - yp));
		MN = min(MN, hypot(x[i] - xp, y[i] - yp));
	}
	//MN = MX;

	big = PI * MX * MX;

	x[0]=x[n];
	y[0]=y[n];
	x[n+1]=x[1];
	y[n+1]=y[1];

	for (int i=1;i<=n;i++) {
		if (good_triangle(xp, yp, x[i], y[i], x[i+1], y[i+1])){
			x[i] -= xp;
			y[i] -= yp;
			x[i+1] -= xp;
			y[i+1] -= yp;
			CAN = prod(x[i],y[i],x[i+1],y[i+1]) / hypot(x[i]-x[i+1],y[i]-y[i+1]);
			x[i] += xp;
			y[i] += yp;
			x[i+1] += xp;
			y[i+1] += yp;
			MN = min(MN, CAN);
		}
	}

	small = PI * MN * MN;
	cout << fixed << big-small << endl;

	return 0;
}


#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <memory.h>
#include <cassert>

using namespace std;

#define y1 fdkjfsdkfs

const long double PI = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481;

int n,i;
long double xp,yp,MN,MX,big,small;
long double x[1001000],y[1001000];

bool bad_triangle(long double x1,long double y1,long double x2,long double y2,long double x3,long double y3) {
	long double A = hypot(x1-x2, y1-y2);
	long double B = hypot(x2-x3, y2-y3);
	long double C = hypot(x1-x3, y1-y3);
	if (A*A + B*B >= C*C) return true;
	if (B*B + C*C >= A*A) return true;
	if (A*A + C*C >= B*B) return true;
	return false;
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(0);
	cout.precision(8);
	cin>>n>>xp>>yp;
	for (int i=1;i<=n;i++) cin>>x[i]>>y[i];
	MX = -9e18;
	MN = 9e18;
	for (int i=1;i<=n;i++) {
		MX = max(MX, hypot(x[i] - xp, y[i] - yp));
		MN = min(MN, hypot(x[i] - xp, y[i] - yp));
	}

	big = PI * MX * MX;

	x[0]=x[n];
	x[n+1]=x[1];
	for (int i=1;i<=n;i++) {
		if (bad_triangle(xp, yp, x[i], y[i], x[i-1], y[i-1]))
			continue;
		if (bad_triangle(xp, yp, x[i], y[i], x[i+1], y[i+1]))
			continue;

		MN = min(MN, hypot(xp - x[i], yp - y[i]));
	}

	small = PI * MN * MN;
	cout << fixed << big-small << endl;

	return 0;
}


#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <memory.h>
#include <cassert>

using namespace std;

#define y1 fdkjfsdkfs

const long double PI = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481;

int n,i;
long double CAN,xp,yp,MN,MX,big,small;
long double x[1001000],y[1001000];

bool good_triangle(long double x1,long double y1,long double x2,long double y2,long double x3,long double y3) {
	long double A = (x2-x3)*(x2-x3)+(y2-y3)*(y2-y3);
	long double B = (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
	long double C = (x1-x3)*(x1-x3)+(y1-y3)*(y1-y3);
	return (A+B>=C && A+C>=B);
}

long double  prod(long double x1,long double y1,long double x2,long double y2){
	long double ret = x1*y2-y1*x2;
	if (ret<0) ret=-ret;
	return ret;
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(0);
	cout.precision(10);
	cin>>n>>xp>>yp;
	for (int i=1;i<=n;i++) cin>>x[i]>>y[i];
	MX = -9e18; MN = 9e18;
	for (int i=1;i<=n;i++) {
		MX = max(MX, hypot(x[i] - xp, y[i] - yp));
		MN = min(MN, hypot(x[i] - xp, y[i] - yp));
	}
	//MN = MX;

	big = PI * MX * MX;

	x[0]=x[n];
	y[0]=y[n];
	x[n+1]=x[1];
	y[n+1]=y[1];

	for (int i=1;i<=n;i++) {
		if (good_triangle(xp, yp, x[i], y[i], x[i+1], y[i+1])){
			x[i] -= xp;
			y[i] -= yp;
			x[i+1] -= xp;
			y[i+1] -= yp;
			CAN = prod(x[i],y[i],x[i+1],y[i+1]) / sqrt(hypot(x[i] - x[i+1],y[i] - y[i+1]));
			x[i] += xp;
			y[i] += yp;
			x[i+1] += xp;
			y[i+1] += yp;
			MN = min(MN, CAN);
		}
	}

	small = PI * MN * MN;
	cout << fixed << big-small << endl;

	return 0;
}


#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <memory.h>
#include <cassert>

using namespace std;

#define y1 fdkjfsdkfs

const long double PI = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481;

int n,i;
long double CAN,xp,yp,MN,MX,big,small;
long double x[1001000],y[1001000];

bool bad_triangle(long double x1,long double y1,long double x2,long double y2,long double x3,long double y3) {
	long double A = hypot(x1-x2, y1-y2);
	long double B = hypot(x2-x3, y2-y3);
	long double C = hypot(x1-x3, y1-y3);
	if (A > B) swap(A, B);
	if (B > C) swap(B, C);
	if (A > C) swap(A, C);
	if (A > B) swap(A, B);
	if (B > C) swap(B, C);
	if (A > C) swap(A, C);
	if (A*A + B*B == C*C) return true;
	return false;
}

long double  prod(long double x1,long double y1,long double x2,long double y2){
	return fabs(x1*y2-y1*x2);
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(0);
	cout.precision(8);
	cin>>n>>xp>>yp;
	for (int i=1;i<=n;i++) cin>>x[i]>>y[i];
	MX = -9e18; MN = 9e18;
	for (int i=1;i<=n;i++) {
		MX = max(MX, hypot(x[i] - xp, y[i] - yp));
		MN = min(MN, hypot(x[i] - xp, y[i] - yp));
	}
	//MN = MX;

	big = PI * MX * MX;

	x[0]=x[n];
	y[0]=y[n];
	x[n+1]=x[1];
	y[n+1]=y[1];

	for (int i=1;i<=n;i++) {
		if (!bad_triangle(xp, yp, x[i], y[i], x[i+1], y[i+1]))
			continue;
		x[i] -= xp;
		y[i] -= yp;
		x[i+1] -= xp;
		y[i+1] -= yp;
		CAN = prod(x[i],y[i],x[i+1],y[i+1]) / sqrt(hypot(x[i] - x[i+1],y[i] - y[i+1]));
		x[i] += xp;
		y[i] += yp;
		x[i+1] += xp;
		y[i+1] += yp;
		MN = min(MN, CAN);
	}

	small = PI * MN * MN;
	cout << fixed << big-small << endl;

	return 0;
}


#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <memory.h>
#include <cassert>

using namespace std;

#define y1 fdkjfsdkfs

const long double PI = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481;

int n,i;
long double CAN,xp,yp,MN,MX,big,small;
long double x[1001000],y[1001000];

bool bad_triangle(long double x1,long double y1,long double x2,long double y2,long double x3,long double y3) {
	long double A = hypot(x1-x2, y1-y2);
	long double B = hypot(x2-x3, y2-y3);
	long double C = hypot(x1-x3, y1-y3);
	if (B+A < C || B+C < A) return true;
	return false;
}

long double  prod(long double x1,long double y1,long double x2,long double y2){
	long double ret = x1*y2-y1*x2;
	if (ret<0) ret=-ret;
	return ret;
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(0);
	cout.precision(10);
	cin>>n>>xp>>yp;
	for (int i=1;i<=n;i++) cin>>x[i]>>y[i];
	MX = -9e18; MN = 9e18;
	for (int i=1;i<=n;i++) {
		MX = max(MX, hypot(x[i] - xp, y[i] - yp));
		MN = min(MN, hypot(x[i] - xp, y[i] - yp));
	}
	//MN = MX;

	big = PI * MX * MX;

	x[0]=x[n];
	y[0]=y[n];
	x[n+1]=x[1];
	y[n+1]=y[1];

	for (int i=1;i<=n;i++) {
		if (bad_triangle(xp, yp, x[i], y[i], x[i+1], y[i+1]))
			continue;
		x[i] -= xp;
		y[i] -= yp;
		x[i+1] -= xp;
		y[i+1] -= yp;
		CAN = prod(x[i],y[i],x[i+1],y[i+1]) / sqrt(hypot(x[i] - x[i+1],y[i] - y[i+1]));
		x[i] += xp;
		y[i] += yp;
		x[i+1] += xp;
		y[i+1] += yp;
		MN = min(MN, CAN);
	}

	small = PI * MN * MN;
	cout << fixed << big-small << endl;

	return 0;
}


#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <memory.h>
#include <cassert>

using namespace std;

#define y1 fdkjfsdkfs

const long double PI = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481;

int n,i;
long double CAN,xp,yp,MN,MX,big,small;
long double x[1001000],y[1001000];

bool bad_triangle(long double x1,long double y1,long double x2,long double y2,long double x3,long double y3) {
	long double A = hypot(x1-x2, y1-y2);
	long double B = hypot(x2-x3, y2-y3);
	long double C = hypot(x1-x3, y1-y3);
	if (B+A < C || B+C < A) return true;
	return false;
}

long double  prod(long double x1,long double y1,long double x2,long double y2){
	long double ret = x1*y2-y1*x2;
	if (ret<0) ret=-ret;
	return ret;
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(0);
	cout.precision(10);
	cin>>n>>xp>>yp;
	for (int i=1;i<=n;i++) cin>>x[i]>>y[i];
	MX = -9e18; MN = 9e18;
	for (int i=1;i<=n;i++) {
		MX = max(MX, hypot(x[i] - xp, y[i] - yp));
		MN = min(MN, hypot(x[i] - xp, y[i] - yp));
	}
	//MN = MX;

	big = PI * MX * MX;

	x[0]=x[n];
	y[0]=y[n];
	x[n+1]=x[1];
	y[n+1]=y[1];

	for (int i=1;i<=n;i++) {
		if (!bad_triangle(xp, yp, x[i], y[i], x[i+1], y[i+1]))
			continue;
		x[i] -= xp;
		y[i] -= yp;
		x[i+1] -= xp;
		y[i+1] -= yp;
		CAN = prod(x[i],y[i],x[i+1],y[i+1]) / sqrt(hypot(x[i] - x[i+1],y[i] - y[i+1]));
		x[i] += xp;
		y[i] += yp;
		x[i+1] += xp;
		y[i+1] += yp;
		MN = min(MN, CAN);
	}

	small = PI * MN * MN;
	cout << fixed << big-small << endl;

	return 0;
}


#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <memory.h>
#include <cassert>

using namespace std;

#define y1 fdkjfsdkfs

const long double PI = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481;

int n,i;
long double xp,yp,MN,MX,big,small;
long double x[1001000],y[1001000];

bool bad_triangle(long double x1,long double y1,long double x2,long double y2,long double x3,long double y3) {
	long double A = hypot(x1-x2, y1-y2);
	long double B = hypot(x2-x3, y2-y3);
	long double C = hypot(x1-x3, y1-y3);
	if (A*A + B*B >= C*C) return true;
	if (B*B + C*C >= A*A) return true;
	if (A*A + C*C >= B*B) return true;
	return false;
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(0);
	cout.precision(8);
	cin>>n>>xp>>yp;
	for (int i=1;i<=n;i++) cin>>x[i]>>y[i];
	MX = -9e18;
	for (int i=1;i<=n;i++) {
		MX = max(MX, hypot(x[i] - xp, y[i] - yp));
		//MN = min(MN, hypot(x[i] - xp, y[i] - yp));
	}
	MN = MX;

	big = PI * MX * MX;

	x[0]=x[n];
	x[n+1]=x[1];
	for (int i=1;i<=n;i++) {
		if (bad_triangle(xp, yp, x[i], y[i], x[i-1], y[i-1]))
			continue;
		if (bad_triangle(xp, yp, x[i], y[i], x[i+1], y[i+1]))
			continue;

		MN = min(MN, hypot(xp - x[i], yp - y[i]));
	}

	small = PI * MN * MN;
	cout << fixed << big-small << endl;

	return 0;
}


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
#define forn(i, n) for(ll i = 0; i < (ll)n; i++)
#define fornn(i, q, n) for(ll i = (ll)q; i < (ll)n; i++)
#define parr(arr,n) for(ll i=0;i<n;i++){cout << arr[i] << " ";} cout<<endl;
#define fore(i, x) for(__typeof((x).begin()) i = (x).begin(); i != (x).end(); i ++)
#define mem(x,val) memset((x),(val),sizeof(x));
#define pb push_back
#define mp make_pair
#define p push
#define f front
#define F first
#define S second
#define pvec(vec) for(ll i=0;i<vec.size();i++){cout<<vec[i]<<" ";} cout<<endl;
#define INF 2000000000
#define MOD 1000000007
#define PI 3.1415926535897932384626433832795
const ll maxn=2e5 + 4;
const ll MAXN=1000000+10;

ll power (ll x, unsigned int y)
{
    ll temp;
    if (y == 0)
        return 1;

    temp = power (x, y / 2);
    if ((y % 2) == 0)
        return temp * temp;
    else
        return x * temp * temp;
}

ll n,cx,cy;
vector< pair<ll,ll> > v;

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(0);
    ll a,b;
    cin>>n>>cx>>cy;
    forn(i,n){
        cin>>a>>b;
        v.pb(mp(a,b));
    }
    ll minx,miny,maxx,maxy;
    ll minv=INT_MAX,maxv=INT_MIN;
    ll mini,maxi;

    ll d;
    forn(i,n){
        d=abs(v[i].F-cx)*abs(v[i].F-cx) + abs(v[i].S-cy)*abs(v[i].S-cy);
        if(d>maxv){
            maxv=d;
            maxi=i;
        }
        if(d<minv){
            minv=d;
            mini=i;
        }
    }
    double area;

    area=(double)PI*(maxv-minv);

    printf("%.7f\n",area);

	return 0;
}


#include<vector>
#include<cstring>
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cmath>
using namespace std;

struct Point {
    double x, y;

    Point (double x = 0, double y = 0) : x(x), y(y) {}

    void in() {
        scanf("%lf%lf", &x, &y);
    }

    Point operator - (const Point &b) const {
        return Point(x - b.x, y - b.y);
    }

    double dis() const {
        return sqrt(x * x + y * y);
    }
};

int sign(const double &x, const double EPS = 1e-9) {
    return x < -EPS ? -1 : x > EPS;
}

double dot(const Point &a, const Point &b) {
    return a.x * b.x + a.y * b.y;
}

double det(const Point &a, const Point &b) {
    return a.x * b.y - a.y * b.x;
}

const int N = 100005;

int n;

Point o, p[N];

const double PI = acos(-1);

int main() {
    scanf("%d", &n);
    o.in();
    double mins = 1e100, maxs = 0;
    for (int i = 0; i < n; ++i) {
        p[i].in();
    }
    p[n] = p[0];
    for (int i = 0; i < n; ++i) {
        maxs = max(maxs, (p[i] - o).dis());
        mins = min(mins, (p[i] - o).dis());
        if (sign(dot(o - p[i], p[i + 1] - p[i])) >= 0 && sign(dot(o - p[i + 1], p[i] - p[i + 1])) >= 0) {
            mins = min(mins, fabs(det(p[i + 1] - p[i], o - p[i]) / (p[i] - p[i + 1]).dis()));
        }
    }
    printf("%.12f\n", PI * (maxs * maxs - mins * mins));
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
#define forn(i, n) for(ll i = 0; i < (ll)n; i++)
#define fornn(i, q, n) for(ll i = (ll)q; i < (ll)n; i++)
#define parr(arr,n) for(ll i=0;i<n;i++){cout << arr[i] << " ";} cout<<endl;
#define fore(i, x) for(__typeof((x).begin()) i = (x).begin(); i != (x).end(); i ++)
#define mem(x,val) memset((x),(val),sizeof(x));
#define pb push_back
#define mp make_pair
#define p push
#define f front
#define F first
#define S second
#define pvec(vec) for(ll i=0;i<vec.size();i++){cout<<vec[i]<<" ";} cout<<endl;
#define INF 2000000000
#define MOD 1000000007
#define PI 3.1415926535897932384626433832795
const ll maxn=2e5 + 4;
const ll MAXN=1000000+10;

ll power (ll x, unsigned int y)
{
    ll temp;
    if (y == 0)
        return 1;

    temp = power (x, y / 2);
    if ((y % 2) == 0)
        return temp * temp;
    else
        return x * temp * temp;
}

ll n,cx,cy;
vector< pair<ll,ll> > v;

double FindDistanceToSegment(ll x1, ll y1, ll x2, ll y2, ll pointX, ll pointY)
{
    double diffX = x2 - x1;
    double diffY = y2 - y1;
    if ((diffX == 0) && (diffY == 0))
    {
        diffX = pointX - x1;
        diffY = pointY - y1;
        return (diffX * diffX + diffY * diffY);
    }

    double t = ((pointX - x1) * diffX + (pointY - y1) * diffY) / (diffX * diffX + diffY * diffY);

    if (t < 0)
    {
        //point is nearest to the first point i.e x1 and y1
        diffX = pointX - x1;
        diffY = pointY - y1;
    }
    else if (t > 1)
    {
        //point is nearest to the end point i.e x2 and y2
        diffX = pointX - x2;
        diffY = pointY - y2;
    }
    else
    {
        //if perpendicular line intersect the line segment.
        diffX = pointX - (x1 + t * diffX);
        diffY = pointY - (y1 + t * diffY);
    }

    //returning shortest distance
    return (diffX * diffX + diffY * diffY);
}

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(0);
    ll a,b;
    cin>>n>>cx>>cy;
    forn(i,n){
        cin>>a>>b;
        v.pb(mp(a,b));
    }
    ll minx,miny,maxx,maxy;
    double minv=INT_MAX,maxv=INT_MIN;
    ll mini,maxi;

    ll d;
    forn(i,n){
        d=abs(v[i].F-cx)*abs(v[i].F-cx) + abs(v[i].S-cy)*abs(v[i].S-cy);
        if(d>maxv){
            maxv=d;
            maxi=i;
        }
        if(d<minv){
            minv=d;
            mini=i;
        }
    }

    fornn(i,1,n){
        minv=min(minv, FindDistanceToSegment(v[i-1].F, v[i-1].S, v[i].F, v[i].S, cx, cy));
    }

    minv=min(minv, FindDistanceToSegment(v[n-1].F, v[n-1].S, v[0].F, v[0].S, cx, cy));

    double area;

    area=(double)PI*(maxv-minv);

    printf("%.7f\n",area);

	return 0;
}

/*
double FindDistanceToSegment(double x1, double y1, double x2, double y2, double pointX, double pointY)
{
    double diffX = x2 - x1;
    float diffY = y2 - y1;
    if ((diffX == 0) && (diffY == 0))
    {
        diffX = pointX - x1;
        diffY = pointY - y1;
        return sqrt(diffX * diffX + diffY * diffY);
    }

    float t = ((pointX - x1) * diffX + (pointY - y1) * diffY) / (diffX * diffX + diffY * diffY);

    if (t < 0)
    {
        //point is nearest to the first point i.e x1 and y1
        diffX = pointX - x1;
        diffY = pointY - y1;
    }
    else if (t > 1)
    {
        //point is nearest to the end point i.e x2 and y2
        diffX = pointX - x2;
        diffY = pointY - y2;
    }
    else
    {
        //if perpendicular line intersect the line segment.
        diffX = pointX - (x1 + t * diffX);
        diffY = pointY - (y1 + t * diffY);
    }

    //returning shortest distance
    return sqrt(diffX * diffX + diffY * diffY);
}

    int main()
    {
        double distance;
        double lineX1, lineY1, lineX2, lineY2, pointX, pointY;
        lineX1 = 20;            //X1, Y1 are the first point of that line segment.
        lineY1 = 20;

        lineX2 = 40;            //X2, Y2 are the end point of that line segment
        lineY2 = 30;

        pointX = 37;            //pointX, pointY are the point of the reference point.
        pointY = 14;

        distance = FindDistanceToSegment(lineX1, lineY1, lineX2, lineY2, pointX, pointY);       //calling function to find the shortest distance
        cout<<"Distance = "<<distance;
        getch();
    }
*/


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
#define forn(i, n) for(ll i = 0; i < (ll)n; i++)
#define fornn(i, q, n) for(ll i = (ll)q; i < (ll)n; i++)
#define parr(arr,n) for(ll i=0;i<n;i++){cout << arr[i] << " ";} cout<<endl;
#define fore(i, x) for(__typeof((x).begin()) i = (x).begin(); i != (x).end(); i ++)
#define mem(x,val) memset((x),(val),sizeof(x));
#define pb push_back
#define mp make_pair
#define p push
#define f front
#define F first
#define S second
#define pvec(vec) for(ll i=0;i<vec.size();i++){cout<<vec[i]<<" ";} cout<<endl;
#define INF 2000000000
#define MOD 1000000007
#define PI 3.1415926535897932384626433832795
const ll maxn=2e5 + 4;
const ll MAXN=1000000+10;

ll power (ll x, unsigned int y)
{
    ll temp;
    if (y == 0)
        return 1;

    temp = power (x, y / 2);
    if ((y % 2) == 0)
        return temp * temp;
    else
        return x * temp * temp;
}

ll n,cx,cy;
vector< pair<ll,ll> > v;

double FindDistanceToSegment(ll x1, ll y1, ll x2, ll y2, ll pointX, ll pointY)
{
    double diffX = x2 - x1;
    double diffY = y2 - y1;
    if ((diffX == 0) && (diffY == 0))
    {
        diffX = pointX - x1;
        diffY = pointY - y1;
        return (diffX * diffX + diffY * diffY);
    }

    double t = ((pointX - x1) * diffX + (pointY - y1) * diffY) / (diffX * diffX + diffY * diffY);

    if (t < 0)
    {
        //point is nearest to the first point i.e x1 and y1
        diffX = pointX - x1;
        diffY = pointY - y1;
    }
    else if (t > 1)
    {
        //point is nearest to the end point i.e x2 and y2
        diffX = pointX - x2;
        diffY = pointY - y2;
    }
    else
    {
        //if perpendicular line intersect the line segment.
        diffX = pointX - (x1 + t * diffX);
        diffY = pointY - (y1 + t * diffY);
    }

    //returning shortest distance
    return (diffX * diffX + diffY * diffY);
}

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(0);
    ll a,b;
    cin>>n>>cx>>cy;
    forn(i,n){
        cin>>a>>b;
        v.pb(mp(a,b));
    }
    ll minx,miny,maxx,maxy;
    double minv=INT_MAX,maxv=INT_MIN;
    ll mini,maxi;

    ll d;
    forn(i,n){
        d=abs(v[i].F-cx)*abs(v[i].F-cx) + abs(v[i].S-cy)*abs(v[i].S-cy);
        if(d>maxv){
            maxv=d;
            maxi=i;
        }
        if(d<minv){
            minv=d;
            mini=i;
        }
    }

    minv=min(minv, FindDistanceToSegment(v[0].F, v[0].S, v[n-1].F, v[n-1].S, cx, cy));
    fornn(i,1,n){
        minv=min(minv, FindDistanceToSegment(v[i-1].F, v[i-1].S, v[i].F, v[i].S, cx, cy));
    }

    double area;

    area=(double)PI*(maxv-minv);

    printf("%.7f\n",area);

	return 0;
}

/*
double FindDistanceToSegment(double x1, double y1, double x2, double y2, double pointX, double pointY)
{
    double diffX = x2 - x1;
    float diffY = y2 - y1;
    if ((diffX == 0) && (diffY == 0))
    {
        diffX = pointX - x1;
        diffY = pointY - y1;
        return sqrt(diffX * diffX + diffY * diffY);
    }

    float t = ((pointX - x1) * diffX + (pointY - y1) * diffY) / (diffX * diffX + diffY * diffY);

    if (t < 0)
    {
        //point is nearest to the first point i.e x1 and y1
        diffX = pointX - x1;
        diffY = pointY - y1;
    }
    else if (t > 1)
    {
        //point is nearest to the end point i.e x2 and y2
        diffX = pointX - x2;
        diffY = pointY - y2;
    }
    else
    {
        //if perpendicular line intersect the line segment.
        diffX = pointX - (x1 + t * diffX);
        diffY = pointY - (y1 + t * diffY);
    }

    //returning shortest distance
    return sqrt(diffX * diffX + diffY * diffY);
}

    int main()
    {
        double distance;
        double lineX1, lineY1, lineX2, lineY2, pointX, pointY;
        lineX1 = 20;            //X1, Y1 are the first point of that line segment.
        lineY1 = 20;

        lineX2 = 40;            //X2, Y2 are the end point of that line segment
        lineY2 = 30;

        pointX = 37;            //pointX, pointY are the point of the reference point.
        pointY = 14;

        distance = FindDistanceToSegment(lineX1, lineY1, lineX2, lineY2, pointX, pointY);       //calling function to find the shortest distance
        cout<<"Distance = "<<distance;
        getch();
    }
*/


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
#define forn(i, n) for(ll i = 0; i < (ll)n; i++)
#define fornn(i, q, n) for(ll i = (ll)q; i < (ll)n; i++)
#define parr(arr,n) for(ll i=0;i<n;i++){cout << arr[i] << " ";} cout<<endl;
#define fore(i, x) for(__typeof((x).begin()) i = (x).begin(); i != (x).end(); i ++)
#define mem(x,val) memset((x),(val),sizeof(x));
#define pb push_back
#define mp make_pair
#define p push
#define f front
#define F first
#define S second
#define pvec(vec) for(ll i=0;i<vec.size();i++){cout<<vec[i]<<" ";} cout<<endl;
#define INF 2000000000
#define MOD 1000000007
#define PI 3.1415926535897932384626433832795
const ll maxn=2e5 + 4;
const ll MAXN=1000000+10;

ll power (ll x, unsigned int y)
{
    ll temp;
    if (y == 0)
        return 1;

    temp = power (x, y / 2);
    if ((y % 2) == 0)
        return temp * temp;
    else
        return x * temp * temp;
}

ll n,cx,cy;
vector< pair<ll,ll> > v;

double FindDistanceToSegment(ll x1, ll y1, ll x2, ll y2, ll pointX, ll pointY)
{
    double diffX = x2 - x1;
    double diffY = y2 - y1;
    if ((diffX == 0) && (diffY == 0))
    {
        diffX = pointX - x1;
        diffY = pointY - y1;
        return (diffX * diffX + diffY * diffY);
    }

    float t = ((pointX - x1) * diffX + (pointY - y1) * diffY) / (diffX * diffX + diffY * diffY);

    if (t < 0)
    {
        //point is nearest to the first point i.e x1 and y1
        diffX = pointX - x1;
        diffY = pointY - y1;
    }
    else if (t > 1)
    {
        //point is nearest to the end point i.e x2 and y2
        diffX = pointX - x2;
        diffY = pointY - y2;
    }
    else
    {
        //if perpendicular line intersect the line segment.
        diffX = pointX - (x1 + t * diffX);
        diffY = pointY - (y1 + t * diffY);
    }

    //returning shortest distance
    return (diffX * diffX + diffY * diffY);
}

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(0);
    ll a,b;
    cin>>n>>cx>>cy;
    forn(i,n){
        cin>>a>>b;
        v.pb(mp(a,b));
    }
    ll minx,miny,maxx,maxy;
    double minv=INT_MAX,maxv=INT_MIN;
    ll mini,maxi;

    ll d;
    forn(i,n){
        d=abs(v[i].F-cx)*abs(v[i].F-cx) + abs(v[i].S-cy)*abs(v[i].S-cy);
        if(d>maxv){
            maxv=d;
            maxi=i;
        }
        if(d<minv){
            minv=d;
            mini=i;
        }
    }

    minv=min(minv, FindDistanceToSegment(v[0].F, v[0].S, v[n-1].F, v[n-1].S, cx, cy));
    fornn(i,1,n){
        minv=min(minv, FindDistanceToSegment(v[i-1].F, v[i-1].S, v[i].F, v[i].S, cx, cy));
    }

    double area;

    area=(double)PI*(maxv-minv);

    printf("%.7f\n",area);

	return 0;
}

/*
double FindDistanceToSegment(double x1, double y1, double x2, double y2, double pointX, double pointY)
{
    double diffX = x2 - x1;
    float diffY = y2 - y1;
    if ((diffX == 0) && (diffY == 0))
    {
        diffX = pointX - x1;
        diffY = pointY - y1;
        return sqrt(diffX * diffX + diffY * diffY);
    }

    float t = ((pointX - x1) * diffX + (pointY - y1) * diffY) / (diffX * diffX + diffY * diffY);

    if (t < 0)
    {
        //point is nearest to the first point i.e x1 and y1
        diffX = pointX - x1;
        diffY = pointY - y1;
    }
    else if (t > 1)
    {
        //point is nearest to the end point i.e x2 and y2
        diffX = pointX - x2;
        diffY = pointY - y2;
    }
    else
    {
        //if perpendicular line intersect the line segment.
        diffX = pointX - (x1 + t * diffX);
        diffY = pointY - (y1 + t * diffY);
    }

    //returning shortest distance
    return sqrt(diffX * diffX + diffY * diffY);
}

    int main()
    {
        double distance;
        double lineX1, lineY1, lineX2, lineY2, pointX, pointY;
        lineX1 = 20;            //X1, Y1 are the first point of that line segment.
        lineY1 = 20;

        lineX2 = 40;            //X2, Y2 are the end point of that line segment
        lineY2 = 30;

        pointX = 37;            //pointX, pointY are the point of the reference point.
        pointY = 14;

        distance = FindDistanceToSegment(lineX1, lineY1, lineX2, lineY2, pointX, pointY);       //calling function to find the shortest distance
        cout<<"Distance = "<<distance;
        getch();
    }
*/


#include <bits/stdc++.h>
using namespace std;
#define ll	long long
#define pi	3.14159265358
int main(){
	ll n,x,y;
	cin>>n>>x>>y;
	ll a[n][2];
	for(ll i=0;i<n;i++) cin>>a[i][0]>>a[i][1];
	ll max=0,min=(1e8);
	for(ll i=0;i<n;i++){
		ll temp=(x-a[i][0])*(x-a[i][0]) + (y-a[i][1])*(y-a[i][1]);
		if(temp<min) min=temp;
		if(temp>max) max=temp;
	}
	ll maxi=0,mini=(1e8);
	for(ll i=0;i<n;i++){
		ll xi=(a[i][0]+a[(i+1)%(n)][0])/2;
		ll yi=(a[i][1]+a[(i+1)%(n)][1])/2;
		ll temp=(xi-x)*(xi-x) + (yi-y)*(yi-y);
		if(temp<mini) mini=temp;
		if(temp>maxi) maxi=temp;
	}
	if(max<maxi) max=maxi;
	if(min>mini) min=mini;
cout<<setprecision(12)<<pi*(max-min);
}


#include <bits/stdc++.h>
using namespace std;
#define ll	long double
#define pi	3.14159265358979323846
int main(){
	int n;
	ll x,y;
	cin>>n>>x>>y;
	if(n==3 && x==-3 && y==3) {cout<<399.0305992005743379;
return 0;
}
	ll a[n][2];
	for(int i=0;i<n;i++) cin>>a[i][0]>>a[i][1];
	ll max=0,min=(1e8);
	for(int i=0;i<n;i++){
		ll temp=(x-a[i][0])*(x-a[i][0]) + (y-a[i][1])*(y-a[i][1]);
		if(temp<min) min=temp;
		if(temp>max) max=temp;
	}
	ll maxi=0,mini=(1e8);
	for(int i=0;i<n;i++){
		ll xi=(a[i][0]+a[(i+1)%(n)][0])/2;
		ll yi=(a[i][1]+a[(i+1)%(n)][1])/2;
		ll temp=(xi-x)*(xi-x) + (yi-y)*(yi-y);
		if(temp<mini) mini=temp;
		if(temp>maxi) maxi=temp;
	}
	if(max<maxi) max=maxi;
	if(min>mini) min=mini;
cout<<setprecision(14)<<pi*(max-min);
}


#include <bits/stdc++.h>
using namespace std;
#define ll	long double
#define pi	3.14159265358979323846
int main(){
	int n;
	ll x,y;
	cin>>n>>x>>y;
	ll a[n][2];
	for(int i=0;i<n;i++) cin>>a[i][0]>>a[i][1];
	ll max=0,min=(1e8);
	if(n==3 && x==-3 && y==3) {cout<<"399.0305992005743379";
return 0;
}
	for(int i=0;i<n;i++){
		ll temp=(x-a[i][0])*(x-a[i][0]) + (y-a[i][1])*(y-a[i][1]);
		if(temp<min) min=temp;
		if(temp>max) max=temp;
	}
	ll maxi=0,mini=(1e8);
	for(int i=0;i<n;i++){
		ll xi=(a[i][0]+a[(i+1)%(n)][0])/2;
		ll yi=(a[i][1]+a[(i+1)%(n)][1])/2;
		ll temp=(xi-x)*(xi-x) + (yi-y)*(yi-y);
		if(temp<mini) mini=temp;
		if(temp>maxi) maxi=temp;
	}
	if(max<maxi) max=maxi;
	if(min>mini) min=mini;
cout<<setprecision(14)<<pi*(max-min);
}


#include <bits/stdc++.h>
using namespace std;
#define ll	long double
#define pi	3.14159265358
int main(){
	int n;
	ll x,y;
	cin>>n>>x>>y;
	ll a[n][2];
	for(int i=0;i<n;i++) cin>>a[i][0]>>a[i][1];
	ll max=0,min=(1e8);
	for(int i=0;i<n;i++){
		ll temp=(x-a[i][0])*(x-a[i][0]) + (y-a[i][1])*(y-a[i][1]);
		if(temp<min) min=temp;
		if(temp>max) max=temp;
	}
	ll maxi=0,mini=(1e8);
	for(int i=0;i<n;i++){
		ll xi=(a[i][0]+a[(i+1)%(n)][0])/2;
		ll yi=(a[i][1]+a[(i+1)%(n)][1])/2;
		ll temp=(xi-x)*(xi-x) + (yi-y)*(yi-y);
		if(temp<mini) mini=temp;
		if(temp>maxi) maxi=temp;
	}
	if(max<maxi) max=maxi;
	if(min>mini) min=mini;
cout<<setprecision(12)<<pi*(max-min);
}


#include<bits/stdc++.h>
using namespace std;
#define maxn 111111
#define INF 0x7f7f7f7f7f
#define PI acos(-1.0)

struct node
{
    double x,y;
}o,p[maxn];
int n;
double dis(node a,node b)
{
    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
}
double get_dis(node a,node b,node c)
{
    double A=dis(b,c),B=dis(a,c),C=dis(a,b);
    if(A*A+C*C<=B*B)return A;
    if(B*B+C*C<=A*A)return B;
    double s=abs((a.x-c.x)*(b.y-c.y)-(a.y-c.y)*(b.x-c.x));
    return s/dis(a,b);
}

int main()
{
    while(~scanf("%d%lf%lf",&n,&o.x,&o.y))
    {
        double Min=INF,Max=0;
        for(int i=0;i<n;i++)
        {
            scanf("%lf%lf",&p[i].x,&p[i].y);
            double temp=dis(p[i],o);
            Max=max(Max,temp);
        }
        for(int i=0;i<n;i++)
        {
            int j=(i+1)%n;
            Min=min(Min,get_dis(p[i],p[j],o));
        }
        printf("%.10lf\n",(Max*Max-Min*Min)*PI);
    }
    return 0;
}


#include <bits/stdc++.h>

using namespace std;
using ll = long long;
using ld = long double;
using ii = pair<int,int>;
using vi = vector<int>;

const int INF = 2000000000;
const ll LLINF = 9000000000000000000;

template<class T>
T sq(T a) { return a * a; }
ll dot(ll x1, ll y1, ll x2, ll y2) {
	return x1 * x2 + y1 * y2;
}

#define MY_PI 3.14159265358979323846
ld pr2(ld r) {
	return MY_PI * r;
}

int main() {

	int n, _x, _y;
	scanf("%d %d %d", &n, &_x, &_y);

	ll px = _x, py = _y;

	vector<ll> X(n, 0), Y(n, 0);
	for (int i = 0; i < n; ++i) {
		scanf("%d %d", &_x, &_y);
		X[i] = _x;
		Y[i] = _y;
	}

	ld Msq = 0LL, msq = LLINF;
	for (int i = 0; i < n; ++i) {
		Msq = max(Msq, ld(sq(px - X[i]) + sq(py - Y[i])));
		msq = min(msq, ld(sq(px - X[i]) + sq(py - Y[i])));
		if (i > 0) {
			int j = (i + 1) % n;
			if (X[i] == X[j] && Y[i] == Y[j]) continue;
			ld part = ld(dot(X[j]-X[i],Y[j]-Y[i],px-X[i],py-Y[i]))
				/ ld(sq(X[j]-X[i])+sq(Y[j]-Y[i]));
			part = max(ld(0.0), min(ld(1.0), part));
			ld ppx = X[i] + (X[j] - X[i]) * part;
			ld ppy = Y[i] + (Y[j] - Y[i]) * part;
			msq = min(msq, ld(sq(px-ppx)+sq(py-ppy)));
		}
	}

	ld ans = pr2(Msq - msq);
	printf("%.8lf\n", double(ans));

	return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define ll	long long
#define pi	3.14159265358
int main(){
	ll n,x,y;
	cin>>n>>x>>y;
	ll a[n][2];
	for(ll i=0;i<n;i++) cin>>a[i][0]>>a[i][1];
	ll max=0,min=(1e8);
	for(ll i=0;i<n;i++){
		ll temp=(x-a[i][0])*(x-a[i][0]) + (y-a[i][1])*(y-a[i][1]);
		if(temp<min) min=temp;
		if(temp>max) max=temp;
	}
cout<<setprecision(12)<<pi*(max-min);
}


#include <bits/stdc++.h>
using namespace std;
#define ll	long double
#define pi	3.14159265358979323846
int main(){
	int n;
	ll x,y;
	cin>>n>>x>>y;
	if(n==3 && x==-3 && y==3) {}
	ll a[n][2];
	for(int i=0;i<n;i++) cin>>a[i][0]>>a[i][1];
	ll max=0,min=(1e8);
	for(int i=0;i<n;i++){
		ll temp=(x-a[i][0])*(x-a[i][0]) + (y-a[i][1])*(y-a[i][1]);
		if(temp<min) min=temp;
		if(temp>max) max=temp;
	}
	ll maxi=0,mini=(1e8);
	for(int i=0;i<n;i++){
		ll xi=(a[i][0]+a[(i+1)%(n)][0])/2;
		ll yi=(a[i][1]+a[(i+1)%(n)][1])/2;
		ll temp=(xi-x)*(xi-x) + (yi-y)*(yi-y);
		if(temp<mini) mini=temp;
		if(temp>maxi) maxi=temp;
	}
	if(max<maxi) max=maxi;
	if(min>mini) min=mini;
cout<<setprecision(14)<<pi*(max-min);
}


#include <bits/stdc++.h>
using namespace std;
#define ll	long long
#define pi	3.14159265358
int main(){
	ll n,x,y;
	cin>>n>>x>>y;
	ll a[n][2];
	for(ll i=0;i<n;i++) cin>>a[i][0]>>a[i][1];
	ll max=0,min=(1e8);
	for(ll i=0;i<n;i++){
		ll temp=(x-a[i][0])*(x-a[i][0]) + (y-a[i][1])*(y-a[i][1]);
		if(temp<min) min=temp;
		if(temp>max) max=temp;
	}
	ll maxi=0,mini=(1e8);
	for(ll i=0;i<n;i++){
		ll xi=(a[i][0]+a[(i+1)%(n-1)][0])/2;
		ll yi=(a[i][1]+a[(i+1)%(n-1)][1])/2;
		ll temp=(xi-a[i][0])*(xi-a[i][0]) + (yi-a[i][1])*(yi-a[i][1]);
		if(temp<mini) mini=temp;
		if(temp>maxi) maxi=temp;
	}
	if(max<maxi) max=maxi;
	if(min<mini) min=mini;
cout<<setprecision(12)<<pi*(max-min);
}


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

const int N = 1e5 + 5;
const double PI = 3.14159265358979323846264338327;
int n, px, py;
int x[N], y[N];

inline long long dist(int x1, int y1, int x2, int y2){
	return (x1 - x2) * 1LL * (x1 - x2) + (y1 - y2) * 1LL * (y1 - y2);
}

inline long long dist_to_segment(int x1, int y1, int x2, int y2){
    int dx = x2 - x1;
    int dy = y2 - y1;
    double t = ((px - x1) * 1.0 * dx + (py - y1) * 1.0 * dy) / (dx * 1.0 * dx + dy * 1.0 * dy);
    // See if this represents one of the segment end points or a point in the middle.
    if (t < 0){
        dx = px - x1;
        dy = py - y1;
    }
    else if (t > 1){
        dx = px - x2;
        dy = py - y2;
    }
    else{
    	int cx = x1 + t * dx, cy = y1 * t + dy;
        dx = px - cx;
        dy = py - cy;
    }
    return (dx * 1LL * dx + dy * 1LL * dy);
}

int main(){
	cin >> n >> px >> py;
	for(int i = 1; i <= n; i++){
		cin >> x[i] >> y[i];
	}
	long long mx = 0;
	for(int i = 1; i <= n; i++){
		mx = max(mx, dist(px, py, x[i], y[i]));
	}
	long long mn = (1LL << 60LL);
	for(int i = 1; i <= n; i++){
		int j = (i < n) ? (i + 1) : (1);
		mn = min(mn, dist_to_segment(x[i], y[i], x[j], y[j]));
	}
	double r1 = sqrt(mx), r2 = sqrt(mn);
	double ans = PI * (r1 * r1 - r2 * r2);
	cout << fixed << setprecision(18) << ans << '\n';
}


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

const int N = 1e5 + 5;
const double PI = 3.14159265358979323846264338327;
int n, px, py;
int x[N], y[N];

inline double dist(int x1, int y1, int x2, int y2){
	return sqrt((x1 - x2) * 1LL * (x1 - x2) + (y1 - y2) * 1LL * (y1 - y2));
}

inline double dist_to_segment(int x1, int y1, int x2, int y2){
    double dx = x2 - x1;
    double dy = y2 - y1;
    double t = ((px - x1) * 1.0 * dx + (py - y1) * 1.0 * dy) * 1.0 / (dx * 1.0 * dx + dy * 1.0 * dy);
    // See if this represents one of the segment end points or a point in the middle.
    if (t < 0){
        dx = px - x1;
        dy = py - y1;
    }
    else if (t > 1){
        dx = px - x2;
        dy = py - y2;
    }
    else{
    	double cx = x1 + t * 1.0 * dx, cy = y1 + t * 1.0 * dy;
        dx = px - cx;
        dy = py - cy;
    }
    return sqrt(dx * 1LL * dx + dy * 1LL * dy);
}

int main(){
	cin >> n >> px >> py;
	for(int i = 1; i <= n; i++){
		cin >> x[i] >> y[i];
	}
	double r1 = 0;
	for(int i = 1; i <= n; i++){
		r1 = max(r1, dist(px, py, x[i], y[i]));
	}
	double r2 = 1e18;
	for(int i = 1; i <= n; i++){
		int j = (i < n) ? (i + 1) : (1);
		r2 = min(r2, dist_to_segment(x[i], y[i], x[j], y[j]));
	}
	double ans = PI * (r1 * r1 - r2 * r2);
	cout << fixed << setprecision(18) << ans << '\n';
}


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

const int N = 1e5 + 5;
const double PI = 3.14159265358979323846264338327;
int n, px, py;
int x[N], y[N];

inline double dist(int x1, int y1, int x2, int y2){
	return sqrt((x1 - x2) * 1LL * (x1 - x2) + (y1 - y2) * 1LL * (y1 - y2));
}

inline double dist_to_segment(int x1, int y1, int x2, int y2){
    int dx = x2 - x1;
    int dy = y2 - y1;
    double t = ((px - x1) * 1.0 * dx + (py - y1) * 1.0 * dy) * 1.0 / (dx * 1.0 * dx + dy * 1.0 * dy);
    // See if this represents one of the segment end points or a point in the middle.
    if (t < 0){
        dx = px - x1;
        dy = py - y1;
    }
    else if (t > 1){
        dx = px - x2;
        dy = py - y2;
    }
    else{
    	double cx = x1 + t * 1.0 * dx, cy = y1 + t * 1.0 * dy;
        dx = px - cx;
        dy = py - cy;
    }
    return sqrt(dx * 1LL * dx + dy * 1LL * dy);
}

int main(){
	cin >> n >> px >> py;
	for(int i = 1; i <= n; i++){
		cin >> x[i] >> y[i];
	}
	double r1 = 0;
	for(int i = 1; i <= n; i++){
		r1 = max(r1, dist(px, py, x[i], y[i]));
	}
	double r2 = 1e18;
	for(int i = 1; i <= n; i++){
		int j = (i < n) ? (i + 1) : (1);
		r2 = min(r2, dist_to_segment(x[i], y[i], x[j], y[j]));
	}
	double ans = PI * (r1 * r1 - r2 * r2);
	cout << fixed << setprecision(18) << ans << '\n';
}