LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x456d(%rip), %rbx      # 0x6fe0
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x20a0
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
je 0x2b18
movq 0x4537(%rip), %r14      # 0x6fd0
leaq 0x15a5(%rip), %r15      # 0x4045
leaq 0x4(%rsp), %r12
movl $0x3a, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2190
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
xorl %esi, %esi
callq 0x2220
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
movl $0xa, %edx
callq 0x20b0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x20a0
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
jne 0x2aa5
movq 0x44c1(%rip), %rdi      # 0x6fe0
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x20b0
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x448b(%rip), %r14      # 0x6fe0
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x20a0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
je 0x2bfc
movq 0x4454(%rip), %r15      # 0x6fd0
leaq 0x14c2(%rip), %r12      # 0x4045
leaq 0xc(%rsp), %r13
movl $0x3a, %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 0x20a0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
jne 0x2b88
movq 0x43dd(%rip), %rdi      # 0x6fe0
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x20b0
movl 0xc(%rsp), %eax
movl %eax, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl 0x20(%r15,%rax), %eax
testb $0x5, %al
jne 0x2c87
movl 0xc(%rsp), %ecx
cmpl %r14d, %ecx
setge %dl
cmpl %ebp, %ecx
setle %cl
testb %cl, %dl
jne 0x2d4a
testb $0x5, %al
je 0x2cee
movl $0x39, %edx
movq %rbx, %rdi
leaq 0x13ea(%rip), %rsi      # 0x4080
callq 0x2190
movq %rbx, %r13
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
movl $0x23, %edx
movq %rbx, %rdi
leaq 0x13bd(%rip), %rsi      # 0x40ba
callq 0x2190
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2230
movq %rax, %r13
movl $0x5, %edx
movq %rax, %rdi
leaq 0x13bf(%rip), %rsi      # 0x40de
callq 0x2190
movq %r13, %rdi
movl %ebp, %esi
callq 0x2230
movq %rax, %r13
movl $0x16, %edx
movq %rax, %rdi
leaq 0x13a4(%rip), %rsi      # 0x40e4
callq 0x2190
jmp 0x2c9e
movq 0x428f(%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_O1/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 0x424f(%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 0x2e38
movq 0x4218(%rip), %r15      # 0x6fd0
leaq 0x133c(%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 0x2dc4
movq 0x41a1(%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_O1/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 0x4154(%rip), %r14      # 0x6fe0
leaq 0x18(%rsp), %r15
movq 0x4138(%rip), %rbp      # 0x6fd0
leaq 0x1245(%rip), %rbx      # 0x40e4
leaq 0x1255(%rip), %r13      # 0x40fb
movq %r14, %rdi
movq %r15, %rsi
callq 0x20c0
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x20(%r14,%rax), %eax
testb $0x5, %al
jne 0x2ee3
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x2edf
ucomisd 0x8(%rsp), %xmm0
jbe 0x2fa5
testb $0x5, %al
je 0x2f46
movl $0x38, %edx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x2190
movq %rbp, %r12
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 0x2ea6
movl $0x23, %edx
movq %rbp, %rdi
leaq 0x1165(%rip), %rsi      # 0x40ba
callq 0x2190
movq %rbp, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x2200
movq %rax, %r12
movl $0x5, %edx
movq %rax, %rdi
leaq 0x1164(%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
jmp 0x2ef6
movq 0x4034(%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_O1/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), %rcx
testl %ecx, %ecx
setg %al
jle 0x3088
movq (%rdi), %rdx
movb (%rdx), %sil
addb $-0x3a, %sil
cmpb $-0xa, %sil
jb 0x3088
movl %ecx, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl $0x1, %edi
movq %rdi, %rsi
cmpq %rdi, %rax
je 0x3082
movb (%rdx,%rsi), %r8b
addb $-0x3a, %r8b
leaq 0x1(%rsi), %rdi
cmpb $-0xb, %r8b
ja 0x3068
cmpq %rax, %rsi
setb %al
testq %rcx, %rcx
setne %cl
xorb $0x1, %al
andb %cl, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3978(%rip), %r15      # 0x6fd0
leaq 0xbb9(%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 0xba5(%rip), %rbp       # 0x423f
movl $0x6, %edx
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2190
callq 0x2a64
movl %eax, (%rbx)
leaq 0xb8e(%rip), %rbx       # 0x4246
movl $0x7, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2190
callq 0x2a64
movl %eax, (%r14)
leaq 0xb77(%rip), %r14       # 0x424e
movl $0x9, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2190
callq 0x2a64
movl %eax, (%r13)
leaq 0xb61(%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_O1/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 0x3d7d
cmpl $0x73, %esi
je 0x3d6e
cmpl $0x72, %esi
jne 0x3d96
movl $0x4, %r8d
leaq 0x6aa(%rip), %rcx       # 0x4416
jmp 0x3d8a
movl $0x7, %r8d
leaq 0x6a6(%rip), %rcx       # 0x4421
jmp 0x3d8a
movl $0x5, %r8d
leaq 0x691(%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 0x3db5
movq (%r15), %rsi
incq %rsi
callq 0x2180
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/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
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 0x68bd(%rip), %rsi      # 0xa010
movq %r13, %rdi
callq 0x3090
movl %eax, %r12d
movq (%r13), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3777
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x31d0
testl %ebx, %ebx
jle 0x37bc
cvtsi2sd %r15d, %xmm0
mulsd 0x6880(%rip), %xmm0     # 0xa008
cvttsd2si %xmm0, %r13d
testl %r12d, %r12d
cmovnel %r15d, %r13d
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x3a3e
cmpl %eax, %r13d
jl 0x37bf
movq %r14, %rdi
callq 0x3a3e
subl %eax, %r13d
incl %r15d
cmpl %r15d, %ebx
jne 0x3797
movl %ebx, %r15d
jmp 0x37bf
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3a3e
movl %eax, %r15d
imull 0x8(%r13), %r14d
movq (%r12), %rax
leaq -0x48(%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq *0x18(%rax)
leaq 0x6797(%rip), %rsi      # 0xa0c1
movq %r13, %rdi
callq 0x3090
movl %eax, %r12d
movq (%r13), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x394e
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x31d0
testl %r12d, %r12d
sete %cl
shll %cl, %r15d
xorl %eax, %eax
testl %ebx, %ebx
jle 0x3975
subl %r15d, %r14d
jl 0x3975
xorl %eax, %eax
leal (%rbx,%rax), %ecx
decl %eax
cmpl $0x2, %ecx
jl 0x3973
subl %r15d, %r14d
jge 0x3964
negl %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa16c(%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 0x65f8(%rip), %rcx      # 0xa0a8
movl $0x4, %r8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3290
movq 0x30(%r15), %rdx
leaq 0x65e0(%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 0x3884
movq %r12, 0x50(%r15)
movl $0x18, %edi
callq 0x31c0
movq %rax, %r12
movq %rax, %rdi
callq 0x9b9c
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 0x9938
movq %r12, 0x68(%r15)
movl $0x18, %edi
callq 0x31c0
movq %rax, %r12
movq %rax, %rdi
callq 0x9c64
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 0x3b84
jmp 0x3b84
jmp 0x3b84
jmp 0x3b84
movq %rax, %r15
movl $0x18, %esi
movq %r12, %rdi
callq 0x31d0
jmp 0x3b99
movq %rax, %r15
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x3bad
movq (%r13), %rsi
incq %rsi
callq 0x31d0
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x3bc5
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x31d0
movq %r15, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9fef(%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 0x3884
movq %r12, 0x50(%r15)
movl $0x18, %edi
callq 0x31c0
movq %rax, %r12
movq %rax, %rdi
callq 0x9b9c
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 0x9938
movq %r12, 0x68(%r15)
movl $0x18, %edi
callq 0x31c0
movq %rax, %r12
movq %rax, %rdi
callq 0x9c64
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 0x3ce0
jmp 0x3ce0
jmp 0x3ce0
jmp 0x3ce0
movq %rax, %r15
movl $0x18, %esi
movq %r12, %rdi
callq 0x31d0
jmp 0x3cf5
movq %rax, %r15
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x3d09
movq (%r13), %rsi
incq %rsi
callq 0x31d0
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x3d21
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x31d0
movq %r15, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x62a6(%rip), %rsi      # 0xa059
movq %r15, %rdi
callq 0x3090
testl %eax, %eax
je 0x3e1e
leaq 0x62fb(%rip), %rsi      # 0xa0c1
movq %r15, %rdi
callq 0x3090
testl %eax, %eax
je 0x3e47
leaq 0x62f0(%rip), %rsi      # 0xa0c9
movq %r15, %rdi
callq 0x3090
testl %eax, %eax
je 0x3e6d
leaq 0x62e1(%rip), %rsi      # 0xa0d1
movq %r15, %rdi
callq 0x3090
testl %eax, %eax
je 0x3e96
leaq 0x62d3(%rip), %rsi      # 0xa0da
movq %r15, %rdi
callq 0x3090
testl %eax, %eax
je 0x3ebf
xorl %eax, %eax
jmp 0x3eef
movq 0x50(%r14), %rdi
callq 0x3a48
imull %ebx, %eax
movsd 0x48(%r14), %xmm0
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x48(%r14)
addl %ebx, 0x78(%r14)
jmp 0x3ee6
movq 0x58(%r14), %rdi
callq 0x3a48
imull %ebx, %eax
movsd 0x48(%r14), %xmm0
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x48(%r14)
addl %ebx, 0x7c(%r14)
jmp 0x3ee6
movq 0x60(%r14), %rdi
callq 0x3a48
imull %ebx, %eax
movsd 0x48(%r14), %xmm0
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x48(%r14)
addl %ebx, 0x80(%r14)
jmp 0x3ee6
movq 0x68(%r14), %rdi
callq 0x3a48
imull %ebx, %eax
movsd 0x48(%r14), %xmm0
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x48(%r14)
addl %ebx, 0x84(%r14)
jmp 0x3ee6
movq 0x70(%r14), %rdi
callq 0x3a48
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_O1/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 0x5ba9(%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_O1/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 0x5953(%rip), %rsi      # 0xa0b3
movq %r14, %rdi
callq 0x3090
testl %eax, %eax
je 0x47c4
leaq 0x594e(%rip), %rsi      # 0xa0c1
movq %r14, %rdi
callq 0x3090
testl %eax, %eax
je 0x47c9
leaq 0x5943(%rip), %rsi      # 0xa0c9
movq %r14, %rdi
callq 0x3090
testl %eax, %eax
je 0x47ce
leaq 0x5938(%rip), %rsi      # 0xa0d1
movq %r14, %rdi
callq 0x3090
testl %eax, %eax
je 0x47d6
leaq 0x592e(%rip), %rsi      # 0xa0da
movq %r14, %rdi
callq 0x3090
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x47dc
movl 0x88(%rbx), %eax
jmp 0x47dc
movl 0x78(%rbx), %eax
jmp 0x47dc
movl 0x7c(%rbx), %eax
jmp 0x47dc
movl 0x80(%rbx), %eax
jmp 0x47dc
movl 0x84(%rbx), %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3a54
leaq 0x4579(%rip), %rax      # 0xdc10
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x3110
leaq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rdx
leaq 0xc12(%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 0x3d2a
movq %r14, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O1/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
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 0x3a54
leaq 0x4425(%rip), %rax      # 0xdc50
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x3110
leaq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rdx
leaq 0xa77(%rip), %rcx       # 0xa2c0
movl $0x5, %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 0x3d2a
movq %r14, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9914
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x44da
movsd 0x7ce(%rip), %xmm1      # 0xa0a0
subsd 0x48(%rbx), %xmm1
minsd 0xbd1(%rip), %xmm1      # 0xa4b0
movapd %xmm0, %xmm2
minsd %xmm1, %xmm2
movapd %xmm2, -0x20(%rbp)
movapd 0xbcc(%rip), %xmm0      # 0xa4c0
xorpd %xmm2, %xmm0
movq %r14, %rdi
callq 0x44e6
movq %rbx, %rdi
movaps -0x20(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x44e6
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x99de
movl %ecx, %ebx
movq %rdx, %r15
movl %esi, %r12d
imull 0x8(%rdi), %r12d
xorl %r14d, %r14d
movq %r15, %rdi
callq 0x3a3e
cmpl %eax, %r12d
jl 0x99e1
movq %r15, %rdi
callq 0x3a3e
subl %eax, %r12d
incl %r14d
cmpl %r14d, %ebx
jne 0x99b9
movl %ebx, %r14d
jmp 0x99e1
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3a54
leaq 0x41f9(%rip), %rax      # 0xdcd8
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x3110
leaq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rdx
leaq 0x7ba(%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 0x3d2a
movq %r14, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3ce(%rip), %rsi       # 0xa0c9
movq %r13, %rdi
callq 0x3090
movl %eax, %r12d
movq (%r13), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x9d1f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x31d0
testl %ebx, %ebx
jle 0x9d54
testl %r12d, %r12d
sete %cl
shll %cl, %r15d
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x3a3e
cmpl %eax, %r15d
jl 0x9d57
movq %r14, %rdi
callq 0x3a3e
subl %eax, %r15d
incl %r12d
cmpl %r12d, %ebx
jne 0x9d2f
movl %ebx, %r12d
jmp 0x9d57
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_O1/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_adler32
mz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr, size_t buf_len)
{
    mz_uint32 i, s1 = (mz_uint32)(adler & 0xffff), s2 = (mz_uint32)(adler >> 16);
    size_t block_len = buf_len % 5552;
    if (!ptr)
        return MZ_ADLER32_INIT;
    while (buf_len)
    {
        for (i = 0; i + 7 < block_len; i += 8, ptr += 8)
        {
            s1 += ptr[0], s2 += s1;
            s1 += ptr[1], s2 += s1;
            s1 += ptr[2], s2 += s1;
            s1 += ptr[3], s2 += s1;
            s1 += ptr[4], s2 += s1;
            s1 += ptr[5], s2 += s1;
            s1 += ptr[6], s2 += s1;
            s1 += ptr[7], s2 += s1;
        }
        for (; i < block_len; ++i)
            s1 += *ptr++, s2 += s1;
        s1 %= 65521U, s2 %= 65521U;
        buf_len -= block_len;
        block_len = 5552;
    }
    return (s2 << 16) + s1;
}

// Assembly:
testq %rsi, %rsi
je 0x370c
movq %rdx, %r8
movq %rdi, %rcx
shrq $0x10, %rcx
movzwl %di, %edi
testq %rdx, %rdx
je 0x3705
pushq %rbp
movq %rsp, %rbp
movq %r8, %rax
shrq $0x4, %rax
movabsq $0x179baa6bb6398b7, %rdx # imm = 0x179BAA6BB6398B7
mulq %rdx
shrq %rdx
imulq $0x15b0, %rdx, %rdx     # imm = 0x15B0
movq %r8, %rax
subq %rdx, %rax
movl $0x80078071, %edx       # imm = 0x80078071
xorl %r9d, %r9d
cmpq $0x8, %rax
jb 0x36ac
movzbl (%rsi,%r9), %r10d
addl %edi, %r10d
addl %r10d, %ecx
movzbl 0x1(%rsi,%r9), %edi
addl %r10d, %edi
addl %edi, %ecx
movzbl 0x2(%rsi,%r9), %r10d
addl %edi, %r10d
addl %r10d, %ecx
movzbl 0x3(%rsi,%r9), %edi
addl %r10d, %edi
addl %edi, %ecx
movzbl 0x4(%rsi,%r9), %r10d
addl %edi, %r10d
addl %r10d, %ecx
movzbl 0x5(%rsi,%r9), %edi
addl %r10d, %edi
addl %edi, %ecx
movzbl 0x6(%rsi,%r9), %r10d
addl %edi, %r10d
addl %r10d, %ecx
movzbl 0x7(%rsi,%r9), %edi
addl %r10d, %edi
addl %edi, %ecx
addq $0x8, %r9
leal 0x7(%r9), %r10d
cmpl %eax, %r10d
jb 0x3641
addq %r9, %rsi
movq %rax, %r10
subq %r9, %r10
jbe 0x36cc
xorl %r9d, %r9d
movzbl (%rsi,%r9), %r11d
addl %r11d, %edi
addl %edi, %ecx
incq %r9
cmpq %r9, %r10
jne 0x36b7
addq %r10, %rsi
movl %edi, %r9d
imulq %rdx, %r9
shrq $0x2f, %r9
imull $0xfff1, %r9d, %r9d     # imm = 0xFFF1
subl %r9d, %edi
movl %ecx, %r9d
imulq %rdx, %r9
shrq $0x2f, %r9
imull $0xfff1, %r9d, %r9d     # imm = 0xFFF1
subl %r9d, %ecx
subq %rax, %r8
movl $0x15b0, %eax           # imm = 0x15B0
jne 0x3638
popq %rbp
shll $0x10, %ecx
orl %edi, %ecx
jmp 0x3711
movl $0x1, %ecx
movq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x38fe
testq %rbx, %rbx
je 0x38de
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 0x38e4
cmpl $0xf, %r12d
je 0x3866
cmpl $-0xf, %r12d
jne 0x38e4
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)
cmpq %rax, 0x40(%rbx)
jne 0x3897
leaq -0xe7(%rip), %rax       # 0x37ac
movq %rax, 0x40(%rbx)
cmpq $0x0, 0x48(%rbx)
jne 0x38a9
leaq -0xe8(%rip), %rax       # 0x37bd
movq %rax, 0x48(%rbx)
movq 0x50(%rbx), %rdi
movl $0x1, %esi
movl $0x4df78, %edx          # imm = 0x4DF78
callq *0x40(%rbx)
testq %rax, %rax
je 0x38f6
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 0x397f
jmp 0x38e4
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 0x38e4
// File: /workspace/github_cpp_makefile_star2_O1/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
cmovll %edi, %eax
testl %edi, %edi
movl $0x6, %ecx
cmovnsl %eax, %ecx
movslq %ecx, %rax
leaq 0x12bdf(%rip), %rcx     # 0x16500
xorl %r8d, %r8d
cmpl $0x4, %edi
setl %r8b
shll $0xe, %r8d
orl (%rcx,%rax,4), %r8d
movl %r8d, %eax
orl $0x1000, %eax           # imm = 0x1000
testl %esi, %esi
cmovlel %r8d, %eax
testl %edi, %edi
je 0x3963
decl %edx
cmpl $0x3, %edx
ja 0x397d
leaq 0x126bd(%rip), %rcx     # 0x16010
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
orl $0x20000, %eax          # imm = 0x20000
jmp 0x397d
orl $0x80000, %eax          # imm = 0x80000
jmp 0x397d
orl $0x10000, %eax          # imm = 0x10000
jmp 0x397d
orl $0x40000, %eax          # imm = 0x40000
jmp 0x397d
andl $0xfffff000, %eax       # imm = 0xFFFFF000
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3ac2
movq %rdi, %r14
movq 0x38(%rdi), %rsi
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x3ac7
movq 0x50(%r14), %rdi
callq *0x48(%r14)
movq $0x0, 0x38(%r14)
jmp 0x3ac7
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps %xmm0, -0x90(%rbp)
movq (%rsi), %rsi
movq %rsi, %rax
orq %rcx, %rax
shrq $0x20, %rax
movl $0xffffd8f0, %r14d      # imm = 0xFFFFD8F0
jne 0x3fb5
leaq -0x90(%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 0x3fb5
leaq -0x90(%rbp), %rdi
movl $0x4, %esi
callq 0x3b17
cmpl $0x1, %eax
jne 0x3f8d
movq -0x68(%rbp), %rax
movq %rax, (%rbx)
movq -0x58(%rbp), %rsi
xorl %r14d, %r14d
testq %rsi, %rsi
je 0x3fb5
movq -0x40(%rbp), %rdi
callq *-0x48(%rbp)
movq $0x0, -0x58(%rbp)
jmp 0x3fb5
movl %eax, %r15d
movq -0x58(%rbp), %rsi
testq %rsi, %rsi
je 0x3fa8
movq -0x40(%rbp), %rdi
callq *-0x48(%rbp)
movq $0x0, -0x58(%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_O1/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 0x40d5
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
cmpl $0xf, %esi
je 0x4049
movl $0xffffd8f0, %eax       # imm = 0xFFFFD8F0
cmpl $-0xf, %ebx
jne 0x40e0
movl $0x0, 0x58(%r14)
movq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x60(%r14)
cmpq $0x0, 0x40(%r14)
jne 0x4078
leaq -0x8c8(%rip), %rax      # 0x37ac
movq %rax, 0x40(%r14)
cmpq $0x0, 0x48(%r14)
jne 0x408a
leaq -0x8c9(%rip), %rax      # 0x37bd
movq %rax, 0x48(%r14)
movq 0x50(%r14), %rdi
movl $0x1, %esi
movl $0xab10, %edx           # imm = 0xAB10
callq *0x40(%r14)
testq %rax, %rax
je 0x40db
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 0x40e0
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
retq
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps %xmm0, -0x90(%rbp)
movq (%rsi), %rsi
movq %rsi, %rax
orq %rcx, %rax
shrq $0x20, %rax
movl $0xffffd8f0, %r14d      # imm = 0xFFFFD8F0
jne 0x5e17
leaq -0x90(%rbp), %rax
movq %rdx, (%rax)
movl %ecx, 0x8(%rax)
movq %rdi, 0x18(%rax)
movl %esi, 0x20(%rax)
movq %rax, %rdi
movl $0xf, %esi
callq 0x4021
movl %eax, %r14d
testl %eax, %eax
jne 0x5e17
leaq -0x90(%rbp), %rdi
movl $0x4, %esi
callq 0x40f4
cmpl $0x1, %eax
jne 0x5de6
movq -0x68(%rbp), %rax
movq %rax, (%rbx)
movq -0x58(%rbp), %rsi
xorl %r14d, %r14d
testq %rsi, %rsi
je 0x5e17
movq -0x40(%rbp), %rdi
callq *-0x48(%rbp)
movq $0x0, -0x58(%rbp)
jmp 0x5e17
movl %eax, %r15d
movq -0x58(%rbp), %rsi
testq %rsi, %rsi
je 0x5e01
movq -0x40(%rbp), %rdi
callq *-0x48(%rbp)
movq $0x0, -0x58(%rbp)
movl %r15d, %eax
xorl $-0x5, %eax
orl -0x88(%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_O1/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 0x768e
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 0x768e
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
movq -0x38(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x397f
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x4, %ecx
callq 0x75b4
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