LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Juan313[P]RockPaperScissor/input.cpp
// Function: readInt(int&)
void readInt(int& number)
{
  int temp;
  std::cin>>temp;
  while (!(std::cin))
  {
    std::cout<<"The number provided is not an integer. Please enter again."<<std::endl;
    std::cin.clear();
    std::cin.ignore(256,'\n');
    std::cin>>temp;
  }
  std::cin.ignore(256,'\n');
  number = temp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x45c7(%rip), %r14      # 0x6fe0
leaq 0x4(%rsp), %r15
movq 0x45ab(%rip), %r12      # 0x6fd0
leaq 0x1619(%rip), %r13      # 0x4045
pushq $0xa
popq %rbp
movq %r14, %rdi
movq %r15, %rsi
callq 0x20b0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
je 0x2a7e
movq %r12, %rdi
movq %r13, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x2090
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
xorl %esi, %esi
callq 0x2210
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
movl %ebp, %edx
callq 0x20c0
jmp 0x2a2f
movq 0x455b(%rip), %rdi      # 0x6fe0
pushq $0xa
popq %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x20c0
movl 0x4(%rsp), %eax
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x451a(%rip), %r15      # 0x6fe0
leaq 0xc(%rsp), %r12
movq 0x44fe(%rip), %r13      # 0x6fd0
pushq $0xa
popq %rbx
movq %r15, %rdi
movq %r12, %rsi
callq 0x20b0
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r15,%rax)
je 0x2afb
movq %r13, %rdi
leaq 0x1587(%rip), %rsi      # 0x4080
jmp 0x2b4b
movl 0xc(%rsp), %eax
cmpl %r14d, %eax
setl %cl
cmpl %ebp, %eax
setg %al
orb %cl, %al
je 0x2b7d
movq %r13, %rdi
leaq 0x15a2(%rip), %rsi      # 0x40ba
callq 0x2150
movq %rax, %rdi
movl %r14d, %esi
callq 0x2220
movq %rax, %rdi
leaq 0x15ac(%rip), %rsi      # 0x40de
callq 0x2150
movq %rax, %rdi
movl %ebp, %esi
callq 0x2220
movq %rax, %rdi
leaq 0x1599(%rip), %rsi      # 0x40e4
callq 0x2150
movq %rax, %rdi
callq 0x2090
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
xorl %esi, %esi
callq 0x2210
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
movl %ebx, %edx
callq 0x20c0
jmp 0x2ad5
movq 0x445c(%rip), %rdi      # 0x6fe0
pushq $0xa
popq %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x20c0
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_O2/Juan313[P]RockPaperScissor/input.cpp
// Function: readDouble(double&)
void readDouble(double& number)
{
  double temp;
  std::cin>>temp;
  while (!(std::cin))
  {
    std::cout<<"The number provided is not a double. Please enter again."<<std::endl;
    std::cin.clear();
    std::cin.ignore(256,'\n');
    std::cin>>temp;
  }
  std::cin.ignore(256,'\n');
  number = temp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4420(%rip), %r14      # 0x6fe0
movq %rsp, %r15
movq 0x4406(%rip), %r12      # 0x6fd0
leaq 0x152a(%rip), %r13      # 0x40fb
pushq $0xa
popq %rbp
movq %r14, %rdi
movq %r15, %rsi
callq 0x20d0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
je 0x2c23
movq %r12, %rdi
movq %r13, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x2090
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
xorl %esi, %esi
callq 0x2210
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
movl %ebp, %edx
callq 0x20c0
jmp 0x2bd4
movq 0x43b6(%rip), %rdi      # 0x6fe0
pushq $0xa
popq %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x20c0
movsd (%rsp), %xmm0
movsd %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x436b(%rip), %r14      # 0x6fe0
leaq 0x18(%rsp), %r15
movq 0x434f(%rip), %r12      # 0x6fd0
leaq 0x145c(%rip), %rbx      # 0x40e4
pushq $0xa
popq %r13
leaq 0x1468(%rip), %rbp      # 0x40fb
movq %r14, %rdi
movq %r15, %rsi
callq 0x20d0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
je 0x2cb5
movq %r12, %rdi
movq %rbp, %rsi
jmp 0x2d0f
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x2ccf
ucomisd 0x8(%rsp), %xmm0
jbe 0x2d42
movq %r12, %rdi
leaq 0x13e1(%rip), %rsi      # 0x40ba
callq 0x2150
movq %rax, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x21f0
movq %rax, %rdi
leaq 0x13e8(%rip), %rsi      # 0x40de
callq 0x2150
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x21f0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x2090
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
xorl %esi, %esi
callq 0x2210
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
movl %r13d, %edx
callq 0x20c0
jmp 0x2c93
movq 0x4297(%rip), %rdi      # 0x6fe0
pushq $0xa
popq %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x20c0
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_O2/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
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
cmpq %rcx, %rdx
je 0x2dde
movq (%rdi), %rsi
movb (%rsi,%rcx), %sil
addb $-0x3a, %sil
incq %rcx
cmpb $-0xa, %sil
jae 0x2dc2
xorl %eax, %eax
retq
testq %rax, %rax
setne %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/Juan313[P]RockPaperScissor/menu.cpp
// Function: Menu::customizeStrength()
char Menu::customizeStrength()
{
  char choice;
  std::cout << "\033[2J\033[1;1H";
  std::cout<<"Welcome to Rock, Paper, Scissors! Do you want to choose different strengths for the tools?"<<std::endl;
  std::cout<<"(y - yes, n - no)";
  readChar(choice);
  while (choice!= 'y' && choice!='n')
  {
    std::cout<<"Please only enter 'y' or 'n' for input."<<std::endl;
    readChar(choice);
  }
  return choice;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x3e5c(%rip), %rbx      # 0x6fd0
leaq 0xfd3(%rip), %rsi       # 0x414e
movq %rbx, %rdi
callq 0x2150
leaq 0xfcf(%rip), %rsi       # 0x4159
movq %rbx, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x2090
leaq 0x1013(%rip), %rsi      # 0x41b4
movq %rbx, %rdi
callq 0x2150
leaq 0xf(%rsp), %r14
leaq 0x1011(%rip), %r15      # 0x41c6
movq %r14, %rdi
callq 0x2d83
movzbl 0xf(%rsp), %eax
cmpl $0x6e, %eax
je 0x31e1
cmpl $0x79, %eax
je 0x31e1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x2090
jmp 0x31b5
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3dba(%rip), %r15      # 0x6fd0
leaq 0xfd1(%rip), %rsi       # 0x41ee
movq %r15, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x2090
leaq 0xfe1(%rip), %rbp       # 0x4215
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2150
callq 0x2968
movl %eax, (%rbx)
leaq 0xfcf(%rip), %rbx       # 0x421c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2150
callq 0x2968
movl %eax, (%r14)
leaq 0xfbd(%rip), %r14       # 0x4224
movq %r15, %rdi
movq %r14, %rsi
callq 0x2150
callq 0x2968
movl %eax, (%r13)
leaq 0xfac(%rip), %rsi       # 0x422e
movq %r15, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x2090
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2150
callq 0x2968
movl %eax, (%r12)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2150
callq 0x2968
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x2150
callq 0x2968
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_O2/Juan313[P]RockPaperScissor/menu.cpp
// Function: Menu::getChoice()
char Menu::getChoice()
{
  char choice;
  std::cout<<"Choose your tool(r - rock, p - paper, s - scissor, e - exit): ";
  readChar(choice);
  while (choice!= 'r' && choice!='p' && choice!='s' && choice !='e')
  {
    std::cout<<"Choose your tool(r - rock, p - paper, s - scissor, e - exit): ";
    readChar(choice);
  }
  return choice;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x3cdf(%rip), %rbx      # 0x6fd0
leaq 0xf60(%rip), %r14       # 0x4258
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2150
leaq 0x7(%rsp), %r15
movl $0x6801, %ebp           # imm = 0x6801
movq %r15, %rdi
callq 0x2d83
movzbl 0x7(%rsp), %eax
leal -0x65(%rax), %ecx
cmpl $0xe, %ecx
ja 0x3327
btl %ecx, %ebp
jb 0x3334
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2150
jmp 0x330d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpl $0x70, %esi
je 0x365f
cmpl $0x73, %esi
je 0x3656
cmpl $0x72, %esi
jne 0x366e
leaq 0xd98(%rip), %rsi       # 0x43ec
jmp 0x3666
leaq 0xd9a(%rip), %rsi       # 0x43f7
jmp 0x3666
leaq 0xd8b(%rip), %rsi       # 0x43f1
movq %rbx, %rdi
callq 0x2250
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2080
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/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), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq *0x18(%rax)
leaq 0x58e7(%rip), %rsi      # 0x9010
movq %r12, %rdi
callq 0x37cd
movl %eax, %r13d
movq %r12, %rdi
callq 0x30d0
cvtsi2sd %r15d, %xmm0
mulsd 0x58bf(%rip), %xmm0     # 0x9008
cvttsd2si %xmm0, %r12d
testb %r13b, %r13b
cmovel %r15d, %r12d
xorl %r15d, %r15d
leal (%rbx,%r15), %eax
testl %eax, %eax
jle 0x377d
movq %r14, %rdi
callq 0x39f8
cmpl %eax, %r12d
jl 0x377d
movq %r14, %rdi
callq 0x39f8
subl %eax, %r12d
decl %r15d
jmp 0x3758
negl %r15d
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x39f8
movl %eax, %r15d
imull 0x8(%r13), %r14d
movq (%r12), %rax
leaq -0x48(%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq *0x18(%rax)
leaq 0x578d(%rip), %rsi      # 0x90c1
movq %r13, %rdi
callq 0x37cd
movl %eax, %r12d
movq %r13, %rdi
callq 0x30d0
movl %r12d, %ecx
shll %cl, %r15d
xorl %eax, %eax
leal (%rbx,%rax), %ecx
testl %ecx, %ecx
jle 0x395f
subl %r15d, %r14d
jl 0x395f
decl %eax
jmp 0x394f
negl %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %r15
leaq 0x91b7(%rip), %rax      # 0xcbe0
movq %rax, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rdi), %rbx
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
leaq 0x28(%rdi), %r14
movb %al, 0x38(%rdi)
movabsq $0x4087700000000000, %rax # imm = 0x4087700000000000
movq %rax, 0x48(%rdi)
leaq 0x563d(%rip), %rsi      # 0x90a8
movq %rbx, %rdi
callq 0x3350
leaq 0x5633(%rip), %rsi      # 0x90ad
movq %r14, %rdi
callq 0x3350
pushq $0x18
popq %rdi
callq 0x31b0
movq %rax, %r12
movq %rax, %rdi
callq 0x3898
movq %r12, 0x50(%r15)
pushq $0x18
popq %rdi
callq 0x31b0
movq %rax, %r12
movq %rax, %rdi
callq 0x7e80
movq %r12, 0x58(%r15)
pushq $0x18
popq %rdi
callq 0x31b0
movq %rax, %r12
movq %rax, %rdi
callq 0x369c
movq %r12, 0x60(%r15)
pushq $0x18
popq %rdi
callq 0x31b0
movq %rax, %r12
movq %rax, %rdi
callq 0x7c4c
movq %r12, 0x68(%r15)
pushq $0x18
popq %rdi
callq 0x31b0
movq %rax, %r12
movq %rax, %rdi
callq 0x7f3c
movq %r12, 0x70(%r15)
xorl %eax, %eax
cmpq $0x5, %rax
je 0x3b08
andl $0x0, 0x78(%r15,%rax,4)
incq %rax
jmp 0x3af7
andl $0x0, 0x8c(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3b21
jmp 0x3b21
jmp 0x3b21
jmp 0x3b21
movq %rax, %r15
pushq $0x18
popq %rsi
movq %r12, %rdi
callq 0x31c0
jmp 0x3b34
movq %rax, %r15
movq %r14, %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x30d0
movq %r15, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdx, %r12
movq %rdi, %r15
leaq 0x907c(%rip), %rax      # 0xcbe0
movq %rax, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rdi), %rbx
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
leaq 0x28(%rdi), %r14
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
pushq $0x18
popq %rdi
callq 0x31b0
movq %rax, %r12
movq %rax, %rdi
callq 0x3898
movq %r12, 0x50(%r15)
pushq $0x18
popq %rdi
callq 0x31b0
movq %rax, %r12
movq %rax, %rdi
callq 0x7e80
movq %r12, 0x58(%r15)
pushq $0x18
popq %rdi
callq 0x31b0
movq %rax, %r12
movq %rax, %rdi
callq 0x369c
movq %r12, 0x60(%r15)
pushq $0x18
popq %rdi
callq 0x31b0
movq %rax, %r12
movq %rax, %rdi
callq 0x7c4c
movq %r12, 0x68(%r15)
pushq $0x18
popq %rdi
callq 0x31b0
movq %rax, %r12
movq %rax, %rdi
callq 0x7f3c
movq %r12, 0x70(%r15)
xorl %eax, %eax
cmpq $0x5, %rax
je 0x3c38
andl $0x0, 0x78(%r15,%rax,4)
incq %rax
jmp 0x3c27
andl $0x0, 0x8c(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3c51
jmp 0x3c51
jmp 0x3c51
jmp 0x3c51
movq %rax, %r15
pushq $0x18
popq %rsi
movq %r12, %rdi
callq 0x31c0
jmp 0x3c64
movq %rax, %r15
movq %r14, %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x30d0
movq %r15, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5372(%rip), %rsi      # 0x9059
movq %r15, %rdi
callq 0x37cd
testb %al, %al
je 0x3d1c
movq 0x50(%r14), %rdi
callq 0x3a02
imull %ebx, %eax
movsd 0x48(%r14), %xmm0
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x48(%r14)
addl %ebx, 0x78(%r14)
jmp 0x3e0a
leaq 0x539e(%rip), %rsi      # 0x90c1
movq %r15, %rdi
callq 0x37cd
testb %al, %al
je 0x3d58
movq 0x58(%r14), %rdi
callq 0x3a02
imull %ebx, %eax
movsd 0x48(%r14), %xmm0
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x48(%r14)
addl %ebx, 0x7c(%r14)
jmp 0x3e0a
leaq 0x536a(%rip), %rsi      # 0x90c9
movq %r15, %rdi
callq 0x37cd
testb %al, %al
je 0x3d94
movq 0x60(%r14), %rdi
callq 0x3a02
imull %ebx, %eax
movsd 0x48(%r14), %xmm0
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x48(%r14)
addl %ebx, 0x80(%r14)
jmp 0x3e0a
leaq 0x5336(%rip), %rsi      # 0x90d1
movq %r15, %rdi
callq 0x37cd
testb %al, %al
je 0x3dd0
movq 0x68(%r14), %rdi
callq 0x3a02
imull %ebx, %eax
movsd 0x48(%r14), %xmm0
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x48(%r14)
addl %ebx, 0x84(%r14)
jmp 0x3e0a
leaq 0x5303(%rip), %rsi      # 0x90da
movq %r15, %rdi
callq 0x37cd
testb %al, %al
je 0x3e1e
movq 0x70(%r14), %rdi
callq 0x3a02
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
xorl %eax, %eax
jmp 0x3e13
// File: /workspace/github_cpp_makefile_star2_O2/Oralf[P]Heros/Hero.cpp
// Function: Hero::PrintHero() const
void Hero:: PrintHero ()const{
	cout << heroName<< " " << heroType <<":"<< endl;
	cout << gold << " gold"<< endl;
	bool space=false;
	if(numOfCretures[blackDragon_e] !=0 ){
		cout << numOfCretures[blackDragon_e]<< " Black_Dragon";
		space=true;
	}
	if(numOfCretures[wizard_e] !=0 ){
		if( space){
			cout<<" ";
		}
		cout << numOfCretures[wizard_e]<< " Wizard";
		space=true;
	}
	if(numOfCretures[archer_e] !=0 ){
		if( space){
			cout<<" ";
		}
		space=true;
		cout << numOfCretures[archer_e]<< " Archer";
	}
	if(numOfCretures[vampire_e] !=0 ){
		if( space){
			cout<<" ";
		}
		space=true;
		cout << numOfCretures[vampire_e]<< " Vampire";
	}
	if(numOfCretures[zombie_e] !=0){
		if( space){
			cout<<" ";
		}
		space=true;
		cout << numOfCretures[zombie_e] << " Zombie";
	}
	if(space){
		cout << "." << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %rsi
movq 0x9165(%rip), %r14      # 0xcfc0
movq %r14, %rdi
callq 0x3180
leaq 0x5229(%rip), %rsi      # 0x9093
movq %rax, %rdi
callq 0x31a0
leaq 0x28(%rbx), %rsi
movq %rax, %rdi
callq 0x3180
leaq 0x55ec(%rip), %rsi      # 0x9471
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30f0
movsd 0x48(%rbx), %xmm0
movq %r14, %rdi
callq 0x32a0
leaq 0x5394(%rip), %rsi      # 0x923d
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30f0
movl 0x78(%rbx), %esi
testl %esi, %esi
je 0x3edf
movq 0x90f9(%rip), %rdi      # 0xcfc0
callq 0x32e0
leaq 0x51df(%rip), %rsi      # 0x90b2
movq %rax, %rdi
callq 0x31a0
movb $0x1, %al
jmp 0x3ee1
xorl %eax, %eax
movl 0x7c(%rbx), %esi
testl %esi, %esi
je 0x3f1f
testb %al, %al
je 0x3f02
movq 0x90cd(%rip), %rdi      # 0xcfc0
leaq 0x5199(%rip), %rsi      # 0x9093
callq 0x31a0
movl 0x7c(%rbx), %esi
movq 0x90b7(%rip), %rdi      # 0xcfc0
callq 0x32e0
leaq 0x51ab(%rip), %rsi      # 0x90c0
movq %rax, %rdi
callq 0x31a0
movb $0x1, %al
movl 0x80(%rbx), %esi
testl %esi, %esi
je 0x3f63
testb %al, %al
je 0x3f46
movq 0x908c(%rip), %rdi      # 0xcfc0
leaq 0x5158(%rip), %rsi      # 0x9093
callq 0x31a0
movl 0x80(%rbx), %esi
movq 0x9073(%rip), %rdi      # 0xcfc0
callq 0x32e0
leaq 0x516f(%rip), %rsi      # 0x90c8
movq %rax, %rdi
callq 0x31a0
movb $0x1, %al
movl 0x84(%rbx), %esi
testl %esi, %esi
je 0x3fa7
testb %al, %al
je 0x3f8a
movq 0x9048(%rip), %rdi      # 0xcfc0
leaq 0x5114(%rip), %rsi      # 0x9093
callq 0x31a0
movl 0x84(%rbx), %esi
movq 0x902f(%rip), %rdi      # 0xcfc0
callq 0x32e0
leaq 0x5133(%rip), %rsi      # 0x90d0
movq %rax, %rdi
callq 0x31a0
movb $0x1, %al
movl 0x88(%rbx), %esi
testl %esi, %esi
je 0x3feb
testb %al, %al
je 0x3fce
movq 0x9004(%rip), %rdi      # 0xcfc0
leaq 0x50d0(%rip), %rsi      # 0x9093
callq 0x31a0
movl 0x88(%rbx), %esi
movq 0x8feb(%rip), %rdi      # 0xcfc0
callq 0x32e0
leaq 0x50f8(%rip), %rsi      # 0x90d9
movq %rax, %rdi
callq 0x31a0
jmp 0x3fef
testb %al, %al
je 0x400e
movq 0x8fca(%rip), %rdi      # 0xcfc0
leaq 0x540f(%rip), %rsi      # 0x940c
callq 0x31a0
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x30f0
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4d7d(%rip), %xmm1     # 0x90a0
minsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
maxsd %xmm1, %xmm0
movsd %xmm0, 0x48(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Oralf[P]Heros/Hero.cpp
// Function: Hero::PrintWithoutGoldHero() const
void Hero:: PrintWithoutGoldHero ()const{
	cout << heroName<< " " << heroType <<":"<< endl;
	bool space=false;
	if(numOfCretures[blackDragon_e] !=0 ){
		cout << numOfCretures[blackDragon_e]<< " Black_Dragon";
		space=true;
	}
	if(numOfCretures[wizard_e] !=0 ){
		if( space){
			cout<<" ";
		}
		cout << numOfCretures[wizard_e]<< " Wizard";
		space=true;
	}
	if(numOfCretures[archer_e] !=0 ){
		if( space){
			cout<<" ";
		}
		space=true;
		cout << numOfCretures[archer_e]<< " Archer";
	}
	if(numOfCretures[vampire_e] !=0 ){
		if( space){
			cout<<" ";
		}
		space=true;
		cout << numOfCretures[vampire_e]<< " Vampire";
	}
	if(numOfCretures[zombie_e] !=0){
		if( space){
			cout<<" ";
		}
		space=true;
		cout << numOfCretures[zombie_e] << " Zombie";
	}
	if(space){
		cout << "." << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %rsi
movq 0x8c76(%rip), %rdi      # 0xcfc0
callq 0x3180
leaq 0x4d3d(%rip), %rsi      # 0x9093
movq %rax, %rdi
callq 0x31a0
leaq 0x28(%rbx), %rsi
movq %rax, %rdi
callq 0x3180
leaq 0x5100(%rip), %rsi      # 0x9471
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30f0
movl 0x78(%rbx), %esi
testl %esi, %esi
je 0x43a7
movq 0x8c31(%rip), %rdi      # 0xcfc0
callq 0x32e0
leaq 0x4d17(%rip), %rsi      # 0x90b2
movq %rax, %rdi
callq 0x31a0
movb $0x1, %al
jmp 0x43a9
xorl %eax, %eax
movl 0x7c(%rbx), %esi
testl %esi, %esi
je 0x43e7
testb %al, %al
je 0x43ca
movq 0x8c05(%rip), %rdi      # 0xcfc0
leaq 0x4cd1(%rip), %rsi      # 0x9093
callq 0x31a0
movl 0x7c(%rbx), %esi
movq 0x8bef(%rip), %rdi      # 0xcfc0
callq 0x32e0
leaq 0x4ce3(%rip), %rsi      # 0x90c0
movq %rax, %rdi
callq 0x31a0
movb $0x1, %al
movl 0x80(%rbx), %esi
testl %esi, %esi
je 0x442b
testb %al, %al
je 0x440e
movq 0x8bc4(%rip), %rdi      # 0xcfc0
leaq 0x4c90(%rip), %rsi      # 0x9093
callq 0x31a0
movl 0x80(%rbx), %esi
movq 0x8bab(%rip), %rdi      # 0xcfc0
callq 0x32e0
leaq 0x4ca7(%rip), %rsi      # 0x90c8
movq %rax, %rdi
callq 0x31a0
movb $0x1, %al
movl 0x84(%rbx), %esi
testl %esi, %esi
je 0x446f
testb %al, %al
je 0x4452
movq 0x8b80(%rip), %rdi      # 0xcfc0
leaq 0x4c4c(%rip), %rsi      # 0x9093
callq 0x31a0
movl 0x84(%rbx), %esi
movq 0x8b67(%rip), %rdi      # 0xcfc0
callq 0x32e0
leaq 0x4c6b(%rip), %rsi      # 0x90d0
movq %rax, %rdi
callq 0x31a0
movb $0x1, %al
movl 0x88(%rbx), %esi
testl %esi, %esi
je 0x44b3
testb %al, %al
je 0x4496
movq 0x8b3c(%rip), %rdi      # 0xcfc0
leaq 0x4c08(%rip), %rsi      # 0x9093
callq 0x31a0
movl 0x88(%rbx), %esi
movq 0x8b23(%rip), %rdi      # 0xcfc0
callq 0x32e0
leaq 0x4c30(%rip), %rsi      # 0x90d9
movq %rax, %rdi
callq 0x31a0
jmp 0x44b7
testb %al, %al
je 0x44d8
movq 0x8b02(%rip), %rdi      # 0xcfc0
leaq 0x4f47(%rip), %rsi      # 0x940c
callq 0x31a0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x30f0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4bbf(%rip), %rsi      # 0x90b3
movq %r14, %rdi
callq 0x37cd
testb %al, %al
je 0x4505
movl 0x78(%rbx), %eax
jmp 0x4570
leaq 0x4bb5(%rip), %rsi      # 0x90c1
movq %r14, %rdi
callq 0x37cd
testb %al, %al
je 0x451d
movl 0x7c(%rbx), %eax
jmp 0x4570
leaq 0x4ba5(%rip), %rsi      # 0x90c9
movq %r14, %rdi
callq 0x37cd
testb %al, %al
je 0x4538
movl 0x80(%rbx), %eax
jmp 0x4570
leaq 0x4b92(%rip), %rsi      # 0x90d1
movq %r14, %rdi
callq 0x37cd
testb %al, %al
je 0x4553
movl 0x84(%rbx), %eax
jmp 0x4570
leaq 0x4b80(%rip), %rsi      # 0x90da
movq %r14, %rdi
callq 0x37cd
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0x4570
movl 0x88(%rbx), %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3a14
leaq 0x523d(%rip), %rax      # 0xcc18
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x3110
leaq 0x28(%rbx), %rdi
leaq 0x18d2(%rip), %rsi      # 0x92c7
callq 0x3350
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 0x3c7c
movq %r14, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3a14
leaq 0x510d(%rip), %rax      # 0xcc58
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x3110
leaq 0x28(%rbx), %rdi
leaq 0x175b(%rip), %rsi      # 0x92c0
callq 0x3350
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 0x3c7c
movq %r14, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7c28
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x4306
movsd 0x14ba(%rip), %xmm1     # 0x90a0
subsd 0x48(%rbx), %xmm1
minsd 0x18bd(%rip), %xmm1     # 0x94b0
movapd %xmm0, %xmm2
minsd %xmm1, %xmm2
movapd %xmm2, -0x20(%rbp)
movapd 0x18b8(%rip), %xmm0     # 0x94c0
xorpd %xmm2, %xmm0
movq %r14, %rdi
callq 0x4312
movq %rbx, %rdi
movaps -0x20(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x4312
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %r15d
imull 0x8(%rdi), %r15d
xorl %r12d, %r12d
leal (%rbx,%r12), %eax
testl %eax, %eax
jle 0x7ce4
movq %r14, %rdi
callq 0x39f8
cmpl %eax, %r15d
jl 0x7ce4
movq %r14, %rdi
callq 0x39f8
subl %eax, %r15d
decl %r12d
jmp 0x7cbf
negl %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3a14
leaq 0x4f11(%rip), %rax      # 0xcce0
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x3110
leaq 0x28(%rbx), %rdi
leaq 0x14ce(%rip), %rsi      # 0x92b7
callq 0x3350
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 0x3c7c
movq %r14, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O2/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), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq *0x18(%rax)
leaq 0x1100(%rip), %rsi      # 0x90c9
movq %r12, %rdi
callq 0x37cd
movl %eax, %r13d
movq %r12, %rdi
callq 0x30d0
movl %r13d, %ecx
shll %cl, %r15d
xorl %r12d, %r12d
leal (%rbx,%r12), %eax
testl %eax, %eax
jle 0x800a
movq %r14, %rdi
callq 0x39f8
cmpl %eax, %r15d
jl 0x800a
movq %r14, %rdi
callq 0x39f8
subl %eax, %r15d
decl %r12d
jmp 0x7fe5
negl %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_O2/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 0x36d4
pushq %rbp
movq %rsp, %rbp
movq %rdx, %rcx
movl $0x15b0, %r8d           # imm = 0x15B0
movq %rdx, %rax
xorl %edx, %edx
divq %r8
movq %rdx, %r8
movq %rdi, %r10
shrq $0x10, %r10
movzwl %di, %r9d
movl $0xfff1, %edi           # imm = 0xFFF1
testq %rcx, %rcx
je 0x36ca
xorl %r11d, %r11d
leal 0x7(%r11), %eax
cmpl %r8d, %eax
jae 0x36a0
movzbl (%rsi,%r11), %eax
addl %eax, %r9d
addl %r9d, %r10d
movzbl 0x1(%rsi,%r11), %eax
addl %r9d, %eax
addl %eax, %r10d
movzbl 0x2(%rsi,%r11), %edx
addl %eax, %edx
addl %edx, %r10d
movzbl 0x3(%rsi,%r11), %eax
addl %edx, %eax
addl %eax, %r10d
movzbl 0x4(%rsi,%r11), %edx
addl %eax, %edx
addl %edx, %r10d
movzbl 0x5(%rsi,%r11), %eax
addl %edx, %eax
addl %eax, %r10d
movzbl 0x6(%rsi,%r11), %edx
addl %eax, %edx
addl %edx, %r10d
movzbl 0x7(%rsi,%r11), %r9d
addl %edx, %r9d
addl %r9d, %r10d
addq $0x8, %r11
jmp 0x3629
movzbl (%rsi,%r11), %eax
addl %eax, %r9d
addl %r9d, %r10d
incq %r11
cmpl %r8d, %r11d
jb 0x3692
movl %r9d, %eax
xorl %edx, %edx
divl %edi
movl %edx, %r9d
movl %r10d, %eax
xorl %edx, %edx
divl %edi
subq %r8, %rcx
addq %r11, %rsi
movl $0x15b0, %r8d           # imm = 0x15B0
movl %edx, %r10d
jmp 0x361d
shll $0x10, %r10d
orl %r9d, %r10d
popq %rbp
jmp 0x36de
movabsq $0x1, %r10
movq %r10, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x38b4
testq %rbx, %rbx
je 0x389a
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 0x389e
cmpl $0xf, %r12d
je 0x3825
cmpl $-0xf, %r12d
jne 0x389e
andl $0x0, 0x58(%rbx)
movq $0x1, 0x60(%rbx)
andq $0x0, 0x68(%rbx)
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movq 0x40(%rbx), %rax
testq %rax, %rax
jne 0x3856
leaq -0xe7(%rip), %rax       # 0x376b
movq %rax, 0x40(%rbx)
cmpq $0x0, 0x48(%rbx)
jne 0x3868
leaq -0xe8(%rip), %rcx       # 0x377c
movq %rcx, 0x48(%rbx)
movq 0x50(%rbx), %rdi
pushq $0x1
popq %rsi
movl $0x4df78, %edx          # imm = 0x4DF78
callq *%rax
testq %rax, %rax
je 0x38b0
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 0x3932
jmp 0x389e
pushq $-0x2
popq %r15
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x4
jmp 0x389c
// File: /workspace/github_cpp_makefile_star2_O2/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 0x11c2c(%rip), %rax     # 0x15500
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 0x3916
decl %edx
cmpl $0x3, %edx
ja 0x3930
leaq 0x1170a(%rip), %rcx     # 0x15010
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
orl $0x20000, %eax          # imm = 0x20000
jmp 0x3930
orl $0x80000, %eax          # imm = 0x80000
jmp 0x3930
orl $0x10000, %eax          # imm = 0x10000
jmp 0x3930
orl $0x40000, %eax          # imm = 0x40000
jmp 0x3930
andl $0xfffff000, %eax       # imm = 0xFFFFF000
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3a78
movq %rdi, %r14
movq 0x38(%rdi), %rsi
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x3a7b
movq 0x50(%r14), %rdi
callq *0x48(%r14)
andq $0x0, 0x38(%r14)
jmp 0x3a7b
pushq $-0x2
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jimmiebergmann[P]fbx-file/miniz.c
// Function: mz_deflateReset
int mz_deflateReset(mz_streamp pStream)
{
    if ((!pStream) || (!pStream->state) || (!pStream->zalloc) || (!pStream->zfree))
        return MZ_STREAM_ERROR;
    pStream->total_in = pStream->total_out = 0;
    tdefl_init((tdefl_compressor *)pStream->state, NULL, NULL, ((tdefl_compressor *)pStream->state)->m_flags);
    return MZ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
pushq $-0x2
popq %rbx
testq %rdi, %rdi
je 0x3ac2
movq %rdi, %rax
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x3ac2
cmpq $0x0, 0x40(%rax)
je 0x3ac2
cmpq $0x0, 0x48(%rax)
je 0x3ac2
andq $0x0, 0x28(%rax)
andq $0x0, 0x10(%rax)
movl 0x10(%rdi), %ecx
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
callq 0x3932
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, -0x20(%rbp)
movq (%rsi), %rsi
movq %rsi, %rax
orq %rcx, %rax
shrq $0x20, %rax
movl $0xffffd8f0, %r14d      # imm = 0xFFFFD8F0
jne 0x4f55
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
callq 0x37aa
movl %eax, %r14d
testl %eax, %eax
jne 0x4f55
leaq -0x88(%rbp), %rdi
pushq $0x4
popq %rsi
callq 0x3acb
cmpl $0x1, %eax
jne 0x4f37
movq -0x60(%rbp), %rax
movq %rax, (%rbx)
movq -0x50(%rbp), %rsi
xorl %r14d, %r14d
testq %rsi, %rsi
je 0x4f55
movq -0x38(%rbp), %rdi
callq *-0x40(%rbp)
jmp 0x4f55
movl %eax, %r15d
movq -0x50(%rbp), %rsi
testq %rsi, %rsi
je 0x4f4a
movq -0x38(%rbp), %rdi
callq *-0x40(%rbp)
testl %r15d, %r15d
pushq $-0x5
popq %r14
cmovnel %r15d, %r14d
movl %r14d, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x505d
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
cmpl $0xf, %esi
je 0x4fdf
movl $0xffffd8f0, %eax       # imm = 0xFFFFD8F0
cmpl $-0xf, %ebx
jne 0x5064
andl $0x0, 0x58(%r14)
andq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x60(%r14)
movq 0x40(%r14), %rax
testq %rax, %rax
jne 0x500a
leaq -0x189b(%rip), %rax     # 0x376b
movq %rax, 0x40(%r14)
cmpq $0x0, 0x48(%r14)
jne 0x501c
leaq -0x189c(%rip), %rcx     # 0x377c
movq %rcx, 0x48(%r14)
movq 0x50(%r14), %rdi
pushq $0x1
popq %rsi
movl $0xab10, %edx           # imm = 0xAB10
callq *%rax
testq %rax, %rax
je 0x5061
movq %rax, 0x38(%r14)
andl $0x0, (%rax)
andq $0x0, 0x2af8(%rax)
movl $0x1, 0xab0c(%rax)
movq $0x1, 0x2b00(%rax)
movl %ebx, 0x2b08(%rax)
xorl %eax, %eax
jmp 0x5064
pushq $-0x2
popq %rax
retq
pushq $-0x4
popq %rax
popq %rbx
popq %r14
popq %rbp
retq