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

struct LCA {
    const int N;
    int n, idx;
    vector<int> id, rid, dep, fa;
    vector<vector<int>> e, st;

    LCA(int n) : N(__lg(n) + 1), n(n), idx(0), id(n, -1), rid(n), dep(n), fa(n), e(n), st(N, vector<int>(n)) {}

    void add(int u, int v) {
        e[u].push_back(v);
        e[v].push_back(u);
    }

    int getMin(int x, int y) {
        return dep[x] < dep[y] ? x : y;
    }

    void dfs(int u) {
        id[u] = idx;
        rid[idx] = u;
        idx++;

        for (int v : e[u]) {
            if (id[v] != -1) {
                continue;
            }

            dep[v] = dep[u] + 1;
            fa[v] = u;
            dfs(v);
        }
    }

    void work(int rt = 0) {
        dep[rt] = 1;
        dfs(rt);

        for (int i = 0; i < n; ++i) {
            st[0][i] = rid[i];
        }

        for (int i = 1; i < N; ++i) {
            for (int j = 0; j + (1 << i) - 1 < n; ++j) {
                st[i][j] = getMin(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
            }
        }
    }

    int getLca(int x, int y) {
        if (x == y) {
            return x;
        }
        x = id[x], y = id[y];
        if (x > y) {
            swap(x, y);
        }
        ++x;
        int z = __lg(y - x + 1);
        return fa[getMin(st[z][x], st[z][y - (1 << z) + 1])];
    }
};


int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin >> n;
    LCA lca(n);
    vector<vector<int>> e(n);
    for (int i = 1; i < n; ++i) {
        int f;
        cin >> f;
        --f;
        lca.add(f, i);
        e[f].push_back(i);
    }
    lca.work();

    vector<int> dep(n, -1);
    vector<int> dfn(n);
    int tot = 0;
    auto dfs = [&](auto &&self, int u) -> void {
        dfn[u] = tot++;
        for (int v : e[u]) {
            dep[v] = dep[u] + 1;
            self(self, v);
        }
    };

    dep[0] = 0;
    dfs(dfs, 0);

    int q;
    cin >> q;

    vector<vector<int>> ee(n);
    vector<int> d(n);

    auto solve = [&]() {
        int m;
        cin >> m;

        vector<int> a(m);
        vector<int> c(m);
        for (int i = 0; i < m; ++i) {
            cin >> a[i];
            --a[i];
            c[i] = a[i];
            if (i) {
                ee[a[i - 1]].push_back(a[i]);
                d[a[i]]++;
            }
        }

        for (int i = 1; i < m; ++i) {
            if (dep[a[i]] < dep[a[i - 1]]) {
                for (auto x : c) {
                    ee[x].clear();
                    d[x] = 0;
                }
                cout << "No\n";
                return;
            }
        }


        for (int i = 0; i < m;) {
            int j = i;
            while (j < m && dep[a[j]] == dep[a[i]]) {
                ++j;
            }

            for (int k = i; k < j - 1; ++k) {
                int l = lca.getLca(a[k], a[k + 1]);

                int t1 = *prev(upper_bound(e[l].begin(), e[l].end(), a[k], [&](int x, int y) {
                    return dfn[x] < dfn[y];
                }));
                int t2 = *prev(upper_bound(e[l].begin(), e[l].end(), a[k + 1], [&](int x, int y) {
                    return dfn[x] < dfn[y];
                }));

                assert(t1 != t2);
                ee[t1].push_back(t2);
                d[t2]++;
                c.push_back(t1);
                c.push_back(t2);
            }
            i = j;
        } 

        sort(c.begin(), c.end());
        c.erase(unique(c.begin(), c.end()), c.end());

        queue<int> q;
        for (auto x : c) {
            if (d[x] == 0) {
                q.push(x);
            }
        }
        int cnt = 0;

        while (q.size()) {
            int u = q.front();
            q.pop();
            ++cnt;
            for (int v : ee[u]) {
                --d[v];

                if (d[v] == 0) {
                    q.push(v);
                }
            }
        }

        for (auto x : c) {
            ee[x].clear();
            d[x] = 0;
        }

        if (cnt != c.size()) {
            cout << "No\n";
        } else {
            cout << "Yes\n";
        }
    };

    while (q--) {
        solve();
    }
    return 0;
}