#include<bits/stdc++.h>
#define int long long
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
#define fi first
#define se second
#define eb emplace_back
#define popc __builtin_popcount
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<pii> vp;
typedef unsigned long long ull;
typedef long double ld;

int read() {
  int x=0,w=1; char c=getchar(); 
  while(!isdigit(c)) {if(c=='-') w=-1; c=getchar();}
  while(isdigit(c)) {x=x*10+(c-'0'); c=getchar();}
  return x*w;
}

const int N=2e6+9,inf=0x3f3f3f3f3f3f3f3f;

int Q,L,bb[N],opt[N],x[N],a[N],cnt,n,m,mxx;

struct node {
  int len,f[2][2][3],g[2][2],l,r;
  node(int x=0,int y=0) {
    len=x; g[0][0]=g[1][1]=y;
    f[0][0][0]=f[0][0][1]=f[1][1][0]=f[1][1][1]=y;
    f[0][1][1]=f[1][0][1]=y; f[1][1][0]=-inf;
    f[0][0][2]=f[0][1][2]=f[1][0][2]=f[1][1][2]=-inf;
    f[0][1][0]=f[1][0][0]=g[0][1]=g[1][0]=0;
  }
  void getg() {
    rep(i,0,1) rep(j,0,1)
      g[i][j]=max(f[i][j][0],max(f[i][j][1],f[i][j][2]));
  }
};
node operator + (const node &a,const node &b) {
  node c(b.r-a.l+1,-inf); c.l=a.l, c.r=b.r;
  if(c.len>2*L) {
    rep(i,0,1) rep(j,0,1)
      c.g[i][j]=max(a.g[i][0]+b.g[1][j],a.g[i][1]+b.g[0][j]);
  } else {
    rep(i,0,1) rep(j,0,1) {
      c.f[i][j][0]=max(a.f[i][0][0]+b.f[1][j][0],a.f[i][1][0]+b.f[0][j][0]);
      c.f[i][j][1]=max(max(a.f[i][0][0]+b.f[1][j][1],a.f[i][1][0]+b.f[0][j][1]),
        max(a.f[i][0][1]+b.f[1][j][0],a.f[i][1][1]+b.f[0][j][0]));
      c.f[i][j][2]=max(max(a.f[i][0][0]+b.f[1][j][2],a.f[i][1][0]+b.f[0][j][2]),
        max(max(a.f[i][0][1]+b.f[1][j][1],a.f[i][1][1]+b.f[0][j][1]),
        max(a.f[i][0][2]+b.f[1][j][0],a.f[i][1][2]+b.f[0][j][0])));
    }
    c.getg();
  }
  return c;
}

namespace SegT {
  int ls[N<<1],rs[N<<1],tag1[N<<1],tag2[N<<1],tot=1;
  node s[N<<1];
  void add1(int p,int x) {
    if(s[p].len<=2*L) {
      rep(k,0,2) s[p].f[0][0][k]+=x;
      rep(k,1,2) s[p].f[1][1][k]-=x;
      s[p].getg();
    } else {
      s[p].g[0][0]+=x, s[p].g[1][1]-=x;
    } tag1[p]+=x;
  }
  void add2(int p,int x) {
    if(s[p].len<=2*L) {
      rep(i,0,1) rep(j,0,1) rep(k,1,2) s[p].f[i][j][k]-=x*k;
      s[p].getg();
    } tag2[p]+=x;
  }
  void psd(int p) {
    if(tag1[p]) add1(ls[p],tag1[p]), add1(rs[p],tag1[p]), tag1[p]=0;
    if(tag2[p]) add2(ls[p],tag2[p]), add2(rs[p],tag2[p]), tag2[p]=0;
  }
  void mdf1(int p,int l,int r,int x,int y,int z) {
    if(l==x&&r==y) {add1(p,z); return;} int mid=l+r>>1; psd(p);
    if(y<=mid) mdf1(ls[p],l,mid,x,y,z);
    else if(x>mid) mdf1(rs[p],mid+1,r,x,y,z);
    else mdf1(ls[p],l,mid,x,mid,z), mdf1(rs[p],mid+1,r,mid+1,y,z);
    s[p]=s[ls[p]]+s[rs[p]];
  }
  void mdf2(int p,int l,int r,int x,int y,int z) {
    if(l==x&&r==y) {add2(p,z); return;} int mid=l+r>>1; psd(p);
    if(y<=mid) mdf2(ls[p],l,mid,x,y,z);
    else if(x>mid) mdf2(rs[p],mid+1,r,x,y,z);
    else mdf2(ls[p],l,mid,x,mid,z), mdf2(rs[p],mid+1,r,mid+1,y,z);
    s[p]=s[ls[p]]+s[rs[p]];
  }
  void build(int p,int l,int r) {
    s[p].len=bb[r]-bb[l]+1; s[p].l=bb[l], s[p].r=bb[r];
    if(l==r) return; int mid=l+r>>1;
    build(ls[p]=++tot,l,mid), build(rs[p]=++tot,mid+1,r);
  }
  int query() {return max(0ll,s[1].g[0][1]);}
}

signed main() {
  Q=read(), L=read();
  rep(i,1,Q) {
    opt[i]=read(), x[i]=read(), a[i]=read(); mxx=max(mxx,x[i]);
    if(opt[i]==1)
      bb[++cnt]=x[i]-L, bb[++cnt]=x[i]+L, bb[++cnt]=x[i]+L-1, bb[++cnt]=x[i]+L+1;
    else bb[++cnt]=x[i], bb[++cnt]=x[i]+1;
  } bb[++cnt]=mxx+L+1; bb[++cnt]=-L;
  sort(bb+1,bb+cnt+1); cnt=unique(bb+1,bb+cnt+1)-bb-1;
  SegT::build(1,1,cnt);
  rep(i,1,Q) {
    if(opt[i]==2) {
      int p=lower_bound(bb+1,bb+cnt+1,x[i])-bb;
      SegT::mdf1(1,1,cnt,p,cnt,-a[i]);
      n+=a[i];
    } else {
      int pl=lower_bound(bb+1,bb+cnt+1,x[i]-L)-bb;
      int pr=lower_bound(bb+1,bb+cnt+1,x[i]+L)-bb;
      int px=lower_bound(bb+1,bb+cnt+1,x[i]+L-1)-bb;
      SegT::mdf1(1,1,cnt,pr,cnt,a[i]);
      SegT::mdf2(1,1,cnt,pl,px,a[i]);
      m+=a[i];
    }
    printf("%lld\n",n-SegT::query());
  }
  return 0;
}