#include<bits/stdc++.h>
using namespace std;

const int N = 1e6 + 9, P = 1e6 + 3, mod = 1e9 + 9;

struct PST {
  #define lc t[cur].l
  #define rc t[cur].r
  struct node {
    int l = 0, r = 0, val = 0, cnt = 0;
  } t[24 * N];
  int T = 0;
  int build(int b, int e) {
    int cur = ++T;
    t[cur].l = t[cur].r = t[cur].val = t[cur].cnt = 0;
    if(b == e) return cur;
    int mid = b + e >> 1;
    lc = build(b, mid);
    rc = build(mid + 1, e);
    t[cur].val = (t[lc].val + t[rc].val) % mod;
    t[cur].cnt = t[lc].cnt + t[rc].cnt;
    return cur;
  }
  int upd(int pre, int b, int e, int i, int v) {
    int cur = ++T;
    t[cur] = t[pre];
    if(b == e) {
      (t[cur].val += v) %= mod;
      t[cur].cnt += 1;
      return cur;
    }
    int mid = b + e >> 1;
    if(i <= mid) {
      rc = t[pre].r;
      lc = upd(t[pre].l, b, mid, i, v);
    } else {
      lc = t[pre].l;
      rc = upd(t[pre].r, mid + 1, e, i, v);
    }
    t[cur].val = (t[lc].val + t[rc].val) % mod;
    t[cur].cnt = t[lc].cnt + t[rc].cnt;
    return cur;
  }
  bool query(int pre, int cur, int b, int e) {
    if(b == e) return t[pre].cnt < t[cur].cnt;
    int mid = b + e >> 1;
    if(t[rc].val == t[t[pre].r].val) return query(t[pre].l, lc, b, mid);
    return query(t[pre].r, rc, mid + 1, e);
  }
  vector<int> v;
  void gen_values(int cur, int b, int e) {
    if (b == e) {
      while (t[cur].cnt) {
        v.push_back(b);
        t[cur].cnt--;
      }
      return;
    }
    int mid = (b + e) >> 1;
    gen_values(rc, mid + 1, e);
    gen_values(lc, b, mid);
  }
} t;
int n;
int dp[N]; // stores the root of the sequence in segment tree
bool cmp(int i, int j) {
  return t.query(dp[i], dp[j], 1, n);
}
int a[N], x[N], pw[N];
bool can[N];
int32_t main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  pw[0] = 1;
  for (int i = 1; i < N; i++) {
    pw[i] = 1LL * pw[i - 1] * P % mod;
  }
  int tc; cin >> tc;
  while (tc--) {
    int l, r; cin >> n >> l >> r;
    for (int i = 1; i <= n; i++) {
      cin >> x[i];
    }
    for (int i = 1; i <= n; i++) {
      cin >> a[i];
      can[i] = true;
    }
    deque<int> dq;
    t.T = 0;
    dp[1] = t.build(1, n);
    dp[1] = t.upd(dp[1], 1, n, a[1], pw[a[1]]);
    auto add = [&](int i) {
      if (!can[i]) return;
      while (!dq.empty() and cmp(dq.back(), i)) {
        dq.pop_back();
      }
      dq.push_back(i);
    };
    auto rem = [&](int i) {
      while (!dq.empty() and dq.front() <= i) {
        dq.pop_front();
      }
    };
    auto get = [&]() {
      if (dq.empty()) return -1;
      return dq.front();
    };
    int lid = 1, rid = 0;
    for (int i = 2; i <= n; i++) {
      while (rid + 1 < i and x[rid + 1] <= x[i] - l) {
        add(++rid);
      }
      while (lid < i and x[lid] < x[i] - r) {
        rem(lid++);
      }
      int mx = get();
      if (mx != -1) {
        dp[i] = t.upd(dp[mx], 1, n, a[i], pw[a[i]]);
      }
      else {
        can[i] = false;
      }
    }
    if (!can[n]) {
      cout << -1 << '\n';
    }
    else {
      t.v.clear();
      t.gen_values(dp[n], 1, n);
      cout << t.v.size() << '\n';
      for (auto x: t.v) {
        cout << x << ' ';
      }
      cout << '\n';
    }
  }
  return 0;
}