LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ttencate[P]pickomino/dice.cc
// Function: operator>>(std::istream&, Dice&)
istream &operator>>(istream &in, Dice &dice) {
  string input;
  for (DieSide const *side : DieSide::ALL) {
    dice[side] = 0;
  }
  if (in >> input) {
    for (unsigned i = 0; i < input.size(); ++i) {
      char c = input[i];
      for (DieSide const *side : DieSide::ALL) {
        if (c == side->inputChar()) {
          dice[side]++;
          break;
        }
      }
    }
  }
  return in;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq 0x89d0(%rip), %rax      # 0xb1f0
movq 0x89d1(%rip), %rcx      # 0xb1f8
cmpq %rcx, %rax
je 0x283f
movq (%rax), %rdx
movl (%rdx), %edx
movl $0x0, (%r14,%rdx,4)
addq $0x8, %rax
jmp 0x2827
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x21a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x285e
movq (%rsp), %rdi
jmp 0x28ae
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x28ae
movq 0x897d(%rip), %rcx      # 0xb1f0
movq 0x897e(%rip), %rdx      # 0xb1f8
xorl %esi, %esi
cmpq %rdx, %rcx
je 0x28a3
movb (%rdi,%rsi), %r8b
movq %rcx, %r9
movq (%r9), %r10
cmpb 0x10(%r10), %r8b
je 0x289c
addq $0x8, %r9
cmpq %rdx, %r9
jne 0x2888
jmp 0x28a3
movl (%r10), %r8d
incl (%r14,%r8,4)
incq %rsi
movl %esi, %r8d
cmpq %r8, %rax
ja 0x287c
cmpq %r15, %rdi
je 0x28b8
callq 0x2140
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x28d6
callq 0x2140
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/ttencate[P]pickomino/game.cc
// Function: operator<<(std::ostream&, Tile const&)
std::ostream &operator<<(std::ostream &out, Tile const &tile) {
  out << tile.score() << '|';
  for (int i = 0; i < tile.worms(); i++) {
    out << 'W';
  }
  return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
callq 0x2230
leaq 0x7(%rsp), %rsi
movb $0x7c, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2180
cmpl $0x0, 0x4(%r14)
jle 0x2a4b
xorl %ebp, %ebp
leaq 0x6(%rsp), %r15
movb $0x57, 0x6(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2180
incl %ebp
cmpl 0x4(%r14), %ebp
jl 0x2a2e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ttencate[P]pickomino/game.cc
// Function: Game::stealableTile(Strategy const*, Dice const&) const
Tile Game::stealableTile(Strategy const *thief, Dice const &dice) const {
  if (!dice.contains(DieSide::WORM)) {
    return Tile::INVALID;
  }
  Score score = dice.sum();
  for (Player const &player : m_players) {
    if (!player.hasStrategy(thief) && player.hasTiles() && player.topTile().score() == score) {
      return player.topTile();
    }
  }
  return Tile::INVALID;
}

// Assembly:
leaq 0x810f(%rip), %rax      # 0xab70
movq (%rax), %rax
movl (%rax), %eax
cmpl $0x0, (%rdx,%rax,4)
jle 0x2ac2
leaq 0x877d(%rip), %rcx      # 0xb1f0
movq (%rcx), %rax
movq 0x8(%rcx), %r8
xorl %ecx, %ecx
cmpq %r8, %rax
je 0x2a99
movq (%rax), %r9
movl (%r9), %r10d
movl 0x4(%r9), %r9d
imull (%rdx,%r10,4), %r9d
addl %r9d, %ecx
addq $0x8, %rax
jmp 0x2a7c
movq (%rdi), %rdx
movq 0x8(%rdi), %rdi
cmpq %rdi, %rdx
je 0x2ac2
cmpq %rsi, (%rdx)
je 0x2abc
movq 0x18(%rdx), %rax
cmpq %rax, 0x10(%rdx)
je 0x2abc
movq -0x8(%rax), %rax
cmpl %eax, %ecx
je 0x2ac9
addq $0x28, %rdx
jmp 0x2aa0
movq 0x8777(%rip), %rax      # 0xb240
retq
// File: /workspace/github_cpp_makefile_star2_O3/ttencate[P]pickomino/game.cc
// Function: Game::bestRemainingTile(Dice const&) const
Tile Game::bestRemainingTile(Dice const &dice) const {
  if (!dice.contains(DieSide::WORM)) {
    return Tile::INVALID;
  }
  Score score = dice.sum();
  for (Tile tile : m_tiles) {
    if (score >= tile.score()) {
      return tile;
    }
  }
  return Tile::INVALID;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x809c(%rip), %rax      # 0xab70
movq (%rax), %rax
movl (%rax), %eax
cmpl $0x0, (%rsi,%rax,4)
jle 0x2b2a
movq %rdi, %rbx
leaq 0x8707(%rip), %rcx      # 0xb1f0
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
xorl %ebp, %ebp
cmpq %rcx, %rax
je 0x2b0b
movq (%rax), %rdx
movl (%rdx), %edi
movl 0x4(%rdx), %edx
imull (%rsi,%rdi,4), %edx
addl %edx, %ebp
addq $0x8, %rax
jmp 0x2af2
movq 0x38(%rbx), %rax
addq $0x28, %rbx
cmpq %rbx, %rax
je 0x2b2a
movq 0x20(%rax), %rcx
cmpl %ecx, %ebp
jge 0x2b31
movq %rax, %rdi
callq 0x2190
jmp 0x2b13
movq 0x870f(%rip), %rcx      # 0xb240
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ttencate[P]pickomino/game.cc
// Function: Game::playOneTurn()
void Game::playOneTurn() {
  cout << "Remaining tiles:";
  for (auto i = m_tiles.rbegin(); i != m_tiles.rend(); i++) {
    cout << ' ' << *i;
  }
  cout << '\n';
  cout << '\n';

  cout << currentPlayer().name() << "'s turn\n";
  Dice taken = takeTurn(currentPlayer().strategy());
  cout << currentPlayer().name() << " scored " << taken.sum() << '\n';
  takeOrLoseTile(taken);

  m_currentPlayer = (m_currentPlayer + 1) % m_players.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x847c(%rip), %rdi      # 0xafd0
leaq 0x4579(%rip), %rsi      # 0x70d4
movl $0x10, %edx
callq 0x2180
leaq 0x28(%rbx), %r14
cmpq 0x38(%rbx), %r14
je 0x2bb8
movq 0x845a(%rip), %r15      # 0xafd0
leaq 0x1f(%rsp), %r12
movb $0x20, 0x1f(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2180
movq %rax, %r13
movq %r14, %rdi
callq 0x20c0
leaq 0x20(%rax), %rsi
movq %r13, %rdi
callq 0x29f7
movq %r14, %rdi
callq 0x20c0
movq %rax, %r14
cmpq 0x38(%rbx), %rax
jne 0x2b7b
movb $0xa, %bpl
leaq 0x1f(%rsp), %r15
movb %bpl, (%r15)
movq 0x8406(%rip), %r14      # 0xafd0
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
movb %bpl, (%r15)
leaq 0x1f(%rsp), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x2180
movl 0x18(%rbx), %eax
movq (%rbx), %rcx
leaq (%rax,%rax,4), %rax
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x2180
leaq 0x44d1(%rip), %rsi      # 0x70e5
movl $0x8, %edx
movq %rax, %rdi
callq 0x2180
movl 0x18(%rbx), %eax
movq (%rbx), %rcx
leaq (%rax,%rax,4), %rax
movq (%rcx,%rax,8), %rdx
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x2d08
movl 0x18(%rbx), %eax
movq (%rbx), %rcx
leaq (%rax,%rax,4), %rax
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x2180
movq %rax, %r14
leaq 0x448a(%rip), %rsi      # 0x70ee
movl $0x8, %edx
movq %rax, %rdi
callq 0x2180
leaq 0x8578(%rip), %rcx      # 0xb1f0
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
xorl %esi, %esi
cmpq %rcx, %rax
je 0x2c9b
movq (%rax), %rdx
movl (%rdx), %edi
movl 0x4(%rdx), %edx
imull 0x20(%rsp,%rdi,4), %edx
addl %edx, %esi
addq $0x8, %rax
jmp 0x2c81
movq %r14, %rdi
callq 0x2230
leaq 0x1f(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2180
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x2ffe
movl 0x18(%rbx), %eax
incl %eax
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rsi
xorl %edx, %edx
divq %rsi
movl %edx, 0x18(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ttencate[P]pickomino/game.cc
// Function: Game::playToEnd()
void Game::playToEnd() {
  while (!isOver()) {
    playOneTurn();
  }
  cout << '\n';
  cout << "Game over!\n";
  for (Player const &player : m_players) {
    cout << player.name() << '\t' << player.worms() << '\t';
    for (Tile tile : player.tiles()) {
      cout << tile << ' ';
    }
    cout << '\n';
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x48(%rdi)
je 0x33cf
movq %rbx, %rdi
callq 0x2b3c
cmpq $0x0, 0x48(%rbx)
jne 0x33c0
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movq 0x7bf2(%rip), %r14      # 0xafd0
movl $0x1, %edx
movq %r14, %rdi
callq 0x2180
leaq 0x3d05(%rip), %rsi      # 0x70f7
movl $0xb, %edx
movq %r14, %rdi
callq 0x2180
movq (%rbx), %r14
movq 0x8(%rbx), %rax
movq %rax, 0x8(%rsp)
cmpq %rax, %r14
je 0x34e8
movq 0x7bb5(%rip), %rbx      # 0xafd0
leaq 0x10(%rsp), %r13
leaq 0x6(%rsp), %rbp
movq (%r14), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %rbx, %rdi
callq 0x2180
movb $0x9, 0x3(%rsp)
movl $0x1, %edx
movq %rax, %rdi
leaq 0x3(%rsp), %rsi
callq 0x2180
movq 0x10(%r14), %rcx
movq 0x18(%r14), %rdx
xorl %esi, %esi
cmpq %rdx, %rcx
je 0x3467
addl 0x4(%rcx), %esi
addq $0x8, %rcx
jmp 0x3459
movq %rax, %rdi
callq 0x2230
movb $0x9, 0x4(%rsp)
movl $0x1, %edx
movq %rax, %rdi
leaq 0x4(%rsp), %rsi
callq 0x2180
movq 0x10(%r14), %r12
movq 0x18(%r14), %r15
cmpq %r15, %r12
je 0x34c2
movq (%r12), %rax
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x29f7
movb $0x20, 0x6(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x2180
addq $0x8, %r12
jmp 0x348e
movb $0xa, 0x5(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x5(%rsp), %rsi
callq 0x2180
addq $0x28, %r14
cmpq 0x8(%rsp), %r14
jne 0x3425
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
subq %rcx, %rax
je 0x35a0
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rdx
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %esi, %esi
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
leaq (%rsi,%rsi,4), %r9
movq 0x10(%rcx,%r9,8), %rax
movq 0x18(%rcx,%r9,8), %r10
xorl %r9d, %r9d
cmpq %r10, %rax
je 0x3570
movq %rax, %r11
addl 0x4(%r11), %r9d
addq $0x8, %r11
cmpq %r10, %r11
jne 0x354a
cmpl %r8d, %r9d
jle 0x3579
xorl %r9d, %r9d
addl 0x4(%rax), %r9d
addq $0x8, %rax
cmpq %r10, %rax
jne 0x355f
movl %esi, %eax
jmp 0x3593
movl %esi, %eax
testl %r8d, %r8d
jns 0x3589
jmp 0x3593
xorl %r9d, %r9d
addl 0x4(%rax), %r9d
addq $0x8, %rax
cmpq %r10, %rax
jne 0x357c
movl %edi, %eax
cmpl %r8d, %r9d
movl %r8d, %r9d
je 0x35a0
incl %esi
movl %eax, %edi
movl %r9d, %r8d
cmpq %rsi, %rdx
ja 0x3531
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, (%rsp)
movq 0x743e(%rip), %r15      # 0xafd0
leaq 0x36ae(%rip), %rsi      # 0x7247
movl $0x15, %edx
movq %r15, %rdi
callq 0x2180
leaq 0x7643(%rip), %rax      # 0xb1f0
movq (%rax), %r14
movq 0x8(%rax), %r13
cmpq %r13, %r14
je 0x3c0d
movq (%r14), %rax
movl (%rax), %ecx
cmpl $0x0, (%rbx,%rcx,4)
jle 0x3c07
movq (%rsp), %rdx
cmpl $0x0, (%rdx,%rcx,4)
jg 0x3c07
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x3bef
movq %r12, %rdi
callq 0x2080
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2180
jmp 0x3c07
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x2220
addq $0x8, %r14
jmp 0x3bb4
movq 0x73bc(%rip), %rdi      # 0xafd0
leaq 0x3625(%rip), %rsi      # 0x7240
movl $0x2, %edx
callq 0x2180
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x38(%rsp), %r14
movq 0x739b(%rip), %r15      # 0xafe0
leaq 0x8(%rsp), %r12
leaq 0x28(%rsp), %r13
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2270
movq %r14, 0x28(%rsp)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x3dac
movq %r13, %rdi
callq 0x3d16
movq %rax, %rbp
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x3ca5
callq 0x2140
testq %rbp, %rbp
je 0x3c4f
movl (%rbp), %eax
cmpl $0x0, (%rbx,%rax,4)
jle 0x3c4f
movq (%rsp), %rcx
cmpl $0x0, (%rcx,%rax,4)
jg 0x3c4f
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3cd1
callq 0x2140
movq %rbp, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x3cfa
callq 0x2140
jmp 0x3cfa
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3d0e
callq 0x2140
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x1, %ecx
cmpl $0x2, %esi
jl 0x3e67
movl $0x1, %r8d
movl %edi, %eax
cltd
idivl %r8d
imull %eax, %ecx
incl %r8d
decl %edi
cmpl %r8d, %esi
jne 0x3e54
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
testl %edi, %edi
je 0x3e80
movslq %edi, %rcx
movl $0x1, %eax
imulq %rcx, %rax
decq %rcx
jne 0x3e76
retq
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
testl %esi, %esi
je 0x3e9b
movslq %edi, %rcx
movl $0x1, %eax
imulq %rcx, %rax
decl %esi
jne 0x3e92
retq
movl $0x1, %eax
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x455c
movq 0x18(%rax), %rcx
cmpq %rcx, 0x10(%rax)
je 0x3ec8
xorl %eax, %eax
subl -0x4(%rcx), %eax
cvtsi2sd %eax, %xmm0
jmp 0x3ecc
xorpd %xmm0, %xmm0
movsd %xmm0, 0x28(%rbx)
leaq 0x30(%rbx), %rdi
callq 0x469c
addq $0x68, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x463a
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdx), %rax
movq %rax, 0x40(%rsp)
movups (%rdx), %xmm0
movaps %xmm0, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x30(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x3fc8
movsd %xmm0, 0x28(%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4112
movsd %xmm0, 0x20(%rsp)
movq 0x708c(%rip), %rbx      # 0xafd0
leaq 0x335d(%rip), %rsi      # 0x72a8
movl $0x18, %edx
movq %rbx, %rdi
callq 0x2180
movq %rbx, %rdi
movsd 0x28(%rsp), %xmm0
callq 0x21f0
leaq 0x3354(%rip), %r14      # 0x72c1
movl $0x9, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2180
leaq 0x3347(%rip), %rsi      # 0x72cb
movl $0x19, %edx
movq %rbx, %rdi
callq 0x2180
movq %rbx, %rdi
movsd 0x20(%rsp), %xmm0
callq 0x21f0
movl $0x9, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2180
movsd 0x28(%rsp), %xmm0
ucomisd 0x20(%rsp), %xmm0
seta %al
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
movq %rdi, %r12
leaq 0x90(%rsp), %rbx
leaq 0x30(%rdi), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x46e0
testq %rax, %rax
jne 0x40d4
leaq 0x30cd(%rip), %rax      # 0x70d0
movl (%rax), %edi
leaq 0x71e4(%rip), %rax      # 0xb1f0
movq (%rax), %rcx
movq 0x8(%rax), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x4028
movq (%rcx), %rsi
movl (%rsi), %esi
addl (%rbx,%rsi,4), %eax
addq $0x8, %rcx
jmp 0x4015
subl %eax, %edi
jle 0x40f2
movq %r14, 0x20(%rsp)
callq 0x5ee0
movq (%rax), %rbp
movq 0x8(%rax), %r14
xorpd %xmm0, %xmm0
cmpq %r14, %rbp
je 0x40b4
movsd %xmm0, 0x18(%rsp)
leaq 0x30(%rsp), %r13
movups (%rbp), %xmm0
movups 0x10(%rbp), %xmm1
movaps %xmm1, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movupd (%rbx), %xmm0
movupd %xmm0, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x44d0
mulsd 0x28(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rsp)
addq $0x20, %rbp
cmpq %r14, %rbp
jne 0x4055
jmp 0x40ba
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x47c8
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x47c8
movsd (%rax), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x326c(%rip), %rdi      # 0x7365
leaq 0x31f8(%rip), %rsi      # 0x72f8
leaq 0x3270(%rip), %rcx      # 0x7377
movl $0x38, %edx
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r12
leaq 0x6a47(%rip), %rax      # 0xab70
movq (%rax), %r13
movl (%r13), %eax
cmpl $0x0, (%rdx,%rax,4)
jle 0x4241
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x70a9(%rip), %rax      # 0xb1f0
movq (%rax), %rcx
movq 0x8(%rax), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x4169
movq (%rcx), %rsi
movl (%rsi), %edi
movl 0x4(%rsi), %esi
imull (%rbx,%rdi,4), %esi
addl %esi, %eax
addq $0x8, %rcx
jmp 0x4150
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x68(%r12), %r15
movq %r15, %rdi
callq 0x4a86
testq %rax, %rax
jne 0x422e
movsd 0x28(%r12), %xmm0
movsd %xmm0, (%rsp)
movl (%r13), %eax
cmpl $0x0, (%rbx,%rax,4)
jle 0x4218
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2a5a
testq %rax, %rax
js 0x41f3
shrq $0x20, %rax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x3, %rax
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
decl %eax
cvtsi2sd %eax, %xmm1
movsd 0x30bf(%rip), %xmm2     # 0x7298
movapd %xmm2, %xmm3
divsd %xmm1, %xmm3
addsd %xmm2, %xmm3
mulsd %xmm0, %xmm3
maxsd (%rsp), %xmm3
movsd %xmm3, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2aca
testq %rax, %rax
js 0x4218
shrq $0x20, %rax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
maxsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
leaq 0xc(%rsp), %rsi
movq %r15, %rdi
callq 0x4ae2
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
leaq 0xc(%rsp), %rsi
movq %r15, %rdi
callq 0x4ae2
movsd (%rax), %xmm0
jmp 0x4248
movsd 0x28(%r12), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, 0x38(%rsp)
movq %rdi, 0x30(%rsp)
leaq 0x6f7b(%rip), %rax      # 0xb1f0
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x43d6
movq %rcx, %rbx
movq %rdx, %r14
movsd 0x300d(%rip), %xmm0     # 0x72a0
movsd %xmm0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x6d27(%rip), %rbp      # 0xafd0
movq (%r12), %r15
movl (%r15), %eax
cmpl $0x0, (%rbx,%rax,4)
jle 0x43b0
cmpl $0x0, (%r14,%rax,4)
jg 0x43b0
movq 0x10(%r14), %rax
movq %rax, 0x50(%rsp)
movups (%r14), %xmm0
movaps %xmm0, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movapd 0x40(%rsp), %xmm0
movupd %xmm0, (%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x43f6
movsd %xmm0, 0x28(%rsp)
ucomisd 0x20(%rsp), %xmm0
movq 0x18(%rsp), %rax
cmovaq %r15, %rax
movq %rax, 0x18(%rsp)
movl $0xd, %edx
movq %rbp, %rdi
leaq 0x2fbb(%rip), %rsi      # 0x72e5
callq 0x2180
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x4350
movq %r15, %rdi
callq 0x2080
movq %rbp, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2180
jmp 0x4368
movq (%rbp), %rax
movq -0x18(%rax), %rax
leaq (%rax,%rbp), %rdi
movl 0x20(%rbp,%rax), %esi
orl $0x1, %esi
callq 0x2220
movsd 0x28(%rsp), %xmm0
maxsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0xb, %edx
movq %rbp, %rdi
leaq 0x2f2c(%rip), %rsi      # 0x72b5
callq 0x2180
movq %rbp, %rdi
movsd 0x28(%rsp), %xmm0
callq 0x21f0
movl $0x9, %edx
movq %rax, %rdi
leaq 0x2f16(%rip), %rsi      # 0x72c1
callq 0x2180
addq $0x8, %r12
cmpq %r13, %r12
jne 0x42a9
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x43d6
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2f16(%rip), %rdi      # 0x72f3
leaq 0x2f14(%rip), %rsi      # 0x72f8
leaq 0x2f1c(%rip), %rcx      # 0x7307
movl $0x27, %edx
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd 0x28(%rdi), %xmm0
leaq 0x6d06(%rip), %rax      # 0xb1f0
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x454d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x60(%rsp), %rbp
movq (%r12), %rcx
movl (%rcx), %eax
cmpl $0x0, (%rbx,%rax,4)
jle 0x4544
cmpl $0x0, (%rbp,%rax,4)
jg 0x4544
movq 0x10(%rbp), %rax
movq %rax, 0x10(%rsp)
movsd %xmm0, 0x20(%rsp)
movupd (%rbp), %xmm0
movupd %xmm0, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x43f6
maxsd 0x20(%rsp), %xmm0
addq $0x8, %r12
cmpq %r13, %r12
jne 0x4504
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
cmpq %rcx, %rax
je 0x4576
cmpq %rsi, (%rax)
je 0x4574
addq $0x28, %rax
jmp 0x4564
popq %rcx
retq
leaq 0x2ed0(%rip), %rdi      # 0x744d
leaq 0x2ecf(%rip), %rsi      # 0x7453
leaq 0x2ed1(%rip), %rcx      # 0x745c
movl $0x97, %edx
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x549b(%rip), %r12      # 0xb1f0
movq (%r12), %rax
movq 0x8(%r12), %rcx
xorl %ebp, %ebp
cmpq %rcx, %rax
je 0x5d73
movq (%rax), %rdx
movl (%rdx), %edx
addl (%rbx,%rdx,4), %ebp
addq $0x8, %rax
jmp 0x5d60
movl %ebp, %edi
callq 0x3e6a
movq %rax, %r14
movl $0x6, %edi
movl %ebp, %esi
callq 0x3e86
movq %rax, %r15
movq (%r12), %r13
movq 0x8(%r12), %r12
cmpq %r12, %r13
je 0x5db2
movq (%r13), %rax
movl (%rax), %eax
movl (%rbx,%rax,4), %edi
callq 0x3e6a
imulq %rax, %r15
addq $0x8, %r13
jmp 0x5d95
cvtsi2sd %r14, %xmm0
cvtsi2sd %r15, %xmm1
divsd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xa0(%rsp), %r14
leaq 0x53da(%rip), %rax      # 0xb1f0
movq 0x8(%rax), %rax
addq $-0x8, %rax
cmpq %rdx, %rax
je 0x5e78
testl %ebp, %ebp
js 0x5ed0
leaq 0x8(%r15), %r12
xorl %r13d, %r13d
movq 0x10(%r14), %rax
movq %rax, 0x30(%rsp)
movups (%r14), %xmm0
movaps %xmm0, 0x20(%rsp)
movq (%r15), %rax
movl (%rax), %eax
movl %ebp, 0x20(%rsp,%rax,4)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movl %r13d, %esi
movq %r12, %rdx
callq 0x5df1
incl %r13d
addl $-0x1, %ebp
jb 0x5e32
jmp 0x5ed0
movq (%r15), %rax
movl (%rax), %eax
movl %ebp, (%r14,%rax,4)
movq 0x10(%r14), %rax
movq %rax, 0x50(%rsp)
movups (%r14), %xmm0
movaps %xmm0, 0x40(%rsp)
movq %r14, %rdi
callq 0x5d40
movsd %xmm0, 0x58(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5ec3
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x20, 0x8(%rbx)
jmp 0x5ed0
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x60b4
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edi, %ebx
movb 0x5377(%rip), %al       # 0xb268
testb %al, %al
je 0x5f9d
movq 0x5358(%rip), %rax      # 0xb258
movq 0x5349(%rip), %r15      # 0xb250
subq %r15, %rax
sarq $0x3, %rax
movl %ebx, %r14d
cmpq %r14, %rax
ja 0x5f2c
leal 0x1(%rbx), %esi
leaq 0x5330(%rip), %rdi      # 0xb250
callq 0x6082
movq 0x5324(%rip), %r15      # 0xb250
movq (%r15,%r14,8), %rax
testq %rax, %rax
jne 0x5f93
movl $0x18, %edi
callq 0x2160
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movq %rax, (%r15,%r14,8)
movq 0x52fa(%rip), %rax      # 0xb250
movq (%rax,%r14,8), %rdi
movq %rcx, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
leaq 0x5285(%rip), %rax      # 0xb1f0
movq (%rax), %rdx
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movl %ebx, %esi
callq 0x5df1
movq 0x52c1(%rip), %rax      # 0xb250
movq (%rax,%r14,8), %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x22f0
jmp 0x5ef9
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testl %esi, %esi
jle 0x6067
movl %esi, %ebp
leaq 0x5238(%rip), %r14      # 0xb270
leaq 0x65b9(%rip), %r15      # 0xc5f8
leaq 0x51aa(%rip), %r12      # 0xb1f0
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x636a
cltq
movq (%r12), %rcx
movq (%rcx,%rax,8), %rax
movl (%rax), %eax
incl (%rbx,%rax,4)
decl %ebp
jne 0x6046
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
movq %r14, %rdi
callq 0x2a5a
testq %rax, %rax
jns 0x65f4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2aca
testq %rax, %rax
js 0x6616
movq 0x49d5(%rip), %rdi      # 0xafd0
leaq 0x1090(%rip), %rsi      # 0x7692
movl $0x15, %edx
callq 0x2180
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x49b3(%rip), %rdi      # 0xafd0
leaq 0x1056(%rip), %rsi      # 0x767a
movl $0x17, %edx
callq 0x2180
movb $0x1, %al
jmp 0x660e
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
leaq 0x452b(%rip), %rax      # 0xab70
movq (%rax), %rax
movq %rax, (%rsp)
leaq 0x4515(%rip), %rsi      # 0xab68
movq (%rsi), %rsi
movq %rsi, 0x8(%rsp)
leaq 0x44fe(%rip), %rsi      # 0xab60
movq (%rsi), %rsi
movq %rsi, 0x10(%rsp)
leaq 0x44e7(%rip), %rsi      # 0xab58
movq (%rsi), %rsi
movq %rsi, 0x18(%rsp)
leaq 0x44d0(%rip), %rsi      # 0xab50
movq (%rsi), %rsi
movq %rsi, 0x20(%rsp)
leaq 0x44b9(%rip), %rsi      # 0xab48
movq (%rsi), %rsi
movq %rsi, 0x28(%rsp)
leaq 0x4b52(%rip), %rdi      # 0xb1f0
movq (%rdi), %rsi
movq 0x8(%rdi), %rdi
xorl %r8d, %r8d
xorl %ebx, %ebx
xorl %r9d, %r9d
movq (%rsp,%r9), %r10
movl (%r10), %r14d
movl (%rcx,%r14,4), %r11d
testl %r11d, %r11d
jle 0x6713
cmpl $0x0, (%rdx,%r14,4)
jg 0x6713
cmpq %rdi, %rsi
sete %bpl
cmpq %rax, %r10
setne %r14b
orb %bpl, %r14b
jne 0x6703
xorl %ebp, %ebp
movq %rsi, %r14
movq (%r14), %r15
movl (%r15), %r15d
xorl %r12d, %r12d
cmpl $0x0, (%rdx,%r15,4)
setg %r12b
addl %r12d, %ebp
addq $0x8, %r14
cmpq %rdi, %r14
jne 0x66dc
cmpl $0x1, %ebp
ja 0x67a6
imull 0x4(%r10), %r11d
cmpl %r8d, %r11d
cmovgq %r10, %rbx
cmovgl %r11d, %r8d
addq $0x8, %r9
cmpq $0x30, %r9
jne 0x66ad
testq %rbx, %rbx
je 0x67ab
movq 0x48a3(%rip), %r14      # 0xafd0
leaq 0xfe7(%rip), %rsi       # 0x771b
movl $0x17, %edx
movq %r14, %rdi
callq 0x2180
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x6766
movq %r15, %rdi
callq 0x2080
movq 0x4877(%rip), %rdi      # 0xafd0
movq %r15, %rsi
movq %rax, %rdx
callq 0x2180
jmp 0x677e
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2220
movq 0x484b(%rip), %rdi      # 0xafd0
leaq 0xf18(%rip), %rsi       # 0x76a4
movl $0x3, %edx
callq 0x2180
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r10, %rbx
jmp 0x6796
leaq 0xef6(%rip), %rdi       # 0x76a8
leaq 0xef7(%rip), %rsi       # 0x76b0
leaq 0xefe(%rip), %rcx       # 0x76be
movl $0x2a, %edx
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x80(%rdi), %rax
movq 0x88(%rdi), %rcx
cmpq %rax, %rcx
je 0x721c
xorl %r14d, %r14d
movq (%rax,%r14,8), %r15
movq %r15, %rdi
callq 0xc5bc
movq 0x98(%rbx), %rcx
movq 0xa0(%rbx), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %r14, %rdx
jbe 0x725a
addl (%rcx,%r14,4), %eax
movq %r15, %rdi
movl %eax, %esi
callq 0xc5c0
incq %r14
movq 0x80(%rbx), %rax
movq 0x88(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r14, %rdx
ja 0x71c8
cmpq %rax, %rcx
je 0x7228
movq %rax, 0x88(%rbx)
movq 0x98(%rbx), %rax
cmpq %rax, 0xa0(%rbx)
je 0x723f
movq %rax, 0xa0(%rbx)
movq 0xb0(%rbx), %rsi
addq $0xb0, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x9fae
leaq 0xb58d(%rip), %rdi      # 0x127ee
movq %r14, %rsi
xorl %eax, %eax
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x10(%rsp)
movq 0x80(%rdi), %rax
cmpq %rax, 0x88(%rdi)
je 0x7692
movq %rdi, %r15
movq $-0x4, %r14
movl $0x4, %r12d
movq $-0x8, %r13
movl $0x8, %ebp
xorl %ebx, %ebx
movq %r13, (%rsp)
movq %r14, 0x8(%rsp)
movq (%rax,%rbx,8), %rsi
leaq 0x18(%rsp), %rdi
callq 0xc560
movq 0x20(%rsp), %rdx
movq 0x10(%rsp), %rax
cmpq 0x8(%rax), %rdx
jne 0x753a
movq 0x18(%rsp), %r13
testq %rdx, %rdx
je 0x7544
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq %r13, %rdi
callq 0x3240
testl %eax, %eax
sete %r14b
jmp 0x7547
movq 0x18(%rsp), %r13
xorl %r14d, %r14d
jmp 0x7547
movb $0x1, %r14b
leaq 0x28(%rsp), %rax
cmpq %rax, %r13
je 0x7561
movq 0x28(%rsp), %rsi
incq %rsi
movq %r13, %rdi
callq 0x3230
movq 0x80(%r15), %rax
movq 0x88(%r15), %rdx
testb %r14b, %r14b
je 0x75ff
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rbx, %rdx
jbe 0x76a1
movq (%rax,%rbx,8), %r13
movq %r13, %rdi
callq 0xc5bc
movq 0x98(%r15), %rcx
movq 0xa0(%r15), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rbx, %rdx
jbe 0x76a1
addl (%rcx,%rbx,4), %eax
movq %r13, %rdi
movl %eax, %esi
callq 0xc5c0
movq 0x80(%r15), %rax
movq 0x88(%r15), %rdx
leaq (%rax,%rbp), %rcx
cmpq %rdx, %rcx
je 0x760a
leaq (%rax,%rbx,8), %rdi
leaq (%rax,%rbx,8), %rsi
addq $0x8, %rsi
subq %rax, %rdx
movq (%rsp), %r13
addq %r13, %rdx
callq 0x3390
movq 0x88(%r15), %rdx
movq 0x8(%rsp), %r14
jmp 0x7613
movq 0x8(%rsp), %r14
movq (%rsp), %r13
jmp 0x766f
movq 0x8(%rsp), %r14
movq (%rsp), %r13
addq $-0x8, %rdx
movq %rdx, 0x88(%r15)
movq 0x98(%r15), %rcx
movq 0xa0(%r15), %rax
leaq (%rcx,%r12), %rsi
cmpq %rax, %rsi
je 0x765d
leaq (%rcx,%rbx,4), %rdi
leaq (%rcx,%rbx,4), %rsi
addq $0x4, %rsi
subq %rcx, %rax
addq %r14, %rax
movq %rax, %rdx
callq 0x3390
movq 0x88(%r15), %rdx
movq 0xa0(%r15), %rax
addq $-0x4, %rax
movq %rax, 0xa0(%r15)
movq 0x80(%r15), %rax
incq %rbx
subq %rax, %rdx
sarq $0x3, %rdx
addq $-0x4, %r14
addq $0x4, %r12
addq $-0x8, %r13
addq $0x8, %rbp
cmpq %rbx, %rdx
ja 0x74f1
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb146(%rip), %rdi      # 0x127ee
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O3/pc260533[P]ITC313-TP2/magasin.cpp
// Function: Magasin::getClientAvecNomPrenomClient(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Client *Magasin::getClientAvecNomPrenomClient(std::string nomClient, std::string prenomClient) {
    Client *res = nullptr;
    for (Client *client : this->listeClients) {
        if ((client->getNomClient() == nomClient) && (client->getPrenomClient() == prenomClient)) {
            res = client;
        }
    }
    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, 0x8(%rsp)
movq 0x50(%rdi), %rbx
movq 0x58(%rdi), %rax
movq %rax, 0x30(%rsp)
cmpq %rax, %rbx
je 0xd9a2
movq %rsi, %r14
leaq 0x20(%rsp), %r13
xorl %r15d, %r15d
movq (%rbx), %rbp
leaq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0x6d96
movq 0x18(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0xd903
testq %rdx, %rdx
je 0xd908
movq (%r14), %rsi
movq 0x10(%rsp), %rdi
callq 0x3240
testl %eax, %eax
je 0xd908
xorl %r12d, %r12d
jmp 0xd973
leaq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0x6d68
movq 0x40(%rsp), %rdx
movq 0x8(%rsp), %rax
cmpq 0x8(%rax), %rdx
jne 0xd947
movq 0x38(%rsp), %r13
testq %rdx, %rdx
je 0xd951
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq %r13, %rdi
callq 0x3240
testl %eax, %eax
sete %r12b
jmp 0xd954
movq 0x38(%rsp), %r13
xorl %r12d, %r12d
jmp 0xd954
movb $0x1, %r12b
leaq 0x48(%rsp), %rax
cmpq %rax, %r13
je 0xd96e
movq 0x48(%rsp), %rsi
incq %rsi
movq %r13, %rdi
callq 0x3230
leaq 0x20(%rsp), %r13
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xd98a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3230
testb %r12b, %r12b
cmovneq %rbp, %r15
addq $0x8, %rbx
cmpq 0x30(%rsp), %rbx
jne 0xd8d2
jmp 0xd9a5
xorl %r15d, %r15d
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xd9d1
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/pc260533[P]ITC313-TP2/magasin.cpp
// Function: Magasin::~Magasin()
Magasin::~Magasin() {
    for (Produit *produit : this->listeProduits) {
        delete produit;
    }
    for (Client *client : this->listeClients) {
        delete client;
    }
    for (Commande *commande : this->listeCommandes) {
        delete commande;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xa1b3(%rip), %rax      # 0x17c10
movq %rax, (%rdi)
movq 0x38(%rdi), %r14
movq 0x40(%rdi), %r15
cmpq %r15, %r14
je 0xda81
movq (%r14), %rdi
testq %rdi, %rdi
je 0xda7b
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0xda68
movq 0x50(%rbx), %r14
movq 0x58(%rbx), %r15
cmpq %r15, %r14
je 0xdaa2
movq (%r14), %rdi
testq %rdi, %rdi
je 0xda9c
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0xda89
movq 0x68(%rbx), %r14
movq 0x70(%rbx), %r15
cmpq %r15, %r14
je 0xdaca
movq (%r14), %rdi
testq %rdi, %rdi
je 0xdabd
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0xdaaf
movq 0x68(%rbx), %r14
testq %r14, %r14
je 0xdade
movq 0x78(%rbx), %rsi
subq %r14, %rsi
movq %r14, %rdi
callq 0x3230
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0xdaf3
movq 0x60(%rbx), %rsi
subq %rdi, %rsi
callq 0x3230
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xdb08
movq 0x48(%rbx), %rsi
subq %rdi, %rsi
callq 0x3230
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x10c3a
nop
// File: /workspace/github_cpp_makefile_star2_O3/pc260533[P]ITC313-TP2/magasin.cpp
// Function: Magasin::afficherProduitAvecNom(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Magasin::afficherProduitAvecNom(std::string nomProduit) {
    std::cout << "Le produit " << nomProduit << " est :" << std::endl;
    for (Produit *produit : this->listeProduits) {
        if (produit->getTitreProduit() == nomProduit) {
            std::cout << "Le produit est : " << std::endl << *produit << std::endl;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0xa257(%rip), %r14      # 0x17fd0
leaq 0x4cbe(%rip), %rsi      # 0x12a3e
movl $0xb, %edx
movq %r14, %rdi
callq 0x3280
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x3280
movq %rax, %r12
leaq 0x4d27(%rip), %rsi      # 0x12acd
movl $0x6, %edx
movq %rax, %rdi
callq 0x3280
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3200
movsbl %al, %esi
movq %r12, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
movq 0x38(%r15), %r12
movq 0x40(%r15), %r15
cmpq %r15, %r12
je 0xded1
movq (%r12), %r13
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0xc560
movq 0x10(%rsp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0xde25
movq 0x8(%rsp), %rbp
testq %rdx, %rdx
je 0xde2f
movq (%rbx), %rsi
movq %rbp, %rdi
callq 0x3240
testl %eax, %eax
sete %r14b
jmp 0xde32
movq 0x8(%rsp), %rbp
xorl %r14d, %r14d
jmp 0xde32
movb $0x1, %r14b
leaq 0x18(%rsp), %rax
cmpq %rax, %rbp
je 0xde4c
movq 0x18(%rsp), %rsi
incq %rsi
movq %rbp, %rdi
callq 0x3230
testb %r14b, %r14b
je 0xdec8
movl $0x11, %edx
movq 0xa173(%rip), %r14      # 0x17fd0
movq %r14, %rdi
leaq 0x4bc5(%rip), %rsi      # 0x12a2c
callq 0x3280
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3200
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
movq %rax, %rdi
movq %r13, %rsi
callq 0xff01
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x3200
movsbl %al, %esi
movq %r13, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
addq $0x8, %r12
jmp 0xdde3
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pc260533[P]ITC313-TP2/magasin.cpp
// Function: Magasin::afficherClient(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Magasin::afficherClient(std::string nomClient, std::string prenomClient) {
    std::cout << "Les clients dont le nom est " << nomClient << " est :" << std::endl;
    for (Client *client : this->listeClients) {
        if ((client->getNomClient() == nomClient) && (client->getPrenomClient() == prenomClient)) {
            std::cout << "Le client est : " << std::endl << *client << std::endl;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, (%rsp)
movq %rsi, %r14
movq %rdi, %r12
movq 0x9dff(%rip), %rbx      # 0x17fd0
leaq 0x489e(%rip), %rsi      # 0x12a76
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x3280
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x3280
movq %rax, %r13
leaq 0x48cf(%rip), %rsi      # 0x12acd
movl $0x6, %edx
movq %rax, %rdi
callq 0x3280
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x3200
movsbl %al, %esi
movq %r13, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
movq 0x50(%r12), %rbx
movq 0x58(%r12), %r12
cmpq %r12, %rbx
je 0xe38a
leaq 0x18(%rsp), %rbp
movq (%rbx), %r13
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x6d96
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0xe27c
testq %rdx, %rdx
je 0xe281
movq (%r14), %rsi
movq 0x8(%rsp), %rdi
callq 0x3240
testl %eax, %eax
je 0xe281
xorl %r15d, %r15d
jmp 0xe2ea
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0x6d68
movq 0x30(%rsp), %rdx
movq (%rsp), %rax
cmpq 0x8(%rax), %rdx
jne 0xe2be
movq 0x28(%rsp), %rbp
testq %rdx, %rdx
je 0xe2c8
movq (%rsp), %rax
movq (%rax), %rsi
movq %rbp, %rdi
callq 0x3240
testl %eax, %eax
sete %r15b
jmp 0xe2cb
movq 0x28(%rsp), %rbp
xorl %r15d, %r15d
jmp 0xe2cb
movb $0x1, %r15b
leaq 0x38(%rsp), %rax
cmpq %rax, %rbp
je 0xe2e5
movq 0x38(%rsp), %rsi
incq %rsi
movq %rbp, %rdi
callq 0x3230
leaq 0x18(%rsp), %rbp
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xe301
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3230
testb %r15b, %r15b
je 0xe37d
movl $0x10, %edx
movq 0x9cbe(%rip), %r15      # 0x17fd0
movq %r15, %rdi
leaq 0x4749(%rip), %rsi      # 0x12a65
callq 0x3280
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3200
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
movq %rax, %rdi
movq %r13, %rsi
callq 0x1014f
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x3200
movsbl %al, %esi
movq %r13, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
addq $0x8, %rbx
cmpq %r12, %rbx
jne 0xe24b
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xe3b3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x33e0
nop