#include <bits/stdc++.h>
#define For(i, a, b) for(int (i)=(int)(a); (i)<(int)(b); ++(i))
#define rFor(i, a, b) for(int (i)=(int)(a)-1; (i)>=(int)(b); --(i))
#define rep(i, n) For((i), 0, (n))
#define rrep(i, n) rFor((i), (n), 0)
#define fi first
#define se second
using namespace std;
typedef long long lint;
typedef unsigned long long ulint;
typedef pair<int, int> pii;
typedef pair<int, lint> pil;
typedef pair<lint, lint> pll;
template<class T> bool chmax(T &a, const T &b){if(a<b){a=b; return true;} return false;}
template<class T> bool chmin(T &a, const T &b){if(a>b){a=b; return true;} return false;}
template<class T> T div_floor(T a, T b){
    if(b < 0) a *= -1, b *= -1;
    return a>=0 ? a/b : (a+1)/b-1;
}
template<class T> T div_ceil(T a, T b){
    if(b < 0) a *= -1, b *= -1;
    return a>0 ? (a-1)/b+1 : a/b;
}

constexpr lint mod = 1e9+7;
constexpr lint INF = 1e15;
constexpr int MAX = 100010;

template<typename T> struct Binary_Trie{
    struct Node{
        Node *ch[2];
        int cnt;
        Node(): cnt(0), ch{nullptr, nullptr}{}
    };

    int len;
    Binary_Trie(int b=31): len(b){}

    Node *make_node(){
        return new Node();
    }
    int count(Node *t){return t ? t->cnt : 0;}

    Node *add(Node *t, T val, int dep){
        if(!t) t = make_node();
        if(dep == -1){
            ++t->cnt;
            return t;
        }
        int x = val >> dep & 1;
        t->ch[x] = add(t->ch[x], val, dep-1);
        t->cnt = count(t->ch[0]) + count(t->ch[1]);
        return t;
    }

    Node *add(Node *t, int val){return add(t, val, len-1);}

    Node *string_add(Node *t, string &s, int cur){
        if(!t) t = make_node();
        if(cur == s.size()) return t;
        int x = s[cur] - '0';
        t->ch[x] = string_add(t->ch[x], s, cur+1);
        return t;
    }

    void get_a(Node *t, int cur, lint L, vector<lint> &a){
        if(!t || (!t->ch[0] && !t->ch[1])) return;
        if((t->ch[0] != nullptr) ^ (t->ch[1] != nullptr)){
            a.push_back(L - cur);
        }
        if(t->ch[0]) get_a(t->ch[0], cur+1, L, a);
        if(t->ch[1]) get_a(t->ch[1], cur+1, L, a);
    }

    Node *del(Node *t, int val, int dep){
        if(count(t) == 0) return t;
        if(dep == -1){
            --t->cnt;
            return t;
        }
        int x = val >> dep & 1;
        t->ch[x] = del(t->ch[x], val, dep-1);
        t->cnt = count(t->ch[0]) + count(t->ch[1]);
        return t;
    }

    Node *del(Node *t, int val){return del(t, val, len-1);}

    T get_kth(Node *t, int K){
        T ret = 0;
        rrep(i, len){
            if(count(t->ch[0]) >= K){
                t = t->ch[0];
                ret <<= 1;
            }
            else{
                K -= count(t->ch[0]);
                t = t->ch[1];
                ret <<= 1;
                ++ret;
            }
        }
        return ret;
    }
};

lint grundy(lint x){
    return x & -x;
}

int main(){
    int n;
    lint L;
    scanf("%d%lld", &n, &L);
    Binary_Trie<int> BT;
    auto root = BT.make_node();
    rep(_, n){
        string s;
        cin >> s;
        BT.string_add(root, s, 0);
    }
    vector<lint> a;
    BT.get_a(root, 0, L, a);
    lint x = 0;
    for(lint i: a) x ^= grundy(i);
    puts(x ? "Alice" : "Bob");
}

Measured memory_bytes: 7480