#include<bits/stdc++.h>
#define int ll
#define inf 141414141414
using namespace std;
typedef long long ll;
const int mxn = 200014;
int n,a[mxn],b[mxn],T[mxn],f[mxn];

struct sgtw{
    int pts=1;
    struct pt
    {
        int l,r,ls,rs;
        int lw,ltg,rw=inf,rtg=inf;
    }t[mxn<<2];
    void init(int k)
    {
        pts=1;
        int l=t[k].l;
        int r=t[k].r;
        if(l!=r)
        {
            init(t[k].ls);
            init(t[k].rs);
        }
        t[k].l=t[k].r=t[k].ls=t[k].rs=0;
        t[k].ltg=t[k].lw=0;
        t[k].rtg=t[k].rw=inf;
    }

    void pd(int k)
    {
        int l=t[k].l;
        int r=t[k].r;
        if(l==r)
        {
            t[k].lw=max(t[k].lw,t[k].ltg);
            t[k].rw=min(t[k].rw,t[k].rtg);
        }
        else 
        {
            int ls=t[k].ls;
            int rs=t[k].rs;
            t[ls].ltg=max(t[ls].ltg,t[k].ltg);
            t[rs].ltg=max(t[rs].ltg,t[k].ltg);
            t[ls].rtg=min(t[ls].rtg,t[k].rtg);
            t[rs].rtg=min(t[rs].rtg,t[k].rtg);
        }
        t[k].ltg=0;t[k].rtg=inf;
    }

    void build(int k,int l,int r)
    {
        t[k].l=l;
        t[k].r=r;
        if(l==r) return ;
        int mid=(l+r)>>1;
        t[k].ls=++pts;
        build(pts,l,mid);
        t[k].rs=++pts;
        build(pts,mid+1,r);
    }

    void updlw(int k,int v)
    {
        int l=t[k].l;
        int r=t[k].r;
        int mid=(l+r)>>1;
        pd(k);
        if(l>=v) 
        {
            t[k].ltg=v;
            return ;
        }
        if(l==r) return ;
        if(v<=mid) updlw(t[k].ls,v);
        updlw(t[k].rs,v);
    }

    void updrw(int k,int v)
    {
        int l=t[k].l;
        int r=t[k].r;
        int mid=(l+r)>>1;
        pd(k);
        if(r<=v) 
        {
            t[k].rtg=v;
        }
        if(l==r) return ;
        if(v>mid) updrw(t[k].rs,v);
        updrw(t[k].ls,v);
    }

    int qlw(int k,int p)
    {
        int l=t[k].l;
        int r=t[k].r;
        int mid=(l+r)>>1;
        pd(k);
        if(l==r) return t[k].lw;
        if(p<=mid) return qlw(t[k].ls,p);
        return qlw(t[k].rs,p);
    }

    int qrw(int k,int p)
    {
        int l=t[k].l;
        int r=t[k].r;
        int mid=(l+r)>>1;
        pd(k);
        if(l==r) return t[k].rw;
        if(p<=mid) return qrw(t[k].ls,p);
        return qrw(t[k].rs,p);
    }
}t1;

struct sgts{
    int pts=1;
    struct pt
    {
        int l,r,ls,rs;
        int v,s,tg;
    }t[mxn<<2];
    void init(int k)
    {
        pts=1;
        int l=t[k].l;
        int r=t[k].r;
        if(l!=r)
        {
            init(t[k].ls);
            init(t[k].rs);
        }
        t[k].l=t[k].r=t[k].ls=t[k].rs=0;
        t[k].v=t[k].s=t[k].tg=0;
    }


    void mktg(int k,int v)
    {
        int l=t[k].l;
        int r=t[k].r;
        t[k].v=(r-l+1);
        t[k].s=v*t[k].v;
    }

    void pd(int k)
    {
        int l=t[k].l;
        int r=t[k].r;
        if(l!=r&&t[k].tg)
        {
            mktg(t[k].ls,t[k].tg);
            mktg(t[k].rs,t[k].tg);
            t[k].tg=0;
        }
    }

    void pu(int k)
    {
        if(t[k].l==t[k].r) return ;
        t[k].v=t[t[k].ls].v+t[t[k].rs].v;
        t[k].s=t[t[k].ls].s+t[t[k].rs].s;
    }

    void build(int k,int l,int r)
    {
        t[k].l=l;
        t[k].r=r;
        if(l==r)
        {
            t[k].v=0;
            t[k].s=a[l];
            return ;
        } 
        int mid=(l+r)>>1;
        t[k].ls=++pts;
        build(pts,l,mid);
        t[k].rs=++pts;
        build(pts,mid+1,r);
        pu(k);
    }

    void upd(int k,int L,int R,int v)
    {
        int l=t[k].l;
        int r=t[k].r;
        int mid=(l+r)>>1;
        pd(k);
        if(L<=l&&R>=r)
        {
            mktg(k,v);
            return ;
        }
        if(L<=mid) upd(t[k].ls,L,R,v);
        if(R>mid) upd(t[k].rs,L,R,v);
        pu(k);
    }

    int qs(int k,int L,int R)
    {
        int ans=0;
        int l=t[k].l;
        int r=t[k].r;
        int mid=(l+r)>>1;
        pd(k);
        if(L<=l&&R>=r)
        {
            return t[k].s;
        }
        if(L<=mid) ans+=qs(t[k].ls,L,R);
        if(R>mid) ans+=qs(t[k].rs,L,R);
        pu(k);
        return ans;
    }

    int qv(int k,int L,int R)
    {
        int ans=0;
        int l=t[k].l;
        int r=t[k].r;
        int mid=(l+r)>>1;
        pd(k);
        if(L<=l&&R>=r)
        {
            return t[k].v;
        }
        if(L<=mid) ans+=qv(t[k].ls,L,R);
        if(R>mid) ans+=qv(t[k].rs,L,R);
        pu(k);
        return ans;
    }
}t2;

struct cc{
    int v,k;
    bool operator < (const cc & p)
    {
        return v<p.v;
    }
}c[mxn];

signed main()
{
    freopen("move.in","r",stdin);
    freopen("move.out","w",stdout);
    int c0,T0;
    cin>>c0>>T0;
    while(T0--)
    {
        cin>>n;
        for(int i=1;i<=n;i++)
        {
            scanf("%lld%lld%lld",&a[i],&b[i],&T[i]);
            c[i].k=i;c[i].v=T[i];
        }
        sort(c+1,c+n+1);
        t1.build(1,1,n);
        t2.build(1,1,n);
        for(int i=1;i<=n;i++)
        {
            f[i]=lower_bound(a+1,a+n+1,b[i])-lower_bound(a+1,a+n+1,a[i]);
        }
        int ans=0,check=0;
        for(int i=1;i<=n;i++)
        {
            if(i>n/3*2) break;
            int k=c[i].k,l,r;
            int lw=t1.qlw(1,k);
            int rw=t1.qrw(1,k);
            if(a[k]<b[k])//rw
            {
                l=k+1;
                r=k-f[k];
                if(rw<=n)
                r=min(r,rw-1);
                if(l<=r)
                {
                    int p=r-l+1;
                    int q=t2.qv(1,l,r);
                    int r=p-q;
                    ans+=b[k]*(p)-t2.qs(1,l,r)+(r+1)*r/2-r*(p);
                    t2.upd(1,l,r,b[k]);
                } 
            }
            if(a[k]>b[k])
            {
                r=k-1;
                l=k-f[k];
                if(lw>0)
                l=max(l,lw+1);
                if(l<=r)
                {
                    int p=r-l+1;
                    int q=t2.qv(1,l,r);
                    r=p-q;
                    ans+=t2.qs(1,l,r)-b[k]*p+(r+1)*r/2-r*(p);
                    t2.upd(1,l,r,b[k]);
                }
            }
            int u=a[k];
            if(lw>0) u=max(u,a[lw]+(k-lw));
            if(rw<=n) u=min(u,a[rw]-(rw-k));
            ans+=abs(u-b[k]);
            // cout<<ans<<" "<<u<<" "<<lw<<" "<<rw<<" "<<k<<" "<<T[k]<<endl;
            if(ans>T[k])
            {
                check=1;
                break;
            }
            t1.updlw(1,k);
            t1.updrw(1,k);
        }

        puts(check?"No":"Yes");
        t1.init(1);
        t2.init(1);
    }
    return 0;
}