#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
using namespace std;
const double eps = 1e-9;
struct Point {
  long double first, second;
  Point() : first(0), second(0) {}
  Point(double _x, double _y) : first(_x), second(_y) {}
  Point(pair<double, double> t) : first(t.first), second(t.second) {}
  inline long double squaredDistance(Point p) const {
    return (first - p.first) * (first - p.first) +
           (second - p.second) * (second - p.second);
  }
  inline double distance(Point p) const {
    return sqrt((first - p.first) * (first - p.first) +
                (second - p.second) * (second - p.second));
  }
  inline bool equals(Point other) const {
    return abs(first - other.first) < eps && abs(second - other.second) < eps;
  }
};
inline Point operator+(const Point &a, const Point &b) {
  return Point(a.first + b.first, a.second + b.second);
}
inline Point operator-(const Point &a, const Point &b) {
  return Point(a.first - b.first, a.second - b.second);
}
inline Point operator*(const Point &a, const double &b) {
  return Point(a.first * b, a.second * b);
}
inline Point operator/(const Point &a, const double &b) {
  return Point(a.first / b, a.second / b);
}
inline double vec(const Point &a, const Point &b) {
  return a.first * b.second - b.first * a.second;
}
inline double scal(const Point &a, const Point &b) {
  return a.first * b.first + a.second * b.second;
}
struct Line {
  long double a, b, c;
  Line() : a(0), b(0), c(0) {}
  Line(double _a, double _b, double _c) : a(_a), b(_b), c(_c) { normalize(); }
  Line(const Point &t1, const Point &t2) {
    a = t2.second - t1.second;
    b = t1.first - t2.first;
    c = -a * t1.first - b * t1.second;
    normalize();
  }
  inline bool degenerate() {
    return abs(a) < eps && abs(b) < eps && abs(c) < eps;
  }
  inline void normalize() {
    long double h = sqrt(a * a + b * b);
    if (a < -eps || (abs(a) < eps && b < -eps) ||
        (abs(a) < eps && abs(b) < eps && c < -eps)) {
      a = -a;
      b = -b;
      c = -c;
    }
    if (h < eps) return;
    a /= h;
    b /= h;
    c /= h;
  }
  inline Point intersect(Line other) {
    if (parallel(other)) return Point(-1e100, -1e100);
    double det = b * other.a - a * other.b;
    double first = (c * other.b - b * other.c) / det;
    double second = (a * other.c - c * other.a) / det;
    return Point(first, second);
  }
  inline bool parallel(Line other) {
    return abs(a * other.b - b * other.a) < eps;
  }
  inline long double evaluate(Point point) {
    return a * point.first + b * point.second + c;
  }
  inline bool contains(Point point) { return abs(evaluate(point)) < eps; }
  inline Line perpendicular(Point point) {
    return Line(-b, a, b * point.first - a * point.second);
  }
  inline long double distance(Point point) { return abs(evaluate(point)); }
};
struct Circle {
  Point center;
  double radius;
  Circle() : radius(0) {}
  Circle(Point _center, double _radius) : center(_center), radius(_radius) {}
  bool contains(Point point) { return center.distance(point) < radius + eps; }
  bool strictlyContains(Point point) {
    return center.distance(point) + eps < radius;
  }
  vector<Point> findTouchingPoints(Point point) {
    double distance = center.distance(point);
    if (distance + eps < radius) return vector<Point>();
    if (distance < radius + eps) return vector<Point>(1, point);
    Circle p(point, sqrt((distance - radius) * (distance + radius)));
    return intersect(p);
  }
  vector<Point> intersect(Line line) {
    double distance = line.distance(center);
    if (distance > radius + eps) return vector<Point>();
    Point intersection = line.intersect(line.perpendicular(center));
    if (abs(distance - radius) < eps) return vector<Point>(1, intersection);
    double shift = sqrt(radius * radius - distance * distance);
    vector<Point> ans;
    ans.push_back(Point(intersection.first + shift * line.b,
                        intersection.second - shift * line.a));
    ans.push_back(Point(intersection.first - shift * line.b,
                        intersection.second + shift * line.a));
    return ans;
  }
  vector<Point> intersect(Circle other) {
    double distance = center.distance(other.center);
    if (distance > radius + other.radius + eps ||
        abs(radius - other.radius) > distance + eps)
      return vector<Point>();
    double p = (radius + other.radius + distance) / 2;
    double h = 2.0 *
               sqrt(p * (p - radius) * (p - other.radius) * (p - distance)) /
               distance;
    double l1 = sqrt(radius * radius - h * h);
    double l2 = sqrt(other.radius * other.radius - h * h);
    if (radius * radius + distance * distance < other.radius * other.radius)
      l1 = -l1;
    if (radius * radius > distance * distance + other.radius * other.radius)
      l2 = -l2;
    Point middle((center.first * l2 + other.center.first * l1) / (l1 + l2),
                 (center.second * l2 + other.center.second * l1) / (l1 + l2));
    Line line(center, other.center);
    return intersect(line.perpendicular(middle));
  }
};
struct Segment {
  Point a, b;
  double distance_;
  Line line_;
  Segment() : distance_(-2), line_(0, 0, 0) {}
  Segment(Point _a, Point _b) : a(_a), b(_b), distance_(-2), line_(0, 0, 0) {}
  inline double length() {
    if (distance_ < -1) {
      distance_ = a.distance(b);
    }
    return distance_;
  }
  inline Line line() {
    if (line_.degenerate()) {
      line_ = Line(a, b);
    }
    return line_;
  }
  inline long double distance(Point point) {
    long double length = this->length();
    long double left = point.distance(a);
    if (length < eps) return left;
    long double right = point.distance(b);
    if (left * left > right * right + length * length) return right;
    if (right * right > left * left + length * length) return left;
    return line().distance(point);
  }
  inline bool contains(Point point, bool includeEnds) {
    if (a.equals(point) || b.equals(point)) return includeEnds;
    if (a.equals(b)) return 0;
    Line line = this->line();
    if (!line.contains(point)) return 0;
    Line perpendicular = line.perpendicular(a);
    double A = perpendicular.evaluate(a);
    double B = perpendicular.evaluate(b);
    double P = perpendicular.evaluate(point);
    return (A < P && P < B) || (B < P && P < A);
  }
  inline Point intersect(Segment other, bool includeEnds) {
    Line line = this->line();
    Line otherLine(other.a, other.b);
    if (line.parallel(otherLine)) return Point(-1e100, -1e100);
    Point intersection = line.intersect(otherLine);
    if (contains(intersection, includeEnds) &&
        other.contains(intersection, includeEnds))
      return intersection;
    return make_pair(-1e100, -1e100);
  }
  inline Point middle() {
    return Point((a.first + b.first) / 2, (a.second + b.second) / 2);
  }
  vector<Point> intersect(Circle circle) {
    vector<Point> result = circle.intersect(line());
    if (result.empty()) return result;
    if ((int)result.size() == 1) {
      if (contains(result[0], true)) return result;
      return vector<Point>();
    }
    if (contains(result[0], true)) {
      if (contains(result[1], true)) return result;
      return vector<Point>(1, result[0]);
    }
    if (contains(result[1], true)) return vector<Point>(1, result[1]);
    return vector<Point>();
  }
};
int a, b, c, d, n, m, k;
int main() {
  int first, second;
  scanf("%d%d%d", &n, &first, &second);
  long double mn = 8LL * 1000000000 * 1000000000;
  long double mx = -1;
  pair<int, int> last, fir;
  Point p(first, second);
  for (int _n((n + 1) - 1), i(0); i <= _n; i++) {
    if (i == n) {
      a = fir.first;
      b = fir.second;
    } else {
      scanf("%d%d", &a, &b);
    }
    if (!i) {
      fir = make_pair(a, b);
    }
    long long cur = (long long)(a - first) * (a - first) +
                    (long long)(b - second) * (b - second);
    if (cur < mn) mn = cur;
    if (cur > mx) mx = cur;
    if (i) {
      Point p1(last.first, last.second);
      Point p2(a, b);
      Segment s(p1, p2);
      auto d = s.distance(p);
      d *= d;
      if (d < mn) {
        mn = d;
      }
      if (d > mx) {
        mx = d;
      }
    }
    last = make_pair(a, b);
  }
  long double ans = 3.1415926535897932384626433832795028841971 * (mx - mn);
  cout.precision(12);
  cout << fixed << ans << endl;
}
