#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);
                    }
                }
            }
        }
    }

    vector<pair<int,int>> init(64);
    for (int i = 0; i < 64; ++i) {
        init[i] = {i/8, i%8};
    }

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

    auto slv = [&](auto slv, vector<pair<int,int>> v, 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');

        ull okeru = 0;
        V can;
        for (auto &[j,k] : v) {
            okeru |= bit(cid(j,k));
        }
        n1 &= okeru;
        n2 &= okeru;
        n3 &= okeru;

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

        for (auto &[j,k] : v) {
            vector<pair<int,int>> nv;
            int id = cid(j,k);

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

            // nvの更新
            ull ng = 0;
            ull nn1 = n1;
            ull nn2 = n2;
            ull nn3 = n3;
            nn1 |= ihi[id];
            nn2 |= ika[id];
            nn3 |= ike[id];
            if (hisya) {
                ng |= hi[id];
            }
            if (kaku) {
                ng |= ka[id];
            }
            if (keima) {
                ng |= ke[id];
            }
            for (auto &[l, m] : v) {
                if (ng&bit(cid(l,m))) continue;
                nv.push_back({l,m});
            }
            auto res = slv(slv, nv, nn1, nn2, nn3, i+1);
            if (!res) {
                mp[{v,{n1,n2,n3}}] = true;
                return true;
            }
        }

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

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