#include <bits/stdc++.h>

#define FOR(i, l, r) for (int i = l; i <= r; ++i)
#define FORD(i, r, l) for (int i = r; i >= l; --i)
#define ll long long
#define pb push_back
#define all(x) (x).begin(), (x).end()
using namespace std;

const int N = 2e5;
int n, m;
ll a[N + 3], b[N + 3], s[N + 3], f[N + 3];

void maximize(ll &a, ll b) {
    if (a < b) a = b;
}

ll M(ll s,ll f,int pos) {
    return (f - s) * max(a[pos], b[pos]);
}
ll cal(int pos,ll val) {
    return (f[pos] - s[pos]) * val;
}

namespace sub1 {
    void solve() {
        cout << M(s[1], f[1], 1);
    }
}

namespace sub2 {
    void solve() {
        int l = max(s[1] , s[2]);
        int r = min(f[1] , f[2]);
        if(l > r || m == 2) cout << M(s[1] , f[1] , 1) + M(s[2] , f[2] , 2);
        else{
            ll beforeLR = 0,inLR = 0,afterLR = 0;
            if(s[1] < l) beforeLR = M(s[1] , l , 1);
            else beforeLR = M(s[2] , l , 2);

            inLR = (r - l) * (b[1] + b[2] + max({0ll , a[1] -  b[1] , a[2] - b[2]}));
            if(f[1] >= r) afterLR = M(r , f[1] , 1);
            else afterLR = M(r , f[2] , 2);

            cout << beforeLR + inLR + afterLR;
        }
    }
}

namespace sub3 {
    ll dp[203][203], pre[203];
    vector<int> pos;
    void solve(){
        memset(dp , -0x3f , sizeof(dp));
        FOR(i, 1, n) pos.pb(s[i]), pos.pb(f[i]);
        sort(all(pos));
        m = min(m, n);
        dp[0][0] = 0;

        FOR(j, 1, 2 * n - 1) {
            vector<ll> dif;
            int l = pos[j - 1];
            int r = pos[j];
            ll sum = 0;
            FOR(i, 1, n)
                if(s[i] <= l && r <= f[i]){
                    sum += b[i];
                    dif.pb(a[i] - b[i]);
                }

            sort(all(dif), greater<ll>());
            int k = min(m,(int) dif.size());

            FOR(o, 1, k) pre[o] = pre[o - 1] + max(0ll ,dif[o - 1]);
            FOR(x, 0, m) FOR(y, 0, x) {
                maximize(dp[j][x], dp[j - 1][y] + (sum + pre[min(k, x)]) * (r - l) * 1ll);
            }
        }

        ll ans = -1e18;
        FOR(j , 0 , m) ans = max(ans , dp[2 * n - 1][j]);
        cout << ans;
    }
}

namespace sub4 {
    struct Event {
        int Time, id, Type;

        Event(int x = 0, int y = 0, int z = 0) {
            Time = x;
            id = y;
            Type = z;
        }

        bool operator < (const Event &ot) const {
            if (Time != ot.Time) return Time < ot.Time;
            return Type > ot.Type;
        }
    };

    vector <Event> Events;
    multiset <ll> best, temp;
    ll sum, res, ans;

    void add(ll profit) {
	// bỏ qua các số bé hoặc bằng 0 vì khi nhận nó kết quả sẽ không tối ưu
        if (profit <= 0) return ;
        if ((int) best.size() < m) {
            sum += profit;
            best.insert(profit);
        }

        else if (profit > (*best.begin())) {
            multiset <ll> :: iterator it = best.begin();
            ll val = *it;
            sum -= val;
            best.erase(it);
            temp.insert(val);

            best.insert(profit);
            sum += profit;
        }

        else temp.insert(profit);
    }

    void del(ll profit) {
	// bỏ qua các số bé hoặc bằng 0 vì khi nhận nó kết quả sẽ không tối ưu
        if (profit <= 0) return ;
        if (best.find(profit) != best.end()) {
            best.erase(best.find(profit));
            sum -= profit;

            if (!temp.empty()) {
                multiset <ll> :: iterator it = prev(temp.end());
                ll val = *it;
                temp.erase(it);

                best.insert(val);
                sum += val;
            }
        }

        else if (temp.find(profit) != temp.end())
            temp.erase(temp.find(profit));
    }

    void solve() {
        FOR(i, 1, n) {
            Events.push_back(Event(s[i], i, 1));
            Events.push_back(Event(f[i], i, -1));
        }
        sort(Events.begin(), Events.end());

        int it = 0;
        while (it < 2 * n) {
            int T = Events[it].Time;

            while (it < 2 * n && Events[it].Time == T) {
                int id = Events[it].id;
                int Type = Events[it].Type;

                if (Type == 1) {
                    res += b[id];
                    add(a[id] - b[id]);
                }

                else {
                    res -= b[id];
                    del(a[id] - b[id]);
                }

                ++it;
            }

            if (it < 2 * n) {
                ll Length = Events[it].Time - T;
                ans += Length * (res + sum);
            }
        }

        cout << ans;
    }
}

signed main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);

    freopen("AICONF.inp" , "r" , stdin);
    freopen("AICONF.out" , "w" , stdout);

    cin >> n >> m;
    FOR(i, 1, n) cin >> a[i] >> b[i] >> s[i] >> f[i];

    if (n == 1) sub1::solve();
    else if (n == 2) sub2::solve();
    else if (n <= 100) sub3::solve();
    else sub4::solve();

    return 0;
}