#include<bits/stdc++.h>
using namespace std;

#define cout cerr
#define rep(i,a,b) for(int i=(a);i<=(b);++i)
#define per(i,a,b) for(int i=(a);i>=(b);--i)

typedef long long ll;
typedef pair<int,int> pii;
#define FR first
#define SE second

inline void rd(int &x){
    x=0;char ch=getchar();int f=1;
    while(ch<'0'||ch>'9'){
        if(ch=='-')f=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9'){
        x=x*10+ch-'0';
        ch=getchar();
    }
    x*=f;
}
inline void rd(ll &x){
    x=0;char ch=getchar();int f=1;
    while(ch<'0'||ch>'9'){
        if(ch=='-')f=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9'){
        x=x*10+ch-'0';
        ch=getchar();
    }
    x*=f;
}

int n;
ll m;
#define Maxn 500010
#define V 1100010
#define ls k<<1
#define rs k<<1|1

int len;
namespace Seg{//Modify query ask add
    int cnt[V],tag[V],sum[V];
    void make_tag(int k,int z){
        tag[k]=z;sum[k]=z*cnt[k];
    }
    void push_down(int k){
        if(tag[k]!=-1){
            make_tag(ls,tag[k]);
            make_tag(rs,tag[k]);
            tag[k]=-1;
        }
    }
    void push_up(int k){sum[k]=sum[ls]+sum[rs];}
    void build(int k,int l,int r){
        cnt[k]=sum[k]=0;tag[k]=-1;
        if(l==r)return;
        int mid=(l+r)>>1;
        build(ls,l,mid);
        build(rs,mid+1,r);
    }
    
    void ADD(int k,int l,int r,int x){
        if(l==r){tag[k]=0;cnt[k]=1;return;}
        push_down(k);
        int mid=(l+r)>>1;
        if(x<=mid)ADD(ls,l,mid,x);else ADD(rs,mid+1,r,x);
        cnt[k]++;
    }
    void add(int x){ADD(1,0,len,x);}

    bool ask(int k,int l,int r,int x){
        if(l==r)return sum[k];
        push_down(k);
        int mid=(l+r)>>1;
        if(x<=mid)return ask(ls,l,mid,x);else return ask(rs,mid+1,r,x);
    }
    bool ask(int x){return ask(1,0,len,x);}

    int find(int k,int l,int r){
        if(l==r)return l;
        push_down(k);
        int mid=(l+r)>>1;
        if(sum[rs])return find(rs,mid+1,r);
        else return find(ls,l,mid);
    }
    int query(int k,int l,int r,int x){
        if(l==r){
            if(sum[k])return l;
            return l-1;
        }
        push_down(k);
        int mid=(l+r)>>1;
        if(x<=mid)return query(ls,l,mid,x);
        else{
            int z=query(rs,mid+1,r,x);
            if(z>mid)return z;
            if(!sum[ls])return l-1;
            return find(ls,l,mid);
        }
    }
    int query(int x){return query(1,0,len,x);}

    void Modify(int k,int l,int r,int L,int R,int v){
        if(l==L&&r==R){
            make_tag(k,v);
            return;
        }
        push_down(k);
        int mid=(l+r)>>1;
        if(R<=mid)Modify(ls,l,mid,L,R,v);
        else if(mid<L)Modify(rs,mid+1,r,L,R,v);
        else{
            Modify(ls,l,mid,L,mid,v);
            Modify(rs,mid+1,r,mid+1,R,v);
        }
        push_up(k);
    }
    void Modify(int l,int r,int v){Modify(1,0,len,l,r,v);}
}

namespace Jump{
    int LIMIT;
    int mx[V];
    void build(int k,int l,int r){
        mx[k]=0;
        if(l==r)return;
        int mid=(l+r)>>1;
        build(ls,l,mid);build(rs,mid+1,r);
    }

    void Change(int k,int l,int r,int x,int z){
        if(l==r){
            mx[k]=z;
            return;
        }
        int mid=(l+r)>>1;
        if(x<=mid)Change(ls,l,mid,x,z);else Change(rs,mid+1,r,x,z);
        mx[k]=max(mx[ls],mx[rs]);
    }
    void Change(int x,int z){Change(1,0,len,x,z);}

    int find(int k,int l,int r){
        if(l==r)return l;
        int mid=(l+r)>>1;
        if(mx[ls]>LIMIT)return find(ls,l,mid);
        else return find(rs,mid+1,r);
    }
    int jump(int k,int l,int r,int x){
        if(l==r){
            if(mx[k]>LIMIT)return l;
            return l+1;
        }
        int mid=(l+r)>>1;
        if(x>mid)return jump(rs,mid+1,r,x);
        else{
            int t=jump(ls,l,mid,x);
            if(t<=mid)return t;
            if(mx[rs]<=LIMIT)return r+1;
            return find(rs,mid+1,r);
        }
    }
    int query(int x){return min(jump(1,0,len,x),len);}
}
using Jump::LIMIT;

ll ynum[Maxn];
bool vis[Maxn];
struct Point{
    ll x,y;
    bool operator <(const Point &q)const{return x==q.x?y<q.y:x<q.x;}
}p[Maxn];

ll s1[Maxn],s2[Maxn],s3[Maxn],tp;int nxt[Maxn];
set<ll> Y;
void Judge(){
    rep(i,1,len)vis[i]=0;vis[0]=1;
    tp=0;
    Seg::build(1,0,len);Seg::add(0);Seg::Modify(0,0,1);
    Jump::build(1,0,len);ynum[len+1]=ynum[len];
    Y.clear();Y.insert(0);nxt[0]=len+1;
    for(ll l=1,r;l<=n;l=r+1){
        if(p[l].x>=m)LIMIT=0;else LIMIT=(m-p[l].x)/2;
        r=l;
        while(r+1<=n&&p[r+1].x==p[r].x)r++;
        s2[tp+1]=len+1;
        ll d=p[l].y;
        for(ll i=tp;s2[i+1]>d;--i){
            ll z1=max(s2[i],d),z2=s2[i+1]-1;
            ll at=upper_bound(ynum+1,ynum+len+1,m-2*(p[l].x-s1[i]))-ynum-1;
            if(max(at+1,z1)<=z2)Seg::Modify(max(at+1,z1),z2,0);
            ll mx=Seg::query(z2);
            if(mx>=z1)Seg::Modify(mx,Jump::query(mx),1);
        }
        while(s2[tp]>=d)tp--;
        if(tp){
            s3[tp]=Seg::query(p[l].y-1);
            if(s3[tp]<s2[tp])s3[tp]=s3[tp-1];
            else s3[tp]=s1[tp]+ynum[s3[tp]];
        }
        rep(i,l,r)
            if(!vis[p[i].y]){
                Seg::add(p[i].y);
                ll t=p[i].y;
                vis[t]=true;
                set<ll>::iterator it=(Y.insert(t)).FR;
                it--;
                ll h1=(*it),h2=nxt[h1];
                nxt[h1]=t;nxt[t]=h2;
                Jump::Change(h1,ynum[t]-ynum[h1]);
                Jump::Change(t,ynum[h2]-ynum[t]);
                if(i!=l&&Seg::ask(h1)&&(ynum[t]-ynum[h1]<=LIMIT))Seg::Modify(t,Jump::query(t),1);
            }
        if(2*p[l].x+2*ynum[p[l].y]-s3[tp]<=m)Seg::Modify(p[l].y,Jump::query(p[l].y),1);
        s1[++tp]=p[l].x;s2[tp]=p[l].y;
        s3[tp]=Seg::query(len);
        if(s3[tp]<s2[tp])s3[tp]=s3[tp-1];else s3[tp]=s1[tp]+ynum[s3[tp]];
    }
    if(Seg::ask(len))puts("Yes");
    else puts("No");
}

int main(){
   // freopen("04","r",stdin);
   // freopen("out","w",stdout);
    int TT;rd(TT);
    while(TT--){
        rd(n);rd(m);
        rep(i,1,n){
            rd(p[i].x);rd(p[i].y);
        }
        sort(p+1,p+n+1);
        rep(i,1,n)ynum[i]=p[i].y;
        sort(ynum+1,ynum+n+1);len=unique(ynum+1,ynum+n+1)-ynum-1;
        rep(i,1,n){
            p[i].y=lower_bound(ynum+1,ynum+len+1,p[i].y)-ynum;
        }
        Judge();
    }
    return 0;
}