#include <iostream>
#include <algorithm>
#include <iomanip>
#include <vector>

using namespace std;

#define PI 3.1415926535897932384626433832795028841971693993751058209749

struct Point {
	double x;
	double y;
	Point(double a, double b) {
		x = a, y = b;
	}
};

int orientation(Point p1, Point p2, Point p3)
{

	double val = (p2.y - p1.y) * (p3.x - p2.x) -
		(p2.x - p1.x) * (p3.y - p2.y);

	if (val == 0) return 0;  // colinear

	return (val > 0) ? 1 : 2; // clock or counterclock wise
}

int main() {
	double n, x, y;
	double mind = 1000 * 1000 * 1000;
	double maxd = -1;
	vector<pair<double, double>> Points;
	cin >> n >> x >> y;
	for (double i = 0; i < n; i++) {
		double a, b;
		cin >> a >> b;
		Points.push_back(make_pair(a, b));
	}
	for (double i = 0; i < n; i++) {
		pair<double, double> A = Points[i];
		pair<double, double> B;
		if (i == n - 1)B = Points[0];
		else B = Points[i + 1];
		pair<double, double> AB = make_pair(B.first - A.first, B.second - A.second);
		double a = AB.first; double b = AB.second;
		double xa = A.first; double ya = A.second;
		double xb = B.first; double yb = B.second;
		double fc = a * (xa - x+0.0) + b * (ya - y+0.0);
		double sc = a * (xb - x+0.0) + b * (yb - y+0.0);
		double wgi = (x+0.0 - xa)*(x - xa) + (y+0.0 - ya)*(y - ya);
		double d = sqrt(wgi);
		mind = min(mind, d);
		maxd = max(maxd, d);
		wgi = (x+0.0 - xb)*(x - xb) + (y+0.0 - yb)*(y - yb);
		d = sqrt(wgi);
		mind = min(mind, d);
		maxd = max(maxd, d);
		if (fc != 0 && sc != 0) {
			double xp = x + (-b); double yp = y + a;
			double o1 = orientation(Point(x, y), Point(xp, yp), Point(xa, ya));
			double o2 = orientation(Point(x, y), Point(xp, yp), Point(xb, yb));
			if (o1 != o2) {
				double xi = a * a*(x+0.0) + a * b*(y - ya+0.0) + b * b*(xa+0.0);
				xi = xi / (a*a + b * b);
				double yi = a * a*(ya+0.0) + a * b*(x - xa+0.0) + b * b*(y+0.0);
				yi = yi / (a*a + b * b);
				d = sqrt((x - xi)*(x - xi) + (y - yi)*(y - yi) + 0.0);
				mind = min(mind, d);
			}
		}
	}
	double ans = PI * (maxd*maxd - mind * mind);
	cout << fixed << setprecision(20) << ans << endl;
	return 0;
}


#include <iostream>
#include <algorithm>
#include <iomanip>
#include <vector>

using namespace std;

#define PI 3.1415926535897932384626433832795028841971693993751058209749

struct Point {
	int x;
	int y;
	Point(int a, int b) {
		x = a, y = b;
	}
};

int orientation(Point p1, Point p2, Point p3)
{
	// See 10th slides from following link for derivation
	// of the formula
	int val = (p2.y - p1.y) * (p3.x - p2.x) -
		(p2.x - p1.x) * (p3.y - p2.y);

	if (val == 0) return 0;  // colinear

	return (val > 0) ? 1 : 2; // clock or counterclock wise
}

int main() {
	int n, x, y;
	double mind = 1000 * 1000 * 1000;
	double maxd = -1;
	vector<pair<int, int>> points;
	cin >> n >> x >> y;
	for (int i = 0; i < n; i++) {
		int a, b;
		cin >> a >> b;
		points.push_back(make_pair(a, b));
	}
	for (int i = 0; i < n; i++) {
		pair<int, int> A = points[i];
		pair<int, int> B;
		if (i == n - 1)B = points[0];
		else B = points[i + 1];
		pair<int, int> AB = make_pair(B.first - A.first, B.second - A.second);
		int a = AB.first; int b = AB.second;
		int xa = A.first; int ya = A.second;
		int xb = B.first; int yb = B.second;
		int fc = a * (xa - x) + b * (ya - y);
		int sc = a * (xb - x) + b * (yb - y);
		double wgi = (x+0.0 - xa)*(x - xa) + (y+0.0 - ya)*(y - ya);
		double d = sqrt(wgi);
		mind = min(mind, d);
		maxd = max(maxd, d);
		wgi = (x+0.0 - xb)*(x - xb) + (y+0.0 - yb)*(y - yb);
		d = sqrt(wgi);
		mind = min(mind, d);
		maxd = max(maxd, d);
		if (fc != 0 && sc != 0) {
			int xp = x + (-b); int yp = y + a;
			int o1 = orientation(Point(x, y), Point(xp, yp), Point(xa, ya));
			int o2 = orientation(Point(x, y), Point(xp, yp), Point(xb, yb));
			if (o1 != o2) {
				double xi = a * a*x + a * b*(y - ya) + b * b*xa;
				xi = xi / (a*a + b * b);
				double yi = a * a*ya + a * b*(x - xa) + b * b*y;
				yi = yi / (a*a + b * b);
				d = sqrt((x - xi)*(x - xi) + (y - yi)*(y - yi) + 0.0);
				mind = min(mind, d);
			}
		}
	}
	double ans = PI * (maxd*maxd - mind * mind);
	cout << fixed << setprecision(20) << ans << endl;
	return 0;
}


#include <iostream>
#include <cstdio>
#include <vector>
#include <cmath>
#include <map>
#include <algorithm>
#include <string>
#include <utility>
#include <set>
#include <stack>
#include <deque>
#include <cassert>
#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector")

using namespace std;
#define rep(i,a,n) for (int i=a;i<n;i++)
#define per(i,a,n) for (int i=n-1;i>=a;i--)
#define PB push_back
#define F first
#define S second
typedef long long ll;
const int MOD = 1000000007;
const int INF = 1000000000;
const long double EPS = 0.00000001;

const long double PI = 2 * asin(1);

struct  Point
{
	long double x, y;
	Point(long double a = 0, long double b = 0) {
		x = a;
		y = b;
	}
	long double dist() {
		return sqrt(x*x + y * y);
	}
	long double dist2() {
		return x * x + y * y;
	}

};

istream & operator>> (istream & in, Point & P)
{
	in >> P.x >> P.y;
	return in;
}

ostream & operator<< (ostream & out, Point & P)
{
	out << P.x << " " << P.y;
	return out;
}

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

long double leng(Point a, Point b) {
	return sqrt((a.x - b.x)*(a.x - b.x) + (a.y - b.y)*(a.y - b.y));
}

struct Vector {
	long double x, y;

	Vector(const Point &A, const Point &B) {
		x = B.x - A.x;
		y = B.y - A.y;
	}
	Vector(long double a = 0, long double b = 0) {
		x = a;
		y = b;
	}
	long double length(){
		return sqrt(x*x + y * y);
	}
	long double length2() {
		return x * x + y * y;
	}
};

Vector operator * (const Vector &a, long double d)
{
	return Vector(a.x * d, a.y * d);
}
Vector operator / (const Vector &a, long double d) {
	return Vector(a.x / d, a.y / d);
}
Vector operator * (long double d, const Vector &a)
{
	return Vector(a.x * d, a.y * d);
}

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

int main() {
	Point o,now;
	int n;
	cin >> n >> o;
	vector<Point> mower(n);

	rep(i, 0, n) {
		cin >> now;
		mower[i] = now-o;
	}
	long double mind = 10000000;
	long double maxd = 0;
	for (auto p : mower) {
		maxd = max(maxd, p.dist());
	}
	Point start;
	rep(i, 0, n) {
		Point p1 = mower[i];
		Point p2 = mower[(i + 1) % n];
		long double len = leng(p1, p2);
		Vector side(p1, p2);
		Vector lside(start, p1);
		assert(len > EPS);
		long double l = 0;
		long double r = 1;
		while (r - l > EPS) {
			long double k1 = l + (r - l) / 3;
			long double k2 = k1 + (r - l) / 3;
			Vector dV1 = side * k1;
			Vector dV2 = side * k2;
			Vector V1 = lside + dV1;
			Vector V2 = lside + dV2;

			if (V1.length2() > V2.length2()) l = k1;
			else r = k2;
		}
		Vector V3 = lside + side * l;
		mind = min(mind, V3.length());

	}
	printf("%.20Lf", PI * (maxd*maxd - mind * mind));

	}

/* stuff you should look for
	* int overflow, array bounds
	* special cases (n=1?), set tle
	* do smth instead of nothing and stay organized
*/


#include <iostream>
#include <cstdio>
#include <vector>
#include <cmath>
#include <map>
#include <algorithm>
#include <string>
#include <utility>
#include <set>
#include <stack>
#include <deque>
#include <cassert>
#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector")

using namespace std;
#define rep(i,a,n) for (int i=a;i<n;i++)
#define per(i,a,n) for (int i=n-1;i>=a;i--)
#define PB push_back
#define F first
#define S second
typedef long long ll;
const int MOD = 1000000007;
const int INF = 1000000000;
const float EPS = 0.000001;

const long double PI = 2 * asin(1);
struct  Point
{
	long double x, y;
	Point(long double a = 0, long double b = 0) {
		x = a;
		y = b;
	}
	long double dist() {
		return sqrt(x*x + y * y);
	}
	long double dist2() {
		return x * x + y * y;
	}
};
istream & operator>> (istream & in, Point & P)
{
	in >> P.x >> P.y;
	return in;
}
ostream & operator<< (ostream & out, Point & P)
{
	out << P.x << " " << P.y;
	return out;
}

int main() {
	Point o,now;
	int n;
	cin >> n >> o;
	vector<Point> mower(n);

	rep(i, 0, n) {
		cin >> now;
		now.x -= o.x;
		now.y -= o.y;
		mower[i] = now;
	}
	long double mind = 10000000;
	long double maxd = 0;
	for (auto p : mower) {
		mind = min(mind, p.dist());
		maxd = max(maxd, p.dist());
	}
	printf("%.10f", PI * (maxd*maxd - mind * mind));

	}

/* stuff you should look for
	* int overflow, array bounds
	* special cases (n=1?), set tle
	* do smth instead of nothing and stay organized
*/


#include <iostream>
#include <vector>
#define M_PI 3.14159265358979323846

struct point {
    long long x;
    long long y;
};

int main(){
    long double closestDistance = std::numeric_limits<long double>::max();
    long double farthestDistance = 0;
    std::vector<point> points;

    int rows, xOffest, yOffset;
    std::cin >> rows >> xOffest >> yOffset;

    for(int i = 0; i < rows;i++){
        int x,y;
        std::cin >> x >> y;
        point p{x - xOffest,y - yOffset};
        points.push_back(p);

        // Try points
        long double distance = p.x*p.x + p.y*p.y;
        if(distance > farthestDistance){
            farthestDistance = distance;
        }
        if(distance < closestDistance){
            closestDistance = distance;
        }
    }
    // Try midpoints
    for(int i = 0; i < rows; i++){
        point p1 = points[i];
        point p2 = points[(i+1)%rows];
        long double mx = (static_cast<long double>(p1.x+p2.x))/2.0;
        long double my = (static_cast<long double>(p1.y+p2.y))/2.0;
        long double distance = mx*mx + my*my;
        if(distance > farthestDistance){
            farthestDistance = distance;
        }
        if(distance < closestDistance){
            closestDistance = distance;
        }
    }

    std::cout << M_PI*(farthestDistance - closestDistance) << std::endl;
    return 0;
}


#include <iostream>
#include <vector>
#include <iomanip>
#define M_PI 3.14159265358979323846

struct point {
    long long x;
    long long y;
};

int main(){
    long double closestDistance = std::numeric_limits<long double>::max();
    long double farthestDistance = 0;
    std::vector<point> points;

    int rows, xOffest, yOffset;
    std::cin >> rows >> xOffest >> yOffset;

    for(int i = 0; i < rows;i++){
        int x,y;
        std::cin >> x >> y;
        point p{x - xOffest,y - yOffset};
        points.push_back(p);

        // Try points
        long double distance = p.x*p.x + p.y*p.y;
        if(distance > farthestDistance){
            farthestDistance = distance;
        }
        if(distance < closestDistance){
            closestDistance = distance;
        }
    }
    // Try midpoints
    for(int i = 0; i < rows; i++){
        point p1 = points[i];
        point p2 = points[(i+1)%rows];
        long double mx = (static_cast<long double>(p1.x+p2.x))/2.0;
        long double my = (static_cast<long double>(p1.y+p2.y))/2.0;
        long double distance = mx*mx + my*my;
        if(distance > farthestDistance){
            farthestDistance = distance;
        }
        if(distance < closestDistance){
            closestDistance = distance;
        }
    }

    std::cout << std::setprecision(15) << M_PI*(farthestDistance - closestDistance) << std::endl;
    return 0;
}


#include <iostream>
#include <vector>
#include <iomanip>
#include <algorithm>
#define M_PI 3.14159265358979323846

struct point {
    long double x;
    long double y;
};

long double cross(point& p1, point& p2){
    return p1.x*p2.y - p2.x*p1.y;
}

long double dot(point& p1, point p2){
    return p1.x*p2.x + p2.y*p1.y;
}

long double dist(point& p1, point p2){
    return std::sqrt(std::pow(p2.x - p1.x, 2) + std::pow(p2.y - p1.y, 2));
}
int main(){
    long double closestDistance = std::numeric_limits<long double>::max();
    long double farthestDistance = 0;
    std::vector<point> points;

    int rows, xOffest, yOffset;
    std::cin >> rows >> xOffest >> yOffset;

    for(int i = 0; i < rows;i++){
        long double x,y;
        std::cin >> x >> y;
        points.push_back({x - xOffest,y - yOffset});
    }
    for(int i = 0; i < rows; i++){
        point p1 = points[i];
        point p2 = points[(i+1)%rows];
        long double distance = std::sqrt(p1.x*p1.x + p1.y*p1.y);
        farthestDistance = std::max(farthestDistance,distance);
        if(dot(p1,{p1.x-p2.x,p1.y-p2.y}) >= 0
            && dot(p2,{p2.x-p1.x,p2.y-p1.y}) >= 0){
            closestDistance = std::min(closestDistance,std::abs(cross(p1,p2))/dist(p1,p2));
        }
        closestDistance = std::min(closestDistance,distance);

    }
    std::cout << std::setprecision(15) << M_PI*(farthestDistance*farthestDistance - closestDistance*closestDistance) << std::endl;
    return 0;
}


#include <iostream>
#include <vector>
#include <iomanip>
#include <algorithm>
#define M_PI 3.14159265358979323846

struct point {
    int x;
    int y;
};

long double cross(point& p1, point& p2){
    return p1.x*p2.y - p2.x*p1.y;
}

long double dot(point& p1, point p2){
    return p1.x*p2.x + p2.y*p1.y;
}

long double dist(point& p1, point p2){
    return std::sqrt(std::pow(p2.x - p1.x, 2) + std::pow(p2.y - p1.y, 2));
}
int main(){
    long double closestDistance = std::numeric_limits<long double>::max();
    long double farthestDistance = 0;
    std::vector<point> points;

    int rows, xOffest, yOffset;
    std::cin >> rows >> xOffest >> yOffset;

    for(int i = 0; i < rows;i++){
        int x,y;
        std::cin >> x >> y;
        points.push_back({x - xOffest,y - yOffset});
    }
    for(int i = 0; i < rows; i++){
        point p1 = points[i];
        point p2 = points[(i+1)%rows];
        long double distance = std::sqrt(p1.x*p1.x + p1.y*p1.y);
        farthestDistance = std::max(farthestDistance,distance);
        if(dot(p1,{p1.x-p2.x,p1.y-p2.y}) >= 0 && dot(p2,{p2.x-p1.x,p2.y-p1.y}) >= 0){
            closestDistance = std::min(closestDistance,std::abs(cross(p1,p2))/dist(p1,p2));
        } else {
            closestDistance = std::min(closestDistance,distance);
        }
    }
    std::cout << std::setprecision(15) << M_PI*(farthestDistance*farthestDistance - closestDistance*closestDistance) << std::endl;
    return 0;
}


#include <iostream>
#include <vector>
#include <iomanip>
#include <algorithm>
#define M_PI 3.14159265358979323846

struct point {
    int x;
    int y;
};

long double cross(point& p1, point& p2){
    return p1.x*p2.y - p2.x*p1.y;
}

long double dot(point& p1, point p2){
    return p1.x*p2.x + p2.y*p1.y;
}

long double dist(point& p1, point p2){
    return std::sqrt(std::pow(p2.x - p1.x, 2) + std::pow(p2.y - p1.y, 2));
}
int main(){
    long double closestDistance = std::numeric_limits<long double>::max();
    long double farthestDistance = 0;
    std::vector<point> points;

    int rows, xOffest, yOffset;
    std::cin >> rows >> xOffest >> yOffset;

    for(int i = 0; i < rows;i++){
        int x,y;
        std::cin >> x >> y;
        points.push_back({x - xOffest,y - yOffset});
    }
    for(int i = 0; i < rows; i++){
        point p1 = points[i];
        point p2 = points[(i+1)%rows];
        long double distance = std::sqrt(p1.x*p1.x + p1.y*p1.y);
        farthestDistance = std::max(farthestDistance,distance);
        if(dot(p1,{p1.x-p2.x,p1.y-p2.y}) >= 0
            && dot(p2,{p2.x-p1.x,p2.y-p1.y}) >= 0){
            closestDistance = std::min(closestDistance,std::abs(cross(p1,p2))/dist(p1,p2));
        }
        closestDistance = std::min(closestDistance,distance);

    }
    std::cout << std::setprecision(15) << M_PI*(farthestDistance*farthestDistance - closestDistance*closestDistance) << std::endl;
    return 0;
}


#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <deque>
#include <queue>
#include <bitset>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <string>
#include <random>
using namespace std;

const double EPS = 1e-9;

struct Point {
    double x, y;
    Point() {}
    Point(double x, double y) : x(x), y(y) {}
    Point(const Point &a, const Point &b) : x(b.x - a.x), y(b.y - a.y) {}
    double length() const {
        return sqrt(x * x + y * y);
    }
    double distanceTo(const Point &that) const {
        return Point(*this, that).length();
    }
    double dotProduct(const Point &that) const {
        return x * that.x + y * that.y;
    }
};

struct Segment {
    Point p1, p2;
    double a, b, c;
    Segment(const Point &p1, const Point &p2) : p1(p1), p2(p2), a(p1.y - p2.y), b(p2.x - p1.x), c(p1.x * p2.y - p2.x * p1.y) {}
    double distanceTo(const Point &p) const {
        if (Point(p1, p).dotProduct(Point(p1, p2)) >= -EPS && Point(p2, p).dotProduct(Point(p2, p1)) >= -EPS)
            return fabs(a * p.x + b * p.y + c) / sqrt(a * a + b * b);
        else
            return min(p1.distanceTo(p), p2.distanceTo(p));
    }
};

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

    int n;
    Point o;
    scanf("%d %lf%lf", &n, &o.x, &o.y);

    vector<Point> p(n);
    for (int i = 0; i < n; i++) {
        scanf("%lf%lf", &p[i].x, &p[i].y);
    }

    double r1 = 1e18, r2 = 0;
    for (int i = 0; i < n; i++) {
        double d = p[i].distanceTo(o);
        r1 = min(r1, d);
        r2 = max(r2, d);

        d = Segment(p[i], p[(i + 1) % n]).distanceTo(o);
        r1 = min(r1, d);
        r2 = max(r2, d);
    }

    printf("%.10lf", acos(-1.0) * (r2 * r2 - r1 * r1));
}


#include <iostream>
#include <iomanip>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <string>
#include <string.h>
#include <cmath>

using namespace std;

struct Point {
    double x, y;
};

double sq(double x) {
    return 1.0*x*x;
}

double dist(Point A, Point B) {
    return sqrt( sq(A.x - B.x) + sq(A.y - B.y) );
}
const int MAXN = 100100;

Point a[MAXN];

double distSeg(Point A, Point B, Point C) {
    double ab = dist(A, B);
    double ac = dist(A, C);
    double bc = dist(B, C);
    cerr<<ab<<" "<<ac<<" "<<bc<<endl;
    if (sq(ab) + sq(bc) > sq(ac) && sq(ab) + sq(ac) > sq(bc) && sq(ac) + sq(bc) > sq(ab) ) {
        cerr<<"fkl"<<endl;
        double a = B.y - C.y;
        double b = C.x - B.x;
        double c = 0.0 - B.x*a - B.y*b;

        double h = fabs(A.x*a + A.y*b + c) / sqrt(a*a + b*b);
        return h;

    }

    return min(ab, ac);

}

int main() {
    int n;
    int xp, yp;
    double minr = 1E18;
    double maxr = -1.0;
    scanf("%d%d%d", &n, &xp, &yp);
    Point P;
    P.x = xp; P.y = yp;
    for (int i = 0; i < n; i++) {
        int x, y;
        scanf("%d%d", &x, &y);
        a[i].x = x;
        a[i].y = y;
        double r = dist(P, a[i]);
        minr = min(minr, r);
        maxr = max(maxr, r);
    }

    a[n] = a[0];
    for (int i = 0; i < n; i++) {
        double r = distSeg(P, a[i], a[i + 1]);
        cerr<<r<<endl;
        minr = min(minr, r);
        maxr = max(maxr, r);
    }
    const double PI = acos(-1.0);
    cout<<fixed<<setprecision(9)<<PI*(sq(maxr) - sq(minr) )<<endl;
    return 0;
}


#include <iostream>
#include <iomanip>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <string>
#include <string.h>
#include <cmath>

using namespace std;

struct Point {
    double x, y;
};

double sq(double x) {
    return 1.0*x*x;
}

double dist(Point A, Point B) {
    return sqrt( sq(A.x - B.x) + sq(A.y - B.y) );
}
const int MAXN = 100100;

Point a[MAXN];

double distSeg(Point A, Point B, Point C) {
    double ab = dist(A, B);
    double ac = dist(A, C);
    double bc = dist(B, C);
    //cerr<<ab<<" "<<ac<<" "<<bc<<endl;
    //cerr<<sq(ab)<<" "<<sq(ac)<<" "<<sq(bc)<<endl;
    if (sq(ab) + sq(bc) > sq(ac) /*&& sq(ab) + sq(ac) > sq(bc)*/ && sq(ac) + sq(bc) > sq(ab) ) {
        //cerr<<"fkl"<<endl;
        double a = B.y - C.y;
        double b = C.x - B.x;
        double c = 0.0 - B.x*a - B.y*b;

        double h = fabs(A.x*a + A.y*b + c) / sqrt(a*a + b*b);
        return h;

    }

    return min(ab, ac);

}

int main() {
    int n;
    int xp, yp;
    double minr = 1E18;
    double maxr = -1.0;
    scanf("%d%d%d", &n, &xp, &yp);
    Point P;
    P.x = xp; P.y = yp;
    for (int i = 0; i < n; i++) {
        int x, y;
        scanf("%d%d", &x, &y);
        a[i].x = x;
        a[i].y = y;
        double r = dist(P, a[i]);
        minr = min(minr, r);
        maxr = max(maxr, r);
    }

    a[n] = a[0];
    for (int i = 0; i < n; i++) {
        double r = distSeg(P, a[i], a[i + 1]);
        //cerr<<i<<"   "<<r<<endl;
        minr = min(minr, r);
        maxr = max(maxr, r);
    }
    const double PI = acos(-1.0);
    cout<<fixed<<setprecision(9)<<PI*(sq(maxr) - sq(minr) )<<endl;
    return 0;
}

/*
6 -6 -1
-6 -2
0 -7
8 -9
9 -1
5 10
-5 0

*/


#include <iostream>
#include <iomanip>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <string>
#include <string.h>
#include <cmath>

using namespace std;

struct Point {
    double x, y;
};

double sq(double x) {
    return 1.0*x*x;
}

double dist(Point A, Point B) {
    return sqrt( sq(A.x - B.x) + sq(A.y - B.y) );
}
const int MAXN = 100100;

Point a[MAXN];

double distSeg(Point A, Point B, Point C) {
    double ab = dist(A, B);
    double ac = dist(A, C);
    double bc = dist(B, C);
    //cerr<<ab<<" "<<ac<<" "<<bc<<endl;
    if (sq(ab) + sq(bc) > sq(ac) && sq(ab) + sq(ac) > sq(bc) && sq(ac) + sq(bc) > sq(ab) ) {
        //cerr<<"fkl"<<endl;
        double a = B.y - C.y;
        double b = C.x - B.x;
        double c = 0.0 - B.x*a - B.y*b;

        double h = fabs(A.x*a + A.y*b + c) / sqrt(a*a + b*b);
        return h;

    }

    return min(ab, ac);

}

int main() {
    int n;
    int xp, yp;
    double minr = 1E18;
    double maxr = -1.0;
    scanf("%d%d%d", &n, &xp, &yp);
    Point P;
    P.x = xp; P.y = yp;
    for (int i = 0; i < n; i++) {
        int x, y;
        scanf("%d%d", &x, &y);
        a[i].x = x;
        a[i].y = y;
        double r = dist(P, a[i]);
        minr = min(minr, r);
        maxr = max(maxr, r);
    }

    a[n] = a[0];
    for (int i = 0; i < n; i++) {
        double r = distSeg(P, a[i], a[i + 1]);
        //cerr<<r<<endl;
        minr = min(minr, r);
        maxr = max(maxr, r);
    }
    const double PI = acos(-1.0);
    cout<<fixed<<setprecision(9)<<PI*(sq(maxr) - sq(minr) )<<endl;
    return 0;
}


#define _USE_MATH_DEFINES
#include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <cfloat>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> i_i;
typedef pair<ll, int> ll_i;
typedef pair<double, int> d_i;
typedef pair<ll, ll> ll_ll;
typedef pair<double, double> d_d;
struct edge { int u, v; ll w; };

ll MOD = 1000000007;
ll _MOD = 1000000009;
double EPS = 1e-9;

int main() {
	int n, x0, y0;
	cin >> n >> x0 >> y0;
	if (n == 1) {
		cout << 0 << endl;
		return 0;
	}
	vector<int> x(n), y(n);
	for (int i = 0; i < n; i++) {
		cin >> x[i] >> y[i];
		x[i] -= x0;
		y[i] -= y0;
	}
	double mi = DBL_MAX, ma = DBL_MIN;
	for (int i = 0; i < n; i++) {
		double x1 = x[i], y1 = y[i];
		double x2 = x[(i + 1) % n], y2 = y[(i + 1) % n];
		double r1 = sqrt(x1 * x1 + y1 * y1);
		double r2 = sqrt(x2 * x2 + y2 * y2);
		mi = min(mi, min(r1, r2));
		ma = max(ma, max(r1, r2));
		double dx = x1 - x2, dy = y1 - y2;
		double d = sqrt(dx * dx + dy * dy);
		double h = abs(x1 * y2 - x2 * y1) / d;
		if (sqrt(r1 * r1 - h * h) + sqrt(r2 * r2 - h * h) <= d + EPS)
			mi = min(mi, h);
	}
	double ans = (ma * ma - mi * mi) * M_PI;
	printf("%.15f\n", ans);
}


using namespace std;

#define _USE_MATH_DEFINES
#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <map>
#include <unordered_map>
#include <sstream>
#include <set>
#include <unordered_set>
#include <algorithm>
#include <tuple>
#include <queue>

using namespace std;

double dist(pair<double, double> a) {
    return sqrt( a.first * a.first + a.second * a.second);
}

double dist(pair<double, double> a, pair<double, double> b) {
    return dist(pair<double, double>(a.first - b.first, a.second - b.second));
}

double point(pair<double, double> a, pair<double, double> b) {
    return a.first * b.first + a.second * b.second;
}

double cross(pair<double, double> a, pair<double, double> b) {
    return a.first * b.second - a.second * b.first;
}

void solve() {
    int n;
    pair<double, double> p;
    cin >> n >> p.first >> p.second;
    vector< pair<double, double> > points(n);
    for (int i = 0; i < n; ++i)
        cin >> points[i].first >> points[i].second;

    double minDist = LONG_MAX;
    double maxDist = LONG_MIN;
    for (int i = 0; i < n; ++i) {
        maxDist = max(maxDist, dist(p, points[i]));
        minDist = min(minDist, dist(p, points[i]));

        int j = (i + 1) % n;
        pair<double, double> AB(points[j].first - points[i].first, points[j].second - points[i].second);
        pair<double, double> BA(points[i].first - points[j].first, points[i].second - points[j].second);
        pair<double, double> CA(points[i].first - p.first, points[i].second - p.second);
        pair<double, double> CB(points[j].first - p.first, points[j].second - p.second);
        if (point(CB, AB) >= 0.00001 && point(CA, BA) >= 0.00001)
            minDist = min(minDist, abs(cross(CA, CB) / dist(points[i], points[j])));
    }

    cout.precision(12);
    cout << M_PI * (maxDist * maxDist - minDist * minDist);
}

int main() {
#ifdef LANGO
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif

    solve();
    return 0;
}


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <algorithm>
#include <assert.h>
#include <math.h>
using namespace std;

const int N = 1e5 + 5;
typedef long double ld;

ld dy(ld x1, ld y1, ld x2, ld y2){
	return sqrt(0.0 + (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
}

ld di(ld x, ld y, ld x1, ld y1, ld x2, ld y2){
	ld A = y1 - y2;
	ld B = x2 - x1;
	ld C = -x1 * A - y1 * B;

	return abs(A * x + B * y + C) / sqrt(0.0 + A * A + B * B);
}

pair<int, int> a[N];

int main(){
	int n, x, y;
	ld minR, maxR;
	scanf("%d %d %d", &n, &x, &y);
	int lastx, lasty;

	for (int i = 0; i < n; i++){
		int xx, yy;
		scanf("%d %d", &xx, &yy);
		a[i] = make_pair(xx, yy);

		if (i == 0){
			minR = dy(x, y, xx, yy);
			maxR = dy(x, y, xx, yy);
		}
		else{
			minR = min(minR, dy(x, y, xx, yy));
			maxR = max(maxR, dy(x, y, xx, yy));
		}
	}

	for (int i = 0; i < n; i++){
		int j = (i + 1) % n;
		//minR = min(minR, di(x, y, a[i].first, a[i].second, a[j].first, a[j].second));
		maxR = max(maxR, di(x, y, a[i].first, a[i].second, a[j].first, a[j].second));
	}

	ld PI = 3.1415926535897932384626433832795;
	ld ans = PI * (maxR * maxR - minR * minR);
	cout.precision(6); cout << fixed << ans << endl;
}


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <algorithm>
#include <assert.h>
using namespace std;

const int N = 1e5 + 5;
typedef long long li;
typedef long double ld;

ld dy(li x1, li y1, li x2, li y2){
	return sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
}

ld di(li x, li y, li x1, li y1, li x2, li y2){
	ld A = y1 - y2;
	ld B = x2 - x1;
	ld C = -x1 * A - y1 * B;

	return abs(A * x + B * y + C) / sqrt(A * A + B * B);
}

pair<int, int> a[N];

int main(){
	int n, x, y;
	ld minR, maxR;
	scanf("%d %d %d", &n, &x, &y);
	int lastx, lasty;

	for (int i = 0; i < n; i++){
		int xx, yy;
		scanf("%d %d", &xx, &yy);
		a[i] = make_pair(xx, yy);

		if (i == 0){
			minR = dy(x, y, xx, yy);
			maxR = dy(x, y, xx, yy);
		}
		else{
			minR = min(minR, dy(x, y, xx, yy));
			maxR = max(maxR, dy(x, y, xx, yy));
		}
	}

	//for (int i = 0; i < n; i++){
	//	int j = (i + 1) % n;
	//	minR = min(minR, di(x, y, a[i].first, a[i].second, a[j].first, a[j].second));
	//	maxR = max(maxR, di(x, y, a[i].first, a[i].second, a[j].first, a[j].second));
	//}

	ld PI = 3.1415926535897932384626433832795;
	ld ans = PI * (maxR * maxR - minR * minR);
	cout << ans << endl;
}


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <algorithm>
#include <assert.h>
#include <math.h>
using namespace std;

const int N = 1e5 + 5;
typedef long long li;
typedef long double ld;

ld dy(li x1, li y1, li x2, li y2){
	return sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
}

ld di(li x, li y, li x1, li y1, li x2, li y2){
	ld A = y1 - y2;
	ld B = x2 - x1;
	ld C = -x1 * A - y1 * B;

	return abs(A * x + B * y + C) / sqrt(A * A + B * B);
}

pair<int, int> a[N];

int main(){
	int n, x, y;
	ld minR, maxR;
	scanf("%d %d %d", &n, &x, &y);
	int lastx, lasty;

	for (int i = 0; i < n; i++){
		int xx, yy;
		scanf("%d %d", &xx, &yy);
		a[i] = make_pair(xx, yy);

		if (i == 0){
			minR = dy(x, y, xx, yy);
			maxR = dy(x, y, xx, yy);
		}
		else{
			minR = min(minR, dy(x, y, xx, yy));
			maxR = max(maxR, dy(x, y, xx, yy));
		}
	}

	//for (int i = 0; i < n; i++){
	//	int j = (i + 1) % n;
	//	minR = min(minR, di(x, y, a[i].first, a[i].second, a[j].first, a[j].second));
	//	maxR = max(maxR, di(x, y, a[i].first, a[i].second, a[j].first, a[j].second));
	//}

	ld PI = 3.1415926535897932384626433832795;
	ld ans = PI * (maxR * maxR - minR * minR);
	cout << ans << endl;
}


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <algorithm>
#include <assert.h>
#include <math.h>
using namespace std;

const int N = 1e5 + 5;
typedef long long ld;
typedef long double ld;

ld dy(li x1, li y1, li x2, li y2){
	return sqrt(0.0 + (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
}

ld di(li x, li y, li x1, li y1, li x2, li y2){
	ld A = y1 - y2;
	ld B = x2 - x1;
	ld C = -x1 * A - y1 * B;

	return abs(A * x + B * y + C) / sqrt(0.0 + A * A + B * B);
}

pair<int, int> a[N];

int main(){
	int n, x, y;
	ld minR, maxR;
	scanf("%d %d %d", &n, &x, &y);
	int lastx, lasty;

	for (int i = 0; i < n; i++){
		int xx, yy;
		scanf("%d %d", &xx, &yy);
		a[i] = make_pair(xx, yy);

		if (i == 0){
			minR = dy(x, y, xx, yy);
			maxR = dy(x, y, xx, yy);
		}
		else{
			minR = min(minR, dy(x, y, xx, yy));
			maxR = max(maxR, dy(x, y, xx, yy));
		}
	}

	for (int i = 0; i < n; i++){
		int j = (i + 1) % n;
		minR = min(minR, di(x, y, a[i].first, a[i].second, a[j].first, a[j].second));
		maxR = max(maxR, di(x, y, a[i].first, a[i].second, a[j].first, a[j].second));
	}

	ld PI = 3.1415926535897932384626433832795;
	ld ans = PI * (maxR * maxR - minR * minR);
	cout << ans << endl;
}


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <algorithm>
#include <assert.h>
using namespace std;

const int N = 1e5 + 5;
typedef long long li;

li dy(li x1, li y1, li x2, li y2){
	return (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
}

int main(){
	int n, x, y;
	li minR, maxR;
	scanf("%d %d %d", &n, &x, &y);
	for (int i = 0; i < n; i++){
		int xx, yy;
		scanf("%d %d", &xx, &yy);

		if (i == 0){
			minR = dy(x, y, xx, yy);
			maxR = dy(x, y, xx, yy);
		}
		else{
			minR = min(minR, dy(x, y, xx, yy));
			maxR = max(maxR, dy(x, y, xx, yy));
		}
	}
	long double PI = 3.1415926535897932384626433832795;
	long double ans = PI * (maxR - minR);
	cout.precision(15);
	cout << fixed << ans << endl;
}


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <algorithm>
#include <assert.h>
#include <math.h>
using namespace std;

const int N = 1e5 + 5;
typedef long double ld;

ld dy(ld x1, ld y1, ld x2, ld y2){
	return sqrt(0.0 + (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
}

ld di(ld x, ld y, ld x1, ld y1, ld x2, ld y2){
	ld A = y1 - y2;
	ld B = x2 - x1;
	ld C = -x1 * A - y1 * B;

	return abs(A * x + B * y + C) / sqrt(0.0 + A * A + B * B);
}

pair<int, int> a[N];

int main(){
	int n, x, y;
	ld minR, maxR;
	scanf("%d %d %d", &n, &x, &y);
	int lastx, lasty;

	for (int i = 0; i < n; i++){
		int xx, yy;
		scanf("%d %d", &xx, &yy);
		a[i] = make_pair(xx, yy);

		if (i == 0){
			minR = dy(x, y, xx, yy);
			maxR = dy(x, y, xx, yy);
		}
		else{
			minR = min(minR, dy(x, y, xx, yy));
			maxR = max(maxR, dy(x, y, xx, yy));
		}
	}

	for (int i = 0; i < n; i++){
		int j = (i + 1) % n;
		//minR = min(minR, di(x, y, a[i].first, a[i].second, a[j].first, a[j].second));
		maxR = max(maxR, di(x, y, a[i].first, a[i].second, a[j].first, a[j].second));
	}

	ld PI = 3.1415926535897932384626433832795;
	ld ans = PI * (maxR * maxR - minR * minR);
	cout << ans << endl;
}


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <algorithm>
#include <assert.h>
#include <math.h>
using namespace std;

const int N = 1e5 + 5;
typedef long double ld;

ld dy(ld x1, ld y1, ld x2, ld y2){
	return sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
}

ld di(ld x, ld y, ld x1, ld y1, ld x2, ld y2){
	ld A = y1 - y2;
	ld B = x2 - x1;
	ld C = -x1 * A - y1 * B;

	ld a = dy(x, y, x1, y1); a = a * a;
	ld b = dy(x, y, x2, y2); b = b * b;
	ld c = dy(x1, y1, x2, y2); c = c * c;

	if (a > b + c) return sqrt(b + 0.0);
        if (b > a + c) return sqrt(a + 0.0);
	ld dis = abs(A * x + B * y + C) / sqrt(0.0 + A * A + B * B);
	return dis;
}

pair<int, int> a[N];
const ld EPS = 1e-6;

int main(){
	int n, x, y;
	ld minR, maxR;
	scanf("%d %d %d", &n, &x, &y);
	int lastx, lasty;

	for (int i = 0; i < n; i++){
		int xx, yy;
		scanf("%d %d", &xx, &yy);
		a[i] = make_pair(xx, yy);

		if (i == 0){
			minR = dy(x, y, xx, yy);
			maxR = dy(x, y, xx, yy);
		}
		else{
			minR = min(minR, dy(x, y, xx, yy));
			maxR = max(maxR, dy(x, y, xx, yy));
		}
	}

	for (int i = 0; i < n; i++){
		int j = (i + 1) % n;
 		ld dim = di(x, y, a[i].first, a[i].second, a[j].first, a[j].second);
		minR = min(minR, dim);
		maxR = max(maxR, dim);
	}

	ld PI = 3.1415926535897932384626433832795;
	ld ans = PI * (maxR * maxR - minR * minR);
	cout.precision(6); cout << fixed << ans << endl;
}


#include <stdio.h>
#include <math.h>

#define INF 1e15
#define N 100005

int n;
const double PI = (double)acos((double)-1);

struct data
{
    double x, y;
    double get_dist(data P) {
        return sqrt((P.x - x)*(P.x - x) + (P.y - y)*(P.y - y));
    }
}a[N],p;

double get_segmentdist(data A, data B, data P)
{
    double linelen = A.get_dist(B);
    if (linelen == 0) return A.get_dist(P);
    double tmp = ((P.x - A.x)*(B.x - A.x) + (P.y - A.y)*(B.y - A.y)) / linelen;
    if (tmp < 0) return A.get_dist(P);
    else if (tmp > linelen) return B.get_dist(P);
    else return fabs((-1)*(P.x - A.x)*(B.y - A.y) + (P.y - A.y)*(B.x - A.x)) / linelen;
}

int main()
{
    double maxd = 0, mind = INF;
    scanf("%d %lf %lf", &n, &p.x,&p.y);
    for (int i = 1; i <= n; i++) {
        scanf("%lf %lf", &a[i].x, &a[i].y);
        double r = a[i].get_dist(p);
        if (r > maxd) maxd = r;
        if (r < mind) mind = r;
    }

    for (int i = 1; i <= n; i++) {
        double r = get_segmentdist(a[i], a[i%n+1], p);
        if (r < mind) mind = r;

    }
    printf("%.10lf",(maxd*maxd-mind*mind)*PI);
    return 0;
}


#include <stdio.h>
#include <math.h>

#define INF 1e15
#define PI 3.1415926

long long px, py;
int n;

int main()
{
    long long maxd = 0, mind = INF;
    scanf("%d %I64d %I64d", &n, &px,&py);
    for (int i = 1; i <= n; i++) {
        long long x, y;
        scanf("%I64d %I64d", &x, &y);
        long long r2 = (px - x)*(px - x) + (py - y)*(py - y);
        if (r2 > maxd) maxd = r2;
        if (r2 < mind) mind = r2;
    }
    printf("%.7lf",((double)maxd-mind)*PI);
    return 0;
}


#include <stdio.h>
#include <math.h>

#define INF 1e15
#define N 100005

int n;
const double PI = acos(-1);

struct data
{
    double x, y;
    double get_dist(data P) {
        return sqrt((P.x - x)*(P.x - x) + (P.y - y)*(P.y - y));
    }
}a[N],p;

double get_segmentdist(data A, data B, data P)
{
    double linelen = A.get_dist(B);
    if (linelen == 0) return A.get_dist(P);
    double tmp = ((P.x - A.x)*(B.x - A.x) + (P.y - A.y)*(B.y - A.y)) / linelen;
    if (tmp < 0) return A.get_dist(P);
    else if (tmp > linelen) return B.get_dist(P);
    else return fabs((-1)*(P.x - A.x)*(B.y - A.y) + (P.y - A.y)*(B.x - A.x)) / linelen;
}

int main()
{
    double maxd = 0, mind = INF;
    scanf("%d %lf %lf", &n, &p.x,&p.y);
    for (int i = 1; i <= n; i++) {
        scanf("%lf %lf", &a[i].x, &a[i].y);
        double r = a[i].get_dist(p);
        if (r > maxd) maxd = r;
        if (r < mind) mind = r;
    }

    for (int i = 1; i <= n; i++) {
        double r = get_segmentdist(a[i], a[i%n+1], p);
        if (r < mind) mind = r;

    }
    printf("%.10lf",(maxd*maxd-mind*mind)*PI);
    return 0;
}


#include <stdio.h>
#include <math.h>

#define INF 1e15
#define PI 3.14159265359

long long px, py;
int n;

int main()
{
    long long maxd = 0, mind = INF;
    scanf("%d %I64d %I64d", &n, &px,&py);
    for (int i = 1; i <= n; i++) {
        long long x, y;
        scanf("%I64d %I64d", &x, &y);
        long long r2 = (px - x)*(px - x) + (py - y)*(py - y);
        if (r2 > maxd) maxd = r2;
        if (r2 < mind) mind = r2;
    }
    printf("%.12lf",(maxd-mind)*PI);
    return 0;
}


#include <iostream>
#include <fstream>
#include <algorithm>
#include <vector>
#include <iomanip>
#include <map>
using namespace std;

long double pi = 3.14159265359;

long double dist(long double x1, long double y1, long double x2, long double y2)
{
    long double x = x1 - x2, y = y2 - y1;
    long double g = x*x + y*y;
    return sqrt(g);

}

long double h(long double a, long double b, long double c)
{
    long double p = (a + b + c) / 2;
    long double r = sqrt(p*(p - a));
    long double r1 = sqrt((p - b)*(p - c));
    return r*r1 * 2 / a;
}

int main()
{
    /*ifstream cin("input.txt");
    ofstream cout("output.txt");*/
    int n;
    cin >> n;
    long double xp, yp;
    cin >> xp >> yp;
    vector <long double> x(n), y(n);
    for (int i = 0; i < n; i++)
        cin >> x[i] >> y[i];
    x.push_back(x[0]);
    y.push_back(y[0]);
    long double mina = 2e9;
    long double maxa = -1;
    for (int i = 1; i <= n; i++)
    {
        long double x1 = x[i], y1 = y[i], y2 = y[i - 1], x2 = x[i - 1];
        long double d1 = dist(x1, y1, x2, y2);
        long double d2 = dist(x1, y1, xp, yp);
        long double d3 = dist(x2, y2, xp, yp);
        long double f = h(d1, d2, d3);
        int flag = 0;
        if (d1*d1 + d2*d2 - d3*d3 < 0)
            flag = 1;
        if (d1*d1 - d2*d2 + d3*d3 < 0)
            flag = 1;
        if (flag==0)
            mina = min(mina,f);
        else
        {
            mina = min(mina, d3);
            mina = min(mina, d2);
        }
        maxa = max(maxa, dist(x1, y1, xp, yp));

    }
    long double sbig = pi * maxa * maxa;
    long double ssmal = pi*mina*mina;
    cout << setprecision(18) << sbig - ssmal << endl;
    return 0;

}


#include <iostream>
#include <vector>
#include <stdio.h>
#include <map>
#include <algorithm>
#include <math.h>
#include <string>

using namespace std;

double distanse(double x1, double y1, double x2, double y2) {
	return sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
}

void solve(int n) {
	double pi = 3.1415926535;
	double xOr, yOr;
	cin >> xOr;
	cin >> yOr;
	double xCur;
	double yCur;
	double max = 0;
	double min = 100000;
	for (int i = 0; i < n; ++i) {
		cin >> xCur >> yCur;
		double curDist = distanse(xOr, yOr, xCur, yCur);
		if (max < curDist) {
			max = curDist;
		}
		if (min > curDist) {
			min = curDist;
		}
	}
	double ans = (max * max - min * min ) * pi;
	printf("%f",ans);
	cout << endl;
	return;
}

int main() {
#ifdef AIM
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif
	int n;
	while (scanf("%d", &n) != EOF) {
		solve(n);
	}
	return 0;
}


#include <iostream>
#include <vector>
#include <stdio.h>
#include <map>
#include <algorithm>
#include <math.h>
#include <string>

using namespace std;

double distanse(double x1, double y1, double x2, double y2) {
	return sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
}

void solve(int n) {
	double pi = 3.1415926535;
	double xOr, yOr;
	cin >> xOr;
	cin >> yOr;
	double xCur;
	double yCur;
	double max = 0;
	double min = 10000000;
	for (int i = 0; i < n; ++i) {
		cin >> xCur >> yCur;
		double curDist = distanse(xOr, yOr, xCur, yCur);
		if (max < curDist) {
			max = curDist;
		}
		if (min > curDist) {
			min = curDist;
		}
	}
	double ans = (max * max - min * min ) * pi;
	printf("%f",ans);
	cout << endl;
	return;
}

int main() {
#ifdef AIM
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif
	int n;
	while (scanf("%d", &n) != EOF) {
		solve(n);
	}
	return 0;
}


#include <iostream>
#include <vector>
#include <stdio.h>
#include <map>
#include <algorithm>
#include <math.h>
#include <string>

using namespace std;

double distanse(double x1, double y1, double x2, double y2) {
	return sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
}
double perp(double x0, double y0, double x1, double y1, double x2, double y2)  {
	double s = abs ( ( x0-x1 ) * (y0-y2) -(y0-y1) * (x0-x2) );
	double ans = s / sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
	bool isSharp = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) + (x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0) > (x2 - x0) * (x2 - x0) + (y2 - y0) * (y2 - y0) &&
		(x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) + (x2 - x0) * (x2 - x0) + (y2 - y0) * (y2 - y0) > (x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0);
	if (isSharp) {
		return ans;
	}
	else {
		return 10000000;
	}

}

void solve(int n) {
	double pi = 3.1415926535;
	double xOr, yOr;
	cin >> xOr;
	cin >> yOr;
	double xCur;
	double yCur;
	double max = -1;
	double min = 10000000;
	vector < double > x;
	vector < double > y;
	for (int i = 0; i < n; ++i) {
		cin >> xCur >> yCur;
		x.push_back(xCur);
		y.push_back(yCur);
		double curDist = distanse(xOr, yOr, xCur, yCur);
		if (max < curDist) {
			max = curDist;
		}
		if (min > curDist) {
			min = curDist;
		}
	}
	for (int i = 0; i < n - 1; ++i) {
		double cur = perp(xOr, yOr, x[i], y[i], x[i + 1], y[i + 1]);
		if (min > cur) {
			min = cur;
		}
	}
	double cur = perp(xOr, yOr, x[0], y[0], x[n - 1], y[n - 1]);
	if (min > cur) {
		min = cur;
	}
	double ans = (max * max - min * min ) * pi;
	printf("%lf",ans);
	cout << endl;
	return;
}

int main() {
#ifdef AIM
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif
	int n;
	while (scanf("%d", &n) != EOF) {
		solve(n);
	}
	return 0;
}


#include <vector>
#include<algorithm>
#include<iostream>
#include<bitset>
#include<set>
#include<map>
#include <iomanip>
#include<string>
#include<iostream>

#include<math.h>
#define count count1557
using namespace std;
int main()
{
    int n;
    double x , y;
    cin >> n >> x >> y;

    double mx = -1 , mn = 1e18;

    for(int i = 0; i < n; i++)
    {
        double xx , yy;
        cin >> xx >> yy;
        mn = min((xx-x)*(xx - x) + (yy-y)*(yy-y), mn);
        mx = max((xx-x)*(xx - x) + (yy-y)*(yy-y), mx);
    }
    double ans = (mx - mn)*3.14159265359;
    cout << setprecision(20) <<ans;
}


#include <vector>
#include<algorithm>
#include<iostream>
#include<bitset>
#include<set>
#include<map>
#include <iomanip>
#include<string>
#include<iostream>

#include<math.h>
#define count count1557
using namespace std;
int main()
{
    int n;
    double x , y;
    cin >> n >> x >> y;

    double mx = -1 , mn = 1e18;

    for(int i = 0; i < n; i++)
    {
        double xx , yy;
        cin >> xx >> yy;
        mn = min((xx-x)*(xx - x) + (yy-y)*(yy-y), mn);
        mx = max((xx-x)*(xx - x) + (yy-y)*(yy-y), mx);
    }
    double ans = (mx - mn)*3.14159265359;
    cout << setprecision(12) <<ans;
}


#include <vector>
#include<algorithm>
#include<iostream>
#include<bitset>
#include<set>
#include<map>
#include <iomanip>
#include<string>
#include<iostream>

#include<math.h>
#define count count1557
#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;

const double pi=acos(-1.0);

double mx,mn=1e12;
long long xx,yy,x[100005],y[100005];
int n;

int main(){
    cin >> n >> xx >> yy;
    double a,b,c;
    for(int i=1;i<=n;i++)
    {
        cin >> x[i] >>y[i];
        x[i]-=xx;
        y[i]-=yy;
        c=(x[i] * x[i])+ (y[i] * y[i]);
        mx=max(c,mx);
        mn=min(c,mn);
    }
    x[n+1]=x[1];
    y[n+1]=y[1];
    for(int i=1;i<=n;i++)
    {
        a=(x[i] * x[i])+ (y[i] * y[i]);
        b=(x[1+i] * x[1+i])+ (y[i+1] * y[i+1]);
        c=(x[i]-x[i+1])*(x[i]-x[i+1])+(y[i]-y[i+1])*(y[i]-y[i+1]);
        if(a+c<b)continue;
        if(b+c<a)continue;
        a=sqrt(a);
        b=sqrt(b);
        c=sqrt(c);
        double p=(a+b+c)/2;
        double S=sqrt(p*(p-a)*(p-b)*(p-c));
        p=1.0*(2*S/c)*(2*S/c);
        mn=min(mn,p);
    }
    cout << setprecision(20) << pi*(mx-mn) ;
}


#include <vector>
#include<algorithm>
#include<iostream>
#include<bitset>
#include<set>
#include<map>
#include <iomanip>
#include<string>
#include<iostream>

#include<math.h>
#define count count1557
using namespace std;
int main()
{
    int n;
    double x , y;
    cin >> n >> x >> y;

    double mx = -1 , mn = 1e18;

    for(int i = 0; i < n; i++)
    {
        double xx , yy;
        cin >> xx >> yy;
        mn = min((xx-x)*(xx - x) + (yy-y)*(yy-y), mn);
        mx = max((xx-x)*(xx - x) + (yy-y)*(yy-y), mx);
    }
    double ans = (mx - mn)*M_PI;
    cout << setprecision(12) <<ans;
}


#include <cstdio>
#include <iostream>
#include <string>
#include <algorithm>
#include <cmath>
#include <vector>
#include <stack>
#include <queue>
#include <list>
#include <map>
#include <set>
#include <stdlib.h>
#include <sstream>
#include <assert.h>
#include <memory.h>
#include <complex>
#include <time.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;

#define mp make_pair
#define pb push_back
#define ll long long
#define sz(x) (int)(x).size()

pair<ll, ll> mas[100100];

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

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

    ll x0, y0;
    scanf("%lld %lld", &x0, &y0);

    for(int i = 0; i < n; i++) {
        scanf("%lld %lld", &mas[i].first, &mas[i].second);
    }

    double mindist = 1e18;
    double maxdist = 0;
    mas[n] = mas[0];
    for(int i = 0; i < n; i++) {
        ll dist = (mas[i].first - x0) * (mas[i].first - x0) + (mas[i].second - y0) * (mas[i].second - y0);
        if(dist > maxdist) maxdist = dist;
        if(dist < mindist) mindist = dist;

        //double A = mas[i].second - mas[i+1].second;
        //double B = mas[i+1].first - mas[i].first;
        //double C = -A * (double)mas[i].first - B * (double)mas[i].second;
        //double d2 = abs(A * (double)x0 + B * (double)y0 + C) / sqrt(A * A + B * B);
        //if(d2 * d2 < mindist) mindist = d2 * d2;
        //if(d2 * d2 > maxdist) maxdist = d2 * d2;
    }

    double diff = maxdist - mindist;
    double xxx = diff * acos(-1.0);
    printf("%.15lf\n", xxx);

    return 0;
}


#include <cstdio>
#include <iostream>
#include <string>
#include <algorithm>
#include <cmath>
#include <vector>
#include <stack>
#include <queue>
#include <list>
#include <map>
#include <set>
#include <stdlib.h>
#include <sstream>
#include <assert.h>
#include <memory.h>
#include <complex>
#include <time.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;

#define mp make_pair
#define pb push_back
#define ll long long
#define sz(x) (int)(x).size()

pair<ll, ll> mas[100100];

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

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

    ll x0, y0;
    scanf("%lld %lld", &x0, &y0);

    for(int i = 0; i < n; i++) {
        scanf("%lld %lld", &mas[i].first, &mas[i].second);
    }

    double mindist = 1e18;
    double maxdist = 0;
    mas[n] = mas[0];
    for(int i = 0; i < n; i++) {
        double dist = ((double)mas[i].first - (double)x0) * ((double)mas[i].first - (double)x0) + ((double)mas[i].second - (double)y0) * ((double)mas[i].second - (double)y0);
        if(dist > maxdist) maxdist = dist;
        if(dist < mindist) mindist = dist;

        double A = mas[i].second - mas[i+1].second;
        double B = mas[i+1].first - mas[i].first;
        double C = -A * (double)mas[i].first - B * (double)mas[i].second;
        double d2 = abs(A * (double)x0 + B * (double)y0 + C) / sqrt(A * A + B * B);
        bool ok = false;
        double dx = mas[i+1].first - mas[i].first;
        double dy = mas[i+1].second - mas[i].second;
        double dd = sqrt(dx * dx + dy * dy);
        dx /= dd;
        dy /= dd;
        double dx2 = -dy;
        double dy2 = dx;

        double cx1 = (double)x0 + dx2 * d2;
        double cy1 = (double)y0 + dy2 * d2;
        double cx2 = (double)x0 - dx2 * d2;
        double cy2 = (double)y0 - dy2 * d2;

        double dd11 = sqrt(((double)mas[i].first - cx1) * ((double)mas[i].first - cx1) + ((double)mas[i].second - cy1) * ((double)mas[i].second - cy1));
        double dd12 = sqrt(((double)mas[i+1].first - cx1) * ((double)mas[i+1].first - cx1) + ((double)mas[i+1].second - cy1) * ((double)mas[i+1].second - cy1));
        if(abs(dd11 + dd12 - dd) < 1e-9) ok = true;
        dd11 = sqrt(((double)mas[i].first - cx2) * ((double)mas[i].first - cx2) + ((double)mas[i].second - cy2) * ((double)mas[i].second - cy2));
        dd12 = sqrt(((double)mas[i+1].first - cx2) * ((double)mas[i+1].first - cx2) + ((double)mas[i+1].second - cy2) * ((double)mas[i+1].second - cy2));
        if(abs(dd11 + dd12 - dd) < 1e-9) ok = true;

        if(d2 * d2 < mindist && ok) mindist = d2 * d2;
    }

    double diff = maxdist - mindist;
    double xxx = diff * acos(-1.0);
    printf("%.15lf\n", (double)xxx);

    return 0;
}


#include <iostream>
#include <iomanip>
#include <algorithm>
#include <math.h>

using namespace std;

const double pi = acos(-1.0);

double xp, yp;

double rad(double x1, double y1, double x2, double y2) {
	if ((((x2 - x1) * (xp - x1) + (y2 - y1) * (yp - y1)) / sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)) * sqrt((xp - x1) * (xp - x1) + (yp - y1) * (yp - y1))) > 0 && (((x1 - x2) * (xp - x2) + (y1 - y2) * (yp - y2)) / sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)) * sqrt((xp - x2) * (xp - x2) + (yp - y2) * (yp - y2))) > 0)
		return abs((xp - x1) * (y2 - y1) - (yp - y1) * (x2 - x1)) / sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
	else
		return min(sqrt((xp - x1) * (xp - x1) + (yp - y1) * (yp - y1)), sqrt((xp - x2) * (xp - x2) + (yp - y2) * (yp - y2)));
}

int main() {
	double n, x, y, x0, y0, xprev, yprev, r, R;
	double minr = 1e9, maxr = 0;
	cin >> n >> xp >> yp >> xprev >> yprev;
	x0 = xprev;
	y0 = yprev;
	for (int i = 1; i < n; ++i) {
		cin >> x >> y;
		r = rad(x, y, xprev, yprev);
		if (r < minr)
			minr = r;
		R = sqrt((xp - x) * (xp - x) + (yp - y) * (yp - y));
		if (R > maxr)
			maxr = R;
		xprev = x;
		yprev = y;
	}
	r = rad(x0, y0, x, y);
	if (r < minr)
		minr = r;

	cout << fixed << setprecision(8) << (pi * maxr * maxr - pi * minr * minr);
	return 0;
}


#include <iostream>
#include <iomanip>
#include <algorithm>
#include <math.h>

using namespace std;

const double pi = acos(-1.0);

double xp, yp;

double rad(double x1, double y1, double x2, double y2) {
	if (acos(((x2 - x1) * (xp - x1) + (y2 - y1) * (yp - y1)) / sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)) * sqrt((xp - x1) * (xp - x1) + (yp - y1) * (yp - y1))) < pi / 2 || acos(((x1 - x2) * (xp - x2) + (y1 - y2) * (yp - y2)) / sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)) * sqrt((xp - x2) * (xp - x2) + (yp - y2) * (yp - y2))) < pi / 2)
		return abs((xp - x1) * (y2 - y1) - (yp - y1) * (x2 - x1)) / sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
	else
		return min(sqrt((xp - x1) * (xp - x1) + (yp - y1) * (yp - y1)), sqrt((xp - x2) * (xp - x2) + (yp - y2) * (yp - y2)));
}

int main() {
	double n, x, y, x0, y0, xprev, yprev, r, R;
	double minr = 1e9, maxr = 0;
	cin >> n >> xp >> yp >> xprev >> yprev;
	x0 = xprev;
	y0 = yprev;
	for (int i = 1; i < n; ++i) {
		cin >> x >> y;
		r = rad(x, y, xprev, yprev);
		if (r < minr)
			minr = r;
		R = sqrt((xp - x) * (xp - x) + (yp - y) * (yp - y));
		if (R > maxr)
			maxr = R;
		xprev = x;
		yprev = y;
	}
	r = rad(x0, y0, x, y);
	if (r < minr)
		minr = r;

	cout << fixed << setprecision(8) << (pi * maxr * maxr - pi * minr * minr);
	return 0;
}


#include <iostream>
#include <iomanip>
#include <algorithm>
#include <math.h>

using namespace std;

const double pi = acos(-1.0);

double xp, yp;

double rad(double x1, double y1, double x2, double y2) {
	if ((((x2 - x1) * (xp - x1) + (y2 - y1) * (yp - y1)) / sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)) * sqrt((xp - x1) * (xp - x1) + (yp - y1) * (yp - y1))) > 0 && (((x1 - x2) * (xp - x2) + (y1 - y2) * (yp - y2)) / sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)) * sqrt((xp - x2) * (xp - x2) + (yp - y2) * (yp - y2))) > 0)
		return abs((xp - x1) * (y2 - y1) - (yp - y1) * (x2 - x1)) / sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
	else
		return min(sqrt((xp - x1) * (xp - x1) + (yp - y1) * (yp - y1)), sqrt((xp - x2) * (xp - x2) + (yp - y2) * (yp - y2)));
}

int main() {
	double n, x, y, x0, y0, xprev, yprev, r, R;
	double minr = 1e9, maxr = 0;
	cin >> n >> xp >> yp >> xprev >> yprev;
	x0 = xprev;
	y0 = yprev;
	for (int i = 1; i < n; ++i) {
		cin >> x >> y;
		r = rad(x, y, xprev, yprev);
		if (r < minr)
			minr = r;
		R = sqrt((xp - x) * (xp - x) + (yp - y) * (yp - y));
		if (R > maxr)
			maxr = R;
		xprev = x;
		yprev = y;
	}
	r = rad(x0, y0, x, y);
	if (r < minr)
		minr = r;
	R = sqrt((xp - x0) * (xp - x0) + (yp - y0) * (yp - y0));
	if (R > maxr)
		maxr = R;
	cout << fixed << setprecision(8) << (pi * maxr * maxr - pi * minr * minr);
	return 0;
}


#include <functional>
#include <algorithm>
#include <iostream>
#include <memory.h>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <assert.h>
#include <bitset>
#include <string>
#include <cstdio>
#include <math.h>
#include <complex>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <ctime>
#include <set>
#include <map>
using namespace std;

#define mp make_pair
#define int64 long long

#ifdef _DEBUG
    const int N = 1010;
#else
    const int N = 100010;
#endif

const double inf = 1e18;
const double pi = acos(-1.0);
const double eps = 1e-9;

int n, xp, yp, x[N], y[N];

int main()
{
#ifdef _DEBUG
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif
    scanf("%d%d%d", &n, &xp, &yp);
    for (int i = 1; i <= n; i++) scanf("%d%d", &x[i], &y[i]);
    for (int i = 1; i <= n; i++)
    {
        x[i] -= xp;
        y[i] -= yp;
    }
    x[n + 1] = x[1];
    y[n + 1] = y[1];
    double mindist = inf, maxdist = -inf;
    for (int i = 1; i <= n; i++)
    {
        double tmp = 1.0 * x[i] * x[i] + 1.0 * y[i] * y[i];
        double A = y[i] - y[i + 1];
        double B = x[i + 1] - x[i];
        double C = -A * x[i] - B * y[i];
        double d = C * C / (A * A + B * B);
        double xc = -A * C / (A * A + B * B);
        double yc = -B * C / (A * A + B * B);
        if (d < mindist && xc > min(x[i], x[i + 1]) - eps && xc < max(x[i], x[i + 1]) + eps && yc > min(y[i], y[i + 1]) - eps && yc < max(y[i], y[i + 1]) + eps)
            mindist = d;
        maxdist = max(maxdist, tmp);
        mindist = min(mindist, tmp);
    }
    double ans = pi * (maxdist - mindist);
    cout << fixed << setprecision(9) << ans;
    return 0;
}


#include <functional>
#include <algorithm>
#include <iostream>
#include <memory.h>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <assert.h>
#include <bitset>
#include <string>
#include <cstdio>
#include <math.h>
#include <complex>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <ctime>
#include <set>
#include <map>
using namespace std;

#define mp make_pair
#define int64 long long

#ifdef _DEBUG
    const int N = 1010;
#else
    const int N = 100010;
#endif

const double inf = 1e18;
const double pi = acos(-1.0);

int n, xp, yp, x[N], y[N];

int main()
{
#ifdef _DEBUG
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif
    scanf("%d%d%d", &n, &xp, &yp);
    for (int i = 1; i <= n; i++) scanf("%d%d", &x[i], &y[i]);
    for (int i = 1; i <= n; i++)
    {
        x[i] -= xp;
        y[i] -= yp;
    }
    double mindist = inf, maxdist = -inf;
    for (int i = 1; i <= n; i++)
    {
        double tmp = 1.0 * x[i] * x[i] + 1.0 * y[i] * y[i];
        mindist = min(mindist, tmp);
        maxdist = max(maxdist, tmp);
    }
    double ans = pi * (maxdist - mindist);
    cout << fixed << setprecision(9) << ans;
    return 0;
}


#define _CRT_SECURE_NO_DEPRECATE
#define _SECURE_SCL 0

#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <map>
#include <set>
#include <string>
#include <utility>
#include <vector>
#include <iostream>
#include <queue>
#include <deque>
#include <stack>
#include <list>
#include <cctype>
#include <sstream>
#include <cassert>
#include <bitset>
#include <memory.h>
#include <complex>
#include <iomanip>

using namespace std;

#pragma comment(linker, "/STACK:200000000")

typedef long long int64;

#define forn(i, n) for(int i = 0; i < (int)(n); i++)
#define ford(i, n) for(int i = (int)(n) - 1; i >= 0; i--)
#define fore(i, a, n) for(int i = (int)(a); i < (int)(n); i++)
#define pb push_back
#define mp make_pair
#define fs first
#define sc second
#define last(a) (int(a.size()) - 1)
#define all(a) a.begin(), a.end()

const double EPS = 1E-9;
const int INF = 1000000000;
const int64 INF64 = (int64) 1E18;
const double PI = 3.1415926535897932384626433832795;

int64 x[1100000], y[1100000];

int main() {
#ifdef RADs_project
  freopen("input.txt", "rt", stdin);
  freopen("output.txt", "wt", stdout);
#endif

  int n;
  int64 px, py;
  cin >> n >> px >> py;
  forn(i, n)
    scanf("%lld%lld", &x[i], &y[i]);
  x[n] = x[0];
  y[n] = y[0];

  double dmin = 1E40, dmax = -1E40;
  forn(i, n) {
    double dst = sqrt((double)(x[i] - px) * (x[i] - px) + (y[i] - py) * (y[i] - py));
    dmin = min(dmin, dst);
    dmax = max(dmax, dst);

    if ((px - x[i]) * (x[i + 1] - x[i]) + (py - y[i]) * (y[i + 1] - y[i]) >= 0 &&
        (px - x[i + 1]) * (x[i] - x[i + 1]) + (py - y[i + 1]) * (y[i] - y[i + 1]) >= 0) {
      double a = y[i + 1] - y[i];
      double b = x[i] - x[i + 1];
      double c = -a * x[i] - b * y[i];

      double dst2 = abs(a * px + b * py + c) / sqrt(a * a + b * b);
      dmin = min(dmin, dst2);
    }
  }

  printf("%.15lf\n", PI * (dmax * dmax - dmin * dmin));

  return 0;
}


#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <string>
#include <cmath>
#include <ctime>
#include <cassert>
using namespace std;

int n, xp, yp;
const long double pi = 3.1415926535897932384626433832795;

int main() {
	ios_base::sync_with_stdio(0);
	cin >> n >> xp >> yp;
	long double mini = 1e9;
	long double maxi = -1e9;
	for(int i = 1; i <= n; ++i) {
		int x, y;
		cin >> x >> y;
		long double dx = x - xp;
		long double dy = y - yp;
		long double dis = sqrt(dx * dx + dy * dy);
		mini = min(mini, dis);
		maxi = max(maxi, dis);
	}

	long double res = maxi * maxi - mini * mini;
	res *= pi;
	cout.precision(15);
	cout << fixed;
	cout << res << endl;
	//system("pause");
	return 0;
}


#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <string>
#include <cmath>
#include <ctime>
#include <cassert>
using namespace std;

int n, xp, yp;
const long double pi = 3.1415926535897932384626433832795;
int x[100007];
int y[100007];

long double det(long double xa, long double ya, long double xb, long double yb) {
	return xa * yb - xb * ya;
}

long double ilsk(long double xa, long double ya, long double xb, long double yb) {
	return xa * xb + ya * yb;
}

long double jebaj(long double ax, long double ay, long double bx, long double by) {
	long double res = det(bx - ax, by - ay, xp - ax, yp - ay);
	res /= sqrt((bx - ax) * (bx - ax) + (by - ay) * (by - ay));
	if(res < 0) res *= -1;

	if(ilsk(xp - ax, yp - ay, bx - ax, by - ay) < 0) return 1e15;
	if(ilsk(ax - bx, ay - by, xp - bx, yp - by) < 0) return 1e15;
	return res * res;
}

int main() {
	ios_base::sync_with_stdio(0);
	cin >> n >> xp >> yp;
	long double mini = 1e15;
	long double maxi = -1e15;

	for(int i = 1; i <= n; ++i) {
		cin >> x[i] >> y[i];
		long double dx = x[i] - xp;
		long double dy = y[i] - yp;
		long double dis = dx * dx + dy * dy;
		mini = min(mini, dis);
		maxi = max(maxi, dis);
	}

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

	for(int i = 1; i <= n; ++i) {
		mini = min(mini, jebaj(x[i], y[i], x[i + 1], y[i + 1]));
	}

	long double res = maxi - mini;
	res *= pi;
	cout.precision(15);
	cout << fixed;
	cout << res << endl;
	//cout << maxi << ' ' << mini << endl;
	//system("pause");
	return 0;
}


#pragma comment(linker, "/STACK:64000000")

#define _USE_MATH_DEFINES
#define _CRT_NO_DERPECATE
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cassert>
#include <memory.h>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <utility>
#include <algorithm>
#include <functional>
#include <complex>

using namespace std;

typedef long long int64;
typedef unsigned long long uint64;
typedef pair<int64, int64> pii;
#define sq(x) ((x)*(x))
#define INF ((int)(2e9))
#define LINF ((int64)(2e18))
#define EPS ((double)(1e-6))
#define MOD ((int64)(1e9 + 9))
#define y0 xdsf
const double PI = 6.283185307179586476925286766559;
const int MAXN = 100010;

int n, x, y;
pii point[MAXN];
double dist(double xi, double yi)
{
    return sqrt(sq(xi - x) + sq(yi - y));
}

double matri(pii a, pii b)
{
    if (a.first > b.first)
    {
        swap(a, b);
    }
    double l = 0, r = b.first - a.first, ans = 0;
    if (abs(r) < EPS)
    {
        return max(dist(a.first, a.second), dist(b.first, b.second));
    }
    double dy = (b.second - a.second) /(double) (b.first - a.first);
    for(int i = 0; i < 128; ++i)
    {
        double del = (r - l) / 3;
        double l1 = l + del, l2 = r - del;
        if (dist(a.first + l1, a.second + dy * l1) > dist(a.first + l2, a.second + dy * l2))
            r = l2;
        else
            l = l1;
    }
    return dist(a.first + l, a.second + dy * l);
}

double mitri(pii a, pii b)
{
    if (a.first > b.first)
    {
        swap(a, b);
    }
    double l = 0, r = b.first - a.first, mid, ans = 1e20;
    if (abs(r) < EPS)
    {
        return min(dist(a.first, a.second), dist(b.first, b.second));
    }
    double dy = (b.second - a.second) /(double) (b.first - a.first);
    for(int i = 0; i < 512; ++i)
    {
        double del = (r - l) / 3;
        double l1 = l + del, l2 = r - del;
        if (dist(a.first + l1, a.second + dy * l1) < dist(a.first + l2, a.second + dy * l2))
            r = l2;
        else
            l = l1;
    }
    return dist(a.first + l, a.second + dy * l);
}

void solve()
{
    cin >> n >> x >> y;
    int64 rmi = 1e18, rma = 0;

    for(int i = 0; i < n; ++i)
    {
        int64 x1, y1;
        cin >> x1 >> y1;
        int64 k = sq(x - x1) + sq(y - y1);
        point[i] = pii(x1, y1);
        rmi = min(rmi, k);
        rma = max(rma, k);
    }
    double r2 = sqrt((double)rma);
    double r1 = sqrt((double)rmi);

    for(int i = 0; i < n - 1; ++i)
    {
        r2 = max(r2, matri(point[i + 1], point[i]));
        r1 = min(r1, mitri(point[i + 1], point[i]));
    }
    r2 = max(r2, matri(point[n - 1], point[0]));
    r1 = min(r1, mitri(point[n - 1], point[0]));
    double ans = PI / 2 * (sq(r2) - sq(r1));

    printf("%0.10f", ans);
}

int main()
{
#ifdef _MY_DEBUG
    freopen("input.txt", "rt", stdin); freopen("output.txt", "wt", stdout);
#else
#endif
    // ios_base::sync_with_stdio(false); cin.tie(0);
    srand(time(0));

    solve();

    return 0;
}


#pragma comment(linker, "/STACK:64000000")

#define _USE_MATH_DEFINES
#define _CRT_NO_DERPECATE
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cassert>
#include <memory.h>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <utility>
#include <algorithm>
#include <functional>
#include <complex>

using namespace std;

typedef long long int64;
typedef unsigned long long uint64;
typedef pair<int64, int64> pii;
#define sq(x) ((x)*(x))
#define INF ((int)(2e9))
#define LINF ((int64)(2e18))
#define EPS ((double)(1e-7))
#define MOD ((int64)(1e9 + 9))
#define y0 xdsf
const double PI = 6.283185307179586476925286766559;
const int MAXN = 100010;

int n, x, y;
pii point[MAXN];
double dist(double xi, double yi)
{
    return sqrt(sq(xi - x) + sq(yi - y));
}

double matri(pii a, pii b)
{
    if (a.first > b.first)
    {
        swap(a, b);
    }
    double l = 0, r = b.first - a.first, ans = 0;
    if (abs(r) < EPS)
    {
        return max(dist(a.first, a.second), dist(b.first, b.second));
    }
    double dy = (b.second - a.second) /(double) (b.first - a.first);
    for(int i = 0; i < 128; ++i)
    {
        double del = (r - l) / 3;
        double l1 = l + del, l2 = r - del;
        if (dist(a.first + l1, a.second + dy * l1) > dist(a.first + l2, a.second + dy * l2))
            r = l2;
        else
            l = l1;
    }
    return dist(a.first + l, a.second + dy * l);
}

double mitri(pii a, pii b)
{
    if (a.first > b.first)
    {
        swap(a, b);
    }
    double l = 0, r = b.first - a.first, mid, ans = 1e20;
    if (abs(r) < EPS)
    {
        return min(dist(a.first, a.second), dist(b.first, b.second));
    }
    double dy = (b.second - a.second) /(double) (b.first - a.first);
    for(int i = 0; i < 128; ++i)
    {
        double del = (r - l) / 3;
        double l1 = l + del, l2 = r - del;
        if (dist(a.first + l1, a.second + dy * l1) < dist(a.first + l2, a.second + dy * l2))
            r = l2;
        else
            l = l1;
    }
    return dist(a.first + l, a.second + dy * l);
}

void solve()
{
    cin >> n >> x >> y;
    int64 rmi = 1e18, rma = 0;

    for(int i = 0; i < n; ++i)
    {
        int64 x1, y1;
        cin >> x1 >> y1;
        int64 k = sq(x - x1) + sq(y - y1);
        point[i] = pii(x1, y1);
        rmi = min(rmi, k);
        rma = max(rma, k);
    }
    double r2 = sqrt((double)rma);
    double r1 = sqrt((double)rmi);

    for(int i = 0; i < n - 1; ++i)
    {
        r2 = max(r2, matri(point[i + 1], point[i]));
        r1 = min(r1, mitri(point[i + 1], point[i]));
    }
    r2 = max(r2, matri(point[n - 1], point[0]));
    r1 = min(r1, mitri(point[n - 1], point[0]));
    double ans = PI / 2 * (sq(r2) - sq(r1));

    printf("%0.10f", ans);
}

int main()
{
#ifdef _MY_DEBUG
    freopen("input.txt", "rt", stdin); freopen("output.txt", "wt", stdout);
#else
#endif
    // ios_base::sync_with_stdio(false); cin.tie(0);
    srand(time(0));

    solve();

    return 0;
}


#pragma comment(linker, "/STACK:64000000")

#define _USE_MATH_DEFINES
#define _CRT_NO_DERPECATE
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cassert>
#include <memory.h>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <utility>
#include <algorithm>
#include <functional>
#include <complex>

using namespace std;

typedef long long int64;
typedef unsigned long long uint64;
typedef pair<double, double> pii;
#define sq(x) ((x)*(x))
#define INF ((int)(2e9))
#define LINF ((int64)(2e18))
#define EPS ((double)(1e-7))
#define MOD ((int64)(1e9 + 9))
#define y0 xdsf
const double PI = 6.283185307179586476925286766559;
const int MAXN = 100010;

int n;
double x, y;
pair<double, double> point[MAXN];
double ang = PI ;
inline double dist(double xi, double yi)
{
    return sq(xi) + sq(yi);
}

inline double matri(pii a, pii b)
{
    if (a.first > b.first)
    {
        swap(a, b);
    }
    double l = 0, r = b.first - a.first, ans = 0;
    if (abs(r) < EPS)
    {
        return max(dist(a.first, a.second), dist(b.first, b.second));
    }
    double dy = (b.second - a.second) /(double) (b.first - a.first);
    for(int i = 0; i < 100; ++i)
    {
        double del = (r - l) / 3;
        double l1 = l + del, l2 = r - del;
        if (dist(a.first + l1, a.second + dy * l1) > dist(a.first + l2, a.second + dy * l2))
            r = l2;
        else
            l = l1;
    }
    return dist(a.first + l, a.second + dy * l);
}

inline double mitri(pii a, pii b)
{
    if (a.first > b.first)
    {
        swap(a, b);
    }
    double l = 0, r = b.first - a.first, mid, ans = 1e20;
    if (abs(r) < EPS)
    {
        return min(dist(a.first, a.second), dist(b.first, b.second));
    }
    double dy = (b.second - a.second) /(double) (b.first - a.first);
    for(int i = 0; i < 100; ++i)
    {
        double del = (r - l) / 3;
        double l1 = l + del, l2 = r - del;
        if (dist(a.first + l1, a.second + dy * l1) < dist(a.first + l2, a.second + dy * l2))
            r = l2;
        else
            l = l1;
    }
    return dist(a.first + l, a.second + dy * l);
}

void update(double &x, double &y)
{
    double nx = x * cos(ang) - y * sin(ang);
    double ny = x * sin(ang) + y * cos(ang);
    x = nx, y = ny;
}

void solve()
{
    cin >> n >> x >> y;
    int64 rmi = 1e18, rma = 0;

    for(int i = 0; i < n; ++i)
    {
        double x1, y1;
        cin >> x1 >> y1;
        x1 -= x; y1 -= y;
        cerr << x1 << ' ' << y1 << endl;
        update(x1, y1);
        cerr << x1 << ' ' << y1 << endl;
        point[i] = make_pair(x1, y1);

    }
    double r2 = (double)rma;
    double r1 = (double)rmi;

    for(int i = 0; i < n - 1; ++i)
    {
        r2 = max(r2, matri(point[i + 1], point[i]));
        r1 = min(r1, mitri(point[i + 1], point[i]));
    }
    r2 = max(r2, matri(point[n - 1], point[0]));
    r1 = min(r1, mitri(point[n - 1], point[0]));
    double ans = PI / 2 * (r2 - r1);

    printf("%0.10f", ans);
}

int main()
{
#ifdef _MY_DEBUG
    freopen("input.txt", "rt", stdin); freopen("output.txt", "wt", stdout);
#else
#endif
    // ios_base::sync_with_stdio(false); cin.tie(0);
    srand(time(0));

    solve();

    return 0;
}


#pragma comment(linker, "/STACK:64000000")

#define _USE_MATH_DEFINES
#define _CRT_NO_DERPECATE
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cassert>
#include <memory.h>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <utility>
#include <algorithm>
#include <functional>
#include <complex>

using namespace std;

typedef long long int64;
typedef unsigned long long uint64;
typedef pair<double, double> pii;
#define sq(x) ((x)*(x))
#define INF ((int)(2e9))
#define LINF ((int64)(2e18))
#define EPS ((double)(1e-7))
#define MOD ((int64)(1e9 + 9))
#define y0 xdsf
const double PI = 6.283185307179586476925286766559;
const int MAXN = 100010;

int n;
double x, y;
pair<double, double> point[MAXN];
double ang = PI ;
inline double dist(double xi, double yi)
{
    return sq(xi) + sq(yi);
}

inline double matri(pii a, pii b)
{
    if (a.first > b.first)
    {
        swap(a, b);
    }
    double l = 0, r = b.first - a.first, ans = 0;
    if (abs(r) < EPS)
    {
        return max(dist(a.first, a.second), dist(b.first, b.second));
    }
    double dy = (b.second - a.second) /(double) (b.first - a.first);
    for(int i = 0; i < 129; ++i)
    {
        double del = (r - l) / 3;
        double l1 = l + del, l2 = r - del;
        if (dist(a.first + l1, a.second + dy * l1) > dist(a.first + l2, a.second + dy * l2))
            r = l2;
        else
            l = l1;
    }
    return dist(a.first + l, a.second + dy * l);
}

inline double mitri(pii a, pii b)
{
    if (a.first > b.first)
    {
        swap(a, b);
    }
    double l = 0, r = b.first - a.first, mid, ans = 1e20;
    if (abs(r) < EPS)
    {
        return min(dist(a.first, a.second), dist(b.first, b.second));
    }
    double dy = (b.second - a.second) /(double) (b.first - a.first);
    for(int i = 0; i < 129; ++i)
    {
        double del = (r - l) / 3;
        double l1 = l + del, l2 = r - del;
        if (dist(a.first + l1, a.second + dy * l1) < dist(a.first + l2, a.second + dy * l2))
            r = l2;
        else
            l = l1;
    }
    return dist(a.first + l, a.second + dy * l);
}

void update(double &x, double &y)
{
    double nx = x * cos(ang) - y * sin(ang);
    double ny = x * sin(ang) + y * cos(ang);
    x = nx, y = ny;
}

void solve()
{
    cin >> n >> x >> y;
    int64 rmi = 1e18, rma = 0;

    for(int i = 0; i < n; ++i)
    {
        double x1, y1;
        cin >> x1 >> y1;
        x1 -= x; y1 -= y;
        update(x1, y1);
        point[i] = make_pair(x1, y1);

    }
    double r2 = (double)rma;
    double r1 = (double)rmi;

    for(int i = 0; i < n - 1; ++i)
    {
        r2 = max(r2, matri(point[i + 1], point[i]));
        r1 = min(r1, mitri(point[i + 1], point[i]));
    }
    r2 = max(r2, matri(point[n - 1], point[0]));
    r1 = min(r1, mitri(point[n - 1], point[0]));
    double ans = PI / 2 * (r2 - r1);

    cout.precision(10);
    cout << fixed << ans;
}

int main()
{
#ifdef _MY_DEBUG
    freopen("input.txt", "rt", stdin); freopen("output.txt", "wt", stdout);
#else
#endif
    ios_base::sync_with_stdio(false); cin.tie(0);
    srand(time(0));

    solve();

    return 0;
}


#pragma comment(linker, "/STACK:64000000")

#define _USE_MATH_DEFINES
#define _CRT_NO_DERPECATE
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cassert>
#include <memory.h>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <utility>
#include <algorithm>
#include <functional>
#include <complex>

using namespace std;

typedef long long int64;
typedef unsigned long long uint64;
typedef pair<int64, int64> pii;
#define sq(x) ((x)*(x))
#define INF ((int)(2e9))
#define LINF ((int64)(2e18))
#define EPS ((double)(1e-7))
#define MOD ((int64)(1e9 + 9))
#define y0 xdsf
const double PI = 6.283185307179586476925286766559;
const int MAXN = 100010;

int n, x, y;
pii point[MAXN];
double dist(double xi, double yi)
{
    return sqrt(sq(xi - x) + sq(yi - y));
}

double matri(pii a, pii b)
{
    if (a.first > b.first)
    {
        swap(a, b);
    }
    double l = 0, r = b.first - a.first, ans = 0;
    if (abs(r) < EPS)
    {
        return max(dist(a.first, a.second), dist(b.first, b.second));
    }
    double dy = (b.second - a.second) /(double) (b.first - a.first);
    for(int i = 0; i < 128; ++i)
    {
        double del = (r - l) / 3;
        double l1 = l + del, l2 = r - del;
        if (dist(a.first + l1, a.second + dy * l1) > dist(a.first + l2, a.second + dy * l2))
            r = l2;
        else
            l = l1;
    }
    return dist(a.first + l, a.second + dy * l);
}

double mitri(pii a, pii b)
{
    if (a.first > b.first)
    {
        swap(a, b);
    }
    double l = 0, r = b.first - a.first, mid, ans = 1e20;
    if (abs(r) < EPS)
    {
        return min(dist(a.first, a.second), dist(b.first, b.second));
    }
    double dy = (b.second - a.second) /(double) (b.first - a.first);
    for(int i = 0; i < 256; ++i)
    {
        double del = (r - l) / 3;
        double l1 = l + del, l2 = r - del;
        if (dist(a.first + l1, a.second + dy * l1) < dist(a.first + l2, a.second + dy * l2))
            r = l2;
        else
            l = l1;
    }
    return dist(a.first + l, a.second + dy * l);
}

void solve()
{
    cin >> n >> x >> y;
    int64 rmi = 1e18, rma = 0;

    for(int i = 0; i < n; ++i)
    {
        int64 x1, y1;
        cin >> x1 >> y1;
        int64 k = sq(x - x1) + sq(y - y1);
        point[i] = pii(x1, y1);
        rmi = min(rmi, k);
        rma = max(rma, k);
    }
    double r2 = sqrt((double)rma);
    double r1 = sqrt((double)rmi);

    for(int i = 0; i < n - 1; ++i)
    {
        r2 = max(r2, matri(point[i + 1], point[i]));
        r1 = min(r1, mitri(point[i + 1], point[i]));
    }
    r2 = max(r2, matri(point[n - 1], point[0]));
    r1 = min(r1, mitri(point[n - 1], point[0]));
    double ans = PI / 2 * (sq(r2) - sq(r1));

    printf("%0.10f", ans);
}

int main()
{
#ifdef _MY_DEBUG
    freopen("input.txt", "rt", stdin); freopen("output.txt", "wt", stdout);
#else
#endif
    // ios_base::sync_with_stdio(false); cin.tie(0);
    srand(time(0));

    solve();

    return 0;
}


#pragma comment(linker, "/STACK:64000000")

#define _USE_MATH_DEFINES
#define _CRT_NO_DERPECATE
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cassert>
#include <memory.h>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <utility>
#include <algorithm>
#include <functional>
#include <complex>

using namespace std;

typedef long long int64;
typedef unsigned long long uint64;
typedef pair<double, double> pii;
#define sq(x) ((x)*(x))
#define INF ((int)(2e9))
#define LINF ((int64)(2e18))
#define EPS ((double)(1e-7))
#define MOD ((int64)(1e9 + 9))
#define y0 xdsf
const double PI = 6.283185307179586476925286766559;
const int MAXN = 100010;

int n;
double x, y;
pair<double, double> point[MAXN];
double ang = PI / 34 ;
inline double dist(double xi, double yi)
{
    return sq(xi) + sq(yi);
}

inline double matri(pii a, pii b)
{
    if (a.first > b.first)
    {
        swap(a, b);
    }
    double l = 0, r = b.first - a.first, ans = 0;
    if (abs(r) < EPS)
    {
        return max(dist(a.first, a.second), dist(b.first, b.second));
    }
    double dy = (b.second - a.second) /(double) (b.first - a.first);
    for(int i = 0; i < 129; ++i)
    {
        double del = (r - l) / 3;
        double l1 = l + del, l2 = r - del;
        if (dist(a.first + l1, a.second + dy * l1) > dist(a.first + l2, a.second + dy * l2))
            r = l2;
        else
            l = l1;
    }
    return dist(a.first + l, a.second + dy * l);
}

inline double mitri(pii a, pii b)
{
    if (a.first > b.first)
    {
        swap(a, b);
    }
    double l = 0, r = b.first - a.first, mid, ans = 1e20;
    if (abs(r) < EPS)
    {
        return min(dist(a.first, a.second), dist(b.first, b.second));
    }
    double dy = (b.second - a.second) /(double) (b.first - a.first);
    for(int i = 0; i < 129; ++i)
    {
        double del = (r - l) / 3;
        double l1 = l + del, l2 = r - del;
        if (dist(a.first + l1, a.second + dy * l1) < dist(a.first + l2, a.second + dy * l2))
            r = l2;
        else
            l = l1;
    }
    return dist(a.first + l, a.second + dy * l);
}

void update(double &x, double &y)
{
    double nx = x * cos(ang) - y * sin(ang);
    double ny = x * sin(ang) + y * cos(ang);
    x = nx, y = ny;
}

void solve()
{
    cin >> n >> x >> y;
    int64 rmi = 1e18, rma = 0;

    for(int i = 0; i < n; ++i)
    {
        double x1, y1;
        cin >> x1 >> y1;
        x1 -= x; y1 -= y;
        update(x1, y1);
        point[i] = make_pair(x1, y1);

    }
    double r2 = (double)rma;
    double r1 = (double)rmi;

    for(int i = 0; i < n - 1; ++i)
    {
        r2 = max(r2, matri(point[i + 1], point[i]));
        r1 = min(r1, mitri(point[i + 1], point[i]));
    }
    r2 = max(r2, matri(point[n - 1], point[0]));
    r1 = min(r1, mitri(point[n - 1], point[0]));
    double ans = PI / 2 * (r2 - r1);

    cout.precision(10);
    cout << fixed << ans;
}

int main()
{
#ifdef _MY_DEBUG
    freopen("input.txt", "rt", stdin); freopen("output.txt", "wt", stdout);
#else
#endif
    ios_base::sync_with_stdio(false); cin.tie(0);
    srand(time(0));

    solve();

    return 0;
}


#pragma comment(linker, "/STACK:64000000")

#define _USE_MATH_DEFINES
#define _CRT_NO_DERPECATE
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cassert>
#include <memory.h>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <utility>
#include <algorithm>
#include <functional>
#include <complex>

using namespace std;

typedef long long int64;
typedef unsigned long long uint64;
typedef pair<double, double> pii;
#define sq(x) ((x)*(x))
#define INF ((int)(2e9))
#define LINF ((int64)(2e18))
#define EPS ((double)(1e-7))
#define MOD ((int64)(1e9 + 9))
#define y0 xdsf
const double PI = 6.283185307179586476925286766559;
const int MAXN = 100010;

int n;
double x, y;
pair<double, double> point[MAXN];
double ang = PI ;
inline double dist(double xi, double yi)
{
    return sq(xi) + sq(yi);
}

inline double matri(pii a, pii b)
{
    if (a.first > b.first)
    {
        swap(a, b);
    }
    double l = 0, r = b.first - a.first, ans = 0;
    if (abs(r) < EPS)
    {
        return max(dist(a.first, a.second), dist(b.first, b.second));
    }
    double dy = (b.second - a.second) /(double) (b.first - a.first);
    for(int i = 0; i < 129; ++i)
    {
        double del = (r - l) / 3;
        double l1 = l + del, l2 = r - del;
        if (dist(a.first + l1, a.second + dy * l1) > dist(a.first + l2, a.second + dy * l2))
            r = l2;
        else
            l = l1;
    }
    return dist(a.first + l, a.second + dy * l);
}

inline double mitri(pii a, pii b)
{
    if (a.first > b.first)
    {
        swap(a, b);
    }
    double l = 0, r = b.first - a.first, mid, ans = 1e20;
    if (abs(r) < EPS)
    {
        return min(dist(a.first, a.second), dist(b.first, b.second));
    }
    double dy = (b.second - a.second) /(double) (b.first - a.first);
    for(int i = 0; i < 129; ++i)
    {
        double del = (r - l) / 3;
        double l1 = l + del, l2 = r - del;
        if (dist(a.first + l1, a.second + dy * l1) < dist(a.first + l2, a.second + dy * l2))
            r = l2;
        else
            l = l1;
    }
    return dist(a.first + l, a.second + dy * l);
}

void update(double &x, double &y)
{
    double nx = x * cos(ang) - y * sin(ang);
    double ny = x * sin(ang) + y * cos(ang);
    x = nx, y = ny;
}

void solve()
{
    cin >> n >> x >> y;
    int64 rmi = 1e18, rma = 0;

    for(int i = 0; i < n; ++i)
    {
        double x1, y1;
        cin >> x1 >> y1;
        x1 -= x; y1 -= y;
        update(x1, y1);
        point[i] = make_pair(x1, y1);

    }
    double r2 = (double)rma;
    double r1 = (double)rmi;

    for(int i = 0; i < n - 1; ++i)
    {
        r2 = max(r2, matri(point[i + 1], point[i]));
        r1 = min(r1, mitri(point[i + 1], point[i]));
    }
    r2 = max(r2, matri(point[n - 1], point[0]));
    r1 = min(r1, mitri(point[n - 1], point[0]));
    double ans = PI / 2 * (r2 - r1);

    cout.precision(10);
    cout << fixed << ans
}

int main()
{
#ifdef _MY_DEBUG
    freopen("input.txt", "rt", stdin); freopen("output.txt", "wt", stdout);
#else
#endif
    ios_base::sync_with_stdio(false); cin.tie(0);
    srand(time(0));

    solve();

    return 0;
}


#pragma comment(linker, "/STACK:64000000")

#define _USE_MATH_DEFINES
#define _CRT_NO_DERPECATE
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cassert>
#include <memory.h>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <utility>
#include <algorithm>
#include <functional>
#include <complex>

using namespace std;

typedef long long int64;
typedef unsigned long long uint64;
typedef pair<int64, int64> pii;
#define sq(x) ((x)*(x))
#define INF ((int)(2e9))
#define LINF ((int64)(2e18))
#define EPS ((double)(1e-14))
#define MOD ((int64)(1e9 + 9))
#define y0 xdsf
const double PI = 3.14159265;
const int MAXN = 100010;

int n, x, y;
pii point[MAXN];
long double dist(long double xi, long double yi)
{
    return sqrt(sq(xi - x) + sq(yi - y));
}

long double matri(pii a, pii b)
{
    if (a.first > b.first)
    {
        swap(a, b);
    }
    double l = 0, r = b.first - a.first, ans = 0;
    if (abs(r) < EPS)
    {
        return max(dist(a.first, a.second), dist(b.first, b.second));
    }
    double dy = (b.second - a.second) /(double) (b.first - a.first);
    for(int i = 0; i < 128; ++i)
    {
        long double del = (r - l) / 3;
        long double l1 = l + del, l2 = r - del;
        if (dist(a.first + l1, a.second + dy * l1) > dist(a.first + l2, a.second + dy * l2))
            r = l2;
        else
            l = l1;
    }
    return dist(a.first + l, a.second + dy * l);
}

long double mitri(pii a, pii b)
{
    if (a.first > b.first)
    {
        swap(a, b);
    }
    double l = 0, r = b.first - a.first, mid, ans = 1e20;
    if (abs(r) < EPS)
    {
        return min(dist(a.first, a.second), dist(b.first, b.second));
    }
    double dy = (b.second - a.second) /(double) (b.first - a.first);
    for(int i = 0; i < 256; ++i)
    {
        long double del = (r - l) / 3;
        long double l1 = l + del, l2 = r - del;
        if (dist(a.first + l1, a.second + dy * l1) < dist(a.first + l2, a.second + dy * l2))
            r = l2;
        else
            l = l1;
    }
    return dist(a.first + l, a.second + dy * l);
}

void solve()
{
    cin >> n >> x >> y;
    int64 rmi = 1e18, rma = 0;

    for(int i = 0; i < n; ++i)
    {
        int64 x1, y1;
        cin >> x1 >> y1;
        int64 k = sq(x - x1) + sq(y - y1);
        point[i] = pii(x1, y1);
        rmi = min(rmi, k);
        rma = max(rma, k);
    }
    long double r2 = sqrt((double)rma);
    long double r1 = sqrt((double)rmi);

    for(int i = 0; i < n - 1; ++i)
    {
        r2 = max(r2, matri(point[i + 1], point[i]));
        r1 = min(r1, mitri(point[i + 1], point[i]));
    }
    r2 = max(r2, matri(point[n - 1], point[0]));
    r1 = min(r1, mitri(point[n - 1], point[0]));
    double ans = PI / 2 * (sq(r2) - sq(r1));

    printf("%0.10f", ans);
}

int main()
{
#ifdef _MY_DEBUG
    freopen("input.txt", "rt", stdin); freopen("output.txt", "wt", stdout);
#else
#endif
    // ios_base::sync_with_stdio(false); cin.tie(0);
    srand(time(0));

    solve();

    return 0;
}


#pragma comment(linker, "/STACK:64000000")

#define _USE_MATH_DEFINES
#define _CRT_NO_DERPECATE
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cassert>
#include <memory.h>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <utility>
#include <algorithm>
#include <functional>
#include <complex>

using namespace std;

typedef long long int64;
typedef unsigned long long uint64;
typedef pair<int64, int64> pii;
#define sq(x) ((x)*(x))
#define INF ((int)(2e9))
#define LINF ((int64)(2e18))
#define EPS ((double)(1e-3))
#define MOD ((int64)(1e9 + 9))
#define y0 xdsf
const double PI = 6.283185307179586476925286766559;
const int MAXN = 1011000;

int n, x, y;

void solve()
{
    cin >> n >> x >> y;
    int64 rmi = 1e18, rma = 0;

    for(int i = 0; i < n; ++i)
    {
        int64 x1, y1;
        cin >> x1 >> y1;
        int64 k = sq(x - x1) + sq(y - y1);
        rmi = min(rmi, k);
        rma = max(rma, k);
    }
    ;
    double ans = PI / 2 * (rma - rmi);
    printf("%0.10f", ans);
}

int main()
{
#ifdef _MY_DEBUG
    freopen("input.txt", "rt", stdin); freopen("output.txt", "wt", stdout);
#else
#endif
    // ios_base::sync_with_stdio(false); cin.tie(0);
    srand(time(0));

    solve();

    return 0;
}


#pragma comment(linker, "/STACK:64000000")

#define _USE_MATH_DEFINES
#define _CRT_NO_DERPECATE
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cassert>
#include <memory.h>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <utility>
#include <algorithm>
#include <functional>
#include <complex>

using namespace std;

typedef long long int64;
typedef unsigned long long uint64;
typedef pair<double, double> pii;
#define sq(x) ((x)*(x))
#define INF ((int)(2e9))
#define LINF ((int64)(2e18))
#define EPS ((double)(1e-7))
#define MOD ((int64)(1e9 + 9))
#define y0 xdsf
const double PI = 6.283185307179586476925286766559;
const int MAXN = 100010;

int n;
double x, y;
pair<double, double> point[MAXN];
double ang = PI ;
inline double dist(double xi, double yi)
{
    return sq(xi) + sq(yi);
}

inline double matri(pii a, pii b)
{
    if (a.first > b.first)
    {
        swap(a, b);
    }
    double l = 0, r = b.first - a.first, ans = 0;
    if (abs(r) < EPS)
    {
        return max(dist(a.first, a.second), dist(b.first, b.second));
    }
    double dy = (b.second - a.second) /(double) (b.first - a.first);
    for(int i = 0; i < 64; ++i)
    {
        double del = (r - l) / 3;
        double l1 = l + del, l2 = r - del;
        if (dist(a.first + l1, a.second + dy * l1) > dist(a.first + l2, a.second + dy * l2))
            r = l2;
        else
            l = l1;
    }
    return dist(a.first + l, a.second + dy * l);
}

inline double mitri(pii a, pii b)
{
    if (a.first > b.first)
    {
        swap(a, b);
    }
    double l = 0, r = b.first - a.first, mid, ans = 1e20;
    if (abs(r) < EPS)
    {
        return min(dist(a.first, a.second), dist(b.first, b.second));
    }
    double dy = (b.second - a.second) /(double) (b.first - a.first);
    for(int i = 0; i < 64; ++i)
    {
        double del = (r - l) / 3;
        double l1 = l + del, l2 = r - del;
        if (dist(a.first + l1, a.second + dy * l1) < dist(a.first + l2, a.second + dy * l2))
            r = l2;
        else
            l = l1;
    }
    return dist(a.first + l, a.second + dy * l);
}

void update(double &x, double &y)
{
    double nx = x * cos(ang) - y * sin(ang);
    double ny = x * sin(ang) + y * cos(ang);
    x = nx, y = ny;
}

void solve()
{
    cin >> n >> x >> y;
    int64 rmi = 1e18, rma = 0;

    for(int i = 0; i < n; ++i)
    {
        double x1, y1;
        cin >> x1 >> y1;
        x1 -= x; y1 -= y;
        cerr << x1 << ' ' << y1 << endl;
        update(x1, y1);
        cerr << x1 << ' ' << y1 << endl;
        point[i] = make_pair(x1, y1);

    }
    double r2 = (double)rma;
    double r1 = (double)rmi;

    for(int i = 0; i < n - 1; ++i)
    {
        r2 = max(r2, matri(point[i + 1], point[i]));
        r1 = min(r1, mitri(point[i + 1], point[i]));
    }
    r2 = max(r2, matri(point[n - 1], point[0]));
    r1 = min(r1, mitri(point[n - 1], point[0]));
    double ans = PI / 2 * (r2 - r1);

    cout.precision(10);
    cout << fixed << ans;
}

int main()
{
#ifdef _MY_DEBUG
    freopen("input.txt", "rt", stdin); freopen("output.txt", "wt", stdout);
#else
#endif
    ios_base::sync_with_stdio(false); cin.tie(0);
    srand(time(0));

    solve();

    return 0;
}


#pragma comment(linker, "/STACK:64000000")

#define _USE_MATH_DEFINES
#define _CRT_NO_DERPECATE
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cassert>
#include <memory.h>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <utility>
#include <algorithm>
#include <functional>
#include <complex>

using namespace std;

typedef long long int64;
typedef unsigned long long uint64;
typedef pair<double, double> pii;
#define sq(x) ((x)*(x))
#define INF ((int)(2e9))
#define LINF ((int64)(2e18))
#define EPS ((double)(1e-7))
#define MOD ((int64)(1e9 + 9))
#define y0 xdsf
const double PI = 6.283185307179586476925286766559;
const int MAXN = 100010;

int n;
double x, y;
pair<double, double> point[MAXN];
double ang = PI ;
inline double dist(double xi, double yi)
{
    return sq(xi) + sq(yi);
}

inline double matri(pii a, pii b)
{
    if (a.first > b.first)
    {
        swap(a, b);
    }
    double l = 0, r = b.first - a.first, ans = 0;
    if (abs(r) < EPS)
    {
        return max(dist(a.first, a.second), dist(b.first, b.second));
    }
    double dy = (b.second - a.second) /(double) (b.first - a.first);
    for(int i = 0; i < 100; ++i)
    {
        double del = (r - l) / 3;
        double l1 = l + del, l2 = r - del;
        if (dist(a.first + l1, a.second + dy * l1) > dist(a.first + l2, a.second + dy * l2))
            r = l2;
        else
            l = l1;
    }
    return dist(a.first + l, a.second + dy * l);
}

inline double mitri(pii a, pii b)
{
    if (a.first > b.first)
    {
        swap(a, b);
    }
    double l = 0, r = b.first - a.first, mid, ans = 1e20;
    if (abs(r) < EPS)
    {
        return min(dist(a.first, a.second), dist(b.first, b.second));
    }
    double dy = (b.second - a.second) /(double) (b.first - a.first);
    for(int i = 0; i < 100; ++i)
    {
        double del = (r - l) / 3;
        double l1 = l + del, l2 = r - del;
        if (dist(a.first + l1, a.second + dy * l1) < dist(a.first + l2, a.second + dy * l2))
            r = l2;
        else
            l = l1;
    }
    return dist(a.first + l, a.second + dy * l);
}

void update(double &x, double &y)
{
    double nx = x * cos(ang) - y * sin(ang);
    double ny = x * sin(ang) + y * cos(ang);
    x = nx, y = ny;
}

void solve()
{
    cin >> n >> x >> y;
    int64 rmi = 1e18, rma = 0;

    for(int i = 0; i < n; ++i)
    {
        double x1, y1;
        cin >> x1 >> y1;
        x1 -= x; y1 -= y;
        cerr << x1 << ' ' << y1 << endl;
        update(x1, y1);
        cerr << x1 << ' ' << y1 << endl;
        point[i] = make_pair(x1, y1);

    }
    double r2 = (double)rma;
    double r1 = (double)rmi;

    for(int i = 0; i < n - 1; ++i)
    {
        r2 = max(r2, matri(point[i + 1], point[i]));
        r1 = min(r1, mitri(point[i + 1], point[i]));
    }
    r2 = max(r2, matri(point[n - 1], point[0]));
    r1 = min(r1, mitri(point[n - 1], point[0]));
    double ans = PI / 2 * (r2 - r1);

    cout.precision(10);
    cout << fixed << ans;
}

int main()
{
#ifdef _MY_DEBUG
    freopen("input.txt", "rt", stdin); freopen("output.txt", "wt", stdout);
#else
#endif
    ios_base::sync_with_stdio(false); cin.tie(0);
    srand(time(0));

    solve();

    return 0;
}


#include <algorithm>
#include <vector>
#include <cmath>
#include <iostream>
#include <unordered_map>
#include <ctime>
#include <string>
#include <random>
#include <set>
#include <stack>
#include <map>
#include <fstream>

using namespace std;
#define ll long long
const int MOD = 1000000007;
const double PI = 3.14159265358979;
/*
#define cin in
#define cout out
ifstream in("input.txt");
ofstream out("output.txt");
/**/

pair<int, int> v[1234567];
double mnd,  mxd;

void f(pair<int, int> p, pair<int, int> t, int x, int y)
{
	p.first -= x;
	p.second -= y;
	t.first -= x;
	t.second -= y;
	if(p.second == t.second)
	{
		if(min(p.first, t.first) <= 0 && max(p.first, t.first) >= 0)
			mnd = min(1.*abs(p.second), mnd);
		return;
	}
	ll a = p.second - t.second;
	ll b = t.first - p.first;
	ll c = -a*p.first - b*p.second;
	//ll d = -b*p.first + a*p.second;
	ll d = 0;
	double yy = (-b*c/((double)a) + d) / ((b*b) / double(a) + a);
	double xx = (-b*yy-c) / a;
	if(p.first > t.first)
		swap(p,t);
	if(xx >= p.first && xx <= t.first && yy >= min(p.second, t.second) && yy <= max(p.second, t.second))
		mnd = min(mnd, xx*xx+yy*yy);
}

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

	int n;
	cin >> n;
	ll x, y;
	cin >> x >> y;
	mnd = 1e18;
	for(int i = 0; i < n; ++i)
	{
		ll a, b;
		cin >> a >> b;
		v[i] = make_pair(a, b);
		a -= x;
		b -= y;
		ll d = a*a+b*b;
		mnd = min(mnd, d*1.);
		mxd = max(mxd, d*1.);
	}
	f(v[0], v[n - 1], x, y);
	for(int i = 1; i < n; ++i)
		f(v[i], v[i-1], x, y);
	cout.precision(12);
	cout << fixed << PI * (mxd - mnd);

 	return 0;
}

/*
3 0 0
1 1
-1 1
0 2

*/


#include <algorithm>
#include <vector>
#include <cmath>
#include <iostream>
#include <unordered_map>
#include <ctime>
#include <string>
#include <random>
#include <set>
#include <stack>
#include <map>
#include <fstream>

using namespace std;
#define ll long long
const int MOD = 1000000007;
const double PI = 3.141592653528;
/*
#define cin in
#define cout out
ifstream in("input.txt");
ofstream out("output.txt");
/**/

pair<int, int> v[1234567];
double mnd,  mxd;

void f(pair<int, int> p, pair<int, int> t, int x, int y)
{
	p.first -= x;
	p.second -= y;
	t.first -= x;
	t.second -= y;
	if(p.second == t.second)
	{
		if(min(p.first, t.first) <= 0 && max(p.first, t.first) >= 0)
			mnd = min(1.*abs(p.second), mnd);
		return;
	}
	ll a = p.second - t.second;
	ll b = t.first - p.first;
	ll c = -a*p.first - b*p.second;
	ll d = -b*p.first + a*p.second;
	double yy = (-b*c/((double)a) + d) / ((b*b) / double(a) + a);
	double xx = (-b*yy-c) / a;
	if(p.first > t.first)
		swap(p,t);
	if(xx >= p.first && xx <= t.first && yy >= min(p.second, t.second) && yy <= max(p.second, t.second))
		mnd = min(mnd, xx*xx+yy*yy);
}

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

	int n;
	cin >> n;
	ll x, y;
	cin >> x >> y;
	mnd = 1e18;
	for(int i = 0; i < n; ++i)
	{
		ll a, b;
		cin >> a >> b;
		v[i] = make_pair(a, b);
		a -= x;
		b -= y;
		ll d = a*a+b*b;
		mnd = min(mnd, d*1.);
		mxd = max(mxd, d*1.);
	}
	f(v[0], v[n - 1], x, y);
	for(int i = 1; i < n; ++i)
		f(v[i], v[i-1], x, y);
	cout.precision(12);
	cout << fixed << PI * (mxd - mnd);

 	return 0;
}

/*
3 0 0
1 1
-1 1
0 2

*/


#include <algorithm>
#include <vector>
#include <cmath>
#include <iostream>
#include <unordered_map>
#include <ctime>
#include <string>
#include <random>
#include <set>
#include <stack>
#include <map>
#include <fstream>

using namespace std;
#define ll long long
const int MOD = 1000000007;
const double PI = 3.141592653528;
/*
#define cin in
#define cout out
ifstream in("input.txt");
ofstream out("output.txt");
/**/

pair<int, int> a[1234567];

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

	int n;
	cin >> n;
	ll x, y;
	cin >> x >> y;
	ll mnd = 1e18,  mxd = 0;
	for(int i = 0; i < n; ++i)
	{
		ll a, b;
		cin >> a >> b;
		a-= x;
		b -= y;
		ll d = a*a+b*b;
		mnd = min(mnd, d);
		mxd = max(mxd, d);
	}
	cout.precision(12);
	cout << fixed << PI * (mxd - mnd);

 	return 0;
}

/*

12
1
2
3
4
5
6
7
8
9
10
11
12

*/