#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")


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 sub1 {
int run() {
  vector<int> dp(N, 0);
  for (int u = N; --u >= 0; ) {
    dp[u] = 1;
    for (const int v : graph[u]) {
      dp[u] ^= dp[v];
    }
  }
  int ans = 0;
  for (const int r : R) {
    ans ^= dp[r];
  }
  return ans;
}
}  // sub1


namespace sub2 {
int run() {
  // 0: even, 1: odd, 2: gote can choose, 3: sente can choose
  vector<int> dp(N, 0);
  for (int u = N; --u >= 0; ) {
    if (C[u]) {
      dp[u] = 1;
      for (const int v : graph[u]) {
        if (dp[v] == 1 || dp[v] == 2) {
          dp[u] = 3;
          break;
        }
      }
    } else {
      dp[u] = 1;
      for (const int v : graph[u]) {
        if (dp[v] >= 2) {
          dp[u] ^= dp[v];
          break;
        }
        dp[u] ^= dp[v];
      }
    }
  }
cerr<<"dp = "<<dp<<endl;
  return (dp[R[0]] & 1);
}
}  // sub2


namespace sub4 {
vector<int> dp;
set<int> us;
vector<int> freq;
priority_queue<int, vector<int>, greater<int>> que0, que1;
void add(int u) {
  us.insert(u);
  if (!freq[dp[u]]++) {
    que1.push(dp[u]);
  }
}
void rem(int u) {
  assert(us.erase(u));
  if (!--freq[dp[u]]) {
    que0.push(dp[u]);
  }
}
int get() {
  for (; !que1.empty() && que0.top() == que1.top(); que0.pop(), que1.pop()) {}
  return que0.top();
}

void dfs(int u) {
  for (int j = deg[u]; --j >= 0; ) {
    dfs(graph[u][j]);
  }
  dp[u] = get();
// cerr<<u<<": "<<dp[u]<<"; ";pv(us.begin(),us.end());
  for (const int v : graph[u]) {
    rem(v);
  }
  add(u);
}
int run() {
  vector<int> par(N, -1);
  for (int u = 0; u < N; ++u) {
    for (const int v : graph[u]) {
      par[v] = u;
    }
  }
  freq.assign(N + 1, 0);
  que0 = {};
  que1 = {};
  for (int x = 0; x <= N + 1; ++x) {
    que0.push(x);
  }
  dp.assign(N + 1, 0);
  for (int u = 0; u < N; ++u) if (!~par[u]) {
    add(N);
    dfs(u);
    rem(u);
    rem(N);
    assert(us.empty());
  }
  int ans = 0;
  for (const int r : R) {
    ans ^= dp[r];
  }
  return ans;
}
}  // sub4


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];
    }
    
    vector<int> indeg(N, 0);
    for (int u = 0; u < N; ++u) {
      for (const int v : graph[u]) {
        ++indeg[v];
      }
    }
    bool spe4 = true;
    spe4 = spe4 && (C == vector<int>(N, 1));
    for (int u = 0; u < N; ++u) {
      spe4 = spe4 && (indeg[u] <= 1);
    }
    for (const int r : R) {
      spe4 = spe4 && (indeg[r] <= 0);
    }
    
    int ans = -1;
    if (C == vector<int>(N, 0)) {
cerr<<"sub1"<<endl;
      ans = sub1::run();
    } else if (K == 1) {
cerr<<"sub2"<<endl;
      ans = sub2::run();
#ifdef LOCAL
const int brt=brute::run();
assert((bool)brt==(bool)ans);
#endif
    } else if (spe4) {
cerr<<"sub4"<<endl;
      ans = sub4::run();
#ifdef LOCAL
brute::run();
#endif
    } else {
      ans = brute::run();
    }
    puts(ans ? "Alice" : "Bob");
  }
  return 0;
}