#pragma GCC optimize ("O3")
#pragma GCC optimize ("unroll-loops")
#include <vector>
#pragma GCC target ("avx2")

#include<bits/stdc++.h>
#include<math.h>
using namespace std;

typedef long long int ll;
typedef long double ld;
typedef pair<ll, ll> pl;
typedef vector<ll> vl;
#define FD(i, r, l) for(ll i = r; i > (l); --i)

#define K first
#define V second
#define G(x) ll x; cin >> x;
#define GD(x) ld x; cin >> x;
#define GS(s) string s; cin >> s;
#define EX(x) { cout << x << '\n'; exit(0); }
#define A(a) (a).begin(), (a).end()
#define F(i, l, r) for (ll i = l; i < (r); ++i)

template<typename A, typename B>
A& chmax(A &a, B b) { return a < b ? (a=b): a; }

template<typename A, typename B>
A& chmin(A &a, B b) { return a > b ? (a=b): a; }




const ll N = 1e5 + 10;
const ll M = 1000000007; // 998244353

ll myceil(ll h, ll s) {
    return (h + s - 1) / s;
}

ll dumbsolve(vector<pl> a, ll w, ll MX) {
    if (!a.size()) return 0;
    // str, hp order 
    auto cost = [](ll str, pl mon) {
        auto [e, h] = mon;
        return (myceil(h, str) - 1) * e;
    };

    a.insert(a.begin(), pair(w, 1ll)); // dummy value here for W starting strength

    vl dp(a.size());
    FD(i, ll(a.size()) - 2, -1) {
        ll cum = 0;
        dp[i] = 1e18;
        F(j, i + 1, a.size()) {
            chmin(dp[i], dp[j] + cum + cost(a[i].K, a[j]));
            cum += cost(MX, a[j]);
        }
    }

    for (auto x: dp) cout << x << " "; cout << endl;

    return dp[0];
}



#define L 20

namespace lztree {
    typedef ll T;
    typedef ll U;

    T idT = 1e18, t[2 * N];
    U idU = 0, d[N];
    ll x = (fill_n(d, N, idU), 0);

    // combining segtree nodes a and b
    T f(T a, T b) { return min(a, b); }
    // applying updates a and b (in that order)
    U g(U b, U a) { return a + b; }
    // applying update b to segtree node a
    T h(U b, T a) { return a + b; }

    void calc(ll p) { t[p] = h(d[p], f(t[p * 2], t[p * 2 + 1])); }

    void apply(ll p, U v) {
        t[p] = h(v, t[p]);
        if(p < N) d[p] = g(v, d[p]);
    }

    void push(ll p) {
        p += N;
        FD(s, L, 0) {
            ll i = p >> s;
            if(d[i] != idU) {
                apply(i * 2, d[i]);
                apply(i * 2 + 1, d[i]);
                d[i] = idU;
            }
        }
    }

    void modify(ll p, T v) {
        push(p);
        t[p += N] = v;
        while(p > 1) calc(p /= 2);
    }

    void subtract(ll p, ll v) {
        push(p);
        t[p += N] -= v;
        while(p > 1) calc(p /= 2);
    }

    void modify(ll l, ll r, U v) {
        push(l), push(r - 1);
        bool cl = false, cr = false;
        for(l += N, r += N; l < r; l /= 2, r /= 2) {
            if(cl) calc(l - 1);
            if(cr) calc(r);
            if(l & 1) apply(l++, v), cl = true;
            if(r & 1) apply(--r, v), cr = true;
        }
        for(--l; r; l /= 2, r /= 2) {
            if(cl) calc(l);
            if(cr) calc(r);
        }
    }

    T query(ll l, ll r) {
        push(l), push(r - 1);
        T resl = idT, resr = idT;
        for(l += N, r += N; l < r; l /= 2, r /= 2) {
            if(l & 1) resl = f(resl, t[l++]);
            if(r & 1) resr = f(t[--r], resr);
        }
        return f(resl, resr);
    }
}

ll solve(vector<pl> a, ll w, ll MX) {
    if (!a.size()) return 0;
    // str, hp order 
    auto cost = [](ll str, pl mon) {
        auto [e, h] = mon;
        return (myceil(h, str) - 1) * e;
    };

    a.insert(a.begin(), pair(w, 1ll)); // dummy value here for W starting strength

    ll n = a.size();
    vl costs(n); // cost(i, j) values that may need to be updated

    F(i, 0, n) lztree::modify(i, 0);
    
    priority_queue<pl> pq; // strength threshold of next update, index. 

    pq.emplace(MX + 1, n - 1); // cost of ending guy 

    vl dps; dps.emplace_back(0);

    FD(i, n - 2, -1) {
        // process any dp values that may or may not need to be updated 
        auto [CSTR, CH] = a[i];

        while (pq.size() and pq.top().K >= CSTR) {
            auto [str, idx] = pq.top(); pq.pop();
            lztree::subtract(idx, costs[idx]);
            costs[idx] = cost(CSTR, a[idx]);
            lztree::subtract(idx, -costs[idx]);


            // find strength threshold of next update 
            // maybe there's a better way to do this shit than bsearching lol 

            ll ans = 0;
            FD(i, 17, -1) {
                ll cur = ans + (1<<i);
                if (CSTR - cur <= 0) continue;
                ll nstr = CSTR - cur;
                if (myceil(a[idx].V, nstr) == myceil(a[idx].V, CSTR)) ans += 1<<i; 
            }

            assert(myceil(a[idx].V, CSTR - ans) == myceil(a[idx].V, CSTR));
            
            if (CSTR - ans - 1 > 0) {
                assert(myceil(a[idx].V, CSTR - ans - 1) != myceil(a[idx].V, CSTR));
            }

            pq.emplace(CSTR - ans - 1, idx); 

            // pq.emplace(str - 1, idx);            
        }
        // if (i == 0) {
        //     cout << "WHAT??? " << lztree::query(1, 2) << " " << lztree::query(2, 3) << endl;
        //     cout << costs[1] << " " << costs[2] << endl;
        // }

        lztree::modify(i, lztree::query(i + 1, n));

        dps.emplace_back(lztree::query(i, i+1));
        if (i == 0) {
            reverse(A(dps));

            // for (auto x: dps) cout << x << " "; cout << endl;

            return lztree::query(0, 1);
        }
        lztree::modify(i + 1, n, cost(MX, a[i]));
        pq.emplace(MX + 1, i);
    }

    assert(false);
}

int main(){
//    freopen("a.in", "r", stdin);
//    freopen("a.out", "w", stdout);

    ios_base::sync_with_stdio(false); cin.tie(0);
    cout << fixed << setprecision(20);
    G(n) G(w)
    map<ll, vl> str;

    while (n--) {
        G(x) G(y) str[x].emplace_back(y);
    }

    ll MX = max(w, str.rbegin()->K);

    vector<pl> mons;

    ll base = 0;
    for (auto [x, y]: str) {
        sort(A(y)); 
        if (x > w) {
            mons.emplace_back(x, y[0]);
        }
        while (y.size() > (x > w)) {
            auto v = y.back(); y.pop_back();
            base += (myceil(v, MX) - 1) * x; 
        }
    }

    // for (auto [x ,y]: mons) cout << x << " " << y << endl;

    // auto x = solve(mons, w, MX);
    // auto y = dumbsolve(mons, w, MX);

    // if (x - y) {
    //     cout << "WTF " << x << " " << y << endl;
    // }
    // assert(x == y);

    // cout << solve(mons, w, MX) << endl;

    // assert(solve(mons, w, MX) == dumbsolve(mons, w, MX));

    cout << base + solve(mons, w, MX) << endl;
}