#include <bits/stdc++.h>

using namespace std;
#define ll long long
#define pii pair<int, int>
#define ld long double
#define all(a) (a).begin(), (a).end()

const int N1 = 40000003;
const int N2 = 41289407;
const int N3 = 43220311;

ll key[N1];
int val[N2];

ll get(ll lvl, ll l, ll r) {
    return ((lvl + 1) * N2 + (l + 7)) * N3 + r;
}

int pos(ll u) {
    int i = u % N1;

    while (key[i] != 0 && key[i] != u) i = (i + 1) % N1;
    return i;
}

// bool in(ll lvl, ll l, ll r) {
//     ll u = get(lvl, l, r);
//     return key[pos(u)] == u;
// }

// int& at(ll lvl, ll l, ll r) {
//     ll u = get(lvl, l, r);
//     int p = pos(u);
//     key[p] = u;
//     return val[p];
// }

// int& at(ll u) {
//     ll u = get(lvl, l, r);
//     int p = pos(u);
//     key[p] = u;
//     return val[p];
// }

// int find_(ll u) {

// }

// 40000003
// 41289407
// 43220311

// bool p(ll i) {
//     for (ll j = 2; j * j <= i; ++j) if (i % j == 0) return 0;
//     return 1;
// }

const int K = 20;
const int MAXN = 1 << K;
map<pair<int, int>, int> nodes_by_children[K + 1];
vector<pair<int, int>> nodes[K + 1];

bool cmp(int rk, int tree1, int tree2) {
    if (tree1 == tree2)
        return false;
    if (rk == 0)
        return tree1 < tree2;
    if (nodes[rk][tree1].second != nodes[rk][tree2].second) {
        return cmp(rk - 1, nodes[rk][tree1].second, nodes[rk][tree2].second);
    }
    return cmp(rk - 1, nodes[rk][tree1].first, nodes[rk][tree2].first);
}

int add_one(int tree, int rk, int left, int right, int i) {
    if (left + 1 == right) {
        return tree + 1;
    }
    int l1 = nodes[rk][tree].first;
    int r1 = nodes[rk][tree].second;
    int mid = (left + right) / 2;
    if (i < mid)
        l1 = add_one(l1, rk - 1, left, mid, i);
    else
        r1 = add_one(r1, rk - 1, mid, right, i);

    ll u = get(rk, l1, r1);

    int j = pos(u);

    if (key[j] == u)
        return val[j];
    nodes[rk].emplace_back(l1, r1);

    key[j] = u;
    val[j] = nodes[rk].size() - 1;
    return nodes[rk].size() - 1;
}

void restore_ans(int tree, int rk, int left, int right, vector<int>& ans) {
    if (left + 1 == right) {
        for (int j = 0; j < tree; ++j)
            ans.emplace_back(left);
        return;
    }
    int mid = (left + right) / 2;
    restore_ans(nodes[rk][tree].second, rk - 1, mid, right, ans);
    restore_ans(nodes[rk][tree].first, rk - 1, left, mid, ans);
}

signed main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    // int at = 4e7;

    // while (at < 5e7) {
    //     if (p(at)) {
    //         cerr << at << '\n';
    //         at += rand() % (1000000) + 1000000;
    //     } else {
    //         at += 1;
    //     }

    // }

    // return 0;


    int t;
    cin >> t;
    for (int i = 1; i <= K; ++i) {
        nodes[i].emplace_back(0, 0);
        // at(i, 0, 0) = 0;

        ll u = get(i, 0, 0);

        int j = pos(u);

        // if (key[i] == u)
        //     return val[i];
        // nodes[rk].emplace_back(l1, r1);
        key[j] = u;
        val[j] = 0;

    }
    while (t--) {
        int n, L, R;
        cin >> n >> L >> R;
        vector<int> x(n);
        for (int i = 0; i < n; ++i)
            cin >> x[i];
        vector<int> a(n);
        for (int i = 0; i < n; ++i)
            cin >> a[i];
        int cur_rk = 0;
        while ((1 << cur_rk) <= n)
            ++cur_rk;
        vector<int> dp(n, -1);
        dp[0] = add_one(0, cur_rk, 0, 1 << cur_rk, a[0]);

        vector<int> stack1;
        vector<int> mx1;
        vector<int> stack2;
        vector<int> mx2;
        
        auto queue_push = [&](int x) {
            stack2.emplace_back(x);
            if (mx2.empty() || cmp(cur_rk, mx2.back(), x))
                mx2.emplace_back(x);
            else
                mx2.emplace_back(mx2.back());
        };
        auto queue_pop = [&]() {
            if (stack1.empty()) {
                while (!stack2.empty()) {
                    int x = stack2.back();

                    stack1.emplace_back(x);
                    if (mx1.empty() || cmp(cur_rk, mx1.back(), x))
                        mx1.emplace_back(x);
                    else
                        mx1.emplace_back(mx1.back());

                    stack2.pop_back();
                    mx2.pop_back();
                }
            }
            stack1.pop_back();
            mx1.pop_back();
        };

        int l1 = 0, r1 = 0;
        for (int i = 1; i < n; ++i) {
            while (r1 < i && x[r1] <= x[i] - L) {
                if (dp[r1] != -1)
                    queue_push(dp[r1]);
                ++r1;
            }
            while (l1 < i && x[l1] < x[i] - R) {
                if (dp[l1] != -1)
                    queue_pop();
                ++l1;
            }
            if (stack1.empty() && stack2.empty()) {
                dp[i] = -1;
            } else {
                int opt = -1;
                if (stack2.empty())
                    opt = mx1.back();
                else if (stack1.empty())
                    opt = mx2.back();
                else if (cmp(cur_rk, mx1.back(), mx2.back()))
                    opt = mx2.back();
                else
                    opt = mx1.back();
                dp[i] = add_one(opt, cur_rk, 0, 1 << cur_rk, a[i]);
            }
        }
        if (dp[n - 1] == -1)
            cout << -1 << '\n';
        else {
            vector<int> ans;
            restore_ans(dp[n - 1], cur_rk, 0, 1 << cur_rk, ans);
            cout << ans.size() << '\n';
            for (int x : ans)
                cout << x << ' ';
            cout << '\n';
        }
    }

    //cerr << clock() * 1.0 / CLOCKS_PER_SEC << '\n';

    return 0;
}