#include <cstdio>
#include <chrono>
#include <vector>
#include <algorithm>
#include <functional>
#include <unordered_map>

#define ull unsigned long long

using namespace std;

const int N = 100005;
const int mask = chrono::steady_clock::now().time_since_epoch().count();

ull shift(ull x)
{
    x ^= mask;
    x ^= x << 13;
    x ^= x >> 7;
    x ^= x << 17;
    x ^= mask;
    return x;
}

struct Tree
{
    ull f[N];
    int n, Max, dep[N], siz[N];
    
    vector <int> e[N];

    void Hash(int u, ull x)
    {
        f[u] = x;
        for(int v : e[u])
            Hash(v, x), f[u] += shift(f[v]);
    }

    void Input()
    {
        Max = 0;
        for(int i = 1; i <= n; ++ i)
            e[i].clear();
        for(int i = 1, x; i <= n; ++ i)
        {
            scanf("%d", &x);
            if(x)
                e[x].push_back(i);
        }
    }

    void Init(int u, int fa)
    {
        siz[u] = 1;
        dep[u] = dep[fa] + 1;
        Max = max(Max, dep[u]);
        for(int v : e[u])
            Init(v, u), siz[u] += siz[v];
    }

    int cnt = 0;
    void Print(int u, int fa)
    {
        printf("%d ", fa);
        int id = ++ cnt;
        for(int v : e[u])
            Print(v, id);
    }
};
Tree A, B, C;

unordered_map <ull, int> vis[2];
vector < pair <ull, int> > val[2];

void work()
{
    vis[0].clear();
    vis[1].clear();
    val[0].clear();
    val[1].clear();

    scanf("%d%d%d", &A.n, &B.n, &C.n);
    A.Input(), A.Init(1, 0);
    B.Input(), B.Init(1, 0);
    C.Input(), C.Init(1, 0);

    C.Hash(1, 1);
    for(int i = 1; i <= C.n; ++ i)
    {
        if(C.dep[i] == A.Max && !vis[0][C.f[i]])
        {
            vis[0][C.f[i]] = 1;
            A.Hash(1, C.f[i]);
            val[0].push_back({A.f[1], i});
        }
        if(C.dep[i] == B.Max && !vis[1][C.f[i]])
        {
            vis[1][C.f[i]] = 1;
            B.Hash(1, C.f[i]);
            val[1].push_back({C.f[1] + 1 - B.f[1], i});
        }
    }

    sort(val[0].begin(), val[0].end());
    sort(val[1].begin(), val[1].end());

    for(int i = 0, j = 0; i < val[0].size(); ++ i)
    {
        while(j < val[1].size() && val[0][i].first > val[1][j].first)
            ++ j;
        if(j < val[1].size() && val[0][i].first == val[1][j].first)
        {
            int u = val[0][i].second, v = val[1][j].second;
            printf("%d %d\n", C.siz[u], C.siz[v]);
            C.Print(u, C.cnt = 0), printf("\n");
            C.Print(v, C.cnt = 0), printf("\n");
            return;
        }
    }
    printf("Impossible\n");
}

int T;

int main()
{
    scanf("%d", &T);
    while(T --)
        work();

    return 0;
}