#include <bits/stdc++.h>
using namespace std;
using namespace chrono;

using ll = long long;
using ull = unsigned long long;

string to_string(const string &s) {
  return '"' + s + '"';
}

string to_string(bool b) {
  return b ? "true" : "false";
}

template <typename A, typename B>
string to_string(const pair<A, B> &p) {
  return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}

template <typename T>
string to_string(const T &v) {
  string s = "{";
  bool first = true;
  for (const auto &it : v) {
    if (!first)
      s += ", ";
    else
      first = false;
    s += to_string(it);
  }
  return s += "}";
}

void debug_out() {
  cerr << endl;
}

template <typename T, typename... Args>
void debug_out(const T &first, const Args&... rest) {
  cerr << to_string(first) << " ";
  debug_out(rest...);
}

#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

auto startTime = high_resolution_clock::now();
int get_time() {
  auto stopTime = chrono::high_resolution_clock::now();
  auto duration = duration_cast<milliseconds>(stopTime - startTime);
  return duration.count(); // in ms
}

inline bool is_knight(char ch) {
  return ch == 'A' || ch == 'C' || ch == 'M';
}

inline bool is_bishop(char ch) {
  return ch == 'A' || ch == 'B' || ch == 'M' || ch == 'Q';
}

inline bool is_rook(char ch) {
  return ch == 'R' || ch == 'M' || ch == 'Q' || ch == 'C';
}

const int dx[] = {-1, -1, 1, 1, -2, -2, 2, 2};
const int dy[] = {-2, 2, -2, 2, -1, 1, -1, 1};

string s;
int cs;
int p[8][8];
int f[8][8];

inline bool in_bounds(int i, int j) {
  return i >= 0 && j >= 0 && i < 8 && j < 8;
}

inline void mark_knight(int i, int j, int sgn) {
  for (int k = 0; k < 8; ++k) {
    int x = dx[k] + i;
    int y = dy[k] + j;
    if (in_bounds(x, y))
      f[x][y] += sgn, cs |= p[x][y];
  }
}

inline void mark_bishop(int i, int j, int sgn) {
  for (int s1 = -1; s1 <= 1; s1 += 2) {
    for (int s2 = -1; s2 <= 1; s2 += 2) {
      for (int k = 1; k < 8; ++k) {
        int x = k * s1 + i;
        int y = k * s2 + j;
        if (in_bounds(x, y))
          f[x][y] += sgn, cs |= p[x][y];
        else
          break;
      }
    }
  }
}

inline void mark_rook(int i, int j, int sgn) {
  for (int s1 = -1; s1 <= 1; s1 += 2) {
    for (int k = 1; k < 8; ++k) {
      int x = k * s1 + i;
      int y = j;
      if (in_bounds(x, y))
        f[x][y] += sgn, cs |= p[x][y];
      else
        break;
    }
    for (int k = 1; k < 8; ++k) {
      int x = i;
      int y = k * s1 + j;
      if (in_bounds(x, y))
        f[x][y] += sgn, cs |= p[x][y];
      else
        break;
    }
  }
}

void mark_pos(int i, int j, char ch, int sgn) {
  f[i][j] += sgn;
  if (is_knight(ch))
    mark_knight(i, j, sgn);
  if (is_bishop(ch))
    mark_bishop(i, j, sgn);
  if (is_rook(ch))
    mark_rook(i, j, sgn);
}

string dum = "PLM";

int back(int pos = 0) {
  if (pos == 12) {
    return 0;
  }

  int res = 0;
  int l = 8;
  if (pos == 0)
    l = 4;

  for (int i = 0; i < l; ++i) {
    for (int j = 0; j < l; ++j) {
      if (!f[i][j]) {
        cs = false;
        mark_pos(i, j, s[pos], 1);
        p[i][j] = 1;

        if (!cs)
          res = !back(pos + 1);

        p[i][j] = 0;
        mark_pos(i, j, s[pos], -1);
        if (res) {
          //if (pos <= 5)
          //  debug("WIN", pos);
          return 1;
        }
      }
    }
  }

  //if (pos <= 5)
  //  debug("LOSE", pos);

  return 0;
}

void solve() {
  int n;
  cin >> s;
  cout << ((back() == 0) ? "Bob" : "Alice") << '\n';
}

int main() {
  cin.tie(NULL);
  ios_base::sync_with_stdio(false);

  int t = 1;
//  cin >> t;
  while (t--)
    solve();

  return 0;
}