Problem:
Score : 700 points

Problem Statement

For strings s and t, we will say that s and t are prefix-free when neither is a prefix of the other.

Let L be a positive integer. A set of strings S is a good string set when the following conditions hold true:

Each string in S has a length between 1 and L (inclusive) and consists of the characters 0 and 1.

Any two distinct strings in S are prefix-free.

We have a good string set S = \{ s_1, s_2, ..., s_N \}. Alice and Bob will play a game against each other. They will alternately perform the following operation, starting from Alice:

Add a new string to S. After addition, S must still be a good string set.

The first player who becomes unable to perform the operation loses the game. Determine the winner of the game when both players play optimally.

Constraints

1 \leq N \leq 10^5

1 \leq L \leq 10^{18}

s_1, s_2, ..., s_N are all distinct.

{ s_1, s_2, ..., s_N } is a good string set.

|s_1| + |s_2| + ... + |s_N| \leq 10^5

Input

Input is given from Standard Input in the following format:

N L
s_1
s_2
:
s_N

Output

If Alice will win, print Alice; if Bob will win, print Bob.

Sample Input 1

2 2
00
01

Sample Output 1

Alice

If Alice adds 1, Bob will be unable to add a new string.

Sample Input 2

2 2
00
11

Sample Output 2

Bob

There are two strings that Alice can add on the first turn: 01 and 10.
In case she adds 01, if Bob add 10, she will be unable to add a new string.
Also, in case she adds 10, if Bob add 01, she will be unable to add a new string.

Sample Input 3

3 3
0
10
110

Sample Output 3

Alice

If Alice adds 111, Bob will be unable to add a new string.

Sample Input 4

2 1
0
1

Sample Output 4

Bob

Alice is unable to add a new string on the first turn.

Sample Input 5

1 2
11

Sample Output 5

Alice

Sample Input 6

2 3
101
11

Sample Output 6

Bob

Solution in Haskell (GHC 7.10.3) (judge verdict: Accepted)

import Data.Bits (xor, (.&.))
import qualified Data.ByteString.Char8 as BS
import Control.Monad (replicateM)

data Tree = Node Int Bool Int Tree Tree
          | Empty Int
          deriving (Show)

coloredChildren :: Tree -> Int
coloredChildren (Empty _) = 0
coloredChildren (Node _ _ n _ _) = n

goDown :: Int -> BS.ByteString -> Tree -> Tree
goDown h s (Empty _)
  | BS.length s == 0 || BS.head s == '\n' = Node h True 1 (Empty (h+1)) (Empty (h+1))
  | BS.head s == '0' = Node h False 1 (goDown (h+1) (BS.tail s) (Empty (h+1))) (Empty (h+1))
  | otherwise = Node h False 1 (Empty (h+1)) (goDown (h+1) (BS.tail s) (Empty (h+1)))
goDown h s t@(Node _ c d l r)
  | BS.length s == 0 || BS.head s == '\n' = Node h True (d+1) l r
  | BS.head s == '0' = let l' = goDown (h+1) (BS.tail s) l
                       in Node h c (coloredChildren l' + coloredChildren r + if c then 1 else 0) l' r
  | BS.head s == '1' = let r' = goDown (h+1) (BS.tail s) r
                       in Node h c (coloredChildren l + coloredChildren r' + if c then 1 else 0) l r'

grundy :: Int -> Tree -> Int
grundy he (Empty h)
  | h > he = 0
  | otherwise = let x = he - h + 1 in x .&. (-x)
grundy _ (Node _ True _ _ _) = 0 -- 根が使われている場合
grundy he (Node h _ _ l@(Node _ _ 0 _ _) r@(Node _ _ 0 _ _)) = let x = he - h + 1 in x .&. (-x)
grundy he (Node _ _ _ l r) = grundy he l `xor` grundy he r

main = do
  [n, l] <- fmap (map read . words) getLine
  ss <- replicateM n BS.getLine
  let t = foldr (goDown 0) (Empty 0) ss
      g = grundy l t
  putStrLn $ if g /= 0 then "Alice" else "Bob"