LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ttencate[P]pickomino/./dice.h
// Function: DieSide::fromString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static DieSide const *fromString(std::string s) {
      for (DieSide const *side : ALL) {
        if (s == side->m_string) {
          return side;
        }
      }
      return nullptr;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x886a(%rip), %rax      # 0xc1e8
movq (%rax), %r15
movq 0x8(%rax), %r12
cmpq %r12, %r15
je 0x39a3
movq (%r15), %r14
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x395f
addq $0x8, %r15
testb %al, %al
je 0x3985
jmp 0x39a6
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq $0x1
popq %rcx
movl %ecx, %r8d
cmpl %esi, %r8d
jge 0x39fb
movl %edi, %eax
cltd
idivl %r8d
imull %eax, %ecx
incl %r8d
decl %edi
jmp 0x39e6
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movslq %edi, %rcx
pushq $0x1
popq %rax
movq %rcx, %rdx
subq $0x1, %rdx
jb 0x3a16
imulq %rcx, %rax
movq %rdx, %rcx
jmp 0x3a07
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movslq %edi, %rcx
pushq $0x1
popq %rax
subl $0x1, %esi
jb 0x3a28
imulq %rcx, %rax
jmp 0x3a1d
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4010
movq 0x18(%rax), %rcx
cmpq %rcx, 0x10(%rax)
je 0x3a50
xorl %eax, %eax
subl -0x4(%rcx), %eax
cvtsi2sd %eax, %xmm0
jmp 0x3a54
xorpd %xmm0, %xmm0
movsd %xmm0, 0x28(%rbx)
leaq 0x30(%rbx), %rdi
callq 0x4128
addq $0x68, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x40a2
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3b3c
movsd %xmm0, 0x28(%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3c60
movsd %xmm0, 0x20(%rsp)
movq 0x8504(%rip), %rbx      # 0xbfd0
leaq 0x37ad(%rip), %rsi      # 0x7280
movq %rbx, %rdi
callq 0x2160
movq %rax, %rdi
movsd 0x28(%rsp), %xmm0
callq 0x2210
leaq 0x37a9(%rip), %r14      # 0x7299
movq %rax, %rdi
movq %r14, %rsi
callq 0x2160
leaq 0x37a1(%rip), %rsi      # 0x72a3
movq %rbx, %rdi
callq 0x2160
movq %rax, %rdi
movsd 0x20(%rsp), %xmm0
callq 0x2210
movq %rax, %rdi
movq %r14, %rsi
callq 0x2160
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_O2/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 0x4192
testq %rax, %rax
jne 0x3c24
movq %r14, 0x20(%rsp)
leaq 0x3554(%rip), %rax      # 0x70d0
movl (%rax), %ebp
movq %rbx, %rdi
callq 0x3226
subl %eax, %ebp
jle 0x3c42
movl %ebp, %edi
callq 0x58ac
movq (%rax), %rbp
movq 0x8(%rax), %r14
xorpd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0x30(%rsp), %r13
cmpq %r14, %rbp
je 0x3c0a
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 0x3f84
mulsd 0x28(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rsp)
addq $0x20, %rbp
jmp 0x3bab
movq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x42c8
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x42c8
movsd (%rax), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x36f4(%rip), %rdi      # 0x733d
leaq 0x3680(%rip), %rsi      # 0x72d0
leaq 0x36f8(%rip), %rcx      # 0x734f
pushq $0x38
popq %rdx
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7ef9(%rip), %rax      # 0xbb70
movq (%rax), %r13
movl (%r13), %eax
cmpl $0x0, (%rdx,%rax,4)
jle 0x3d67
movq %rdx, %r14
movq %rsi, %r15
movq %rdx, %rdi
callq 0x31e0
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x68(%r12), %rbx
movq %rbx, %rdi
callq 0x45ee
testq %rax, %rax
jne 0x3d54
movsd 0x28(%r12), %xmm0
movsd %xmm0, (%rsp)
movl (%r13), %eax
cmpl $0x0, (%r14,%rax,4)
jle 0x3d3e
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x28dc
testq %rax, %rax
js 0x3d1c
shrq $0x20, %rax
cvtsi2sd %eax, %xmm0
movq 0x8(%r15), %rax
subq (%r15), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
decl %eax
cvtsi2sd %eax, %xmm1
movsd 0x356e(%rip), %xmm2     # 0x7270
movapd %xmm2, %xmm3
divsd %xmm1, %xmm3
addsd %xmm2, %xmm3
mulsd %xmm0, %xmm3
maxsd (%rsp), %xmm3
movsd %xmm3, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x2942
testq %rax, %rax
js 0x3d3e
shrq $0x20, %rax
cvtsi2sd %eax, %xmm0
maxsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x466a
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x466a
movsd (%rax), %xmm0
jmp 0x3d6e
movsd 0x28(%r12), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rcx, %rbx
movq %rdx, %r14
movq %rsi, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
leaq 0x8447(%rip), %rax      # 0xc1e8
movq (%rax), %r15
movq 0x8(%rax), %r13
movsd 0x34c8(%rip), %xmm0     # 0x7278
xorl %r12d, %r12d
cmpq %r13, %r15
je 0x3e95
movq (%r15), %rbp
movl (%rbp), %eax
cmpl $0x0, (%rbx,%rax,4)
jle 0x3e8c
cmpl $0x0, (%r14,%rax,4)
jg 0x3e8c
movq 0x10(%r14), %rax
movq %rax, 0x50(%rsp)
movsd %xmm0, 0x20(%rsp)
movups (%r14), %xmm0
movaps %xmm0, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movapd 0x40(%rsp), %xmm0
movupd %xmm0, (%rsp)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq %rbx, %rdx
movq %rbp, %rcx
callq 0x3eca
movsd %xmm0, 0x38(%rsp)
movsd 0x20(%rsp), %xmm2
ucomisd %xmm2, %xmm0
movapd %xmm0, %xmm1
maxsd %xmm2, %xmm1
movsd %xmm1, 0x20(%rsp)
cmovaq %rbp, %r12
movq 0x818e(%rip), %rdi      # 0xbfd0
leaq 0x3474(%rip), %rsi      # 0x72bd
callq 0x2160
movq 0x8(%rbp), %rsi
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
leaq 0x3429(%rip), %rsi      # 0x728d
callq 0x2160
movq %rax, %rdi
movsd 0x38(%rsp), %xmm0
callq 0x2210
movq %rax, %rdi
leaq 0x3418(%rip), %rsi      # 0x7299
callq 0x2160
movsd 0x20(%rsp), %xmm0
addq $0x8, %r15
jmp 0x3db3
testq %r12, %r12
je 0x3eac
movq %r12, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3418(%rip), %rdi      # 0x72cb
leaq 0x3416(%rip), %rsi      # 0x72d0
leaq 0x341e(%rip), %rcx      # 0x72df
pushq $0x27
popq %rdx
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x60(%rsp), %r12
movsd 0x28(%rdi), %xmm0
leaq 0x823c(%rip), %rax      # 0xc1e8
movq (%rax), %r13
movq 0x8(%rax), %rbp
cmpq %rbp, %r13
je 0x4000
movq (%r13), %rcx
movl (%rcx), %eax
cmpl $0x0, (%rbx,%rax,4)
jle 0x3ffa
cmpl $0x0, (%r12,%rax,4)
jg 0x3ffa
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movsd %xmm0, 0x20(%rsp)
movupd (%r12), %xmm0
movupd %xmm0, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3eca
maxsd 0x20(%rsp), %xmm0
addq $0x8, %r13
jmp 0x3fb3
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x402a
cmpq %rsi, (%rax)
je 0x4028
addq $0x28, %rax
jmp 0x4018
popq %rcx
retq
leaq 0x33f4(%rip), %rdi      # 0x7425
leaq 0x33f3(%rip), %rsi      # 0x742b
leaq 0x33f5(%rip), %rcx      # 0x7434
movl $0x97, %edx
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x3226
movl %eax, %ebp
movl %eax, %edi
callq 0x39fe
movq %rax, %r14
pushq $0x6
popq %rdi
movl %ebp, %esi
callq 0x3a17
movq %rax, %r15
leaq 0x6a65(%rip), %rax      # 0xc1e8
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x57a7
movq (%r12), %rax
movl (%rax), %eax
movl (%rbx,%rax,4), %edi
callq 0x39fe
imulq %rax, %r15
addq $0x8, %r12
jmp 0x578a
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
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x80(%rsp), %r14
leaq 0x69de(%rip), %rax      # 0xc1e8
movq 0x8(%rax), %rax
addq $-0x8, %rax
cmpq %rdx, %rax
je 0x5865
leaq 0x8(%r15), %r12
xorl %r13d, %r13d
testl %ebp, %ebp
js 0x589c
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 0x57e5
decl %ebp
incl %r13d
jmp 0x581e
movq (%r15), %rax
movl (%rax), %eax
movl %ebp, (%r14,%rax,4)
movq 0x10(%r14), %rax
leaq 0x20(%rsp), %r15
movq %rax, 0x10(%r15)
movups (%r14), %xmm0
movaps %xmm0, (%r15)
movq %r14, %rdi
callq 0x5750
movsd %xmm0, 0x18(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5a98
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x69a3(%rip), %al       # 0xc260
testb %al, %al
je 0x5967
movq 0x6984(%rip), %rax      # 0xc250
movq 0x6975(%rip), %r15      # 0xc248
subq %r15, %rax
sarq $0x3, %rax
movl %ebx, %r14d
cmpq %r14, %rax
ja 0x58f8
leal 0x1(%rbx), %esi
leaq 0x695c(%rip), %rdi      # 0xc248
callq 0x5a26
movq 0x6950(%rip), %r15      # 0xc248
movq (%r15,%r14,8), %rax
testq %rax, %rax
jne 0x595d
pushq $0x18
popq %rdi
callq 0x2170
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, (%r15,%r14,8)
movq 0x6929(%rip), %rax      # 0xc248
movq (%rax,%r14,8), %rdi
andq $0x0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
leaq 0x68b3(%rip), %rax      # 0xc1e8
movq (%rax), %rdx
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movl %ebx, %esi
callq 0x57e5
movq 0x68ef(%rip), %rax      # 0xc248
movq (%rax,%r14,8), %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x68f2(%rip), %rdi      # 0xc260
callq 0x2260
testl %eax, %eax
je 0x58c5
xorps %xmm0, %xmm0
movups %xmm0, 0x68c3(%rip)     # 0xc248
andq $0x0, 0x68cb(%rip)      # 0xc258
leaq 0x68b4(%rip), %rsi      # 0xc248
leaq 0x85(%rip), %rdi        # 0x5a20
leaq 0x679e(%rip), %rdx      # 0xc140
callq 0x2130
leaq 0x68b2(%rip), %rdi      # 0xc260
callq 0x20f0
jmp 0x58c5
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
xorl %ebp, %ebp
testl %esi, %esi
cmovgl %esi, %ebp
subl $0x1, %ebp
jb 0x5a16
callq 0x59c7
movl (%rax), %eax
incl (%rbx,%rax,4)
jmp 0x5a05
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x28dc
testq %rax, %rax
jns 0x6034
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2942
testq %rax, %rax
js 0x6053
leaq 0x15ef(%rip), %rsi      # 0x762a
xorl %ebx, %ebx
movq 0x5f8c(%rip), %rdi      # 0xbfd0
callq 0x2160
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x1, %bl
leaq 0x15b6(%rip), %rsi      # 0x7612
jmp 0x603d
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movq %rcx, %rbx
leaq 0x5afa(%rip), %rax      # 0xbb70
movq (%rax), %rsi
movq %rsi, 0x8(%rsp)
leaq 0x5ae3(%rip), %rax      # 0xbb68
movq (%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x5acc(%rip), %rax      # 0xbb60
movq (%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0x5ab5(%rip), %rax      # 0xbb58
movq (%rax), %rax
movq %rax, 0x20(%rsp)
leaq 0x5a9e(%rip), %rax      # 0xbb50
movq (%rax), %rax
movq %rax, 0x28(%rsp)
leaq 0x5a87(%rip), %rax      # 0xbb48
movq (%rax), %rax
movq %rax, 0x30(%rsp)
xorl %ebp, %ebp
xorl %r14d, %r14d
xorl %edi, %edi
cmpq $0x30, %rbp
je 0x612b
movq 0x8(%rsp,%rbp), %r15
movl (%r15), %ecx
movl (%rbx,%rcx,4), %eax
testl %eax, %eax
jle 0x6125
cmpl $0x0, (%rdx,%rcx,4)
jg 0x6125
cmpq %rsi, %r15
jne 0x6117
movl %edi, 0x4(%rsp)
movq %rsi, %r12
movq %rdx, %r13
movq %rdx, %rdi
callq 0x6190
cmpl $0x1, %eax
jg 0x6161
movl (%r15), %eax
movl (%rbx,%rax,4), %eax
movq %r12, %rsi
movq %r13, %rdx
movl 0x4(%rsp), %edi
imull 0x4(%r15), %eax
cmpl %edi, %eax
cmovgq %r15, %r14
cmovgl %eax, %edi
addq $0x8, %rbp
jmp 0x60d0
testq %r14, %r14
je 0x6173
movq 0x5e99(%rip), %rdi      # 0xbfd0
leaq 0x1575(%rip), %rsi      # 0x76b3
callq 0x2160
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x2160
leaq 0x14e6(%rip), %rsi      # 0x763c
movq %rax, %rdi
callq 0x2160
movq %r14, %r15
movq %r15, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14c6(%rip), %rdi      # 0x7640
leaq 0x14c7(%rip), %rsi      # 0x7648
leaq 0x14ce(%rip), %rcx      # 0x7656
pushq $0x2a
popq %rdx
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/pc260533[P]ITC313-TP2/client.cpp
// Function: Client::viderLePanier()
void Client::viderLePanier() {
    for (int i = 0; i < this->listeProduitsSelectionnes.size(); i++) {
        this->listeProduitsSelectionnes.at(i)->setQuantiteDisponibleProduit(this->listeProduitsSelectionnes.at(i)->getQuantiteDisponibleProduit() + this->listeQuantitesProduitsSelectionnes.at(i));
    }
    this->listeProduitsSelectionnes.clear();
    this->listeQuantitesProduitsSelectionnes.clear();
    this->listeNomProduitsSelectionnes.clear();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x80(%rdi), %r14
leaq 0x98(%rdi), %r15
xorl %r12d, %r12d
movq 0x80(%rbx), %rax
movq 0x88(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r12, %rdx
jbe 0x5909
movq %r14, %rdi
movq %r12, %rsi
callq 0x6e38
movq (%rax), %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0x6e38
movq (%rax), %rdi
callq 0x9178
movl %eax, %ebp
movq %r15, %rdi
movq %r12, %rsi
callq 0x6e5a
addl (%rax), %ebp
movq %r13, %rdi
movl %ebp, %esi
callq 0x917c
incq %r12
jmp 0x58ad
cmpq %rax, %rcx
je 0x5915
movq %rax, 0x88(%rbx)
movq 0x98(%rbx), %rax
cmpq %rax, 0xa0(%rbx)
je 0x592c
movq %rax, 0xa0(%rbx)
addq $0xb0, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6e7c
nop
// File: /workspace/github_cpp_makefile_star2_O2/pc260533[P]ITC313-TP2/client.cpp
// Function: Client::modifierQuantiteProduitSelectionne(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void Client::modifierQuantiteProduitSelectionne(std::string nomProduit, int nombreDeProduits) {
    if (nombreDeProduits > 0) {
        for (int i = 0; i < this->listeProduitsSelectionnes.size(); i++) {
            if (this->listeProduitsSelectionnes.at(i)->getTitreProduit() == nomProduit) {
                if (this->listeProduitsSelectionnes.at(i)->getQuantiteDisponibleProduit() != 0) {
                    if ((this->listeProduitsSelectionnes.at(i)->getQuantiteDisponibleProduit() < nombreDeProduits - this->listeQuantitesProduitsSelectionnes.at(i))) {
                        this->listeQuantitesProduitsSelectionnes.at(i) = this->listeProduitsSelectionnes.at(i)->getQuantiteDisponibleProduit() + this->listeQuantitesProduitsSelectionnes.at(i);
                    }
                    else {
                        this->listeProduitsSelectionnes.at(i)->setQuantiteDisponibleProduit(this->listeProduitsSelectionnes.at(i)->getQuantiteDisponibleProduit() - nombreDeProduits + this->listeQuantitesProduitsSelectionnes.at(i));
                        this->listeQuantitesProduitsSelectionnes.at(i) = nombreDeProduits;
                    }
                }
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, 0xc(%rsp)
testl %edx, %edx
jle 0x5af0
movq %rsi, %r14
movq %rdi, %r15
leaq 0x80(%rdi), %r12
leaq 0x98(%rdi), %rax
movq %rax, (%rsp)
xorl %ebp, %ebp
movq %r12, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movq 0x88(%r15), %rax
subq 0x80(%r15), %rax
sarq $0x3, %rax
cmpq %rbp, %rax
jbe 0x5af0
movq %r12, %rdi
movq %rbp, %rsi
callq 0x6e38
movq (%rax), %rsi
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x9140
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6e84
movl %eax, %r13d
movq %rbx, %rdi
callq 0x3110
testb %r13b, %r13b
je 0x5ae8
movq %r12, %rdi
movq %rbp, %rsi
callq 0x6e38
movq (%rax), %rdi
callq 0x9178
testl %eax, %eax
je 0x5ae8
movq %r12, %rdi
movq %rbp, %rsi
callq 0x6e38
movq (%rax), %rdi
callq 0x9178
movl %eax, %r14d
movq (%rsp), %rdi
movq %rbp, %rsi
callq 0x6e5a
movl 0xc(%rsp), %r15d
movl %r15d, %ebx
subl (%rax), %ebx
movq %r12, %rdi
movq %rbp, %rsi
callq 0x6e38
movq (%rax), %r13
cmpl %ebx, %r14d
jge 0x5a95
movq %r13, %rdi
callq 0x9178
movl %eax, %r15d
movq (%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x6e5a
addl (%rax), %r15d
jmp 0x5acb
movq %r12, %rdi
movq %rbp, %rsi
callq 0x6e38
movq (%rax), %rdi
callq 0x9178
movl %eax, %r14d
subl %r15d, %r14d
movq (%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x6e5a
addl (%rax), %r14d
movq %r13, %rdi
movl %r14d, %esi
callq 0x917c
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x6e5a
movl %r15d, (%rax)
movq 0x20(%rsp), %r14
movq 0x18(%rsp), %r15
movq 0x10(%rsp), %r12
incq %rbp
jmp 0x59c7
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, %r13
leaq 0x80(%rdi), %r15
leaq 0x98(%rdi), %rax
movq %rax, 0x10(%rsp)
xorl %r14d, %r14d
movq $0x0, (%rsp)
xorl %ebp, %ebp
movq %r15, 0x8(%rsp)
movq 0x88(%r13), %rax
subq 0x80(%r13), %rax
sarq $0x3, %rax
cmpq %rbp, %rax
jbe 0x5c08
movq %r15, %rdi
movq %rbp, %rsi
callq 0x6e38
movq (%rax), %rsi
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x9140
movq %r12, %rdi
movq 0x20(%rsp), %rsi
callq 0x6e84
movl %eax, %ebx
movq %r12, %rdi
callq 0x3110
testb %bl, %bl
je 0x5bf7
movq %r15, %rdi
movq %rbp, %rsi
callq 0x6e38
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
callq 0x6e38
movq (%rax), %rdi
callq 0x9178
movl %eax, %r12d
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x6e5a
addl (%rax), %r12d
movq 0x18(%rsp), %rdi
movl %r12d, %esi
movq 0x8(%rsp), %r15
callq 0x917c
movq (%r15), %rsi
addq (%rsp), %rsi
movq %r15, %rdi
callq 0x6eae
movq (%rbx), %rsi
addq %r14, %rsi
movq %rbx, %rdi
callq 0x6ee8
incq %rbp
addq $0x8, (%rsp)
addq $0x4, %r14
jmp 0x5b3b
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pc260533[P]ITC313-TP2/client.cpp
// Function: Client::initialisertMapAttributsNomAttributs()
void Client::initialisertMapAttributsNomAttributs() {
    this->ajouterEntreeMapAttributsNomAttributs("identifiantClient", "identifiantClient");
    this->ajouterEntreeMapAttributsNomAttributs("nomClient", "nomClient");
    this->ajouterEntreeMapAttributsNomAttributs("prenomClient", "prenomClient");
    this->ajouterEntreeMapAttributsNomAttributs("listeNomProduitsSelectionnes", "listeProduitsSelectionnes");
    this->ajouterEntreeMapAttributsNomAttributs("listeQuantitesProduitsSelectionnes", "listeQuantitesProduitsSelectionnes");
}

// Assembly:
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movq %rdi, %rbx
leaq 0x799f(%rip), %rsi      # 0xd759
leaq 0x130(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x52be
leaq 0x7986(%rip), %rsi      # 0xd759
leaq 0x110(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x52be
leaq 0x130(%rsp), %rsi
leaq 0x110(%rsp), %rdx
movq %rbx, %rdi
callq 0xcb6e
leaq 0x110(%rsp), %rdi
callq 0x3110
leaq 0x130(%rsp), %rdi
callq 0x3110
leaq 0x7950(%rip), %rsi      # 0xd76e
leaq 0xf0(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x52be
leaq 0x7937(%rip), %rsi      # 0xd76e
leaq 0xd0(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x52be
leaq 0xf0(%rsp), %rsi
leaq 0xd0(%rsp), %rdx
movq %rbx, %rdi
callq 0xcb6e
leaq 0xd0(%rsp), %rdi
callq 0x3110
leaq 0xf0(%rsp), %rdi
callq 0x3110
leaq 0x78e9(%rip), %rsi      # 0xd76b
leaq 0xb0(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x52be
leaq 0x78d0(%rip), %rsi      # 0xd76b
leaq 0x90(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x52be
leaq 0xb0(%rsp), %rsi
leaq 0x90(%rsp), %rdx
movq %rbx, %rdi
callq 0xcb6e
leaq 0x90(%rsp), %rdi
callq 0x3110
leaq 0xb0(%rsp), %rdi
callq 0x3110
leaq 0x7892(%rip), %rsi      # 0xd778
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x52be
leaq 0x7899(%rip), %rsi      # 0xd795
leaq 0x50(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x52be
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0xcb6e
leaq 0x50(%rsp), %rdi
callq 0x3110
leaq 0x70(%rsp), %rdi
callq 0x3110
leaq 0x7877(%rip), %rsi      # 0xd7af
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x52be
leaq 0x7861(%rip), %rsi      # 0xd7af
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x52be
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xcb6e
leaq 0x10(%rsp), %rdi
callq 0x3110
leaq 0x30(%rsp), %rdi
callq 0x3110
addq $0x150, %rsp            # imm = 0x150
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3110
jmp 0x5f9e
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x6024
jmp 0x602b
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3110
jmp 0x5fbc
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x6024
jmp 0x602b
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x3110
jmp 0x5fda
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
jmp 0x6024
jmp 0x602b
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x3110
jmp 0x5ffb
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
jmp 0x6024
jmp 0x602b
movq %rax, %rbx
leaq 0x110(%rsp), %rdi
callq 0x3110
jmp 0x601c
movq %rax, %rbx
leaq 0x130(%rsp), %rdi
callq 0x3110
jmp 0x602e
movq %rax, %rbx
movq %rbx, %rdi
callq 0x33a0
// File: /workspace/github_cpp_makefile_star2_O2/pc260533[P]ITC313-TP2/produit.cpp
// Function: Produit::initialisertMapAttributsNomAttributs()
void Produit::initialisertMapAttributsNomAttributs() {
    this->ajouterEntreeMapAttributsNomAttributs("titreProduit", "titreProduit");
    this->ajouterEntreeMapAttributsNomAttributs("descriptionProduit", "descriptionProduit");
    this->ajouterEntreeMapAttributsNomAttributs("quantiteDisponibleProduit", "quantiteDisponibleProduit");
    this->ajouterEntreeMapAttributsNomAttributs("prixUnitaire", "prixUnitaire");
}

// Assembly:
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
leaq 0x469f(%rip), %rsi      # 0xd9bd
leaq 0xf0(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x52be
leaq 0x4686(%rip), %rsi      # 0xd9bd
leaq 0xd0(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x52be
leaq 0xf0(%rsp), %rsi
leaq 0xd0(%rsp), %rdx
movq %rbx, %rdi
callq 0xcb6e
leaq 0xd0(%rsp), %rdi
callq 0x3110
leaq 0xf0(%rsp), %rdi
callq 0x3110
leaq 0x4648(%rip), %rsi      # 0xd9ca
leaq 0xb0(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x52be
leaq 0x462f(%rip), %rsi      # 0xd9ca
leaq 0x90(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x52be
leaq 0xb0(%rsp), %rsi
leaq 0x90(%rsp), %rdx
movq %rbx, %rdi
callq 0xcb6e
leaq 0x90(%rsp), %rdi
callq 0x3110
leaq 0xb0(%rsp), %rdi
callq 0x3110
leaq 0x45f7(%rip), %rsi      # 0xd9dd
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x52be
leaq 0x45e1(%rip), %rsi      # 0xd9dd
leaq 0x50(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x52be
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0xcb6e
leaq 0x50(%rsp), %rdi
callq 0x3110
leaq 0x70(%rsp), %rdi
callq 0x3110
leaq 0x45bf(%rip), %rsi      # 0xd9f7
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x52be
leaq 0x45a9(%rip), %rsi      # 0xd9f7
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x52be
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xcb6e
leaq 0x10(%rsp), %rdi
callq 0x3110
leaq 0x30(%rsp), %rdi
callq 0x3110
addq $0x110, %rsp            # imm = 0x110
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3110
jmp 0x949e
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x9500
jmp 0x9507
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3110
jmp 0x94b9
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x9500
jmp 0x9507
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x3110
jmp 0x94d7
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
jmp 0x9500
jmp 0x9507
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x3110
jmp 0x94f8
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0x3110
jmp 0x950a
movq %rax, %rbx
movq %rbx, %rdi
callq 0x33a0
// File: /workspace/github_cpp_makefile_star2_O2/pc260533[P]ITC313-TP2/magasin.cpp
// Function: Magasin::getProduitAvecNomProduit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Produit *Magasin::getProduitAvecNomProduit(std::string nomProduit) {
    Produit *res = nullptr;
    for (Produit *produit : this->listeProduits) {
        if (produit->getTitreProduit() == nomProduit) {
            res = produit;
        }
    }
    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, (%rsp)
movq 0x38(%rdi), %r13
movq 0x40(%rdi), %rbx
xorl %r14d, %r14d
leaq 0x8(%rsp), %r15
cmpq %rbx, %r13
je 0x9d89
movq (%r13), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x9140
movq %r15, %rdi
movq (%rsp), %rsi
callq 0x6e84
movl %eax, %ebp
movq %r15, %rdi
callq 0x3110
testb %bpl, %bpl
cmovneq %r12, %r14
addq $0x8, %r13
jmp 0x9d52
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x10(%rsp)
movq %rsi, %r13
movq 0x50(%rdi), %rbx
movq 0x58(%rdi), %r14
xorl %r15d, %r15d
leaq 0x18(%rsp), %r12
cmpq %r14, %rbx
je 0x9e2f
movq (%rbx), %rbp
movq %r12, %rdi
movq %rbp, %rsi
callq 0x55b0
movq %r12, %rdi
movq %r13, %rsi
callq 0x6e84
testb %al, %al
je 0x9e21
movq %r13, %r12
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq %rbp, %rsi
callq 0x5594
movq %r13, %rdi
movq 0x10(%rsp), %rsi
callq 0x6e84
movb %al, 0xf(%rsp)
movq %r13, %rdi
callq 0x3110
cmpb $0x0, 0xf(%rsp)
cmovneq %rbp, %r15
movq %r12, %r13
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x3110
addq $0x8, %rbx
jmp 0x9dc2
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x33a0
// File: /workspace/github_cpp_makefile_star2_O2/pc260533[P]ITC313-TP2/magasin.cpp
// Function: Magasin::getCommandeAvecIdentifiantCommande(int)
Commande *Magasin::getCommandeAvecIdentifiantCommande(int identifiantCommande) {
    Commande *res = nullptr;
    for (Commande *commande : this->listeCommandes) {
        if (commande->getIdentifiantCommande() == identifiantCommande) {
            res = commande;
        }
    }
    return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movq 0x68(%rdi), %r12
movq 0x70(%rdi), %r13
xorl %r14d, %r14d
cmpq %r13, %r12
je 0x9e89
movq (%r12), %r15
movq %r15, %rdi
callq 0x7c0c
cmpl %ebx, %eax
cmoveq %r15, %r14
addq $0x8, %r12
jmp 0x9e6c
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x9d39(%rip), %rax      # 0x13c10
movq %rax, (%rdi)
leaq 0x38(%rdi), %r14
movq 0x38(%rdi), %r15
movq 0x40(%rdi), %r12
cmpq %r12, %r15
je 0x9eff
movq (%r15), %rdi
testq %rdi, %rdi
je 0x9ef9
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r15
jmp 0x9ee6
leaq 0x50(%rbx), %r15
movq 0x50(%rbx), %r12
movq 0x58(%rbx), %r13
cmpq %r13, %r12
je 0x9f25
movq (%r12), %rdi
testq %rdi, %rdi
je 0x9f1f
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r12
jmp 0x9f0b
leaq 0x68(%rbx), %r12
movq 0x68(%rbx), %r13
movq 0x70(%rbx), %rbp
cmpq %rbp, %r13
je 0x9f4b
movq (%r13), %rdi
testq %rdi, %rdi
je 0x9f45
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r13
jmp 0x9f31
movq %r12, %rdi
callq 0xb8a0
movq %r15, %rdi
callq 0xb86c
movq %r14, %rdi
callq 0x7348
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xbe86
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9ecd(%rip), %rdi      # 0x13fc8
leaq 0x393c(%rip), %rsi      # 0xda3e
callq 0x3200
movq %rax, %rdi
movq %rbx, %rsi
callq 0x31f0
leaq 0x39b4(%rip), %rsi      # 0xdacd
movq %rax, %rdi
callq 0x3200
movq %rax, %rdi
callq 0x3120
movq 0x38(%r15), %r14
movq 0x40(%r15), %r12
leaq 0x8(%rsp), %r15
cmpq %r12, %r14
je 0xa197
movq (%r14), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x9140
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6e84
movl %eax, %ebp
movq %r15, %rdi
callq 0x3110
testb %bpl, %bpl
je 0xa191
movq 0x9e5e(%rip), %rdi      # 0x13fc8
leaq 0x38bb(%rip), %rsi      # 0xda2c
callq 0x3200
movq %rax, %rdi
callq 0x3120
movq %rax, %rdi
movq %r13, %rsi
callq 0xb3dc
movq %rax, %rdi
callq 0x3120
addq $0x8, %r14
jmp 0xa136
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x58, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq 0x9c44(%rip), %rdi      # 0x13fc8
leaq 0x36eb(%rip), %rsi      # 0xda76
callq 0x3200
movq %rax, %rdi
movq %r14, %rsi
callq 0x31f0
leaq 0x372b(%rip), %rsi      # 0xdacd
movq %rax, %rdi
callq 0x3200
movq %rax, %rdi
callq 0x3120
movq 0x50(%r15), %rbx
movq 0x58(%r15), %r13
leaq 0x18(%rsp), %r12
leaq 0x38(%rsp), %rbp
cmpq %r13, %rbx
je 0xa45e
movq (%rbx), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x55b0
movq %r12, %rdi
movq %r14, %rsi
callq 0x6e84
testb %al, %al
je 0xa44d
movq %rbp, %rdi
movq %r15, %rsi
callq 0x5594
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
callq 0x6e84
movb %al, 0xf(%rsp)
movq %rbp, %rdi
callq 0x3110
movq %r12, %rdi
callq 0x3110
cmpb $0x0, 0xf(%rsp)
je 0xa455
movq 0x9ba4(%rip), %rdi      # 0x13fc8
leaq 0x363a(%rip), %rsi      # 0xda65
callq 0x3200
movq %rax, %rdi
callq 0x3120
movq %rax, %rdi
movq %r15, %rsi
callq 0xb4e7
movq %rax, %rdi
callq 0x3120
jmp 0xa455
movq %r12, %rdi
callq 0x3110
addq $0x8, %rbx
jmp 0xa3c4
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x33a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9b2c(%rip), %rdi      # 0x13fc8
leaq 0x35f0(%rip), %rsi      # 0xda93
callq 0x3200
movq %rax, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movl %ebx, %esi
callq 0x7096
movq %r15, %rdi
movq %r12, %rsi
callq 0x31f0
leaq 0x3601(%rip), %rsi      # 0xdacd
movq %rax, %rdi
callq 0x3200
movq %rax, %rdi
callq 0x3120
leaq 0x8(%rsp), %rdi
callq 0x3110
movq 0x50(%r14), %r13
movq 0x58(%r14), %rbp
movq 0x9ad3(%rip), %r14      # 0x13fc8
leaq 0x3569(%rip), %r15      # 0xda65
cmpq %rbp, %r13
je 0xa53d
movq (%r13), %r12
movq %r12, %rdi
callq 0x558c
cmpl %ebx, %eax
jne 0xa537
movq %r14, %rdi
movq %r15, %rsi
callq 0x3200
movq %rax, %rdi
callq 0x3120
movq %rax, %rdi
movq %r12, %rsi
callq 0xb4e7
movq %rax, %rdi
callq 0x3120
addq $0x8, %r13
jmp 0xa4fc
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x33a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %rdi
callq 0x32a0
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x32a0
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x9d9c
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x3110
leaq 0x50(%rsp), %rdi
callq 0x3110
testq %r14, %r14
je 0xa88d
leaq 0x70(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x55cc
movq (%r15), %r12
movq 0x8(%r15), %r13
movq %r15, %rdi
callq 0x7348
cmpq %r13, %r12
je 0xa88d
movl $0xd8, %edi
callq 0x3210
movq %rax, %r15
movl 0x84(%rbx), %ebp
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x55cc
movq %rsp, %rdi
movq %r14, %rsi
callq 0x55de
movb $0x1, %r12b
leaq 0x18(%rsp), %rcx
movq %rsp, %r8
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x7d84
leaq 0x68(%rbx), %rdi
leaq 0x70(%rsp), %rsi
movq %r15, (%rsi)
xorl %r12d, %r12d
callq 0xbb4c
movq %rsp, %rdi
callq 0x73de
leaq 0x18(%rsp), %rdi
callq 0x7348
movq %r14, %rdi
callq 0x594a
incl 0x84(%rbx)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movb $0x1, %r12b
jmp 0xa8b7
movq %rax, %rbx
jmp 0xa8c6
movq %rax, %rbx
movq %rsp, %rdi
callq 0x73de
leaq 0x18(%rsp), %rdi
callq 0x7348
testb %r12b, %r12b
je 0xa8f1
movl $0xd8, %esi
movq %r15, %rdi
callq 0x3220
jmp 0xa8f1
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3110
jmp 0xa8e7
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x33a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/pc260533[P]ITC313-TP2/magasin.cpp
// Function: Magasin::afficherCommandeAvecNom(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::afficherCommandeAvecNom(std::string nomClient, std::string prenomClient) {
    std::cout << "La liste des commandes dont le nom du client est " << nomClient << " est :" << std::endl;
    for (Commande *commande : this->listeCommandes) {
        if (commande->getClientCommande()->getNomClient() == nomClient) {
            std::cout << "La commande est : " << std::endl << *commande << 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 0x9621(%rip), %rdi      # 0x13fc8
leaq 0x3139(%rip), %rsi      # 0xdae7
callq 0x3200
movq %rax, %rdi
movq %rbx, %rsi
callq 0x31f0
leaq 0x3108(%rip), %rsi      # 0xdacd
movq %rax, %rdi
callq 0x3200
movq %rax, %rdi
callq 0x3120
movq 0x68(%r15), %r14
movq 0x70(%r15), %r12
leaq 0x8(%rsp), %r15
cmpq %r12, %r14
je 0xaa4b
movq (%r14), %r13
movq %r13, %rdi
callq 0x7c14
movq %r15, %rdi
movq %rax, %rsi
callq 0x55b0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6e84
movl %eax, %ebp
movq %r15, %rdi
callq 0x3110
testb %bpl, %bpl
je 0xaa45
movq 0x95aa(%rip), %rdi      # 0x13fc8
leaq 0x30af(%rip), %rsi      # 0xdad4
callq 0x3200
movq %rax, %rdi
callq 0x3120
movq %rax, %rdi
movq %r13, %rsi
callq 0xb5df
movq %rax, %rdi
callq 0x3120
addq $0x8, %r14
jmp 0xa9e2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pc260533[P]ITC313-TP2/magasin.cpp
// Function: Magasin::initialiserPanierClient(Client*)
void Magasin::initialiserPanierClient(Client *client) {
    std::vector<Produit*> listeProduitsSelectionnesParLeClient;
    for (int i = 0; i < client->getListeNomProduitsSelectionnes().size(); i++) {
        Produit *produit = this->getProduitAvecNomProduit(client->getListeNomProduitsSelectionnes().at(i));
        if (produit) {
            listeProduitsSelectionnesParLeClient.push_back(produit);
        }
        client->initialiserListeProduitSelectionnes(listeProduitsSelectionnesParLeClient);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, (%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
xorl %r12d, %r12d
leaq 0x28(%rsp), %r13
leaq 0x58(%rsp), %rbp
leaq 0x40(%rsp), %r15
movq %r13, %rdi
movq %rbx, %rsi
callq 0x55f4
movq 0x30(%rsp), %r14
subq 0x28(%rsp), %r14
sarq $0x5, %r14
movq %r13, %rdi
callq 0x6df8
cmpq %r12, %r14
jbe 0xab3c
movq %r13, %rdi
movq %rbx, %rsi
callq 0x55f4
movq %r13, %rdi
movq %r12, %rsi
callq 0xb7ca
movq %rbp, %rdi
movq %rax, %rsi
callq 0x32a0
movq (%rsp), %rdi
movq %rbp, %rsi
callq 0x9d30
movq %rax, %r14
movq %rbp, %rdi
callq 0x3110
movq %r13, %rdi
callq 0x6df8
movq %r14, 0x8(%rsp)
testq %r14, %r14
je 0xab14
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6e1a
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
callq 0x6d08
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5c18
movq %r15, %rdi
callq 0x7348
incq %r12
jmp 0xaa91
leaq 0x10(%rsp), %rdi
callq 0x7348
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x3110
jmp 0xab7f
jmp 0xab77
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x7348
jmp 0xab89
jmp 0xab77
movq %rax, %rbx
jmp 0xab89
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6df8
leaq 0x10(%rsp), %rdi
callq 0x7348
movq %rbx, %rdi
callq 0x33a0
nop