#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< pair<int, int> > now;
    vector<int> to[2000], tmp;
    vector< vector< pair<int, 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, int lst) {
        now.push_back(make_pair(x, lst));
        tot.push_back(now);
        for (int i = 0; i < g[x].size(); ++i) dfs(g[x][i], i);
        now.pop_back();
    }

    void solve() {
        for (int x = 1; x <= n; ++x) {
            tot.clear(); dfs(x, 0); tot.push_back(now);
            for (int i = 0; i < tot.size(); ++i) to[i].clear();
            for (int i = 0; i < tot.size(); ++i) {
                if (tot[i].empty()) continue;
                for (int j = i + 1; j < tot.size(); ++j) {
                    if (tot[j].size() <= tot[i].size()) {
                        if (tot[j].empty()) {
                            to[i].push_back(j);
                            continue;
                        }
                        bool pd = true;
                        for (int ID = 0; ID + 1 < tot[j].size(); ++ID)
                            if (tot[j][ID] != tot[i][ID]) pd = false;
                        if (!pd) continue;
                        to[i].push_back(j);
                        if (c[tot[j][tot[j].size() - 2].first] == 0) break;
                    }
                    if (tot[j].size() == tot[i].size() + 1 && tot[j][tot[i].size() - 1] == tot[i].back()) {
                        to[i].push_back(j);
                        if (c[tot[i].back().first] == 0) 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());
                tmp.erase(unique(tmp.begin(), tmp.end()), 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");
    }
}

namespace subtask4 {
    int du[N], ans, sg[N];
    multiset<int> S, T;
    
    bool check() {
        for (int x = 1; x <= n; ++x)
            for (auto y : g[x]) du[y]++;
        for (int i = 1; i <= n; ++i)
            if (du[i] > 1) return false;
        for (auto x : vec) if (du[x]) return false;
        return true;
    }

    void ins(int x) {
        if (T.find(x) != T.end()) T.erase(T.find(x));
        else S.insert(x);
        while (S.find(ans) != S.end()) ans++;
    }

    void del(int x) {
        if (S.find(x) != S.end()) S.erase(S.find(x));
        else T.insert(x);
    }

    int work() {
        int res;
        if (T.empty()) res = ans;
        else res = min(ans, *T.begin());
        ins(res); return res;
    }

    void dfs(int x) {
        if (g[x].empty()) {
            sg[x] = work();
            return;
        }
        for (auto y : g[x]) dfs(y);
        sg[x] = work();
        for (auto y : g[x]) del(sg[y]);
    }
    
    void solve() {
        ins(0);
        for (int i = 1; i <= n; ++i) reverse(g[i].begin(), g[i].end());
        for (int i = 1; i <= n; ++i)
            if (du[i] == 0) S.clear(), T.clear(), ans = 0, dfs(i);
        int fin = 0;
        for (auto x : vec) fin ^= sg[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);

    // subtask4 :: solve(); exit(0);

    if (subtask1 :: check()) subtask1 :: solve();
    else if (subtask4 :: check()) subtask4 :: solve();
    else if (subtask2 :: check()) subtask2 :: solve();
    else if (subtask3 :: check()) subtask3 :: solve();
    return 0;
}