Problem: Peter got a new snow blower as a New Year present. Of course, Peter decided to try it immediately. After reading the instructions he realized that it does not work like regular snow blowing machines. In order to make it work, you need to tie it to some point that it does not cover, and then switch it on. As a result it will go along a circle around this point and will remove all the snow from its path.

Formally, we assume that Peter's machine is a polygon on a plane. Then, after the machine is switched on, it will make a circle around the point to which Peter tied it (this point lies strictly outside the polygon). That is, each of the points lying within or on the border of the polygon will move along the circular trajectory, with the center of the circle at the point to which Peter tied his machine.

Peter decided to tie his car to point P and now he is wondering what is the area of ​​the region that will be cleared from snow. Help him.

Input

The first line of the input contains three integers — the number of vertices of the polygon n (<image>), and coordinates of point P.

Each of the next n lines contains two integers — coordinates of the vertices of the polygon in the clockwise or counterclockwise order. It is guaranteed that no three consecutive vertices lie on a common straight line.

All the numbers in the input are integers that do not exceed 1 000 000 in their absolute value.

Output

Print a single real value number — the area of the region that will be cleared. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6. 

Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.

Examples

Input

3 0 0
0 1
-1 2
1 2


Output

12.566370614359172464


Input

4 1 -1
0 0
1 2
2 0
1 1


Output

21.991148575128551812

Note

In the first sample snow will be removed from that area:

<image>

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const int COUNTER_CLOCKWISE = +1;
const int CLOCKWISE = -1;
const int ONLINE_BACK = +2;
const int ONLINE_FRONT = -2;
const int ON_SEGMENT = 0;
const double EPS = 1e-7;
const double INF = 1e10;
const double PI = acos(-1);
struct Line {
  complex<double> a, b;
  Line() {}
  Line(const complex<double> &_a, const complex<double> &_b) {
    a = _a;
    b = _b;
  }
};
struct Segment {
  complex<double> a, b;
  Segment() {}
  Segment(const complex<double> &_a, const complex<double> &_b) {
    a = _a;
    b = _b;
  }
};
struct Circle {
  complex<double> c;
  double r;
  Circle() {}
  Circle(const complex<double> &_c, const double &_r) {
    c = _c;
    r = _r;
  }
};
istream &operator>>(istream &is, complex<double> &p) {
  double x, y;
  is >> x >> y;
  p.real(x);
  p.imag(y);
  return is;
}
Segment ToSegment(const Line l) { return Segment(l.a, l.b); }
Line ToLine(const Segment s) { return Line(s.a, s.b); }
bool equals(const double &a, const double &b);
bool equals(const complex<double> &a, const complex<double> &b);
bool comp(const complex<double> &a, const complex<double> &b);
double toRad(double a);
double toDeg(double a);
complex<double> rotate(complex<double> p, double d);
double dot(const complex<double> &a, const complex<double> &b);
double cross(const complex<double> &a, const complex<double> &b);
double GetArea(const vector<complex<double> > &g);
int CCW(const complex<double> &p0, const complex<double> &p1,
        const complex<double> &p2);
bool IsOrthogonal(const complex<double> &a, const complex<double> &b);
bool IsOrthogonal(const Line &l1, const Line &l2);
bool IsParallel(const complex<double> &a, const complex<double> &b);
bool IsParallel(const Line &l1, const Line &l2);
complex<double> Project(const Line &s, const complex<double> &p);
complex<double> Reflect(const Line &s, const complex<double> &p);
double GetDistance(const Line &l, const complex<double> &p);
double GetDistance(const Segment &s, const complex<double> &p);
double GetDistance(const Segment &s1, const Segment &s2);
bool Intersects(const Line &l, const Segment &s);
bool Intersects(const Segment &l1, const Segment &l2);
complex<double> GetIntersection(const Line &l1, const Line &l2);
vector<complex<double> > GetIntersection(const Circle &c1, const Circle &c2);
int Contains(const vector<complex<double> > &g, const complex<double> &p);
vector<complex<double> > AndrewScan(vector<complex<double> > &s);
vector<complex<double> > ConvexCut(const vector<complex<double> > &g,
                                   const Line &l);
bool equals(const double &a, const double &b) { return abs(a - b) < EPS; }
bool equals(const complex<double> &a, const complex<double> &b) {
  return equals(a.real(), b.real()) && equals(a.imag(), b.imag());
}
bool comp(const complex<double> &a, const complex<double> &b) {
  return equals(a.real(), b.real()) ? a.imag() < b.imag() : a.real() < b.real();
}
double dot(const complex<double> &a, const complex<double> &b) {
  return a.real() * b.real() + a.imag() * b.imag();
}
double cross(const complex<double> &a, const complex<double> &b) {
  return a.real() * b.imag() - a.imag() * b.real();
}
double GetArea(const vector<complex<double> > &g) {
  if (g.size() < 3) return 0;
  double res = 0;
  for (int i = 1; i < g.size() - 1; i++) {
    res += cross(g[i] - g[0], g[i + 1] - g[0]);
  }
  return abs(res / 2);
}
int CCW(const complex<double> &p0, const complex<double> &p1,
        const complex<double> &p2) {
  complex<double> v1 = (complex<double>)(p1 - p0), v2 = p2 - p0;
  if (cross(v1, v2) > EPS) return COUNTER_CLOCKWISE;
  if (cross(v1, v2) < -EPS) return CLOCKWISE;
  if (dot(v1, v2) < -EPS) return ONLINE_BACK;
  if (abs(v1) < abs(v2)) return ONLINE_FRONT;
  return ON_SEGMENT;
}
bool IsOrthogonal(const complex<double> &a, const complex<double> &b) {
  return equals(dot(a, b), 0.0);
}
bool IsOrthogonal(const Line &l1, const Line &l2) {
  return equals(dot(l1.b - l1.a, l2.b - l2.a), 0.0);
}
bool IsParallel(const complex<double> &a, const complex<double> &b) {
  return equals(cross(a, b), 0.0);
}
bool IsParallel(const Line &l1, const Line &l2) {
  return equals(cross(l1.b - l1.a, l2.b - l2.a), 0.0);
}
complex<double> Project(const Line &s, const complex<double> &p) {
  complex<double> v1 = s.b - s.a;
  complex<double> v2 = p - s.a;
  double r = dot(v1, v2) / norm(v1);
  return s.a + v1 * r;
}
complex<double> Reflect(const Line &s, const complex<double> &p) {
  return p + (Project(s, p) - p) * 2.0;
}
double GetDistance(const Line &l, const complex<double> &p) {
  return abs(cross(l.a - l.b, p - l.a) / abs(l.b - l.a));
}
double GetDistance(const Segment &s, const complex<double> &p) {
  if (dot(s.b - s.a, p - s.a) < 0.0) return abs(p - s.a);
  if (dot(s.a - s.b, p - s.b) < 0.0) return abs(p - s.b);
  return GetDistance(ToLine(s), p);
}
double GetDistance(const Segment &s1, const Segment &s2) {
  if (Intersects(s1, s2)) return 0.0;
  return min(min(GetDistance(s1, s2.a), GetDistance(s1, s2.b)),
             min(GetDistance(s2, s1.a), GetDistance(s2, s1.b)));
}
bool Intersects(const Line &l, const Segment &s) {
  return CCW(l.a, l.b, s.a) * CCW(l.a, l.b, s.b) != 1;
}
bool Intersects(const Segment &l1, const Segment &l2) {
  return CCW(l1.a, l1.b, l2.a) * CCW(l1.a, l1.b, l2.b) <= 0 &&
         CCW(l2.a, l2.b, l1.a) * CCW(l2.a, l2.b, l1.b) <= 0;
}
complex<double> GetIntersection(const Line &l1, const Line &l2) {
  complex<double> a1 = l1.b - l1.a, a2 = l2.b - l2.a;
  complex<double> b1 = l2.a - l1.a, b2 = l1.a - l2.b;
  double s1 = cross(a1, b1) / 2, s2 = cross(a1, b2) / 2;
  return complex<double>(l2.a.real() + a2.real() * s1 / (s1 + s2),
                         l2.a.imag() + a2.imag() * s1 / (s1 + s2));
}
vector<complex<double> > GetIntersection(const Circle &c1, const Circle &c2) {
  vector<complex<double> > res;
  double d, a, t;
  d = sqrt(norm((c2.c - c1.c)));
  if (d < abs(c1.r - c2.r) || c1.r + c2.r < d) return res;
  a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2 * c1.r * d));
  t = atan2(c2.c.imag() - c1.c.imag(), c2.c.real() - c1.c.real());
  res.push_back(complex<double>(c1.c.real() + c1.r * cos(t + a),
                                c1.c.imag() + c1.r * sin(t + a)));
  res.push_back(complex<double>(c1.c.real() + c1.r * cos(t - a),
                                c1.c.imag() + c1.r * sin(t - a)));
  if (equals(res[0], res[1])) res.pop_back();
  return res;
}
int Contains(const vector<complex<double> > &g, const complex<double> &p) {
  Line l = Line(p, complex<double>(INF, p.imag()));
  int cnt = 0, n = g.size();
  for (int i = 0; i < n; i++) {
    complex<double> a = g[i] - p;
    complex<double> b = g[(i + 1) % n] - p;
    if (CCW(g[i], g[(i + 1) % n], p) == 0) return 2;
    if (a.imag() > b.imag()) swap(a, b);
    if (a.imag() <= EPS && EPS < b.imag() && cross(a, b) > EPS) cnt++;
  }
  if ((cnt & 1) == 1) return 1;
  return 0;
}
vector<complex<double> > AndrewScan(vector<complex<double> > &s) {
  if (s.size() <= 2) return s;
  sort(s.begin(), s.end(), comp);
  vector<complex<double> > g;
  for (int i = 0; i < s.size(); i++) {
    for (int n = g.size(); n >= 2 && CCW(g[n - 2], g[n - 1], s[i]) != CLOCKWISE;
         n--) {
      g.pop_back();
    }
    g.push_back(s[i]);
  }
  for (int i = s.size() - 2; i >= 0; i--) {
    for (int n = g.size(); CCW(g[n - 2], g[n - 1], s[i]) != CLOCKWISE; n--) {
      g.pop_back();
    }
    g.push_back(s[i]);
  }
  reverse(g.begin(), g.end());
  g.pop_back();
  return g;
}
vector<complex<double> > ConvexCut(const vector<complex<double> > &g,
                                   const Line &l) {
  vector<complex<double> > res;
  for (int i = 0; i < g.size(); i++) {
    Segment s = Segment(g[i], g[(i + 1) % g.size()]);
    if (CCW(l.a, l.b, s.a) != -1) res.push_back(s.a);
    if (CCW(l.a, l.b, s.a) * CCW(l.a, l.b, s.b) == -1)
      res.push_back(GetIntersection(l, ToLine(s)));
  }
  return res;
}
double toRad(double a) { return a / 180.0 * PI; }
double toDeg(double a) { return a * 180.0 / PI; }
complex<double> rotate(complex<double> p, double d) {
  return complex<double>(p.real() * cos(d) - p.imag() * sin(d),
                         p.real() * sin(d) + p.imag() * cos(d));
}
void get(complex<double> &p) {
  double x, y;
  scanf("%lf%lf", &x, &y);
  p = complex<double>(x, y);
}
int N;
complex<double> p;
vector<complex<double> > g;
int main() {
  scanf("%d", &N);
  get(p);
  g.resize(N);
  for (int i = 0; i < N; i++) {
    get(g[i]);
  }
  if (g.size() >= 3 && CCW(g[0], g[1], g[2]) == CLOCKWISE) {
    reverse(g.begin(), g.end());
  }
  if (g.size() >= 3 && Contains(g, p)) {
    printf("%.20lf\n", 0.0);
    return 0;
  }
  double ma = 0, mi = 1001001001001001001.0;
  for (int i = 0; i < N; i++) {
    double dx = g[i].real() - p.real(), dy = g[i].imag() - p.imag();
    double d = dx * dx + dy * dy;
    ma = max(ma, d);
    mi = min(mi, d);
    Segment S(g[i], g[(i + 1) % N]);
    d = GetDistance(S, p);
    ma = max(ma, d * d);
    mi = min(mi, d * d);
  }
  printf("%.20lf\n", (ma - mi) * PI);
  return 0;
}