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

const int N=1e6+1e3+7;

int n,st[N],ed[N],dep[N],dc,rev[N];

vector<int> g[N];

int anc[N][21];

void dfs(int x,int f)
{
    st[x]=++dc;
    rev[dc]=x;
    anc[x][0]=f;
    for(int j=1;j<=20;j++)
        anc[x][j]=anc[anc[x][j-1]][j-1];
    for(auto v:g[x])
    {
        if(v==f)
            continue;
        dep[v]=dep[x]+1;
        dfs(v,x);
    }
    ed[x]=dc;
}

int lca(int x,int y)
{
    if(dep[x]<dep[y])
        swap(x,y);
    for(int i=20;i>=0;i--)
        if(dep[x]-(1<<i)>=dep[y])
            x=anc[x][i];
    if(x==y)
        return x;
    for(int i=20;i>=0;i--)
        if(anc[x][i]!=anc[y][i])
            x=anc[x][i],y=anc[y][i];
    return anc[x][0];
}
set<vector<int> >SQ;

int fup(int a,int b)
{
    for(int i=20;i>=0;i--)
        if(dep[a]-(1<<i)>dep[b])
            a=anc[a][i];
    return a;
}

namespace SOLVE {
  int m, i, a[N], q[N], t, tot;
  int pos[N];

  bool vip[N], vis[N];
  bool cmp(int x, int y) { return st[x] < st[y]; }
  vector<int> g[N];
  vector<int> h[N];
  int deg[N];
  void solve(vector<int> v,vector<int> seq) {
    // bool cok=0;
    // for(auto s:SQ)
    // {
    //     auto it=seq.begin();
    //     for(auto p:s)
    //     {
    //         if(it!=seq.end()&&*it==p)
    //             it++;
    //     }
    //     if(it==seq.end())
    //     {
    //         cok=1;
    //         break;
    //     }
    // }
    
    for(int i=0;i+1<seq.size();i++)
    {
        int x=seq[i],y=seq[i+1];
        if(dep[x]!=dep[y])
            continue;
        int z=lca(x,y);
        v.push_back(fup(x,z));
        v.push_back(fup(y,z));
    }
    int la=-1;
    bool ok=1;
    for(auto x:seq)
    {
        if(dep[x]<la)
            ok=0;
        la=dep[x];
    }
    if(!ok)
    {
        cout<<"No\n";
        return;
    }
    if (!v.size())
      return;
    vis[1] = vip[1] = a[1] = 1;
    m = v.size();
    for (tot = ++m, i = 2; i <= m; i++)
      a[i] = v.back(), v.pop_back(), vis[a[i]] = vip[a[i]] = 1;
    sort(a + 1, a + m + 1, cmp);
    int x;
    for (i = 1; i < m; i++)
      if (!vis[x = lca(a[i], a[i + 1])])
        vis[a[++tot] = x] = 1;
    vector<int> use;
    m = tot, sort(a + 1, a + m + 1, cmp);
    for (q[t = 1] = 1, i = 2; i <= m; q[++t] = a[i++]) {
      while (st[a[i]] < st[q[t]] || ed[a[i]] > ed[q[t]]) // dfs order
        t--;
      if (q[t] != a[i])
        g[q[t]].push_back(a[i]);
      use.push_back(q[t]);
      use.push_back(a[i]);
    }
    sort(use.begin(),use.end());
    use.erase(unique(use.begin(),use.end()),use.end());
    for(auto x:use)
        h[x].clear(),h[x+n].clear(),deg[x]=0,deg[x+n]=0;
    for(auto x:use)
    {
        h[x+n].push_back(x);
        ++deg[x];
        for(auto y:g[x])
        {
            h[y].push_back(x);
            ++deg[x];
            h[x+n].push_back(y+n);
            ++deg[y+n];
        }
    }
    for(int i=0;i+1<seq.size();i++)
    {
        int x=seq[i],y=seq[i+1];
        if(dep[x]!=dep[y])
            continue;
        int z=lca(x,y);
        x=fup(x,z),y=fup(y,z);
        h[x].push_back(y+n);
        ++deg[y+n];
    }
    for(int i=0;i<seq.size();i++)
        pos[seq[i]]=0;
    queue<int> q;
    for(auto x:use)
    {
        if(!deg[x])
            q.push(x);
        if(!deg[x+n])
            q.push(x+n);
    }
    int cnt=0;
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        ++cnt;
        for(auto v:h[x])
            if(!--deg[v])
                q.push(v);
    }
    ok&=cnt==use.size()*2;
    // if(ok!=cok)
    // {
    //     cerr<<"ALERT"<<endl;
    //     exit(0);
    // }
    if(ok)
        cout<<"Yes\n";
    else
        cout<<"No\n";
    for (auto x : use)
      vis[x] = vip[x] = 0, g[x].clear();
    return;
  }
} // namespace SOLVE

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin>>n;
    for(int i=2;i<=n;i++)
    {
        int f;
        cin>>f;
        // f=rand()%(i-1)+1;
        g[f].push_back(i);
    }
    // vector<int> p(n);
    // iota(p.begin(),p.end(),0);
    // do {
    //     vector<int> s;
    //     queue<int> Q;
    //     Q.push(1);
    //     while(!Q.empty())
    //     {
    //         int x=Q.front();
    //         s.push_back(x);
    //         Q.pop();
    //         sort(g[x].begin(),g[x].end(),[&](const int &a,const int &b){return p[a-1]<p[b-1];});
    //         for(auto y:g[x])
    //             Q.push(y);
    //     }
    //     SQ.insert(s);
    // }while(next_permutation(p.begin(),p.end()));
    dfs(1,0);
    int m;
    cin>>m;
    while(m--)
    {
        int k;
        // k=rand()%n+1;
        cin>>k;
        vector<int> s;
        while(k--)
        {
            int x;
            cin>>x;
            // x=rand()%n+1;
            s.push_back(x);
        }
        SOLVE::solve(s,s);
    }
}