#include <bits/stdc++.h>
using namespace std;
#define int long long
const int maxN = 1e5 + 10;
const int mod = 1e9 + 7;
int isPrime[maxN], primes[maxN];
void init(int n) {
    for (int i = 1; i <= n; i++) {
        isPrime[i] = true;
    }
    primes[0] = 0;
    for (int i = 2; i <= n; i++) {
        if (isPrime[i]) {
            primes[++primes[0]] = i;
        }
        for (int j = 1; j <= primes[0] && primes[j] * i <= n; j++) {
            isPrime[i * primes[j]] = false;
            if (i % primes[j] == 0)
                break;
        }
    }
}

struct Tree {
    vector<int> edges[maxN];
    int n, rt, ttmp;
    void read() {
        cin >> n;
        for (int i = 1; i <= n; i++)
            edges[i].clear();
        for (int i = 1; i <= n; i++) {
            cin >> ttmp;
            // cout << ttmp << '\n';
            if (ttmp == -1) {
                // cout << "Rt: " << i << "\n";
                rt = i;
            } else {
                // cout << ttmp << " " << i << "\n";
                edges[ttmp].push_back(i);
            }
        }
    }
    int size[maxN], myHash[maxN];
    void hashHandler(int u) {
        myHash[u] = size[u] = 1;
        for (int i : edges[u]) {
            hashHandler(i);
            size[u] += size[i];
            myHash[u] += (primes[size[i]] * myHash[i]) % mod;
            myHash[u] %= mod;
        }
    }
} g, h;
set<pair<int, int>> mp;
int dfs(int u1, int u2, int limit) {
    if (u2 == -1)
        return g.size[u1] > limit ? 114514 : g.size[u1];
    if (g.size[u1] - h.size[u2] > limit)
        return 114514;
    if (h.size[u2] == 1)
        return g.size[u1] - 1;
    for (auto son1 : g.edges[u1]) {
        mp.insert({g.myHash[son1], son1});
    }
    vector<int> G, H;
    for (auto son2 : h.edges[u2]) {
        set<pair<int, int>>::iterator it = mp.lower_bound({h.myHash[son2], 0});
        if (it == mp.end() || it->first != h.myHash[son2]) {
            H.push_back(son2);
        } else {
            mp.erase(it);
        }
    }
    for (auto node : mp) {
        G.push_back(node.second);
    }
    if (G.size() < H.size() || (int)G.size() > limit)
        return 114514;
    int diff = G.size() - H.size();
    for (int i = 1; i <= diff; i++) {
        H.push_back(-1);
    }
    sort(G.begin(), G.end());
    int ans = 114514;
    do {
        int tmp = 0;
        for (int i = 0; i < (int)G.size(); i++) {
            tmp += dfs(G[i], H[i], limit);
        }
        ans = min(ans, tmp);
    } while (next_permutation(G.begin(), G.end()));
    return ans;
}
signed main() {
    init(maxN);
    int c, t, k;
    cin >> c >> t >> k;
    while (t-- > 0) {
        mp.clear();
        g.read();
        h.read();
        // cout << "Read.\n";
        g.hashHandler(g.rt);
        h.hashHandler(h.rt);
        // cout << "Hashed.\n";
        int ans = dfs(g.rt, h.rt, k);
        ////cout << "Ans == " << k << "\n";
        cout << (ans <= k ? "Yes\n" : "No\n");
    }
}