#include <bits/stdc++.h>
#define long uint64_t
#define DEBUG
using namespace std;

// @author: pashka

struct state {
    long x[6];
};

bool operator < (const state &a, const state &b) {
    for (int i = 0; i < 6; i++) {
        if (a.x[i] < b.x[i]) return true;
        if (a.x[i] > b.x[i]) return false;
    }
    return false;
}

vector<vector<long>> beat(6, vector<long>(64));
map<state, int> mem[13];
vector<int> tt;

void print(long x) {
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            cout << ((x >> (i * 8 + j)) & 1);
        }
        cout << "\n";
    }
    cout << "\n";
}

int c = 0;

int ntz(uint64_t x) {
    // We return the number of trailing zeros in
    // the binary representation of x.
    //
    // We have that 0 <= x < 2^64.
    //
    // We begin by applying a function sensitive only
    // to the least significant bit (lsb) of x:
    //
    //   x -> x^(x-1)  e.g. 0b11001000 -> 0b00001111
    //
    // Observe that x^(x-1) == 2^(ntz(x)+1) - 1.

    uint64_t y = x^(x-1);

    // Next, we multiply by 0x03f79d71b4cb0a89,
    // and then roll off the first 58 bits.

    constexpr uint64_t debruijn = 0x03f79d71b4cb0a89;

    uint8_t z = (debruijn*y) >> 58;

    // What? Don't look at me like that.
    //
    // With 58 bits rolled off, only 6 bits remain,
    // so we must have one of 0, 1, 2, ..., 63.
    //
    // It turns out this number was judiciously
    // chosen to make it so each of the possible
    // values for y were mapped into distinct slots.
    //
    // So we just use a look-up table of all 64
    // possible answers, which have been precomputed in
    // advance by the the sort of people who write
    // chess engines in their spare time:

    constexpr std::array<int,64> lookup = {
            0, 47,  1, 56, 48, 27,  2, 60,
            57, 49, 41, 37, 28, 16,  3, 61,
            54, 58, 35, 52, 50, 42, 21, 44,
            38, 32, 29, 23, 17, 11,  4, 62,
            46, 55, 26, 59, 40, 36, 15, 53,
            34, 51, 20, 43, 31, 22, 10, 45,
            25, 39, 14, 33, 19, 30,  9, 24,
            13, 18,  8, 12,  7,  6,  5, 63
    };

    return lookup[z];
}

int go(state st, int i) {
    auto res = mem[i][st];
    if (res != 0) return res;
    res = 2;
    long mm = ULLONG_MAX - st.x[tt[i]];
    while (mm) {
        int x = ntz(mm);
        mm -= (1ull << x);
//        if (i == 0 && ((x / 8 >= 4) || (x % 8 >= 4))) continue;
        state st2 = st;
        for (int j = 0; j < 6; j++) {
            st2.x[j] = st2.x[j] | beat[tt[i]][x];
            st2.x[j] = st2.x[j] | beat[j][x];
        }
        int g = go(st2, i + 1);
        if (g == 2) {
            res = 1;
            break;
        }
    }
    mem[i][st] = res;
//    c++;
//    if (c % 100000 == 0) {
//        cout << c << endl;
//    }
    return res;
}

int main() {
    ios::sync_with_stdio(false);

    for (int t = 0; t < 6; t++) {
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                int x = i * 8 + j;
                for (int ii = 0; ii < 8; ii++) {
                    for (int jj = 0; jj < 8; jj++) {
                        int y = ii * 8 + jj;

                        bool bb = false;
                        if (t ==  1 || t == 2 || t == 4 || t == 5) {
                            if (ii == i || jj == j) bb = true;
                        }
                        if (t ==  0 || t == 2 || t == 3 || t == 5) {
                            if ((ii - jj) == (i - j) || (ii + jj == i + j)) bb = true;
                        }
                        if (t == 3 || t == 4 || t == 5) {
                            if ((abs(ii - i) == 2 && abs(jj - j) == 1) ||
                                (abs(ii - i) == 1 && abs(jj - j) == 2)) bb = true;
                        }
                        if (bb) {
                            beat[t][x] = beat[t][x] | (1ull << y);
                        }
                    }
                }
            }
        }
    }

//    for (int t = 0; t < 64; t++) {
//        print(beat[1][t]);
//    }

    string types = "BRQACM";
    string s;
    cin >> s;
    tt.resize(12);
    for (int i = 0; i < 12; i++) {
        for (int j = 0; j < 6; j++) {
            if (types[j] == s[i]) tt[i] = j;
        }
    }

    state st;
    for (int i = 0;i < 6; i++) st.x[i] = 0;
    auto res = go(st, 0);
    cout << (res == 1 ? "Alice" : "Bob");

    return 0;
}