#include <bits/stdc++.h>
const double PI = acos(-1);
const double EP = 0.000000001;
template <class T>
T sqr(T x) {
  return x * x;
}
struct Point;
struct Vector;
struct Segment;
struct Line;
struct Polygon;
struct Point {
  double x, y;
  Point() : x(0), y(0) {}
  Point(const double& x, const double& y) : x(x), y(y) {}
  bool operator==(const Point& point) const {
    return fabs(x - point.x) < EP && fabs(y - point.y) < EP;
  }
  double disToPoint_square(const Point& other) const {
    return sqr(x - other.x) + sqr(y - other.y);
  }
  double disToPoint(const Point& other) const {
    return sqrt(disToPoint_square(other));
  }
  double disToLine(const Line& line) const;
};
struct Vector {
  double x, y;
  Vector(const double& x, const double& y) : x(x), y(y) {}
  Vector(const Point& a, const Point& b) : x(b.x - a.x), y(b.y - a.y) {}
  Vector(const Segment& seg);
  bool operator==(const Point& point) const {
    return fabs(x - point.x) < EP && fabs(y - point.y) < EP;
  }
  double length() const { return sqrt(sqr(x) + sqr(y)); }
  double cosToVector(const Vector& other) const {
    return (x * other.x + y * other.y) / (length() * other.length());
  }
  int isDirect(const Vector& other) const {
    double cosValue = cosToVector(other);
    if (fabs(cosValue - 1) < EP) return 1;
    if (fabs(cosValue + 1) < EP) return -1;
    return 0;
  }
};
struct Segment {
  Point a, b;
  Segment(const Point& a, const Point& b) : a(a), b(b) {}
  bool hasPoint(const Point& point) const {
    if (point == a || point == b) return true;
    Vector vecA(point, a);
    Vector vecB(point, b);
    return vecA.isDirect(vecB) == -1;
  }
  bool crossSegment(const Segment& other) const;
};
Vector::Vector(const Segment& seg)
    : x(seg.b.x - seg.a.x), y(seg.b.y - seg.a.y) {}
struct Line {
  double a, b, c;
  Line(const double& a, const double& b, const double& c) : a(a), b(b), c(c) {}
  Line(const Point& a, const Point& b) {
    Vector vec1(a, b);
    Vector vec2(-vec1.y, vec1.x);
    *this = Line(vec2.x, vec2.y, -a.x * vec2.x - a.y * vec2.y);
  }
  Line(const Segment& seg) : Line(seg.a, seg.b) {}
  double valueWithPoint(const Point& point) const {
    return a * point.x + b * point.y + c;
  }
  bool hasPoint(const Point& point) const {
    return fabs(valueWithPoint(point)) < EP;
  }
};
double Point::disToLine(const Line& line) const {
  return fabs(line.a * x + line.b * y + line.c) /
         sqrt(sqr(line.a) + sqr(line.b));
  ;
}
bool Segment::crossSegment(const Segment& other) const {
  Vector vecA(*this);
  Vector vecB(other);
  if (vecA.isDirect(vecB) != 0)
    return hasPoint(other.a) || hasPoint(other.b) || other.hasPoint(a) ||
           other.hasPoint(b);
  Line lineA(*this);
  Line lineB(other);
  return lineA.valueWithPoint(other.a) * lineA.valueWithPoint(other.b) <= 0 &&
         lineB.valueWithPoint(a) * lineB.valueWithPoint(b) <= 0;
}
struct Polygon {
  std::vector<Point> setPoint;
  Polygon() { setPoint.clear(); }
  Polygon(const int& sz, Point* const& points) {
    setPoint.clear();
    for (int i = 0; i < sz; ++i) setPoint.push_back(points[i]);
  }
  Polygon(std::vector<Point> points) { setPoint = points; }
  void push(const Point& point) { setPoint.push_back(point); }
  bool hasPoint(const Point& point) {
    int i, j;
    bool res = false;
    for (i = 0, j = setPoint.size() - 1; i < setPoint.size(); j = i++)
      if (((setPoint[i].y > point.y) != (setPoint[j].y > point.y)) &&
          (point.x < (setPoint[j].x - setPoint[i].x) *
                             (point.y - setPoint[i].y) /
                             (setPoint[j].y - setPoint[i].y) +
                         setPoint[i].x))
        res = !res;
    return res;
  }
};
using namespace std;
const int MAX = 1e5;
int n;
double minDis, maxDis;
Point points[MAX], center;
int main() {
  scanf("%d %lf %lf", &n, &center.x, &center.y);
  minDis = 1e9;
  maxDis = -1e9;
  for (int i = 0; i < n; ++i) {
    scanf("%lf %lf", &points[i].x, &points[i].y);
    maxDis = max(maxDis, center.disToPoint(points[i]));
  }
  Polygon pol(n, points);
  if (pol.hasPoint(center))
    printf("%.9lf", sqr(maxDis) * PI);
  else {
    for (int i = 0; i < n; ++i) {
      int j = (i + 1) % n;
      if (Vector(points[i], center).cosToVector(Vector(points[i], points[j])) <
          0)
        minDis = min(minDis, center.disToPoint(points[i]));
      else if (Vector(points[j], center)
                   .cosToVector(Vector(points[j], points[i])) < 0)
        minDis = min(minDis, center.disToPoint(points[j]));
      else
        minDis = min(minDis, center.disToLine(Line(points[i], points[j])));
    }
    printf("%.9lf", sqr(maxDis) * PI - sqr(minDis) * PI);
  }
  return 0;
}
