LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33df
movq %rbx, %rdi
callq 0x2b66
cmpq $0x0, 0x48(%rbx)
jne 0x33d0
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movq 0x7be2(%rip), %r14      # 0xafd0
movl $0x1, %edx
movq %r14, %rdi
callq 0x2180
leaq 0x3d05(%rip), %rsi      # 0x7107
movl $0xb, %edx
movq %r14, %rdi
callq 0x2180
movq (%rbx), %r14
movq 0x8(%rbx), %rax
movq %rax, 0x8(%rsp)
cmpq %rax, %r14
je 0x34f8
movq 0x7ba5(%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 0x3477
addl 0x4(%rcx), %esi
addq $0x8, %rcx
jmp 0x3469
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 0x34d2
movq (%r12), %rax
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2a03
movb $0x20, 0x6(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x2180
addq $0x8, %r12
jmp 0x349e
movb $0xa, 0x5(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x5(%rsp), %rsi
callq 0x2180
addq $0x28, %r14
cmpq 0x8(%rsp), %r14
jne 0x3435
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x35a5
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %esi, %esi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
leaq (%rsi,%rsi,4), %r9
movq 0x10(%rcx,%r9,8), %r8
movq 0x18(%rcx,%r9,8), %r9
movl $0x0, %r10d
cmpq %r9, %r8
je 0x356c
xorl %r10d, %r10d
movq %r8, %r11
addl 0x4(%r11), %r10d
addq $0x8, %r11
cmpq %r9, %r11
jne 0x355f
cmpl %edi, %r10d
jle 0x3582
xorl %edi, %edi
cmpq %r9, %r8
je 0x3594
addl 0x4(%r8), %edi
addq $0x8, %r8
jmp 0x3573
xorl %r10d, %r10d
cmpq %r9, %r8
je 0x3598
addl 0x4(%r8), %r10d
addq $0x8, %r8
jmp 0x3585
movl %esi, %eax
jmp 0x359d
cmpl %edi, %r10d
je 0x35a5
incl %esi
cmpq %rsi, %rdx
ja 0x3540
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7402(%rip), %r15      # 0xafd0
leaq 0x3682(%rip), %rsi      # 0x7257
movl $0x15, %edx
movq %r15, %rdi
callq 0x2180
leaq 0x7607(%rip), %rax      # 0xb1f0
movq (%rax), %r14
movq 0x8(%rax), %r13
cmpq %r13, %r14
je 0x3c49
movq (%r14), %rax
movl (%rax), %ecx
cmpl $0x0, (%rbx,%rcx,4)
jle 0x3c43
movq (%rsp), %rdx
cmpl $0x0, (%rdx,%rcx,4)
jg 0x3c43
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x3c2b
movq %r12, %rdi
callq 0x2080
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2180
jmp 0x3c43
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 0x3bf0
movq 0x7380(%rip), %rdi      # 0xafd0
leaq 0x35f9(%rip), %rsi      # 0x7250
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 0x735f(%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 0x3dea
movq %r13, %rdi
callq 0x3d52
movq %rax, %rbp
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x3ce1
callq 0x2140
testq %rbp, %rbp
je 0x3c8b
movl (%rbp), %eax
cmpl $0x0, (%rbx,%rax,4)
jle 0x3c8b
movq (%rsp), %rcx
cmpl $0x0, (%rcx,%rax,4)
jg 0x3c8b
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3d0d
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 0x3d36
callq 0x2140
jmp 0x3d36
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3d4a
callq 0x2140
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3e9f
movl $0x1, %r8d
movl %edi, %eax
cltd
idivl %r8d
imull %eax, %ecx
incl %r8d
decl %edi
cmpl %r8d, %esi
jne 0x3e8c
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3eb8
movslq %edi, %rcx
movl $0x1, %eax
imulq %rcx, %rax
decq %rcx
jne 0x3eae
retq
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3ed3
movslq %edi, %rcx
movl $0x1, %eax
imulq %rcx, %rax
decl %esi
jne 0x3eca
retq
movl $0x1, %eax
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 0x45f4
movq 0x18(%rax), %rcx
cmpq %rcx, 0x10(%rax)
je 0x3f00
xorl %eax, %eax
subl -0x4(%rcx), %eax
cvtsi2sd %eax, %xmm0
jmp 0x3f04
xorpd %xmm0, %xmm0
movsd %xmm0, 0x28(%rbx)
leaq 0x30(%rbx), %rdi
callq 0x4750
addq $0x68, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x46ee
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4000
movsd %xmm0, 0x28(%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x414a
movsd %xmm0, 0x20(%rsp)
movq 0x7054(%rip), %rbx      # 0xafd0
leaq 0x3335(%rip), %rsi      # 0x72b8
movl $0x18, %edx
movq %rbx, %rdi
callq 0x2180
movq %rbx, %rdi
movsd 0x28(%rsp), %xmm0
callq 0x21f0
leaq 0x332c(%rip), %r14      # 0x72d1
movl $0x9, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2180
leaq 0x331f(%rip), %rsi      # 0x72db
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_O1/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 0x4794
testq %rax, %rax
jne 0x410c
leaq 0x30a5(%rip), %rax      # 0x70e0
movl (%rax), %edi
leaq 0x71ac(%rip), %rax      # 0xb1f0
movq (%rax), %rcx
movq 0x8(%rax), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x4060
movq (%rcx), %rsi
movl (%rsi), %esi
addl (%rbx,%rsi,4), %eax
addq $0x8, %rcx
jmp 0x404d
subl %eax, %edi
jle 0x412a
movq %r14, 0x20(%rsp)
callq 0x5fc8
movq (%rax), %rbp
movq 0x8(%rax), %r14
xorpd %xmm0, %xmm0
cmpq %r14, %rbp
je 0x40ec
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 0x4568
mulsd 0x28(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rsp)
addq $0x20, %rbp
cmpq %r14, %rbp
jne 0x408d
jmp 0x40f2
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x48cc
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x48cc
movsd (%rax), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3244(%rip), %rdi      # 0x7375
leaq 0x31d0(%rip), %rsi      # 0x7308
leaq 0x3248(%rip), %rcx      # 0x7387
movl $0x38, %edx
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x69d6(%rip), %rax      # 0xab38
movq (%rax), %r8
movl (%r8), %eax
cmpl $0x0, (%rdx,%rax,4)
jle 0x41fc
movq %rdx, %rbx
leaq 0x7074(%rip), %rcx      # 0xb1f0
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
xorl %r9d, %r9d
cmpq %rcx, %rax
je 0x41a0
movq (%rax), %rdx
movl (%rdx), %edi
movl 0x4(%rdx), %edx
imull (%rbx,%rdi,4), %edx
addl %edx, %r9d
addq $0x8, %rax
jmp 0x4186
movl %r9d, 0x14(%rsp)
movslq %r9d, %rax
movq 0x68(%rsi), %rdi
movq 0x70(%rsi), %r10
xorl %r12d, %r12d
xorl %edx, %edx
divq %r10
movq (%rdi,%rdx,8), %rax
testq %rax, %rax
je 0x4209
movq (%rax), %r11
movq %rax, %r12
cmpl 0x8(%r11), %r9d
je 0x4209
movq %rdx, %rcx
movq %r11, %r15
movq (%r11), %r11
testq %r11, %r11
je 0x4206
movslq 0x8(%r11), %rdi
movq %rdi, %rax
xorl %edx, %edx
divq %r10
movl $0x0, %r12d
cmpq %rcx, %rdx
jne 0x4209
movq %r15, %r12
cmpl %edi, %r9d
jne 0x41d0
jmp 0x4209
movsd 0x28(%rsi), %xmm0
jmp 0x42d6
xorl %r12d, %r12d
leaq 0x68(%rsi), %r15
testq %r12, %r12
je 0x421d
cmpq $0x0, (%r12)
jne 0x42c5
movsd 0x28(%rsi), %xmm0
movsd %xmm0, 0x8(%rsp)
movl (%r8), %eax
cmpl $0x0, (%rbx,%rax,4)
jle 0x42ae
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2a66
testq %rax, %rax
js 0x4287
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 0x303d(%rip), %xmm2     # 0x72a8
movapd %xmm2, %xmm3
divsd %xmm1, %xmm3
addsd %xmm2, %xmm3
mulsd %xmm0, %xmm3
maxsd 0x8(%rsp), %xmm3
movsd %xmm3, 0x8(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2af4
testq %rax, %rax
js 0x42ae
shrq $0x20, %rax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
maxsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x14(%rsp), %rsi
movq %r15, %rdi
callq 0x4bde
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
leaq 0x14(%rsp), %rsi
movq %r15, %rdi
callq 0x4bde
movsd (%rax), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6eef(%rip), %rax      # 0xb1f0
movq (%rax), %r13
movq 0x8(%rax), %rbp
cmpq %rbp, %r13
je 0x444d
movq %rcx, %rbx
movq %rdx, %r15
movsd 0x2f91(%rip), %xmm0     # 0x72b0
movsd %xmm0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x6c9b(%rip), %r14      # 0xafd0
movq (%r13), %r12
movl (%r12), %eax
cmpl $0x0, (%rbx,%rax,4)
jle 0x443e
cmpl $0x0, (%r15,%rax,4)
jg 0x443e
movq 0x10(%r15), %rax
movq %rax, 0x50(%rsp)
movups (%r15), %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 %r12, %rcx
callq 0x448e
movsd %xmm0, 0x28(%rsp)
ucomisd 0x20(%rsp), %xmm0
movq 0x18(%rsp), %rax
cmovaq %r12, %rax
movq %rax, 0x18(%rsp)
movl $0xd, %edx
movq %r14, %rdi
leaq 0x2f3e(%rip), %rsi      # 0x72f5
callq 0x2180
movq 0x8(%r12), %r12
testq %r12, %r12
je 0x43de
movq %r12, %rdi
callq 0x2080
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2180
jmp 0x43f6
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2220
movsd 0x28(%rsp), %xmm0
maxsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0xb, %edx
movq %r14, %rdi
leaq 0x2eae(%rip), %rsi      # 0x72c5
callq 0x2180
movq %r14, %rdi
movsd 0x28(%rsp), %xmm0
callq 0x21f0
movl $0x9, %edx
movq %rax, %rdi
leaq 0x2e98(%rip), %rsi      # 0x72d1
callq 0x2180
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x4335
jmp 0x4456
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x446f
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e8d(%rip), %rdi      # 0x7303
leaq 0x2e8b(%rip), %rsi      # 0x7308
leaq 0x2e93(%rip), %rcx      # 0x7317
movl $0x27, %edx
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6c6e(%rip), %rax      # 0xb1f0
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x45e5
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 0x45dc
cmpl $0x0, (%rbp,%rax,4)
jg 0x45dc
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 0x448e
maxsd 0x20(%rsp), %xmm0
addq $0x8, %r12
cmpq %r13, %r12
jne 0x459c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %rdx
cmpq %rdx, %rax
sete %cl
je 0x4624
cmpq %rsi, (%rax)
je 0x4624
leaq 0x28(%rax), %rdi
cmpq %rdx, %rdi
sete %cl
je 0x4624
cmpq %rsi, (%rdi)
cmoveq %rdi, %rax
leaq 0x28(%rdi), %rdi
jne 0x460d
jmp 0x4624
testb %cl, %cl
jne 0x462a
popq %rcx
retq
leaq 0x2e2c(%rip), %rdi      # 0x745d
leaq 0x2e2b(%rip), %rsi      # 0x7463
leaq 0x2e2d(%rip), %rcx      # 0x746c
movl $0x97, %edx
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x53bb(%rip), %r12      # 0xb1f0
movq (%r12), %rax
movq 0x8(%r12), %rcx
xorl %ebp, %ebp
cmpq %rcx, %rax
je 0x5e53
movq (%rax), %rdx
movl (%rdx), %edx
addl (%rbx,%rdx,4), %ebp
addq $0x8, %rax
jmp 0x5e40
movl %ebp, %edi
callq 0x3ea2
movq %rax, %r14
movl $0x6, %edi
movl %ebp, %esi
callq 0x3ebe
movq %rax, %r15
movq (%r12), %r13
movq 0x8(%r12), %r12
cmpq %r12, %r13
je 0x5e92
movq (%r13), %rax
movl (%rax), %eax
movl (%rbx,%rax,4), %edi
callq 0x3ea2
imulq %rax, %r15
addq $0x8, %r13
jmp 0x5e75
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_O1/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, %r12d
movq %rdi, %rbx
leaq 0xa0(%rsp), %r14
leaq 0x52f9(%rip), %rax      # 0xb1f0
movq 0x8(%rax), %rax
addq $-0x8, %rax
cmpq %rdx, %rax
je 0x5f60
testl %r12d, %r12d
js 0x5fb8
leaq 0x8(%r15), %r13
xorl %ebp, %ebp
movq 0x10(%r14), %rax
movq %rax, 0x30(%rsp)
movups (%r14), %xmm0
movaps %xmm0, 0x20(%rsp)
movq (%r15), %rax
movl (%rax), %eax
movl %r12d, 0x20(%rsp,%rax,4)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0x5ed1
leal -0x1(%r12), %eax
incl %ebp
testl %r12d, %r12d
movl %eax, %r12d
jg 0x5f13
jmp 0x5fb8
movq (%r15), %rax
movl (%rax), %eax
movl %r12d, (%r14,%rax,4)
movq 0x10(%r14), %rax
movq %rax, 0x50(%rsp)
movups (%r14), %xmm0
movaps %xmm0, 0x40(%rsp)
movq %r14, %rdi
callq 0x5e20
movsd %xmm0, 0x58(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5fab
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x20, 0x8(%rbx)
jmp 0x5fb8
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x6196
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x528f(%rip), %al       # 0xb268
testb %al, %al
je 0x6080
movq 0x5270(%rip), %rax      # 0xb258
subq 0x5261(%rip), %rax      # 0xb250
sarq $0x3, %rax
movl %ebx, %r14d
cmpq %r14, %rax
ja 0x600a
leal 0x1(%rbx), %esi
leaq 0x524b(%rip), %rdi      # 0xb250
callq 0x6164
movq 0x523f(%rip), %r15      # 0xb250
cmpq $0x0, (%r15,%r14,8)
jne 0x606b
movl $0x18, %edi
callq 0x2160
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movq %rax, (%r15,%r14,8)
movq 0x5217(%rip), %rax      # 0xb250
movq (%rax,%r14,8), %rdi
movq %rcx, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
leaq 0x51a2(%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 0x5ed1
movq 0x51de(%rip), %rax      # 0xb250
movq (%rax,%r14,8), %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x22f3
jmp 0x5fe1
// File: /workspace/github_cpp_makefile_star2_O1/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 0x614a
movl %esi, %ebp
leaq 0x5155(%rip), %r14      # 0xb270
leaq 0x64d6(%rip), %r15      # 0xc5f8
leaq 0x50c7(%rip), %r12      # 0xb1f0
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x644a
cltq
movq (%r12), %rcx
movq (%rcx,%rax,8), %rax
movl (%rax), %eax
incl (%rbx,%rax,4)
decl %ebp
jne 0x6129
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rsi
movq %r15, %rdi
callq 0x2a66
movb $0x1, %bl
testq %rax, %rax
jns 0x66d4
movq %r15, %rdi
movq %r14, %rsi
callq 0x2af4
testq %rax, %rax
setns %bl
movq 0x48f5(%rip), %rdi      # 0xafd0
testb %bl, %bl
je 0x66ed
leaq 0xf9c(%rip), %rsi       # 0x7682
movl $0x15, %edx
jmp 0x66f9
leaq 0xf76(%rip), %rsi       # 0x766a
movl $0x17, %edx
callq 0x2180
xorb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0x4419(%rip), %rax      # 0xab38
movq (%rax), %r10
movq %r10, 0x18(%rsp)
leaq 0x4402(%rip), %rax      # 0xab30
movq (%rax), %rax
movq %rax, 0x20(%rsp)
leaq 0x43eb(%rip), %rax      # 0xab28
movq (%rax), %rax
movq %rax, 0x28(%rsp)
leaq 0x43d4(%rip), %rax      # 0xab20
movq (%rax), %rax
movq %rax, 0x30(%rsp)
leaq 0x43bd(%rip), %rax      # 0xab18
movq (%rax), %rax
movq %rax, 0x38(%rsp)
leaq 0x43a6(%rip), %rax      # 0xab10
movq (%rax), %rax
movq %rax, 0x40(%rsp)
leaq 0x4a77(%rip), %rax      # 0xb1f0
movq (%rax), %rdi
movq %rdi, 0x8(%rsp)
movq 0x8(%rax), %r8
xorl %r9d, %r9d
xorl %eax, %eax
xorl %r15d, %r15d
xorl %r11d, %r11d
movq 0x18(%rsp,%r11), %r14
movl (%r14), %r12d
movl (%rcx,%r12,4), %ebp
movb $0x1, %bl
testl %ebp, %ebp
jle 0x6806
cmpl $0x0, (%rdx,%r12,4)
jg 0x6806
cmpq %r8, 0x8(%rsp)
sete %r12b
cmpq %r10, %r14
setne %r13b
orb %r12b, %r13b
jne 0x67f8
movq %r15, %rdi
xorl %r12d, %r12d
movq 0x8(%rsp), %r13
movq (%r13), %rsi
movl (%rsi), %esi
xorl %r15d, %r15d
cmpl $0x0, (%rdx,%rsi,4)
setg %r15b
addl %r15d, %r12d
addq $0x8, %r13
cmpq %r8, %r13
jne 0x67c9
cmpl $0x1, %r12d
movq %rdi, %r15
jbe 0x67f8
xorl %ebx, %ebx
movq %r14, 0x10(%rsp)
jmp 0x6806
imull 0x4(%r14), %ebp
cmpl %eax, %ebp
cmovgq %r14, %r15
cmovgl %ebp, %eax
testb %bl, %bl
je 0x681c
addq $0x8, %r11
cmpq $0x30, %r11
sete %r9b
jne 0x6790
testb $0x1, %r9b
movq 0x10(%rsp), %rax
je 0x68a2
testq %r15, %r15
je 0x68b1
movq 0x4799(%rip), %rbx      # 0xafd0
leaq 0xecd(%rip), %rsi       # 0x770b
movl $0x17, %edx
movq %rbx, %rdi
callq 0x2180
movq 0x8(%r15), %r14
testq %r14, %r14
je 0x6870
movq %r14, %rdi
callq 0x2080
movq 0x476d(%rip), %rdi      # 0xafd0
movq %r14, %rsi
movq %rax, %rdx
callq 0x2180
jmp 0x6887
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x2220
movq 0x4742(%rip), %rdi      # 0xafd0
leaq 0xdff(%rip), %rsi       # 0x7694
movl $0x3, %edx
callq 0x2180
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xde0(%rip), %rdi       # 0x7698
leaq 0xde1(%rip), %rsi       # 0x76a0
leaq 0xde8(%rip), %rcx       # 0x76ae
movl $0x2a, %edx
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7178
xorl %r14d, %r14d
movq (%rax,%r14,8), %r15
movq %r15, %rdi
callq 0xc4ec
movq 0x98(%rbx), %rcx
movq 0xa0(%rbx), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %r14, %rdx
jbe 0x71b6
addl (%rcx,%r14,4), %eax
movq %r15, %rdi
movl %eax, %esi
callq 0xc4f0
incq %r14
movq 0x80(%rbx), %rax
movq 0x88(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r14, %rdx
ja 0x7124
cmpq %rax, %rcx
je 0x7184
movq %rax, 0x88(%rbx)
movq 0x98(%rbx), %rax
cmpq %rax, 0xa0(%rbx)
je 0x719b
movq %rax, 0xa0(%rbx)
movq 0xb0(%rbx), %rsi
addq $0xb0, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x9ea4
leaq 0xb631(%rip), %rdi      # 0x127ee
movq %r14, %rsi
xorl %eax, %eax
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x75ab
movq %rdi, %r15
movq $-0x4, 0x8(%rsp)
movl $0x4, %r12d
movq $-0x8, %r14
movl $0x8, %ebp
xorl %ebx, %ebx
movq (%rax,%rbx,8), %rsi
leaq 0x18(%rsp), %rdi
callq 0xc490
movq 0x20(%rsp), %rdx
movq 0x10(%rsp), %rax
cmpq 0x8(%rax), %rdx
jne 0x7488
testq %rdx, %rdx
je 0x748d
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x18(%rsp), %rdi
callq 0x3240
testl %eax, %eax
sete %r13b
jmp 0x7490
xorl %r13d, %r13d
jmp 0x7490
movb $0x1, %r13b
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x74ac
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3230
testb %r13b, %r13b
je 0x7578
movq 0x80(%r15), %rax
movq 0x88(%r15), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rbx, %rdx
jbe 0x75ba
movq (%rax,%rbx,8), %r13
movq %r13, %rdi
callq 0xc4ec
movq 0x98(%r15), %rcx
movq 0xa0(%r15), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rbx, %rdx
jbe 0x75ba
addl (%rcx,%rbx,4), %eax
movq %r13, %rdi
movl %eax, %esi
callq 0xc4f0
movq 0x80(%r15), %rax
movq 0x88(%r15), %rdx
leaq (%rax,%rbp), %rcx
cmpq %rdx, %rcx
je 0x7538
leaq (%rax,%rbx,8), %rdi
leaq (%rax,%rbx,8), %rsi
addq $0x8, %rsi
subq %rax, %rdx
addq %r14, %rdx
callq 0x3390
addq $-0x8, 0x88(%r15)
movq 0x98(%r15), %rax
movq 0xa0(%r15), %rdx
leaq (%rax,%r12), %rcx
cmpq %rdx, %rcx
je 0x7570
leaq (%rax,%rbx,4), %rdi
leaq (%rax,%rbx,4), %rsi
addq $0x4, %rsi
subq %rax, %rdx
addq 0x8(%rsp), %rdx
callq 0x3390
addq $-0x4, 0xa0(%r15)
incq %rbx
movq 0x80(%r15), %rax
movq 0x88(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
addq $-0x4, 0x8(%rsp)
addq $0x4, %r12
addq $-0x8, %r14
addq $0x8, %rbp
cmpq %rbx, %rcx
ja 0x744b
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb22d(%rip), %rdi      # 0x127ee
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %r13
movq 0x58(%rdi), %rax
movq %rax, 0x30(%rsp)
cmpq %rax, %r13
je 0xd8c8
movq %rsi, %r14
xorl %r15d, %r15d
movq (%r13), %rbp
leaq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0x6cf2
movq 0x18(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0xd826
testq %rdx, %rdx
je 0xd82a
movq (%r14), %rsi
movq 0x10(%rsp), %rdi
callq 0x3240
testl %eax, %eax
sete %bl
jmp 0xd82c
xorl %ebx, %ebx
jmp 0xd82c
movb $0x1, %bl
testb %bl, %bl
je 0xd86c
leaq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0x6cc4
movq 0x40(%rsp), %rdx
movq 0x8(%rsp), %rax
cmpq 0x8(%rax), %rdx
jne 0xd86c
testq %rdx, %rdx
je 0xd8c3
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x38(%rsp), %rdi
callq 0x3240
testl %eax, %eax
sete %r12b
jmp 0xd86f
xorl %r12d, %r12d
testb %bl, %bl
je 0xd88f
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0xd88f
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x3230
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xd8ab
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3230
testb %r12b, %r12b
cmovneq %rbp, %r15
addq $0x8, %r13
cmpq 0x30(%rsp), %r13
jne 0xd7f1
jmp 0xd8cb
movb $0x1, %r12b
jmp 0xd86f
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
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xd8fc
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa289(%rip), %rax      # 0x17c10
movq %rax, (%rdi)
movq 0x38(%rdi), %r14
movq 0x40(%rdi), %r15
cmpq %r15, %r14
je 0xd9ab
movq (%r14), %rdi
testq %rdi, %rdi
je 0xd9a5
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0xd992
movq 0x50(%rbx), %r14
movq 0x58(%rbx), %r15
cmpq %r15, %r14
je 0xd9cc
movq (%r14), %rdi
testq %rdi, %rdi
je 0xd9c6
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0xd9b3
movq 0x68(%rbx), %r14
movq 0x70(%rbx), %r15
cmpq %r15, %r14
je 0xd9ed
movq (%r14), %rdi
testq %rdi, %rdi
je 0xd9e7
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0xd9d4
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0xda02
movq 0x78(%rbx), %rsi
subq %rdi, %rsi
callq 0x3230
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0xda17
movq 0x60(%rbx), %rsi
subq %rdi, %rsi
callq 0x3230
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xda2c
movq 0x48(%rbx), %rsi
subq %rdi, %rsi
callq 0x3230
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x10af6
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa343(%rip), %r14      # 0x17fd0
leaq 0x4daa(%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 0x4e13(%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), %rbp
movq 0x40(%r15), %r12
cmpq %r12, %rbp
je 0xddd8
movq (%rbp), %r13
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0xc490
movq 0x10(%rsp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0xdd36
testq %rdx, %rdx
je 0xdd3b
movq (%rbx), %rsi
movq 0x8(%rsp), %rdi
callq 0x3240
testl %eax, %eax
sete %r15b
jmp 0xdd3e
xorl %r15d, %r15d
jmp 0xdd3e
movb $0x1, %r15b
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xdd5a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3230
testb %r15b, %r15b
je 0xddcf
movl $0x11, %edx
movq %r14, %rdi
leaq 0x4cbe(%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 0xfdd5
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, %rbp
jmp 0xdcf7
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9f0f(%rip), %rbx      # 0x17fd0
leaq 0x49ae(%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 0x49df(%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), %rbp
movq 0x58(%r12), %r12
cmpq %r12, %rbp
je 0xe27f
movq (%rbp), %r13
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x6cf2
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0xe16b
testq %rdx, %rdx
je 0xe16f
movq (%r14), %rsi
movq 0x8(%rsp), %rdi
callq 0x3240
testl %eax, %eax
sete %bl
jmp 0xe171
xorl %ebx, %ebx
jmp 0xe171
movb $0x1, %bl
testb %bl, %bl
je 0xe1b3
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0x6cc4
movq 0x30(%rsp), %rdx
movq (%rsp), %rax
cmpq 0x8(%rax), %rdx
jne 0xe1b3
testq %rdx, %rdx
je 0xe277
movq (%rsp), %rax
movq (%rax), %rsi
movq 0x28(%rsp), %rdi
callq 0x3240
testl %eax, %eax
sete %r15b
jmp 0xe1b6
xorl %r15d, %r15d
testb %bl, %bl
je 0xe1d6
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xe1d6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3230
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe1f2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3230
testb %r15b, %r15b
je 0xe26e
movl $0x10, %edx
movq 0x9dcd(%rip), %rbx      # 0x17fd0
movq %rbx, %rdi
leaq 0x4858(%rip), %rsi      # 0x12a65
callq 0x3280
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3200
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
movq %rax, %rdi
movq %r13, %rsi
callq 0x10023
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, %rbp
jmp 0xe12d
movb $0x1, %r15b
jmp 0xe1b6
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe2ad
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/pc260533[P]ITC313-TP2/magasin.cpp
// Function: Magasin::afficherClient(int)
void Magasin::afficherClient(int identifiantClient) {
    std::cout << "Les clients dont l'identifiant est " << std::to_string(identifiantClient) << " est :" << std::endl;
    for (Client *client : this->listeClients) {
        if (client->getIdentifiantClient() == identifiantClient) {
            std::cout << "Le client est : " << std::endl << *client << std::endl;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq 0x9d00(%rip), %rdi      # 0x17fd0
leaq 0x47bc(%rip), %rsi      # 0x12a93
movl $0x23, %edx
callq 0x3280
movl %ebx, %ebp
negl %ebp
cmovsl %ebx, %ebp
movl $0x1, %r15d
cmpl $0xa, %ebp
jb 0xe33c
movl $0x4, %r15d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0xe333
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0xe339
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0xe33c
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r15d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0xe300
addl $-0x3, %r15d
jmp 0xe33c
addl $-0x2, %r15d
jmp 0xe33c
decl %r15d
movl %ebx, %r12d
shrl $0x1f, %r12d
leal (%r15,%r12), %esi
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movl $0x2d, %edx
callq 0x3290
addq (%r13), %r12
movq %r12, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x9a4d
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq 0x9c4e(%rip), %r15      # 0x17fd0
movq %r15, %rdi
callq 0x3280
movq %rax, %r12
leaq 0x4739(%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 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe3e5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3230
movq 0x50(%r14), %r13
movq 0x58(%r14), %rbp
cmpq %rbp, %r13
je 0xe486
leaq 0x4668(%rip), %r14      # 0x12a65
movq (%r13), %r12
movq %r12, %rdi
callq 0x6cbc
cmpl %ebx, %eax
jne 0xe479
movl $0x10, %edx
movq %r15, %rdi
movq %r14, %rsi
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 %r12, %rsi
callq 0x10023
movq %rax, %r12
movq (%rax), %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
addq $0x8, %r13
cmpq %rbp, %r13
jne 0xe3fd
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe4b4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/pc260533[P]ITC313-TP2/magasin.cpp
// Function: Magasin::validerCommandeDUnClient(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::validerCommandeDUnClient(std::string nomClient, std::string prenomClient) {
    Client *client = this->getClientAvecNomPrenomClient(nomClient, prenomClient);
    if (client) {
        if (!client->getListeProduitsSelectionnes().empty()) {
            this->listeCommandes.push_back(new Commande(this->compteurCommandes, client, client->getListeProduitsSelectionnes(), client->getListeQuantitesProduitsSelectionnes()));
            client->validerLePanier();
            this->compteurCommandes++;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x68(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x58(%rsp), %rdi
movq %rax, %rsi
callq 0x6b9c
leaq 0x48(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x38(%rsp), %rdi
callq 0x6b9c
leaq 0x58(%rsp), %rsi
leaq 0x38(%rsp), %rdx
movq %rbx, %rdi
callq 0xd7c2
movq %rax, %r14
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0xe8d5
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x3230
movq 0x58(%rsp), %rdi
cmpq %r15, %rdi
je 0xe8ec
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x3230
testq %r14, %r14
je 0xe9c6
leaq 0x78(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x6d20
movq (%r12), %r15
movq 0x8(%r12), %r12
testq %r15, %r15
je 0xe926
movq 0x88(%rsp), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x3230
cmpq %r12, %r15
je 0xe9c6
movl $0xd8, %edi
callq 0x3220
movq %rax, %r15
movl 0x84(%rbx), %ebp
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x6d20
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x6d32
movb $0x1, %r12b
leaq 0x20(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0xa428
leaq 0x68(%rbx), %rdi
leaq 0x78(%rsp), %rsi
movq %r15, (%rsi)
xorl %r12d, %r12d
callq 0x107bc
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xe9a1
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x3230
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xe9b8
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x3230
movq %r14, %rdi
callq 0x71c8
incl 0x84(%rbx)
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movb $0x1, %r12b
jmp 0xea00
movq %rax, %rbx
movb $0x1, %r12b
jmp 0xea17
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xea00
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x3230
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xea17
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x3230
testb %r12b, %r12b
je 0xea5c
movl $0xd8, %esi
movq %r15, %rdi
jmp 0xea57
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0xea45
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x3230
jmp 0xea45
movq %rax, %rbx
movq 0x58(%rsp), %rdi
cmpq %r15, %rdi
je 0xea5c
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x33e0