#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N=2e5+5,INF=0x3f3f3f3f3f3f3f3f;
int c,T,n;
struct L{
	mutable int bh_l,bh_r,wz_l,wz_r;
	bool operator <(const L to)const{ return bh_l!=to.bh_l?bh_l<to.bh_l:bh_r<to.bh_r; }
};
typedef multiset<L>::iterator iter;
struct ODT:multiset<L>{
	int tim;
	inline int len(iter x){
		return x->bh_r-x->bh_l+1; 
	}
	iter spt(int bh){
		iter it=--upper_bound({bh,bh,0,0});//因为加了哨兵，所以这里一定是有对象的 
		if(it->bh_l==bh) return it;
		int bh_l=it->bh_l,bh_r=it->bh_r,wz_l=it->wz_l,wz_r=it->wz_r;
		erase(it);
		insert(L{bh_l,bh-1,wz_l,wz_l+(bh-1-bh_l)});
		return insert(L{bh,bh_r,wz_l+(bh-bh_l),wz_r});
	}
	void try_gt_r(iter now,int to){
		iter nxt=next(now);
		int d1=to-now->wz_l;//直接推到目标需要推的距离 
		if(now->wz_r+d1<nxt->wz_l) tim+=len(now)*d1,now->wz_l+=d1,now->wz_r+=d1;//可以直接推到，不用退更多的相知 
		else{
			int d2=nxt->wz_l-1-now->wz_r;//合并前需要推的距离 
			tim+=len(now)*d2,nxt->bh_l=now->bh_l,nxt->wz_l=now->wz_l+d2;
			try_gt_r(nxt,to);
			erase(now);//注意迭代器失效问题
		}
	}
	void try_gt_l(iter now,int to){
		iter pre=prev(now);
		int d1=now->wz_r-to;
		if(now->wz_l-d1>pre->wz_r) tim+=len(now)*d1,now->wz_l-=d1,now->wz_r-=d1;
		else{
			int d2=now->wz_l-(pre->wz_r+1);
			tim+=len(now)*d2,pre->bh_r=now->bh_r,pre->wz_r=now->wz_r-d2;
			erase(now);
			try_gt_l(pre,to);
		}
	}
};
#define a(x) dat[x].a
#define b(x) dat[x].b
#define t(x) dat[x].t
#define id(x) dat[x].id
struct DAT{
	int a,b,t,id;
	bool operator <(const DAT to)const{ return t<to.t; }
}dat[N];
void solve(){
	cin>>n;
	for(int i=1;i<=n;i++) cin>>a(i)>>b(i)>>t(i),id(i)=i;
	ODT odt;odt.clear();odt.tim=0;
	odt.insert(L{0,0,0,0});
	odt.insert(L{n+1,n+1,INF,INF});
	for(int i=1;i<=n;i++) odt.insert({i,i,a(i),a(i)});
	
	sort(dat+1,dat+1+n);
	for(int i=1;i<=n;i++){
		iter tmp=(odt.spt(id(i)+1),odt.spt(id(i)));
		if(tmp->wz_l<b(i)) odt.try_gt_r(tmp,b(i));
		else odt.try_gt_l(tmp,b(i));
		if(odt.tim>t(i)) return cout<<"No\n",void();
	}
	cout<<"Yes\n";
}
signed main(){
	freopen("move.in","r",stdin);
	freopen("move.out","w",stdout);
//	freopen("move5.in","r",stdin);
//	freopen("ans1.out","w",stdout);
	cin.tie(0)->sync_with_stdio(0);
	cin>>c>>T;
	while(T--) solve();
	return 0;
}
/*
0 1
3
4 5 3
7 6 1
10 8 4

我们需要维护set,set中存储：
bh_l,bh_r,wz_l,wz_r,
每次考虑一个对象时，我们先将其从其所在连通块中分裂出来（这也要求以编号为键值），
然后对分裂出来的一块进行递归考虑
需要注意的是，向两个方向走的应该要写两个函数……吗？
好像在递归的时候是需要的，但是实际不是太需要 
*/ 
/*
这个题目主要有两维限制，
一维是时间上的（必须在某个时刻前完成指定任务），
一维是空间上的

假如没有空间上的限制，直接按时间考虑显然不劣（可以通过邻项交换简单证明）
我们猜想，现在这个问题也有类似的贪心，但是需要打一些补丁

如果范围不交，那么显然这样贪心是正确的，
如果存在两个箱子相向而交，这就显然不可以，
箱子之间的相对关系是不能变的

或者从空间上开始考虑，
对于最右边的对象n，其在期限到来时再推一定不劣，
如果是向右的，或者是向左的，但是不交，那么没什么好说的，
如果与n-1存在交集，那么我们猜想选择在推n之前先把n-1处理好不劣，
证明：
如果存在必须要推n推一部分再推n-1,那么我们把顺序交换一下完全不会有任何影响，
最终效果也就是n-1在n前处理了
（不过要注意这里的处理不是将n-1推到其的位置，而是不干扰n,也就是推到l[n]-1）,
这样操作显然不劣，但是带来的影响是略复杂的，
时间上的限制好说，但是上面的贪心会额外带来限制，就是对于n-1有两段要求，
感觉这样子没有什么前途，

如果仍然从时间上考虑，每次选择限制最紧的去推，
显然每次操作都是没有任何浪费的（对其它对象的操作也都符合其它对象自己的需要）
那么我们就这样模拟应该就可以，
不过最好需要先判定在无限时间下可不可以

直接模拟的复杂度应该是O(n^2)的，
主要是因为阶段太多，
不过也许均摊分析能说明复杂度的正确性，

每个对象只有1个起始态和结束态，
中间的过程一定伴随着连续段数的减少，
而这个数量不会太多，
连续段数初始数量+变化量是O(n)的，
所以总的复杂度是O(n)的
虽然中间应该有些损耗，但是整体O(nlogn)应该是问题不大的

感觉现在脑袋不大清楚，先不要去打正解吧
先看后面的 
*/