LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tbjohns[P]BlitzL1/src/solver.cpp
// Function: BlitzL1::Solver::compute_alpha(BlitzL1::Dataset const*, double, double)
value_t Solver::compute_alpha(const Dataset *data, value_t lambda, value_t theta_scale)
  {
    // Returns alpha, the largest value in [0,1] such that
    // (1 - alpha) * phi + alpha * theta * theta_scale is feasible
    // Requires values of ATphi and ATtheta to be current

    value_t best_alpha = 1.0;
    for (vector<size_t>::iterator j = prioritized_features.begin();
         j != prioritized_features.end();
         ++j)
    {

      value_t norm = priority_norm_j(*j, data);
      if (norm <= 0.0)
        continue;

      value_t l = ATphi[*j];
      value_t r = theta_scale * ATtheta[*j];
      if (fabs(r) <= lambda)
        continue;

      value_t alpha;
      if (r >= 0)
        alpha = (lambda - l) / (r - l);
      else
        alpha = (-lambda - l) / (r - l);

      if (alpha < best_alpha)
        best_alpha = alpha;
    }
    return best_alpha;
  }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movsd %xmm0, 0x60(%rsp)
movsd %xmm1, 0x58(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movsd 0x5b44(%rip), %xmm0     # 0x1c150
movsd %xmm0, 0x50(%rsp)
addq $0xa0, %rdi
callq 0xe100
movq %rax, 0x48(%rsp)
movq 0x18(%rsp), %rdi
addq $0xa0, %rdi
callq 0xf890
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xe4d0
testb $0x1, %al
jne 0x16651
jmp 0x167b1
leaq 0x48(%rsp), %rdi
callq 0xf120
movq 0x18(%rsp), %rdi
movq (%rax), %rsi
movq 0x68(%rsp), %rdx
callq 0xe050
movsd %xmm0, 0x38(%rsp)
xorps %xmm0, %xmm0
ucomisd 0x38(%rsp), %xmm0
jb 0x16683
jmp 0x167a2
movq 0x18(%rsp), %rax
addq $0x60, %rax
movq %rax, (%rsp)
leaq 0x48(%rsp), %rdi
callq 0xf120
movq (%rsp), %rdi
movq (%rax), %rsi
callq 0xebf0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
addq $0x30, %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xf120
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
callq 0xebf0
movsd 0x10(%rsp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm1
movaps 0x593f(%rip), %xmm0     # 0x1c040
pand %xmm0, %xmm1
movsd 0x60(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x16716
jmp 0x167a2
movsd 0x28(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x16749
movsd 0x60(%rsp), %xmm0
subsd 0x30(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
subsd 0x30(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x16782
movsd 0x60(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
subsd 0x30(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
subsd 0x30(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm1
movsd 0x50(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x167a0
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
jmp 0x167a2
leaq 0x48(%rsp), %rdi
callq 0xf5c0
jmp 0x16623
movsd 0x50(%rsp), %xmm0
addq $0x78, %rsp
retq
nopl (%rax)
// File: tbjohns[P]BlitzL1/src/solver.cpp
// Function: BlitzL1::Solver::update_phi(double, double)
void Solver::update_phi(value_t alpha, value_t theta_scale)
  {
    // Updates phi via phi = (1-alpha)*phi + alpha*theta*theta_scale
    // Also updates ATphi
    // Requires values of ATtheta and ATphi to be current

    for (vector<size_t>::iterator j = prioritized_features.begin();
         j != prioritized_features.end();
         ++j)
    {
      ATphi[*j] = (1 - alpha) * ATphi[*j] + alpha * theta_scale * ATtheta[*j];
    }
    for (size_t i = 0; i < phi.size(); ++i)
      phi[i] = (1 - alpha) * phi[i] + alpha * theta_scale * theta[i];
  }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movsd %xmm0, 0x88(%rsp)
movsd %xmm1, 0x80(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x60(%rsp)
addq $0xa0, %rdi
callq 0xe100
movq %rax, 0x78(%rsp)
movq 0x60(%rsp), %rdi
addq $0xa0, %rdi
callq 0xf890
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xe4d0
testb $0x1, %al
jne 0x1682d
jmp 0x16918
movq 0x60(%rsp), %rax
movsd 0x5916(%rip), %xmm0     # 0x1c150
subsd 0x88(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
addq $0x60, %rax
movq %rax, 0x28(%rsp)
leaq 0x78(%rsp), %rdi
callq 0xf120
movq 0x28(%rsp), %rdi
movq (%rax), %rsi
callq 0xebf0
movq %rax, %rcx
movq 0x60(%rsp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x88(%rsp), %xmm0
mulsd 0x80(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
addq $0x30, %rax
movq %rax, 0x30(%rsp)
leaq 0x78(%rsp), %rdi
callq 0xf120
movq 0x30(%rsp), %rdi
movq (%rax), %rsi
callq 0xebf0
movsd 0x38(%rsp), %xmm1
movsd 0x40(%rsp), %xmm0
movsd 0x48(%rsp), %xmm2
movq %rax, %rcx
movq 0x60(%rsp), %rax
mulsd (%rcx), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x58(%rsp)
addq $0x60, %rax
movq %rax, 0x50(%rsp)
leaq 0x78(%rsp), %rdi
callq 0xf120
movq 0x50(%rsp), %rdi
movq (%rax), %rsi
callq 0xebf0
movsd 0x58(%rsp), %xmm0
movsd %xmm0, (%rax)
leaq 0x78(%rsp), %rdi
callq 0xf5c0
jmp 0x167ff
movq $0x0, 0x68(%rsp)
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
addq $0x48, %rdi
callq 0xe730
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x169f7
movq 0x60(%rsp), %rdi
movsd 0x57f9(%rip), %xmm0     # 0x1c150
subsd 0x88(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
addq $0x48, %rdi
movq 0x68(%rsp), %rsi
callq 0xebf0
movq 0x60(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x88(%rsp), %xmm0
mulsd 0x80(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x68(%rsp), %rsi
callq 0xebf0
movsd (%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm2
movq 0x60(%rsp), %rdi
mulsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
addq $0x48, %rdi
movq 0x68(%rsp), %rsi
callq 0xebf0
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x68(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x68(%rsp)
jmp 0x16921
addq $0x98, %rsp
retq
nop
// File: masaers[P]blind/./blind.hpp
// Function: decltype(auto) com::masaers::blind::blind_t<main::$_1, std::_Placeholder<1> const&, std::_Placeholder<2> const&, main::$_0>::operator()<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>&&, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>&&) const
inline decltype(auto) operator()(LateArgs&&... late_args) const {
      return detail::call_with_merged_args(func_m,
                                           args_m,
                                           std::make_index_sequence<sizeof...(Args)>(),
                                           std::forward<LateArgs>(late_args)...);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, %rsi
addq $0x1, %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x3860
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: masaers[P]blind/./blind.hpp
// Function: decltype(auto) com::masaers::blind::blind_t<main::$_3, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>>::operator()<main::$_4>(main::$_4&&)
inline decltype(auto) operator()(LateArgs&&... late_args) {
      return detail::call_with_merged_args(func_m,
                                           static_cast<const args_type>(args_m),
                                           std::make_index_sequence<sizeof...(Args)>(),
                                           std::forward<LateArgs>(late_args)...);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq 0x8(%rdi), %rax
movq %rax, -0x20(%rbp)
movq 0x10(%rdi), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdx
leaq -0x20(%rbp), %rsi
callq 0x69e0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Serfati[P]Heroes-of-Might-and-Magic-3/main.cpp
// Function: main
int main(int argc,char *argv[]) {

    if ( argv[2] )
        /*    New Game   */  {
        /* - [ Arguments ] -    argv[0] is the name of the program; Heroes  */
        const string playOrLoad = argv[1];
        const int warriors = atoi(argv[2]);
        const int thieves = atoi(argv[3]);
        const int Necromancers = atoi(argv[4]);
        GameUnit *gamePlay = new GameUnit(warriors,thieves,Necromancers);
        delete gamePlay;
    } else  /*  Load last Game  */{
        GameUnit *gamePlay = new GameUnit();
        delete gamePlay;
    }
//    cout << "\t...main.cpp END...‬‬" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4b7c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x70(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4530
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x4c10
jmp 0x4a94
leaq -0x31(%rbp), %rdi
callq 0x4360
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4480
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4480
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x4480
movl %eax, -0x50(%rbp)
movl $0x38, %edi
callq 0x4320
movq %rax, -0x78(%rbp)
jmp 0x4add
movq -0x78(%rbp), %rdi
movl -0x48(%rbp), %esi
movl -0x4c(%rbp), %edx
movl -0x50(%rbp), %ecx
callq 0x62e0
jmp 0x4af1
movq -0x78(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0x4b1e
movq -0x80(%rbp), %rdi
callq 0x7290
movq -0x80(%rbp), %rdi
movl $0x38, %esi
callq 0x4330
leaq -0x30(%rbp), %rdi
callq 0x4200
jmp 0x4bf4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x4360
jmp 0x4c00
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x4b6e
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
movl $0x38, %esi
callq 0x4330
leaq -0x30(%rbp), %rdi
callq 0x4200
jmp 0x4c00
movl $0x38, %edi
callq 0x4320
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
callq 0x4f60
jmp 0x4b9a
movq -0x88(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x90(%rbp)
cmpq $0x0, %rax
je 0x4bd3
movq -0x90(%rbp), %rdi
callq 0x7290
movq -0x90(%rbp), %rdi
movl $0x38, %esi
callq 0x4330
jmp 0x4bf4
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
movl $0x38, %esi
callq 0x4330
jmp 0x4c00
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4520
nopl (%rax)
// File: Serfati[P]Heroes-of-Might-and-Magic-3/GameUnit.cpp
// Function: GameUnit::rmdir()
void GameUnit::rmdir() {
    try {
        string comand = "find * -type d | grep -v \"^CMakeFiles\" | xargs rm -rf";
        const char *runComand = comand.c_str();
        system(runComand);
    } catch( std::exception &e ) {
        cout << "Error deleting directory!n" << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x4530
movq -0x58(%rbp), %rdx
leaq 0xc7b6(%rip), %rsi      # 0x1348a
leaq -0x28(%rbp), %rdi
callq 0x4c10
jmp 0x6cdf
leaq -0x29(%rbp), %rdi
callq 0x4360
leaq -0x28(%rbp), %rdi
callq 0x4140
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x42b0
jmp 0x6d00
leaq -0x28(%rbp), %rdi
callq 0x4200
jmp 0x6d80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x4360
jmp 0x6d37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4200
movl -0x3c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x6d9b
movq -0x38(%rbp), %rdi
callq 0x4130
movq %rax, -0x50(%rbp)
movq 0x15269(%rip), %rdi     # 0x1bfc0
leaq 0xc762(%rip), %rsi      # 0x134c0
callq 0x4310
movq %rax, -0x60(%rbp)
jmp 0x6d69
movq -0x60(%rbp), %rdi
movq 0x1523c(%rip), %rsi     # 0x1bfb0
callq 0x4340
jmp 0x6d7b
callq 0x44c0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x44c0
jmp 0x6d99
jmp 0x6d9b
movq -0x38(%rbp), %rdi
callq 0x4520
movq %rax, %rdi
callq 0x4f20
nopl (%rax)
// File: Serfati[P]Heroes-of-Might-and-Magic-3/GameUnit.cpp
// Function: GameUnit::mkdir()
bool GameUnit::mkdir() {
    try {
        string comand = "mkdir game";
        const char *runComand = comand.c_str();
        system(runComand);
    } catch( std::exception &e ) {
        cout << "Error creating directory!" << endl;
        return 0;
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x4530
movq -0x60(%rbp), %rdx
leaq 0xc691(%rip), %rsi      # 0x13465
leaq -0x30(%rbp), %rdi
callq 0x4c10
jmp 0x6ddf
leaq -0x31(%rbp), %rdi
callq 0x4360
leaq -0x30(%rbp), %rdi
callq 0x4140
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x42b0
jmp 0x6e00
leaq -0x30(%rbp), %rdi
callq 0x4200
jmp 0x6e9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x4360
jmp 0x6e3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4200
movl -0x44(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x6ead
movq -0x40(%rbp), %rdi
callq 0x4130
movq %rax, -0x58(%rbp)
movq 0x15166(%rip), %rdi     # 0x1bfc0
leaq 0xc60f(%rip), %rsi      # 0x13470
callq 0x4310
movq %rax, -0x68(%rbp)
jmp 0x6e6c
movq -0x68(%rbp), %rdi
movq 0x15139(%rip), %rsi     # 0x1bfb0
callq 0x4340
jmp 0x6e7e
movb $0x0, -0x1(%rbp)
callq 0x44c0
jmp 0x6ea2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x44c0
jmp 0x6e9c
jmp 0x6ead
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4520
movq %rax, %rdi
callq 0x4f20
nop
// File: Serfati[P]Heroes-of-Might-and-Magic-3/GameUnit.cpp
// Function: GameUnit::getHeroByName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Hero *GameUnit::getHeroByName(string heroName) {
    for (int i = 0; i < ::numberOfPlayers; ++ i)
        if ( realOrder[i]->getName() == heroName )
            return realOrder[i];
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x146f8(%rip), %eax     # 0x1c354
jge 0x7cbc
movq -0x48(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x86e0
movq (%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0xf0c0
movq -0x50(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x8e90
movb %al, -0x51(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4200
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x7c99
jmp 0x7caf
movq -0x48(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x86e0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x7cc4
jmp 0x7cb1
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7c53
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: Serfati[P]Heroes-of-Might-and-Magic-3/GameUnit.cpp
// Function: GameUnit::nextTurn()
void GameUnit::nextTurn() {
    int check = currentTurn;
    if ( check + 1 >= ::numberOfPlayers ) {
        currentTurn = 0;
        ::roundNumber ++;
        mainMenu(turnOrder[currentTurn]);
    } else {
        currentTurn ++;
        mainMenu(turnOrder[currentTurn]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x30(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
cmpl 0x1465e(%rip), %eax     # 0x1c354
jl 0x7d30
movq -0x18(%rbp), %rax
movl $0x0, 0x30(%rax)
movl 0x14647(%rip), %ecx     # 0x1c350
addl $0x1, %ecx
movl %ecx, 0x1463e(%rip)     # 0x1c350
movq %rax, %rdi
addq $0x18, %rdi
movslq 0x30(%rax), %rsi
callq 0x86e0
movq -0x18(%rbp), %rdi
movq (%rax), %rsi
callq 0x59c0
jmp 0x7d59
movq -0x18(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movq %rax, %rdi
addq $0x18, %rdi
movslq 0x30(%rax), %rsi
callq 0x86e0
movq -0x18(%rbp), %rdi
movq (%rax), %rsi
callq 0x59c0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Serfati[P]Heroes-of-Might-and-Magic-3/GameUnit.cpp
// Function: GameUnit::showHeroes()
void GameUnit::showHeroes() {
    for (int i = 0; i < ::numberOfPlayers; ++ i) {
        if ( realOrder[i]->getName() != turnOrder[currentTurn]->getName()) {
            cout << realOrder[i]->getName() << " ";
            cout << realOrder[i]->displayType() << endl;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x145ca(%rip), %eax     # 0x1c354
jge 0x7f1f
movq -0xa8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x86e0
movq (%rax), %rsi
leaq -0x30(%rbp), %rdi
callq 0xf0c0
movq -0xa8(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movslq 0x30(%rax), %rsi
callq 0x86e0
movq (%rax), %rsi
leaq -0x50(%rbp), %rdi
callq 0xf0c0
jmp 0x7dd1
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x8f20
movb %al, -0xa9(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4200
leaq -0x30(%rbp), %rdi
callq 0x4200
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x7e05
jmp 0x7f0f
movq -0xa8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x86e0
movq (%rax), %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0xf0c0
movq -0xc0(%rbp), %rsi
movq 0x1418a(%rip), %rdi     # 0x1bfc0
callq 0x42f0
movq %rax, -0xb8(%rbp)
jmp 0x7e44
movq -0xb8(%rbp), %rdi
leaq 0xb95b(%rip), %rsi      # 0x137ad
callq 0x4310
jmp 0x7e59
leaq -0x80(%rbp), %rdi
callq 0x4200
movq -0xa8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x86e0
movq (%rax), %rsi
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0xfd80
movq -0xd0(%rbp), %rsi
movq 0x1412a(%rip), %rdi     # 0x1bfc0
callq 0x42f0
movq %rax, -0xc8(%rbp)
jmp 0x7ea4
movq -0xc8(%rbp), %rdi
movq 0x140fe(%rip), %rsi     # 0x1bfb0
callq 0x4340
jmp 0x7eb9
leaq -0xa0(%rbp), %rdi
callq 0x4200
jmp 0x7f0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4200
jmp 0x7f28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x4200
jmp 0x7f28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x4200
jmp 0x7f28
jmp 0x7f11
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7d81
addq $0xd0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x4520
nopw %cs:(%rax,%rax)
// File: Serfati[P]Heroes-of-Might-and-Magic-3/GameUnit.cpp
// Function: GameUnit::eraseKilled()
void GameUnit::eraseKilled() {
    unsigned long size = realOrder.size();
    for (int i = 0; i < size; i ++) {
        if ( realOrder[i]->inLife() == 0 && realOrder[i]->showArmy() == "." ) {
            realOrder[i]->rmdir();
            realOrder[i]->~Hero();
            realOrder.erase(realOrder.begin() + i);
            ::numberOfPlayers --;
        }
    }
    realOrder.shrink_to_fit();
    turnOrder.shrink_to_fit();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x8a60
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x80b0
movq -0x78(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x86e0
movq (%rax), %rdi
callq 0x8900
andb $0x1, %al
movzbl %al, %ecx
movb $0x0, -0x39(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x79(%rbp)
jne 0x7fe1
movq -0x78(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x86e0
movq (%rax), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xf910
movq -0x88(%rbp), %rdi
movb $0x1, -0x39(%rbp)
leaq 0xb0cc(%rip), %rsi      # 0x1309b
callq 0x8a80
movb %al, -0x7a(%rbp)
jmp 0x7fd9
movb -0x7a(%rbp), %al
movb %al, -0x79(%rbp)
jmp 0x7fe1
movb -0x79(%rbp), %al
movb %al, -0x89(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x7ff2
jmp 0x7ffb
leaq -0x38(%rbp), %rdi
callq 0x4200
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x800a
jmp 0x80a0
movq -0x78(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x86e0
movq (%rax), %rdi
callq 0x110c0
movq -0x78(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x86e0
movq (%rax), %rdi
callq 0x8850
movq -0x78(%rbp), %rdi
callq 0x8790
movq %rax, -0x68(%rbp)
movslq -0x14(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x8b20
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x8b60
movq -0x78(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x8ab0
movq %rax, -0x70(%rbp)
movl 0x142de(%rip), %eax     # 0x1c354
addl $-0x1, %eax
movl %eax, 0x142d5(%rip)     # 0x1c354
jmp 0x80a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x8095
jmp 0x809e
leaq -0x38(%rbp), %rdi
callq 0x4200
jmp 0x80cf
jmp 0x80a2
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7f67
movq -0x78(%rbp), %rdi
callq 0x8ba0
movq -0x78(%rbp), %rdi
addq $0x18, %rdi
callq 0x8ba0
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4520
nopl (%rax,%rax)
// File: Serfati[P]Heroes-of-Might-and-Magic-3/GameUnit.cpp
// Function: GameUnit::getTurnOrder[abi:cxx11]()
string GameUnit::getTurnOrder() {
    string turnList = "";
    for (Hero *i : turnOrder)
        turnList += i->getName() + " ";
    return turnList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x4530
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rdx
leaq 0xb3f3(%rip), %rsi      # 0x1352b
callq 0x4c10
jmp 0x813f
leaq -0x12(%rbp), %rdi
callq 0x4360
movq -0xa0(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x8790
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x87c0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x87f0
testb $0x1, %al
jne 0x8187
jmp 0x824d
leaq -0x38(%rbp), %rdi
callq 0x8830
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0xf0c0
jmp 0x81a9
leaq 0xb5fd(%rip), %rdx      # 0x137ad
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x8920
jmp 0x81c2
movq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x43f0
jmp 0x81d4
leaq -0x68(%rbp), %rdi
callq 0x4200
leaq -0x88(%rbp), %rdi
callq 0x4200
leaq -0x38(%rbp), %rdi
callq 0x88c0
jmp 0x8171
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x4360
jmp 0x827f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x8273
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x823f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4200
leaq -0x88(%rbp), %rdi
callq 0x4200
jmp 0x8273
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x8263
movq -0x98(%rbp), %rdi
callq 0x4200
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x4200
movq -0x20(%rbp), %rdi
callq 0x4520
nopl (%rax,%rax)
// File: Serfati[P]Heroes-of-Might-and-Magic-3/Army.cpp
// Function: Army::getArmySize()
int Army::getArmySize() {
    int size = 0;
    for (int i : armyList)
        size += i;
    return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, -0xc(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xce00
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xce30
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xce60
testb $0x1, %al
jne 0xc0c8
jmp 0xc0ea
leaq -0x20(%rbp), %rdi
callq 0xcea0
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xcec0
jmp 0xc0b5
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Serfati[P]Heroes-of-Might-and-Magic-3/Army.cpp
// Function: Army::saveArmy[abi:cxx11]()
std::string Army::saveArmy() {
    std::string saveArmy = "";
    for (int i = 4; i >= 0; i --) {
        saveArmy += std::to_string(armyList[i]);
        if ( i != 0 )
            saveArmy += " ";
        else
            saveArmy += "";
    }
    return saveArmy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4530
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x6fd8(%rip), %rsi      # 0x1352b
callq 0x4c10
jmp 0xc55a
leaq -0x12(%rbp), %rdi
callq 0x4360
movl $0x4, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0xc620
movq -0x60(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0xcde0
movl (%rax), %esi
leaq -0x48(%rbp), %rdi
callq 0xcee0
jmp 0xc58e
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x43f0
jmp 0xc59d
leaq -0x48(%rbp), %rdi
callq 0x4200
cmpl $0x0, -0x28(%rbp)
je 0xc5fc
movq -0x58(%rbp), %rdi
leaq 0x71f6(%rip), %rsi      # 0x137ad
callq 0x4300
jmp 0xc5be
jmp 0xc610
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x4360
jmp 0xc646
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xc63d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4200
jmp 0xc63d
movq -0x58(%rbp), %rdi
leaq 0x6f24(%rip), %rsi      # 0x1352b
callq 0x4300
jmp 0xc60e
jmp 0xc610
jmp 0xc612
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xc56a
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xc633
movq -0x58(%rbp), %rdi
callq 0x4200
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x4200
movq -0x20(%rbp), %rdi
callq 0x4520
nop
// File: Serfati[P]Heroes-of-Might-and-Magic-3/Army.cpp
// Function: Army::buildArmy(int, int, int, int, int)
void Army::buildArmy(int BD,int WZ,int ARC,int VMP,int ZMB) {
    armyList[4] = BD;
    armyList[3] = WZ;
    armyList[2] = ARC;
    armyList[1] = VMP;
    armyList[0] = ZMB;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x38(%rbp)
movl $0x4, %esi
callq 0xcde0
movl -0x38(%rbp), %ecx
movq -0x28(%rbp), %rdi
movl %ecx, (%rax)
movl -0x10(%rbp), %eax
movl %eax, -0x34(%rbp)
movl $0x3, %esi
callq 0xcde0
movl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rdi
movl %ecx, (%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
movl $0x2, %esi
callq 0xcde0
movl -0x30(%rbp), %ecx
movq -0x28(%rbp), %rdi
movl %ecx, (%rax)
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl $0x1, %esi
callq 0xcde0
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rdi
movl %ecx, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0xcde0
movl -0x20(%rbp), %ecx
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Serfati[P]Heroes-of-Might-and-Magic-3/Army.cpp
// Function: Army::reBuild()
void Army::reBuild() {
    for(Creature* i : realArmy)
        delete i;
    realArmy = {new Zombie(),new Vampire(),new Archer(),
                new Wizard(),new BlackDragon()};

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd050
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd080
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xd0b0
testb $0x1, %al
jne 0xc74c
jmp 0xc781
leaq -0x18(%rbp), %rdi
callq 0xd0f0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0xc774
movq -0x80(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xc776
leaq -0x18(%rbp), %rdi
callq 0xd110
jmp 0xc739
movl $0x18, %edi
callq 0x4320
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
callq 0x12750
jmp 0xc79f
movq -0x88(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rax
movq %rax, -0x98(%rbp)
movl $0x18, %edi
callq 0x4320
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
callq 0x125e0
jmp 0xc7d3
movq -0x98(%rbp), %rax
movq -0x90(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x50(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl $0x18, %edi
callq 0x4320
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
callq 0x12410
jmp 0xc80d
movq -0xa8(%rbp), %rax
movq -0xa0(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x48(%rbp), %rax
movq %rax, -0xb8(%rbp)
movl $0x18, %edi
callq 0x4320
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
callq 0x12270
jmp 0xc847
movq -0xb8(%rbp), %rax
movq -0xb0(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x40(%rbp), %rax
movq %rax, -0xc8(%rbp)
movl $0x18, %edi
callq 0x4320
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
callq 0x120e0
jmp 0xc881
movq -0x78(%rbp), %rdi
movq -0xc8(%rbp), %rax
movq -0xc0(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x5, -0x30(%rbp)
addq $0x18, %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xc9b0
addq $0xd0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x18, %esi
callq 0x4330
jmp 0xc959
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x18, %esi
callq 0x4330
jmp 0xc959
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x18, %esi
callq 0x4330
jmp 0xc959
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x18, %esi
callq 0x4330
jmp 0xc959
movq -0xc0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x18, %esi
callq 0x4330
movq -0x68(%rbp), %rdi
callq 0x4520
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Serfati[P]Heroes-of-Might-and-Magic-3/Hero.cpp
// Function: Hero::Hero(Hero&)
Hero::Hero(Hero &another) {
    setName(another.getName());
    this->type = another.getType();
    this->gold = another.getGold();
    this->army = another.army;
    isAlive = another.isAlive;;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
leaq 0xcac1(%rip), %rax      # 0x1ba60
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x48(%rbp)
callq 0x4420
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xf0c0
jmp 0xefbe
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xf060
jmp 0xefcd
leaq -0x30(%rbp), %rdi
callq 0x4200
movq -0x10(%rbp), %rdi
callq 0xf0f0
movl %eax, -0x54(%rbp)
jmp 0xefe4
movq -0x50(%rbp), %rax
movl -0x54(%rbp), %ecx
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rdi
callq 0xf110
movsd %xmm0, -0x60(%rbp)
jmp 0xeffe
movq -0x50(%rbp), %rax
movsd -0x60(%rbp), %xmm0
movsd %xmm0, 0x30(%rax)
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rcx
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rcx
movb 0x3a(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x3a(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xf04e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4200
movq -0x48(%rbp), %rdi
callq 0x4200
movq -0x38(%rbp), %rdi
callq 0x4520
// File: Serfati[P]Heroes-of-Might-and-Magic-3/Hero.cpp
// Function: Hero::setName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Hero::setName(const string nName) {
    if ( nName.size() < 0 )
        return 0;
    this->name = nName;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x4230
cmpq $0x0, %rax
jae 0xf098
movb $0x0, -0x1(%rbp)
jmp 0xf0ad
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x4030
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Serfati[P]Heroes-of-Might-and-Magic-3/Hero.cpp
// Function: Hero::mkdir()
bool Hero::mkdir() {
    errno = 0;
    try {
        string command = "mkdir -p Heros/" + getName();
        auto runCommand = command.c_str();
        int dir_result = system(runCommand);
        if ( dir_result != 0 && errno != EEXIST )
            return 0;
    }
    catch( std::exception &e ) {
        cout << "Error creating directory!n" << endl;
        return 0;
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0x4040
movq -0x80(%rbp), %rsi
movl $0x0, (%rax)
leaq -0x50(%rbp), %rdi
callq 0xf0c0
jmp 0xf6d1
leaq 0x4027(%rip), %rsi      # 0x136ff
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0xd000
jmp 0xf6e7
leaq -0x50(%rbp), %rdi
callq 0x4200
leaq -0x30(%rbp), %rdi
callq 0x4140
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0x42b0
movl %eax, -0x84(%rbp)
jmp 0xf70e
movl -0x84(%rbp), %eax
movl %eax, -0x6c(%rbp)
cmpl $0x0, -0x6c(%rbp)
je 0xf7d9
callq 0x4040
cmpl $0x11, (%rax)
je 0xf7d9
movb $0x0, -0x1(%rbp)
movl $0x1, -0x70(%rbp)
jmp 0xf7e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xf779
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4200
jmp 0xf779
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4200
movl -0x5c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xf81d
movq -0x58(%rbp), %rdi
callq 0x4130
movq %rax, -0x78(%rbp)
movq 0xc823(%rip), %rdi      # 0x1bfc0
leaq 0x3f6b(%rip), %rsi      # 0x1370f
callq 0x4310
movq %rax, -0x90(%rbp)
jmp 0xf7b2
movq -0x90(%rbp), %rdi
movq 0xc7f0(%rip), %rsi      # 0x1bfb0
callq 0x4340
jmp 0xf7c7
movb $0x0, -0x1(%rbp)
movl $0x1, -0x70(%rbp)
callq 0x44c0
jmp 0xf80f
movl $0x0, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4200
movl -0x70(%rbp), %eax
testl %eax, %eax
je 0xf7f4
jmp 0xf7f2
jmp 0xf80f
jmp 0xf80b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x44c0
jmp 0xf809
jmp 0xf81d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x4520
movq %rax, %rdi
callq 0x4f20
nop
// File: Serfati[P]Heroes-of-Might-and-Magic-3/Hero.cpp
// Function: Hero::setType(int)
void Hero::setType(int type) {
    switch ( type ) {
        case 0:
            this->type = warrior;
            break;
        case 1:
            this->type = thief;
            break;
        case 2:
            this->type = necromancer;
            break;
        default:
            this->type = UnknownType;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0xf863
jmp 0xf84f
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0xf870
jmp 0xf859
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0xf87d
jmp 0xf88a
movq -0x18(%rbp), %rax
movl $0x0, 0x28(%rax)
jmp 0xf895
movq -0x18(%rbp), %rax
movl $0x1, 0x28(%rax)
jmp 0xf895
movq -0x18(%rbp), %rax
movl $0x2, 0x28(%rax)
jmp 0xf895
movq -0x18(%rbp), %rax
movl $0x3, 0x28(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: Serfati[P]Heroes-of-Might-and-Magic-3/Hero.cpp
// Function: Hero::buyCreature(double, int, int, int)
bool Hero::buyCreature(double budget,int creatureType,int quantity,int unitPrice) {
    Creature c;
    if ( quantity > 0 && budget > 0 && creatureType >= 0 ) {
        army->addUnit(creatureType,quantity);
        this->gold -= unitPrice * quantity;
        c.~Creature();
        return true;
    } else return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x11b00
cmpl $0x0, -0x20(%rbp)
jle 0xfb44
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xfb44
cmpl $0x0, -0x1c(%rbp)
jl 0xfb44
movq -0x58(%rbp), %rax
movq 0x40(%rax), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
callq 0xc100
jmp 0xfafa
movq -0x58(%rbp), %rax
movl -0x24(%rbp), %ecx
imull -0x20(%rbp), %ecx
cvtsi2sd %ecx, %xmm1
movsd 0x30(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rax)
leaq -0x40(%rbp), %rdi
callq 0x8a20
movb $0x1, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0xfb4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8a20
jmp 0xfb63
movb $0x0, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8a20
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4520
nopl (%rax)
// File: Serfati[P]Heroes-of-Might-and-Magic-3/Hero.cpp
// Function: Hero::showHero()
void Hero::showHero() {
    cout << getName() << " ";
    cout << displayType() << ":" << endl;
    cout << getGold() << endl;
    if ( showArmy() != "." )
        cout << showArmy() << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xf0c0
movq -0xa8(%rbp), %rsi
movq 0xc418(%rip), %rdi      # 0x1bfc0
callq 0x42f0
movq %rax, -0xa0(%rbp)
jmp 0xfbb6
movq -0xa0(%rbp), %rdi
leaq 0x3be9(%rip), %rsi      # 0x137ad
callq 0x4310
jmp 0xfbcb
leaq -0x28(%rbp), %rdi
callq 0x4200
movq -0xb0(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0xfd80
movq -0xc0(%rbp), %rsi
movq 0xc3c7(%rip), %rdi      # 0x1bfc0
callq 0x42f0
movq %rax, -0xb8(%rbp)
jmp 0xfc07
movq -0xb8(%rbp), %rdi
leaq 0x3686(%rip), %rsi      # 0x1329b
callq 0x4310
movq %rax, -0xc8(%rbp)
jmp 0xfc23
movq -0xc8(%rbp), %rdi
movq 0xc37f(%rip), %rsi      # 0x1bfb0
callq 0x4340
jmp 0xfc38
leaq -0x58(%rbp), %rdi
callq 0x4200
movq -0xb0(%rbp), %rdi
callq 0xf110
movq 0xc36c(%rip), %rdi      # 0x1bfc0
callq 0x45a0
movq %rax, %rdi
movq 0xc34d(%rip), %rsi      # 0x1bfb0
callq 0x4340
movq -0xb0(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0xf910
movq -0xd8(%rbp), %rdi
leaq 0x340e(%rip), %rsi      # 0x1309b
callq 0x118a0
movb %al, -0xc9(%rbp)
jmp 0xfc9a
leaq -0x78(%rbp), %rdi
callq 0x4200
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0xfcb2
jmp 0xfd6a
movq -0xb0(%rbp), %rsi
leaq -0x98(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0xf910
movq -0xe8(%rbp), %rsi
movq 0xc2e6(%rip), %rdi      # 0x1bfc0
callq 0x42f0
movq %rax, -0xe0(%rbp)
jmp 0xfce8
movq -0xe0(%rbp), %rdi
movq 0xc2ba(%rip), %rsi      # 0x1bfb0
callq 0x4340
jmp 0xfcfd
leaq -0x98(%rbp), %rdi
callq 0x4200
jmp 0xfd6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4200
jmp 0xfd73
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4200
jmp 0xfd73
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x4200
jmp 0xfd73
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x4200
jmp 0xfd73
addq $0xf0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x4520
nopl (%rax)
// File: Serfati[P]Heroes-of-Might-and-Magic-3/Hero.cpp
// Function: Hero::displayType[abi:cxx11]()
string Hero::displayType() {
    switch ( type ) {
        case 0:
            return "Warrior";

        case 1:
            return "Thief";

        case 2:
            return "Necromancer";

        default:
            return "UnknownType";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0xfdc6
jmp 0xfdab
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0xfe11
jmp 0xfdb5
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0xfe5c
jmp 0xfea1
leaq -0x11(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x4530
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x3956(%rip), %rsi      # 0x13738
callq 0x4c10
jmp 0xfde9
leaq -0x11(%rbp), %rdi
callq 0x4360
jmp 0xfee6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x4360
jmp 0xfef0
leaq -0x25(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4530
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x3913(%rip), %rsi      # 0x13740
callq 0x4c10
jmp 0xfe34
leaq -0x25(%rbp), %rdi
callq 0x4360
jmp 0xfee6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x4360
jmp 0xfef0
leaq -0x26(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x4530
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x38ce(%rip), %rsi      # 0x13746
callq 0x4c10
jmp 0xfe7f
leaq -0x26(%rbp), %rdi
callq 0x4360
jmp 0xfee6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x26(%rbp), %rdi
callq 0x4360
jmp 0xfef0
leaq -0x27(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x4530
movq -0x40(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x3895(%rip), %rsi      # 0x13752
callq 0x4c10
jmp 0xfec4
leaq -0x27(%rbp), %rdi
callq 0x4360
jmp 0xfee6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x27(%rbp), %rdi
callq 0x4360
jmp 0xfef0
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x4520
nopl (%rax)
// File: Serfati[P]Heroes-of-Might-and-Magic-3/Hero.cpp
// Function: Hero::showHeroFight()
void Hero::showHeroFight() {
    cout << getName() << " ";
    cout << displayType() << ":" << endl;
    if ( showArmy() != "." )
        cout << showArmy() << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xf0c0
movq -0xa8(%rbp), %rsi
movq 0xc088(%rip), %rdi      # 0x1bfc0
callq 0x42f0
movq %rax, -0xa0(%rbp)
jmp 0xff46
movq -0xa0(%rbp), %rdi
leaq 0x3859(%rip), %rsi      # 0x137ad
callq 0x4310
jmp 0xff5b
leaq -0x28(%rbp), %rdi
callq 0x4200
movq -0xb0(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0xfd80
movq -0xc0(%rbp), %rsi
movq 0xc037(%rip), %rdi      # 0x1bfc0
callq 0x42f0
movq %rax, -0xb8(%rbp)
jmp 0xff97
movq -0xb8(%rbp), %rdi
leaq 0x32f6(%rip), %rsi      # 0x1329b
callq 0x4310
movq %rax, -0xc8(%rbp)
jmp 0xffb3
movq -0xc8(%rbp), %rdi
movq 0xbfef(%rip), %rsi      # 0x1bfb0
callq 0x4340
jmp 0xffc8
leaq -0x58(%rbp), %rdi
callq 0x4200
movq -0xb0(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0xf910
movq -0xd8(%rbp), %rdi
leaq 0x30a5(%rip), %rsi      # 0x1309b
callq 0x118a0
movb %al, -0xc9(%rbp)
jmp 0x10003
leaq -0x78(%rbp), %rdi
callq 0x4200
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0x1001b
jmp 0x100d3
movq -0xb0(%rbp), %rsi
leaq -0x98(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0xf910
movq -0xe8(%rbp), %rsi
movq 0xbf7d(%rip), %rdi      # 0x1bfc0
callq 0x42f0
movq %rax, -0xe0(%rbp)
jmp 0x10051
movq -0xe0(%rbp), %rdi
movq 0xbf51(%rip), %rsi      # 0x1bfb0
callq 0x4340
jmp 0x10066
leaq -0x98(%rbp), %rdi
callq 0x4200
jmp 0x100d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4200
jmp 0x100dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4200
jmp 0x100dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x4200
jmp 0x100dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x4200
jmp 0x100dc
addq $0xf0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x4520
nopw %cs:(%rax,%rax)
// File: Serfati[P]Heroes-of-Might-and-Magic-3/Hero.cpp
// Function: Hero::rmdir()
void Hero::rmdir() {
    isAlive = false;
    try {
        string command = "rm -rf Heros/" + getName();
        const char *runCommand = command.c_str();
        system(runCommand);
    }
    catch( std::exception &e ) {
        cout << "Error deleting directory!n" << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movb $0x0, 0x3a(%rsi)
leaq -0x48(%rbp), %rdi
callq 0xf0c0
jmp 0x110df
leaq 0x2644(%rip), %rsi      # 0x1372a
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0xd000
jmp 0x110f5
leaq -0x48(%rbp), %rdi
callq 0x4200
leaq -0x28(%rbp), %rdi
callq 0x4140
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x42b0
jmp 0x11116
leaq -0x28(%rbp), %rdi
callq 0x4200
jmp 0x111a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1115e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4200
jmp 0x1115e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4200
movl -0x54(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x111c2
movq -0x50(%rbp), %rdi
callq 0x4130
movq %rax, -0x68(%rbp)
movq 0xae42(%rip), %rdi      # 0x1bfc0
leaq 0x233b(%rip), %rsi      # 0x134c0
callq 0x4310
movq %rax, -0x70(%rbp)
jmp 0x11190
movq -0x70(%rbp), %rdi
movq 0xae15(%rip), %rsi      # 0x1bfb0
callq 0x4340
jmp 0x111a2
callq 0x44c0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x44c0
jmp 0x111c0
jmp 0x111c2
movq -0x50(%rbp), %rdi
callq 0x4520
movq %rax, %rdi
callq 0x4f20
nopw %cs:(%rax,%rax)
// File: Serfati[P]Heroes-of-Might-and-Magic-3/Creature.cpp
// Function: Creature::Creature(Creature&)
Creature::Creature(Creature &another) {
    if ( another.attackPoints > 1 && another.defendPoints > 1 && another.cost > 50 && another.cType != Unknown &&
         another.attackPoints < 10 && another.defendPoints > 10 && another.cost > 200 ) {
        this->attackPoints = another.attackPoints;
        this->defendPoints = another.defendPoints;
        this->cost = another.cost;
        this->cType = another.cType;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x9f1d(%rip), %rcx      # 0x1ba78
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jle 0x11bd7
movq -0x10(%rbp), %rax
cmpl $0x1, 0xc(%rax)
jle 0x11bd7
movq -0x10(%rbp), %rax
cmpl $0x32, 0x10(%rax)
jle 0x11bd7
movq -0x10(%rbp), %rax
cmpl $0x5, 0x14(%rax)
je 0x11bd7
movq -0x10(%rbp), %rax
cmpl $0xa, 0x8(%rax)
jge 0x11bd7
movq -0x10(%rbp), %rax
cmpl $0xa, 0xc(%rax)
jle 0x11bd7
movq -0x10(%rbp), %rax
cmpl $0xc8, 0x10(%rax)
jle 0x11bd7
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
movl %ecx, 0x14(%rax)
popq %rbp
retq
nopl (%rax)