#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;
    set<int> T;
    
    bool check() {
        for (int x = 1; x <= n; ++x)
            if (c[x] != 1) return false;
        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(x);
        S.insert(x);
        while (S.find(ans) != S.end()) ans++;
    }

    void del(int x) {
        S.erase(S.find(x));
        if (S.find(x) == S.end()) 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) {
        for (auto y : g[x]) dfs(y);
        sg[x] = work();
        for (auto y : g[x]) del(sg[y]);
    }
    
    void solve() {
        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, ins(0), dfs(i);
        int fin = 0;
        for (auto x : vec) fin ^= sg[x];
        puts(fin ? "Alice" : "Bob");
    }
}

namespace subtask5 {
    struct BIT {
        int tree[N]; vector<int> mem;

        inline int lowbit(int x) {return x & -x;}
        inline void add(int p) {
            for (int i = p; i <= n; i += lowbit(i))
                tree[i]++, mem.push_back(i);
        }
        inline int get(int p) {
            int res = 0;
            for (int i = p; i; i -= lowbit(i))
                res += tree[i];
            return res;
        }
        inline void clear() {
            for (auto i : mem) tree[i] = 0;
            mem.clear();
        }
        inline void update(int k) {
            int pos = 0, sum = 0;
            for (int i = 17; i >= 0; --i) {
                if (pos + (1 << i) > n) continue;
                if (pos + (1 << i) - sum - tree[pos + (1 << i)] >= k) continue;
                pos += (1 << i);
                sum += tree[pos];
            }
            return add(pos + 1), void();
        }
        inline int get_mex() {
            int pos = 0, sum = 0;
            for (int i = 17; i >= 0; --i) {
                if (pos + (1 << i) > n) continue;
                if (pos + (1 << i) > sum + tree[pos + (1 << i)]) continue;
                pos += (1 << i);
                sum += tree[pos];
            }
            return pos + 1;
        }
    }t;
    int dp[N];

    bool check() {
        for (int i = 1; i <= n; ++i)
            if (c[i] == 0) return false;
        return true;
    }

    void solve() {
        for (int i = 1; i <= n; ++i) reverse(g[i].begin(), g[i].end());
        for (int x = n; x >= 1; --x) {
            t.clear();
            for (auto y : g[x]) t.update(dp[y]);
            dp[x] = t.get_mex();
        }
        int fin = 0;
        for (auto x : vec) fin ^= dp[x];
        puts(fin ? "Alice" : "Bob");
    }
}

namespace subtask6 {
    struct BIT {
        int tree[N]; vector<int> mem;

        inline int lowbit(int x) {return x & -x;}
        inline void add(int p, int val = 1) {
            for (int i = p; i <= n; i += lowbit(i))
                tree[i] += val, mem.push_back(i);
        }
        inline int get(int p) {
            int res = 0;
            for (int i = p; i; i -= lowbit(i))
                res += tree[i];
            return res;
        }
        inline void clear() {
            for (auto i : mem) tree[i] = 0;
            mem.clear();
        }
        inline void update(int k) {
            int pos = 0, sum = 0;
            for (int i = 17; i >= 0; --i) {
                if (pos + (1 << i) > n) continue;
                if (pos + (1 << i) - sum - tree[pos + (1 << i)] >= k) continue;
                pos += (1 << i);
                sum += tree[pos];
            }
            return add(pos + 1), void();
        }
        inline int query(int k) {
            int pos = 0, sum = 0;
            for (int i = 17; i >= 0; --i) {
                if (pos + (1 << i) > n) continue;
                if (pos + (1 << i) - sum - tree[pos + (1 << i)] >= k) continue;
                pos += (1 << i);
                sum += tree[pos];
            }
            return pos + 1;
        }
        inline int get_mex() {
            int pos = 0, sum = 0;
            for (int i = 17; i >= 0; --i) {
                if (pos + (1 << i) > n) continue;
                if (pos + (1 << i) > sum + tree[pos + (1 << i)]) continue;
                pos += (1 << i);
                sum += tree[pos];
            }
            return pos + 1;
        }
    }t;
    int dp[N][4];

    void solve() {
        for (int x = 1; x <= n; ++x) {
            if (g[x].empty()) c[x] = 1;
            reverse(g[x].begin(), g[x].end());
        }
        for (int x = n; x >= 1; --x) {
            for (int S = 0; S < 4; ++S) {
                if (c[x] == 0) {
                    int T = S;
                    for (auto y : g[x]) {
                        T = dp[y][T];
                        if (T < 2) T = (1 << T);
                        else T = 0;
                    }
                    if (T & 1) {
                        dp[x][S]++;
                        if (T & 1) dp[x][S]++;
                    }
                }else {
                    int T = S; t.clear();
                    for (auto y : g[x]) {
                        int tmp = t.query(dp[y][T] + 1) - 1;
                        if (tmp < 2) T |= (1 << tmp);
                        else t.add(tmp + 1, 1);
                    }
                    if (T & 1) t.add(1, 1);
                    if (T & 2) t.add(2, 1);
                    dp[x][S] = t.get_mex() - 1;
                }
            }
        }
        int fin = 0;
        for (auto x : vec) fin ^= dp[x][1];
        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);

    return subtask6 :: solve(), 0;

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