#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 sub5 {
int run() {
  // dp[u]-th (0-based) mex of {transition with returning}
  vector<int> dp(N);
  for (int u = N; --u >= 0; ) {
    rbtree<int> unapp;
    for (int x = 0; x <= deg[u]; ++x) {
      unapp.insert(x);
    }
    for (int j = deg[u]; --j >= 0; ) {
      const int v = graph[u][j];
      auto it = unapp.find_by_order(dp[v]);
      if (it != unapp.end()) {
        unapp.erase(it);
      }
    }
    dp[u] = *unapp.find_by_order(0);
  }
// cerr<<"dp = "<<dp<<endl;
  int ans = 0;
  for (const int r : R) {
    ans ^= (1 + dp[r]);
  }
  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];
    }
    
    int ans = -1;
    if (C == vector<int>(N, 1)) {
cerr<<"sub5"<<endl;
      ans = sub5::run();
#ifdef LOCAL
const int brt=brute::run();
assert(brt==ans);
#endif
    } else {
      ans = brute::run();
    }
    puts(ans ? "Alice" : "Bob");
  }
  return 0;
}