/*
題目大意：工廠有m臺機器，需要做n個任務。對於一個任務i，
你需要花費一個機器Pi天，而且，開始做這個任務的時間要>=Si，完成這個任務的時間<=Ei。
對於一個任務，只能由一個機器來完成，一個機器同一時間只能做一個任務。
但是，一個任務可以分成幾段不連續的時間來完成。問，能否做完全部任務。


建圖：把每個任務和每一天都看做一個點，新增源點和匯點。
源點與每個任務之間連一條邊，容量為完成該任務所需處理次數。
若第i個任務可以在Si至Ei天處理，則由該任務向這些天分別連一條邊，容量為1，表示此任務每天只能被處理一次。
最後，從每一天連一條到匯點的邊，容量為機器數M，表示每天可以處理M個任務。
若求出的最大流等於所有任務需要處理的次數之和，說明能完成任務；否則，不能完成任務。
*/
# include<stdio.h>
# include<algorithm>
# include<stack>
#include<queue>
# include<string.h>
using namespace std;
#define inf 0x3fffff
#define N 1010
#define M 600010
//N為點數 M為邊數
struct Edge
{
    int from, to, cap, nex;
} edge[M*2]; //雙向邊，注意RE 注意這個模版是 相同起末點的邊 同時有效而不是去重
int head[N],tot;//2個要初始化-1和0
void add(int u, int v, int cap) //網路流要加反向弧，即u->v 為10 則 v->u為 -10
{
    Edge E = {u, v, cap, head[u]};
    edge[ tot ] = E;
    head[ u ] = tot++;

    Edge E2 = {v, u, 0,  head[v]}; //如果是無向邊則rw的引數值和cap相同（即 add(u,v,cap,cap) ），若是有向邊則rw不寫（即 add(u,v,cap); ）
    edge[ tot ] = E2;
    head[ v ] = tot++;
}
int dis[N], cur[N];//dis[i]表示i點距離起點的距離 cur[i]表示i點所連線的邊中 正在考慮的邊 優化不再考慮已經用過的點 初始化為head
bool vis[N];
bool BFS(int Start,int End) //跑一遍最短路
{
    memset(vis,0,sizeof(vis));
    memset(dis,-1,sizeof(dis));

    queue<int>Q;
    Q.push(Start);
    dis[Start]=0;
    vis[Start]=1;
    while(!Q.empty())
    {
        int u = Q.front();
        Q.pop();
        for(int i = head[u]; i != -1; i = edge[i].nex)
        {
            Edge E = edge[i];
            if( !vis[E.to] && E.cap > 0)
            {
                vis[ E.to ] = true;
                dis[ E.to ] = dis[ u ] + 1;
                if(E.to == End)
                    return true;
                Q.push( E.to );
            }
        }
    }
    return false;
}
int DFS(int x, int a,int End) //當前 流入x 的流量是a   流量a 是所有流過邊中 邊權的最小值
{
    if( x == End || a == 0)return a;
    int flow = 0, f; //flow表示從x點流到下面所有點，最大的流量
    for(int& i = cur[x]; i != -1; i = edge[i].nex)
    {
        Edge& E = edge[i];
        if(dis[x] + 1 == dis[E.to] && (f = DFS(E.to , min(a, E.cap), End))>0 )
        {
            E.cap -= f;
            edge[ i^1 ].cap += f;//反向邊要減掉
            flow += f;
            a -= f;
            if(a==0)break;
        }
    }
    return flow;
}
int Dinic(int Start,int End)
{
    int flow=0;
    while(BFS(Start,End))  //當存在源點到匯點的路徑時
    {
        memcpy(cur,head,sizeof(head));//把head的陣列複製過去
        flow += DFS(Start, inf, End);
        //  printf("%d\n",flow);
    }
    return flow;
}
void init()
{
    memset(head, -1, sizeof head);
    tot = 0;
}
int main()
{
    int t,m,n,i,j,p,s,e;
    while(~scanf("%d",&t))
    {
        int cas=0;
        while(t--)
        {
            init();
            scanf("%d%d",&n,&m);
            int sum=0;
            int maxx=0;
            for(i=1; i<=n; i++)
            {
                scanf("%d%d%d",&p,&s,&e);
                add(0,i,p);
                maxx=max(maxx,e);
                sum+=p;
                for(j=s; j<=e; j++)
                    add(i,j+n,1);
            }
            int sink=maxx+n+1;
            for(i=1; i<=maxx; i++)
                add(n+i,sink,m);
            if(Dinic(0,sink)==sum)
                printf("Case %d: Yes\n\n",++cas);
            else
                printf("Case %d: No\n\n",++cas);
        }
    }
    return 0;
}