#include <bits/stdc++.h>

using namespace std;

using ll = long long;
constexpr int maxn = 200000;
int a[maxn + 5], b[maxn + 5], id[maxn + 5];
ll ft[maxn + 5];
int n;

template <typename tp>
tp read()
{
    char ch;
    while ((ch = getchar()) && (ch < '0' || ch > '9'));
    tp ans = ch - '0';
    while ((ch = getchar()) && ch >= '0' && ch <= '9')
        ans = ans * 10 + ch - '0';
    return ans;
}

namespace subtask1
{
    void solve()
    {
        for (int i = 1; i <= n; i++)
            id[i] = i;
        sort(id + 1, id + n + 1, [](int x, int y) { return ft[x] < ft[y]; });

        ll cur = 0;
        for (int c = 1; c <= n; c++)
        {
            int i = id[c];
            if (b[i] > a[i])
            {
                for (int j = i; j <= n; j++)
                    if (a[j] < b[i] + j - i)
                    {
                        cur += b[i] + j - i - a[j];
                        a[j] = b[i] + j - i;
                    }
                    else
                        break;
                if (cur > ft[i])
                { cur = -1; break; }
            }
            else if (b[i] < a[i])
            {
                for (int j = i; j >= 1; j--)
                    if (a[j] > b[i] + j - i)
                    {
                        cur += a[j] - b[i] - j + i;
                        a[j] = b[i] + j - i;
                    }
                    else
                        break;
                if (cur > ft[i])
                { cur = -1; break; }
            }
        }
        if (-1 == cur)
            puts("No");
        else
            puts("Yes");
    }
}

namespace subtask2
{
    struct segment_tree
    {
        ll s; int maxv, minv, tag;
    } t[4 * maxn + 5];

    inline ll calc_sum(int l, int r)
    { return 1ll * (l + r) * (r - l + 1) >> 1; }

    inline void update(int k)
    {
        t[k].s = t[k << 1].s + t[k << 1 | 1].s;
        t[k].maxv = max(t[k << 1].maxv, t[k << 1 | 1].maxv);
        t[k].minv = min(t[k << 1].minv, t[k << 1 | 1].minv);
    }

    inline void push_down(int k, int l, int r)
    {
        if (t[k].tag)
        {
            int mid = (l + r) >> 1;
            t[k << 1].tag = t[k].tag;
            t[k << 1].s = calc_sum(t[k].tag, t[k].tag + mid - l);
            t[k << 1].minv = t[k << 1].maxv = t[k].tag - l;
            t[k << 1 | 1].tag = t[k].tag + mid - l + 1;
            t[k << 1 | 1].s = calc_sum(t[k].tag + mid - l + 1, t[k].tag + r - l);
            t[k << 1 | 1].minv = t[k << 1 | 1].maxv = t[k].tag - l;
            t[k].tag = 0;
        }
    }

    void build(int k, int l, int r)
    {
        t[k].tag = 0;
        if (l == r)
        {
            t[k].s = a[l]; t[k].tag = 0;
            t[k].maxv = t[k].minv = a[l] - l;
            return;
        }

        int mid = (l + r) >> 1;
        build(k << 1, l, mid);
        build(k << 1 | 1, mid + 1, r);
        update(k);
    }

    int query_max(int k, int l, int r, int v)
    {
        if (l == r)
            return l;
        
        push_down(k, l, r);
        int mid = (l + r) >> 1;
        if (t[k << 1].maxv >= v)
            return query_max(k << 1, l, mid, v);
        else if (t[k << 1 | 1].minv >= v)
            return mid;
        else
            return query_max(k << 1 | 1, mid + 1, r, v);
    }

    int query_min(int k, int l, int r, int v)
    {
        if (l == r)
            return l;
        
        push_down(k, l, r);
        int mid = (l + r) >> 1;
        if (t[k << 1 | 1].minv <= v)
            return query_min(k << 1 | 1, mid + 1, r, v);
        else if (t[k << 1].maxv <= v)
            return mid + 1;
        else
            return query_min(k << 1, l, mid, v);
    }

    ll query_sum(int k, int l, int r, int x, int y)
    {
        if (x <= l && r <= y)
            return t[k].s;
        
        push_down(k, l, r);
        int mid = (l + r) >> 1; ll ans = 0;
        if (x <= mid)
            ans += query_sum(k << 1, l, mid, x, y);
        if (mid < y)
            ans += query_sum(k << 1 | 1, mid + 1, r, x, y);
        return ans;
    }

    void change(int k, int l, int r, int x, int y, int v)
    {
        if (x <= l && r <= y)
        {
            t[k].tag = v + l - x;
            t[k].s = calc_sum(t[k].tag, t[k].tag + r - l);
            t[k].maxv = t[k].minv = t[k].tag - l;
            return;
        }

        push_down(k, l, r);
        int mid = (l + r) >> 1;
        if (x <= mid)
            change(k << 1, l, mid, x, y, v);
        if (mid < y)
            change(k << 1 | 1, mid + 1, r, x, y, v);
        update(k);
    }

    void solve()
    {
        for (int i = 1; i <= n; i++)
            id[i] = i;
        sort(id + 1, id + n + 1, [](int x, int y) { return ft[x] < ft[y]; });

        ll cur = 0; build(1, 1, n);
        for (int c = 1; c <= n; c++)
        {
            int i = id[c], a = (int)query_sum(1, 1, n, i, i);
            if (a < b[i])
            {
                int pos = query_max(1, 1, n, b[i] - i);
                cur += calc_sum(b[i], b[i] + pos - i) - query_sum(1, 1, n, i, pos);
                if (cur > ft[i])
                { cur = -1; break; }
                change(1, 1, n, i, pos, b[i]);
            }
            else if (a > b[i])
            {
                int pos = query_min(1, 1, n, b[i] - i);
                cur += query_sum(1, 1, n, pos, i) - calc_sum(b[i] + pos - i, b[i]);
                if (cur > ft[i])
                { cur = -1; break; }
                change(1, 1, n, pos, i, b[i] + pos - i);
            }
        }
        if (-1 == cur)
            puts("No");
        else
            puts("Yes");
    }
}

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

    int c = read<int>(), t = read<int>();
    while (t--)
    {
        n = read<int>();
        for (int i = 1; i <= n; i++)
        { a[i] = read<int>(); b[i] = read<int>(); ft[i] = read<ll>(); }

        if (n <= 3000)
        { subtask1::solve(); continue; }
        subtask2::solve();
    }

    return 0;
}