LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, 0x10(%rsp)
movq 0x439b(%rip), %r15      # 0x6fe0
leaq 0xc(%rsp), %r12
movq 0x437f(%rip), %rbx      # 0x6fd0
movq %r15, %rdi
movq %r12, %rsi
callq 0x20a0
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r15,%rax)
je 0x2c84
movl $0x39, %edx
movq %rbx, %rdi
leaq 0x1406(%rip), %rsi      # 0x4080
callq 0x2190
movq %rbx, %r13
jmp 0x2cf2
movl 0xc(%rsp), %eax
cmpl %r14d, %eax
setl %cl
cmpl %ebp, %eax
setg %al
orb %cl, %al
je 0x2d42
movl $0x23, %edx
movq %rbx, %rdi
leaq 0x1410(%rip), %rsi      # 0x40ba
callq 0x2190
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2230
movq %rax, %r13
movl $0x5, %edx
movq %rax, %rdi
leaq 0x1412(%rip), %rsi      # 0x40de
callq 0x2190
movq %r13, %rdi
movl %ebp, %esi
callq 0x2230
movq %rax, %r13
movl $0x16, %edx
movq %rax, %rdi
leaq 0x13f7(%rip), %rsi      # 0x40e4
callq 0x2190
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
xorl %esi, %esi
callq 0x2220
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
movl $0xa, %edx
callq 0x20b0
jmp 0x2c51
movq 0x4297(%rip), %rdi      # 0x6fe0
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x20b0
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
movl %eax, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x4257(%rip), %r14      # 0x6fe0
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x20c0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
je 0x2e30
movq 0x4220(%rip), %r15      # 0x6fd0
leaq 0x1344(%rip), %r12      # 0x40fb
leaq 0x8(%rsp), %r13
movl $0x38, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2190
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
xorl %esi, %esi
callq 0x2220
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
movl $0xa, %edx
callq 0x20b0
movq %r14, %rdi
movq %r13, %rsi
callq 0x20c0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
jne 0x2dbc
movq 0x41a9(%rip), %rdi      # 0x6fe0
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x20b0
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rdi, 0x20(%rsp)
movq 0x415c(%rip), %r14      # 0x6fe0
leaq 0x18(%rsp), %r15
movq 0x4140(%rip), %rbp      # 0x6fd0
leaq 0x124d(%rip), %rbx      # 0x40e4
leaq 0x125d(%rip), %r13      # 0x40fb
movq %r14, %rdi
movq %r15, %rsi
callq 0x20c0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
je 0x2ecd
movl $0x38, %edx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x2190
movq %rbp, %r12
jmp 0x2f45
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x2eeb
ucomisd 0x8(%rsp), %xmm0
jbe 0x2f95
movl $0x23, %edx
movq %rbp, %rdi
leaq 0x11c0(%rip), %rsi      # 0x40ba
callq 0x2190
movq %rbp, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x2200
movq %rax, %r12
movl $0x5, %edx
movq %rax, %rdi
leaq 0x11bf(%rip), %rsi      # 0x40de
callq 0x2190
movq %r12, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x2200
movq %rax, %r12
movl $0x16, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2190
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
xorl %esi, %esi
callq 0x2220
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
movl $0xa, %edx
callq 0x20b0
jmp 0x2e9e
movq 0x4044(%rip), %rdi      # 0x6fe0
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x20b0
movsd 0x18(%rsp), %xmm0
movq 0x20(%rsp), %rax
movsd %xmm0, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq 0x8(%rdi), %rax
testl %eax, %eax
jle 0x305c
movq (%rdi), %rcx
movl %eax, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %esi, %esi
movb (%rcx,%rsi), %dil
addb $-0x3a, %dil
cmpb $-0xa, %dil
jb 0x3063
incq %rsi
cmpq %rsi, %rdx
jne 0x3046
testq %rax, %rax
setne %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq 0x39d4(%rip), %r15      # 0x6fd0
leaq 0xc15(%rip), %rsi       # 0x4218
movl $0x26, %edx
movq %r15, %rdi
callq 0x2190
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
leaq 0xc01(%rip), %rbp       # 0x423f
movl $0x6, %edx
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2190
callq 0x2a64
movl %eax, (%rbx)
leaq 0xbea(%rip), %rbx       # 0x4246
movl $0x7, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2190
callq 0x2a64
movl %eax, (%r14)
leaq 0xbd3(%rip), %r14       # 0x424e
movl $0x9, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2190
callq 0x2a64
movl %eax, (%r13)
leaq 0xbbd(%rip), %rsi       # 0x4258
movl $0x29, %edx
movq %r15, %rdi
callq 0x2190
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movl $0x6, %edx
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2190
callq 0x2a64
movl %eax, (%r12)
movl $0x7, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2190
callq 0x2a64
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
movl $0x9, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2190
callq 0x2a64
movq 0x10(%rsp), %rcx
movl %eax, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpl $0x70, %esi
je 0x3cae
cmpl $0x73, %esi
je 0x3c9f
cmpl $0x72, %esi
jne 0x3cc7
movl $0x4, %r8d
leaq 0x779(%rip), %rcx       # 0x4416
jmp 0x3cbb
movl $0x7, %r8d
leaq 0x775(%rip), %rcx       # 0x4421
jmp 0x3cbb
movl $0x5, %r8d
leaq 0x760(%rip), %rcx       # 0x441b
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21f0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3ce6
movq (%r15), %rsi
incq %rsi
callq 0x2180
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movq %rdx, %r12
movl %esi, %r14d
movq %rdi, %r13
movq %rdx, %rdi
callq 0x3a42
movl %eax, %r15d
imull 0x8(%r13), %r14d
movq (%r12), %rax
leaq -0x48(%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq *0x18(%rax)
leaq 0x6793(%rip), %rsi      # 0xa0c1
movq %r13, %rdi
callq 0x3090
movl %eax, %r12d
movq (%r13), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3952
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x31d0
testl %r12d, %r12d
sete %cl
shll %cl, %r15d
xorl %eax, %eax
testl %ebx, %ebx
jle 0x3979
subl %r15d, %r14d
jl 0x3979
xorl %eax, %eax
leal (%rbx,%rax), %ecx
decl %eax
cmpl $0x2, %ecx
jb 0x3977
subl %r15d, %r14d
jge 0x3968
negl %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq 0xa168(%rip), %rax      # 0xdbd8
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x28(%rdi), %r14
leaq 0x38(%rdi), %r13
movq %r13, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
movabsq $0x4087700000000000, %rax # imm = 0x4087700000000000
movq %rax, 0x48(%rdi)
leaq 0x65f4(%rip), %rcx      # 0xa0a8
movl $0x4, %r8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3290
movq 0x30(%r15), %rdx
leaq 0x65dc(%rip), %rcx      # 0xa0ad
movl $0x4, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x3290
movl $0x18, %edi
callq 0x31c0
movq %rax, %r12
movq %rax, %rdi
callq 0x3888
movq %r12, 0x50(%r15)
movl $0x18, %edi
callq 0x31c0
movq %rax, %r12
movq %rax, %rdi
callq 0x9ba0
movq %r12, 0x58(%r15)
movl $0x18, %edi
callq 0x31c0
movq %rax, %r12
movq %rax, %rdi
callq 0x36bc
movq %r12, 0x60(%r15)
movl $0x18, %edi
callq 0x31c0
movq %rax, %r12
movq %rax, %rdi
callq 0x993c
movq %r12, 0x68(%r15)
movl $0x18, %edi
callq 0x31c0
movq %rax, %r12
movq %rax, %rdi
callq 0x9c68
movq %r12, 0x70(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%r15)
movq $0x0, 0x88(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3b88
jmp 0x3b88
jmp 0x3b88
jmp 0x3b88
movq %rax, %r15
movl $0x18, %esi
movq %r12, %rdi
callq 0x31d0
jmp 0x3b9d
movq %rax, %r15
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x3bb1
movq (%r13), %rsi
incq %rsi
callq 0x31d0
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x3bc9
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x31d0
movq %r15, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O3/Oralf[P]Heros/Hero.cpp
// Function: Hero::Hero(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Hero::Hero(string name, string type){
	gold=750;
	heroName=name;
	heroType=type;
	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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rdi, %r15
leaq 0x9feb(%rip), %rax      # 0xdbd8
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x28(%rdi), %r14
leaq 0x38(%rdi), %r13
movq %r13, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
movabsq $0x4087700000000000, %rax # imm = 0x4087700000000000
movq %rax, 0x48(%rdi)
movq %rbx, %rdi
callq 0x3110
movq %r14, %rdi
movq %r12, %rsi
callq 0x3110
movl $0x18, %edi
callq 0x31c0
movq %rax, %r12
movq %rax, %rdi
callq 0x3888
movq %r12, 0x50(%r15)
movl $0x18, %edi
callq 0x31c0
movq %rax, %r12
movq %rax, %rdi
callq 0x9ba0
movq %r12, 0x58(%r15)
movl $0x18, %edi
callq 0x31c0
movq %rax, %r12
movq %rax, %rdi
callq 0x36bc
movq %r12, 0x60(%r15)
movl $0x18, %edi
callq 0x31c0
movq %rax, %r12
movq %rax, %rdi
callq 0x993c
movq %r12, 0x68(%r15)
movl $0x18, %edi
callq 0x31c0
movq %rax, %r12
movq %rax, %rdi
callq 0x9c68
movq %r12, 0x70(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%r15)
movq $0x0, 0x88(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3ce4
jmp 0x3ce4
jmp 0x3ce4
jmp 0x3ce4
movq %rax, %r15
movl $0x18, %esi
movq %r12, %rdi
callq 0x31d0
jmp 0x3cf9
movq %rax, %r15
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x3d0d
movq (%r13), %rsi
incq %rsi
callq 0x31d0
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x3d25
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x31d0
movq %r15, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O3/Oralf[P]Heros/Hero.cpp
// Function: Hero::BuyCretures(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
bool Hero:: BuyCretures(string creatureType, int numToBuy){
	int totalCost=0;
	if(creatureType=="BlackDragon"){
		totalCost=(armyCreatures[blackDragon_e]->getCost()) * numToBuy;
		gold=gold-totalCost;
		numOfCretures[blackDragon_e]= numOfCretures[blackDragon_e]+ numToBuy;
		totalCreatures+= numToBuy;
		return true;
	}
	else if( creatureType=="Wizard"){
		totalCost=(armyCreatures[wizard_e]->getCost()) * numToBuy;
		gold=gold-totalCost;
		numOfCretures[wizard_e]= numOfCretures[wizard_e]+ numToBuy;
		totalCreatures+= numToBuy;
		return true;
	}
	else if (creatureType=="Archer"){
		totalCost=(armyCreatures[archer_e]->getCost()) * numToBuy;
		gold=gold-totalCost;
		numOfCretures[archer_e]= numOfCretures[archer_e]+ numToBuy;
		totalCreatures+= numToBuy;
		return true;
	}
	else if ( creatureType=="Vampire"){
		totalCost=(armyCreatures[vampire_e]->getCost()) * numToBuy;
		gold=gold-totalCost;
		numOfCretures[vampire_e]= numOfCretures[vampire_e]+ numToBuy;
		totalCreatures+= numToBuy;
		return true;
	}
	else if( creatureType=="Zombie"){
		totalCost=(armyCreatures[zombie_e]->getCost()) * numToBuy;
		gold=gold-totalCost;
		numOfCretures[zombie_e]= numOfCretures[zombie_e]+ numToBuy;
		totalCreatures+= numToBuy;
		return true;
	}
	else{
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x62a2(%rip), %rsi      # 0xa059
movq %r15, %rdi
callq 0x3090
testl %eax, %eax
je 0x3e22
leaq 0x62f7(%rip), %rsi      # 0xa0c1
movq %r15, %rdi
callq 0x3090
testl %eax, %eax
je 0x3e4b
leaq 0x62ec(%rip), %rsi      # 0xa0c9
movq %r15, %rdi
callq 0x3090
testl %eax, %eax
je 0x3e71
leaq 0x62dd(%rip), %rsi      # 0xa0d1
movq %r15, %rdi
callq 0x3090
testl %eax, %eax
je 0x3e9a
leaq 0x62cf(%rip), %rsi      # 0xa0da
movq %r15, %rdi
callq 0x3090
testl %eax, %eax
je 0x3ec3
xorl %eax, %eax
jmp 0x3ef3
movq 0x50(%r14), %rdi
callq 0x3a4c
imull %ebx, %eax
movsd 0x48(%r14), %xmm0
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x48(%r14)
addl %ebx, 0x78(%r14)
jmp 0x3eea
movq 0x58(%r14), %rdi
callq 0x3a4c
imull %ebx, %eax
movsd 0x48(%r14), %xmm0
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x48(%r14)
addl %ebx, 0x7c(%r14)
jmp 0x3eea
movq 0x60(%r14), %rdi
callq 0x3a4c
imull %ebx, %eax
movsd 0x48(%r14), %xmm0
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x48(%r14)
addl %ebx, 0x80(%r14)
jmp 0x3eea
movq 0x68(%r14), %rdi
callq 0x3a4c
imull %ebx, %eax
movsd 0x48(%r14), %xmm0
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x48(%r14)
addl %ebx, 0x84(%r14)
jmp 0x3eea
movq 0x70(%r14), %rdi
callq 0x3a4c
imull %ebx, %eax
movsd 0x48(%r14), %xmm0
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x48(%r14)
addl %ebx, 0x88(%r14)
addl %ebx, 0x8c(%r14)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
addsd 0x48(%rdi), %xmm0
movsd 0x5ba1(%rip), %xmm1     # 0xa0a0
minsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
maxsd %xmm1, %xmm0
movsd %xmm0, 0x48(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x5947(%rip), %rsi      # 0xa0b3
movq %r14, %rdi
callq 0x3090
testl %eax, %eax
je 0x47d0
leaq 0x5942(%rip), %rsi      # 0xa0c1
movq %r14, %rdi
callq 0x3090
testl %eax, %eax
je 0x47d5
leaq 0x5937(%rip), %rsi      # 0xa0c9
movq %r14, %rdi
callq 0x3090
testl %eax, %eax
je 0x47da
leaq 0x592c(%rip), %rsi      # 0xa0d1
movq %r14, %rdi
callq 0x3090
testl %eax, %eax
je 0x47e2
leaq 0x5922(%rip), %rsi      # 0xa0da
movq %r14, %rdi
callq 0x3090
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x47e8
movl 0x88(%rbx), %eax
jmp 0x47e8
movl 0x78(%rbx), %eax
jmp 0x47e8
movl 0x7c(%rbx), %eax
jmp 0x47e8
movl 0x80(%rbx), %eax
jmp 0x47e8
movl 0x84(%rbx), %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, -0x2c(%rbp)
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %r13d
movsd %xmm0, -0x38(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3a58
leaq 0x4575(%rip), %rax      # 0xdc10
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x3110
leaq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rdx
leaq 0xc0e(%rip), %rcx       # 0xa2c7
movl $0xb, %r8d
xorl %esi, %esi
callq 0x3290
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %ecx
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x48(%rbx)
movl %r13d, 0x78(%rbx)
movl %r12d, 0x7c(%rbx)
movl %r15d, 0x80(%rbx)
movl -0x2c(%rbp), %edx
movl %edx, 0x84(%rbx)
movl %ecx, 0x88(%rbx)
movl %eax, 0x8c(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3d2e
movq %r14, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O3/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:
testq %rsi, %rsi
je 0x9918
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x44e2
movsd 0x7ca(%rip), %xmm1      # 0xa0a0
subsd 0x48(%rbx), %xmm1
minsd 0xbcd(%rip), %xmm1      # 0xa4b0
movapd %xmm0, %xmm2
minsd %xmm1, %xmm2
movapd %xmm2, -0x20(%rbp)
movapd 0xbc8(%rip), %xmm0      # 0xa4c0
xorpd %xmm2, %xmm0
movq %r14, %rdi
callq 0x44ee
movq %rbx, %rdi
movaps -0x20(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x44ee
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %ecx, %ecx
jle 0x99e2
movl %ecx, %ebx
movq %rdx, %r15
movl %esi, %r12d
imull 0x8(%rdi), %r12d
xorl %r14d, %r14d
movq %r15, %rdi
callq 0x3a42
cmpl %eax, %r12d
jl 0x99e5
movq %r15, %rdi
callq 0x3a42
subl %eax, %r12d
incl %r14d
cmpl %r14d, %ebx
jne 0x99bd
movl %ebx, %r14d
jmp 0x99e5
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, -0x2c(%rbp)
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %r13d
movsd %xmm0, -0x38(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3a58
leaq 0x41f5(%rip), %rax      # 0xdcd8
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x3110
leaq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rdx
leaq 0x7b6(%rip), %rcx       # 0xa2b7
movl $0x7, %r8d
xorl %esi, %esi
callq 0x3290
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %ecx
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x48(%rbx)
movl %r13d, 0x78(%rbx)
movl %r12d, 0x7c(%rbx)
movl %r15d, 0x80(%rbx)
movl -0x2c(%rbp), %edx
movl %edx, 0x84(%rbx)
movl %ecx, 0x88(%rbx)
movl %eax, 0x8c(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3d2e
movq %r14, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %r15d
imull 0x8(%rdi), %r15d
movq (%rdx), %rax
leaq -0x48(%rbp), %r13
movq %r13, %rdi
movq %rdx, %rsi
callq *0x18(%rax)
leaq 0x3ca(%rip), %rsi       # 0xa0c9
movq %r13, %rdi
callq 0x3090
movl %eax, %r12d
movq (%r13), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x9d23
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x31d0
testl %ebx, %ebx
jle 0x9d58
testl %r12d, %r12d
sete %cl
shll %cl, %r15d
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x3a42
cmpl %eax, %r15d
jl 0x9d5b
movq %r14, %rdi
callq 0x3a42
subl %eax, %r15d
incl %r12d
cmpl %r12d, %ebx
jne 0x9d33
movl %ebx, %r12d
jmp 0x9d5b
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %r13d
movq %rdi, %rbx
movl %esi, %edi
movl %ecx, %esi
movl %r9d, %edx
callq 0x3904
testq %rbx, %rbx
je 0x38e4
movl %eax, %r14d
cmpl $0x8, %r13d
setne %al
addl $-0xa, %r15d
cmpl $-0x9, %r15d
setb %cl
orb %al, %cl
movl $0xffffd8f0, %r15d      # imm = 0xFFFFD8F0
jne 0x38ea
cmpl $0xf, %r12d
je 0x386a
cmpl $-0xf, %r12d
jne 0x38ea
movl $0x0, 0x58(%rbx)
movq $0x1, 0x60(%rbx)
xorl %eax, %eax
movq %rax, 0x68(%rbx)
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movq 0x40(%rbx), %rax
testq %rax, %rax
jne 0x389e
leaq -0xee(%rip), %rax       # 0x37ac
movq %rax, 0x40(%rbx)
cmpq $0x0, 0x48(%rbx)
jne 0x38b0
leaq -0xef(%rip), %rcx       # 0x37bd
movq %rcx, 0x48(%rbx)
movq 0x50(%rbx), %rdi
movl $0x1, %esi
movl $0x4df78, %edx          # imm = 0x4DF78
callq *%rax
testq %rax, %rax
je 0x38fc
orl $0x2000, %r14d          # imm = 0x2000
movq %rax, 0x38(%rbx)
xorl %r15d, %r15d
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl %r14d, %ecx
callq 0x3982
jmp 0x38ea
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xfffffffc, %r15d      # imm = 0xFFFFFFFC
jmp 0x38ea
// File: /workspace/github_cpp_makefile_star2_O3/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
cmpl $0xa, %edi
movl $0xa, %eax
cmovbl %edi, %eax
testl %edi, %edi
movl $0x6, %ecx
cmovnsl %eax, %ecx
leaq 0x12bdc(%rip), %rax     # 0x16500
xorl %r8d, %r8d
cmpl $0x4, %edi
setl %r8b
shll $0xe, %r8d
orl (%rax,%rcx,4), %r8d
movl %r8d, %eax
orl $0x1000, %eax           # imm = 0x1000
testl %esi, %esi
cmovlel %r8d, %eax
testl %edi, %edi
je 0x3966
decl %edx
cmpl $0x3, %edx
ja 0x3980
leaq 0x126ba(%rip), %rcx     # 0x16010
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
orl $0x20000, %eax          # imm = 0x20000
jmp 0x3980
orl $0x80000, %eax          # imm = 0x80000
jmp 0x3980
orl $0x10000, %eax          # imm = 0x10000
jmp 0x3980
orl $0x40000, %eax          # imm = 0x40000
jmp 0x3980
andl $0xfffff000, %eax       # imm = 0xFFFFF000
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3ac4
movq %rdi, %r14
movq 0x38(%rdi), %rsi
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x3ac9
movq 0x50(%r14), %rdi
callq *0x48(%r14)
movq $0x0, 0x38(%r14)
jmp 0x3ac9
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_compress2
int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len, int level)
{
    int status;
    mz_stream stream;
    memset(&stream, 0, sizeof(stream));

    /* In case mz_ulong is 64-bits (argh I hate longs). */
    if ((source_len | *pDest_len) > 0xFFFFFFFFU)
        return MZ_PARAM_ERROR;

    stream.next_in = pSource;
    stream.avail_in = (mz_uint32)source_len;
    stream.next_out = pDest;
    stream.avail_out = (mz_uint32)*pDest_len;

    status = mz_deflateInit(&stream, level);
    if (status != MZ_OK)
        return status;

    status = mz_deflate(&stream, MZ_FINISH);
    if (status != MZ_STREAM_END)
    {
        mz_deflateEnd(&stream);
        return (status == MZ_OK) ? MZ_BUF_ERROR : status;
    }

    *pDest_len = stream.total_out;
    return mz_deflateEnd(&stream);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, -0x30(%rbp)
movups %xmm0, -0x40(%rbp)
movups %xmm0, -0x50(%rbp)
movups %xmm0, -0x60(%rbp)
movups %xmm0, -0x70(%rbp)
movups %xmm0, -0x80(%rbp)
movq $0x0, -0x20(%rbp)
movq (%rsi), %rsi
movq %rsi, %rax
orq %rcx, %rax
shrq $0x20, %rax
movl $0xffffd8f0, %r14d      # imm = 0xFFFFD8F0
jne 0x3f9a
leaq -0x88(%rbp), %rax
movq %rdx, (%rax)
movl %ecx, 0x8(%rax)
movq %rdi, 0x18(%rax)
movl %esi, 0x20(%rax)
movq %rax, %rdi
movl %r8d, %esi
movl $0x8, %edx
movl $0xf, %ecx
movl $0x9, %r8d
xorl %r9d, %r9d
callq 0x3808
movl %eax, %r14d
testl %eax, %eax
jne 0x3f9a
leaq -0x88(%rbp), %rdi
movl $0x4, %esi
callq 0x3b19
cmpl $0x1, %eax
jne 0x3f7a
movq -0x60(%rbp), %rax
movq %rax, (%rbx)
movq -0x50(%rbp), %rsi
xorl %r14d, %r14d
testq %rsi, %rsi
je 0x3f9a
movq -0x38(%rbp), %rdi
callq *-0x40(%rbp)
jmp 0x3f9a
movl %eax, %r15d
movq -0x50(%rbp), %rsi
testq %rsi, %rsi
je 0x3f8d
movq -0x38(%rbp), %rdi
callq *-0x40(%rbp)
testl %r15d, %r15d
movl $0xfffffffb, %r14d      # imm = 0xFFFFFFFB
cmovnel %r15d, %r14d
movl %r14d, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_inflateInit2
int mz_inflateInit2(mz_streamp pStream, int window_bits)
{
    inflate_state *pDecomp;
    if (!pStream)
        return MZ_STREAM_ERROR;
    if ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS))
        return MZ_PARAM_ERROR;

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

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

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

    tinfl_init(&pDecomp->m_decomp);
    pDecomp->m_dict_ofs = 0;
    pDecomp->m_dict_avail = 0;
    pDecomp->m_last_status = TINFL_STATUS_NEEDS_MORE_INPUT;
    pDecomp->m_first_call = 1;
    pDecomp->m_has_flushed = 0;
    pDecomp->m_window_bits = window_bits;

    return MZ_OK;
}

// Assembly:
testq %rdi, %rdi
je 0x40ba
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
cmpl $0xf, %esi
je 0x402e
movl $0xffffd8f0, %eax       # imm = 0xFFFFD8F0
cmpl $-0xf, %ebx
jne 0x40c5
movl $0x0, 0x58(%r14)
movq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x60(%r14)
movq 0x40(%r14), %rax
testq %rax, %rax
jne 0x405f
leaq -0x8af(%rip), %rax      # 0x37ac
movq %rax, 0x40(%r14)
cmpq $0x0, 0x48(%r14)
jne 0x4071
leaq -0x8b0(%rip), %rcx      # 0x37bd
movq %rcx, 0x48(%r14)
movq 0x50(%r14), %rdi
movl $0x1, %esi
movl $0xab10, %edx           # imm = 0xAB10
callq *%rax
testq %rax, %rax
je 0x40c0
movq %rax, 0x38(%r14)
movl $0x0, (%rax)
movq $0x0, 0x2af8(%rax)
movl $0x1, 0xab0c(%rax)
movq $0x1, 0x2b00(%rax)
movl %ebx, 0x2b08(%rax)
xorl %eax, %eax
jmp 0x40c5
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
retq
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_uncompress
int mz_uncompress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len)
{
    mz_stream stream;
    int status;
    memset(&stream, 0, sizeof(stream));

    /* In case mz_ulong is 64-bits (argh I hate longs). */
    if ((source_len | *pDest_len) > 0xFFFFFFFFU)
        return MZ_PARAM_ERROR;

    stream.next_in = pSource;
    stream.avail_in = (mz_uint32)source_len;
    stream.next_out = pDest;
    stream.avail_out = (mz_uint32)*pDest_len;

    status = mz_inflateInit(&stream);
    if (status != MZ_OK)
        return status;

    status = mz_inflate(&stream, MZ_FINISH);
    if (status != MZ_STREAM_END)
    {
        mz_inflateEnd(&stream);
        return ((status == MZ_BUF_ERROR) && (!stream.avail_in)) ? MZ_DATA_ERROR : status;
    }
    *pDest_len = stream.total_out;

    return mz_inflateEnd(&stream);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, -0x30(%rbp)
movups %xmm0, -0x40(%rbp)
movups %xmm0, -0x50(%rbp)
movups %xmm0, -0x60(%rbp)
movups %xmm0, -0x70(%rbp)
movups %xmm0, -0x80(%rbp)
movq $0x0, -0x20(%rbp)
movq (%rsi), %rsi
movq %rsi, %rax
orq %rcx, %rax
shrq $0x20, %rax
movl $0xffffd8f0, %r14d      # imm = 0xFFFFD8F0
jne 0x5e72
leaq -0x88(%rbp), %rax
movq %rdx, (%rax)
movl %ecx, 0x8(%rax)
movq %rdi, 0x18(%rax)
movl %esi, 0x20(%rax)
movq %rax, %rdi
movl $0xf, %esi
callq 0x4006
movl %eax, %r14d
testl %eax, %eax
jne 0x5e72
leaq -0x88(%rbp), %rdi
movl $0x4, %esi
callq 0x40d9
cmpl $0x1, %eax
jne 0x5e4c
movq -0x60(%rbp), %rax
movq %rax, (%rbx)
movq -0x50(%rbp), %rsi
xorl %r14d, %r14d
testq %rsi, %rsi
je 0x5e72
movq -0x38(%rbp), %rdi
callq *-0x40(%rbp)
jmp 0x5e72
movl %eax, %r15d
movq -0x50(%rbp), %rsi
testq %rsi, %rsi
je 0x5e5f
movq -0x38(%rbp), %rdi
callq *-0x40(%rbp)
movl %r15d, %eax
xorl $-0x5, %eax
orl -0x80(%rbp), %eax
movl $0xfffffffd, %r14d      # imm = 0xFFFFFFFD
cmovnel %r15d, %r14d
movl %r14d, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jimmiebergmann[P]fbx-file/miniz.c
// Function: tdefl_compress_mem_to_output
mz_bool tdefl_compress_mem_to_output(const void *pBuf, size_t buf_len, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
{
    tdefl_compressor *pComp;
    mz_bool succeeded;
    if (((buf_len) && (!pBuf)) || (!pPut_buf_func))
        return MZ_FALSE;
    pComp = (tdefl_compressor *)MZ_MALLOC(sizeof(tdefl_compressor));
    if (!pComp)
        return MZ_FALSE;
    succeeded = (tdefl_init(pComp, pPut_buf_func, pPut_buf_user, flags) == TDEFL_STATUS_OKAY);
    succeeded = succeeded && (tdefl_compress_buffer(pComp, pBuf, buf_len, TDEFL_FINISH) == TDEFL_STATUS_DONE);
    MZ_FREE(pComp);
    return succeeded;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r13
testq %rsi, %rsi
setne %al
testq %rdi, %rdi
sete %dl
andb %al, %dl
testq %r13, %r13
sete %al
xorl %r15d, %r15d
orb %dl, %al
jne 0x76b8
movq %rsi, %rbx
movq %rdi, %r14
movq %rcx, -0x38(%rbp)
movl %r8d, -0x2c(%rbp)
movl $0x4df78, %edi          # imm = 0x4DF78
callq 0x3320
testq %rax, %rax
je 0x76b8
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
movq -0x38(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x3982
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x4, %ecx
callq 0x75de
xorl %r15d, %r15d
cmpl $0x1, %eax
sete %r15b
movq %r12, %rdi
callq 0x32d0
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jimmiebergmann[P]fbx-file/miniz.c
// Function: tdefl_compress_mem_to_heap
void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
{
    tdefl_output_buffer out_buf;
    MZ_CLEAR_OBJ(out_buf);
    if (!pOut_len)
        return MZ_FALSE;
    else
        *pOut_len = 0;
    out_buf.m_expandable = MZ_TRUE;
    if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags))
        return NULL;
    *pOut_len = out_buf.m_size;
    return out_buf.m_pBuf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movaps %xmm0, -0x30(%rbp)
testq %rdx, %rdx
je 0x7718
movl %ecx, %r8d
movq %rdx, %rbx
movq $0x0, (%rdx)
leaq -0x30(%rbp), %rcx
movl $0x1, 0x18(%rcx)
leaq 0x1f(%rip), %rdx        # 0x7721
callq 0x7632
testl %eax, %eax
je 0x7718
movq -0x30(%rbp), %rax
movq %rax, (%rbx)
movq -0x20(%rbp), %rax
jmp 0x771a
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jimmiebergmann[P]fbx-file/miniz.c
// Function: tdefl_output_buffer_putter(void const*, int, void*)
static mz_bool tdefl_output_buffer_putter(const void *pBuf, int len, void *pUser)
{
    tdefl_output_buffer *p = (tdefl_output_buffer *)pUser;
    size_t new_size = p->m_size + len;
    if (new_size > p->m_capacity)
    {
        size_t new_capacity = p->m_capacity;
        mz_uint8 *pNew_buf;
        if (!p->m_expandable)
            return MZ_FALSE;
        do
        {
            new_capacity = MZ_MAX(128U, new_capacity << 1U);
        } while (new_size > new_capacity);
        pNew_buf = (mz_uint8 *)MZ_REALLOC(p->m_pBuf, new_capacity);
        if (!pNew_buf)
            return MZ_FALSE;
        p->m_pBuf = pNew_buf;
        p->m_capacity = new_capacity;
    }
    memcpy((mz_uint8 *)p->m_pBuf + p->m_size, pBuf, len);
    p->m_size = new_size;
    return MZ_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %rcx
movq (%rdx), %rdi
movq 0x8(%rdx), %r12
movslq %esi, %r15
leaq (%rdi,%r15), %r14
cmpq %r12, %r14
jbe 0x778f
xorl %r13d, %r13d
cmpl $0x0, 0x18(%rbx)
je 0x77aa
movq %rcx, -0x30(%rbp)
movl $0x80, %eax
addq %r12, %r12
cmpq $0x81, %r12
cmovbq %rax, %r12
cmpq %r12, %r14
ja 0x775a
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x33e0
testq %rax, %rax
je 0x77aa
movq %rax, 0x10(%rbx)
movq %r12, 0x8(%rbx)
movq (%rbx), %rdi
movq -0x30(%rbp), %rcx
jmp 0x7793
movq 0x10(%rbx), %rax
addq %rax, %rdi
movq %rcx, %rsi
movq %r15, %rdx
callq 0x31e0
movq %r14, (%rbx)
movl $0x1, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jimmiebergmann[P]fbx-file/miniz.c
// Function: tdefl_compress_mem_to_mem
size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags)
{
    tdefl_output_buffer out_buf;
    MZ_CLEAR_OBJ(out_buf);
    if (!pOut_buf)
        return 0;
    out_buf.m_pBuf = (mz_uint8 *)pOut_buf;
    out_buf.m_capacity = out_buf_len;
    if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags))
        return 0;
    return out_buf.m_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x10(%rbp)
movaps %xmm0, -0x20(%rbp)
testq %rdi, %rdi
je 0x7802
leaq -0x20(%rbp), %rax
movq %rdi, 0x10(%rax)
movq %rsi, 0x8(%rax)
leaq -0xc6(%rip), %r9        # 0x7721
movq %rdx, %rdi
movq %rcx, %rsi
movq %r9, %rdx
movq %rax, %rcx
callq 0x7632
testl %eax, %eax
je 0x7802
movq -0x20(%rbp), %rax
jmp 0x7804
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jimmiebergmann[P]fbx-file/miniz.c
// Function: tinfl_decompress_mem_to_heap
void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
{
    tinfl_decompressor decomp;
    void *pBuf = NULL, *pNew_buf;
    size_t src_buf_ofs = 0, out_buf_capacity = 0;
    *pOut_len = 0;
    tinfl_init(&decomp);
    for (;;)
    {
        size_t src_buf_size = src_buf_len - src_buf_ofs, dst_buf_size = out_buf_capacity - *pOut_len, new_out_buf_capacity;
        tinfl_status status = tinfl_decompress(&decomp, (const mz_uint8 *)pSrc_buf + src_buf_ofs, &src_buf_size, (mz_uint8 *)pBuf, pBuf ? (mz_uint8 *)pBuf + *pOut_len : NULL, &dst_buf_size,
                                               (flags & ~TINFL_FLAG_HAS_MORE_INPUT) | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF);
        if ((status < 0) || (status == TINFL_STATUS_NEEDS_MORE_INPUT))
        {
            MZ_FREE(pBuf);
            *pOut_len = 0;
            return NULL;
        }
        src_buf_ofs += src_buf_size;
        *pOut_len += dst_buf_size;
        if (status == TINFL_STATUS_DONE)
            break;
        new_out_buf_capacity = out_buf_capacity * 2;
        if (new_out_buf_capacity < 128)
            new_out_buf_capacity = 128;
        pNew_buf = MZ_REALLOC(pBuf, new_out_buf_capacity);
        if (!pNew_buf)
        {
            MZ_FREE(pBuf);
            *pOut_len = 0;
            return NULL;
        }
        pBuf = pNew_buf;
        out_buf_capacity = new_out_buf_capacity;
    }
    return pBuf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2b28, %rsp           # imm = 0x2B28
movq %rdx, %rbx
movq %rsi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq $0x0, (%rdx)
leaq -0x2b48(%rbp), %rax
movl $0x0, (%rax)
andl $-0x7, %ecx
orl $0x4, %ecx
movl %ecx, -0x2c(%rbp)
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %r14d, %r14d
xorl %r15d, %r15d
movq -0x50(%rbp), %rax
subq %r14, %rax
movq %rax, -0x40(%rbp)
movq %r15, %rax
subq %r12, %rax
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
leaq (%rax,%r14), %rsi
testq %r13, %r13
je 0x7b7d
addq %r13, %r12
movl -0x2c(%rbp), %eax
movl %eax, (%rsp)
leaq -0x2b48(%rbp), %rdi
leaq -0x40(%rbp), %rdx
movq %r13, %rcx
movq %r12, %r8
jmp 0x7b93
movl -0x2c(%rbp), %eax
movl %eax, (%rsp)
leaq -0x2b48(%rbp), %rdi
leaq -0x40(%rbp), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
leaq -0x38(%rbp), %r9
callq 0x441a
testl %eax, %eax
js 0x7be2
cmpl $0x1, %eax
je 0x7be2
addq -0x40(%rbp), %r14
movq (%rbx), %r12
addq -0x38(%rbp), %r12
movq %r12, (%rbx)
testl %eax, %eax
je 0x7bf4
addq %r15, %r15
cmpq $0x81, %r15
movl $0x80, %eax
cmovbq %rax, %r15
movq %r13, %rdi
movq %r15, %rsi
callq 0x33e0
testq %rax, %rax
je 0x7be2
movq %rax, %r13
jmp 0x7b3f
movq %r13, %rdi
callq 0x32d0
movq $0x0, (%rbx)
xorl %r13d, %r13d
movq %r13, %rax
addq $0x2b28, %rsp           # imm = 0x2B28
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq