LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18724
movq %rax, %rdi
callq 0x18736
movl %eax, %ebp
movq %rbx, %rdi
callq 0x18724
movq %rax, %rdi
callq 0x18732
movl %eax, %r15d
movq 0x8(%rbx), %rdi
callq 0x67c0
cmpl %eax, %r15d
je 0x14560
movq 0x8(%rbx), %rdi
leal 0x1(%r15), %r14d
movl %ebp, %esi
movl %r14d, %edx
callq 0x684e
movq %rax, %rdi
callq 0x6652
testb %al, %al
jne 0x145b8
movq 0x8(%rbx), %rdi
movl %ebp, %esi
movl %r15d, %edx
movq %rbx, %rcx
callq 0x6918
movq %rbx, %rdi
callq 0x18724
movq %rax, %rdi
movl %r14d, %esi
callq 0x1873a
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 0x686a
movl $0x28, %edi
callq 0x4130
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x78f6(%rip), %rsi      # 0x1be73
leaq 0x790f(%rip), %rdx      # 0x1be93
leaq 0x8(%rsp), %rdi
callq 0x6520
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4c58
xorl %ebp, %ebp
leaq 0x10091(%rip), %rsi     # 0x24638
leaq -0xf90c(%rip), %rdx     # 0x4ca2
movq %rbx, %rdi
callq 0x4410
jmp 0x1460e
movl $0x28, %edi
callq 0x4130
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x783a(%rip), %rsi      # 0x1be0f
leaq 0x785a(%rip), %rdx      # 0x1be36
leaq 0x8(%rsp), %rdi
callq 0x6520
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4c58
xorl %ebp, %ebp
leaq 0x10039(%rip), %rsi     # 0x24638
leaq -0xf964(%rip), %rdx     # 0x4ca2
movq %rbx, %rdi
callq 0x4410
jmp 0x14612
jmp 0x1462e
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x14634
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x14634
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x14641
movq %rbx, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x146a7
movl %esi, %eax
leaq 0x76ee(%rip), %rcx      # 0x1bd50
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1403c
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x14344
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x144c2
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x141c6
movl $0x28, %edi
callq 0x4130
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x77d0(%rip), %rsi      # 0x1be94
leaq 0x77da(%rip), %rdx      # 0x1bea5
leaq 0x8(%rsp), %rdi
callq 0x6520
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4c58
xorl %ebp, %ebp
leaq 0xff4a(%rip), %rsi      # 0x24638
leaq -0xfa53(%rip), %rdx     # 0x4ca2
movq %rbx, %rdi
callq 0x4410
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1471f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x1471f
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1472c
movq %rbx, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10876(%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 0x68c2(%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 0x107ff(%rip), %rdi     # 0x24fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %edx
movq 0x107e4(%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 0x14813
movq (%r15), %rsi
incq %rsi
callq 0x42a0
movq %r14, %rdi
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xed2e
testq %rax, %rax
je 0x14d17
movq %rbx, %rdi
movq %rax, %rsi
callq 0xeb50
jmp 0x14d32
movq %rbx, %rdi
movq %r14, %rsi
callq 0xedc4
testq %rax, %rax
je 0x14d3c
movq %rbx, %rdi
movq %rax, %rsi
callq 0xebce
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x1027d(%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 0x714b(%rip), %rsi      # 0x1bebf
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 0x14d34
// File: /workspace/github_cpp_makefile_star2_O1/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 0xed2e
movq %rax, %rbx
testq %rax, %rax
je 0x14e58
movq (%rbx), %rax
movq %rsp, %r12
movq %r12, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
leaq 0x713b(%rip), %rsi      # 0x1bf27
movq %r12, %rdi
callq 0x40d0
movl %eax, %ebp
movq (%r12), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x14e11
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
testl %ebp, %ebp
je 0x14ec9
movq 0x101a0(%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 0x70b8(%rip), %rsi      # 0x1bf09
movl $0x24, %edx
jmp 0x14e95
movq 0x10161(%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 0x705f(%rip), %rsi      # 0x1beef
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 0x14f6d
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 0xec4c
movq %rbx, %rdi
callq 0x1a20c
addsd 0x6e38(%rip), %xmm0     # 0x1bd40
cvtsi2sdl 0x98(%r14), %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, 0x98(%r14)
movq %rbx, %rdi
callq 0x1a200
addsd 0x6e10(%rip), %xmm0     # 0x1bd40
mulsd 0xa0(%r14), %xmm0
movsd %xmm0, 0xa0(%r14)
movq %rbx, %rdi
callq 0x1a206
addsd 0x6dee(%rip), %xmm0     # 0x1bd40
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_O1/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 0xed2e
testq %rax, %rax
je 0x15bd1
movq %rax, %r15
movq 0xf4d6(%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 0x6597(%rip), %rsi      # 0x1c0b3
movl $0x5, %edx
movq %rax, %rdi
callq 0x42f0
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r13, %rdi
callq 0x42f0
movq %rax, %r12
leaq 0x6547(%rip), %rsi      # 0x1c08b
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 0x5a52(%rip), %rsi      # 0x1b5cb
movl $0x1, %edx
movq %rax, %rdi
callq 0x42f0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15ba1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %r14, %rdi
movq %r15, %rsi
callq 0xeb50
movl 0xac(%rbx), %ebp
movq %r15, %rdi
callq 0x1a738
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 0xedc4
testq %rax, %rax
jne 0x15c5b
movq 0xf3d8(%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 0x6475(%rip), %rsi      # 0x1c08e
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 0x15c81
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x160bc
movq %rsi, %r14
xorl %ebx, %ebx
movq 0x10(%r12), %rdi
callq 0x130b4
movq 0x8(%rax), %rdx
cmpq 0x8(%r14), %rdx
jne 0x160b1
testq %rdx, %rdx
je 0x160c0
movq (%r14), %rsi
movq (%rax), %rdi
callq 0x42b0
testl %eax, %eax
je 0x160c0
movq (%r12), %r12
cmpq %r15, %r12
jne 0x16089
jmp 0x160c5
xorl %ebx, %ebx
jmp 0x160c5
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_O1/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 0x1664e
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 0x5707(%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 0x1659a
movq %r13, %rdi
leaq 0x56e5(%rip), %rsi      # 0x1bc4b
callq 0x40d0
testl %eax, %eax
je 0x165b2
movq %r13, %rdi
leaq 0x56dc(%rip), %rsi      # 0x1bc55
callq 0x40d0
testl %eax, %eax
jne 0x165c8
movq 0x10(%r15), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0xfb1a
jmp 0x165c8
movq 0x10(%r15), %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
movq %r12, %rsi
callq 0xf842
jmp 0x165c8
movq 0x10(%r15), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
movq %r12, %rsi
callq 0xf9ae
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x165df
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x42a0
movq (%r15), %r15
cmpq %rbx, %r15
jne 0x16540
leaq 0x50(%rsp), %rsi
callq 0x17bfa
leaq 0x30(%rsp), %rsi
callq 0x17738
leaq 0x10(%rsp), %rsi
callq 0x180bc
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x16620
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x42a0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x16637
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x42a0
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1664e
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 0x16682
jmp 0x16666
jmp 0x16666
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x16685
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x16685
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1669c
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x42a0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x166b3
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x42a0
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x166ca
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4d80
movq %rbx, %rdi
callq 0x1885e
callq 0x4db4
testb %al, %al
je 0x1676b
movq 0xe8bc(%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 0x5af2(%rip), %rsi      # 0x1c227
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 0x167bb
movl 0x98(%r14), %ebp
movq 0x48(%r14), %rdi
testq %rdi, %rdi
je 0x16782
callq 0x1996c
addl %eax, %ebp
movq 0x50(%r14), %rdi
testq %rdi, %rdi
je 0x16792
callq 0x1996c
addl %eax, %ebp
movq %rbx, %rdi
callq 0x18858
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_O1/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 0x4e38
movq %r15, %rdi
callq 0x4ff0
testl %eax, %eax
je 0x1688c
movl %eax, %r12d
leaq 0x5584(%rip), %r13      # 0x1bd8c
leaq 0xea5a(%rip), %rbp      # 0x25269
movq %r15, %rdi
callq 0x4f74
decl %r12d
cmpl $0x5, %r12d
ja 0x16875
movslq (%r13,%r12,4), %rax
addq %r13, %rax
jmpq *%rax
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
jmp 0x16875
movq %r14, %rdi
callq 0x17534
jmp 0x1685c
movq %rbx, %rsi
callq 0x168bc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x16efe
jmp 0x1685c
movq %r14, %rdi
callq 0x172fa
testb %al, %al
je 0x16875
jmp 0x1688c
callq 0x8c1b
cmpb $0x0, (%rbp)
jne 0x1688c
movq %r15, %rdi
callq 0x4f74
movq %r15, %rdi
callq 0x4e38
movq %r15, %rdi
callq 0x4ff0
movl %eax, %r12d
testl %eax, %eax
jne 0x1680f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rsi
callq 0x168bc
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x16b48
// File: /workspace/github_cpp_makefile_star2_O1/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 0xca36
movl %eax, %ebp
testb %al, %al
je 0x17694
movb %bpl, 0x7(%rsp)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0xda42(%rip), %r12      # 0x24fc0
movq 0xda4b(%rip), %rbx      # 0x24fd0
leaq 0x8(%rsp), %r13
callq 0x8e16
movq %r15, %rdi
callq 0xea36
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 0x4d88(%rip), %rsi      # 0x1c359
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 0x3a35(%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 0x1481c
testb %al, %al
je 0x1758a
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1768d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movb 0x7(%rsp), %bpl
jmp 0x17700
movq 0xd925(%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 0x4c68(%rip), %rsi      # 0x1c334
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 0x17730
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/livings/Living.cpp
// Function: Living::operator==(Living const&) const
bool Living :: operator==(const Living& rValue) const {
  bool sameName;
  bool sameLevel;
  bool sameHealthPower;
  bool samePosition;

  sameName = (this->name == rValue.name) ? true : false;
  sameLevel = (this->level == rValue.level) ? true : false;
  sameHealthPower = (this->healthPower == rValue.healthPower) ? true : false;
  samePosition = (this->p == rValue.p) ? true : false;

  return (sameName && sameLevel && sameHealthPower && samePosition);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rdx
cmpq 0x28(%rsi), %rdx
jne 0x186db
testq %rdx, %rdx
je 0x186df
movq 0x20(%rbx), %rsi
movq 0x20(%r14), %rdi
callq 0x42b0
testl %eax, %eax
sete %cl
jmp 0x186e1
xorl %ecx, %ecx
jmp 0x186e1
movb $0x1, %cl
xorl %eax, %eax
testb %cl, %cl
je 0x1870c
movl 0x10(%rbx), %ecx
cmpl %ecx, 0x10(%r14)
jne 0x1870c
movl 0x18(%rbx), %eax
movl 0x1c(%rbx), %ecx
xorl 0x18(%r14), %eax
xorl 0x1c(%r14), %ecx
movl 0x40(%r14), %edx
xorl 0x40(%rbx), %edx
orl %eax, %edx
orl %ecx, %edx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4d80
movq %rbx, %rdi
callq 0x13470
callq 0x4db4
testb %al, %al
jne 0x18cf5
movl 0x44(%r14), %edi
movl 0x48(%r14), %esi
callq 0x4dee
movl %eax, %ebp
movq %rbx, %rdi
callq 0x134aa
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_O1/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 0x18d99
cmpl $0x2, %ebp
je 0x18d80
cmpl $0x1, %ebp
jne 0x18db0
movsd 0x2fea(%rip), %xmm0     # 0x1bd40
cvtsi2sdl 0x44(%rbx), %xmm1
subsd (%rsp), %xmm0
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, 0x44(%rbx)
xorps %xmm1, %xmm1
cvtsi2sdl 0x48(%rbx), %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, 0x48(%rbx)
jmp 0x18db0
movsd 0x58(%rbx), %xmm0
subsd (%rsp), %xmm0
xorpd %xmm1, %xmm1
maxsd %xmm0, %xmm1
movsd %xmm1, 0x58(%rbx)
jmp 0x18db0
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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18e78
movq %rdi, %rbx
subl $0x1, 0x10(%r14)
jae 0x18e6c
movl 0x20(%r14), %eax
testl %eax, %eax
je 0x18e3d
cmpl $0x2, %eax
je 0x18e2b
cmpl $0x1, %eax
jne 0x18e4d
movsd 0x2f43(%rip), %xmm0     # 0x1bd40
subsd 0x18(%r14), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl 0x44(%rbx), %xmm1
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, 0x44(%rbx)
xorps %xmm1, %xmm1
cvtsi2sdl 0x48(%rbx), %xmm1
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, 0x48(%rbx)
jmp 0x18e4d
movsd 0x18(%r14), %xmm0
addsd 0x58(%rbx), %xmm0
movsd %xmm0, 0x58(%rbx)
jmp 0x18e4d
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 0x18dd8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13fb0
testb %al, %al
je 0x1949a
movsd 0x158(%rbx), %xmm0
ucomisd 0x158(%r14), %xmm0
jne 0x1949a
jp 0x1949a
movsd 0x160(%r14), %xmm0
cmpeqsd 0x160(%rbx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x1949c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13fb0
testb %al, %al
je 0x19684
movsd 0x158(%rbx), %xmm0
ucomisd 0x158(%r14), %xmm0
jne 0x19684
jp 0x19684
movsd 0x160(%r14), %xmm0
cmpeqsd 0x160(%rbx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x19686
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13fb0
testb %al, %al
je 0x1986c
movsd 0x158(%rbx), %xmm0
ucomisd 0x158(%r14), %xmm0
jne 0x1986c
jp 0x1986c
movsd 0x160(%r14), %xmm0
cmpeqsd 0x160(%rbx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x1986e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1a746
testb %al, %al
je 0x19d05
movb 0x44(%r14), %al
cmpb 0x44(%rbx), %al
sete %cl
movl 0x40(%r14), %eax
cmpl 0x40(%rbx), %eax
sete %al
andb %cl, %al
jmp 0x19d07
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1a746
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_O1/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 0x1a746
movsd 0x40(%rbx), %xmm0
ucomisd 0x40(%r14), %xmm0
jne 0x1a65e
jp 0x1a65e
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 0x1a660
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3330
callq 0x30a0
movq 0x6921(%rip), %r15      # 0x9fd0
movq (%r15), %rdi
movl $0x1, %esi
callq 0x3100
callq 0x33e0
movq (%r15), %rdi
leaq 0x3939(%rip), %rsi      # 0x7004
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x30d0
movq (%r15), %rdi
leaq -0x6a(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x3340
callq 0x3290
cmpl $0x2, %ebx
jle 0x37ea
movl $0x1a0, %edi            # imm = 0x1A0
callq 0x3230
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 0x3aea
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3750
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x3240
leaq -0x30(%rbp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x3769
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3240
movq %rbx, %rdi
callq 0x4204
callq 0x33b0
movl $0x1, %edi
callq 0x3190
movq %rbx, %rdi
callq 0x476e
testb %al, %al
jne 0x3796
movq %rbx, %rdi
callq 0x4382
jmp 0x3780
movq 0x10(%r14), %rsi
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x3110
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x487e
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x37c8
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3240
movq %rbx, %rdi
callq 0x42ec
movl $0x1a0, %esi            # imm = 0x1A0
movq %rbx, %rdi
callq 0x3240
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x3140
leaq 0x381f(%rip), %rcx      # 0x701a
movq %rcx, (%rax)
movq 0x67b3(%rip), %rsi      # 0x9fb8
movq %rax, %rdi
xorl %edx, %edx
callq 0x33c0
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x3875
movq -0x30(%rbp), %rsi
incq %rsi
jmp 0x3870
movq %rax, %r14
jmp 0x3875
movq %rax, %r14
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x384a
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x3240
jmp 0x384a
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3868
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3240
jmp 0x3868
movq %rax, %r14
movl $0x1a0, %esi            # imm = 0x1A0
movq %rbx, %rdi
callq 0x3240
movq %r14, %rdi
callq 0x33f0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 0x427a
movq 0x5da0(%rip), %r12      # 0x9fd0
leaq 0x2e31(%rip), %r13      # 0x7068
movq (%r14), %rbx
movq 0x8(%r14), %r15
cmpq %r15, %rbx
je 0x4262
movl (%rbx), %eax
decl %eax
cmpl $0x5, %eax
ja 0x425c
movl %eax, %eax
movl (%r13,%rax,4), %esi
movq (%r12), %rdi
callq 0x3090
addq $0x4, %rbx
jmp 0x423e
movq (%r12), %rdi
movl $0xa, %esi
callq 0x3090
addq $0x18, %r14
cmpq -0x38(%rbp), %r14
jne 0x4237
movq 0x5d4f(%rip), %rbx      # 0x9fd0
movq (%rbx), %rdi
leaq 0x2e19(%rip), %rsi      # 0x70a4
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x30d0
movq (%rbx), %rdi
leaq 0x2e31(%rip), %rsi      # 0x70d0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x30d0
movq -0x30(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
callq 0x65a2
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_O1/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 0x43b4
movq %rbx, %rdi
callq 0x45c0
movq %rbx, %rdi
callq 0x3880
movq %rbx, %rdi
callq 0x45c0
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4764
movq %rdi, %rbx
leaq 0x29dc(%rip), %rdx      # 0x7050
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movb $0x0, 0x19c(%rbx)
jmp 0x4764
incl 0x198(%rbx)
leaq 0x38(%rbx), %rdi
movl %r14d, %esi
movl %eax, %edx
callq 0x5726
movq (%rbx), %rax
movq (%rax,%r15,8), %rax
movl $0x3, (%rax,%r14,4)
cmpl $0xa, 0x198(%rbx)
jne 0x4764
movq %rbx, %rdi
callq 0x477a
leaq 0x120(%rbx), %r14
leaq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x61f2
movq %r14, %rdi
callq 0x626a
cltq
movq (%rbx), %rbx
leaq (%rax,%rax,2), %r15
movq %r14, %rdi
callq 0x6274
cltq
movq (%rbx,%r15,8), %rcx
movl $0x7, (%rcx,%rax,4)
movq 0x58cf(%rip), %r12      # 0x9fd0
movq (%r12), %rbx
movq %r14, %rdi
callq 0x626a
movl %eax, %r15d
movq %r14, %rdi
callq 0x6274
movq %rbx, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x3250
cmpl $-0x1, %eax
je 0x4764
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 0x5726
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_O1/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 %rdi, %rbx
movq 0x18(%rdi), %r15
movq 0x20(%rdi), %r12
cmpq %r15, %r12
je 0x47b3
movq %r15, %r14
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
addq $0x10, %r14
cmpq %r12, %r14
jne 0x479e
movq %r15, 0x20(%rbx)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
testl %eax, %eax
jle 0x485b
leaq 0x18(%rbx), %rax
movq %rax, -0x30(%rbp)
xorl %r15d, %r15d
leaq -0x40(%rbp), %r12
movq (%rbx), %rcx
leaq (%r15,%r15,2), %r14
movq (%rcx,%r14,8), %rax
movq 0x8(%rcx,%r14,8), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
testl %ecx, %ecx
jle 0x4840
xorl %r13d, %r13d
cmpl $0x2, (%rax,%r13,4)
jne 0x4822
movq %r12, %rdi
movl %r13d, %esi
movl %r15d, %edx
callq 0x5826
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x49ba
movq %r12, %rdi
callq 0x583c
incq %r13
movq (%rbx), %rcx
movq (%rcx,%r14,8), %rax
movq 0x8(%rcx,%r14,8), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r13
jl 0x47f9
incq %r15
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
cltq
cmpq %rax, %r15
jl 0x47db
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x583c
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4cdc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64d8
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 0x6582
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x490f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3240
leaq -0x248(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x14, %edx
callq 0x3430
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6302
leaq -0x248(%rbp), %rdi
callq 0x3300
movq 0x5684(%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 0x31e0
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 0x3320
jmp 0x49b2
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x49b2
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3240
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/Teris45[P]Maze-Game/Living.cpp
// Function: Point::euclidean(Point const&)
float Point:: euclidean(const Point &point){
    int x2 = this->x - point.x;
    int y2 = this->y - point.y;

    x2 = x2*x2;
    y2 = y2*y2;

    int distance = x2 + y2;

    return sqrt(distance);
}

// Assembly:
movl 0x8(%rdi), %eax
subl 0x8(%rsi), %eax
movl 0xc(%rdi), %ecx
subl 0xc(%rsi), %ecx
imull %eax, %eax
imull %ecx, %ecx
addl %eax, %ecx
cvtsi2sd %ecx, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x56dc
sqrtsd %xmm0, %xmm0
jmp 0x56e6
pushq %rbp
movq %rsp, %rbp
callq 0x31b0
popq %rbp
cvtsd2ss %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3200
movl %eax, %edi
callq 0x3210
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 0x59b4