#include <bits/stdc++.h>
using ull = unsigned long long;

ull f(ull x) { return std::hash<std::bitset<64>>()(x); }
ull hash_tree(const std::vector<std::vector<int>> &son, int root, ull adt = 0) {
  auto dfs = [&](auto &self, int u) -> ull {
    ull ret = 1 + adt;
    for (auto v : son[u]) ret += f(self(self, v));
    return ret;
  };
  return dfs(dfs, root);
}

auto adjust(std::vector<std::vector<int>> &son) {
  int n = son.size() - 1;
  std::vector<int> siz(n + 1);
  auto dfs = [&](auto &self, int u) -> void {
    siz[u] = 1;
    for (int v : son[u]) self(self, v), siz[u] += siz[v];
    std::sort(son[u].begin(), son[u].end(),
              [&](auto x, auto y) { return siz[x] < siz[y]; });
  };
  dfs(dfs, 1);
  return siz;
}
std::vector<int> gen(const std::vector<std::vector<int>> &son,
                     std::vector<int> root) {
  int n = son.size() - 1;
  std::vector<int> id(n + 1);
  id[0] = 1;
  std::vector<int> ret{-1, 0};
  auto dfs = [&](auto &self, int u, int ff) -> void {
    id[u] = ret.size(), ret.push_back(id[ff]);
    for (auto v : son[u]) self(self, v, u);
  };
  for (int v : root) dfs(dfs, v, 0);
  ret[0] = ret.size() - 1;
  return ret;
}

void mian() {
  int na, nb, nc;
  std::cin >> na >> nb >> nc;
  std::vector<std::vector<int>> sa(na + 1), sb(nb + 1), sc(nc + 1);
  for (int i = 1, p; i <= na; i++) std::cin >> p, sa[p].push_back(i);
  for (int i = 1, p; i <= nb; i++) std::cin >> p, sb[p].push_back(i);
  for (int i = 1, p; i <= nc; i++) std::cin >> p, sc[p].push_back(i);
  auto solve =
      [&]() -> std::optional<std::pair<std::vector<int>, std::vector<int>>> {
    auto size_a = adjust(sa), size_c = adjust(sc);
    if (size_c[sc[1].back()] % size_a[sa[1].back()]) return std::nullopt;
    int size_x = size_c[sc[1].back()] / size_a[sa[1].back()] - 1;
    if ((nc + 1 - na * (size_x + 1)) % nb) return std::nullopt;
    int size_y = (nc + 1 - na * (size_x + 1)) / nb - 1;
    ull hx = 0, hy = 0;
    std::vector<int> retx, rety;
    std::multiset<ull> s;
    if (size_x) {
      for (int t = size_x; int v : sc[sc[1].back()]) {
        t -= size_c[v], hx += f(hash_tree(sc, v)), retx.push_back(v);
        s.insert(hash_tree(sc, v));
        if (t < 0) return std::nullopt;
        if (t == 0) break;
      }
    }
    for (int v : sa[1]) s.insert(hash_tree(sa, v, hx));
    if (size_y) {
      for (int t = size_y; int v : sc[1]) {
        auto h = hash_tree(sc, v);
        if (s.count(h)) {
          s.erase(s.find(h));
          continue;
        }
        t -= size_c[v], hy += f(hash_tree(sc, v)), rety.push_back(v);
        if (t < 0) return std::nullopt;
        if (t == 0) break;
      }
    }
    if (hash_tree(sc, 1) != hash_tree(sa, 1, hx) + hash_tree(sb, 1, hy) - 1)
      return std::nullopt;
    return std::make_pair(retx, rety);
  };
  auto ret = solve();
  if (!ret) {
    std::swap(na, nb), std::swap(sa, sb);
    ret = solve();
    if (ret.has_value()) std::swap(ret.value().first, ret.value().second);
  }
  if (!ret)
    std::cout << "Impossible\n";
  else {
    auto va = gen(sc, ret.value().first), vb = gen(sc, ret.value().second);
    std::cout << va[0] << ' ' << vb[0] << '\n';
    va.erase(va.begin()), vb.erase(vb.begin());
    for (auto i : va) std::cout << i << ' ';
    std::cout << '\n';
    for (auto i : vb) std::cout << i << ' ';
    std::cout << '\n';
  }
}

int main() {
  std::cin.tie(0)->sync_with_stdio(0);
  int t;
  std::cin >> t;
  while (t--) mian();
}