LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ttencate[P]pickomino/game.cc
// Function: Game::winner() const
int Game::winner() const {
  Worms maxWorms = -1;
  int winner = -1;
  for (unsigned i = 0; i < m_players.size(); ++i) {
    if (m_players[i].worms() > maxWorms) {
      maxWorms = m_players[i].worms();
      winner = i;
    } else if (m_players[i].worms() == maxWorms) {
      return -1; // Tie.
    }
  }
  return winner;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x20(%rsp) # imm = 0xFFFFFFFF
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movq %rax, 0x8(%rsp)
callq 0x4f60
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x498f
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x51f0
movq %rax, %rdi
callq 0x5030
cmpl 0x24(%rsp), %eax
jle 0x4953
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x51f0
movq %rax, %rdi
callq 0x5030
movl %eax, 0x24(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x20(%rsp)
jmp 0x497d
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x51f0
movq %rax, %rdi
callq 0x5030
cmpl 0x24(%rsp), %eax
jne 0x497b
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x4997
jmp 0x497d
jmp 0x497f
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x48eb
movl 0x20(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: ttencate[P]pickomino/./dice.h
// Function: Dice::sum() const
Score sum() const {
      int s = 0;
      for (DieSide const *side : DieSide::ALL) {
        s += (*this)[side] * side->score();
      }
      return s;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x3c(%rsp)
leaq 0x166d6(%rip), %rax     # 0x1b218
movq %rax, 0x30(%rsp)
leaq 0x166ca(%rip), %rdi     # 0x1b218
callq 0x2e30
movq %rax, 0x28(%rsp)
leaq 0x166b9(%rip), %rdi     # 0x1b218
callq 0x2e60
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2e90
testb $0x1, %al
jne 0x4b7e
jmp 0x4bca
leaq 0x28(%rsp), %rdi
callq 0x2ed0
movq 0x10(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
callq 0x2ee0
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
callq 0x5840
movl %eax, %ecx
movl 0xc(%rsp), %eax
imull %ecx, %eax
addl 0x3c(%rsp), %eax
movl %eax, 0x3c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x2f30
jmp 0x4b69
movl 0x3c(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ttencate[P]pickomino/./game.h
// Function: Player::worms() const
Worms worms() const {
      Worms w = 0;
      for (Tile tile : m_tiles) {
        w += tile.worms();
      }
      return w;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movl $0x0, 0x2c(%rsp)
addq $0x10, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x50d0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x5100
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x5130
testb $0x1, %al
jne 0x5082
jmp 0x50b2
leaq 0x18(%rsp), %rdi
callq 0x5170
movq (%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x4ad0
addl 0x2c(%rsp), %eax
movl %eax, 0x2c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x5180
jmp 0x506d
movl 0x2c(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: ttencate[P]pickomino/./dice.h
// Function: Dice::count() const
int count() const {
      int n = 0;
      for (DieSide const *side : DieSide::ALL) {
        n += (*this)[side];
      }
      return n;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0x2c(%rsp)
leaq 0x15fa7(%rip), %rax     # 0x1b218
movq %rax, 0x20(%rsp)
leaq 0x15f9b(%rip), %rdi     # 0x1b218
callq 0x2e30
movq %rax, 0x18(%rsp)
leaq 0x15f8a(%rip), %rdi     # 0x1b218
callq 0x2e60
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2e90
testb $0x1, %al
jne 0x52ad
jmp 0x52e1
leaq 0x18(%rsp), %rdi
callq 0x2ed0
movq (%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
callq 0x2ee0
addl 0x2c(%rsp), %eax
movl %eax, 0x2c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x2f30
jmp 0x5298
movl 0x2c(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: ttencate[P]pickomino/./game.h
// Function: Game::canTakeAny(Dice, Dice) const
bool canTakeAny(Dice taken, Dice roll) const {
      for (DieSide const *side : DieSide::ALL) {
        if (roll.contains(side) && !taken.contains(side)) {
          return true;
        }
      }
      return false;
    }

// Assembly:
subq $0x48, %rsp
leaq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x38(%rsp)
leaq 0x15ee4(%rip), %rax     # 0x1b218
movq %rax, 0x30(%rsp)
leaq 0x15ed8(%rip), %rdi     # 0x1b218
callq 0x2e30
movq %rax, 0x28(%rsp)
leaq 0x15ec7(%rip), %rdi     # 0x1b218
callq 0x2e60
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2e90
testb $0x1, %al
jne 0x5370
jmp 0x53bf
leaq 0x28(%rsp), %rdi
callq 0x2ed0
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
callq 0x4af0
testb $0x1, %al
jne 0x5397
jmp 0x53b1
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4af0
testb $0x1, %al
jne 0x53b1
movb $0x1, 0x47(%rsp)
jmp 0x53c4
jmp 0x53b3
leaq 0x28(%rsp), %rdi
callq 0x2f30
jmp 0x535b
movb $0x0, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nop
// File: ttencate[P]pickomino/human.cc
// Function: Human::chooseWhetherToRoll(Game const&, Dice const&)
bool Human::chooseWhetherToRoll(Game const &, Dice const &) {
  cout << "Roll again? [Y/n] ";
  string answer;
  do {
    getline(cin, answer);
  } while (answer != "" && answer != "y" && answer != "n");
  return answer == "" || answer == "y";
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x13836(%rip), %rdi     # 0x1afd0
leaq 0xaa03(%rip), %rsi      # 0x121a4
callq 0x2170
leaq 0x20(%rsp), %rdi
callq 0x2210
movq 0x13829(%rip), %rdi     # 0x1afe0
leaq 0x20(%rsp), %rsi
callq 0x2040
jmp 0x77c3
jmp 0x77c5
leaq 0xa8aa(%rip), %rsi      # 0x12076
leaq 0x20(%rsp), %rdi
callq 0x7b00
movb %al, 0x13(%rsp)
jmp 0x77dc
movb 0x13(%rsp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x12(%rsp)
jne 0x77ed
jmp 0x7836
leaq 0xa9c3(%rip), %rsi      # 0x121b7
leaq 0x20(%rsp), %rdi
callq 0x7b00
movb %al, 0x11(%rsp)
jmp 0x7804
movb 0x11(%rsp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x12(%rsp)
jne 0x7815
jmp 0x7836
leaq 0xa99d(%rip), %rsi      # 0x121b9
leaq 0x20(%rsp), %rdi
callq 0x7b00
movb %al, 0x10(%rsp)
jmp 0x782c
movb 0x10(%rsp), %al
movb %al, 0x12(%rsp)
jmp 0x7836
movb 0x12(%rsp), %al
testb $0x1, %al
jne 0x77b0
leaq 0xa82d(%rip), %rsi      # 0x12076
leaq 0x20(%rsp), %rdi
callq 0x7b30
movb %al, 0xf(%rsp)
jmp 0x7859
movb 0xf(%rsp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xe(%rsp)
jne 0x788b
jmp 0x786a
leaq 0xa946(%rip), %rsi      # 0x121b7
leaq 0x20(%rsp), %rdi
callq 0x7b30
movb %al, 0xd(%rsp)
jmp 0x7881
movb 0xd(%rsp), %al
movb %al, 0xe(%rsp)
jmp 0x788b
movb 0xe(%rsp), %al
movb %al, 0xc(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x20e0
movb 0xc(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x20e0
movq 0x18(%rsp), %rdi
callq 0x2280
nopw (%rax,%rax)
// File: ttencate[P]pickomino/human.cc
// Function: Human::chooseSideToTake(Game const&, Dice const&, Dice const&)
DieSide const *Human::chooseSideToTake(Game const &, Dice const &taken, Dice const &roll) {
  cout << "Which side to take? [";
  for (DieSide const *side : DieSide::ALL) {
    if (roll.contains(side) && !taken.contains(side)) {
      cout << side->toString();
    }
  }
  cout << "] ";
  string answer;
  DieSide const *side;
  do {
    getline(cin, answer);
    side = DieSide::fromString(answer);
  } while (!side || !roll.contains(side) || taken.contains(side));
  return side;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rcx, 0x98(%rsp)
movq 0x136d2(%rip), %rdi     # 0x1afd0
leaq 0xa8b6(%rip), %rsi      # 0x121bb
callq 0x2170
leaq 0x13907(%rip), %rax     # 0x1b218
movq %rax, 0x90(%rsp)
leaq 0x138f8(%rip), %rdi     # 0x1b218
callq 0x2e30
movq %rax, 0x88(%rsp)
leaq 0x138e4(%rip), %rdi     # 0x1b218
callq 0x2e60
movq %rax, 0x80(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x2e90
testb $0x1, %al
jne 0x795c
jmp 0x79cc
leaq 0x88(%rsp), %rdi
callq 0x2ed0
movq (%rax), %rax
movq %rax, 0x78(%rsp)
movq 0x98(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x4af0
testb $0x1, %al
jne 0x7989
jmp 0x79b8
movq 0xa0(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x4af0
testb $0x1, %al
jne 0x79b8
movq 0x78(%rsp), %rdi
callq 0x2f20
movq %rax, %rsi
movq 0x1361d(%rip), %rdi     # 0x1afd0
callq 0x2170
jmp 0x79ba
leaq 0x88(%rsp), %rdi
callq 0x2f30
jmp 0x7941
movq 0x135fd(%rip), %rdi     # 0x1afd0
leaq 0xa7da(%rip), %rsi      # 0x121b4
callq 0x2170
leaq 0x58(%rsp), %rdi
callq 0x2210
movq 0x135f0(%rip), %rdi     # 0x1afe0
leaq 0x58(%rsp), %rsi
callq 0x2040
jmp 0x79fc
leaq 0x20(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x2090
jmp 0x7a0d
leaq 0x20(%rsp), %rdi
callq 0x7b60
movq %rax, 0x18(%rsp)
jmp 0x7a1e
movq 0x18(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x20e0
movb $0x1, %al
cmpq $0x0, 0x50(%rsp)
movb %al, 0x17(%rsp)
je 0x7a8b
movq 0x98(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x4af0
movb %al, 0x16(%rsp)
jmp 0x7a58
movb 0x16(%rsp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x7a69
jmp 0x7a8b
movq 0xa0(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x4af0
movb %al, 0x15(%rsp)
jmp 0x7a81
movb 0x15(%rsp), %al
movb %al, 0x17(%rsp)
jmp 0x7a8b
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x79e9
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x20e0
movq 0x8(%rsp), %rax
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x7ae0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x20e0
leaq 0x58(%rsp), %rdi
callq 0x20e0
movq 0x48(%rsp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
nop
// File: ttencate[P]pickomino/./dice.h
// Function: DieSide::fromString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static DieSide const *fromString(std::string s) {
      for (DieSide const *side : ALL) {
        if (s == side->m_string) {
          return side;
        }
      }
      return nullptr;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, (%rsp)
movq %rdi, 0x28(%rsp)
leaq 0x136a4(%rip), %rax     # 0x1b218
movq %rax, 0x20(%rsp)
leaq 0x13698(%rip), %rdi     # 0x1b218
callq 0x2e30
movq %rax, 0x18(%rsp)
leaq 0x13687(%rip), %rdi     # 0x1b218
callq 0x2e60
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2e90
testb $0x1, %al
jne 0x7bb0
jmp 0x7bf4
leaq 0x18(%rsp), %rdi
callq 0x2ed0
movq (%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x7b30
testb $0x1, %al
jne 0x7bda
jmp 0x7be6
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x7bfd
jmp 0x7be8
leaq 0x18(%rsp), %rdi
callq 0x2f30
jmp 0x7b9b
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: ttencate[P]pickomino/maths.cc
// Function: nChooseK(int, int)
int nChooseK(int n, int k) {
  int out = 1;
  for (int i = 1; i < k; ++i) {
    out *= (n + 1 - i) / i;
  }
  return out;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl $0x1, -0xc(%rsp)
movl $0x1, -0x10(%rsp)
movl -0x10(%rsp), %eax
cmpl -0x8(%rsp), %eax
jge 0x7cd8
movl -0x4(%rsp), %eax
addl $0x1, %eax
subl -0x10(%rsp), %eax
cltd
idivl -0x10(%rsp)
imull -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x7ca8
movl -0xc(%rsp), %eax
retq
nopl (%rax)
// File: ttencate[P]pickomino/maths.cc
// Function: factorial(int)
long int factorial(int n) {
  long int f = 1;
  for (; n; --n) {
    f *= n;
  }
  return f;
}

// Assembly:
movl %edi, -0x4(%rsp)
movq $0x1, -0x10(%rsp)
cmpl $0x0, -0x4(%rsp)
je 0x7d11
movslq -0x4(%rsp), %rax
imulq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movl -0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x7ced
movq -0x10(%rsp), %rax
retq
nopw (%rax,%rax)
// File: ttencate[P]pickomino/maths.cc
// Function: power(int, int)
long int power(int n, int k) {
  long int p = 1;
  for (; k; --k) {
    p *= n;
  }
  return p;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movq $0x1, -0x10(%rsp)
cmpl $0x0, -0x8(%rsp)
je 0x7d55
movslq -0x4(%rsp), %rax
imulq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movl -0x8(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x7d31
movq -0x10(%rsp), %rax
retq
nopl (%rax,%rax)
// File: ttencate[P]pickomino/optimal_bot.cc
// Function: OptimalBot::prepareTurn(Game const&)
void OptimalBot::prepareTurn(Game const &game) {
  Player const &me = game.playerByStrategy(this);
  m_expectedWhenDead = me.hasTiles() ? -me.topTile().worms() : 0;
  m_expectedWhenRolling.clear();
  m_expectedWhenQuitting.clear();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rsi
movq %rsi, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x8840
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4cd0
testb $0x1, %al
jne 0x7d97
jmp 0x7dbc
movq 0x20(%rsp), %rdi
callq 0x4cf0
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x4ad0
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, 0xc(%rsp)
jmp 0x7dc4
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x7dc4
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x28(%rdi)
addq $0x30, %rdi
callq 0x88f0
movq 0x10(%rsp), %rdi
addq $0x68, %rdi
callq 0x8900
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ttencate[P]pickomino/optimal_bot.cc
// Function: OptimalBot::chooseWhetherToRoll(Game const&, Dice const&)
bool OptimalBot::chooseWhetherToRoll(Game const &game, Dice const &taken) {
  ExpectedWorms whenRolling = expectedWormsWhenRolling(game, taken);
  ExpectedWorms whenQuitting = expectedWormsWhenQuitting(game, taken);
  cout << "\"When rolling, I expect " << whenRolling << " worms.\"\n";
  cout << "\"When quitting, I expect " << whenQuitting << " worms.\"\n";
  return whenRolling > whenQuitting;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x40(%rsp)
leaq 0x30(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x7f00
movq 0x20(%rsp), %rdi
movsd %xmm0, 0x48(%rsp)
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x8160
movsd %xmm0, 0x28(%rsp)
movq 0x13145(%rip), %rdi     # 0x1afd0
leaq 0xa366(%rip), %rsi      # 0x121f8
callq 0x2170
movq %rax, %rdi
movsd 0x48(%rsp), %xmm0
callq 0x22b0
movq %rax, %rdi
leaq 0xa362(%rip), %rsi      # 0x12211
callq 0x2170
movq 0x13115(%rip), %rdi     # 0x1afd0
leaq 0xa359(%rip), %rsi      # 0x1221b
callq 0x2170
movq %rax, %rdi
movsd 0x28(%rsp), %xmm0
callq 0x22b0
movq %rax, %rdi
leaq 0xa332(%rip), %rsi      # 0x12211
callq 0x2170
movsd 0x48(%rsp), %xmm0
ucomisd 0x28(%rsp), %xmm0
seta %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: ttencate[P]pickomino/optimal_bot.cc
// Function: OptimalBot::expectedWormsWhenRolling(Game const&, Dice)
ExpectedWorms OptimalBot::expectedWormsWhenRolling(Game const &game, Dice taken) {
  if (m_expectedWhenRolling.find(taken) == m_expectedWhenRolling.end()) {
    int remainingDice = NUM_DICE - taken.count();
    assert(remainingDice > 0);

    ExpectedWorms w = 0;
    for (Roll roll : Roll::allWithDice(remainingDice)) {
      w += roll.probability() * expectedWormsWhenRolled(game, taken, roll.dice());
    }

    m_expectedWhenRolling[taken] = w;
  }
  return m_expectedWhenRolling[taken];
}

// Assembly:
subq $0xc8, %rsp
movq %rsi, %rax
leaq 0xd0(%rsp), %rsi
movq %rsi, 0x38(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rax, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
movq %rdi, 0x40(%rsp)
addq $0x30, %rdi
callq 0x8980
movq 0x40(%rsp), %rdi
movq %rax, 0xb0(%rsp)
addq $0x30, %rdi
callq 0x89b0
movq %rax, 0xa8(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x8960
testb $0x1, %al
jne 0x7f79
jmp 0x8139
movq 0x38(%rsp), %rdi
leaq 0xa0bf(%rip), %rax      # 0x12044
movl (%rax), %eax
movl %eax, 0x34(%rsp)
callq 0x5250
movl %eax, %ecx
movl 0x34(%rsp), %eax
subl %ecx, %eax
movl %eax, 0xa4(%rsp)
cmpl $0x0, 0xa4(%rsp)
jle 0x7fab
jmp 0x7fca
leaq 0xa303(%rip), %rdi      # 0x122b5
leaq 0xa28f(%rip), %rsi      # 0x12248
movl $0x38, %edx
leaq 0xa302(%rip), %rcx      # 0x122c7
callq 0x2100
xorps %xmm0, %xmm0
movsd %xmm0, 0x98(%rsp)
movl 0xa4(%rsp), %edi
callq 0xf500
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rdi
callq 0x89e0
movq %rax, 0x88(%rsp)
movq 0x90(%rsp), %rdi
callq 0x8a10
movq %rax, 0x80(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x8a40
testb $0x1, %al
jne 0x8032
jmp 0x810d
leaq 0x88(%rsp), %rdi
callq 0x8a80
movq (%rax), %rcx
movq %rcx, 0x60(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x68(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x70(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x78(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x8a90
movq 0x38(%rsp), %rax
movsd %xmm0, 0x28(%rsp)
movq 0xb8(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movq (%rax), %rcx
movq %rcx, 0x48(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x50(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x8aa0
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rax, %rdx
leaq 0x48(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x86e0
movaps %xmm0, %xmm2
movsd 0x28(%rsp), %xmm0
movsd 0x98(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x98(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x8ab0
jmp 0x8014
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdi
movsd 0x98(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
addq $0x30, %rdi
callq 0x8ad0
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdi
addq $0x30, %rdi
callq 0x8ad0
movsd (%rax), %xmm0
addq $0xc8, %rsp
retq
nopl (%rax,%rax)
// File: ttencate[P]pickomino/optimal_bot.cc
// Function: OptimalBot::expectedWormsWhenQuitting(Game const&, Dice const&)
ExpectedWorms OptimalBot::expectedWormsWhenQuitting(Game const &game, Dice const &taken) {
  if (!taken.contains(DieSide::WORM)) {
    return m_expectedWhenDead;
  }

  Score score = taken.sum();
  if (m_expectedWhenQuitting.find(score) == m_expectedWhenQuitting.end()) {
    ExpectedWorms w = m_expectedWhenDead;

    if (taken.contains(DieSide::WORM)) {
      Tile stealable = game.stealableTile(this, taken);
      if (stealable.valid()) {
        w = max(w, stealable.worms() * (1 + 1.0 / (game.numPlayers() - 1)));
      }

      Tile remaining = game.bestRemainingTile(taken);
      if (remaining.valid()) {
        w = max(w, ExpectedWorms(remaining.worms()));
      }
    }

    m_expectedWhenQuitting[score] = w;
  }
  return m_expectedWhenQuitting[score];
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x129af(%rip), %rax     # 0x1ab38
movq (%rax), %rsi
callq 0x4af0
testb $0x1, %al
jne 0x81aa
movq 0x10(%rsp), %rax
movsd 0x28(%rax), %xmm0
movsd %xmm0, 0x70(%rsp)
jmp 0x834e
movq 0x58(%rsp), %rdi
callq 0x4b20
movq 0x10(%rsp), %rdi
movl %eax, 0x54(%rsp)
addq $0x68, %rdi
leaq 0x54(%rsp), %rsi
callq 0x8b20
movq 0x10(%rsp), %rdi
movq %rax, 0x48(%rsp)
addq $0x68, %rdi
callq 0x8b50
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x8b00
testb $0x1, %al
jne 0x81fb
jmp 0x8331
movq 0x10(%rsp), %rax
movsd 0x28(%rax), %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x12921(%rip), %rax     # 0x1ab38
movq (%rax), %rsi
callq 0x4af0
testb $0x1, %al
jne 0x8228
jmp 0x830a
movq 0x10(%rsp), %rsi
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rdx
callq 0x3a40
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x8b80
testb $0x1, %al
jne 0x8251
jmp 0x82b7
leaq 0x30(%rsp), %rdi
callq 0x4ad0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x60(%rsp), %rdi
callq 0x8ba0
movsd 0x8(%rsp), %xmm0
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
movsd 0x9f64(%rip), %xmm2     # 0x121e8
divsd %xmm1, %xmm2
movsd 0x9f58(%rip), %xmm1     # 0x121e8
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x8920
movsd (%rax), %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x3b80
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x8b80
testb $0x1, %al
jne 0x82db
jmp 0x8308
leaq 0x20(%rsp), %rdi
callq 0x4ad0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x8920
movsd (%rax), %xmm0
movsd %xmm0, 0x38(%rsp)
jmp 0x830a
movq 0x10(%rsp), %rdi
movsd 0x38(%rsp), %xmm0
movsd %xmm0, (%rsp)
addq $0x68, %rdi
leaq 0x54(%rsp), %rsi
callq 0x8bb0
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x10(%rsp), %rdi
addq $0x68, %rdi
leaq 0x54(%rsp), %rsi
callq 0x8bb0
movsd (%rax), %xmm0
movsd %xmm0, 0x70(%rsp)
movsd 0x70(%rsp), %xmm0
addq $0x78, %rsp
retq
nopl (%rax)
// File: ttencate[P]pickomino/optimal_bot.cc
// Function: OptimalBot::chooseSideToTake(Game const&, Dice const&, Dice const&)
DieSide const *OptimalBot::chooseSideToTake(Game const &game, Dice const &taken, Dice const &roll) {
  DieSide const *best = nullptr;
  ExpectedWorms bestW = -numeric_limits<ExpectedWorms>::max();
  for (DieSide const *side : DieSide::ALL) {
    if (roll.contains(side) && !taken.contains(side)) {
      ExpectedWorms w = expectedWormsWhenTaking(game, taken, roll, side);
      if (w > bestW) {
        bestW = w;
        best = side;
      }
      cout << "\"When taking " << side->toString() << ", I expect " << w << " worms.\"\n";
    }
  }
  assert(best);
  return best;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x70(%rsp)
callq 0x8910
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x68(%rsp)
leaq 0x12e55(%rip), %rax     # 0x1b218
movq %rax, 0x60(%rsp)
leaq 0x12e49(%rip), %rdi     # 0x1b218
callq 0x2e30
movq %rax, 0x58(%rsp)
leaq 0x12e38(%rip), %rdi     # 0x1b218
callq 0x2e60
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2e90
testb $0x1, %al
jne 0x8402
jmp 0x8538
leaq 0x58(%rsp), %rdi
callq 0x2ed0
movq (%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x78(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x4af0
testb $0x1, %al
jne 0x842c
jmp 0x8527
movq 0x80(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x4af0
testb $0x1, %al
jne 0x8527
movq 0x20(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x80(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x78(%rsp), %rdx
movq 0x48(%rsp), %rcx
leaq 0x28(%rsp), %rax
movq (%rax), %r8
movq %r8, (%rsp)
movq 0x8(%rax), %r8
movq %r8, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x8570
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
ucomisd 0x68(%rsp), %xmm0
jbe 0x84cc
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x68(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x12afd(%rip), %rdi     # 0x1afd0
leaq 0x9d5b(%rip), %rsi      # 0x12235
callq 0x2170
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0x2f20
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x2170
movq %rax, %rdi
leaq 0x9d00(%rip), %rsi      # 0x12205
callq 0x2170
movq %rax, %rdi
movsd 0x40(%rsp), %xmm0
callq 0x22b0
movq %rax, %rdi
leaq 0x9cef(%rip), %rsi      # 0x12211
callq 0x2170
jmp 0x8529
leaq 0x58(%rsp), %rdi
callq 0x2f30
jmp 0x83ea
cmpq $0x0, 0x70(%rsp)
je 0x8542
jmp 0x8561
leaq 0x9cfa(%rip), %rdi      # 0x12243
leaq 0x9cf8(%rip), %rsi      # 0x12248
movl $0x27, %edx
leaq 0x9cfb(%rip), %rcx      # 0x12257
callq 0x2100
movq 0x70(%rsp), %rax
addq $0x98, %rsp
retq
nop
// File: ttencate[P]pickomino/optimal_bot.cc
// Function: OptimalBot::expectedWormsWhenTaking(Game const&, Dice, Dice const&, DieSide const*)
ExpectedWorms OptimalBot::expectedWormsWhenTaking(Game const &game, Dice taken, Dice const &roll, DieSide const *side) {
  assert(roll.contains(side));
  assert(!taken.contains(side));

  taken[side] = roll[side];

  ExpectedWorms w = expectedWormsWhenQuitting(game, taken);
  if (taken.count() < NUM_DICE) {
    w = max(w, expectedWormsWhenRolling(game, taken));
  }
  return w;
}

// Assembly:
subq $0x78, %rsp
leaq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x4af0
testb $0x1, %al
jne 0x85b4
jmp 0x85b6
jmp 0x85d5
leaq 0x9d51(%rip), %rdi      # 0x1230e
leaq 0x9c84(%rip), %rsi      # 0x12248
movl $0x5f, %edx
leaq 0x9d52(%rip), %rcx      # 0x12322
callq 0x2100
movq 0x20(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x4af0
xorb $-0x1, %al
testb $0x1, %al
jne 0x85ec
jmp 0x85ee
jmp 0x860d
leaq 0x9d92(%rip), %rdi      # 0x12387
leaq 0x9c4c(%rip), %rsi      # 0x12248
movl $0x60, %edx
leaq 0x9d1a(%rip), %rcx      # 0x12322
callq 0x2100
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x2ee0
movq 0x20(%rsp), %rdi
movl %eax, 0x1c(%rsp)
movq 0x58(%rsp), %rsi
callq 0x2f50
movl 0x1c(%rsp), %ecx
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl %ecx, (%rax)
movq 0x68(%rsp), %rsi
callq 0x8160
movq 0x20(%rsp), %rdi
movsd %xmm0, 0x50(%rsp)
callq 0x5250
leaq 0x99e4(%rip), %rcx      # 0x12044
cmpl (%rcx), %eax
jge 0x86cf
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x68(%rsp), %rsi
movq (%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x40(%rsp)
leaq 0x30(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x7f00
movsd %xmm0, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x8920
movsd (%rax), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: ttencate[P]pickomino/optimal_bot.cc
// Function: OptimalBot::expectedWormsWhenRolled(Game const&, Dice, Dice const&)
ExpectedWorms OptimalBot::expectedWormsWhenRolled(Game const &game, Dice taken, Dice const &roll) {
  ExpectedWorms w = m_expectedWhenDead;
  for (DieSide const *side : DieSide::ALL) {
    if (roll.contains(side) && !taken.contains(side)) {
      w = max(w, expectedWormsWhenTaking(game, taken, roll, side));
    }
  }
  return w;
}

// Assembly:
subq $0x88, %rsp
leaq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movsd 0x28(%rax), %xmm0
movsd %xmm0, 0x68(%rsp)
leaq 0x12af3(%rip), %rax     # 0x1b218
movq %rax, 0x60(%rsp)
leaq 0x12ae7(%rip), %rdi     # 0x1b218
callq 0x2e30
movq %rax, 0x58(%rsp)
leaq 0x12ad6(%rip), %rdi     # 0x1b218
callq 0x2e60
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2e90
testb $0x1, %al
jne 0x8764
jmp 0x8827
leaq 0x58(%rsp), %rdi
callq 0x2ed0
movq (%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x70(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x4af0
testb $0x1, %al
jne 0x878e
jmp 0x8816
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x4af0
testb $0x1, %al
jne 0x8816
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x78(%rsp), %rsi
movq (%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x70(%rsp), %rdx
movq 0x48(%rsp), %rcx
leaq 0x28(%rsp), %rax
movq (%rax), %r8
movq %r8, (%rsp)
movq 0x8(%rax), %r8
movq %r8, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x8570
movsd %xmm0, 0x40(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x8920
movsd (%rax), %xmm0
movsd %xmm0, 0x68(%rsp)
jmp 0x8818
leaq 0x58(%rsp), %rdi
callq 0x2f30
jmp 0x874c
movsd 0x68(%rsp), %xmm0
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ttencate[P]pickomino/./game.h
// Function: Game::playerByStrategy(Strategy const*) const
Player const &playerByStrategy(Strategy const *strategy) const {
      for (Player const &player : m_players) {
        if (&player.strategy() == strategy) {
          return player;
        }
      }
      assert(false);
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4be0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4c10
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4c40
testb $0x1, %al
jne 0x888b
jmp 0x88c3
leaq 0x18(%rsp), %rdi
callq 0x4c80
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x4f50
cmpq 0x28(%rsp), %rax
jne 0x88b5
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
jmp 0x88b7
leaq 0x18(%rsp), %rdi
callq 0x4d20
jmp 0x8876
leaq 0x9ad3(%rip), %rdi      # 0x1239d
leaq 0x9ad2(%rip), %rsi      # 0x123a3
movl $0x97, %edx
leaq 0x9acf(%rip), %rcx      # 0x123ac
callq 0x2100
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ttencate[P]pickomino/./dice.h
// Function: std::hash<Dice>::operator()(Dice const&) const
size_t operator()(Dice const &dice) const {
      size_t out = 0;
      int i = 0;
      for (DieSide const *side : DieSide::ALL) {
        out ^= hash<int>()(dice[side] << (4*i));
        i++;
      }
      return out;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
leaq 0x11aa2(%rip), %rax     # 0x1b218
movq %rax, 0x20(%rsp)
leaq 0x11a96(%rip), %rdi     # 0x1b218
callq 0x2e30
movq %rax, 0x18(%rsp)
leaq 0x11a85(%rip), %rdi     # 0x1b218
callq 0x2e60
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2e90
testb $0x1, %al
jne 0x97b2
jmp 0x9809
leaq 0x18(%rsp), %rdi
callq 0x2ed0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2ee0
movl %eax, %esi
movl 0x2c(%rsp), %ecx
shll $0x2, %ecx
shll %cl, %esi
leaq 0x7(%rsp), %rdi
callq 0x9830
xorq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x2f30
jmp 0x979d
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ttencate[P]pickomino/./dice.h
// Function: Dice::operator==(Dice const&) const
bool operator==(Dice const &other) const {
      for (DieSide const *side : DieSide::ALL) {
        if ((*this)[side] != other[side]) {
          return false;
        }
      }
      return true;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x116f9(%rip), %rax     # 0x1b218
movq %rax, 0x28(%rsp)
leaq 0x116ed(%rip), %rdi     # 0x1b218
callq 0x2e30
movq %rax, 0x20(%rsp)
leaq 0x116dc(%rip), %rdi     # 0x1b218
callq 0x2e60
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x2e90
testb $0x1, %al
jne 0x9b5b
jmp 0x9bae
leaq 0x20(%rsp), %rdi
callq 0x2ed0
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
callq 0x2ee0
movl %eax, 0x4(%rsp)
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2ee0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
je 0x9ba0
movb $0x0, 0x47(%rsp)
jmp 0x9bb3
jmp 0x9ba2
leaq 0x20(%rsp), %rdi
callq 0x2f30
jmp 0x9b46
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nop
// File: ttencate[P]pickomino/roll.cc
// Function: rollProbability(Dice const&)
Probability rollProbability(Dice const &dice) {
  int n = dice.count();
  long int numerator = factorial(n);
  long int denominator = power(DieSide::COUNT, n);
  for (DieSide const *side : DieSide::ALL) {
    denominator *= factorial(dice[side]);
  }
  return (Probability) numerator / denominator;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x5250
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %edi
callq 0x7ce0
movq %rax, 0x30(%rsp)
movl 0x3c(%rsp), %esi
movl $0x6, %edi
callq 0x7d20
movq %rax, 0x28(%rsp)
leaq 0xbfd9(%rip), %rax      # 0x1b218
movq %rax, 0x20(%rsp)
leaq 0xbfcd(%rip), %rdi      # 0x1b218
callq 0x2e30
movq %rax, 0x18(%rsp)
leaq 0xbfbc(%rip), %rdi      # 0x1b218
callq 0x2e60
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2e90
testb $0x1, %al
jne 0xf27b
jmp 0xf2ba
leaq 0x18(%rsp), %rdi
callq 0x2ed0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2ee0
movl %eax, %edi
callq 0x7ce0
imulq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x2f30
jmp 0xf266
cvtsi2sdq 0x30(%rsp), %xmm0
cvtsi2sdq 0x28(%rsp), %xmm1
divsd %xmm1, %xmm0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ttencate[P]pickomino/roll.cc
// Function: enumerateRolls(std::vector<Roll, std::allocator<Roll>>&, int, Dice, __gnu_cxx::__normal_iterator<DieSide const* const*, std::vector<DieSide const*, std::allocator<DieSide const*>>>)
void enumerateRolls(vector<Roll> &out, int remainingDice, Dice dice, vector<DieSide const *>::const_iterator side) {
  if (side == DieSide::ALL.end() - 1) {
    dice[*side] = remainingDice;
    out.push_back(Roll(dice));
    return;
  }
  for (int num = remainingDice; num >= 0; --num) {
    Dice newRoll = dice;
    newRoll[*side] = num;
    enumerateRolls(out, remainingDice - num, newRoll, side + 1);
  }
}

// Assembly:
subq $0xc8, %rsp
leaq 0xd0(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rdi, 0xb8(%rsp)
movl %esi, 0xb4(%rsp)
leaq 0xbeb6(%rip), %rdi      # 0x1b218
callq 0x2e60
movq %rax, 0xa0(%rsp)
leaq 0xa0(%rsp), %rdi
movl $0x1, %esi
callq 0xf760
movq %rax, 0xa8(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0xf720
testb $0x1, %al
jne 0xf3a4
jmp 0xf405
movl 0xb4(%rsp), %eax
movl %eax, 0x2c(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x2ed0
movq 0x38(%rsp), %rdi
movq (%rax), %rsi
callq 0x2f50
movl 0x2c(%rsp), %ecx
movq 0x38(%rsp), %rsi
movl %ecx, (%rax)
movq 0xb8(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x80(%rsp), %rdi
callq 0xf2e0
movq 0x30(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xf7b0
jmp 0xf4f4
movl 0xb4(%rsp), %eax
movl %eax, 0x7c(%rsp)
cmpl $0x0, 0x7c(%rsp)
jl 0xf4f4
movq 0x38(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x64(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x6c(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x74(%rsp)
movl 0x7c(%rsp), %eax
movl %eax, 0x1c(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x2ed0
movq (%rax), %rsi
leaq 0x64(%rsp), %rdi
callq 0x2f50
movl 0x1c(%rsp), %ecx
movl %ecx, (%rax)
movq 0xb8(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0xb4(%rsp), %eax
subl 0x7c(%rsp), %eax
movl %eax, 0x28(%rsp)
movq 0x64(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x6c(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x74(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0xc0(%rsp), %rdi
movl $0x1, %esi
callq 0xf7e0
movq 0x20(%rsp), %rdi
movl 0x28(%rsp), %esi
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdx
leaq 0x48(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xf330
movl 0x7c(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x7c(%rsp)
jmp 0xf410
addq $0xc8, %rsp
retq
nopl (%rax)
// File: ttencate[P]pickomino/roll.cc
// Function: Roll::allWithDice(unsigned int)
vector<Roll> const &Roll::allWithDice(unsigned numDice) {
  static vector<vector<Roll>*> cache;
  if (cache.size() <= numDice) {
    cache.resize(numDice + 1);
  }
  if (!cache[numDice]) {
    cache[numDice] = new vector<Roll>();
    enumerateRolls(*cache[numDice], numDice, Dice(), DieSide::ALL.begin());
  }
  return *cache[numDice];
}

// Assembly:
subq $0x58, %rsp
movl %edi, 0x54(%rsp)
cmpb $0x0, 0xbd81(%rip)      # 0x1b290
jne 0xf554
leaq 0xbd78(%rip), %rdi      # 0x1b290
callq 0x22a0
cmpl $0x0, %eax
je 0xf554
leaq 0xbd4f(%rip), %rdi      # 0x1b278
callq 0xf820
leaq 0x2fb(%rip), %rdi       # 0xf830
leaq 0xbd3c(%rip), %rsi      # 0x1b278
leaq 0xbc2d(%rip), %rdx      # 0x1b170
callq 0x2140
leaq 0xbd41(%rip), %rdi      # 0x1b290
callq 0x20f0
leaq 0xbd1d(%rip), %rdi      # 0x1b278
callq 0xf890
movl 0x54(%rsp), %ecx
cmpq %rcx, %rax
ja 0xf580
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
leaq 0xbcfd(%rip), %rdi      # 0x1b278
callq 0xf8b0
movl 0x54(%rsp), %eax
movl %eax, %esi
leaq 0xbceb(%rip), %rdi      # 0x1b278
callq 0xf950
cmpq $0x0, (%rax)
jne 0xf64c
movl $0x18, %edi
callq 0x2180
movq %rax, %rdi
movq %rdi, 0x18(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x20b0
movq 0x18(%rsp), %rdi
callq 0xf970
movl 0x54(%rsp), %eax
movl %eax, %esi
leaq 0xbca7(%rip), %rdi      # 0x1b278
callq 0xf950
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movl 0x54(%rsp), %eax
movl %eax, %esi
leaq 0xbc8d(%rip), %rdi      # 0x1b278
callq 0xf950
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movl 0x54(%rsp), %eax
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x5210
leaq 0xbc07(%rip), %rdi      # 0x1b218
callq 0x2e30
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdx
leaq 0x38(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xf330
movl 0x54(%rsp), %eax
movl %eax, %esi
leaq 0xbc1f(%rip), %rdi      # 0x1b278
callq 0xf950
movq (%rax), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ttencate[P]pickomino/roll.cc
// Function: randomRoll(int)
Dice randomRoll(int n) {
  Dice dice;
  for (int i = 0; i < n; i++) {
    dice[randomDieSide()]++;
  }
  return dice;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl %esi, 0x14(%rsp)
callq 0x5210
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0xf710
callq 0xf690
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x2f50
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0xf6e1
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: ttencate[P]pickomino/simple_bot.cc
// Function: SimpleBot::chooseWhetherToRoll(Game const&, Dice const&)
bool SimpleBot::chooseWhetherToRoll(Game const &game, Dice const &taken) {
  Tile take = game.stealableTile(this, taken);
  if (!take.valid()) {
    take = game.bestRemainingTile(taken);
  }
  if (!take.valid()) {
    cout << "\"No tile to take yet.\"\n";
    return true;
  }
  cout << "\"I can take a tile.\"\n";
  return false;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
callq 0x3a40
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x8b80
testb $0x1, %al
jne 0x11608
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3b80
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x8b80
testb $0x1, %al
jne 0x11630
movq 0x99b3(%rip), %rdi      # 0x1afd0
leaq 0xf5a(%rip), %rsi       # 0x1257e
callq 0x2170
movb $0x1, 0x37(%rsp)
jmp 0x11648
movq 0x9999(%rip), %rdi      # 0x1afd0
leaq 0xf58(%rip), %rsi       # 0x12596
callq 0x2170
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ttencate[P]pickomino/simple_bot.cc
// Function: SimpleBot::chooseSideToTake(Game const&, Dice const&, Dice const&)
DieSide const *SimpleBot::chooseSideToTake(Game const &, Dice const &taken, Dice const &roll) {
  Score maxScore = 0;
  DieSide const *maxSide = nullptr;
  for (DieSide const *side : {DieSide::WORM, DieSide::FIVE, DieSide::FOUR, DieSide::THREE, DieSide::TWO, DieSide::ONE}) {
    if (roll.contains(side) && !taken.contains(side)) {
      if (side == DieSide::WORM && taken.sideCount() >= 2) {
        return side;
      }
      Score score = side->score() * roll[side];
      if (score > maxScore) {
        maxScore = score;
        maxSide = side;
      }
    }
  }
  assert(maxSide);
  cout << "\"Highest value side is " << maxSide->toString() << ".\"\n";
  return maxSide;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdx, 0x88(%rsp)
movq %rcx, 0x80(%rsp)
movl $0x0, 0x7c(%rsp)
movq $0x0, 0x70(%rsp)
leaq 0x9499(%rip), %rax      # 0x1ab38
movq (%rax), %rax
movq %rax, 0x28(%rsp)
leaq 0x9482(%rip), %rax      # 0x1ab30
movq (%rax), %rax
movq %rax, 0x30(%rsp)
leaq 0x946b(%rip), %rax      # 0x1ab28
movq (%rax), %rax
movq %rax, 0x38(%rsp)
leaq 0x9454(%rip), %rax      # 0x1ab20
movq (%rax), %rax
movq %rax, 0x40(%rsp)
leaq 0x943d(%rip), %rax      # 0x1ab18
movq (%rax), %rax
movq %rax, 0x48(%rsp)
leaq 0x9426(%rip), %rax      # 0x1ab10
movq (%rax), %rax
movq %rax, 0x50(%rsp)
leaq 0x28(%rsp), %rax
movq %rax, 0x58(%rsp)
movq $0x6, 0x60(%rsp)
leaq 0x58(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
callq 0x3100
movq %rax, 0x20(%rsp)
movq 0x68(%rsp), %rdi
callq 0x3110
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x11814
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x80(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4af0
testb $0x1, %al
jne 0x11765
jmp 0x117ff
movq 0x88(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4af0
testb $0x1, %al
jne 0x117ff
movq 0x10(%rsp), %rax
leaq 0x93ad(%rip), %rcx      # 0x1ab38
cmpq (%rcx), %rax
jne 0x117b4
movq 0x88(%rsp), %rdi
callq 0x118a0
cmpl $0x2, %eax
jl 0x117b4
movq 0x10(%rsp), %rax
movq %rax, 0xa0(%rsp)
jmp 0x11886
movq 0x10(%rsp), %rdi
callq 0x5840
movl %eax, 0x8(%rsp)
movq 0x80(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2ee0
movl %eax, %ecx
movl 0x8(%rsp), %eax
imull %ecx, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x7c(%rsp), %eax
jle 0x117fd
movl 0xc(%rsp), %eax
movl %eax, 0x7c(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x117ff
jmp 0x11801
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
jmp 0x1172d
cmpq $0x0, 0x70(%rsp)
je 0x1181e
jmp 0x1183d
leaq 0xd87(%rip), %rdi       # 0x125ac
leaq 0xd88(%rip), %rsi       # 0x125b4
movl $0x2a, %edx
leaq 0xd8a(%rip), %rcx       # 0x125c2
callq 0x2100
movq 0x978c(%rip), %rdi      # 0x1afd0
leaq 0xdd4(%rip), %rsi       # 0x1261f
callq 0x2170
movq %rax, (%rsp)
movq 0x70(%rsp), %rdi
callq 0x2f20
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x2170
movq %rax, %rdi
leaq 0xd34(%rip), %rsi       # 0x125a8
callq 0x2170
movq 0x70(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ttencate[P]pickomino/./dice.h
// Function: Dice::sideCount() const
int sideCount() const {
      int n = 0;
      for (DieSide const *side : DieSide::ALL) {
        if ((*this)[side] > 0) {
          n++;
        }
      }
      return n;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0x2c(%rsp)
leaq 0x9957(%rip), %rax      # 0x1b218
movq %rax, 0x20(%rsp)
leaq 0x994b(%rip), %rdi      # 0x1b218
callq 0x2e30
movq %rax, 0x18(%rsp)
leaq 0x993a(%rip), %rdi      # 0x1b218
callq 0x2e60
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2e90
testb $0x1, %al
jne 0x118fd
jmp 0x1193b
leaq 0x18(%rsp), %rdi
callq 0x2ed0
movq (%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
callq 0x2ee0
cmpl $0x0, %eax
jle 0x1192d
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1192f
leaq 0x18(%rsp), %rdi
callq 0x2f30
jmp 0x118e8
movl 0x2c(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: pc260533[P]ITC313-TP2/client.cpp
// Function: Client::viderLePanier()
void Client::viderLePanier() {
    for (int i = 0; i < this->listeProduitsSelectionnes.size(); i++) {
        this->listeProduitsSelectionnes.at(i)->setQuantiteDisponibleProduit(this->listeProduitsSelectionnes.at(i)->getQuantiteDisponibleProduit() + this->listeQuantitesProduitsSelectionnes.at(i));
    }
    this->listeProduitsSelectionnes.clear();
    this->listeQuantitesProduitsSelectionnes.clear();
    this->listeNomProduitsSelectionnes.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x80, %rdi
callq 0xb250
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x8b99
movq -0x18(%rbp), %rdi
addq $0x80, %rdi
movslq -0xc(%rbp), %rsi
callq 0xb270
movq -0x18(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x28(%rbp)
addq $0x80, %rdi
movslq -0xc(%rbp), %rsi
callq 0xb270
movq (%rax), %rdi
callq 0x130d0
movq -0x18(%rbp), %rdi
movl %eax, -0x2c(%rbp)
addq $0x98, %rdi
movslq -0xc(%rbp), %rsi
callq 0xb2b0
movl -0x2c(%rbp), %esi
movq -0x28(%rbp), %rdi
addl (%rax), %esi
callq 0x130f0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8b0b
movq -0x18(%rbp), %rdi
addq $0x80, %rdi
callq 0xb2f0
movq -0x18(%rbp), %rdi
addq $0x98, %rdi
callq 0xb310
movq -0x18(%rbp), %rdi
addq $0xb0, %rdi
callq 0xb330
addq $0x30, %rsp
popq %rbp
retq
nop
// File: pc260533[P]ITC313-TP2/client.cpp
// Function: Client::supprimerProduit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Client::supprimerProduit(std::string nomProduit) {
    for (int i = 0; i < this->listeProduitsSelectionnes.size(); i++) {
        if (this->listeProduitsSelectionnes.at(i)->getTitreProduit() == nomProduit) {
            this->listeProduitsSelectionnes.at(i)->setQuantiteDisponibleProduit(this->listeProduitsSelectionnes.at(i)->getQuantiteDisponibleProduit() + this->listeQuantitesProduitsSelectionnes.at(i));
            this->listeProduitsSelectionnes.erase(this->listeProduitsSelectionnes.begin() + i);
            this->listeQuantitesProduitsSelectionnes.erase(this->listeQuantitesProduitsSelectionnes.begin() + i);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x80(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x90(%rbp)
addq $0x80, %rdi
callq 0xb250
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0x8ff9
movq -0x80(%rbp), %rdi
addq $0x80, %rdi
movslq -0x14(%rbp), %rsi
callq 0xb270
movq (%rax), %rsi
leaq -0x38(%rbp), %rdi
callq 0x13010
movq -0x88(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xb350
movb %al, -0x91(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4200
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x8ed5
jmp 0x8fe9
movq -0x80(%rbp), %rdi
addq $0x80, %rdi
movslq -0x14(%rbp), %rsi
callq 0xb270
movq -0x80(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0xb0(%rbp)
addq $0x80, %rdi
movslq -0x14(%rbp), %rsi
callq 0xb270
movq (%rax), %rdi
callq 0x130d0
movq -0x80(%rbp), %rdi
movl %eax, -0xb4(%rbp)
addq $0x98, %rdi
movslq -0x14(%rbp), %rsi
callq 0xb2b0
movl -0xb4(%rbp), %esi
movq -0xb0(%rbp), %rdi
addl (%rax), %esi
callq 0x130f0
movq -0x80(%rbp), %rdi
movq %rdi, %rax
addq $0x80, %rax
movq %rax, -0xa8(%rbp)
addq $0x80, %rdi
callq 0xb450
movq %rax, -0x50(%rbp)
movslq -0x14(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xb480
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xb4c0
movq -0xa8(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0xb3e0
movq -0x80(%rbp), %rdi
movq %rax, -0x58(%rbp)
movq %rdi, %rax
addq $0x98, %rax
movq %rax, -0xa0(%rbp)
addq $0x98, %rdi
callq 0xb570
movq %rax, -0x70(%rbp)
movslq -0x14(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0xb5a0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xb5e0
movq -0xa0(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0xb500
movq %rax, -0x78(%rbp)
jmp 0x8feb
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8e59
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)