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 <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <sstream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <numeric>
#include <cctype>
#include <tuple>
#include <array>
#include <climits>
#include <bitset>

// BEGIN CUT HERE
#ifdef _MSC_VER
#include <agents.h>
#endif
// END CUT HERE 

#define FOR(i, a, b) for(int i = (a); i < (int)(b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define REV(v) v.rbegin(), v.rend()
#define MEMSET(v, s) memset(v, s, sizeof(v))
#define MP make_pair
#define MT make_tuple

using namespace std;

typedef long long ll;
typedef pair<ll, ll> P;

const int N = 1010;
int dp[N];
vector<int> G[N];

int calc_grundy(int v);

void dfs(int v, int x, set<int> &st){
	for (auto nxt : G[v]){
		x ^= calc_grundy(nxt);
	}
	st.insert(x);
	for (auto nxt : G[v]){
		dfs(nxt, x^calc_grundy(nxt), st);
	}
}

int calc_grundy(int v){
	int &res = dp[v];
	if (res >= 0) return res;

	set<int> st;
	dfs(v, 0, st);
	for (int i = 0; i <= 1000; ++i){
		if (st.count(i) == 0) return res = i;
	}
	return -1;
}

int main(){
	cin.tie(0);
	ios::sync_with_stdio(false);

	MEMSET(dp, -1);

	int n, m;
	cin >> n >> m;

	vector<int> p(n, -1);
	rep(i, m){
		cin >> p[i];
		--p[i];
		G[p[i]].push_back(i);
	}

	int g = 0;
	rep(i, n) if (p[i] < 0) g ^= calc_grundy(i);

	cout << (g ? "Alice" : "Bob") << endl;

	return 0;
}