Problem

Multiple rooted trees are given as the initial state. Alice and Bob, on the other hand, play the game. The game is played alternately by two players, with Alice on the play and Bob on the play. The player whose turn has turned takes the following actions.

1. Select one root (vertex that has no parent). Let this vertex be S.
2. Select the vertices contained in the rooted tree rooted at S (S can also be selected here). Let this vertex be T.
3. Delete all vertices on the path from S to T, including S and T. It also deletes all edges where the deleted vertices are endpoints.



If all vertices have been deleted when the turn comes, that player loses.

When Alice and Bob always take the best action, determine which player will win against a given initial state.

The figure below shows an example of a player's actions.
Example of player behavior

Constraints

The input satisfies the following constraints.

* 1 ≤ N ≤ 1000
* 0 ≤ M <N
* i <pi ≤ N (1 ≤ i ≤ M)

Input

The input is given in the following format.


N M
p1
p2
::
pM


In the first line, the number of vertices N and the number of sides M in the initial state are given separated by blanks. At this time, the numbers representing each vertex are 1 to N. The next M line gives edge information. Of these, in line i, one integer pi is given. This means that there is an edge from vertex pi to vertex i. In other words, it means that the parent of vertex i is vertex pi.

Output

Print the name of the winning player (Alice or Bob) on one line.

Examples

Input

6 3
4
4
5


Output

Alice


Input

6 4
2
5
4
5


Output

Bob
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <cfloat>
#include <ctime>
#include <cassert>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <numeric>
#include <list>
#include <iomanip>
#include <fstream>
#include <bitset>

using namespace std;

#define foreach(it, c) for (__typeof__((c).begin()) it=(c).begin(); it != (c).end(); ++it)
template <typename T> void print_container(ostream& os, const T& c) { const char* _s = " "; if (!c.empty()) { __typeof__(c.begin()) last = --c.end(); foreach (it, c) { os << *it; if (it != last) os << _s; } } }
template <typename T> ostream& operator<<(ostream& os, const vector<T>& c) { print_container(os, c); return os; }
template <typename T> ostream& operator<<(ostream& os, const set<T>& c) { print_container(os, c); return os; }
template <typename T> ostream& operator<<(ostream& os, const multiset<T>& c) { print_container(os, c); return os; }
template <typename T> ostream& operator<<(ostream& os, const deque<T>& c) { print_container(os, c); return os; }
template <typename T, typename U> ostream& operator<<(ostream& os, const map<T, U>& c) { print_container(os, c); return os; }
template <typename T, typename U> ostream& operator<<(ostream& os, const pair<T, U>& p) { os << "(" << p.first << ", " << p.second << ")"; return os; }

template <typename T> void print(T a, int n, const string& split = " ") { for (int i = 0; i < n; i++) { cout << a[i]; if (i + 1 != n) cout << split; } cout << endl; }
template <typename T> void print2d(T a, int w, int h, int width = -1, int br = 0) { for (int i = 0; i < h; ++i) { for (int j = 0; j < w; ++j) { if (width != -1) cout.width(width); cout << a[i][j] << ' '; } cout << endl; } while (br--) cout << endl; }
template <typename T> void input(T& a, int n) { for (int i = 0; i < n; ++i) cin >> a[i]; }
#define dump(v) (cerr << #v << ": " << v << endl)

#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define erep(i, n) for (int i = 0; i <= (int)(n); ++i)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define clr(a, x) memset(a, x, sizeof(a))
#define sz(a) ((int)(a).size())
#define mp(a, b) make_pair(a, b)
#define ten(n) ((long long)(1e##n))

template <typename T, typename U> void upmin(T& a, const U& b) { a = min<T>(a, b); }
template <typename T, typename U> void upmax(T& a, const U& b) { a = max<T>(a, b); }
template <typename T> void uniq(T& a) { sort(a.begin(), a.end()); a.erase(unique(a.begin(), a.end()), a.end()); }
template <class T> string to_s(const T& a) { ostringstream os; os << a; return os.str(); }
template <class T> T to_T(const string& s) { istringstream is(s); T res; is >> res; return res; }
void fast_io() { cin.tie(0); ios::sync_with_stdio(false); }
bool in_rect(int x, int y, int w, int h) { return 0 <= x && x < w && 0 <= y && y < h; }

typedef long long ll;
typedef pair<int, int> pint;

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


int dp[1024];
vector<int> g[1024];
int grundy(int);
void dfs(int i, set<int>& path, set<int>& ns, int x)
{
    path.insert(i);

    for (int to : g[i])
        x ^= grundy(to);
    ns.insert(x);

    for (int to : g[i])
        dfs(to, path, ns, x ^ grundy(to));

    path.erase(i);
}
int grundy(int i)
{
    if (dp[i] != -1)
        return dp[i];

    set<int> ns, path;
    dfs(i, path, ns, 0);

    int x = 0;
    while (ns.count(x))
        ++x;
    return dp[i] = x;
}
int main()
{
    int n, m;
    cin >> n >> m;
    clr(dp, -1);
    bool root[1024];
    fill_n(root, n, true);
    rep(i, m)
    {
        int p;
        cin >> p;
        --p;

        root[i] = false;
        g[p].push_back(i);
    }

    int x = 0;
    rep(i, n)
        if (root[i])
            x ^= grundy(i);
    cout << (x ? "Alice" : "Bob") << endl;
}
