Alice and Bob play a game on a grid with $n$ rows and infinitely many columns. In each row, there are three tokens, blue, white and red one. **Before** the game starts and **after every move**, the following two conditions must hold:

- Any two tokens are not in the same cell.
- In each row, the blue token is to the left of the white token, and the red token is to the right of the white token.

First, they pick a positive integer $f$, whose value is valid for the whole game. Second, the starting player is chosen and makes his or her first turn. Then players take alternating turns. The player who is unable to make a move loses.

During a move, a player first selects an integer $k$ that is either a prime number or a product of two (not necessarily distinct) primes. The smallest possible values of $k$ are thus $2, 3, 4, 5, 6, 7, 9, 10, 11, 13, 14, 15, 17, 19, \dots$. Furthermore, $k$ must not be equal to the previously picked integer $f$. Each turn, a move is performed in exactly one of the rows.

If it is Alice’s turn, she chooses a single blue token and moves it $k$ cells to the right. Alternatively, she may move both the blue and the white token in the same row by the same amount $k$ to the right.

On the other hand, Bob selects a single red token and moves it $k$ cells to the left. Similarly, he may also move the white and the red token in the corresponding row by $k$ to the left.

Note that Alice may never move a red token, while Bob may never move a blue one. Remember that after a move, the two conditions on relative positions of the tokens must still hold.

Both players play optimally. Given the initial state of the board, determine who wins for two games: if Alice starts and if Bob starts.

**Input**

The first line contains a two integers $n$ and $f$ ($1 \leq n \leq 10^5$, $2 \leq f \leq 2 \cdot 10^5$) — the number of rows and the forbidden move, respectively.

Each of the next $n$ lines contains three integers $b_i$, $w_i$, $r_i$ ($-10^5 \leq b_i < w_i < r_i \leq 10^5$) — the number of column in which the blue, white and red token lies in the $i$-th row, respectively.

**Output**

Output two lines.

The first line should contain the name of the winner when Alice starts, and the second line should contain the name of the winner when Bob starts.

**Examples **

input

1 6 0 3 9

output

Alice Bob

input

1 2 0 3 9

output

Alice Bob

input

10 133 -248 -193 -187 97 101 202 -72 67 91 23 89 215 -129 -108 232 -223 -59 236 -99 86 242 -137 -109 -45 -105 173 246 -44 228 243

output

Bob Alice

**Note**

The first example is as follows:

When Alice starts, she can win by moving the blue and white token to right by $2$ cells, getting into position $2~5~9$. Regardless of what Bob does, Alice will have one more move and then the game is over. For instance, he can move both the red and white token by $2$ cells to the left, reaching state $2~3~7$. Alice can then move blue and white token by $2$ to move into $4~5~7$, where no more moves are possible.

If Bob starts, he gains enough advantage to win. For instance, he may move the red token by $3$ to the left, getting into position $0~3~6$. Alice can, for example, move the blue token by $2$, which is countered by Bob by moving the red token by $2$. The game ends in position $2~3~4$.

In the second example, it is forbidden to move by $2$, but this doesn’t stop Alice from winning! She can move the blue and white token by $4$, getting into position $4~7~9$. Now Bob has no move, since moving by $2$ is forbidden.

**Solution:**

#undef _GLIBCXX_DEBUG #include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(false); cin.tie(0); const int MAX = 200010; vector<int> p(MAX); iota(p.begin(), p.end(), 0); for (int i = 2; i < MAX; i++) { if (p[i] == i) { for (int j = i + i; j < MAX; j += i) { if (p[j] == j) { p[j] = i; } } } } int n, f; cin >> n >> f; vector<int> is_valid(MAX, 0); for (int i = 2; i < MAX; i++) { if (p[i] == i || p[i / p[i]] == i / p[i]) { if (i != f) { is_valid[i] = 1; } } } vector<int> g(MAX); g[0] = 0; vector<vector<int>> who(1); who[0].push_back(0); for (int i = 1; i < MAX; i++) { g[i] = 0; while (true) { if ((int) who.size() < g[i] + 1) { break; } int any = 0; for (int j : who[g[i]]) { if (is_valid[i - j]) { any = 1; break; } } if (!any) { break; } g[i]++; } if ((int) who.size() < g[i] + 1) { who.resize(g[i] + 1); } who[g[i]].push_back(i); } int res = 0; for (int i = 0; i < n; i++) { int x, y, z; cin >> x >> y >> z; res ^= g[y - x - 1]; res ^= g[z - y - 1]; } cout << (res == 0 ? "Bob" : "Alice") << '\n'; cout << (res != 0 ? "Bob" : "Alice") << '\n'; return 0; }