#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1);
int cmp(double x) {
  if (fabs(x) < eps) return 0;
  if (x > 0) return 1;
  return -1;
}
int cmp(double x, double y) { return cmp(x - y); }
inline double sqr(double x) { return x * x; }
struct point {
  double x, y;
  point() {}
  point(double a, double b) : x(a), y(b) {}
  friend point operator+(const point &a, const point &b) {
    return point(a.x + b.x, a.y + b.y);
  }
  friend point operator-(const point &a, const point &b) {
    return point(a.x - b.x, a.y - b.y);
  }
  friend bool operator==(const point &a, const point &b) {
    return cmp(a.x - b.x) == 0 && cmp(a.y - b.y) == 0;
  }
  friend bool operator<(const point &a, const point &b) {
    if (cmp(a.x - b.x) < 0) return true;
    if (cmp(a.x - b.x) > 0) return false;
    return cmp(a.y - b.y) < 0;
  }
  friend point operator*(const point &a, const double &b) {
    return point(a.x * b, a.y * b);
  }
  friend point operator*(const double &a, const point &b) {
    return point(a * b.x, a * b.y);
  }
  friend point operator/(const point &a, const double &b) {
    return point(a.x / b, a.y / b);
  }
  friend istream &operator>>(istream &fin, point &a) {
    fin >> a.x >> a.y;
    return fin;
  }
  double norm() { return sqrt(sqr(x) + sqr(y)); }
};
double det(const point &a, const point &b) { return a.x * b.y - a.y * b.x; }
double dot(const point &a, const point &b) { return a.x * b.x + a.y * b.y; }
double dist(const point &a, const point &b) { return (a - b).norm(); }
point rorate_point(const point &p, double A) {
  double tx = p.x, ty = p.y;
  return point(tx * cos(A) - ty * sin(A), tx * sin(A) + ty * cos(A));
}
struct line {
  point a, b;
  line(point x, point y) : a(x), b(y) {}
};
double dis_point_segment(const point p, const point s, const point t) {
  if (cmp(dot(p - s, t - s)) < 0) return (p - s).norm();
  if (cmp(dot(p - t, s - t)) < 0) return (p - t).norm();
  return fabs(det(s - p, t - p) / dist(s, t));
}
void PointProjLine(const point p, const point s, const point t, point &cp) {
  double r = dot((t - s), (p - s)) / dot(t - s, t - s);
  cp = s + r * (t - s);
}
bool PointOnSegment(point p, point s, point t) {
  return cmp(det(p - s, t - s)) == 0 && cmp(dot(p - s, p - t)) <= 0;
}
bool parallel(line a, line b) { return !cmp(det(a.a - a.b, b.a - b.b)); }
bool line_make_point(line a, line b, point &res) {
  if (parallel(a, b)) return false;
  double s1 = det(a.a - b.a, b.b - b.a);
  double s2 = det(a.b - b.a, b.b - b.a);
  res = (s1 * a.b - s2 * a.a) / (s1 - s2);
  return true;
}
double multiply(point sp, point ep, point op) {
  return ((sp.x - op.x) * (ep.y - op.y) - (ep.x - op.x) * (sp.y - op.y));
}
bool intersect(line u, line v) {
  return ((max(u.a.x, u.b.x) >= min(v.a.x, v.b.x)) &&
          (max(v.a.x, v.b.x) >= min(u.a.x, u.b.x)) &&
          (max(u.a.y, u.b.y) >= min(v.a.y, v.b.y)) &&
          (max(v.a.y, v.b.y) >= min(u.a.y, u.b.y)) &&
          (multiply(v.a, u.b, u.a) * multiply(u.b, v.b, u.a) >= 0) &&
          (multiply(u.a, v.b, v.a) * multiply(v.b, u.b, v.a) >= 0));
}
const int maxn = 10001;
struct polygon {
  int n;
  point a[maxn];
  double perimeter() {
    double sum = 0;
    a[n] = a[0];
    for (int i = 0; i < n; i++) sum += (a[i + 1] - a[i]).norm();
    return sum;
  }
  double area() {
    double sum = 0;
    a[n] = a[0];
    for (int i = 0; i < n; i++) sum += det(a[i + 1], a[i]);
    return sum / 2.;
  }
  int Point_In(point t) {
    int num = 0, i, d1, d2, k;
    a[n] = a[0];
    for (int i = 0; i < n; i++) {
      if (PointOnSegment(t, a[i], a[i + 1])) return 2;
      k = cmp(det(a[i + 1] - a[i], t - a[i]));
      d1 = cmp(a[i].y - t.y);
      d2 = cmp(a[i + 1].y - t.y);
      if (k > 0 && d1 <= 0 && d2 > 0) num++;
      if (k < 0 && d2 <= 0 && d1 > 0) num++;
    }
    return num & 1;
  }
};
struct polygon_convex {
  vector<point> P;
  polygon_convex(int Size = 0) { P.resize(Size); }
};
bool comp_less(const point &a, const point &b) {
  return cmp(a.x - b.x) < 0 || cmp(a.x - b.x) == 0 && cmp(a.y - b.y) < 0;
}
polygon_convex convex_hull(vector<point> a) {
  polygon_convex res(2 * a.size() + 5);
  sort(a.begin(), a.end(), comp_less);
  a.erase(unique(a.begin(), a.end()), a.end());
  int m = 0;
  for (int i = 0; i < a.size(); ++i) {
    while (m > 1 &&
           cmp(det(res.P[m - 1] - res.P[m - 2], a[i] - res.P[m - 2])) <= 0)
      --m;
    res.P[m++] = a[i];
  }
  int k = m;
  for (int i = int(a.size()) - 2; i >= 0; --i) {
    while (m > k &&
           cmp(det(res.P[m - 1] - res.P[m - 2], a[i] - res.P[m - 2])) <= 0)
      --m;
    res.P[m++] = a[i];
  }
  res.P.resize(m);
  if (a.size() > 1) res.P.resize(m - 1);
  return res;
}
int containOlogn(const polygon_convex &a, const point &b) {
  int n = a.P.size();
  point g = (a.P[0] + a.P[n / 3] + a.P[2 * n / 3]) / 3.0;
  int l = 0, r = n;
  while (l + 1 < r) {
    int mid = (l + r) / 2;
    if (cmp(det(a.P[l] - g, a.P[mid] - g)) > 0) {
      if (cmp(det(a.P[l] - g, b - g)) >= 0 && cmp(det(a.P[mid] - g, b - g)) < 0)
        r = mid;
      else
        l = mid;
    } else {
      if (cmp(det(a.P[l] - g, b - g)) < 0 && cmp(det(a.P[mid] - g, b - g)) >= 0)
        l = mid;
      else
        r = mid;
    }
  }
  r %= n;
  int z = cmp(det(a.P[r] - b, a.P[l] - b)) - 1;
  if (z == -2) return 1;
  return z;
}
bool containOn(const polygon_convex &a, const point &b) {
  int n = a.P.size();
  int sign = 0;
  for (int i = 0; i < n; ++i) {
    int x = cmp(det(a.P[i] - b, a.P[((i + 1) % n)] - b));
    if (x) {
      if (sign) {
        if (sign != x) return false;
      } else
        sign = x;
    }
  }
  return true;
}
bool inaline(line a, line b) {
  if (!parallel(a, b)) return false;
  if (cmp(det(a.a - a.b, a.a - b.a)) == 0) return true;
  return false;
}
const double INF = 10000;
double arg(const point &p) { return atan2(p.y, p.x); }
inline double satisfy(point a, pair<point, point> p) {
  return cmp(det(a - p.first, p.second - p.first)) <= 0;
}
point crosspoint(const pair<point, point> &a, const pair<point, point> &b) {
  double k = det(b.first - b.second, a.first - b.second);
  k = k / (k - det(b.first - b.second, a.second - b.second));
  return a.first + (a.second - a.first) * k;
}
bool cmpp(const pair<point, point> &a, const pair<point, point> &b) {
  int res = cmp(arg(a.second - a.first) - arg(b.second - b.first));
  return res == 0 ? satisfy(a.first, b) : res < 0;
}
vector<point> HalfplaneIntersection(vector<pair<point, point> > v) {
  sort(v.begin(), v.end(), cmpp);
  deque<pair<point, point> > q;
  deque<point> ans;
  q.push_back(v[0]);
  for (int i = 1; i < v.size(); ++i) {
    if (cmp(arg(v[i].second - v[i].first) -
            arg(v[i - 1].second - v[i - 1].first)) == 0) {
      continue;
    }
    while (ans.size() > 0 && !satisfy(ans.back(), v[i])) {
      ans.pop_back();
      q.pop_back();
    }
    while (ans.size() > 0 && !satisfy(ans.front(), v[i])) {
      ans.pop_front();
      q.pop_front();
    }
    ans.push_back(crosspoint(q.back(), v[i]));
    q.push_back(v[i]);
  }
  while (ans.size() > 0 && !satisfy(ans.back(), q.front())) {
    ans.pop_back();
    q.pop_back();
  }
  while (ans.size() > 0 && !satisfy(ans.front(), q.back())) {
    ans.pop_front();
    q.pop_front();
  }
  ans.push_back(crosspoint(q.back(), q.front()));
  return vector<point>(ans.begin(), ans.end());
}
vector<point> convexIntersection(vector<point> v1, vector<point> v2) {
  vector<pair<point, point> > h;
  for (int i = 0; i < v1.size(); ++i)
    h.push_back(pair<point, point>(v1[i], v1[(i + 1) % v1.size()]));
  for (int i = 0; i < v2.size(); ++i)
    h.push_back(pair<point, point>(v2[i], v2[(i + 1) % v2.size()]));
  return HalfplaneIntersection(h);
}
int n;
point o, x;
int main() {
  double mmax = 0, mmin = 1e9;
  cin >> n >> o;
  vector<point> v;
  for (int i = 0; i < n; ++i) {
    cin >> x;
    mmax = max(dist(x, o), mmax);
    mmin = min(dist(x, o), mmin);
    v.push_back(x);
  }
  v.push_back(*v.begin());
  for (int i = 0; i < v.size() - 1; ++i) {
    point cp;
    PointProjLine(o, v[i], v[i + 1], cp);
    if (PointOnSegment(cp, v[i], v[i + 1]))
      mmin = min(mmin, dis_point_segment(o, v[i], v[i + 1]));
  }
  printf("%.10f\n", (sqr(mmax) - sqr(mmin)) * pi);
}
