#include <bits/stdc++.h>
#ifndef ONLINE_JUDGE
#ifdef CPH
#include "/home/floze3/OI/debug.cpp"
#else
#include "/home/floze3/OI/debug_colored.cpp"
#endif
#else
#define debug(...)
#define debugArr(...)
#define look_time
#define look_memory
#endif
#define mp(x, y) std::make_pair(x, y)
#define mt std::make_tuple
#define eb emplace_back
#define fi first
#define se second
#define all(s) s.begin(), s.end()
#define rall(x) s.rbegin(), s.rend()
#define file(name)                 \
  freopen(name ".in", "r", stdin); \
  freopen(name ".out", "w", stdout);
#define fs(x) std::fixed << std::setprecision(x)
#define lowbit(x) (x & -x)
#define il inline
#define Avada_Kedavra return 0
#define _IOS                        \
  std::ios::sync_with_stdio(false); \
  std::cin.tie(nullptr), std::cout.tie(nullptr)
#define RANDOM_SEED std::chrono::steady_clock::now().time_since_epoch().count()
#define popcount __builtin_popcount
#define popcountll __builtin_popcountll
#define multitask \
  int _;          \
  io.read(_);     \
  while (_--)

namespace TYPEDEF {

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned int;
using i128 = __int128;
using pii = std::pair<int, int>;
using pi64 = std::pair<i64, i64>;
using vi = std::vector<int>;
using vi64 = std::vector<i64>;
using vu64 = std::vector<u64>;
using vpii = std::vector<pii>;
using vpi64 = std::vector<pi64>;
using si = std::stack<int>;
using si64 = std::stack<i64>;
using su64 = std::stack<u64>;
using spii = std::stack<pii>;
using spi64 = std::stack<pi64>;
using qi = std::queue<int>;
using qi64 = std::queue<i64>;
using qu64 = std::queue<u64>;
using qpii = std::queue<pii>;
using qpi64 = std::queue<pi64>;
using siset = std::set<int>;
using si64set = std::set<i64>;
using su64set = std::set<u64>;
using spiiset = std::set<pii>;
using spi64set = std::set<pi64>;
using str = std::string;
using vstr = std::vector<str>;
using f64 = long double;

}  // namespace TYPEDEF

using namespace TYPEDEF;

struct IO {
  static constexpr int MAXSIZE = 1 << 20;
  char buf[MAXSIZE], *p1, *p2, pbuf[MAXSIZE], *pp;
#ifndef ONLINE_JUDGE  // 调试，可显示字符
#else
  IO(): p1(buf), p2(buf), pp(pbuf) {}
  ~IO() { fwrite(pbuf, 1, pp - pbuf, stdout); }
#endif
  char gc() {
#ifndef ONLINE_JUDGE  // 调试，可显示字符
    return getchar();
#endif
    if (p1 == p2) p2 = (p1 = buf) + fread(buf, 1, MAXSIZE, stdin);
    return p1 == p2 ? ' ' : *p1++;
  }
  il bool blank(char ch) {
    return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
  }
  template<typename T> il void read(T &x) {
    double tmp = 1;
    bool sign = 0;
    x = 0;
    char ch = gc();
    for (; !isdigit(ch); ch = gc())
      if (ch == '-') sign = 1;
    for (; isdigit(ch); ch = gc()) x = x * 10 + (ch - '0');
    if (ch == '.')
      for (ch = gc(); isdigit(ch); ch = gc())
        tmp /= 10.0, x += tmp * (ch - '0');
    if (sign) x = -x;
  }
  il void read(char *s) {
    char ch = gc();
    for (; blank(ch); ch = gc())
      ;
    for (; !blank(ch); ch = gc()) *s++ = ch;
    *s = 0;
  }
  il void read(char &c) {
    for (c = gc(); blank(c); c = gc())
      ;
  }
  il void read(str &s) {
    s.clear();
    char ch = gc();
    for (; blank(ch); ch = gc())
      ;
    for (; !blank(ch); ch = gc()) s += ch;
  }
  template<typename T, typename... Args> il void read(T &x, Args &...args) {
    read(x), read(args...);
  }
  il void push(const char &c) {
#ifndef ONLINE_JUDGE  // 调试，可显示字符
    putchar(c);
#else
    if (pp - pbuf == MAXSIZE) fwrite(pbuf, 1, MAXSIZE, stdout), pp = pbuf;
    *pp++ = c;
#endif
  }
  template<typename T> il void write(T x) {
    if (x < 0) x = -x, push('-');  // 负数输出
    static int sta[40];
    int top = 0;
    do sta[top++] = x % 10, x /= 10;
    while (x);
    while (top) push(sta[--top] + '0');
  }
  il void write(double x, int k = 6) {
    if (x < 0) x = -x, push('-');  // 负数输出
    static int sta[40];
    int n = pow(10, k), top = 0;
    i64 nx = (i64)x, y = i64(x * n) % n;
    write(nx, '.');
    for (int i = 0; i < k; i++) sta[++top] = y % 10, y /= 10;
    while (top) push(sta[top--] + '0');
  }
  il void write(char *s) {
    while (*s) push(*s++);
  }
  il void write(const char *s) {
    while (*s) push(*s++);
  }
  il void write(char c) { push(c); }
  il void write(str s) {
    for (int c : s) push(c);
  }
  template<typename T, typename... Args> il void write(T x, Args... args) {
    write(x), write(args...);
  }
} io;

/*===============================ALGOS===============================*/

namespace basic_algorithm {
template<typename T> il T abs(T a) { return a >= 0 ? a : -a; }
template<typename T> il void chmin(T &a, T b) {
  if (a > b) a = b;
}
template<typename T> il void chmax(T &a, T b) {
  if (a < b) a = b;
}
}  // namespace basic_algorithm

using namespace basic_algorithm;

/*================================END================================*/

constexpr int N = 5e5 + 5;
constexpr int mod = 1e9 + 7;
constexpr int inf = 0x3f3f3f3f;
constexpr i64 inf64 = 0x3f3f3f3f3f3f3f3fll;

std::mt19937 rng(RANDOM_SEED);

bool mst;

int a[N], sum[N], f[20][N], ans[N];

bool med;

signed main() {
  int n, x;
  io.read(n);
  for (int i = 0; i < n; i++) io.read(x), a[x] ^= 1;
  for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] ^ a[i];
  for (int i = 0; i <= 18; i++)
    for (int j = n - (1 << i); j >= 0; j--)
      f[i][j] = sum[j + (1 << i) - 1] ^ sum[std::min(j + (1 << i + 1) - 1, n)] ^
                (j + (1 << i + 1) <= n ? f[i][j + (1 << i + 1)] : 0);

  for (int j = 0; j <= 18; j++)
    for (int i = 2; i <= n + 1; i++) {
      for (int l = 0; l <= n; l += i) {
        int r = std::min(l + i - 1, n),
            s = f[j][l] ^ f[j][l + ((r - l >> j + 1) << j + 1)];
        if ((r - l >> j) & 1) s ^= sum[r] ^ sum[l + ((r - l >> j) << j) - 1];
        ans[i] ^= s << j;
      }
    }
  for (int i = 2; i <= n + 1; i++) io.write(ans[i] ? "Alice " : "Bob ");
  Avada_Kedavra;
}

/*
all the things you do
the words you say
it all comes back to you
*/