Problem: 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, .... 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 ≤ n ≤ 10^5, 2 ≤ f ≤ 2 ⋅ 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 ≤ b_i < w_i < r_i ≤ 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 (in CPP):

Solution:
#include <bits/stdc++.h>
#pragma GCC optimize("O2,unroll-loops,no-stack-protector,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
namespace io {
const int L = (1 << 20) + 1;
char buf[L], *S, *T, c;
char getchar() {
  if (__builtin_expect(S == T, 0)) {
    T = (S = buf) + fread(buf, 1, L, stdin);
    return (S == T ? EOF : *S++);
  }
  return *S++;
}
int inp() {
  int x = 0, f = 1;
  char ch;
  for (ch = getchar(); !isdigit(ch); ch = getchar())
    if (ch == '-') f = -1;
  for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
    ;
  return x * f;
}
unsigned inpu() {
  unsigned x = 0;
  char ch;
  for (ch = getchar(); !isdigit(ch); ch = getchar())
    ;
  for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
    ;
  return x;
}
long long inp_ll() {
  long long x = 0;
  int f = 1;
  char ch;
  for (ch = getchar(); !isdigit(ch); ch = getchar())
    if (ch == '-') f = -1;
  for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
    ;
  return x * f;
}
char B[25], *outs = B + 20, *outr = B + 20;
template <class T>
inline void print(register T a, register char x = 0) {
  if (x) *--outs = x, x = 0;
  if (!a)
    *--outs = '0';
  else
    while (a) *--outs = (a % 10) + 48, a /= 10;
  if (x) *--outs = x;
  fwrite(outs, outr - outs, 1, stdout);
  outs = outr;
}
};  // namespace io
using io ::inp;
using io ::inp_ll;
using io ::inpu;
using io ::print;
using i32 = int;
using i64 = long long;
using u8 = unsigned char;
using u32 = unsigned;
using u64 = unsigned long long;
using f64 = double;
using f80 = long double;
long long power(long long a, long long b, long long p) {
  if (!b) return 1;
  long long t = power(a, b / 2, p);
  t = t * t % p;
  if (b & 1) t = t * a % p;
  return t;
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
  if (b == 0) {
    x = 1;
    y = 0;
    return a;
  }
  long long px, py;
  long long d = exgcd(b, a % b, px, py);
  x = py;
  y = px - a / b * py;
  return d;
}
template <class T>
inline void freshmin(T &a, const T &b) {
  if (a > b) a = b;
}
template <class T>
inline void freshmax(T &a, const T &b) {
  if (a < b) a = b;
}
const int MAXN = 200010;
const int MAXP = 200000;
const int MAXK = 110;
const int MOD = 1000000009;
const f80 MI = f80(1) / MOD;
const int INF = 1000000000;
template <int MAXN>
struct mybitset {
  const static int LIMIT = (MAXN >> 5) + 1;
  u32 a[LIMIT];
  mybitset() { memset(a, 0, sizeof(a)); }
  void set(int x) { a[x >> 5] |= 1 << (x & 31); }
  void reset(int x) { a[x >> 5] &= 0xffffffff ^ (1 << (x & 31)); }
  bool test(int x) { return a[x >> 5] >> (x & 31) & 1; }
  void orshl(const mybitset &v, int shift) {
    if ((shift & 31) == 0) {
      for (int i = 0; i < LIMIT - (shift >> 5); ++i)
        a[(shift >> 5) + i] |= v.a[i];
    } else {
      a[shift >> 5] |= v.a[0] << shift;
      for (int i = 1; i < LIMIT - (shift >> 5); ++i)
        a[(shift >> 5) + i] |= (v.a[i - 1] >> (32 - shift)) | (v.a[i] << shift);
    }
  }
};
int b[MAXN];
mybitset<MAXN> u;
mybitset<MAXN> v[MAXK];
int f[MAXN];
void init(int x) {
  for (int i = 2; i <= MAXP; ++i) {
    if (!b[i]) {
      u.set(i);
      for (int j = i + i; j <= MAXP; j += i) b[j] = i;
    } else if (!b[i / b[i]])
      u.set(i);
  }
  u.reset(x);
  v[0] = u;
  for (int i = 1; i <= MAXP; ++i) {
    for (; v[f[i]].test(i); ++f[i])
      ;
    v[f[i]].orshl(u, i);
  }
}
int main() {
  int n = inp();
  init(inp());
  int ans = 0;
  while (n--) {
    int a = inp();
    int b = inp();
    int c = inp();
    ans ^= f[b - a - 1] ^ f[c - b - 1];
  }
  puts(ans ? "Alice\nBob" : "Bob\nAlice");
  return 0;
}