#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <typename T, typename Real = double>
struct Pt {
  T x, y;
  Pt() : x(0), y(0) {}
  Pt(const T x, const T y) : x(x), y(y) {}
  template <class F>
  operator Pt<F>() const {
    return Pt<F>((F)x, (F)y);
  }
  Pt& operator=(const Pt b) {
    x = b.x, y = b.y;
    return *this;
  }
  Pt operator+(const Pt b) const { return Pt(x + b.x, y + b.y); }
  Pt operator-(const Pt b) const { return Pt(x - b.x, y - b.y); }
  template <class F>
  Pt<F> operator*(const F fac) {
    return Pt<F>(x * fac, y * fac);
  }
  template <class F>
  Pt<F> operator/(const F fac) {
    return Pt<F>(x / fac, y / fac);
  }
  T operator&(const Pt b) const { return x * b.x + y * b.y; }
  T operator^(const Pt b) const { return x * b.y - y * b.x; }
  bool operator==(const Pt b) const { return x == b.x and y == b.y; }
  bool operator<(const Pt b) const { return x == b.x ? y < b.y : x < b.x; }
  Pt operator-() const { return Pt() - *this; }
  Pt prep() const { return Pt(-y, x); }
  T norm2() const { return *this & *this; }
  double rad() const { return atan2(y, x); }
  double angle(Pt<T> a) {
    return acos((*this & a) / sqrt(norm2()) / sqrt(a.norm2()));
  }
  Pt<Real> rotate(double arg) {
    return Pt<Real>(cos(arg) * x - sin(arg) * y, sin(arg) * x + cos(arg) * y);
  }
};
template <class F>
istream& operator>>(istream& is, Pt<F>& pt) {
  return is >> pt.x >> pt.y;
}
template <class F>
ostream& operator<<(ostream& os, const Pt<F>& pt) {
  return os << pt.x << " " << pt.y;
}
template <typename T, typename Real = double>
struct Line {
  Pt<T> p1, p2;
  Line() {}
  Line(const Pt<T> x, const Pt<T> y) : p1(x), p2(y) {}
  template <class F>
  operator Line<F>() const {
    return Line<F>((Pt<F>)p1, (Pt<F>)p2);
  }
  bool operator<(Line B) const {
    Pt<T> a = vec(), b = B.vec();
    auto sgn = [](const Pt<T> t) { return (t.y == 0 ? t.x : t.y) < 0; };
    if (sgn(a) != sgn(b)) return sgn(a) < sgn(b);
    if (abs(a ^ b) == 0) return B.ori(p1) > 0;
    return (a ^ b) > 0;
  }
  Pt<T> vec() const { return p2 - p1; }
  T ori(const Pt<T> p) const { return (p2 - p1) ^ (p - p1); }
  Pt<Real> get_intersection(const Line<Real> l) {
    Pt<Real> q1 = p1, q2 = p2, qv = vec();
    return q1 + qv * (l.vec() ^ (q1 - l.p1)) / (qv ^ l.vec());
  }
  Real dis2_to_Line(const Pt<T> p, bool is_Seg = false) const {
    Pt<T> v1 = p - p1;
    if (is_Seg) {
      Pt<T> v2 = p - p2;
      if ((vec() & v1) <= 0) return abs(v1.norm2());
      if ((vec() & v2) >= 0) return abs(v2.norm2());
    }
    return (vec() ^ v1) * (vec() ^ v1) / vec().norm2();
  }
  bool is_seg_proper_intersection(const Line l) const {
    T det1 = l.ori(p1) * l.ori(p2);
    T det2 = ori(l.p1) * ori(l.p2);
    return det1 < 0 and det2 < 0;
  }
  bool is_Pt_on_Seg_properly(const Pt<T> p) const {
    return ori(p) == 0 and ((p1 - p) & (p2 - p)) < 0;
  }
  Pt<Real> projection(const Pt<T> q) const {
    Pt<Real> p = q, n = (p2 - p1).prep();
    return p - n * sqrt(dis2_to_Line(p)) / sqrt(n.norm2());
  }
};
class Solution {
  int n;

 public:
  void run() {
    int x, y;
    cin >> n >> x >> y;
    Pt<long double> orgin(x, y);
    vector<Pt<long double>> V;
    long double l = 1e18, r = -1e18;
    for (int i = 0; i < n; ++i) {
      cin >> x >> y;
      V.emplace_back(x, y);
    }
    for (int i = 0; i < n; ++i) {
      r = max(r, sqrt((V[i] - orgin).norm2()));
      l = min(l, (long double)sqrt(Line<long double>(V[i], V[(i + 1) % n])
                                       .dis2_to_Line(orgin, true)));
    }
    const long double PI = acos(-1);
    cout << fixed << setprecision(20) << PI * (r * r - l * l) << '\n';
  }
};
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  Solution().run();
}
