#include<bits/stdc++.h>

struct SlidingWindow {
    std::deque<int> pos;
    std::vector<int> value;

    SlidingWindow(int N): value(1 + N) {}

    void push(int i, int v) {
        value[i] = v;

        while (!pos.empty() && v >= value[pos.back()])
            pos.pop_back();
        pos.push_back(i);
    }

    void pop(int i) {
        if (!pos.empty() && pos.front() == i)
            pos.pop_front();
    }

    int query() {
        if (pos.empty())
            return -1000000000;
        return value[pos.front()];
    }

    void dump() {
        std::cerr << "dump\n";
        std::cerr << "    ";
        for (auto it: pos)
            std::cerr << it << " ";
        std::cerr << "\n    ";
        for (auto it: pos)
            std::cerr << value[it] << " ";
        std::cerr << "\n";
    }
};

void solve_test() {
    int n;
    long long A, B;

    std::cin >> n >> A >> B;

    std::vector<long long> v(1 + 2 * n);
    for (int i = 1; i <= 2 * n; i++)
        std::cin >> v[i];

    n = n * 2;

    std::sort(v.begin() + 1, v.end());

    std::vector<int> dp(1 + n, -1000000000);
    dp[0] = 0;

    SlidingWindow ds(n);
    ds.push(0, 0);

    int last_invalid = 1;

    for (int i = 1; i <= n; i++) {

        if (i % 2 == 0) {
            if (v[i] - v[i - 1] <= A) {
                dp[i] = std::max(dp[i], dp[i - 2] + (v[i] - v[i - 1] <= B));
            }

            while (last_invalid + 1 <= i + 1 && (v[i] - v[last_invalid] > A || (i > 2 && v[i - 1] - v[i - 2] > B))) {
                ds.pop(last_invalid - 1);
                last_invalid += 2;
            }

            if (last_invalid < i) {
                dp[i] = std::max(dp[i], i / 2 + ds.query() - 1);
            }
            ds.push(i, dp[i] - i / 2);
        }
    }

    if (dp[n] < 0)
        std::cout << "-1\n";
    else
        std::cout << dp[n] << "\n";
}

int main(){
    std::ios_base::sync_with_stdio(0);
    std::cin.tie(0);

    int t;
    std::cin >> t;

    while (t--) solve_test();

    return 0;
}