#include <bits/stdc++.h>

using std::vector, std::array, std::string;
using std::set, std::map, std::multiset;
using std::min, std::max, std::swap;
using std::pair, std::tuple;
using std::tie;
using std::abs, std::sin, std::cos, std::tan, std::asin, std::acos, std::atan2;
using std::cin, std::cout;

template <class T> using Vec = vector<T>;
template <class T> using Opt = std::optional<T>;

using i32 = int32_t;
using i64 = int64_t;
using u32 = uint32_t;
using u64 = uint64_t;
using u128 = __uint128_t;

std::mt19937_64 mt(std::chrono::steady_clock::now().time_since_epoch().count());

int solve(int N, i64 A, i64 B, const Vec<i64>& S) {
	for (int i = 0; i < N; i++) {
		if (S[2*i+1] - S[2*i] > A) {
			return -1;
		}
	}

	int cur_dp = 0;
	int pref_cnt = 0;
	int first_pairable = 0;

	auto q = Vec<pair<int, int>>{{0, cur_dp - 0}};
	q.reserve(N+1);
	decltype(q)::const_iterator fr = q.begin();

	for (int i = 0; i < N; i++) {
		int nxt_dp = cur_dp + int(S[2*i+1] - S[2*i] <= B);

		if (i > 0 && S[2*i] - S[2*i-1] <= B) {
			pref_cnt++;
		}
		// unsafe but whatever
		while (S[2*i+1] - S[2*first_pairable] > A) {
			first_pairable++;
		}
		while (fr->first < first_pairable) {
			fr = next(fr);
		}
		nxt_dp = max(nxt_dp, fr->second + pref_cnt);
		// dp[i+1] is now computed correctly

		cur_dp = std::move(nxt_dp);
		if (i+1 < N) {
			// must subtract away the contribution of (2*i+1, 2*i+2)
			int sub = pref_cnt + int(S[2*i+2] - S[2*i+1] <= B);
			q.emplace_back(i+1, cur_dp - sub);
		}
	}
	return cur_dp;
}

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

	int T;
	cin >> T;
	while (T--) {
		int N;
		i64 A, B;
		cin >> N >> A >> B;
		auto S = Vec<i64>(2*N);
		for (auto& s : S) {
			cin >> s;
		}
		std::ranges::sort(S);

		cout << solve(N, A, B, S) << '\n';
	}

	return 0;
}