#include <bits/stdc++.h>

using i64 = long long;

template<class Info, class Tag>
struct LazySegmentTree {
    int n;
    std::vector<Info> info;
    std::vector<Tag> tag;
    LazySegmentTree() : n(0) {}
    LazySegmentTree(int n_, Info v_ = Info()) {
        init(n_, v_);
    }
    template<class T>
    LazySegmentTree(std::vector<T> init_) {
        init(init_);
    }
    void init(int n_, Info v_ = Info()) {
        init(std::vector(n_, v_));
    }
    template<class T>
    void init(std::vector<T> init_) {
        n = init_.size();
        info.assign(4 << std::__lg(n), Info());
        tag.assign(4 << std::__lg(n), Tag());
        std::function<void(int, int, int)> build = [&](int p, int l, int r) {
            if (r - l == 1) {
                info[p] = init_[l];
                return;
            }
            int m = (l + r) / 2;
            build(2 * p, l, m);
            build(2 * p + 1, m, r);
            pull(p);
        };
        build(1, 0, n);
    }
    void pull(int p) {
        info[p] = info[2 * p] + info[2 * p + 1];
    }
    void apply(int p, const Tag &v) {
        info[p].apply(v);
        tag[p].apply(v);
    }
    void push(int p) {
        apply(2 * p, tag[p]);
        apply(2 * p + 1, tag[p]);
        tag[p] = Tag();
    }
    void modify(int p, int l, int r, int x, const Info &v) {
        if (r - l == 1) {
            info[p] = v;
            return;
        }
        int m = (l + r) / 2;
        push(p);
        if (x < m) {
            modify(2 * p, l, m, x, v);
        } else {
            modify(2 * p + 1, m, r, x, v);
        }
        pull(p);
    }
    void modify(int p, const Info &v) {
        modify(1, 0, n, p, v);
    }
    Info rangeQuery(int p, int l, int r, int x, int y) {
        if (l >= y || r <= x) {
            return Info();
        }
        if (l >= x && r <= y) {
            return info[p];
        }
        int m = (l + r) / 2;
        push(p);
        return rangeQuery(2 * p, l, m, x, y) + rangeQuery(2 * p + 1, m, r, x, y);
    }
    Info rangeQuery(int l, int r) {
        return rangeQuery(1, 0, n, l, r);
    }
    void rangeApply(int p, int l, int r, int x, int y, const Tag &v) {
        if (l >= y || r <= x) {
            return;
        }
        if (l >= x && r <= y) {
            apply(p, v);
            return;
        }
        int m = (l + r) / 2;
        push(p);
        rangeApply(2 * p, l, m, x, y, v);
        rangeApply(2 * p + 1, m, r, x, y, v);
        pull(p);
    }
    void rangeApply(int l, int r, const Tag &v) {
        return rangeApply(1, 0, n, l, r, v);
    }
    template<class F>
    int findFirst(int p, int l, int r, int x, int y, F pred) {
        if (l >= y || r <= x || !pred(info[p])) {
            return -1;
        }
        if (r - l == 1) {
            return l;
        }
        int m = (l + r) / 2;
        push(p);
        int res = findFirst(2 * p, l, m, x, y, pred);
        if (res == -1) {
            res = findFirst(2 * p + 1, m, r, x, y, pred);
        }
        return res;
    }
    template<class F>
    int findFirst(int l, int r, F pred) {
        return findFirst(1, 0, n, l, r, pred);
    }
    template<class F>
    int findLast(int p, int l, int r, int x, int y, F pred) {
        if (l >= y || r <= x || !pred(info[p])) {
            return -1;
        }
        if (r - l == 1) {
            return l;
        }
        int m = (l + r) / 2;
        push(p);
        int res = findLast(2 * p + 1, m, r, x, y, pred);
        if (res == -1) {
            res = findLast(2 * p, l, m, x, y, pred);
        }
        return res;
    }
    template<class F>
    int findLast(int l, int r, F pred) {
        return findLast(1, 0, n, l, r, pred);
    }
};

constexpr i64 inf = 4E18;

struct Tag {
    i64 tag = 0, bec = 0;
    i64 add = 0;
    void apply(const Tag &t) {
        if (t.tag) {
            *this = t;
        } else if (tag) {
            bec += t.add;
        } else {
            add += t.add;
        }
    }
};

struct Info {
    i64 x = inf;
    void apply(const Tag &t) {
        if (t.tag) {
            x = t.bec;
        } else {
            x += t.add;
        }
    }
};

Info operator+(const Info &a, const Info &b) {
    return Info{std::min(a.x, b.x)};
}

void solve() {
    int n, m;
    std::cin >> n >> m;

    std::vector<int> v {0};
    std::vector<int> a(n), b(n);
    for (int i = 0; i < n; i++) {
        std::cin >> a[i] >> b[i];
        v.push_back(a[i]);
        v.push_back(a[i] - 1);
    }

    std::sort(v.begin(), v.end());
    v.erase(std::unique(v.begin(), v.end()), v.end());
    for (int i = 0; i < n; i++) {
        a[i] = std::lower_bound(v.begin(), v.end(), a[i]) - v.begin();
    }

    int K = v.size();

    // std::vector<i64> f(K, -inf);
    // f[0] = 0;

    // for (int i = 0; i < n; i++) {
    //     auto g = f;
    //     for (int j = 1; j < K; j++) {
    //         g[j] = std::max(g[j], g[j - 1] - 1LL * (v[j] - v[j - 1]) * m);
    //     }
    //     for (int j = a[i]; j < K; j++) {
    //         g[j] += b[i];
    //     }
    //     for (int j = K - 2; j >= 0; j--) {
    //         g[j] = std::max(g[j], g[j + 1]);
    //     }
    //     f = std::move(g);
    // }

    LazySegmentTree<Info, Tag> seg(K);
    for (int i = 0; i < K; i++) {
        seg.modify(i, Info{-1LL * v[i] * m});
    }
    for (int i = 0; i < n; i++) {
        i64 p = seg.rangeQuery(a[i], a[i] + 1).x;
        i64 q = seg.rangeQuery(a[i] - 1, a[i]).x;

        if (b[i] > 0) {
            int t = seg.findFirst(0, n, 
                [&](const Info &info) {
                    return info.x <= p + b[i];
                });
            seg.rangeApply(t, a[i], Tag{1, p + b[i], 0});
            seg.rangeApply(a[i], K, Tag{0, 0, b[i]});
        } else {
            i64 sub = -b[i];
            sub = std::min(sub, p - q + 1LL * (v[i] - v[i - 1]) * m);
            seg.rangeApply(a[i], K, Tag{0, 0, -sub});
        }
    }

    i64 ans = seg.rangeQuery(0, 1).x;
    std::cout << ans << "\n";
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr); 

    int t;
    std::cin >> t;

    while (t--) {
        solve();
    }

    return 0;
}