#include <bits/stdc++.h>
using namespace std;
#define IC isdigit(c)
#define GC c=getchar()
#define il inline
il void rd(auto &x) { bool f = 0; x = 0; int GC; 
   for (; !IC; GC) f |= c == '-';
   for (; IC; GC) x = x * 10 + (c - 48);
   f ? (x = -x) : 0;
}
il void rd(auto &x, auto &... y) { rd(x); rd(y...); }
#define U(i,l,r) for (int i(l),END##i(r); i<=END##i; ++i)
#define D(i,l,r) for (int i(l),END##i(r); i>=END##i; --i)
#define ms(x, v) memset(x, v, sizeof(x))
using ll = long long;
#define pb push_back
#define eb emplace_back
#define vc vector
int _perf;
#define bp ++_perf

// qujian fugai
const int V = 1000000000;
const int N = 200005, SIZ = N * 65;
int CID;

#define mid ((l + r) >> 1)
#define ls tr[p].lc
#define rs tr[p].rc
#define arg int &p = rt, int l = 0, int r = V
#define L ls, l, mid
#define R rs, mid + 1, r
int rt;
il ll sgm(ll l, ll r) { return (l + r) * (r - l + 1) >> 1; }
struct node {
   int sum, cnt; // zuixiao qianzhuihe yu weizhi
   ll spos; // xiabiao zhihe
   int mpre, msuf;
   int lc, rc;
   int tc = 1;
   void app(int v, int l, int r) {
      tc = v;
      if (v == 0) {
         cnt = r - l + 1;
         sum = 0;
         mpre = msuf = 0;
         spos = sgm(l, r);
      } else {
         cnt = 0; sum = -(r - l + 1);
         mpre = msuf = sum;
         spos = 0;
      }
   }
} tr[SIZ]; int ptr;
il int alloc() { tr[++ptr] = node{}; return ptr; }
il void up(int p) {
   tr[p].sum = tr[ls].sum + tr[rs].sum;
   tr[p].cnt = tr[ls].cnt + tr[rs].cnt;
   tr[p].spos = tr[ls].spos + tr[rs].spos;
   
   tr[p].mpre = min(tr[ls].mpre, tr[rs].mpre + tr[ls].sum);
   tr[p].msuf = min(tr[rs].msuf, tr[ls].msuf + tr[rs].sum);
}
il void down(int p, int l, int r) {
   int &t = tr[p].tc; if (t == 1) return;
   if (!ls) ls = alloc();
   if (!rs) rs = alloc();
   tr[ls].app(t, l, mid);
   tr[rs].app(t, mid + 1, r);
   t = 1;
}
void cover(int b, int e, int v, arg) {
   if (b <= l && e >= r) {
      tr[p].app(v, l, r);
      return;
   }
   down(p, l, r);
   if (b <= mid) cover(b, e, v, L);
   if (e > mid) cover(b, e, v, R);
   up(p);
}
int qc(int b, int e, arg) {
   if (b <= l && e >= r) return tr[p].cnt;
   if (tr[p].tc != 1) {
      if (tr[p].tc == -1) return 0;
      b = max(b, l); e = min(e, r);
      return e - b + 1;
   }
   down(p, l, r);
   int v = 0;
   if (b <= mid) v = qc(b, e, L);
   if (e > mid) v += qc(b, e, R);
   return v;
}
// ll qsp(int b, int e, arg) {
//    if (b <= l && e >= r) return tr[p].spos;
//    down(p, l, r);
//    ll v = 0;
//    if (b <= mid) v = qsp(b, e, L);
//    if (e > mid) v += qsp(b, e, R);
//    return v;
// }
il void operator += (pair<int, ll> &x, const pair<int, ll> &y) {
   x.first += y.first;
   x.second += y.second;
}
pair<int, ll> q2(int b, int e, arg) {
   if (b <= l && e >= r) return {tr[p].cnt, tr[p].spos};
   if (tr[p].tc != 1) {
      if (tr[p].tc == -1)
         return {0, 0};
      b = max(b, l); e = min(e, r);
      return {e - b + 1, sgm(b, e)};
   }
   pair<int, ll> v = {0, 0};
   if (b <= mid) v = q2(b, e, L);
   if (e > mid) v += q2(b, e, R);
   return v;
}
int kth(int k, arg) {
   if (l == r) return l;
   if (tr[p].tc != 1) {
      // assert(tr[p].tc == 0);
      // assert(l + k - 1 <= r);
      return l + k - 1;
   }
   // down(p, l, r);
   if (k <= tr[ls].cnt)
      return kth(k, L);
   return kth(k - tr[ls].cnt, R);
}
pair<int, int> sch_r(int b, int c, arg) {
   // bp;
   // assert(p);
   if (b <= l) {
      if (tr[p].mpre + c > 0)
         return {-1, tr[p].sum};
      if (l == r) return {l, 0};
      
      if (tr[p].tc != 1) {
         if (tr[p].tc == 0) {
            // assert(c <= 0);
            return {l, 0};
         }
         return {l + c - 1, 0};
      }
      // down(p, l, r);
      if (tr[ls].mpre + c <= 0)
         return sch_r(b, c, L);
      return sch_r(b, c + tr[ls].sum, R);
   }
   if (tr[p].tc != 1) {
      b = max(b, l);
      if (tr[p].tc == 0) {
         if (c > 0) return {-1, 0};
         return {b, 0};
      } else {
         if (c - (r - b + 1) > 0) return {-1, -(r - b + 1)};
         return {b + c - 1, 0};
      }
   }
   // down(p, l, r);
   int v = -1, w = 0;
   if (b <= mid)
      tie(v, w) = sch_r(b, c, L);
   if (v != -1) return {v, 0};
   auto [v2, w2] = sch_r(b, c + w, R);
   if (v2 != -1) return {v2, 0};
   return {-1, w + w2};
}
pair<int, int> sch_l(int e, int c, arg) {
   // bp;
   // assert(p);
   if (e >= r) {
      if (tr[p].msuf + c > 0)
         return {-1, tr[p].sum};
      if (l == r) return {l, 0};
      
      if (tr[p].tc != 1) {
         if (tr[p].tc == 0) {
            // assert(c <= 0);
            return {r, 0};
         }
         return {r - c + 1, 0};
      }
      down(p, l, r);
      if (tr[rs].msuf + c <= 0)
         return sch_l(e, c, R);
      return sch_l(e, c + tr[rs].sum, L);
   }
   if (tr[p].tc != 1) {
      e = min(e, r);
      if (tr[p].tc == 0) {
         if (c > 0) return {-1, 0};
         return {e, 0};
      } else {
         if (c - (e - l + 1) > 0) return {-1, -(e - l + 1)};
         return {e - c + 1, 0};
      }
   }
   down(p, l, r);
   int v = -1, w = 0;
   if (e > mid)
      tie(v, w) = sch_l(e, c, R);
   if (v != -1) return {v, 0};
   auto [v2, w2] = sch_l(e, c + w, L);
   if (v2 != -1) return {v2, 0};
   return {-1, w + w2};
}

int n, a[N], b[N]; ll t[N];

int cp;
// void dump(arg) {
//    if (l == r) {
//       a[++cp] = l;
//       return;
//    }
//    if (tr[p].tc != 1) {
//       if (tr[p].tc == -1) return;
//       U (i, l, r) a[++cp] = i;
//       return;
//    }
//    dump(L); dump(R);
// }
void build(arg) {
   if (cp > n) return;
   if (l == r) {
      tr[p].app(0, l, l);
      ++cp;
      return;
   }
   down(p, l, r);
   // assert(a[cp] >= l);
   if (cp <= n && a[cp] <= mid)
      build(L);
   if (cp <= n && a[cp] <= r)
      build(R);
   up(p);
}
void make() {
   ptr = 0;
   rt = alloc();
   cover(0, V, -1);
   cp = 1;
   build();
}

void solve() {

   rd(n);
   U (i, 1, n) rd(a[i], b[i], t[i]);
   int sa[N] {};
   U (i, 1, n) sa[i] = i;
   sort(sa + 1, sa + n + 1, [&](int u, int v) {
      return t[u] < t[v];
   });

   if (CID >= 19 && CID <= 20) {
      ll ct = 0;
      U (_, 1, n) {
         int i = sa[_];
         ct += abs(b[i] - a[i]);
         if (ct > t[i]) { puts("No"); return; }
      }
      puts("Yes"); return;
   }

   make();

   ll ct = 0;
   U (_, 1, n) {
      int i = sa[_];
      int pos = kth(i);
      // if (_ == 1) assert(pos == a[i]);
      // clog << "@" << i << endl;
      
      if (pos < b[i]) {
         int c = qc(pos, b[i] - 1);
         int j = b[i];
         j = sch_r(b[i], c).first;
         auto [tot, sp] = q2(pos, j);
         ll cost = sgm(j - tot + 1, j) - sp;
         ct += cost;
         cover(pos, j, -1);
         cover(b[i], j, 0);
      } else if (pos > b[i]) {
         int c = qc(b[i] + 1, pos);
         int j = b[i];
         j = sch_l(b[i], c).first;
         auto [tot, sp] = q2(j, pos);
         ll cost = sp - sgm(j, j + tot - 1);
         ct += cost;
         cover(j, pos, -1);
         cover(j, b[i], 0);
      }
      if (ct > t[i]) {
         puts("No");
         return;
      }
   }
   puts("Yes");
}  

void clear() {
   // clog << "*" << ptr << ' ' << SIZ << endl;
   rt = 0;
   // U (i, 1, ptr) tr[i] = node {};
   // memset(tr, 0, sizeof(node) * (ptr + 1));
   // U (i, 1, ptr) tr[i].tc = 1;
   ptr = 0;
   // clog << "#" << _perf << endl;
   // _perf = 0;
}
int main() {
   freopen("move.in", "r", stdin);
   freopen("move.out", "w", stdout);
   // freopen("out", "w", stderr);

   int t; rd(CID, t);
   while (t--) {
      solve();
      clear();
   }
}