#include<bits/stdc++.h>

#define int long long

typedef long long ll;
typedef unsigned long long ull;
typedef std::pair<int, int> pii;

#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 lowbit(x) (x & (-x))

#define mp make_pair
#define pb push_back
#define fir first
#define sec second
#define ins insert

using namespace std;

const int P = 1e9 + 7, L = 2e5 + 5, inf = 2e9 + 5;

ll qpow(ll a, ll b) { ll ans = 1, x = a; while(b) { if(b & 1) ans = ans * x % P; x = x * x % P; b >>= 1; } return ans; }

namespace Fast_IO {
    template<typename T> void rd(T &x) {
        x = 0; char c = getchar(); bool fg = 0;
        while(!isdigit(c)) fg |= (c == '-'), c = getchar();
        while(isdigit(c)) x = (x << 3) + (x << 1) + c - '0', c = getchar();
        x = (fg ? -x : x);
    } 
    template<typename T, typename ... Args> void rd(T &x, Args& ...args) {
        rd(x), rd(args ...);
    }
    template<typename T> void write(T x, bool tg) {
        if(x < 0) putchar('-'), x = -x; short stack[50], top(0);
        do stack[top ++] = x % 10, x /= 10; while(x);
        while(top --) putchar(stack[top] | 48);
        putchar(tg ? '\n' : ' ');
    }
} using namespace Fast_IO;

/****************************************************************************************************
*                                                                                                   *
****************************************************************************************************/

int n;
int a[L], b[L], tim[L];
int id[L];

namespace sgt {
    struct node {
        int num;
        int l, r;
        int tot;
    } p[L << 2];
    #define mid ((l + r) >> 1)
    #define lson l, mid, L, R, (w << 1)
    #define rson mid + 1, r, L, R, (w << 1 | 1)
    void pushup(int w) {
        p[w].l = p[w << 1].l, p[w].r = p[w << 1 | 1].r;
        p[w].tot = p[w << 1].tot + p[w << 1 | 1].tot;
    }
    void pushdown(int w, int l, int r) {
        if(p[w].num != -1) {
            p[w << 1].num = p[w].num;
            p[w << 1 | 1].num = p[w].num + (mid - l + 1);
            p[w << 1].l = p[w].num; p[w << 1].r = p[w].num + mid - l;
            p[w << 1 | 1].l = p[w << 1 | 1].num; p[w << 1 | 1].r = p[w].num + r - l;
            p[w << 1].tot = (p[w << 1].l + p[w << 1].r) * (mid - l + 1) / 2;
            p[w << 1 | 1].tot = (p[w << 1 | 1].l + p[w << 1 | 1].r) * (r - mid) / 2;   
        }
        p[w].num = -1;
    }
    void modify(int l, int r, int L, int R, int w, int num) {
        if(L <= l && r <= R) { p[w].num = num + (l - L); p[w].l = p[w].num, p[w].r = (r - l) + p[w].num, p[w].tot = (p[w].r + p[w].l) * (r - l + 1) / 2; return ; } pushdown(w, l, r);
        if(R <= mid) modify(lson, num);
        else if(mid < L) modify(rson, num);
        else modify(lson, num), modify(rson, num); pushup(w);
    }
    int getnum(int l, int r, int L, int R, int w) {
        if(L <= l && r <= R) return p[w].tot; pushdown(w, l, r);
        if(R <= mid) return getnum(lson);
        else if(mid < L) getnum(rson);
        else return getnum(lson) + getnum(rson);
    }
    int querylef(int l, int r, int id, int w, int pos) {
        if(l == r) return l; pushdown(w, l, r);
        if(id <= mid) querylef(l, mid, id, w << 1, pos);
        else if((pos - p[w << 1].r) >= (id - mid)) {
            return querylef(mid + 1, r, id, w << 1 | 1, pos);
        } else {
            return querylef(l, mid, id, w << 1, pos);
        }
    }
    int queryrig(int l, int r, int id, int w, int pos) {
        if(l == r) return l; pushdown(w, l, r);
        if(id > mid) queryrig(mid + 1, r, id, w << 1 | 1, pos);
        else if((p[w << 1 | 1].l - pos) >= (mid - id + 1)) {
            return queryrig(l, mid, id, w << 1, pos);
        } else {
            return queryrig(mid + 1, r, id, w << 1 | 1, pos);
        }
    }
    void build(int l, int r, int w) { p[w].tot = 0, p[w].num = -1;
        if(l != r) {
            build(l, mid, w << 1), build(mid + 1, r, w << 1 | 1); 
            pushup(w);
        } else {
            p[w].l = p[w].r = p[w].tot = a[l];
            p[w].num = a[l];
        }
    }
} using namespace sgt;

signed main() { int c, T;
    freopen("move.in", "r", stdin);
    freopen("move.out", "w", stdout);
    rd(c, T);
    while(T --) { int time = 0;
        rd(n); rep(i, 1, n) {
            rd(a[i], b[i], tim[i]);
            id[i] = i;
        }
        sort(id + 1, id + 1 + n, [](int a, int b) { return tim[a] < tim[b]; });
        build(1, n, 1);
        rep(_, 1, n) {
            int i = id[_];
            int num = getnum(1, n, i, i, 1);
            if(num > b[i]) {
                int pos = querylef(1, n, i, 1, b[i]);
                int nowtot = getnum(1, n, pos, i, 1);
                int newtot = (b[i] - (i - pos) + b[i]) * (i - pos + 1) / 2;
                modify(1, n, pos, i, 1, b[i] - (i - pos));
                time += nowtot - newtot;
            } else if(num < b[i]) {
                int pos = queryrig(1, n, i, 1, b[i]);
                int nowtot = getnum(1, n, i, pos, 1);
                int newtot = (b[i] + (pos - i) + b[i]) * (pos - i + 1) / 2;
                modify(1, n, i, pos, 1, b[i]);
                time += newtot - nowtot;
            }
            // rep(x, 1, n) write(getnum(1, n, x, x, 1), x == n);
            // cout << i << ' ' << time << ' ' << tim[i] << endl;
            if(time > tim[i]) {
                puts("No"); goto lv;
            }
        }
        puts("Yes");
        lv:;
    }
    return 0;
}