#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 dp[2][2];
    int lx, rx;
    int ly, ry;

    asd() {
        dp[0][0] = dp[1][0] = dp[0][1] = dp[1][1] = 0;
        lx = rx = 0;
    }
};

asd merge(asd x, asd y) {
    asd ans;
    ans.lx = x.lx, ans.rx = y.rx;
    ans.ly = x.ly, ans.ry = y.ry;
    for(int i = 0; i < 2; i++) {
        for(int j = 0; j < 2; j++) {
            ans.dp[i][j] = min(x.dp[i][1] + y.dp[1][j] - x.ry, min(x.dp[i][0], x.dp[i][1]) + min(y.dp[0][j], y.dp[1][j]));
        }
    }
    return ans;
}


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

void upd(int v, int tl, int tr, int pos, int x, int tp) {
    if(tl == tr) {
        if(!tp) {
            t[v].lx += x;
            t[v].rx += x;
        }
        else {
            if(tp < 0) {
                t[v].ly += x;
            }
            else {
                t[v].ry += x;
            }
        }
        t[v].dp[0][1] = 1e18;
        t[v].dp[1][0] = 1e18;
        t[v].dp[1][1] = t[v].ly + t[v].ry - t[v].lx;
        return;
    }
    int mid = tl + tr >> 1;
    if(!L[v]) {
        L[v] = ++nv;
    }
    if(!R[v]) {
        R[v] = ++nv;
    }
    if(pos <= mid) {
        upd(L[v], tl, mid, pos, x, tp);
    }
    else {
        upd(R[v], mid + 1, tr, pos, x, tp);
    }
    t[v] = merge(t[L[v]], t[R[v]]);
}

void solve() {
    cin >> n >> k;
    m = (1 << 30) - 1;
    int sum = 0;
    while(n--) {
        int tp, pos, x;
        cin >> tp >> pos >> x;
        if(tp == 2) {
            upd(1, 0, m, pos / 2, x, 0);
            sum += x;
        }
        else {
            upd(1, 0, m, pos / 2, x, 1);
            upd(1, 0, m, pos / 2 + 1, x, -1);
        }
        cout << sum + min({t[1].dp[0][0], t[1].dp[1][0], t[1].dp[0][1], t[1].dp[1][1]}) << ent;
    }
}

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

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