#include <bits/stdc++.h>
#define endl '\n'
typedef long long i64;

// I used Segment Tree which is extremely loved by ZJL
// I pray for ZJL and She will help me get AC in D2T1

const int MaxN = 2e5 + 10;
i64 mn[2][MaxN << 2], mx[2][MaxN << 2], tag[2][MaxN << 2], sum[2][MaxN << 2];
// 0 for go right & 1 for go left

void pull(int p, int t){
    mn[t][p] = std::min(mn[t][p << 1], mn[t][p << 1 | 1]);
    mx[t][p] = std::max(mx[t][p << 1], mx[t][p << 1 | 1]);
    sum[t][p] = sum[t][p << 1] + sum[t][p << 1 | 1];
    return ;
}

void push(int p, int l, int r, int t){
    int m = l + r >> 1;
    if(t){
        if(mn[t][p << 1] >= tag[t][p]){
            mx[t][p << 1] = mn[t][p << 1] = tag[t][p];
            sum[t][p << 1] = tag[t][p] * (m - l + 1);
        }
        if(mn[t][p << 1 | 1] >= tag[t][p]){
            mx[t][p << 1 | 1] = mn[t][p << 1 | 1] = tag[t][p];
            sum[t][p << 1 | 1] = tag[t][p] * (r - m);
        }

        tag[t][p << 1] = std::min(tag[t][p << 1], tag[t][p]);
        tag[t][p << 1 | 1] = std::min(tag[t][p << 1 | 1], tag[t][p]);
        tag[t][p] = 1LL << 60;

    }
    else{
        if(mx[t][p << 1] <= tag[t][p]){
            mx[t][p << 1] = mn[t][p << 1] = tag[t][p];
            sum[t][p << 1] = tag[t][p] * (m - l + 1);
        }
        if(mx[t][p << 1 | 1] <= tag[t][p]){
            mx[t][p << 1 | 1] = mn[t][p << 1 | 1] = tag[t][p];
            sum[t][p << 1 | 1] = tag[t][p] * (r - m);
        }

        tag[t][p << 1] = std::max(tag[t][p << 1], tag[t][p]);
        tag[t][p << 1 | 1] = std::max(tag[t][p << 1 | 1], tag[t][p]);
        tag[t][p] = -1LL << 60;
    }
    return ;
}

void build(int p, int l, int r, const std::vector<i64> &V, int t){
    tag[t][p] = (t ? 1LL << 60 : -1LL << 60);
    if(l == r){
        mx[t][p] = mn[t][p] = sum[t][p] = V[l];
        return ;
    }

    int m = l + r >> 1;
    build(p << 1, l, m, V, t);
    build(p << 1 | 1, m + 1, r, V, t);

    pull(p, t);
    return ;
}

void upd(int p, int l, int r, int ql, int qr, i64 v, int t){
    if(ql <= l && r <= qr){
        if(t && mn[t][p] >= v || !t && mx[t][p] <= v){
            mx[t][p] = mn[t][p] = v;
            sum[t][p] = v * (r - l + 1);
            tag[t][p] = t ? std::min(tag[t][p], v) : std::max(tag[t][p], v);
            return ;
        }
    }
    if(!t && mn[t][p] >= v || t && mx[t][p] <= v) return ;
    push(p, l, r, t);

    int m = l + r >> 1;
    if(ql <= m) upd(p << 1, l, m, ql, qr, v, t);
    if(qr > m) upd(p << 1 | 1, m + 1, r, ql, qr, v, t);

    pull(p, t);
    return ;
}


void solve(){
    int n;
    std::cin >> n;
    std::vector<i64> a(n), b(n), t(n);
    for(int i = 0;i < n;i++){
        std::cin >> a[i] >> b[i] >> t[i];
    }

    std::vector<int> lto, rto;
    for(int i = 0;i < n;i++){
        a[i] < b[i] ? rto.emplace_back(i) : lto.emplace_back(i);
    }

    std::vector<int> L(lto.size()), R(rto.size());
    for(int i = 0, j = 0; i < lto.size();i++){
        while(j < lto.size() && a[lto[j]] - lto[j] <= b[lto[i]] - lto[i]) j ++;
        L[i] = j;
    }
    for(int i = rto.size() - 1, j = rto.size() - 1;i >= 0;i--){
        while(j >= 0 && a[rto[j]] - rto[j] >= b[rto[i]] - rto[i]) j --;
        R[i] = j;
    }

    std::vector<i64> V(lto.size() + 1, 0);
    for(int i = 0;i < lto.size();i++){
        V[i + 1] = a[lto[i]] - lto[i];
    }
    build(1, 0, lto.size(), V, 1);
    V.resize(rto.size() + 1, 0);
    for(int i = 0;i < rto.size();i++){
        V[i + 1] = a[rto[i]] - rto[i];
    }
    build(1, 0, rto.size(), V, 0);


    std::vector<int> p(n);
    std::iota(p.begin(), p.end(), 0);
    std::sort(p.begin(), p.end(), [&](int x, int y){ return t[x] < t[y] ; });

    i64 Distorted_Fate = 0;
    i64 Destruction_321 = 0;
    for(int i = 0;i < n;i++){
        a[i] < b[i] ? Distorted_Fate += a[i] - i : Destruction_321 += a[i] - i;
    }

    i64 Rrharil = 0;
    for(int i = 0;i < n;i++){
        int x = p[i];
        int tp = (int)(a[i] >= b[i]);
        if(tp){
            int y = std::lower_bound(lto.begin(), lto.end(), x) - lto.begin();
            upd(1, 0, lto.size(), L[y] + 1, y + 1, b[x] - x, 1);
        }
        else{
            int y = std::lower_bound(rto.begin(), rto.end(), x) - rto.begin();
            upd(1, 0, rto.size(), y + 1, R[y] + 1, b[x] - x, 0);
        }
        Rrharil = sum[0][1] - Distorted_Fate + Destruction_321 - sum[1][1];
        if(Rrharil > t[x]){
            std::cout << "No" << endl;
            return ;
        }
    }
    std::cout << "Yes" << endl;
    return ;
}

signed main(){

    freopen("move.in", "r", stdin);
    freopen("move.out", "w", stdout);

    std::cin.tie(nullptr) -> sync_with_stdio(false);
    int c, T;
    std::cin >> c >> T;
    while(T --) solve();
    std::cout.flush();
    fclose(stdin);
    fclose(stdout);
    return 0;
}