/*
如果x < 0，它会立刻散架
冲撞会损耗ai稳定性，回馈bi的稳定性
合理安排顺序，保证不散架，将障碍全部摧毁
思路：肯定是先上小的（是么），积蓄力量，攻克大的
故而一开始先排小的，处理完小的再看大的能否处理
是咩：若是这样的呢
1
6 3
1 0
1 0
1 0
3 3
3 3
3 3
那我没了啊
那我每次选择（a-b）>=0 && a<=m先收入囊中
这样排序来贪心，数据的多大肯定超时；没事我试试
果真没了，%35，但有一个答案错误，这是为什么呢
我排序，把比m小反馈多的先吃掉，每次都排一次
这样保证每一次都尽可能吃掉自己接受的，且消耗少
为啥会出错呢？不知道，我一定要换个思路
还是先吃小怪，达到峰值，再吃大怪
小怪怎么吃呢 bi-ai&&ai<m吃了之后得到
会不会出现这种情况，那我排小怪就死定了，所以不
能直接按照bi-ai来走，
1
5 50
1 0
1 0
1 0
1 0
50 30
要按照bi来走，
那要是遇到（例子很多啊）

貌似我又死了
所以不能单纯走bi

ai，bi，bi-ai都不能单纯走得通
肯定要变通一下，如何变通呢
ai，bi，bi-ai都不能单纯走得通
肯定要变通一下，如何变通呢
1.先吃小怪，达峰值,吃bi大的大怪
记得m要long long 因为可能疯狂吃超过了int范围，停在了%80
这个点卡了好久，加long long啊！！！
*/

`#include

代码块
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
struct node
{
    long long a;
    long long b;
};
long long t,n,m,flag;
struct node x[600000];
bool cmp(struct node q,struct node w)
{
    return (q.b-q.a)>(w.b-w.a);
}
bool cmm(struct node q,struct node w)
{
    return q.b>w.b;
}
int main()
{
    cin>>t;
    while(t--)
    {
        cin>>n>>m;
        for(int i=1; i<=n; i++)
            cin>>x[i].a>>x[i].b;
        flag=1;
        while(flag==1)
        {
            flag=0;
            sort(x+1,x+n+1,cmp);
            for(int i=1;i<=n;i++)
                if(x[i].a<=m&&(x[i].b-x[i].a)>=0&&(x[i].a!=0||x[i].b!=0))
                {
                    flag=1;
                    m=m-x[i].a+x[i].b;
                    x[i].a=0;
                    x[i].b=0;
                }
        }
        sort(x+1,x+1+n,cmm);
        flag=0;
        for(int i=1;i<=n;i++)
        {
            if(m>=x[i].a)
            {
                m=m-x[i].a+x[i].b;
            }
            else
            {
                cout<<"No"<<endl;
                flag=1;
                break;
            }
        }
        if(flag==0)
            cout<<"Yes"<<endl;

    }
    return 0;
}
`