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 Go (1.6) (judge verdict: Accepted)

package main

import (
  "bufio"
  "fmt"
  "os"
  "strconv"
  "strings"
)

func main() {
  input := Input{bufio.NewReaderSize(os.Stdin,10000)}
  n,l := input.NextInts()
  root := NewNode(0)
  for i:=0;i<n;i++ {
    s := input.NextLine()
    node := root
    for j:=0;j<len(s);j++ {
      if s[j:j+1] == "0" {
        node = node.Left()
      } else {
        node = node.Right()
      }
    }
  }
  pile := []int64{}
  var dfs func(*Node)
  dfs = func(node *Node) {
    not := true
    if node.left != nil {
      if node.right == nil { pile = append(pile,l-node.depth);not = false }
      dfs(node.left)
    }
    if node.right != nil {
      if node.left == nil && not { pile = append(pile,l-node.depth) }
      dfs(node.right)
    }
  }
  dfs(root)
  p := make([]int64,61)
  p[0] = 1
  for i:=1;i<61;i++ { p[i] = 2*p[i-1] }
  xor := int64(0)
  for i:=0;i<len(pile);i++ {
    grundy := 0
    ub := 61
    for ub-grundy > 1 {
      m := (ub+grundy)/2
      if pile[i]%p[m] == 0 {
        grundy = m
      } else {
        ub = m
      }
    }
    xor ^= p[grundy]
  }
  if xor == 0 {
    fmt.Println("Bob")
  } else {
    fmt.Println("Alice")
  }
}

type Node struct {
  depth int64
  left,right *Node
}
func NewNode(d int64) *Node { return &Node{d,nil,nil} }
func(n *Node) Left() *Node {
  if n.left == nil { n.left = NewNode(n.depth+1) }
  return n.left
}
func(n *Node) Right() *Node {
  if n.right == nil { n.right = NewNode(n.depth+1) }
  return n.right
}

type Input struct { reader *bufio.Reader }
func(i *Input) NextLine() string {
  var buffer []byte
  for {
    line,isPrefix,err := i.reader.ReadLine()
    if err != nil { panic(err) }
    buffer = append(buffer,line...)
    if !isPrefix { break }
  }
  return string(buffer)
}
func(i *Input) NextInts() (int,int64) {
  s := strings.Fields(i.NextLine())
  x,_ := strconv.Atoi(s[0])
  y,_ := strconv.ParseInt(s[1],10,64)
  return x,y
}
func(i *Input) NextIntArray() []int {
  s := strings.Fields(i.NextLine())
  a := make([]int,len(s))
  for i:=0;i<len(s);i++ { a[i],_ = strconv.Atoi(s[i]) }
  return a
}