#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) {
    return (ull)rng() % B;
}
inline double time() {
    return static_cast<long double>(chrono::duration_cast<chrono::nanoseconds>(chrono::steady_clock::now().time_since_epoch()).count()) * 1e-9;
}

ull bit(int x) {
    return ((ull)1 << x);
}

int main(){
    cin.tie(nullptr);
    ios::sync_with_stdio(false);

    auto cid = [&](int x, int y) -> int {
        return x*8+y;
    };

    vector<ull> hi(64),ka(64),ke(64);
    vector<ull> ihi(64),ika(64),ike(64);
    for (int i = 0; i < 8; ++i) {
        for (int j = 0; j < 8; ++j) {
            int id = cid(i,j);

            for (int k = 0; k < 8; ++k) {
                for (int l = 0; l < 8; ++l) {
                    int nid = cid(k,l);
                    if (k == i or j == l) {
                        hi[id] |= bit(nid);
                        ihi[nid] |= bit(id);
                    }
                    if (i+j == k+l or i-j == k-l) {
                        ka[id] |= bit(nid);
                        ika[nid] |= bit(id);
                    }
                    if (abs(k-i) == 1 and abs(j-l) == 2) {
                        ke[id] |= bit(nid);
                        ike[nid] |= bit(id);
                    }
                    if (abs(k-i) == 2 and abs(j-l) == 1) {
                        ke[id] |= bit(nid);
                        ike[nid] |= bit(id);
                    }
                }
            }
        }
    }

    ull kouho = 0;
    for (int i = 0; i < 64; ++i) {
        kouho |= bit(i);
    }

    string str = "BBAARRCCQQMM";
    cin >> str;
    map<tuple<ull,ull,ull,ull,int>,bool> mp;

    auto slv = [&](auto slv, ull n0, ull n1, ull n2, ull n3, int i) -> bool {
        char c = str[i];
        bool hisya = (c == 'R' or c == 'Q' or c == 'C' or c == 'M');
        bool kaku = (c == 'B' or c == 'Q' or c == 'A' or c == 'M');
        bool keima = (c == 'A' or c == 'C' or c == 'M');

        if (mp.find({n0,n1,n2,n3,i}) != mp.end()) {
            return mp[{n0,n1,n2,n3,i}];
        }

        ull cp = n0;
        int id = -1;
        while (cp) {
            id += 1;
            if (cp%2 == 0) {
                cp /= 2;
                continue;
            }
            cp /= 2;

            if (hisya) {
                if (n1&bit(id)) continue;
            }
            if (kaku) {
                if (n2&bit(id)) continue;
            }
            if (keima) {
                if (n3&bit(id)) continue;
            }

            ull nn0 = n0;
            ull nn1 = n1;
            ull nn2 = n2;
            ull nn3 = n3;
            nn1 |= ihi[id];
            nn2 |= ika[id];
            nn3 |= ike[id];

            if (hisya) {
                nn0 ^= (nn0&hi[id]);
            }
            if (kaku) {
                nn0 ^= (nn0&ka[id]);
            }
            if (keima) {
                nn0 ^= (nn0&ke[id]);
            }

            auto res = slv(slv, nn0, nn1&nn0, nn2&nn0, nn3&nn0, i+1);
            if (!res) {
                mp[{n0,n1,n2,n3,i}] = true;
                return true;
            }
        }

        mp[{n0,n1,n2,n3,i}] = false;
        return false;
    };

    if (slv(slv, kouho, 0, 0, 0, 0)) {
        cout << "Alice" << endl;
    }
    else {
        cout << "Bob" << endl;
    }
}