Imagine a board with n pins put into it, the i-th pin is located at (x_i, y_i). For simplicity, we will restrict the problem to the case where the pins are placed in vertices of a convex polygon.

Then, take a non-stretchable string of length l, and put it around all the pins. Place a pencil inside the string and draw a curve around the pins, trying to pull the string in every possible direction. The picture below shows an example of a string tied around the pins and pulled by a pencil (a point P).

<image>

Your task is to find an area inside this curve. Formally, for a given convex polygon S and a length l let's define a fiber shape F(S, l) as a set of points t such that the perimeter of the convex hull of S ∪ \\{t\} does not exceed l. Find an area of F(S, l).

Input

The first line contains two integers n and l (3 ≤ n ≤ 10^4; 1 ≤ l ≤ 8 ⋅ 10^5) — the number of vertices of the polygon S and the length of the string. Next n lines contain integers x_i and y_i (-10^5 ≤ x_i, y_i ≤ 10^5) — coordinates of polygon's vertices in counterclockwise order. All internal angles of the polygon are strictly less than π. The length l exceeds the perimeter of the polygon by at least 10^{-3}.

Output

Output a single floating-point number — the area of the fiber shape F(S, l). Your answer will be considered correct if its absolute or relative error doesn't exceed 10^{-6}. 

Examples

Input


3 4
0 0
1 0
0 1


Output


3.012712585980357


Input


4 5
0 0
1 0
1 1
0 1


Output


5.682061989789656


Input


5 17
0 0
2 -1
3 0
4 3
-1 4


Output


37.719371276930820

Note

The following pictures illustrate the example tests.

<image> <image>

<image>
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
#define INF 1e9
#define EPS 1e-9
#define PI (atan(1) * 4)

template <class T> int sgn(T x) { return (x > 0) - (x < 0); }
template<class T>
struct Point {
    typedef Point P;
    T x, y;
    explicit Point(T x=0, T y=0) : x(x), y(y) {}
    bool operator<(P p) const { return tie(x,y) < tie(p.x,p.y); }
    bool operator==(P p) const { return tie(x,y)==tie(p.x,p.y); }
    P operator+(P p) const { return P(x+p.x, y+p.y); }
    P operator-(P p) const { return P(x-p.x, y-p.y); }
    P operator*(T d) const { return P(x*d, y*d); }
    P operator/(T d) const { return P(x/d, y/d); }
    T dot(P p) const { return x*p.x + y*p.y; }
    T cross(P p) const { return x*p.y - y*p.x; }
    T cross(P a, P b) const { return (a-*this).cross(b-*this); }
    T dist2() const { return x*x + y*y; }
    double dist() const { return sqrt((double)dist2()); }
    double angle() const { return atan2(y, x); }
    P unit() const { return *this/dist(); }
    P perp() const { return P(-y, x); }
    P normal() const { return perp().unit(); }
    P rotate(double a) const {
        return P(x*cos(a)-y*sin(a),x*sin(a)+y*cos(a)); }
    friend ostream& operator<<(ostream& os, P p) {
        return os << "(" << p.x << "," << p.y << ")"; }
};

template<class P> vector<P> segInter(P a, P b, P c, P d) {
    auto oa = c.cross(d, a), ob = c.cross(d, b),
    oc = a.cross(b, c), od = a.cross(b, d);
    if (sgn(oa) * sgn(ob) < 0 && sgn(oc) * sgn(od) < 0)
    return {(a * ob - b * oa) / (ob - oa)};
    set<P> s;
    if (onSegment(c, d, a)) s.insert(a);
    if (onSegment(c, d, b)) s.insert(b);
    if (onSegment(a, b, c)) s.insert(c);
    if (onSegment(a, b, d)) s.insert(d);
    return {all(s)};
}

template<class P>
pair<int, P> lineInter(P s1, P e1, P s2, P e2) {
    auto d = (e1 - s1).cross(e2 - s2);
    if (d == 0) 
    	return {-(s1.cross(e1, s2) == 0), P(0, 0)};
    auto p = s2.cross(e1, e2), q = s2.cross(e2, s1);
    return {1, (s1 * p + e1 * q) / d};
}

Point<double> pts[10000];

Point<double> isect(Point<double> foci1, Point<double> foci2, Point<double> ray1, Point<double> ray2, double slack) {
    double bl = 0, br = 1e6;
    while (abs(br - bl) > EPS) {
        double bm = 0.5 * bl + 0.5 * br;
        Point<double> cpt = ray2 + (ray2 - ray1).unit() * bm;
        double cur = (cpt - foci1).dist() + (cpt - foci2).dist();
        if (cur > slack) br = bm;
        else bl = bm;
    }
    return ray2 + (ray2 - ray1).unit() * bl;
}

double constrainAngle(double x){
    x = fmod(x,PI*2);
    if (x < 0)
        x += PI*2;
    return x;
}

template<class T>
T polygonArea(vector<Point<T>>& v) {
    T a = v.back().cross(v[0]);
    rep(i,0,sz(v)-1) a += v[i].cross(v[i+1]);
    return a * 0.5;
}

bool aligned(Point<double> vec1, Point<double> vec2) {
    return vec1.dot(vec2) >= 0;
}

int main() {
    ios_base::sync_with_stdio(false); cin.tie(0);
    int n; double l; cin >> n >> l;
    for (int i = 0; i < n; i++) cin >> pts[i].x >> pts[i].y;
    double perim = 0;
    for (int i = 0; i < n; i++) perim += (pts[i] - pts[(i + 1) % n]).dist();
    
    double cur_perim = perim;
    int lft0 = 0, rt0;
    for (int i = 1; i < n; i++) {
        if (i > 1) cur_perim -= (pts[i] - pts[(i + n - 1) % n]).dist();
        
        pair<int, Point<double> > interp = lineInter(pts[0], pts[1], pts[i], pts[(i + 1) % n]);
        Point<double> inter = interp.second;
        if (interp.first != 1 || !aligned(inter - pts[1], pts[1] - pts[0]) || !aligned(pts[(i + 1) % n] - pts[i], pts[i] - inter)) {
            lft0 = 1;
            rt0 = i;
            break;
        }
        
        double new_p = cur_perim + (inter - pts[1]).dist() + (inter - pts[i]).dist();
        if (new_p >= l) {
            lft0 = 1;
            rt0 = i;
            break;
        }
    }
    
    double res = 0;
    
    vector<Point<double> > poly;
    Point<double> lb(INF, INF);
    
    int lft = lft0, rt = rt0;
    do {
        Point<double> e_ctr = (pts[lft] + pts[rt]) / 2;
        
        if (lb.x == INF) lb = isect(pts[lft], pts[rt], pts[(lft + n - 1) % n], pts[lft], l - cur_perim);
        double lb_ang = constrainAngle((lb - e_ctr).angle() - (pts[lft] - e_ctr).angle());
        
        Point<double> ub0 = isect(pts[lft], pts[rt], pts[(rt + 1) % n], pts[rt], l - cur_perim);
        double ub0_ang = constrainAngle((ub0 - e_ctr).angle() - (pts[lft] - e_ctr).angle());
        
        Point<double> ub1 = isect(pts[lft], pts[rt], pts[lft], pts[(lft + 1) % n], l - cur_perim);
        double ub1_ang = constrainAngle((ub1 - e_ctr).angle() - (pts[lft] - e_ctr).angle());
        
        double ub_ang = min(ub1_ang, ub0_ang);
        
        double c = (pts[lft] - e_ctr).dist();
        double a = (l - cur_perim) / 2;
        double b = sqrt(a * a - c * c);
        
        double lb_angc = atan(a * tan(lb_ang) / b);
        double ub_angc = atan(a * tan(ub_ang) / b);
        
        if (abs(lb_ang) > PI / 2) lb_angc += PI;
        if (abs(ub_ang) > PI / 2) ub_angc += PI;
        
        while (ub_angc < lb_angc) ub_angc += PI * 2;
        
        res += a * b * (ub_angc - lb_angc) * 0.5;
        
        vector<Point<double> > curv;
        curv.push_back(e_ctr);
        curv.push_back(lb);
        
        if (ub0_ang < ub1_ang) {
            poly.push_back(ub0);
            curv.push_back(ub0);
            lb = ub0;
            cur_perim -= (pts[rt] - pts[(rt + 1) % n]).dist();
            rt++;
            rt %= n;
        } else {
            poly.push_back(ub1);
            curv.push_back(ub1);
            lb = ub1;
            cur_perim += (pts[lft] - pts[(lft + 1) % n]).dist();
            lft++;
            lft %= n;
        }
        
        res -= polygonArea(curv);
    } while (lft != lft0 || rt != rt0);
    
    res += polygonArea(poly);
    
    cout << fixed << setprecision(7) << res;
    
    return 0;
}