#include <bits/stdc++.h>
using namespace std;
#define lli long long int

struct SegmentTree
{
    vector<int> s;      // tree
    vector<int> u;      // update
    int n;

    SegmentTree( int _n );
    int get( int l , int r );
    int get(int p , int l , int r , int x , int y );
    void propagate( int p , int l , int r );
    void update( int l , int r , int d );
    void update( int p , int l , int r , int x , int y , int d );
};

lli x[1005] , y[1005];
struct E
{
    lli time , type , val;      // type : 0=add  , 1=delete
    E( lli _ti , lli _ty , lli _v ) { time = _ti , type = _ty , val = _v; }
    E() {}
    bool operator < ( const E& x )  const
    {
        if ( time != x.time ) return time < x.time;
        if ( type != x.type ) return type < x.type;
        return val < x.val;
    }
} e[3005];


int main()
{
    int T; cin>>T;
    while (  T-- )
    {
        int n;
        lli m;
        cin>>n>>m;
        for ( int i=0 ; i<n ; i++ )
            cin>>y[i]>>x[i];

        int ans = 0;

        {
            lli S = m; //min( 1000 , m );
            for ( lli w=1 ; w<=S ; w++ )        // set fixed width and height and walk on columns
            {
                lli h = m / w;

                for ( int i=0 ; i<n ; i++ )
                {
                    e[2*i] = E( x[i] , 0 , y[i] );          // time to add
                    e[2*i + 1] = E( x[i]+w , 1 , y[i] );    // time to delete
                }
                sort( e , e+2*n );

                SegmentTree st( 1005 );
                for ( int i=0 ; i<2*n ; i++ )
                {
                    lli taim = e[i].time , type = e[i].type , val = e[i].val;

                    if ( type == 0 )        // add
                    {
                        st.update( max(1LL , val-h) , val , +1 );
                        ans = max( ans , st.get( 1 , 1000 ) );
                    }
                    else if ( type == 1 )   // delete
                    {
                        st.update( max(1LL , val-h) , val , -1 );
                    }
                }
            }
        }

        cout<<ans<<"\n";
    }

    return 0;
}


// struct SegmentTree
// {
    SegmentTree::SegmentTree( int _n )
    {
        n = _n;
        s.resize(6*n+5 , 0);
        u.resize(6*n+5 , 0);
    }

    int SegmentTree::get( int l , int r )
    {
        return get( 1 , 1 , n , l , r );
    }

    int SegmentTree::get(int p , int l , int r , int x , int y )
    {
        if ( r < x || l > y ) return 0;
        propagate(p , l , r);
        if ( l>=x && r<=y ) return s[p];

        int L = p*2 , R = p*2+1 , m = (l+r)/2;
        int ansL = get( L , l , m , x , y );
        int ansR = get( R , m+1 , r , x , y );
        return max(ansL , ansR);
    }

    void SegmentTree::propagate( int p , int l , int r )
    {
        int L = p*2 , R = L+1 , S = r-l+1;
        s[p] += u[p];
        if (L < s.size()) u[L] += u[p];
        if (R < s.size()) u[R] += u[p];
        u[p] = 0;
    }

    void SegmentTree::update( int l , int r , int d )
    {
        update( 1 , 1 , n , l , r , d );
    }

    void SegmentTree::update( int p , int l , int r , int x , int y , int d )
    {
        if ( r < x || l > y ) { propagate(p , l , r); return; }
        if ( l>=x && r<=y )
        {
            u[p] += d;
            propagate(p , l , r);
            return;
        }

        propagate(p , l , r);
        int L = p*2 , R = p*2+1 , m = (l+r)/2;
        update( L , l , m , x , y , d );
        update( R , m+1 , r , x , y , d );
        s[p] = max( s[L] , s[R] );
    }
// }