Problem: 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

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(int i=0;i<(int)(n);++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
#define valid(y,x,h,w) (0<=y&&y<h&&0<=x&&x<w)
#define tpl(...) make_tuple(__VA_ARGS__)
const int INF = 0x3f3f3f3f;
const double EPS = 1e-8;
const double PI = acos(-1);
typedef long long ll;
typedef pair<int,int> pii;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
template<class T>ostream&operator<<(ostream &o,const vector<T>&t){o<<'[';FOR(i,t){if(i!=t.begin())o<<',';o<<*i;}return o<<']';}
template<class S,class T>ostream&operator<<(ostream &o,const pair<S,T>&t){return o<<'('<<t.first<<','<<t.second<<')';}
template<int N,class Tp>void output(ostream&,const Tp&){}
template<int N,class Tp,class,class ...Ts>void output(ostream &o,const Tp&t){if(N)o<<',';o<<get<N>(t);output<N+1,Tp,Ts...>(o,t);}
template<class ...Ts>ostream&operator<<(ostream&o,const tuple<Ts...>&t){o<<'(';output<0,tuple<Ts...>,Ts...>(o,t);return o<<')';}
template<class T>void output(T t,char z=10){if(t<0)t=-t,putchar(45);int c[20];
int k=0;while(t)c[k++]=t%10,t/=10;for(k||(c[k++]=0);k;)putchar(c[--k]^48);putchar(z);}
template<class T>void outputs(T t){output(t);}
template<class S,class ...T>void outputs(S a,T...t){output(a,32);outputs(t...);}
template<class T>void output(T *a,int n){REP(i,n)output(a[i],i!=n-1?',':10);}
template<class T>void output(T *a,int n,int m){REP(i,n)output(a[i],m);}
template<class T>bool input(T &t){int n=1,c;for(t=0;!isdigit(c=getchar())&&~c&&c-45;);
if(!~c)return 0;for(c-45&&(n=0,t=c^48);isdigit(c=getchar());)t=10*t+c-48;t=n?-t:t;return 1;}
template<class S,class ...T>bool input(S&a,T&...t){input(a);return input(t...);}

vector<int> g[1000];
int grundy(int v, int p);

int vvv;
void dfs(int v, int p, int gr, int vvv, vector<int> &gv) {
  FOR(it, g[v]) {
    if (*it == p) continue;
    gr ^= grundy(*it, v);
  }
  // if (gr == 0) {
  //   cout << p+1 << " " << vvv+1 << " " << v+1 << endl;
  // }
  gv.push_back(gr);
  FOR(it, g[v]) {
    if (*it == p) continue;
    dfs(*it, v, gr ^ grundy(*it, v), vvv, gv);
  }
}

int dp[1000];
int grundy(int v, int p) {
  if (dp[v] >= 0) return dp[v];
  vvv= v;
  vector<int> gv;
  dfs(v,p,0,v,gv);
  sort(ALL(gv));
  int res = 0;
  gv.erase(unique(ALL(gv)), gv.end());
  REP(i,gv.size()) {
    if (gv[i] != res) break;
    res++;
  }
  // cout << v+1 << " " << gv << " " << res << endl;
  return dp[v] = res;
}

int main() {
  int n,m;
  while(cin >> n >> m) {
    REP(i,n) g[i].clear();
    vector<int> num(n);
    REP(i,m) {
      int p; cin >> p;
      g[p-1].push_back(i);
      num[i]++;
    }
    memset(dp,-1,sizeof(dp));
    int gr = 0;
    REP(i,n) {
      if (num[i] == 0) {
        gr ^= grundy(i,-1);
      }
    }
    // output(dp,n);
    cout << (gr?"Alice":"Bob") << endl;
  }
}