#include <bits/stdc++.h>
#define ent '\n'
#define int long long

using namespace std;
typedef long long ll;

const int maxn = 5e5 + 12;
const int mod = 998244353;

int n, m, k;

struct asd {
    int lx, rx, ans;
    int tl, tr;

    asd() {
        lx = rx = tl = tr = ans = 0;
    }

    asd(int i, int x) {
        ans = 0;
        lx = rx = x;
        tl = tr = i;
    }
};

asd merge(asd x, asd y) {
    asd ans;
    ans.ans = x.ans + y.ans;
    ans.tl = x.tl, ans.tr = y.tr;
    if(x.tr == x.tl) {
        if(y.tl == y.tr) {
            int val = min(x.lx, y.lx);
            ans.ans += val;
            ans.lx = x.lx - val;
            ans.rx = y.lx - val;
        }
        else {
            int val = min(x.lx, y.lx);
            ans.lx = x.lx - val;
            ans.rx = y.rx;
        }
    }
    else if(y.tl == y.tr) {
        int val = min(x.rx, y.lx);
        ans.ans += val;
        ans.lx = x.lx;
        ans.rx = y.lx - val;
    }
    else {
        ans.ans += min(x.rx, y.lx);
        ans.lx = x.lx;
        ans.rx = y.rx;
    }
    return ans;
}


asd t[maxn * 30];
int L[maxn * 30], R[maxn];
int nv = 1;

void upd(int v, int tl, int tr, int pos, int x) {
    if(tl == tr) {
        t[v] = asd(tl, t[v].lx + x);
        return;
    }
    int mid = tl + tr >> 1;
    if(!L[v]) {
        L[v] = ++nv;
        t[L[v]].tl = tl;
        t[L[v]].tr = mid;
    }
    if(!R[v]) {
        R[v] = ++nv;
        t[R[v]].tl = mid + 1;
        t[R[v]].tr = tr;
    }
    if(pos <= mid) {
        upd(L[v], tl, mid, pos, x);
    }
    else {
        upd(R[v], mid + 1, tr, pos, x);
    }
    t[v] = merge(t[L[v]], t[R[v]]);
}

void solve() {
    cin >> n >> k;
    m = (1 << 30) - 1;
    while(n--) {
        int tp, pos, x;
        cin >> tp >> pos >> x;
        upd(1, 0, m, pos, x);
        cout << t[1].ans << ent;
    }
}

int32_t main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
//    cin >> t;

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