LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::moveRight()
void Hero :: moveRight() {
  int heroY = this->getPosition().getY();
  int heroX = this->getPosition().getX();

  if (heroX == grid->getMaxX()) {
    throw HeroMoveException("You can't move right any further");    
  } else if (this->grid->getTile(heroY, heroX + 1).isNonAccessible()) {
    throw HeroMoveException("You can't move in a non accessible tile");
  } else {
    this->grid->removeLiving(heroY, heroX, this);
    this->getPosition().setX(heroX + 1);
    this->grid->addLiving(heroY, heroX + 1, this);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x187a8
movq %rax, %rdi
callq 0x187ba
movl %eax, %ebp
movq %rbx, %rdi
callq 0x187a8
movq %rax, %rdi
callq 0x187b6
movl %eax, %r15d
movq 0x8(%rbx), %rdi
callq 0x67f0
cmpl %eax, %r15d
je 0x145d2
movq 0x8(%rbx), %rdi
leal 0x1(%r15), %r14d
movl %ebp, %esi
movl %r14d, %edx
callq 0x687e
movq %rax, %rdi
callq 0x6682
testb %al, %al
jne 0x1462a
movq 0x8(%rbx), %rdi
movl %ebp, %esi
movl %r15d, %edx
movq %rbx, %rcx
callq 0x6948
movq %rbx, %rdi
callq 0x187a8
movq %rax, %rdi
movl %r14d, %esi
callq 0x187be
movq 0x8(%rbx), %rdi
movl %ebp, %esi
movl %r14d, %edx
movq %rbx, %rcx
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x689a
movl $0x28, %edi
callq 0x4130
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7894(%rip), %rsi      # 0x1be83
leaq 0x78ad(%rip), %rdx      # 0x1bea3
leaq 0x8(%rsp), %rdi
callq 0x654a
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4c58
xorl %ebp, %ebp
leaq 0x1001f(%rip), %rsi     # 0x24638
leaq -0xf97e(%rip), %rdx     # 0x4ca2
movq %rbx, %rdi
callq 0x4410
jmp 0x14680
movl $0x28, %edi
callq 0x4130
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x77d8(%rip), %rsi      # 0x1be1f
leaq 0x77f8(%rip), %rdx      # 0x1be46
leaq 0x8(%rsp), %rdi
callq 0x654a
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4c58
xorl %ebp, %ebp
leaq 0xffc7(%rip), %rsi      # 0x24638
leaq -0xf9d6(%rip), %rdx     # 0x4ca2
movq %rbx, %rdi
callq 0x4410
jmp 0x14684
jmp 0x146a5
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1469e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
testb %bpl, %bpl
jne 0x146a8
jmp 0x146b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O3/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::move(Hero::directions)
void Hero :: move(directions direction) {
  switch (direction) {
  case UP: moveUp(); break;
  case DOWN: moveDown(); break;
  case LEFT: moveLeft(); break;
  case RIGHT: moveRight(); break;
  default: throw HeroMoveException("Unknown direction"); break; 
  }   
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x3, %esi
ja 0x14715
movl %esi, %eax
leaq 0x7690(%rip), %rcx      # 0x1bd60
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x140b8
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x143ba
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x14534
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1423e
movl $0x28, %edi
callq 0x4130
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7772(%rip), %rsi      # 0x1bea4
leaq 0x777c(%rip), %rdx      # 0x1beb5
leaq 0x8(%rsp), %rdi
callq 0x654a
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4c58
xorl %ebp, %ebp
leaq 0xfedc(%rip), %rsi      # 0x24638
leaq -0xfac1(%rip), %rdx     # 0x4ca2
movq %rbx, %rdi
callq 0x4410
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x14785
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
testb %bpl, %bpl
jne 0x1478f
jmp 0x14797
movq %rax, %r14
movq %rbx, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O3/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::getUserInput(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string Hero :: getUserInput(const string& prompt) {
  cout << prompt << endl << endl << "> ";

  string input;
  getline(cin, input);  

  return input;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
movq 0x1080a(%rip), %rdi     # 0x24fc0
callq 0x42f0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41b0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41b0
leaq 0x6856(%rip), %rsi      # 0x1b06c
movl $0x2, %edx
movq %rax, %rdi
callq 0x42f0
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq 0x10793(%rip), %rdi     # 0x24fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %edx
movq 0x10778(%rip), %rdi     # 0x24fd0
movq %rbx, %rsi
callq 0x4460
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1487f
movq (%r15), %rsi
incq %rsi
callq 0x42a0
movq %r14, %rdi
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O3/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::discard(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Hero :: discard(const string& name) {
  Item* itemToDiscard = inventory.getItemByName(name);

  if (itemToDiscard != NULL) {
    this->inventory.removeAndDeleteItem(itemToDiscard);
    return true;
  }

  Spell* spellToDiscard = inventory.getSpellByName(name);

  if (spellToDiscard != NULL) {
    this->inventory.removeAndDeleteSpell(spellToDiscard);
    return true;
  }

  cout << endl << "There's no such item or spell in your inventory" << endl;
  return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0xc0, %rbx
movq %rbx, %rdi
callq 0xed62
testq %rax, %rax
je 0x14d83
movq %rbx, %rdi
movq %rax, %rsi
callq 0xeb84
jmp 0x14d9e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xee00
testq %rax, %rax
je 0x14da8
movq %rbx, %rdi
movq %rax, %rsi
callq 0xec02
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x10211(%rip), %rbx     # 0x24fc0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41b0
movq %rax, %rbx
leaq 0x70ef(%rip), %rsi      # 0x1becf
movl $0x2f, %edx
movq %rax, %rdi
callq 0x42f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41b0
xorl %eax, %eax
jmp 0x14da0
// File: /workspace/github_cpp_makefile_star2_O3/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::use(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Hero::use(const string& potionName) {
  Potion* potionToUse = static_cast<Potion*>(inventory.getItemByName(potionName));
  if (potionToUse  == NULL) {
    cout << endl << "This potion doesn't exist" << endl;
    return false;
  } else if (potionToUse->kindOf() != "Potion") {
    cout << endl << "The item you selected isn't a Potion" << endl;
    return true;
  }
  potions.push_back(potionToUse);
  inventory.removeItem(potionToUse);
  this->strength *= potionToUse->getStrengthBoost() + 1.0;
  this->agility *= potionToUse->getAgilityBoost() + 1.0;
  this->dexterity *= potionToUse->getDexterityBoost() + 1.0;
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0xc0(%rdi), %r15
movq %r15, %rdi
callq 0xed62
movq %rax, %rbx
testq %rax, %rax
je 0x14ec4
movq (%rbx), %rax
movq %rsp, %r12
movq %r12, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
leaq 0x70df(%rip), %rsi      # 0x1bf37
movq %r12, %rdi
callq 0x40d0
movl %eax, %ebp
movq (%r12), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x14e7d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
testl %ebp, %ebp
je 0x14f35
movq 0x10134(%rip), %r14     # 0x24fc0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41b0
movq %rax, %r14
leaq 0x705c(%rip), %rsi      # 0x1bf19
movl $0x24, %edx
jmp 0x14f01
movq 0x100f5(%rip), %r14     # 0x24fc0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41b0
movq %rax, %r14
leaq 0x7003(%rip), %rsi      # 0x1beff
movl $0x19, %edx
movq %rax, %rdi
callq 0x42f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41b0
jmp 0x14fd9
leaq 0x78(%r14), %r12
movl $0x18, %edi
callq 0x4290
movq %rbx, 0x10(%rax)
movq %rax, %rdi
movq %r12, %rsi
callq 0x4050
incq 0x88(%r14)
movq %r15, %rdi
movq %rbx, %rsi
callq 0xec80
movq %rbx, %rdi
callq 0x1a2b0
addsd 0x6ddc(%rip), %xmm0     # 0x1bd50
cvtsi2sdl 0x98(%r14), %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, 0x98(%r14)
movq %rbx, %rdi
callq 0x1a2a4
addsd 0x6db4(%rip), %xmm0     # 0x1bd50
mulsd 0xa0(%r14), %xmm0
movsd %xmm0, 0xa0(%r14)
movq %rbx, %rdi
callq 0x1a2aa
addsd 0x6d92(%rip), %xmm0     # 0x1bd50
xorps %xmm1, %xmm1
cvtsi2sdl 0xa8(%r14), %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, 0xa8(%r14)
testq %rbx, %rbx
setne %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::sell(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Hero::sell(const string& itemName) {
    Item* itemToSell = inventory.getItemByName(itemName);

	if (itemToSell != NULL) {
	  cout << endl << "Sold " << itemName
	       << " (" << itemToSell->kindOf() << ")";
		inventory.removeAndDeleteItem(itemToSell);
		setMoney(getMoney() + itemToSell->sellsFor());
		return;
	}

	Spell* spellToSell = inventory.getSpellByName(itemName);
	if (spellToSell != NULL) {
	  cout << endl << "Sold " << itemName
	       << " (" << itemToSell->kindOf() << ")";
	  
		inventory.removeAndDeleteSpell(spellToSell);
		setMoney(getMoney() + spellToSell->getValue()/2);
		return;
	}

	cout << endl << "There's no item/spell with this name" << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xc0(%rdi), %r14
movq %r14, %rdi
callq 0xed62
testq %rax, %rax
je 0x15c2f
movq %rax, %r15
movq 0xf478(%rip), %r13      # 0x24fc0
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %r13, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41b0
movq %rax, %r13
leaq 0x6549(%rip), %rsi      # 0x1c0c3
movl $0x5, %edx
movq %rax, %rdi
callq 0x42f0
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r13, %rdi
callq 0x42f0
movq %rax, %r12
leaq 0x64f9(%rip), %rsi      # 0x1c09b
movl $0x2, %edx
movq %rax, %rdi
callq 0x42f0
movq (%r15), %rax
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq *0x18(%rax)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r12, %rdi
callq 0x42f0
leaq 0x59f4(%rip), %rsi      # 0x1b5cb
movl $0x1, %edx
movq %rax, %rdi
callq 0x42f0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15bff
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %r14, %rdi
movq %r15, %rsi
callq 0xeb84
movl 0xac(%rbx), %ebp
movq %r15, %rdi
callq 0x1a7fc
addl %ebp, %eax
movl %eax, 0xac(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %r12, %rsi
callq 0xee00
testq %rax, %rax
jne 0x15cb9
movq 0xf37a(%rip), %rbx      # 0x24fc0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41b0
movq %rax, %rbx
leaq 0x6427(%rip), %rsi      # 0x1c09e
movl $0x24, %edx
movq %rax, %rdi
callq 0x42f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x41b0
movq %r12, %rdi
callq 0x461d
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15cdf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O3/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::getSpellByName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Spell* Hero :: getSpellByName(const string& name) {
  list<Spell*> :: const_iterator it = spells.begin();
  for ( ; it != spells.end(); ++it) {
    if ((*it)->getName() == name) {
      return *it;
    }
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x60(%rdi), %r12
addq $0x60, %r15
cmpq %r15, %r12
je 0x1611a
movq %rsi, %r14
xorl %ebx, %ebx
movq 0x10(%r12), %rdi
callq 0x13128
movq 0x8(%rax), %rdx
cmpq 0x8(%r14), %rdx
jne 0x1610f
testq %rdx, %rdx
je 0x1611e
movq (%r14), %rsi
movq (%rax), %rdi
callq 0x42b0
testl %eax, %eax
je 0x1611e
movq (%r12), %r12
cmpq %r15, %r12
jne 0x160e7
jmp 0x16123
xorl %ebx, %ebx
jmp 0x16123
movq 0x10(%r12), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::printEquipedSpells()
void Hero :: printEquipedSpells() {
  if (spells.empty()) {    
    return;
  } else {
    list<Spell*> :: const_iterator it = spells.begin();
    vector<IceSpell*> iceSpells;
    vector<FireSpell*> fireSpells;
    vector<LightningSpell*> lightningSpells;
    for ( ; it != spells.end(); ++it) {
      string kind = (*it)->kindOf();
      if (kind == "IceSpell") {
	iceSpells.push_back(static_cast<IceSpell*>(*it));
      } else if (kind == "FireSpell") {
	fireSpells.push_back(static_cast<FireSpell*>(*it));        
      } else if (kind == "LightningSpell") {
	lightningSpells.push_back(static_cast<LightningSpell*>(*it));
      }
    }
    printIceSpells(iceSpells);
    printFireSpells(fireSpells);
    printLightningSpells(lightningSpells);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %r15
addq $0x60, %rbx
cmpq %rbx, %r15
je 0x166ac
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %rcx
movaps %xmm0, (%rcx)
xorl %eax, %eax
movq %rax, 0x10(%rcx)
leaq 0x30(%rsp), %rcx
movq %rax, 0x10(%rcx)
movaps %xmm0, (%rcx)
leaq 0x10(%rsp), %rcx
movq %rax, 0x10(%rcx)
movaps %xmm0, (%rcx)
leaq 0x78(%rsp), %r14
leaq 0x68(%rsp), %r13
leaq 0x56a9(%rip), %rbp      # 0x1bc42
leaq 0x8(%rsp), %r12
movq 0x10(%r15), %rsi
movq (%rsi), %rax
movq %r13, %rdi
callq *0x18(%rax)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x40d0
testl %eax, %eax
je 0x165f8
movq %r13, %rdi
leaq 0x5687(%rip), %rsi      # 0x1bc4b
callq 0x40d0
testl %eax, %eax
je 0x16610
movq %r13, %rdi
leaq 0x567e(%rip), %rsi      # 0x1bc55
callq 0x40d0
testl %eax, %eax
jne 0x16626
movq 0x10(%r15), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0xfb7e
jmp 0x16626
movq 0x10(%r15), %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
movq %r12, %rsi
callq 0xf896
jmp 0x16626
movq 0x10(%r15), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
movq %r12, %rsi
callq 0xfa0a
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x1663d
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x42a0
movq (%r15), %r15
cmpq %rbx, %r15
jne 0x1659e
leaq 0x50(%rsp), %rsi
callq 0x17c62
leaq 0x30(%rsp), %rsi
callq 0x177a0
leaq 0x10(%rsp), %rsi
callq 0x18124
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1667e
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x42a0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x16695
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x42a0
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x166ac
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x42a0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x166e0
jmp 0x166c4
jmp 0x166c4
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x166e3
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x166e3
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x166fa
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x42a0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x16711
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x42a0
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x16728
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O3/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::attack(Monster*)
void Hero::attack(Monster* monster) {
	Random random;

	if (random.boolean(monster->getDodge())) {
	  cout << endl << "Monster Dodged your attack sucker!" << endl;
	} else {
		int heroDamage = 0;
		// Calculate the damage that the Hero can cause.
		heroDamage += strength;

		if (leftHandWeapon != NULL) {
			heroDamage += leftHandWeapon->getDamage();
		}

		if (rightHandWeapon != NULL) {
			heroDamage += rightHandWeapon->getDamage();
		}

		// Calculate the damage reduction.
		int damageReduction = 0;

		damageReduction += monster->getDamageReductionFactor()*heroDamage;

		monster->receiveDamage(heroDamage - damageReduction);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xf(%rsp), %rdi
xorl %esi, %esi
callq 0x4d88
movq %rbx, %rdi
callq 0x188e2
callq 0x4dbc
testb %al, %al
je 0x167c9
movq 0xe85e(%rip), %rbx      # 0x24fc0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41b0
movq %rax, %rbx
leaq 0x5aa4(%rip), %rsi      # 0x1c237
movl $0x22, %edx
movq %rax, %rdi
callq 0x42f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41b0
jmp 0x16819
movl 0x98(%r14), %ebp
movq 0x48(%r14), %rdi
testq %rdi, %rdi
je 0x167e0
callq 0x199c8
addl %eax, %ebp
movq 0x50(%r14), %rdi
testq %rdi, %rdi
je 0x167f0
callq 0x199c8
addl %eax, %ebp
movq %rbx, %rdi
callq 0x188dc
cvtsi2sd %ebp, %xmm1
mulsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
subl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
movl %ebp, %esi
callq *0x10(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::battle(std::__cxx11::list<Monster*, std::allocator<Monster*>>&)
void Hero :: battle(list<Monster*>& monsters) {
  int selection;
  battleMenu.displayMenu();
  while ((selection = battleMenu.getSelection())) {
    battleMenu.clearMenu();
    switch (selection) {
    case 1: {
      printStats();
      break;
    }
    case 2: {
      printMonsters(monsters);
      handleAttackCase(monsters);
      return;
    }
    case 3: {
      printMonsters(monsters);
      if (handleCastSpellCase(monsters)) return;      
      break;
    }
    case 4: {
      if (handleUseCase()) return;
      break;
    }
    case 5: {
      if (handleEquipCase()) return;
      break;
    }
    case 6: {
      handleQuitCase();
      if (quitGame) return;
      battleMenu.clearMenu();
      break;
    }             
    }    
    battleMenu.displayMenu();
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x118(%rdi), %r15
movq %r15, %rdi
callq 0x4e40
movq %r15, %rdi
callq 0x4ff8
testl %eax, %eax
je 0x168ea
movl %eax, %r12d
leaq 0x5536(%rip), %r13      # 0x1bd9c
leaq 0xe9fc(%rip), %rbp      # 0x25269
movq %r15, %rdi
callq 0x4f7c
decl %r12d
cmpl $0x5, %r12d
ja 0x168d3
movslq (%r13,%r12,4), %rax
addq %r13, %rax
jmpq *%rax
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
jmp 0x168d3
movq %r14, %rdi
callq 0x1759c
jmp 0x168ba
movq %rbx, %rsi
callq 0x1691a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x16f5a
jmp 0x168ba
movq %r14, %rdi
callq 0x1735a
testb %al, %al
je 0x168d3
jmp 0x168ea
callq 0x8c64
cmpb $0x0, (%rbp)
jne 0x168ea
movq %r15, %rdi
callq 0x4f7c
movq %r15, %rdi
callq 0x4e40
movq %r15, %rdi
callq 0x4ff8
movl %eax, %r12d
testl %eax, %eax
jne 0x1686d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rsi
callq 0x1691a
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x16ba6
// File: /workspace/github_cpp_makefile_star2_O3/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::handleEquipCase()
bool Hero :: handleEquipCase() {
  if (!this->getInventory().hasItems()) {
    cout << endl << "You have no items in your Inventory." << endl;
    return false;
  }
  string name;
  do {
    clearScreen();
    inventory.printInfo();
    cout << endl
	 << "Please enter the name of the weapon/armor you want to equip"
	 << endl << endl << "> ";
    getline(cin, name);    
  } while (equip(name) == false);
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0xc0(%rdi), %r15
movq %r15, %rdi
callq 0xca6a
movl %eax, %ebp
testb %al, %al
je 0x176fc
movb %bpl, 0x7(%rsp)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0xd9da(%rip), %r12      # 0x24fc0
movq 0xd9e3(%rip), %rbx      # 0x24fd0
leaq 0x8(%rsp), %r13
callq 0x8e5f
movq %r15, %rdi
callq 0xea6a
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %r12, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41b0
movq %rax, %rbp
movl $0x3b, %edx
movq %rax, %rdi
leaq 0x4d30(%rip), %rsi      # 0x1c369
callq 0x42f0
movq (%rbp), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %rbp, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41b0
movq %rax, %rbp
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %rbp, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41b0
movl $0x2, %edx
movq %rax, %rdi
leaq 0x39cd(%rip), %rsi      # 0x1b06c
callq 0x42f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4460
movq %r14, %rdi
movq %r13, %rsi
callq 0x14888
testb %al, %al
je 0x175f2
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x176f5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movb 0x7(%rsp), %bpl
jmp 0x17768
movq 0xd8bd(%rip), %rbx      # 0x24fc0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41b0
movq %rax, %rbx
leaq 0x4c10(%rip), %rsi      # 0x1c344
movl $0x24, %edx
movq %rax, %rdi
callq 0x42f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41b0
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x17798
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O3/arisKoutsou[P]oopproj/./src/livings/Monster.cpp
// Function: Monster::attack(Hero*)
void Monster::attack(Hero* hero) {
  Random random;

  if (random.boolean(hero->getAgility())) {
  } else {
    int monsterDamage = 0;
    // Calculate the damage that the Monster can cause.
    monsterDamage += random.fromMintoMax(this->minDamage, this->maxDamage);

    // Calculate the damage reduction.
    int damageReduction = 0;

    damageReduction += hero->getDamageReductionFactor()*monsterDamage;

    hero->receiveDamage(monsterDamage - damageReduction);
  }

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xf(%rsp), %rdi
xorl %esi, %esi
callq 0x4d88
movq %rbx, %rdi
callq 0x134d8
callq 0x4dbc
testb %al, %al
jne 0x18d7d
movl 0x44(%r14), %edi
movl 0x48(%r14), %esi
callq 0x4df6
movl %eax, %ebp
movq %rbx, %rdi
callq 0x13512
cvtsi2sd %ebp, %xmm1
mulsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
subl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
movl %ebp, %esi
callq *0x10(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/arisKoutsou[P]oopproj/./src/livings/Monster.cpp
// Function: Monster::applyNerf(int, double, Monster::Type)
void Monster :: applyNerf(int duration, double amount, Type nerfType) {
  Nerf newNerf(duration, amount, nerfType);
  nerfs.push_back(newNerf);
  switch (nerfType) {
  case ICE: {
    minDamage *= 1.0 - amount;
    maxDamage *= 1.0 - amount;
    break;  
  }
  case FIRE: {
    damageReductionFactor -= amount;
    damageReductionFactor = (damageReductionFactor < 0.0) ? 0.0 : damageReductionFactor;
    break;    
  }
  case LIGHT: {
    dodge -= amount;
    dodge = (dodge < 0.0) ? 0.0 : dodge;
    break;
  }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movsd %xmm0, (%rsp)
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x60(%rdi), %r15
movl $0x28, %edi
callq 0x4290
movl %r14d, 0x10(%rax)
movsd (%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
movl %ebp, 0x20(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x4050
incq 0x70(%rbx)
testl %ebp, %ebp
je 0x18e14
cmpl $0x2, %ebp
je 0x18dfb
cmpl $0x1, %ebp
jne 0x18e2b
movsd 0x2f72(%rip), %xmm0     # 0x1bd50
subsd (%rsp), %xmm0
cvtdq2pd 0x44(%rbx), %xmm1
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm1, %xmm0
cvttpd2dq %xmm0, %xmm0
movlpd %xmm0, 0x44(%rbx)
jmp 0x18e2b
movsd 0x58(%rbx), %xmm0
subsd (%rsp), %xmm0
xorpd %xmm1, %xmm1
maxsd %xmm0, %xmm1
movsd %xmm1, 0x58(%rbx)
jmp 0x18e2b
movsd 0x50(%rbx), %xmm0
subsd (%rsp), %xmm0
xorpd %xmm1, %xmm1
maxsd %xmm0, %xmm1
movsd %xmm1, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/arisKoutsou[P]oopproj/./src/livings/Monster.cpp
// Function: Monster::updateNerfs()
void Monster :: updateNerfs() {
  list<Nerf> :: iterator it = nerfs.begin();
  for ( ; it != nerfs.end(); ++it) {
    (*it).roundPassed();
    if ((*it).getDuration() == -1) {
      switch ((*it).getNerfType()) {
      case ICE: {
	minDamage /= 1.0 - (*it).getNerfAmount();
	maxDamage /= 1.0 - (*it).getNerfAmount();
	break;
      }
      case FIRE: {
        damageReductionFactor += (*it).getNerfAmount();
	break;
      }
      case LIGHT: {
	dodge += (*it).getNerfAmount();
	break;
      }
      }
      list<Nerf> :: iterator tmp = it++;
      nerfs.erase(tmp);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x60(%rdi), %r15
movq 0x60(%rdi), %r14
cmpq %r15, %r14
je 0x18ede
movq %rdi, %rbx
subl $0x1, 0x10(%r14)
jae 0x18ed2
movl 0x20(%r14), %eax
testl %eax, %eax
je 0x18ea3
cmpl $0x2, %eax
je 0x18e91
cmpl $0x1, %eax
jne 0x18eb3
movsd 0x2edd(%rip), %xmm0     # 0x1bd50
subsd 0x18(%r14), %xmm0
cvtdq2pd 0x44(%rbx), %xmm1
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
divpd %xmm0, %xmm1
cvttpd2dq %xmm1, %xmm0
movlpd %xmm0, 0x44(%rbx)
jmp 0x18eb3
movsd 0x18(%r14), %xmm0
addsd 0x58(%rbx), %xmm0
movsd %xmm0, 0x58(%rbx)
jmp 0x18eb3
movsd 0x18(%r14), %xmm0
addsd 0x50(%rbx), %xmm0
movsd %xmm0, 0x50(%rbx)
movq (%r14), %r12
decq 0x70(%rbx)
movq %r14, %rdi
callq 0x43f0
movl $0x28, %esi
movq %r14, %rdi
callq 0x42a0
movq %r12, %r14
movq (%r14), %r14
cmpq %r15, %r14
jne 0x18e52
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/arisKoutsou[P]oopproj/./src/livings/heroes/Sorcerer.cpp
// Function: Sorcerer::operator==(Sorcerer const&) const
bool Sorcerer :: operator==(const Sorcerer& rValue) const {
  bool sameHeros;
  bool sameAgilityBonus;
  bool sameDexterityBonus;

  sameHeros = Hero::operator==(rValue);
  sameAgilityBonus = (this->agilityBonus == rValue.agilityBonus)
    ? true : false;
  sameDexterityBonus = (this->dexterityBonus == rValue.dexterityBonus)
    ? true : false;

  return (sameHeros && sameAgilityBonus && sameDexterityBonus);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x14038
testb %al, %al
je 0x1950c
movsd 0x158(%rbx), %xmm0
ucomisd 0x158(%r14), %xmm0
jne 0x1950c
jp 0x1950c
movsd 0x160(%r14), %xmm0
cmpeqsd 0x160(%rbx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x1950e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/arisKoutsou[P]oopproj/./src/livings/heroes/Warrior.cpp
// Function: Warrior::operator==(Warrior const&) const
bool Warrior :: operator==(const Warrior& rValue) const {
  bool sameHeros;
  bool sameAgilityBonus;
  bool sameStrengthBonus;

  sameHeros = Hero::operator==(rValue);
  sameAgilityBonus = (this->agilityBonus == rValue.agilityBonus)
    ? true : false;
  sameStrengthBonus = (this->strengthBonus == rValue.strengthBonus)
    ? true : false;

  return (sameHeros && sameAgilityBonus && sameStrengthBonus);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x14038
testb %al, %al
je 0x196ee
movsd 0x158(%rbx), %xmm0
ucomisd 0x158(%r14), %xmm0
jne 0x196ee
jp 0x196ee
movsd 0x160(%r14), %xmm0
cmpeqsd 0x160(%rbx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x196f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/arisKoutsou[P]oopproj/./src/livings/heroes/Paladin.cpp
// Function: Paladin::operator==(Paladin const&) const
bool Paladin :: operator==(const Paladin& rValue) const {
  bool sameHeros;
  bool sameStrengthBonus;
  bool sameDexterityBonus;

  sameHeros = Hero::operator==(rValue);
  sameStrengthBonus = (this->strengthBonus == rValue.strengthBonus)
    ? true : false;
  sameDexterityBonus = (this->dexterityBonus == rValue.dexterityBonus)
    ? true : false;

  return (sameHeros && sameStrengthBonus && sameDexterityBonus);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x14038
testb %al, %al
je 0x198ca
movsd 0x158(%rbx), %xmm0
ucomisd 0x158(%r14), %xmm0
jne 0x198ca
jp 0x198ca
movsd 0x160(%r14), %xmm0
cmpeqsd 0x160(%rbx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x198cc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/arisKoutsou[P]oopproj/./src/items/Weapon.cpp
// Function: Weapon::operator==(Weapon const&) const
bool Weapon :: operator==(const Weapon& rValue) const {
  bool sameItems;
  bool sameDamage;
  bool sameRequiresBothHands;

  sameItems = Item::operator==(rValue);
  sameDamage = (this->damage == rValue.damage) ? true : false;
  sameRequiresBothHands = (this->requiresBothHands == rValue.requiresBothHands)
                           ? true : false;

  return (sameItems && sameDamage && sameRequiresBothHands);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1a80a
testb %al, %al
je 0x19d87
movb 0x44(%r14), %al
cmpb 0x44(%rbx), %al
sete %cl
movl 0x40(%r14), %eax
cmpl 0x40(%rbx), %eax
sete %al
andb %cl, %al
jmp 0x19d89
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/arisKoutsou[P]oopproj/./src/items/Armor.cpp
// Function: Armor::operator==(Armor const&) const
bool Armor :: operator==(const Armor& rValue) const {
  bool sameItems;
  bool sameReduceDamageTakenBy;

  sameItems = Item::operator==(rValue);
  sameReduceDamageTakenBy =
    (this->reduceDamageTakenBy == rValue.reduceDamageTakenBy)
    ? true : false;

  return (sameItems && sameReduceDamageTakenBy);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1a80a
movsd 0x40(%r14), %xmm0
ucomisd 0x40(%rbx), %xmm0
setnp %cl
sete %dl
andb %cl, %dl
andb %dl, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/arisKoutsou[P]oopproj/./src/items/Potion.cpp
// Function: Potion::operator==(Potion const&) const
bool Potion :: operator==(const Potion& rValue) const {
  bool sameItems;
  bool sameStrengthBoost;
  bool sameDexterityBoost;
  bool sameAgilityBoost;

  sameItems = Item::operator==(rValue);

  sameStrengthBoost = (this->strengthBoost == rValue.strengthBoost)
                       ? true : false;

  sameDexterityBoost = (this->dexterityBoost == rValue.dexterityBoost)
                        ? true : false;

  sameAgilityBoost = (this->agilityBoost == rValue.agilityBoost)
                      ? true : false;

  return (sameStrengthBoost &&
	  sameDexterityBoost &&
	  sameAgilityBoost &&
	  sameItems);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1a80a
movsd 0x40(%rbx), %xmm0
ucomisd 0x40(%r14), %xmm0
jne 0x1a720
jp 0x1a720
movsd 0x50(%rbx), %xmm0
movsd 0x50(%r14), %xmm1
movsd 0x48(%r14), %xmm2
movsd 0x48(%rbx), %xmm3
cmpeqpd %xmm2, %xmm3
cmpeqpd %xmm0, %xmm1
andpd %xmm3, %xmm1
movd %xmm1, %ecx
andb %cl, %al
jmp 0x1a722
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/Teris45[P]Maze-Game/main.cpp
// Function: main
int main(int argc, char *argv[]) {
    initscr();
    cbreak();
    keypad(stdscr, TRUE);
    clear();

    char name[10];
    addstr("Enter Player's name: ");

    getstr(name);



    noecho();

    if(argc<3)
        throw "NOT ENOUGH ARGUMENTS";

    auto* engine = new Engine(argv[1],argv[2],name);
    engine->printMaze();
    refresh();
    sleep(1);

    while(!engine->getGameEnded()){
        engine->gameLoop();
    }

    engine->updateHG(argv[2]);
//    engine->makeMove();

//    refresh();
    //    engine->printMaze();

//    sleep(2);

    delete engine;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movl %edi, %ebx
callq 0x3320
callq 0x30a0
movq 0x6911(%rip), %r15      # 0x9fd0
movq (%r15), %rdi
movl $0x1, %esi
callq 0x3100
callq 0x33d0
movq (%r15), %rdi
leaq 0x3929(%rip), %rsi      # 0x7004
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x30d0
movq (%r15), %rdi
leaq -0x6a(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x3330
callq 0x3280
cmpl $0x2, %ebx
jle 0x37fa
movl $0x1a0, %edi            # imm = 0x1A0
callq 0x3220
movq %rax, %rbx
movq 0x8(%r14), %rsi
leaq -0x40(%rbp), %rdi
leaq -0x1a(%rbp), %rdx
callq 0x3110
movq 0x10(%r14), %rsi
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x3110
leaq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdx
leaq -0x6a(%rbp), %rcx
movq %rbx, %rdi
callq 0x3aec
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3760
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x3230
leaq -0x30(%rbp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x3779
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x4206
callq 0x33a0
movl $0x1, %edi
callq 0x3190
movq %rbx, %rdi
callq 0x476a
testb %al, %al
jne 0x37a6
movq %rbx, %rdi
callq 0x4384
jmp 0x3790
movq 0x10(%r14), %rsi
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x3110
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x488a
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x37d8
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x42ee
movl $0x1a0, %esi            # imm = 0x1A0
movq %rbx, %rdi
callq 0x3230
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x3140
leaq 0x380f(%rip), %rcx      # 0x701a
movq %rcx, (%rax)
movq 0x67a3(%rip), %rsi      # 0x9fb8
movq %rax, %rdi
xorl %edx, %edx
callq 0x33b0
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x3885
movq -0x30(%rbp), %rsi
incq %rsi
jmp 0x3880
movq %rax, %r14
jmp 0x3885
movq %rax, %r14
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x385a
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x3230
jmp 0x385a
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3878
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3230
jmp 0x3878
movq %rax, %r14
movl $0x1a0, %esi            # imm = 0x1A0
movq %rbx, %rdi
callq 0x3230
movq %r14, %rdi
callq 0x33e0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/Teris45[P]Maze-Game/Engine.cpp
// Function: Engine::printMaze()
void Engine::printMaze(){
    for(auto & it : maze)
    {
        for(auto & it1 : it){
            if(it1 == WALL)
                addch('*');
            else if(it1 == DIADROMOS)
                addch(' ');
            else if(it1 == GOBLINAKOS)
                addch('G');
            else if(it1 == TRAALINAKOS)
                addch('T');
            else if(it1 == POTERAKOS)
                addch('P');
            else if(it1 == GEM)
                addch('0');

        }
        addch('\n');

    }

    addstr("------------------------------------------\n");
    addstr("HIGH SCORES\n");
    const char *str = hg.toStr();
    addstr(str);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rdi), %r14
movq %rdi, -0x30(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x38(%rbp)
cmpq %rax, %r14
je 0x427c
movq 0x5d9e(%rip), %r12      # 0x9fd0
leaq 0x2e2f(%rip), %r13      # 0x7068
movq (%r14), %rbx
movq 0x8(%r14), %r15
cmpq %r15, %rbx
je 0x4264
movl (%rbx), %eax
decl %eax
cmpl $0x5, %eax
ja 0x425e
movl %eax, %eax
movl (%r13,%rax,4), %esi
movq (%r12), %rdi
callq 0x3090
addq $0x4, %rbx
jmp 0x4240
movq (%r12), %rdi
movl $0xa, %esi
callq 0x3090
addq $0x18, %r14
cmpq -0x38(%rbp), %r14
jne 0x4239
movq 0x5d4d(%rip), %rbx      # 0x9fd0
movq (%rbx), %rdi
leaq 0x2e17(%rip), %rsi      # 0x70a4
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x30d0
movq (%rbx), %rdi
leaq 0x2e2f(%rip), %rsi      # 0x70d0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x30d0
movq -0x30(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
callq 0x65ae
movq (%rbx), %rdi
movq %rax, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x30d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Teris45[P]Maze-Game/Engine.cpp
// Function: Engine::gameLoop()
void Engine::gameLoop() {
    Engine::GetInput();
    Engine::checkEnding();
    Engine::makeMove();
    Engine::checkEnding();
    refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x43b6
movq %rbx, %rdi
callq 0x45bc
movq %rbx, %rdi
callq 0x3890
movq %rbx, %rdi
callq 0x45bc
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x33a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Teris45[P]Maze-Game/Engine.cpp
// Function: Engine::moveCheck(int, int)
void Engine::moveCheck(int py,int px){

    if(maze[py][px] == GEM){
        this->cntEatenGems++;
        this->poterakos.setPoint(px,py);
        this->maze[py][px] = POTERAKOS;
        if(cntEatenGems == NUMGEMS){
            this->setAvailablePoints();
            this->Pergamini.setPoint(available_points);
            maze[Pergamini.getY()][Pergamini.getX()] = PERGAMINI;
            mvaddch(Pergamini.getY(),Pergamini.getX(),'#');
        }
    }
    else if(maze[py][px] == PERGAMINI){
        this->winner = true;
        this->poterakos.setPoint(px,py);
        this->maze[py][px] = POTERAKOS;

    }
    else if(maze[py][px] == GOBLINAKOS || maze[py][px] == TRAALINAKOS){
        this->poterAlive = false;
    }
    else if(maze[py][px] == DIADROMOS){
        this->poterakos.setPoint(px,py);
        this->maze[py][px] = POTERAKOS;

    }


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %eax
movslq %esi, %rcx
movq (%rdi), %rsi
leaq (%rcx,%rcx,2), %r15
movslq %edx, %r14
movq (%rsi,%r15,8), %rcx
movl (%rcx,%r14,4), %ecx
addl $-0x2, %ecx
cmpl $0x5, %ecx
ja 0x4760
movq %rdi, %rbx
leaq 0x29e0(%rip), %rdx      # 0x7050
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movb $0x0, 0x19c(%rbx)
jmp 0x4760
incl 0x198(%rbx)
leaq 0x38(%rbx), %rdi
movl %r14d, %esi
movl %eax, %edx
callq 0x5770
movq (%rbx), %rax
movq (%rax,%r15,8), %rax
movl $0x3, (%rax,%r14,4)
cmpl $0xa, 0x198(%rbx)
jne 0x4760
movq %rbx, %rdi
callq 0x4776
leaq 0x120(%rbx), %r14
leaq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x6202
movq %r14, %rdi
callq 0x627a
cltq
movq (%rbx), %rbx
leaq (%rax,%rax,2), %r15
movq %r14, %rdi
callq 0x6284
cltq
movq (%rbx,%r15,8), %rcx
movl $0x7, (%rcx,%rax,4)
movq 0x58d3(%rip), %r12      # 0x9fd0
movq (%r12), %rbx
movq %r14, %rdi
callq 0x627a
movl %eax, %r15d
movq %r14, %rdi
callq 0x6284
movq %rbx, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x3240
cmpl $-0x1, %eax
je 0x4760
movq (%r12), %rdi
movl $0x23, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3090
movb $0x1, 0x19d(%rbx)
leaq 0x38(%rbx), %rdi
movl %r14d, %esi
movl %eax, %edx
callq 0x5770
movq (%rbx), %rax
movq (%rax,%r15,8), %rax
movl $0x3, (%rax,%r14,4)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Teris45[P]Maze-Game/Engine.cpp
// Function: Engine::setAvailablePoints()
void Engine::setAvailablePoints() {
    this->available_points.clear();
    for(int y = 0; y<(int) maze.size();y++){
        for(int x=0;x<(int) maze[y].size();x++){
            if(maze[y][x] == DIADROMOS){
                Point p1(x,y);
                available_points.push_back(p1);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x18(%rdi), %rbx
movq 0x20(%rdi), %r15
cmpq %rbx, %r15
movq %rdi, -0x30(%rbp)
je 0x47b4
movq %rbx, %r14
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
addq $0x10, %r14
cmpq %r15, %r14
jne 0x479b
movq -0x30(%rbp), %rdi
movq %rbx, 0x20(%rdi)
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
imull $0xaaaaaaab, %edx, %edx # imm = 0xAAAAAAAB
testl %edx, %edx
jle 0x4866
leaq 0x18(%rdi), %r14
xorl %r15d, %r15d
leaq -0x40(%rbp), %r12
leaq (%r15,%r15,2), %rbx
movq (%rax,%rbx,8), %rdx
movq 0x8(%rax,%rbx,8), %rsi
subq %rdx, %rsi
shrq $0x2, %rsi
testl %esi, %esi
jle 0x4847
xorl %r13d, %r13d
cmpl $0x2, (%rdx,%r13,4)
jne 0x4828
movq %r12, %rdi
movl %r13d, %esi
movl %r15d, %edx
callq 0x5866
movq %r14, %rdi
movq %r12, %rsi
callq 0x49c6
movq %r12, %rdi
callq 0x587c
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
incq %r13
movq (%rax,%rbx,8), %rdx
movq 0x8(%rax,%rbx,8), %rcx
subq %rdx, %rcx
shrq $0x2, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r13
jl 0x47f9
movq 0x8(%rdi), %rcx
incq %r15
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
imull $0xaaaaaaab, %edx, %edx # imm = 0xAAAAAAAB
movslq %edx, %rdx
cmpq %rdx, %r15
jl 0x47de
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x587c
movq %rbx, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Teris45[P]Maze-Game/Engine.cpp
// Function: Engine::updateHG(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Engine::updateHG(const string& filename) {

    int score = cntEatenGems * 10;
    if(winner)
        score += 10;
    hg<<this->username<< score;

    ofstream file(filename, ios::binary | ios::out);

    hg.save(file);

    file.close();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %r14
movl 0x198(%rdi), %r12d
movb 0x19d(%rdi), %r13b
leaq 0x130(%rdi), %rbx
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq 0x178(%rdi), %rsi
movq 0x180(%rdi), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x4d38
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64e8
addl %r12d, %r12d
leal (%r12,%r12,4), %ecx
leal (%r12,%r12,4), %esi
addl $0xa, %esi
testb %r13b, %r13b
cmovel %ecx, %esi
movq %rax, %rdi
callq 0x658e
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x491b
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3230
leaq -0x248(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x14, %edx
callq 0x3420
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6312
leaq -0x248(%rbp), %rdi
callq 0x32f0
movq 0x5678(%rip), %rax      # 0x9fc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x240(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x248(%rbp,%rcx)
callq 0x31d0
leaq -0x150(%rbp), %rdi
callq 0x30c0
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x248(%rbp), %rdi
callq 0x3310
jmp 0x49be
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x49be
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/Teris45[P]Maze-Game/Living.cpp
// Function: Living::setPoint(std::vector<Point, std::allocator<Point>>&)
void Living::setPoint(vector<Point> &starting) {
    srand(time(nullptr));

    int size = (int) starting.size();
    int rand_int = rand()%size;

    this->inMap.setX(starting[rand_int].getX());
    this->inMap.setY(starting[rand_int].getY());

    starting.erase(starting.begin()+rand_int);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
callq 0x31f0
movl %eax, %edi
callq 0x3200
movq 0x8(%rbx), %r15
subq (%rbx), %r15
shrq $0x4, %r15
callq 0x3070
cltd
idivl %r15d
movslq %edx, %rax
movq (%rbx), %rcx
shlq $0x4, %rax
leaq (%rcx,%rax), %rsi
movl 0x8(%rcx,%rax), %edx
movl %edx, 0x10(%r14)
movl 0xc(%rcx,%rax), %eax
movl %eax, 0x14(%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x59cc
// File: /workspace/github_cpp_makefile_star2_O3/Teris45[P]Maze-Game/Moving.cpp
// Function: MyMoving::Move(Traal, Poter&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&)
Point MyMoving::Move(Traal monster, Poter &poter, vector<vector<int>> &maze){
    vector<Point> possibleMoveSet;


    Point p = monster.getPoint();
    mvaddch(p.getY(),p.getX(),' ');

    possibleMoveSet = get_possible_moveset(p,maze);

    possibleMoveSet.push_back(p);

    p = getShortestEuclidean(poter,possibleMoveSet);

    mvaddch(p.getY(),p.getX(),'T');


    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
callq 0x582a
movq 0x4569(%rip), %rax      # 0x9fd0
movq (%rax), %r12
movq %rbx, %rdi
callq 0x5766
movl %eax, %r13d
movq %rbx, %rdi
callq 0x5752
movq %r12, %rdi
movl %r13d, %esi
movl %eax, %edx
callq 0x3240
cmpl $-0x1, %eax
je 0x5aa3
movq 0x453a(%rip), %rax      # 0x9fd0
movq (%rax), %rdi
movl $0x20, %esi
callq 0x3090
leaq -0x70(%rbp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x5bac
leaq -0x40(%rbp), %r15
movaps (%r15), %xmm0
movq 0x10(%r15), %rax
leaq -0x70(%rbp), %r12
movaps (%r12), %xmm1
movaps %xmm1, (%r15)
movq 0x10(%r12), %rcx
movq %rcx, 0x10(%r15)
leaq -0x58(%rbp), %rdi
movups %xmm0, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
callq 0x4ab0
movq %r12, %rdi
callq 0x4ab0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x49c6
leaq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rdx
movq %r14, %rsi
callq 0x5d32
leaq -0x58(%rbp), %rdi
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rbx)
callq 0x587c
movq 0x44a0(%rip), %rax      # 0x9fd0
movq (%rax), %r14
movq %rbx, %rdi
callq 0x5766
movl %eax, %r15d
movq %rbx, %rdi
callq 0x5752
movq %r14, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x3240
cmpl $-0x1, %eax
je 0x5b6c
movq 0x4471(%rip), %rax      # 0x9fd0
movq (%rax), %rdi
movl $0x54, %esi
callq 0x3090
leaq -0x40(%rbp), %rdi
callq 0x4ab0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5b90
jmp 0x5b90
movq %rax, %r14
jmp 0x5b9b
movq %rax, %r14
movq %rbx, %rdi
callq 0x587c
leaq -0x40(%rbp), %rdi
callq 0x4ab0
movq %r14, %rdi
callq 0x33e0