#include <bits/stdc++.h>
using namespace std; 
typedef long long i64; 
const int N = 200005; 

int n, m, nn; 
struct Cake {
    int v, c; 
    bool operator< (const Cake &a) const { return c < a.c; }
} a[N]; 
int b[N]; 

struct Node {
    int ls, rs; 
    int siz; i64 sum; 
} T[N * 40]; 
int rt[N], tot; 
int update(int pre, int l, int r, int x, int v) {
    int o = ++tot; T[o] = T[pre]; ++T[o].siz; T[o].sum += v; 
    if (l == r) return o; 
    int mid = l + r >> 1; 
    if (x <= mid) T[o].ls = update(T[pre].ls, l, mid, x, v); 
    else T[o].rs = update(T[pre].rs, mid + 1, r, x, v); 
    return o; 
}
i64 query(int p, int q, int l, int r, int k) { // 值域在 [l, r] 中的 V 最大 k 个的答案
    if (l == r) return 1ll * k * b[l]; 
    int mid = l + r >> 1, res = T[T[q].rs].siz - T[T[p].rs].siz; 
    if (res >= k) return query(T[p].rs, T[q].rs, mid + 1, r, k); 
    return query(T[p].ls, T[q].ls, l, mid, k - res) + T[T[q].rs].sum - T[T[p].rs].sum; 
}

i64 ans; 
inline i64 calc(int l, int r) { return query(rt[l - 1], rt[r], 1, nn, m) - 2 * (a[r].c - a[l].c); }

void solve(int l, int r, int L, int R) { // 决策区间 [L, R]
    if (l > r) return; 
    int mid = l + r >> 1, p = 0, RR = min(R, mid - m + 1); 
    i64 mx = -1e18; 
    for (int i = L; i <= RR; ++i) {
        i64 w = calc(i, mid); 
        if (w > mx) mx = w, p = i; 
    } ans = max(ans, mx); 
    solve(l, mid - 1, L, p); solve(mid + 1, r, p, R); 
}

int main(void) {
    ios::sync_with_stdio(0); 
    cin >> n >> m; 
    for (int i = 1; i <= n; ++i) cin >> a[i].v >> a[i].c, b[i] = a[i].v; 
    sort(b + 1, b + n + 1); sort(a + 1, a + n + 1); 
    nn = unique(b + 1, b + n + 1) - (b + 1); 
    for (int i = 1; i <= n; ++i) rt[i] = update(rt[i - 1], 1, nn, lower_bound(b + 1, b + nn + 1, a[i].v) - b, a[i].v); 
    solve(m, n, 1, n); 
    cout << ans << "\n"; 
    return 0; 
}