LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Juan313[P]RockPaperScissor/RPSGame.cpp
// Function: RPSGame::play(char, char)
int RPSGame::play (char humanChoice, char computerChoice) {
    int result;
    Tool* human;
    Tool* computer;
    
    // Set human choice
    if (humanChoice == 'r') {
        human = human_rock; 
    } else if (humanChoice == 'p') {
        human = human_paper; 
    } else {
        human = human_scissors; 
    }

    // Set computer choice
    if (computerChoice == 'r') {
        computer = computer_rock; 
    } else if (computerChoice == 'p') {
        computer = computer_paper;
    } else {
        computer = computer_scissors;
    }
    
    // Fight
    result = human->fight(computer);
    // Set results
    set_winner(result);
    set_human_last_tool(humanChoice); 
    set_comp_last_tool(computerChoice);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x72, %eax
jne 0x2e05
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2e2a
movsbl -0x9(%rbp), %eax
cmpl $0x70, %eax
jne 0x2e1c
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2e28
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2e2a
movsbl -0xa(%rbp), %eax
cmpl $0x72, %eax
jne 0x2e41
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2e66
movsbl -0xa(%rbp), %eax
cmpl $0x70, %eax
jne 0x2e58
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2e64
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2e66
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x28(%rbp), %rdi
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %esi
callq 0x2eb0
movq -0x28(%rbp), %rdi
movsbl -0x9(%rbp), %esi
callq 0x3020
movq -0x28(%rbp), %rdi
movsbl -0xa(%rbp), %esi
callq 0x3040
movl -0x10(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Juan313[P]RockPaperScissor/RPSGame.cpp
// Function: RPSGame::set_winner(int)
void RPSGame::set_winner (int winner) {
    if (winner == 1) {
        set_human_wins(get_human_wins() + 1);
        set_last_winner(1);
    } else if (winner == 2) {
        set_computer_wins(get_computer_wins() + 1);
        set_last_winner(2);
    } else {
        set_ties(get_ties() + 1);
        set_last_winner(3);         // sets tie
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0x2ef4
movq -0x18(%rbp), %rdi
callq 0x3080
movq -0x18(%rbp), %rdi
movl %eax, %esi
addl $0x1, %esi
callq 0x3060
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x30a0
jmp 0x2f48
cmpl $0x2, -0xc(%rbp)
jne 0x2f21
movq -0x18(%rbp), %rdi
callq 0x30e0
movq -0x18(%rbp), %rdi
movl %eax, %esi
addl $0x1, %esi
callq 0x30c0
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x30a0
jmp 0x2f46
movq -0x18(%rbp), %rdi
callq 0x3120
movq -0x18(%rbp), %rdi
movl %eax, %esi
addl $0x1, %esi
callq 0x3100
movq -0x18(%rbp), %rdi
movl $0x3, %esi
callq 0x30a0
jmp 0x2f48
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Juan313[P]RockPaperScissor/input.cpp
// Function: readInt()
int readInt()
{
  int num;
  std::cin>>num;
  while (!(std::cin))
  {
    std::cout<<"The number provided is not an integer. Please enter again."<<std::endl;
    std::cin.clear();
    std::cin.ignore(256,'\n');
    std::cin>>num;
  }
  std::cin.ignore(256,'\n');
  return num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x5da1(%rip), %rdi      # 0x8fe0
leaq -0x4(%rbp), %rsi
callq 0x20c0
movq 0x5d91(%rip), %rax      # 0x8fe0
movq (%rax), %rax
movq 0x5d87(%rip), %rdi      # 0x8fe0
addq -0x18(%rax), %rdi
callq 0x2090
testb $0x1, %al
jne 0x3268
jmp 0x32d1
movq 0x5d61(%rip), %rdi      # 0x8fd0
leaq 0x2dcf(%rip), %rsi      # 0x6045
callq 0x2170
movq %rax, %rdi
movq 0x5d3b(%rip), %rsi      # 0x8fc0
callq 0x21a0
movq 0x5d4f(%rip), %rax      # 0x8fe0
movq (%rax), %rax
movq 0x5d45(%rip), %rdi      # 0x8fe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x2250
movq 0x5d33(%rip), %rdi      # 0x8fe0
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x20e0
movq 0x5d1d(%rip), %rdi      # 0x8fe0
leaq -0x4(%rbp), %rsi
callq 0x20c0
jmp 0x3248
movq 0x5d08(%rip), %rdi      # 0x8fe0
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x20e0
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: Juan313[P]RockPaperScissor/input.cpp
// Function: readInt(int&)
void readInt(int& number)
{
  int temp;
  std::cin>>temp;
  while (!(std::cin))
  {
    std::cout<<"The number provided is not an integer. Please enter again."<<std::endl;
    std::cin.clear();
    std::cin.ignore(256,'\n');
    std::cin>>temp;
  }
  std::cin.ignore(256,'\n');
  number = temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x5cdd(%rip), %rdi      # 0x8fe0
leaq -0xc(%rbp), %rsi
callq 0x20c0
movq 0x5ccd(%rip), %rax      # 0x8fe0
movq (%rax), %rax
movq 0x5cc3(%rip), %rdi      # 0x8fe0
addq -0x18(%rax), %rdi
callq 0x2090
testb $0x1, %al
jne 0x332c
jmp 0x3395
movq 0x5c9d(%rip), %rdi      # 0x8fd0
leaq 0x2d0b(%rip), %rsi      # 0x6045
callq 0x2170
movq %rax, %rdi
movq 0x5c77(%rip), %rsi      # 0x8fc0
callq 0x21a0
movq 0x5c8b(%rip), %rax      # 0x8fe0
movq (%rax), %rax
movq 0x5c81(%rip), %rdi      # 0x8fe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x2250
movq 0x5c6f(%rip), %rdi      # 0x8fe0
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x20e0
movq 0x5c59(%rip), %rdi      # 0x8fe0
leaq -0xc(%rbp), %rsi
callq 0x20c0
jmp 0x330c
movq 0x5c44(%rip), %rdi      # 0x8fe0
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x20e0
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Juan313[P]RockPaperScissor/input.cpp
// Function: readInt(int&, int, int)
void readInt(int& number, int l, int h)
{
  int temp;
  std::cin>>temp;
  while (!(std::cin)||temp < l || temp > h)
  {
    if (!(std::cin))
    {
      std::cout<<"The number provided is not a integer. Please enter again."<<std::endl;
    } 
    else 
    {
      std::cout<<"The number provided is not between "<<l<<" and "<<h<<" . Please enter again."<<std::endl;
    }
      std::cin.clear();
      std::cin.ignore(256,'\n');
      std::cin>>temp;
  }
  std::cin.ignore(256,'\n');
  number = temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq 0x5c07(%rip), %rdi      # 0x8fe0
leaq -0x14(%rbp), %rsi
callq 0x20c0
movq 0x5bf7(%rip), %rax      # 0x8fe0
movq (%rax), %rax
movq 0x5bed(%rip), %rdi      # 0x8fe0
addq -0x18(%rax), %rdi
callq 0x2090
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x15(%rbp)
jne 0x3421
movl -0x14(%rbp), %ecx
movb $0x1, %al
cmpl -0xc(%rbp), %ecx
movb %al, -0x15(%rbp)
jl 0x3421
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
setg %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x342d
jmp 0x350e
movq 0x5bac(%rip), %rax      # 0x8fe0
movq (%rax), %rax
movq 0x5ba2(%rip), %rdi      # 0x8fe0
addq -0x18(%rax), %rdi
callq 0x2090
testb $0x1, %al
jne 0x344d
jmp 0x3471
movq 0x5b7c(%rip), %rdi      # 0x8fd0
leaq 0x2c25(%rip), %rsi      # 0x6080
callq 0x2170
movq %rax, %rdi
movq 0x5b56(%rip), %rsi      # 0x8fc0
callq 0x21a0
jmp 0x34c7
movq 0x5b58(%rip), %rdi      # 0x8fd0
leaq 0x2c3b(%rip), %rsi      # 0x60ba
callq 0x2170
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2260
movq %rax, %rdi
leaq 0x2c45(%rip), %rsi      # 0x60de
callq 0x2170
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x2260
movq %rax, %rdi
leaq 0x2c31(%rip), %rsi      # 0x60e4
callq 0x2170
movq %rax, %rdi
movq 0x5afe(%rip), %rsi      # 0x8fc0
callq 0x21a0
movq 0x5b12(%rip), %rax      # 0x8fe0
movq (%rax), %rax
movq 0x5b08(%rip), %rdi      # 0x8fe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x2250
movq 0x5af6(%rip), %rdi      # 0x8fe0
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x20e0
movq 0x5ae0(%rip), %rdi      # 0x8fe0
leaq -0x14(%rbp), %rsi
callq 0x20c0
jmp 0x33e2
movq 0x5acb(%rip), %rdi      # 0x8fe0
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x20e0
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Juan313[P]RockPaperScissor/input.cpp
// Function: readDouble(double&)
void readDouble(double& number)
{
  double temp;
  std::cin>>temp;
  while (!(std::cin))
  {
    std::cout<<"The number provided is not a double. Please enter again."<<std::endl;
    std::cin.clear();
    std::cin.ignore(256,'\n');
    std::cin>>temp;
  }
  std::cin.ignore(256,'\n');
  number = temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x5a8d(%rip), %rdi      # 0x8fe0
leaq -0x10(%rbp), %rsi
callq 0x2120
movq 0x5a7d(%rip), %rax      # 0x8fe0
movq (%rax), %rax
movq 0x5a73(%rip), %rdi      # 0x8fe0
addq -0x18(%rax), %rdi
callq 0x2090
testb $0x1, %al
jne 0x357c
jmp 0x35e5
movq 0x5a4d(%rip), %rdi      # 0x8fd0
leaq 0x2b71(%rip), %rsi      # 0x60fb
callq 0x2170
movq %rax, %rdi
movq 0x5a27(%rip), %rsi      # 0x8fc0
callq 0x21a0
movq 0x5a3b(%rip), %rax      # 0x8fe0
movq (%rax), %rax
movq 0x5a31(%rip), %rdi      # 0x8fe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x2250
movq 0x5a1f(%rip), %rdi      # 0x8fe0
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x20e0
movq 0x5a09(%rip), %rdi      # 0x8fe0
leaq -0x10(%rbp), %rsi
callq 0x2120
jmp 0x355c
movq 0x59f4(%rip), %rdi      # 0x8fe0
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x20e0
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: Juan313[P]RockPaperScissor/input.cpp
// Function: readDouble(double&, double, double)
void readDouble(double& number, double l, double h)
{
  double temp;
  std::cin>>temp;
  while (!(std::cin)||temp < l || temp > h)
  {
    if (!(std::cin))
    {
      std::cout<<"The number provided is not a double. Please enter again."<<std::endl;
    } 
    else 
    {
      std::cout<<"The number provided is not between "<<l<<" and "<<h<<" . Please enter again."<<std::endl;
    }
      std::cin.clear();
      std::cin.ignore(256,'\n');
      std::cin>>temp;
  }
  std::cin.ignore(256,'\n');
  number = temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq 0x59b3(%rip), %rdi      # 0x8fe0
leaq -0x20(%rbp), %rsi
callq 0x2120
movq 0x59a3(%rip), %rax      # 0x8fe0
movq (%rax), %rax
movq 0x5999(%rip), %rdi      # 0x8fe0
addq -0x18(%rax), %rdi
callq 0x2090
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x3681
movsd -0x20(%rbp), %xmm1
movsd -0x10(%rbp), %xmm0
movb $0x1, %al
ucomisd %xmm1, %xmm0
movb %al, -0x21(%rbp)
ja 0x3681
movsd -0x20(%rbp), %xmm0
ucomisd -0x18(%rbp), %xmm0
seta %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x368d
jmp 0x3772
movq 0x594c(%rip), %rax      # 0x8fe0
movq (%rax), %rax
movq 0x5942(%rip), %rdi      # 0x8fe0
addq -0x18(%rax), %rdi
callq 0x2090
testb $0x1, %al
jne 0x36ad
jmp 0x36d1
movq 0x591c(%rip), %rdi      # 0x8fd0
leaq 0x2a40(%rip), %rsi      # 0x60fb
callq 0x2170
movq %rax, %rdi
movq 0x58f6(%rip), %rsi      # 0x8fc0
callq 0x21a0
jmp 0x372b
movq 0x58f8(%rip), %rdi      # 0x8fd0
leaq 0x29db(%rip), %rsi      # 0x60ba
callq 0x2170
movq %rax, %rdi
movsd -0x10(%rbp), %xmm0
callq 0x2290
movq %rax, %rdi
leaq 0x29e3(%rip), %rsi      # 0x60de
callq 0x2170
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x2290
movq %rax, %rdi
leaq 0x29cd(%rip), %rsi      # 0x60e4
callq 0x2170
movq %rax, %rdi
movq 0x589a(%rip), %rsi      # 0x8fc0
callq 0x21a0
movq 0x58ae(%rip), %rax      # 0x8fe0
movq (%rax), %rax
movq 0x58a4(%rip), %rdi      # 0x8fe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x2250
movq 0x5892(%rip), %rdi      # 0x8fe0
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x20e0
movq 0x587c(%rip), %rdi      # 0x8fe0
leaq -0x20(%rbp), %rsi
callq 0x2120
jmp 0x3636
movq 0x5867(%rip), %rdi      # 0x8fe0
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x20e0
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Juan313[P]RockPaperScissor/input.cpp
// Function: numberOnly(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool numberOnly(std::string s)
{
  for (int i = 0; i<(int) s.length(); ++i)
  {
    if (s[i]>'9'|| s[i]<'0')
    return false;
  }
  if (s.length()>0)
  {
    return true;
  } else 
  {
    return false;
  } 

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0x2220
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x387d
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x22a0
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x386a
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x22a0
movsbl (%rax), %eax
cmpl $0x30, %eax
jge 0x3870
movb $0x0, -0x1(%rbp)
jmp 0x3896
jmp 0x3872
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3827
movq -0x20(%rbp), %rdi
callq 0x2220
cmpq $0x0, %rax
jbe 0x3892
movb $0x1, -0x1(%rbp)
jmp 0x3896
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Juan313[P]RockPaperScissor/menu.cpp
// Function: Menu::customizeStrength()
char Menu::customizeStrength()
{
  char choice;
  std::cout << "\033[2J\033[1;1H";
  std::cout<<"Welcome to Rock, Paper, Scissors! Do you want to choose different strengths for the tools?"<<std::endl;
  std::cout<<"(y - yes, n - no)";
  readChar(choice);
  while (choice!= 'y' && choice!='n')
  {
    std::cout<<"Please only enter 'y' or 'n' for input."<<std::endl;
    readChar(choice);
  }
  return choice;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x47a1(%rip), %rdi      # 0x8fd0
leaq 0x1918(%rip), %rsi      # 0x614e
callq 0x2170
movq 0x478e(%rip), %rdi      # 0x8fd0
leaq 0x1910(%rip), %rsi      # 0x6159
callq 0x2170
movq %rax, %rdi
movq 0x4768(%rip), %rsi      # 0x8fc0
callq 0x21a0
movq 0x476c(%rip), %rdi      # 0x8fd0
leaq 0x1949(%rip), %rsi      # 0x61b4
callq 0x2170
leaq -0x1(%rbp), %rdi
callq 0x37d0
movsbl -0x1(%rbp), %ecx
xorl %eax, %eax
cmpl $0x79, %ecx
movb %al, -0x2(%rbp)
je 0x4894
movsbl -0x1(%rbp), %eax
cmpl $0x6e, %eax
setne %al
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
testb $0x1, %al
jne 0x489d
jmp 0x48ca
movq 0x472c(%rip), %rdi      # 0x8fd0
leaq 0x191b(%rip), %rsi      # 0x61c6
callq 0x2170
movq %rax, %rdi
movq 0x4706(%rip), %rsi      # 0x8fc0
callq 0x21a0
leaq -0x1(%rbp), %rdi
callq 0x37d0
jmp 0x4879
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Juan313[P]RockPaperScissor/menu.cpp
// Function: Menu::getStrength(int&, int&, int&, int&, int&, int&)
void Menu::getStrength(int& hr, int& hp, int& hs, int& cr, int& cp, int& cs)
{
  std::cout<<"Please enter strength for human tools:"<<std::endl;
  std::cout<<"Rock: ";
  hr = readInt();
  std::cout<<"Paper: ";
  hp = readInt();
  std::cout<<"Scissor: ";
  hs = readInt();
  std::cout<<"Please enter strength for computer tools:"<<std::endl;
  std::cout<<"Rock: ";
  cr = readInt();
  std::cout<<"Paper: ";
  cp = readInt();
  std::cout<<"Scissor: ";
  cs = readInt();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq 0x46c9(%rip), %rdi      # 0x8fd0
leaq 0x18e0(%rip), %rsi      # 0x61ee
callq 0x2170
movq %rax, %rdi
movq 0x46a3(%rip), %rsi      # 0x8fc0
callq 0x21a0
movq 0x46a7(%rip), %rdi      # 0x8fd0
leaq 0x18e5(%rip), %rsi      # 0x6215
callq 0x2170
callq 0x3230
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq 0x4687(%rip), %rdi      # 0x8fd0
leaq 0x18cc(%rip), %rsi      # 0x621c
callq 0x2170
callq 0x3230
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq 0x4667(%rip), %rdi      # 0x8fd0
leaq 0x18b4(%rip), %rsi      # 0x6224
callq 0x2170
callq 0x3230
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq 0x4647(%rip), %rdi      # 0x8fd0
leaq 0x189e(%rip), %rsi      # 0x622e
callq 0x2170
movq %rax, %rdi
movq 0x4621(%rip), %rsi      # 0x8fc0
callq 0x21a0
movq 0x4625(%rip), %rdi      # 0x8fd0
leaq 0x1863(%rip), %rsi      # 0x6215
callq 0x2170
callq 0x3230
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq 0x4605(%rip), %rdi      # 0x8fd0
leaq 0x184a(%rip), %rsi      # 0x621c
callq 0x2170
callq 0x3230
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq 0x45e5(%rip), %rdi      # 0x8fd0
leaq 0x1832(%rip), %rsi      # 0x6224
callq 0x2170
callq 0x3230
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Juan313[P]RockPaperScissor/menu.cpp
// Function: Menu::getChoice()
char Menu::getChoice()
{
  char choice;
  std::cout<<"Choose your tool(r - rock, p - paper, s - scissor, e - exit): ";
  readChar(choice);
  while (choice!= 'r' && choice!='p' && choice!='s' && choice !='e')
  {
    std::cout<<"Choose your tool(r - rock, p - paper, s - scissor, e - exit): ";
    readChar(choice);
  }
  return choice;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x45b1(%rip), %rdi      # 0x8fd0
leaq 0x1832(%rip), %rsi      # 0x6258
callq 0x2170
leaq -0x1(%rbp), %rdi
callq 0x37d0
movsbl -0x1(%rbp), %ecx
xorl %eax, %eax
cmpl $0x72, %ecx
movb %al, -0x2(%rbp)
je 0x4a6b
movsbl -0x1(%rbp), %ecx
xorl %eax, %eax
cmpl $0x70, %ecx
movb %al, -0x2(%rbp)
je 0x4a6b
movsbl -0x1(%rbp), %ecx
xorl %eax, %eax
cmpl $0x73, %ecx
movb %al, -0x2(%rbp)
je 0x4a6b
movsbl -0x1(%rbp), %eax
cmpl $0x65, %eax
setne %al
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
testb $0x1, %al
jne 0x4a74
jmp 0x4a92
movq 0x4555(%rip), %rdi      # 0x8fd0
leaq 0x17d6(%rip), %rsi      # 0x6258
callq 0x2170
leaq -0x1(%rbp), %rdi
callq 0x37d0
jmp 0x4a34
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Juan313[P]RockPaperScissor/play_game.cpp
// Function: getFullName[abi:cxx11](char)
std::string getFullName(char c)
{
  std::string name;
  switch (c)
  {
    case 'r': name = "rock";
              break;
    case 'p': name = "paper";
              break;
    case 's': name =  "scissor";
              break;
  }
  return name;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movb %sil, %al
movq %rdi, %rcx
movq %rcx, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movb $0x0, -0xa(%rbp)
callq 0x2200
movsbl -0x9(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $0x70, %eax
je 0x4fb3
jmp 0x4f74
movl -0x20(%rbp), %eax
subl $0x72, %eax
je 0x4f88
jmp 0x4f7e
movl -0x20(%rbp), %eax
subl $0x73, %eax
je 0x4fc7
jmp 0x4fdb
movq -0x30(%rbp), %rdi
leaq 0x1459(%rip), %rsi      # 0x63ec
callq 0x21f0
jmp 0x4f9a
jmp 0x4fdb
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x20d0
jmp 0x4ff8
movq -0x30(%rbp), %rdi
leaq 0x1433(%rip), %rsi      # 0x63f1
callq 0x21f0
jmp 0x4fc5
jmp 0x4fdb
movq -0x30(%rbp), %rdi
leaq 0x1425(%rip), %rsi      # 0x63f7
callq 0x21f0
jmp 0x4fd9
jmp 0x4fdb
movb $0x1, -0xa(%rbp)
testb $0x1, -0xa(%rbp)
jne 0x4fee
movq -0x30(%rbp), %rdi
callq 0x20d0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2270
// File: Oralf[P]Heros/Archer.cpp
// Function: Archer::CreatureAttack(int, Creature&, int) const
int Archer::CreatureAttack (int numOfMe, Creature& c, int numOfC)const{
	int numOfDead=0;
	int totalAtt= attackLevel*numOfMe;
	if( c.getType()=="Black Dragon"){
		totalAtt= totalAtt*1.2;
	}
	while( numOfC>0 && totalAtt>= c.getDefenseLevel()){
		totalAtt= totalAtt-c.getDefenseLevel();
		numOfDead++;
		numOfC--;
	}
	return numOfDead;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, -0x20(%rbp)
movl 0x8(%rax), %eax
movl -0xc(%rbp), %ecx
imull %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x48(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq *%rax
movq -0x60(%rbp), %rdi
leaq 0x8673(%rip), %rsi      # 0xc010
callq 0x3b10
movb %al, -0x55(%rbp)
jmp 0x39a7
leaq -0x48(%rbp), %rdi
callq 0x3170
movb -0x55(%rbp), %al
testb $0x1, %al
jne 0x39b9
jmp 0x39ea
cvtsi2sdl -0x24(%rbp), %xmm0
movsd 0x8642(%rip), %xmm1     # 0xc008
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x24(%rbp)
jmp 0x39ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3170
jmp 0x3a52
jmp 0x39ec
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x61(%rbp)
jle 0x3a13
movl -0x24(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4120
movl %eax, %ecx
movl -0x68(%rbp), %eax
cmpl %ecx, %eax
setge %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x3a1c
jmp 0x3a49
movl -0x24(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4120
movl %eax, %ecx
movl -0x6c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x39ec
movl -0x20(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3400
nopl (%rax,%rax)
// File: Oralf[P]Heros/BlackDragon.cpp
// Function: Black_Dragon::CreatureAttack(int, Creature&, int) const
int Black_Dragon:: CreatureAttack (int numOfMe, Creature& c, int numOfC)const{
	int numOfDead=0;
	int defence=c.getDefenseLevel();
	int totalAtt= attackLevel*numOfMe;
	if(c.getType()== "Wizard"){
		defence= defence*2;
	}
	while( numOfC>0 && totalAtt>= defence){
		totalAtt= totalAtt-defence;
		numOfDead++;
		numOfC--;
	}
	return numOfDead;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4120
movl %eax, %ecx
movq -0x68(%rbp), %rax
movl %ecx, -0x24(%rbp)
movl 0x8(%rax), %eax
movl -0xc(%rbp), %ecx
imull %ecx, %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x48(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq *%rax
movq -0x60(%rbp), %rdi
leaq 0x815e(%rip), %rsi      # 0xc0c1
callq 0x3b10
movb %al, -0x55(%rbp)
jmp 0x3f6d
leaq -0x48(%rbp), %rdi
callq 0x3170
movb -0x55(%rbp), %al
testb $0x1, %al
jne 0x3f7f
jmp 0x3fa0
movl -0x24(%rbp), %eax
shll %eax
movl %eax, -0x24(%rbp)
jmp 0x3fa0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3170
jmp 0x3fe8
jmp 0x3fa2
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x69(%rbp)
jle 0x3fb9
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
setge %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x3fc2
jmp 0x3fdf
movl -0x28(%rbp), %eax
subl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3fa2
movl -0x20(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3400
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Oralf[P]Heros/Hero.cpp
// Function: Hero::Hero()
Hero::Hero() {
	gold=750;
	heroName="Name";
	heroType="Hero";
	armyCreatures[blackDragon_e]=new Black_Dragon();
	armyCreatures[wizard_e]=new Wizard();
	armyCreatures[archer_e]=new Archer();
	armyCreatures[vampire_e]=new Vampire();
	armyCreatures[zombie_e]=new Zombie();
	int i;
	for(i=0;i<5;i++){
		numOfCretures[i]=0;
	}
	totalCreatures=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
leaq 0xba4d(%rip), %rax      # 0xfbd8
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x20(%rbp)
callq 0x3350
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x30(%rbp)
callq 0x3350
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
movabsq $0x4087700000000000, %rcx # imm = 0x4087700000000000
movq %rcx, 0x48(%rax)
leaq 0x7edf(%rip), %rsi      # 0xc0a8
callq 0x3340
jmp 0x41d0
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
leaq 0x7ece(%rip), %rsi      # 0xc0ad
callq 0x3340
jmp 0x41e6
movl $0x18, %edi
callq 0x3230
movq %rax, -0x38(%rbp)
jmp 0x41f6
movq -0x38(%rbp), %rdi
callq 0x3e40
jmp 0x4201
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x50(%rax)
movl $0x18, %edi
callq 0x3230
movq %rax, -0x40(%rbp)
jmp 0x421d
movq -0x40(%rbp), %rdi
callq 0xba50
jmp 0x4228
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x58(%rax)
movl $0x18, %edi
callq 0x3230
movq %rax, -0x48(%rbp)
jmp 0x4244
movq -0x48(%rbp), %rdi
callq 0x3890
jmp 0x424f
movq -0x28(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x60(%rax)
movl $0x18, %edi
callq 0x3230
movq %rax, -0x50(%rbp)
jmp 0x426b
movq -0x50(%rbp), %rdi
callq 0xb690
jmp 0x4276
movq -0x28(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x68(%rax)
movl $0x18, %edi
callq 0x3230
movq %rax, -0x58(%rbp)
jmp 0x4292
movq -0x58(%rbp), %rdi
callq 0xbbe0
jmp 0x429d
movq -0x28(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x70(%rax)
movl $0x0, -0x18(%rbp)
cmpl $0x5, -0x18(%rbp)
jge 0x4375
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl $0x0, 0x78(%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x42b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x4389
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x18, %esi
callq 0x3240
jmp 0x4389
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x18, %esi
callq 0x3240
jmp 0x4389
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x18, %esi
callq 0x3240
jmp 0x4389
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x18, %esi
callq 0x3240
jmp 0x4389
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x18, %esi
callq 0x3240
jmp 0x4389
movq -0x28(%rbp), %rax
movl $0x0, 0x8c(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3170
movq -0x20(%rbp), %rdi
callq 0x3170
movq -0x10(%rbp), %rdi
callq 0x3400
nopw %cs:(%rax,%rax)
// File: Oralf[P]Heros/Hero.cpp
// Function: Hero::addGold(double)
void Hero:: addGold(double newGold){
	gold+=newGold;
	if(gold>2500){
		gold = 2500;
	}
	if( gold<0){
		gold=0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
addsd 0x48(%rax), %xmm0
movsd %xmm0, 0x48(%rax)
movsd 0x48(%rax), %xmm0
movsd 0x6f07(%rip), %xmm1     # 0xc098
ucomisd %xmm1, %xmm0
jbe 0x51a8
movq -0x18(%rbp), %rax
movsd 0x6ef5(%rip), %xmm0     # 0xc098
movsd %xmm0, 0x48(%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
ucomisd 0x48(%rax), %xmm0
jbe 0x51c2
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x48(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Oralf[P]Heros/Hero.cpp
// Function: Hero::getNumOfCreatures(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
int Hero::getNumOfCreatures(string creature)const{
	if( creature== "Black_Dragon"){
		return numOfCretures[blackDragon_e];
	}
	else if( creature== "Wizard"){
		return numOfCretures[wizard_e];
	}
	else if(creature== "Archer"){
		return numOfCretures[archer_e];
	}
	else if(creature== "Vampire"){
		return numOfCretures[vampire_e];
	}
	else if( creature== "Zombie"){
		return numOfCretures[zombie_e];
	}
	else{
		return 0;
	}
}

// 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)
leaq 0x6cb5(%rip), %rsi      # 0xc0b3
callq 0x3b10
testb $0x1, %al
jne 0x5409
jmp 0x5418
movq -0x20(%rbp), %rax
movl 0x78(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x54b0
movq -0x28(%rbp), %rdi
leaq 0x6c9e(%rip), %rsi      # 0xc0c1
callq 0x3b10
testb $0x1, %al
jne 0x542e
jmp 0x543a
movq -0x20(%rbp), %rax
movl 0x7c(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x54b0
movq -0x28(%rbp), %rdi
leaq 0x6c84(%rip), %rsi      # 0xc0c9
callq 0x3b10
testb $0x1, %al
jne 0x5450
jmp 0x545f
movq -0x20(%rbp), %rax
movl 0x80(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x54b0
movq -0x28(%rbp), %rdi
leaq 0x6c67(%rip), %rsi      # 0xc0d1
callq 0x3b10
testb $0x1, %al
jne 0x5475
jmp 0x5484
movq -0x20(%rbp), %rax
movl 0x84(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x54b0
movq -0x28(%rbp), %rdi
leaq 0x6c4b(%rip), %rsi      # 0xc0da
callq 0x3b10
testb $0x1, %al
jne 0x549a
jmp 0x54a9
movq -0x20(%rbp), %rax
movl 0x88(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x54b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Oralf[P]Heros/main.cpp
// Function: isValidName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool isValidName(string name){
	int i;
	char a;
	if( name.length()>31){
		return false;
	}
	for(i=0;i<name.length();i++){
		a=name[i];
		if(a == ' '){
			return false;
		}
		if( !(a<='z' && a>='a') && !(a<='Z' && a>='A')&& !(a>='0'&& a<='9')){
			return false;
		}
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x3380
cmpq $0x1f, %rax
jbe 0x5504
movb $0x0, -0x1(%rbp)
jmp 0x5599
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x3380
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x5595
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x34c0
movb (%rax), %al
movb %al, -0x15(%rbp)
movsbl -0x15(%rbp), %eax
cmpl $0x20, %eax
jne 0x5549
movb $0x0, -0x1(%rbp)
jmp 0x5599
movsbl -0x15(%rbp), %eax
cmpl $0x7a, %eax
jg 0x555b
movsbl -0x15(%rbp), %eax
cmpl $0x61, %eax
jge 0x5585
movsbl -0x15(%rbp), %eax
cmpl $0x5a, %eax
jg 0x556d
movsbl -0x15(%rbp), %eax
cmpl $0x41, %eax
jge 0x5585
movsbl -0x15(%rbp), %eax
cmpl $0x30, %eax
jl 0x557f
movsbl -0x15(%rbp), %eax
cmpl $0x39, %eax
jle 0x5585
movb $0x0, -0x1(%rbp)
jmp 0x5599
jmp 0x5587
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x550b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Oralf[P]Heros/Necromancer.cpp
// Function: Necromancer::Necromancer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, int, int, int, int, int, int)
Necromancer::Necromancer(string name,double newgold,int bd,int wiz, int arch, int vamp, int zomb, int tot){
	heroName=name;
	heroType="Necromancer";
	gold=newgold;
	numOfCretures[blackDragon_e]=bd;
	numOfCretures[wizard_e]=wiz;
	numOfCretures[archer_e]=arch;
	numOfCretures[vampire_e]=vamp;
	numOfCretures[zombie_e]=zomb;
	totalCreatures=tot;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x40(%rbp)
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x4170
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq 0x4977(%rip), %rax      # 0xfc10
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x3030
jmp 0xb2a7
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
leaq 0x1009(%rip), %rsi      # 0xc2bf
callq 0x3340
jmp 0xb2bd
movq -0x48(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x48(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x78(%rax)
movl -0x20(%rbp), %ecx
movl %ecx, 0x7c(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x80(%rax)
movl -0x28(%rbp), %ecx
movl %ecx, 0x84(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x88(%rax)
movl 0x18(%rbp), %ecx
movl %ecx, 0x8c(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x4600
movq -0x30(%rbp), %rdi
callq 0x3400
nop
// File: Oralf[P]Heros/Thief.cpp
// Function: Thief::Thief(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, int, int, int, int, int, int)
Thief::Thief(string name,double newgold,int bd,int wiz, int arch, int vamp, int zomb, int tot){
	heroName=name;
	heroType="Thief";
	gold=newgold;
	numOfCretures[blackDragon_e]=bd;
	numOfCretures[wizard_e]=wiz;
	numOfCretures[archer_e]=arch;
	numOfCretures[vampire_e]=vamp;
	numOfCretures[zombie_e]=zomb;
	totalCreatures=tot;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x40(%rbp)
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x4170
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq 0x4787(%rip), %rax      # 0xfc50
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x3030
jmp 0xb4d7
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
leaq 0xdd2(%rip), %rsi       # 0xc2b8
callq 0x3340
jmp 0xb4ed
movq -0x48(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x48(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x78(%rax)
movl -0x20(%rbp), %ecx
movl %ecx, 0x7c(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x80(%rax)
movl -0x28(%rbp), %ecx
movl %ecx, 0x84(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x88(%rax)
movl 0x18(%rbp), %ecx
movl %ecx, 0x8c(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x4600
movq -0x30(%rbp), %rdi
callq 0x3400
nop
// File: Oralf[P]Heros/Thief.cpp
// Function: Thief::SpecialSkill(Hero*)
void Thief::SpecialSkill(Hero* heroToStole){
	if(heroToStole != NULL){
		double moneyOfStolen=heroToStole->getGold();
		double howMuchto2500= 2500-gold;
		double toSteel=70;
		if(howMuchto2500<70){
			toSteel=howMuchto2500;
		}
		if(moneyOfStolen<toSteel){
			heroToStole->addGold(-moneyOfStolen);
			this->addGold(moneyOfStolen);
		}
		else{// have more then 70
			heroToStole->addGold(-toSteel);
			this->addGold(toSteel);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb637
movq -0x10(%rbp), %rdi
callq 0x5140
movq -0x30(%rbp), %rax
movsd %xmm0, -0x18(%rbp)
movsd 0xb0b(%rip), %xmm0      # 0xc098
subsd 0x48(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0xf09(%rip), %xmm0      # 0xc4a8
movsd %xmm0, -0x28(%rbp)
movsd 0xefc(%rip), %xmm0      # 0xc4a8
ucomisd -0x20(%rbp), %xmm0
jbe 0xb5bd
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb602
movq -0x10(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x5160
movq -0x30(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
callq 0x5160
jmp 0xb635
movq -0x10(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x5160
movq -0x30(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
callq 0x5160
jmp 0xb637
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Oralf[P]Heros/Vampire.cpp
// Function: Vampire::CreatureAttack(int, Creature&, int) const
int Vampire::CreatureAttack(int numOfMe, Creature& c, int numOfC)const{
	int numOfDead=0;
	int totalAtt= attackLevel*numOfMe;
	while( numOfC>0 && totalAtt>= c.getDefenseLevel()){
		totalAtt= totalAtt-c.getDefenseLevel();
		numOfDead++;
		numOfC--;
	}
	return numOfDead;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, -0x20(%rbp)
movl 0x8(%rax), %eax
imull -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x25(%rbp)
jle 0xb7a2
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4120
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
setge %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0xb7ab
jmp 0xb7d8
movl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4120
movl %eax, %ecx
movl -0x30(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb77b
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Oralf[P]Heros/Warrior.cpp
// Function: Warrior::Warrior(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, int, int, int, int, int, int)
Warrior::Warrior(string name,double newgold,int bd,int wiz, int arch, int vamp, int zomb, int tot){
	heroName=name;
	heroType="Warrior";
	gold=newgold;
	numOfCretures[blackDragon_e]=bd;
	numOfCretures[wizard_e]=wiz;
	numOfCretures[archer_e]=arch;
	numOfCretures[vampire_e]=vamp;
	numOfCretures[zombie_e]=zomb;
	totalCreatures=tot;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x40(%rbp)
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x4170
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq 0x438f(%rip), %rax      # 0xfcd8
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x3030
jmp 0xb957
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
leaq 0x949(%rip), %rsi       # 0xc2af
callq 0x3340
jmp 0xb96d
movq -0x48(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x48(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x78(%rax)
movl -0x20(%rbp), %ecx
movl %ecx, 0x7c(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x80(%rax)
movl -0x28(%rbp), %ecx
movl %ecx, 0x84(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x88(%rax)
movl 0x18(%rbp), %ecx
movl %ecx, 0x8c(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x4600
movq -0x30(%rbp), %rdi
callq 0x3400
nop
// File: Oralf[P]Heros/Zombie.cpp
// Function: Zombie::CreatureAttack(int, Creature&, int) const
int Zombie::CreatureAttack (int numOfMe, Creature& c, int numOfC)const{
	int numOfDead=0;
	int totalAtt= attackLevel*numOfMe;
	if( c.getType()=="Archer"){
		totalAtt= totalAtt*2;
	}
	while( numOfC>0 && totalAtt>= c.getDefenseLevel()){
		totalAtt= totalAtt-c.getDefenseLevel();
		numOfDead++;
		numOfC--;
	}
	return numOfDead;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, -0x20(%rbp)
movl 0x8(%rax), %eax
movl -0xc(%rbp), %ecx
imull %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x48(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq *%rax
movq -0x60(%rbp), %rdi
leaq 0x3dc(%rip), %rsi       # 0xc0c9
callq 0x3b10
movb %al, -0x55(%rbp)
jmp 0xbcf7
leaq -0x48(%rbp), %rdi
callq 0x3170
movb -0x55(%rbp), %al
testb $0x1, %al
jne 0xbd09
jmp 0xbd2a
movl -0x24(%rbp), %eax
shll %eax
movl %eax, -0x24(%rbp)
jmp 0xbd2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3170
jmp 0xbd92
jmp 0xbd2c
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x61(%rbp)
jle 0xbd53
movl -0x24(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4120
movl %eax, %ecx
movl -0x68(%rbp), %eax
cmpl %ecx, %eax
setge %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0xbd5c
jmp 0xbd89
movl -0x24(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4120
movl %eax, %ecx
movl -0x6c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xbd2c
movl -0x20(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3400
nopl (%rax,%rax)
// File: jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_deflateInit2
int mz_deflateInit2(mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy)
{
    tdefl_compressor *pComp;
    mz_uint comp_flags = TDEFL_COMPUTE_ADLER32 | tdefl_create_comp_flags_from_zip_params(level, window_bits, strategy);

    if (!pStream)
        return MZ_STREAM_ERROR;
    if ((method != MZ_DEFLATED) || ((mem_level < 1) || (mem_level > 9)) || ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS)))
        return MZ_PARAM_ERROR;

    pStream->data_type = 0;
    pStream->adler = MZ_ADLER32_INIT;
    pStream->msg = NULL;
    pStream->reserved = 0;
    pStream->total_in = 0;
    pStream->total_out = 0;
    if (!pStream->zalloc)
        pStream->zalloc = miniz_def_alloc_func;
    if (!pStream->zfree)
        pStream->zfree = miniz_def_free_func;

    pComp = (tdefl_compressor *)pStream->zalloc(pStream->opaque, 1, sizeof(tdefl_compressor));
    if (!pComp)
        return MZ_MEM_ERROR;

    pStream->state = (struct mz_internal_state *)pComp;

    if (tdefl_init(pComp, NULL, NULL, comp_flags) != TDEFL_STATUS_OKAY)
    {
        mz_deflateEnd(pStream);
        return MZ_PARAM_ERROR;
    }

    return MZ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl -0x14(%rbp), %edi
movl -0x1c(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x3cc0
orl $0x2000, %eax           # imm = 0x2000
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3b96
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x3cac
cmpl $0x8, -0x18(%rbp)
jne 0x3bb8
cmpl $0x1, -0x20(%rbp)
jl 0x3bb8
cmpl $0x9, -0x20(%rbp)
jg 0x3bb8
cmpl $0xf, -0x1c(%rbp)
je 0x3bc4
xorl %eax, %eax
subl -0x1c(%rbp), %eax
cmpl $0xf, %eax
je 0x3bc4
movl $0xffffd8f0, -0x4(%rbp) # imm = 0xFFFFD8F0
jmp 0x3cac
movq -0x10(%rbp), %rax
movl $0x0, 0x58(%rax)
movq -0x10(%rbp), %rax
movq $0x1, 0x60(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x3c25
movq -0x10(%rbp), %rax
leaq -0x1a1(%rip), %rcx      # 0x3a80
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x3c3f
movq -0x10(%rbp), %rax
leaq -0x18b(%rip), %rcx      # 0x3ab0
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rdi
movl $0x1, %esi
movl $0x4df78, %edx          # imm = 0x4DF78
callq *%rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3c6f
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x3cac
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %ecx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x3da0
cmpl $0x0, %eax
je 0x3ca5
movq -0x10(%rbp), %rdi
callq 0x4050
movl $0xffffd8f0, -0x4(%rbp) # imm = 0xFFFFD8F0
jmp 0x3cac
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jimmiebergmann[P]fbx-file/miniz.c
// Function: tdefl_create_comp_flags_from_zip_params
mz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits, int strategy)
{
    mz_uint comp_flags = s_tdefl_num_probes[(level >= 0) ? MZ_MIN(10, level) : MZ_DEFAULT_LEVEL] | ((level <= 3) ? TDEFL_GREEDY_PARSING_FLAG : 0);
    if (window_bits > 0)
        comp_flags |= TDEFL_WRITE_ZLIB_HEADER;

    if (!level)
        comp_flags |= TDEFL_FORCE_ALL_RAW_BLOCKS;
    else if (strategy == MZ_FILTERED)
        comp_flags |= TDEFL_FILTER_MATCHES;
    else if (strategy == MZ_HUFFMAN_ONLY)
        comp_flags &= ~TDEFL_MAX_PROBES_MASK;
    else if (strategy == MZ_FIXED)
        comp_flags |= TDEFL_FORCE_ALL_STATIC_BLOCKS;
    else if (strategy == MZ_RLE)
        comp_flags |= TDEFL_RLE_MATCHES;

    return comp_flags;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x3cf5
movl $0xa, %eax
cmpl -0x4(%rbp), %eax
jge 0x3ce7
movl $0xa, %eax
movl %eax, -0x14(%rbp)
jmp 0x3ced
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x3cff
movl $0x6, %eax
movl %eax, -0x18(%rbp)
jmp 0x3cff
movl -0x18(%rbp), %eax
movslq %eax, %rcx
leaq 0x31864(%rip), %rax     # 0x35570
movl (%rax,%rcx,4), %eax
movl -0x4(%rbp), %esi
xorl %ecx, %ecx
movl $0x4000, %edx           # imm = 0x4000
cmpl $0x3, %esi
cmovlel %edx, %ecx
orl %ecx, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jle 0x3d35
movl -0x10(%rbp), %eax
orl $0x1000, %eax           # imm = 0x1000
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x3d48
movl -0x10(%rbp), %eax
orl $0x80000, %eax          # imm = 0x80000
movl %eax, -0x10(%rbp)
jmp 0x3d9a
cmpl $0x1, -0xc(%rbp)
jne 0x3d5b
movl -0x10(%rbp), %eax
orl $0x20000, %eax          # imm = 0x20000
movl %eax, -0x10(%rbp)
jmp 0x3d98
cmpl $0x2, -0xc(%rbp)
jne 0x3d6e
movl -0x10(%rbp), %eax
andl $0xfffff000, %eax       # imm = 0xFFFFF000
movl %eax, -0x10(%rbp)
jmp 0x3d96
cmpl $0x4, -0xc(%rbp)
jne 0x3d81
movl -0x10(%rbp), %eax
orl $0x40000, %eax          # imm = 0x40000
movl %eax, -0x10(%rbp)
jmp 0x3d94
cmpl $0x3, -0xc(%rbp)
jne 0x3d92
movl -0x10(%rbp), %eax
orl $0x10000, %eax          # imm = 0x10000
movl %eax, -0x10(%rbp)
jmp 0x3d94
jmp 0x3d96
jmp 0x3d98
jmp 0x3d9a
movl -0x10(%rbp), %eax
popq %rbp
retq
nop
// File: jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_deflateEnd
int mz_deflateEnd(mz_streamp pStream)
{
    if (!pStream)
        return MZ_STREAM_ERROR;
    if (pStream->state)
    {
        pStream->zfree(pStream->opaque, pStream->state);
        pStream->state = NULL;
    }
    return MZ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x406c
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x40a4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x409d
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rsi
callq *%rax
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_deflateReset
int mz_deflateReset(mz_streamp pStream)
{
    if ((!pStream) || (!pStream->state) || (!pStream->zalloc) || (!pStream->zfree))
        return MZ_STREAM_ERROR;
    pStream->total_in = pStream->total_out = 0;
    tdefl_init((tdefl_compressor *)pStream->state, NULL, NULL, ((tdefl_compressor *)pStream->state)->m_flags);
    return MZ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x40e4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x40e4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x40e4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x40ed
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x412b
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl 0x10(%rax), %ecx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x3da0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)