#include<bits/stdc++.h>
#define ll long long
#define F(i, l, r) for(int i = l; i <= r; ++i)
#define UF(i, l, r) for(int i = r; i >= l; --i)
#define File(x) (In(x), Out(x))
#define In(x) freopen(x".in", "r", stdin)
#define Out(x) freopen(x".out", "w", stdout)
#define pii pair<ll,int>
#define fi first
#define se second
#define inf 0x3f3f3f3f
using namespace std;
const int maxn = 2e5 + 5;
int N;
int a[maxn], b[maxn];
pii t[maxn];

ll read(){
    ll x = 0, f = 1; char c;
    while(!isdigit(c = getchar())) if(c == '-') f = -1;
    while(isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
    return x * f;
}

struct SegTree{
    int root, tot;
    struct NODE{ int l, r, lc, rc, minx, lazyl, lazyr; ll sum; }nd[maxn << 2];
    #define ND nd[id]
    #define LC nd[ND.lc]
    #define RC nd[ND.rc]
    void init(){ tot = 0; root = 1; }
    void pushdown(int id){
        if(id == 0 || ND.lazyl == -1) return;
        ND.minx = ND.lazyl;
        ND.sum = 1ll * (ND.lazyl + ND.lazyr) * (ND.lazyr - ND.lazyl + 1) / 2;
        if(ND.lc != 0){
            int lazymid = (ND.lazyl + ND.lazyr) >> 1;
            LC.lazyl = ND.lazyl, LC.lazyr = lazymid;
            RC.lazyl = lazymid + 1, RC.lazyr = ND.lazyr;
        }
        ND.lazyl = ND.lazyr = -1;
    }
    void pushup(int id){
        pushdown(id); pushdown(ND.lc); pushdown(ND.rc);
        if(ND.lc == 0) return;
        ND.minx = min(LC.minx, RC.minx);
        ND.sum = LC.sum + RC.sum;
    }
    int build(int l, int r){
        int id = ++tot;
        if(l == r){
            ND = (NODE){l, r, 0, 0, a[l], -1, -1, a[l]};
            return id;
        }
        int mid = (l + r) >> 1;
        ND = (NODE){l, r, build(l, mid), build(mid + 1, r), inf, -1, -1, 0};
        pushup(id); return id;
    }
    int geta(int id, int qx){
        pushdown(id);
        int l = ND.l, r = ND.r, mid = (ND.l + ND.r) >> 1;
        if(l == qx && qx == r) return ND.sum;
        ll ans = 0;
        if(qx <= mid) ans = geta(ND.lc, qx);
        else if(mid+1 <= qx) ans = geta(ND.rc, qx);
        pushup(id);
        return ans;
    }
    int cnt(int id, int qr){
        pushdown(id); pushdown(ND.rc);
        int ans = 0;
        if(ND.l == ND.r) ans = ND.l;
        else if(RC.minx <= qr) ans = cnt(ND.rc, qr);
        else ans = cnt(ND.lc, qr);
        pushup(id);
        return ans;
    }
    ll getsum(int id, int ql, int qr){
        pushdown(id);
        int l = ND.l, r = ND.r, mid = (ND.l + ND.r) >> 1;
        if(ql <= l && r <= qr) return ND.sum;
        ll ans = 0;
        if(ql <= mid) ans += getsum(ND.lc, ql, qr);
        if(mid+1 <= qr) ans += getsum(ND.rc, ql, qr);
        pushup(id);
        return ans;
    }
    void cover(int id, int ql, int qr, int lzl, int lzr){
        int l = ND.l, r = ND.r, mid = (ND.l + ND.r) >> 1;
        if(ql <= l && r <= qr){
            ND.lazyl = lzl; ND.lazyr = lzr;
            pushdown(id); return;
        }
        pushdown(id);
        if(ql <= mid) cover(ND.lc, ql, min(qr, mid), lzl, lzl + min(qr, mid) - ql);
        if(mid+1 <= qr) cover(ND.rc, max(ql, mid + 1), qr, lzr - (qr - max(ql, mid + 1)), lzr);
        pushup(id);
    }
}T;

int ki;
#define check(x) (T.cnt(1, x) - ki <= x - b[ki])
int findx(int l, int r){
    while(l + 1 < r){
        int mid = (l + r) >> 1;
        if(check(mid)) r = mid;
        else l = mid;
    }
    return r;
}

void solve(){
    // cin >> N;
    N = read();
    T.init();

    int li = 0, lv, rv;
    F(i, 1, N){
        a[i] = read(), b[i] = read();
        t[i] = make_pair(read(), i);
        if(li == 0 && b[i] < a[i]) li = i, lv = b[i], rv = a[i];
        else if(b[i] < a[i])
            lv = min(lv, b[i]), rv = max(rv, a[i]);
        if(li != 0 && a[i] <= b[i]){
            F(j, li, i-1){
                a[j] = rv - a[j] + lv;
                b[j] = rv - b[j] + lv;
            }
            reverse(a + li, a + i);
       		reverse(b + li, b + i);
            reverse(t + li, t + i);
            F(j, li, i-1) t[j].se = j;
            li = 0;
        }
    }
    if(li != 0){
        F(j, li, N){
            a[j] = rv - a[j] + lv;
            b[j] = rv - b[j] + lv;
        }
        reverse(a + li, a + N + 1);
        reverse(b + li, b + N + 1);
        reverse(t + li, t + N + 1);
        F(j, li, N) t[j].se = j;
    }

    T.build(1, N);
    sort(t + 1, t + 1 + N);

    ll ttime = 0;
    F(j, 1, N){
        ki = t[j].se;
        a[ki] = T.geta(1, ki);
        int fx = findx(b[ki]-1, inf);
        int fcnt = T.cnt(1, fx);
        ttime = ttime + 1ll * (fx + b[ki]) * (fx - b[ki] + 1) / 2 - T.getsum(1, ki, fcnt);

        T.cover(1, ki, fcnt, b[ki], fx);
        
        if(ttime > t[j].fi){
            cout << "No\n";
            return;
        }
    }
    cout << "Yes\n";
    return;
}

int main(){
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    File("move");
    int c = read(), T = read();
    // cin >> c >> T;
    while(T--) solve();
    return 0;
}