#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
template <class T> using rbtree = __gnu_pbds::tree<
  T,
  __gnu_pbds::null_type,
  std::less<T>,
  __gnu_pbds::rb_tree_tag,
  __gnu_pbds::tree_order_statistics_node_update
>;


int N;
vector<int> C;
vector<int> deg;
vector<vector<int>> graph;
int K;
vector<int> R;


namespace brute {
// state: just determined to call dfs(stack.back().first)
map<vector<pair<int, int>>, int> cache;
int calc(const vector<pair<int, int>> &stack) {
  auto it = cache.find(stack);
  if (it != cache.end()) return it->second;
  
  set<int> app;
  for (auto ujs = stack; ; ujs.pop_back()) {
    if (ujs.empty()) {
      app.insert(0);
      goto done;
    }
    const int u = ujs.back().first;
    for (int &j = ujs.back().second; ++j < deg[u]; ) {
      auto vjs = ujs;
      vjs.emplace_back(graph[u][j], -1);
      app.insert(calc(vjs));
      if (!C[u]) {
        goto done;
      }
    }
  }
 done:{}
  int ret;
  for (ret = 0; app.count(ret); ++ret) {}
#ifdef LOCAL
cerr<<"calc "<<stack<<" = "<<ret<<endl;
#endif
  
  return cache[stack] = ret;
}
int run() {
  cache.clear();
  int ans = 0;
  for (const int r : R) {
    ans ^= calc({make_pair(r, -1)});
  }
  return ans;
}
}  // brute


namespace fast {
// dp[u][p]: now at u,  p = {transition with returning} \subseteq {0, 1}
int dp[200'010][1 << 2];
int run() {
  vector<int> fs(N), gs(N);
  for (int u = N; --u >= 0; ) {
    for (int p = 0; p < 1 << 2; ++p) {
      if (C[u] || !deg[u]) {
        int q = p;
        rbtree<int> unapp;
        for (int x = 2; x <= deg[u] + 2; ++x) {
          unapp.insert(x);
        }
        for (int j = deg[u]; --j >= 0; ) {
          const int v = graph[u][j];
          const int g = dp[v][q];
          if (g < 2) {
            q |= 1 << g;
          } else {
            // (g-2)-th excludant
            auto it = unapp.find_by_order(q);
            if (it != unapp.end()) {
              unapp.erase(it);
            }
          }
        }
        dp[u][p] = (!(q & 1 << 0)) ? 0 : (!(q & 1 << 1)) ? 1 : *unapp.begin();
      } else {
        int q = p;
        for (int j = deg[u]; --j >= 0; ) {
          const int v = graph[u][j];
          const int g = dp[v][q];
          q = (g < 2) ? (1 << g) : 0;
        }
        dp[u][p] = (!(q & 1 << 0)) ? 0 : (!(q & 1 << 1)) ? 1 : -1;
      }
    }
// cerr<<"dp["<<u<<"] = ";pv(dp[u],dp[u]+4);
  }
  int ans = 0;
  for (const int r : R) {
    ans ^= (C[r] || !deg[r]) ? dp[r][1 << 0] : dp[r][0];
  }
  return ans;
}
}  // sub5


int main() {
  for (; ~scanf("%d", &N); ) {
    C.resize(N);
    for (int u = 0; u < N; ++u) {
      scanf("%d", &C[u]);
    }
    deg.resize(N);
    graph.resize(N);
    for (int u = 0; u < N; ++u) {
      scanf("%d", &deg[u]);
      graph[u].resize(deg[u]);
      for (int j = 0; j < deg[u]; ++j) {
        scanf("%d", &graph[u][j]);
        --graph[u][j];
      }
    }
    scanf("%d", &K);
    R.resize(K);
    for (int k = 0; k < K; ++k) {
      scanf("%d", &R[k]);
      --R[k];
    }
    
    const int ans = fast::run();
    puts(ans ? "Alice" : "Bob");
#ifdef LOCAL
const int brt=brute::run();
assert(brt==ans);
cerr<<"========"<<endl;
#endif
  }
  return 0;
}