#include <bits/stdc++.h>
using i64 = long long;
#ifdef DEBUG
#include "/home/ahmetalp/Desktop/Workplace/debug.h"
#else
#define debug(...) void(23)
#endif
template<typename T>
bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
constexpr i64 inf = i64(1E18);
constexpr int max_Q = int(5E5) + 5;
int Q;
int L;
int qrys[max_Q][3];
std::vector<int> all;
#define def int mid = (l + r) >> 1, lv = v + 1, rv = v + ((mid - l + 1) << 1)
// DCDCDCDC
// 0=D
// 1=C
struct node {
i64 g[2][2][2] {};
i64 lz1 = 0;
i64 lz2 = 0;
node() {
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j) {
for (int k = 0; k < 2; ++k) {
g[i][j][k] = -inf;
}
}
}
}
void modify1(i64 x) { // add C and D's +x
for (int i = 0; i < 2; ++i) {
g[i][0][0] -= x;
g[i][1][1] += x;
}
lz1 += x;
}
void modify2(i64 x) { // add only C +x, guaranteed that interval is <= [-L, +L]
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j) {
g[1][i][j] += x;
}
}
lz2 += x;
}
};
node unite(const node& lhs, const node& rhs) {
node res;
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j) {
for (int l = 0; l < 2; ++l) {
for (int r = 0; r < 2; ++r) {
chmax(res.g[std::min(1, i + j)][l][r], lhs.g[i][l][1] + rhs.g[j][0][r]);
chmax(res.g[std::min(1, i + j)][l][r], lhs.g[i][l][0] + rhs.g[j][1][r]);
}
}
}
}
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j) {
for (int k = 0; k < 2; ++k) {
chmax(res.g[i][j][k], lhs.g[i][j][k]);
chmax(res.g[i][j][k], rhs.g[i][j][k]);
}
}
}
return res;
}
std::vector<node> tree;
void push(int v, int l, int r) {
def;
if (tree[v].lz1) {
tree[lv].modify1(tree[v].lz1);
tree[rv].modify1(tree[v].lz1);
tree[v].lz1 = 0;
}
if (tree[v].lz2) {
tree[lv].modify2(tree[v].lz2);
tree[rv].modify2(tree[v].lz2);
tree[v].lz2 = 0;
}
}
void modify1(int v, int l, int r, int ql, int qr, int x) {
if (ql == l && r == qr) {
tree[v].modify1(x);
return;
}
def;
push(v, l, r);
if (qr <= mid) {
modify1(lv, l, mid, ql, qr, x);
} else if (mid + 1 <= ql) {
modify1(rv, mid + 1, r, ql, qr, x);
} else {
modify1(lv, l, mid, ql, mid, x);
modify1(rv, mid + 1, r, mid + 1, qr, x);
}
tree[v] = unite(tree[lv], tree[rv]);
}
void modify2(int v, int l, int r, int ql, int qr, int x) {
if (ql == l && r == qr) {
tree[v].modify2(x);
return;
}
def;
push(v, l, r);
if (qr <= mid) {
modify2(lv, l, mid, ql, qr, x);
} else if (mid + 1 <= ql) {
modify2(rv, mid + 1, r, ql, qr, x);
} else {
modify2(lv, l, mid, ql, mid, x);
modify2(rv, mid + 1, r, mid + 1, qr, x);
}
tree[v] = unite(tree[lv], tree[rv]);
}
void build(int v, int l, int r) {
if (l == r) {
tree[v].g[0][0][0] = 0;
tree[v].g[1][1][1] = 0;
return;
}
def;
build(lv, l, mid);
build(rv, mid + 1, r);
tree[v] = unite(tree[lv], tree[rv]);
}
void debug_tree(int v, int l, int r) {
debug(v, l, r);
for (int a = 0; a < 2; ++a){
for (int b = 0; b < 2; ++b) {
for (int c = 0; c < 2; ++c) {
debug(a, b, c, tree[v].g[a][b][c]);
}
}
}
if (l == r) {
return;
}
def;
push(v, l, r);
debug_tree(lv, l, mid);
debug_tree(rv, mid + 1, r);
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cin >> Q >> L;
for (int i = 0; i < Q; ++i) {
std::cin >> qrys[i][0] >> qrys[i][1] >> qrys[i][2];
}
for (int i = 0; i < Q; ++i) {
for (auto d : {-1, 0, +1}) {
all.emplace_back(qrys[i][1] - L + d);
all.emplace_back(qrys[i][1] + d);
all.emplace_back(qrys[i][1] + L + d);
}
}
std::sort(all.begin(), all.end());
all.erase(std::unique(all.begin(), all.end()), all.end());
auto Id = [&](int x) -> int {
return int(std::lower_bound(all.begin(), all.end(), x) - all.begin());
};
i64 T = 0;
int n = int(all.size());
tree.resize(n << 1);
build(0, 0, n - 1);
for (int i = 0; i < Q; ++i) {
if (qrys[i][0] == 1) {
T += qrys[i][2];
int p = Id(qrys[i][1]);
modify1(0, 0, n - 1, p, n - 1, +qrys[i][2]);
} else {
int p1 = Id(qrys[i][1] - L);
int p2 = Id(qrys[i][1] + L);
modify1(0, 0, n - 1, p2, n - 1, -qrys[i][2]);
modify2(0, 0, n - 1, p1, p2 - 1, -qrys[i][2]);
}
i64 res = -inf;
for (int a = 0; a < 2; ++a) {
chmax(res, tree[0].g[a][0][1]);
}
debug(res);
std::cout << T - res << '\n';
// debug_tree(0, 0, n - 1);
}
return 0;
}
