import sys
input = sys.stdin.readline

T = int(input())
for _ in range(T):
    n, m, k, w = map(int, input().split())
    red = list(map(int, input().split()))
    black = list(map(int, input().split()))

    red.sort()
    black.sort()

    # Add boundary black cells
    black_cells = [0] + black + [w+1]

    intervals = []
    r_idx = 0
    possible = True

    # Process each gap formed by black cells
    for i in range(len(black_cells)-1):
        G_start = black_cells[i] + 1
        G_end = black_cells[i+1] - 1
        if G_start > G_end:
            continue

        # In this gap, cover all red cells that fall inside
        # Reset last_end for each gap
        last_end = G_start - 1

        # Move r_idx to first red cell in this gap (if any)
        while r_idx < n and red[r_idx] < G_start:
            r_idx += 1

        while r_idx < n and red[r_idx] <= G_end:
            R = red[r_idx]
            # Compute intersection:
            L = max(G_start, R - k + 1, last_end + 1)
            U = min(R, G_end - k + 1)
            if L > U:
                possible = False
                break

            # Choose X = U (far right feasible)
            X = U
            # Place interval [X..X+k-1]
            intervals.append(X)
            new_end = X + k - 1
            last_end = new_end

            # Cover all red cells up to new_end
            while r_idx < n and red[r_idx] <= new_end:
                r_idx += 1

        if not possible:
            break

    if not possible or r_idx < n:
        print(-1)
    else:
        print(len(intervals))
        if intervals:
            print(" ".join(map(str, intervals)))
        else:
            # No intervals needed (if n=0, though problem states n>=1 so likely never occurs)
            print()