// An AC a day keeps the doctor away.
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#ifdef local
#define safe std::cerr<<__PRETTY_FUNCTION__<<" line "<<__LINE__<<" safe\n"
#define debug(args...) qqbx(#args, args)
#define orange(args...) danb(#args, args)
using std::cerr;
template <typename ...T> void qqbx(const char *s, T ...args) {
    int cnt = sizeof...(T);
    ((cerr << "\e[1;32m(" << s << ") = ("), ..., (cerr << args << (--cnt ? ", " : ")\e[0m\n")));
}
template <typename T> void danb(const char *s, T L, T R) {
    cerr << "\e[1;32m[ " << s << " ] = [ ";
    for (int f = 0; L != R; ++L) cerr << (f++ ? ", " : "") << *L;
    cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) ((void)0)
#define orange(...) ((void)0)
#endif // local
#define all(v) begin(v),end(v)

using namespace std;

const int mod = 998244353;
const int base = 1000007;

struct node {
    node *l, *r;
    int sum;
    node() = default;
    node(int val) : sum(val) {}
};

const int maxn = 1000025, maxlg = 20;
node pool[maxn * maxlg * 4], *ptr;
int pw[maxn];

void init_mem_pool() {
    ptr = pool;
}

node *build(int l, int r) {
    if (r - l == 1) {
        return new (ptr++) node(0);
    }
    int m = (l + r) / 2;
    node *res = new (ptr++) node(0);
    res->l = build(l, m);
    res->r = build(m, r);
    return res;
}

node *add(node *old, int pos, int l, int r) {
    node *res = new (ptr++) node;
    if (r - l == 1) {
        res->sum = old->sum;
        res->sum += 1;
        return res;
    }
    int m = (l + r) / 2;
    if (pos < m)
        res->l = add(old->l, pos, l, m), res->r = old->r;
    else
        res->l = old->l, res->r = add(old->r, pos, m, r);
    res->sum = (res->l->sum + 1LL * res->r->sum * pw[m - l]) % mod;
    return res;
}

bool cmp(node *lhs, node *rhs, int l, int r) {
    if (r - l == 1) {
        return lhs->sum > rhs->sum;
    }
    int m = (l + r) / 2;
    if (lhs->r->sum == rhs->r->sum)
        return cmp(lhs->l, rhs->l, l, m);
    else
        return cmp(lhs->r, rhs->r, m, r);
}

void dump(vector<int> &res, node *p, int l, int r) {
    if (r - l == 1) {
        for (int j = 0; j < p->sum; j++)
            res.push_back(l);
        return;
    }
    int m = (l + r) / 2;
    dump(res, p->r, m, r);
    dump(res, p->l, l, m);
}


void solve() {
    int n, L, R;
    cin >> n >> L >> R;
    vector<int> x(n), a(n);
    for (int i = 0; i < n; i++) {
        cin >> x[i];
    }
    for (int i = 0; i < n; i++) {
        cin >> a[i];
        --a[i];
    }
    init_mem_pool();

    node *root = build(0, n);

    vector<node*> dp(n);
    deque<pair<node*, int>> dq;
    dp[0] = add(root, a[0], 0, n);
    // dq.emplace_back(dp[0], x[0]);


    /* node *aa = add(root, 3, 0, n); */
    /* node *bb = add(root, 4, 0, n); */
    /* debug(cmp(aa, bb, 0, n)); */

    for (int i = 1, j = 0; i < n; i++) {
        for (; j < i && x[j] + L <= x[i]; j++) {
            if (dp[j] == nullptr) continue;
            while (!dq.empty() && !cmp(dq.back().first, dp[j], 0, n)) {
                dq.pop_back();
            }
            dq.emplace_back(dp[j], x[j]);
        }
        while (!dq.empty() && dq.front().second + R < x[i])
            dq.pop_front();

        if (!dq.empty()) {
            dp[i] = add(dq.front().first, a[i], 0, n);
            /* debug(i); */
            /* vector<int> res; */
            /* dump(res, dp[i], 0, n); */
            /* for (int &x: res) ++x; */
            /* orange(all(res)); */
        }
    }

    if (dp[n - 1] == nullptr)
        cout << -1 << '\n';
    else {
        vector<int> res;
        dump(res, dp[n - 1], 0, n);
        cout << res.size() << '\n';
        for (size_t i = 0; i < res.size(); i++)
            cout << res[i] + 1 << (i+1==res.size() ? '\n' : ' ');
    }
}

signed main() {
    pw[0] = 1;
    for (int i = 1; i < maxn; i++)
        pw[i] = 1LL * pw[i - 1] * base % mod;

    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int T;
    cin >> T;
    while (T--)
        solve();
}