#include<iostream>
#include<cstring>
#include<vector>
#include<numeric>
#include<functional>
#include<algorithm>
using namespace std;
using LL = long long;

const int INF = 1e9;
struct Info {
    int mx = -INF;
};

Info operator+(const Info &a, const Info &b){
    return {max(a.mx, b.mx)};
}

template<class Info>
struct SegmentTree{
    int n;
    vector<Info> info;

    SegmentTree() {}

    SegmentTree(int n, Info _init = Info()){
        init(vector<Info>(n, _init));
    }

    SegmentTree(const vector<Info> &_init){
        init(_init);
    }

    void init(const vector<Info> &_init){
        n = (int)_init.size();
        info.assign((n << 2) + 1, Info());
        function<void(int, int, int)> build = [&](int p, int l, int r){
            if (l == r){
                info[p] = _init[l];
                return;
            }
            int m = (l + r) / 2;
            build(2 * p, l, m);
            build(2 * p + 1, m + 1, r);
            pull(p);
        };
        build(1, 0, n - 1);
    }

    void pull(int p){
        info[p] = info[2 * p] + info[2 * p + 1];
    }

    void modify(int p, int l, int r, int x, const Info &v){
        if (l == r){
            info[p] = v;
            return;
        }
        int m = (l + r) / 2;
        if (x <= m){
            modify(2 * p, l, m, x, v);
        } 
        else{
            modify(2 * p + 1, m + 1, r, x, v);
        }
        pull(p);
    }

    void modify(int p, const Info &v){
        modify(1, 0, n - 1, p, v);
    }

    Info query(int p, int l, int r, int x, int y){
        if (l > y || r < x){
            return Info();
        }
        if (l >= x && r <= y){
            return info[p];
        }
        int m = (l + r) / 2;
        return query(2 * p, l, m, x, y) + query(2 * p + 1, m + 1, r, x, y);
    }

    Info query(int l, int r){
        return query(1, 0, n - 1, l, r);
    }
};

int main(){

#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif

    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);

    int T;
    cin >> T;
    while(T--){
        int n; LL A, B;
        cin >> n >> A >> B;
        n *= 2;
        vector<LL> a(n + 1);
        for(int i = 1; i <= n; i++) cin >> a[i];
        sort(a.begin() + 1, a.end());
        vector<int> b(n + 2);
        for(int i = n - 2; i >= 1; i -= 2){
            if (a[i + 1] - a[i] <= B){
                b[i] = 1;
            }
        }
        for(int i = 1; i <= n + 1; i++){
            b[i] += b[i - 1];
        }
        vector<int> pre(n + 1);
        for(int i = n, j = n; i >= 1; i--){
            while(j >= 1 and a[i] - a[j] <= A) j--;
            pre[i] = j;
        }
        SegmentTree<Info> seg(n + 1);
        seg.modify(0, {0});
        vector<int> dp(n + 1, -1);
        dp[0] = 0;
        for(int i = 2; i <= n; i += 2){
            if (a[i] - a[i - 1] <= B){
                dp[i] = max(dp[i], dp[i - 2] + 1);
            }
            dp[i] = max(dp[i], seg.query(pre[i], i).mx + b[i - 1]);
            seg.modify(i, {dp[i] - b[i + 1]});
        }
        cout << dp[n] << '\n';
    }

}