#include <bits/stdc++.h>
using namespace std;
 
#define rep(i,a,n) for(int i=(a);i<(n);i++)
#define per(i,a,n) for(int i=(n)-1;i>=(a);i--)
#define mp make_pair
#define pb push_back
 
typedef double db;
 
const db EPS = 1e-8;
 
inline int sign(db a) {
	return a < -EPS ? -1 : a > EPS;
}
 
inline int cmp(db a, db b){
	return sign(a-b);
}
 
struct P {
	db x, y;
	P() {}
	P(db _x, db _y) : x(_x), y(_y) {}
	P operator+(P p) { return P(x + p.x, y + p.y); }
	P operator-(P p) { return P(x - p.x, y - p.y); }
	P operator*(db d) { return P(x * d, y * d); }
	P operator/(db d) { return P(x / d, y / d); }
	bool operator<(P p) const { 
		int c = cmp(x, p.x);
		if (c) return c == -1;
		return cmp(y, p.y) == -1;
	}
	db dot(P p) { return x * p.x + y * p.y; }
	db det(P p) { return x * p.y - y * p.x; }
	db distTo(P p) { return (*this-p).abs(); }
	db alpha() { return atan2(y, x); }
	void read() { 
		int auxx, auxy; cin >> auxx >> auxy;
		x = auxx, y = auxy;
	}
	db abs() { return sqrt(abs2());}
	db abs2() { return x * x + y * y; }
	P rot90() { return P(-y,x);}
	P unit() { return *this/abs(); }
    int quad() const { return sign(y) == 1 || (sign(y) == 0 && sign(x) >= 0); }
};
 
struct L{ //ps[0] -> ps[1]
	P ps[2];
	P& operator[](int i) { return ps[i]; }
	P dir() { return ps[1] - ps[0]; }
 	bool include(P p) { return sign((ps[1] - ps[0]).det(p - ps[0])) > 0; }
 	L push(){ // push eps outward
 		const double eps = 1e-6;
 		P delta = (ps[1] - ps[0]).rot90().unit() * eps;
 		return {ps[0] - delta, ps[1] - delta};
 	}
};
 
#define cross(p1,p2,p3) ((p2.x-p1.x)*(p3.y-p1.y)-(p3.x-p1.x)*(p2.y-p1.y))
#define crossOp(p1,p2,p3) sign(cross(p1,p2,p3))
 
P isLL(P p1, P p2, P q1, P q2) {
	db a1 = cross(q1, q2, p1), a2 = -cross(q1, q2, p2);
	return (p1 * a2 + p2 * a1) / (a1 + a2);
}
 
P isLL(L l1,L l2){ return isLL(l1[0],l1[1],l2[0],l2[1]); }
 
bool intersect(db l1,db r1,db l2,db r2){
	if(l1>r1) swap(l1,r1); if(l2>r2) swap(l2,r2); 
	return !( cmp(r1,l2) == -1 || cmp(r2,l1) == -1 );
}
 
bool isSS(P p1, P p2, P q1, P q2){
    return intersect(p1.x,p2.x,q1.x,q2.x) && intersect(p1.y,p2.y,q1.y,q2.y) && 
    crossOp(p1,p2,q1) * crossOp(p1,p2,q2) <= 0 && crossOp(q1,q2,p1)
            * crossOp(q1,q2,p2) <= 0;
}
 
bool isMiddle(db a, db m, db b) {
    return sign(a - m) == 0 || sign(b - m) == 0 || (a < m != b < m);
}
 
bool isMiddle(P a, P m, P b) {
    return isMiddle(a.x, m.x, b.x) && isMiddle(a.y, m.y, b.y);
}
 
bool onSeg(P p1, P p2, P q){
	return crossOp(p1,p2,q) == 0 && isMiddle(p1, q, p2);
}
 
 
int main() {
	ios::sync_with_stdio(0); cin.tie(0);
    int n, H;
    //
    cin >> n >> H;
    vector <P> point(n);    
    for (int i = 0; i < n; ++i) {
        point[i].read();
    }
    P o = point[n-1] + P(0, H);
    P best = point[n-1];
    db ans = 0;
    for (int i = n-1; i > 0; --i) {
        if (cross(o, best, point[i]) < 0) {
            best = point[i];
        }
        if (cross(o, best, point[i]) == 0 && cross(o, best, point[i-1]) == 0) {
            ans += point[i].distTo(point[i-1]);
        } else {
            if (cross(o, best, point[i-1]) < 0) {
                P intersection = isLL(o, best, point[i], point[i-1]);
                ans += point[i-1].distTo(intersection);
            }
        }
    } 
    cout << fixed << setprecision(10) << ans << endl;
}
