#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 3;

inline int read() {
    char ch = getchar(); int x = 0;
    while (!isdigit(ch)) {ch = getchar();}
    while (isdigit(ch)) {x = x * 10 + ch - 48; ch = getchar();}
    return x;
}

int n, c[N];
vector<int> g[N], vec;

namespace subtask1 {
    bool dp[N], ans;
    
    bool check() {
        for (int i = 1; i <= n; ++i)
            if (c[i] == 1) return false;
        return true;
    }

    void solve() {
        for (int x = n; x >= 1; --x) {
            dp[x] = 1;
            for (auto y : g[x]) dp[x] ^= dp[y];
        }
        for (auto r : vec) ans ^= dp[r];
        puts(ans ? "Alice" : "Bob");
    }
}

namespace subtask2 {
    int dp[N];

    bool check() {return vec.size() == 1;}

    void solve() {
        for (int x = n; x >= 1; --x) {
            if (g[x].empty()) dp[x] = 1;
            else {
                int val = 1;
                for (auto y : g[x]) {
                    if (val == 0) {
                        if (dp[y] == 0) val = 0;
                        else if (dp[y] == 1) val = 1;
                        else {
                            val = dp[y];
                            break;
                        }
                    }else {
                        if (dp[y] == 0) val = 1;
                        else if (dp[y] == 1) val = 0;
                        else {
                            val = dp[y] ^ 1;
                            break;
                        }
                    }
                }
                if (c[x] == 0) dp[x] = val;
                else {
                    if (val == 3) dp[x] = 1;
                    else if (val == 0) dp[x] = 2;
                    else dp[x] = val;
                }
            }
        }
        puts((dp[vec[0]] == 1 || dp[vec[0]] == 2) ? "Alice" : "Bob");
    }
}

namespace subtask3 {
    int cnt, val[N], sg[2000];
    vector<int> now, to[2000], tmp;
    vector< vector<int> > tot;
    
    bool check() {
        int m = 0;
        for (int x = 1; x <= n; ++x) m += g[x].size();
        return (n <= 10 && m <= 10);
    }

    void dfs(int x) {
        now.push_back(x);
        tot.push_back(now);
        for (auto y : g[x]) dfs(y);
        now.pop_back();
    }

    void solve() {
        for (int x = 1; x <= n; ++x) {
            tot.clear(); dfs(x); tot.push_back(now);
            for (int i = 0; i < tot.size(); ++i) to[i].clear();
            for (int i = 0; i + 1 < tot.size(); ++i) to[i].push_back(i + 1);
            for (int i = 0; i < tot.size(); ++i) {
                if (tot[i].empty() || c[tot[i].back()] == 0) continue;
                for (int j = i + 1; j < tot.size(); ++j)
                    if (tot[j].size() < tot[i].size() || tot[j][tot[i].size() - 1] != tot[i].back()) {to[i].push_back(j); break;}
            }
            for (int i = tot.size() - 1; i >= 0; --i) {
                tmp.clear();
                for (auto j : to[i]) tmp.push_back(sg[j]);
                sort(tmp.begin(), tmp.end());
                int ans = 0;
                while (ans < tmp.size() && ans == tmp[ans]) ans++;
                sg[i] = ans;
            }
            val[x] = sg[0];
        }
        int fin = 0;
        for (auto x : vec) fin ^= val[x];
        puts(fin ? "Alice" : "Bob");
    }
}

int main() {
    n = read();
    for (int i = 1; i <= n; ++i) c[i] = read();
    for (int x = 1, m, y; x <= n; ++x) {
        m = read();
        while (m--) {
            y = read();
            g[x].push_back(y);
        }
    }
    int k = read(), x;
    while (k--) x = read(), vec.push_back(x);
    if (subtask1 :: check()) subtask1 :: solve();
    else if (subtask2 :: check()) subtask2 :: solve();
    else if (subtask3 :: check()) subtask3 :: solve();
}