//#pragma GCC optimize("Ofast", "unroll-loops")
//#pragma GCC target("sse", "sse2", "sse3", "ssse3", "sse4")
#ifdef LOCAL
#include <iostream>
#include <cmath>
#include <algorithm>
#include <stdio.h>
#include <cstdint>
#include <cstring>
#include <string>
#include <cstdlib>
#include <vector>
#include <bitset>
#include <map>
#include <queue>
#include <ctime>
#include <stack>
#include <set>
#include <list>
#include <random>
#include <deque>
#include <functional>
#include <iomanip>
#include <sstream>
#include <fstream>
#include <complex>
#include <numeric>
#include <cassert>
#include <array>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <thread>
#else
#include <bits/stdc++.h>
#endif

#define all(a) a.begin(),a.end()
#define len(a) (int)(a.size())
#define mp make_pair
#define pb push_back
#define fir first
#define sec second
#define fi first
#define se second

using namespace std;

typedef pair<int, int> pii;
typedef long long ll;
typedef long double ld;

template<typename T>
inline bool umin(T &a, T b) {
    if (b < a) {
        a = b;
        return true;
    }
    return false;
}

template<typename T>
inline bool umax(T &a, T b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}

#ifdef LOCAL
#define D for (bool _FLAG = true; _FLAG; _FLAG = false)
#define LOG(...) print(#__VA_ARGS__" ::", __VA_ARGS__) << endl
template <class ...Ts> auto &print(Ts ...ts) { return ((cerr << ts << " "), ...); }
#else
#define D while (false)
#define LOG(...)
#endif // LOCAL

const int max_n = 2e7 + 11, inf = 1000111222;


struct num {
    static const int MA = 1e9 + 7, MB = 1e9 + 9;

    int a, b;

    num() : a(0), b(0) { }
    num( int x ) : a(x), b(x) { }
    num( int a, int b ) : a(a), b(b) { }

    num operator + ( const num &x ) const { return num((a + x.a) % MA, (b + x.b) % MB); }
    num operator - ( const num &x ) const { return num((a + MA - x.a) % MA, (b + MB - x.b) % MB); }
    num operator * ( int x ) const { return num(((ll)a * x) % MA, ((ll)b * x) % MB); }
    num operator * ( const num &x ) const { return num(((ll)a * x.a) % MA, ((ll)b * x.b) % MB); }
    bool operator == ( const num &x ) const { return a == x.a && b == x.b; }
    bool operator != ( const num &x ) const { return !(a == x.a && b == x.b); }

};


struct node {
    int l, r, cnt;
    num h;
    node () : h(1), cnt(0), l(0), r(0) {}
};

node t[max_n] = {};
int all = 1;

inline int copy_past (int v) {
    t[all] = t[v];
    return all++;
}

inline void build (int v, int tl, int tr) {
    if (tl == tr) {
        return;
    }
    int tm = (tl + tr) >> 1;
    t[v].l = all++;
    build(t[v].l, tl, tm);
    t[v].r = all++;
    build(t[v].r, tm + 1, tr);
}

const int max_N = 1e6 + 11;

num h[max_N] = {};



inline void upd (int v, int tl, int tr, int pos, int x) {
    ++t[v].cnt;
    t[v].h = t[v].h * h[x];
    if (tl == tr) {
        return;
    }
    int tm = (tl + tr) >> 1;
    if (pos <= tm) {
        t[v].l = copy_past(t[v].l);
        upd(t[v].l, tl, tm, pos, x);
    }
    else {
        t[v].r = copy_past(t[v].r);
        upd(t[v].r, tm + 1, tr, pos, x);
    }
}

int n;


inline bool cmp (int v1, int v2, int tl, int tr) {
    LOG(tl, tr, t[v1].h.a, t[v2].h.a);
    if (tl == tr) {
        LOG(tr, t[v1].cnt, t[v2].cnt, v1, v2);
        return t[v1].cnt > t[v2].cnt;
    }
    int tm = (tl + tr) >> 1;
    if (t[t[v1].r].h == t[t[v2].r].h) {
        return cmp(t[v1].l, t[v2].l, tl, tm);
    }
    return cmp(t[v1].r, t[v2].r, tm + 1, tr);
}


struct min_st {
    int root;

    min_st(int x = -1) : root(x) {}


    bool operator < (const min_st &x) const {
        LOG(root, x.root);
        return cmp(root, x.root, 0, n - 1);
    }

    bool operator == (const min_st &x) const {
        return root == x.root;
    }

    inline void add (int x) {
        upd(root, 0, n - 1, x, x);
    }

    inline min_st copy () {
        return min_st(copy_past(root));
    }
};

struct min_queue {

    queue <min_st> q;
    deque <min_st> mn;

    inline void add (min_st x) {
        LOG("add");
        q.push(x);
        while (!mn.empty() && x < mn.back()) {
            LOG("here");
            mn.pop_back();
        }
        mn.pb(x);
    }

    inline void del () {
        if (mn.front() == q.front()) {
            mn.pop_front();
        }
        q.pop();
    }

    inline bool empty () {
        return q.empty();
    }

    inline min_st get_min () {
        return mn.front();
    }
};

mt19937 rng(228);
template<typename T = int>
inline T randll(T l = INT_MIN, T r = INT_MAX) {
    return uniform_int_distribution<T>(l, r)(rng);
}

inline ld randld(ld l = INT_MIN, ld r = INT_MAX) {
    return uniform_real_distribution<ld>(l, r)(rng);
}

vector <int> ans;

inline void go (int v, int tl, int tr) {
    if (tl == tr) {
        for (int i = 0; i < t[v].cnt; i++) {
            ans.pb(tr);
        }
        return;
    }
    int tm = (tl + tr) >> 1;
    go(t[v].l, tl, tm);
    go(t[v].r, tm + 1, tr);
}

inline void test_case () {
    ans.clear();
    while (all >= 0) {
        t[all].l = t[all].r = t[all].cnt = 0;
        t[all].h = 1;
        --all;
    }
    all = 1;
    int l, r;
    cin >> n >> l >> r;
    vector <int> x(n), a(n);
    for (auto &i : x) cin >> i;
    for (auto &i : a) {
        cin >> i;
        --i;
    }
    min_queue q;
    vector <min_st> b(n);
    b[0].root = 0;
    build(0, 0, n - 1);
    b[0].add(a[0]);
    for (int i = 1, j = 0, k = 0; i < n; i++) {
        LOG(i);
        while (x[i] - x[k] >= l) {
            if (b[k].root != -1) {
                q.add(b[k]);
            }
            ++k;
        }
        while (x[i] - x[j] > r) {
            if (b[j].root != -1) {
                q.del();
            }
            ++j;
        }
        if (!q.empty()) {
            LOG(q.get_min().root);
            b[i] = q.get_min().copy();
            LOG(i, b[i].root);
            b[i].add(a[i]);
        }
    }
    if (b[n - 1].root == -1) {
        cout << "-1\n";
        return;
    }
    go(b[n - 1].root, 0, n - 1);
//    sort(all(ans));
    reverse(all(ans));
    cout << len(ans) << '\n';
    for (auto &i : ans) {
        cout << i + 1 << ' ';
    }
    cout << '\n';
}

int main() {
//    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);

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

    for (int i = 0; i < max_N; i++) {
        h[i].a = randll(1, num::MA - 1);
        h[i].b = randll(1, num::MB - 1);
    }

    int t = 1;
    cin >> t;
    for (int test = 1; test <= t; test++) {
        test_case();
    }
}