LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/inventory/Inventory.cpp
// Function: Inventory::printSpells()
void Inventory :: printSpells() {
  if (getCurrentSpells() == 0) {
    cout << endl << "No spells in the Inventory" << endl << endl;
    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
cmpl $0x0, 0x30(%rdi)
je 0xb6bd
movq %rdi, %rbx
movq 0x20(%rdi), %r15
addq $0x20, %rbx
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %r14
andq $0x0, 0x10(%r14)
leaq 0x30(%rsp), %rax
andq $0x0, 0x10(%rax)
movaps %xmm0, (%r14)
movaps %xmm0, (%rax)
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
leaq 0x68(%rsp), %r13
leaq 0xa667(%rip), %rbp      # 0x15c32
leaq 0x8(%rsp), %r12
cmpq %rbx, %r15
je 0xb66f
movq 0x10(%r15), %rsi
movq (%rsi), %rax
movq %r13, %rdi
callq *0x18(%rax)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x5b02
testb %al, %al
je 0xb60b
movq 0x10(%r15), %rax
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0xc390
jmp 0xb65f
movq %r13, %rdi
leaq 0xa626(%rip), %rsi      # 0x15c3b
callq 0x5b02
testb %al, %al
je 0xb636
movq 0x10(%r15), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
movq %r12, %rsi
callq 0xc50c
jmp 0xb65f
movq %r13, %rdi
leaq 0xa605(%rip), %rsi      # 0x15c45
callq 0x5b02
testb %al, %al
je 0xb65f
movq 0x10(%r15), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0xc688
movq %r13, %rdi
callq 0x4470
movq (%r15), %r15
jmp 0xb5d0
leaq 0x50(%rsp), %rsi
callq 0xafb6
leaq 0x30(%rsp), %rsi
callq 0xacda
leaq 0x10(%rsp), %rsi
callq 0xb292
leaq 0x10(%rsp), %rdi
callq 0xc35c
leaq 0x30(%rsp), %rdi
callq 0xc328
leaq 0x50(%rsp), %rdi
callq 0xc2f4
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x158fc(%rip), %rdi     # 0x20fc0
callq 0x4120
leaq 0xa547(%rip), %rsi      # 0x15c17
movq %rax, %rdi
callq 0x4250
movq %rax, %rdi
callq 0x4120
movq %rax, %rdi
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4120
jmp 0xb70e
jmp 0xb6ff
jmp 0xb6ff
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x4470
jmp 0xb711
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc35c
leaq 0x30(%rsp), %rdi
callq 0xc328
leaq 0x50(%rsp), %rdi
callq 0xc2f4
movq %rbx, %rdi
callq 0x4410
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/inventory/Inventory.cpp
// Function: Inventory::addItem(Item*)
void Inventory :: addItem(Item* item) {
  if (this->getCurrentCapacity() == maxCapacity) {
    cout << "Your inventory is full" << endl;
    return;
  }

  items.push_back(item);
}

// Assembly:
pushq %rax
movq %rsi, (%rsp)
movl 0x30(%rdi), %eax
addl 0x18(%rdi), %eax
cmpl %eax, (%rdi)
jne 0xb775
movq 0x15860(%rip), %rdi     # 0x20fc0
leaq 0xa4ed(%rip), %rsi      # 0x15c54
callq 0x4250
movq %rax, %rdi
popq %rax
jmp 0x4120
addq $0x8, %rdi
movq %rsp, %rsi
callq 0xbc84
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/inventory/Inventory.cpp
// Function: Inventory::addSpell(Spell*)
void Inventory :: addSpell(Spell* spell) {
  if (this->getCurrentCapacity() == maxCapacity) {
    cout << "Your inventory is full" << endl;
    return;
  }

  spells.push_back(spell);
}

// Assembly:
pushq %rax
movq %rsi, (%rsp)
movl 0x30(%rdi), %eax
addl 0x18(%rdi), %eax
cmpl %eax, (%rdi)
jne 0xb7af
movq 0x15826(%rip), %rdi     # 0x20fc0
leaq 0xa4b3(%rip), %rsi      # 0x15c54
callq 0x4250
movq %rax, %rdi
popq %rax
jmp 0x4120
addq $0x20, %rdi
movq %rsp, %rsi
callq 0xbc90
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/inventory/Inventory.cpp
// Function: Inventory::removeAndDeleteItem(Item*)
void Inventory :: removeAndDeleteItem(Item* item) {
  if (this->getCurrentCapacity() == 0) {
    cout << "Your inventory is already empty" << endl;
    return;
  }

  items.remove(item);
  delete item;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
movl 0x30(%rdi), %eax
addl 0x18(%rdi), %eax
je 0xb7f5
addq $0x8, %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0xbc9c
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xb7ef
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
movq 0x157c4(%rip), %rdi     # 0x20fc0
leaq 0xa468(%rip), %rsi      # 0x15c6b
callq 0x4250
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x4120
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/inventory/Inventory.cpp
// Function: Inventory::removeAndDeleteSpell(Spell*)
void Inventory :: removeAndDeleteSpell(Spell* spell) {
  if (this->getCurrentCapacity() == 0) {
    cout << "Your inventory is aldready empty" << endl;
    return;
  }

  spells.remove(spell);
  delete spell;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
movl 0x30(%rdi), %eax
addl 0x18(%rdi), %eax
je 0xb84d
addq $0x20, %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0xbcfa
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xb847
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
movq 0x1576c(%rip), %rdi     # 0x20fc0
leaq 0xa430(%rip), %rsi      # 0x15c8b
callq 0x4250
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x4120
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/inventory/Inventory.cpp
// Function: Inventory::removeItem(Item*)
void Inventory :: removeItem(Item* item) {
  if (this->getCurrentCapacity() == 0) {
    cout << "Your inventory is already empty" << endl;
    return;
  }

  items.remove(item);
}

// Assembly:
pushq %rax
movq %rsi, (%rsp)
movl 0x30(%rdi), %eax
addl 0x18(%rdi), %eax
je 0xb889
addq $0x8, %rdi
movq %rsp, %rsi
callq 0xbc9c
popq %rax
retq
movq 0x15730(%rip), %rdi     # 0x20fc0
leaq 0xa3d4(%rip), %rsi      # 0x15c6b
callq 0x4250
movq %rax, %rdi
popq %rax
jmp 0x4120
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/inventory/Inventory.cpp
// Function: Inventory::removeSpell(Spell*)
void Inventory :: removeSpell(Spell* spell) {
  if (this->getCurrentCapacity() == 0) {
    cout << "Your inventory is already empty" << endl;
    return;
  }

  spells.remove(spell);
}

// Assembly:
pushq %rax
movq %rsi, (%rsp)
movl 0x30(%rdi), %eax
addl 0x18(%rdi), %eax
je 0xb8c1
addq $0x20, %rdi
movq %rsp, %rsi
callq 0xbcfa
popq %rax
retq
movq 0x156f8(%rip), %rdi     # 0x20fc0
leaq 0xa39c(%rip), %rsi      # 0x15c6b
callq 0x4250
movq %rax, %rdi
popq %rax
jmp 0x4120
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/inventory/Inventory.cpp
// Function: Inventory::getItemByName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
Item* Inventory::getItemByName(const string& itemName) const {
  list<Item*>::const_iterator it = items.begin();

  for ( ; it != items.end() ; it++) {
    if ((*it)->getName() == itemName) {
      return *it;
    }
  }

  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
addq $0x8, %r15
xorl %ebx, %ebx
leaq 0x8(%rsp), %r12
movq %r15, %r13
movq (%r13), %r13
cmpq %r15, %r13
je 0xb939
movq 0x10(%r13), %rsi
movq %r12, %rdi
callq 0x14584
movq %r12, %rdi
movq %r14, %rsi
callq 0x57df
movl %eax, %ebp
movq %r12, %rdi
callq 0x4470
testb %bpl, %bpl
je 0xb906
movq 0x10(%r13), %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/inventory/Inventory.cpp
// Function: Inventory::getSpellByName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
Spell* Inventory::getSpellByName(const string& spellName) const {
  list<Spell*>::const_iterator it = spells.begin();

  for ( ; it != spells.end() ; it++) {
    if ((*it)->getName() == spellName) {
      return *it;
    }
  }

  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
addq $0x20, %r15
xorl %ebx, %ebx
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0xb98a
movq 0x10(%r12), %rdi
callq 0xed62
movq %rax, %rdi
movq %r14, %rsi
callq 0x57df
testb %al, %al
je 0xb963
movq 0x10(%r12), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/market/Market.cpp
// Function: Market::~Market()
Market :: ~Market() {
  while(items.empty() == false) {
    delete items.front();
    items.pop_front();
  }

  while(spells.empty() == false) {
    delete spells.front();
    spells.pop_front();
  }  
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq (%rbx), %rax
cmpq %rbx, %rax
je 0xca71
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0xca67
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xbc74
jmp 0xca50
leaq 0x20(%r14), %r15
movq (%r15), %rax
cmpq %r15, %rax
je 0xca96
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0xca8c
movq (%rdi), %rax
callq *0x8(%rax)
movq %r15, %rdi
callq 0xbc7c
jmp 0xca75
addq $0x38, %r14
movq %r14, %rdi
callq 0x57c8
movq %r15, %rdi
callq 0xbd58
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xbd82
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/market/Market.cpp
// Function: Market::addItem(Item*)
void Market :: addItem(Item* item) {
  if (this->getCurrentCapacity() == maxCapacity) {
    cout << "Market is full" << endl;
    return;
  }
  
  items.push_back(item);
}

// Assembly:
pushq %rax
movq %rsi, (%rsp)
movl 0x30(%rdi), %eax
addl 0x18(%rdi), %eax
cmpl %eax, (%rdi)
jne 0xde47
movq 0x1318e(%rip), %rdi     # 0x20fc0
leaq 0x7ea4(%rip), %rsi      # 0x15cdd
callq 0x4250
movq %rax, %rdi
popq %rax
jmp 0x4120
addq $0x8, %rdi
movq %rsp, %rsi
callq 0xbc84
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/market/Market.cpp
// Function: Market::addSpell(Spell*)
void Market :: addSpell(Spell* spell) {
  if (this->getCurrentCapacity() == maxCapacity) {
    cout << "Market is full" << endl;
    return;
  }

  spells.push_back(spell);
}

// Assembly:
pushq %rax
movq %rsi, (%rsp)
movl 0x30(%rdi), %eax
addl 0x18(%rdi), %eax
cmpl %eax, (%rdi)
jne 0xde81
movq 0x13154(%rip), %rdi     # 0x20fc0
leaq 0x7e6a(%rip), %rsi      # 0x15cdd
callq 0x4250
movq %rax, %rdi
popq %rax
jmp 0x4120
addq $0x20, %rdi
movq %rsp, %rsi
callq 0xbc90
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/market/Market.cpp
// Function: Market::getItemByName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Item* Market :: getItemByName(const string& name) {
  list<Item*> :: iterator itemIterator = items.begin();

  for ( ; itemIterator != items.end(); ++itemIterator) {
    if ((*itemIterator)->getName() == name) {
      return (*itemIterator);
    }
  }

  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
addq $0x8, %r15
xorl %ebx, %ebx
leaq 0x8(%rsp), %r12
movq %r15, %r13
movq (%r13), %r13
cmpq %r15, %r13
je 0xdee5
movq 0x10(%r13), %rsi
movq %r12, %rdi
callq 0x14584
movq %r12, %rdi
movq %r14, %rsi
callq 0x57df
movl %eax, %ebp
movq %r12, %rdi
callq 0x4470
testb %bpl, %bpl
je 0xdeb2
movq 0x10(%r13), %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/market/Market.cpp
// Function: Market::getSpellByName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Spell* Market :: getSpellByName(const string& name) {
  list<Spell*> :: iterator spellIterator = spells.begin();

  for ( ; spellIterator != spells.end(); ++spellIterator) {
    if ((*spellIterator)->getName() == name) {
      return (*spellIterator);
    }
  }

  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
addq $0x20, %r15
xorl %ebx, %ebx
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0xdf36
movq 0x10(%r12), %rdi
callq 0xed62
movq %rax, %rdi
movq %r14, %rsi
callq 0x57df
testb %al, %al
je 0xdf0f
movq 0x10(%r12), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/spells/IceSpell.cpp
// Function: IceSpell::operator==(IceSpell const&) const
bool IceSpell :: operator==(const IceSpell& rValue) const {
  bool sameSpells;
  bool sameOponentDamageReduction;
  bool sameRounds;

  sameSpells = Spell::operator==(rValue);
  sameOponentDamageReduction =
    (this->oponentDamageReduction == rValue.oponentDamageReduction) ? true : false;
  sameRounds = (this->rounds == rValue.rounds) ? true : false;

  return (sameSpells && sameOponentDamageReduction && sameRounds);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xed7e
movl %eax, %ecx
movl 0x50(%r14), %eax
cmpl 0x50(%rbx), %eax
sete %al
testb %cl, %cl
je 0xe388
movsd 0x48(%r14), %xmm0
ucomisd 0x48(%rbx), %xmm0
jne 0xe388
jnp 0xe38a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/spells/LightningSpell.cpp
// Function: LightningSpell::operator==(LightningSpell const&) const
bool LightningSpell :: operator==(const LightningSpell& rValue) const {
  bool sameSpells;
  bool sameOponentDodgeReduction;
  bool sameRounds;

  sameSpells = Spell::operator==(rValue);;
  sameOponentDodgeReduction =
    (this->oponentDodgeReduction == rValue.oponentDodgeReduction) ? true : false;
  sameRounds = (this->rounds == rValue.rounds) ? true : false;

  return (sameSpells && sameOponentDodgeReduction && sameRounds);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xed7e
movl %eax, %ecx
movl 0x50(%r14), %eax
cmpl 0x50(%rbx), %eax
sete %al
testb %cl, %cl
je 0xe80c
movsd 0x48(%r14), %xmm0
ucomisd 0x48(%rbx), %xmm0
jne 0xe80c
jnp 0xe80e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/spells/FireSpell.cpp
// Function: FireSpell::operator==(FireSpell const&) const
bool FireSpell :: operator==(const FireSpell& rValue) const {
  bool sameSpells;
  bool sameOponentArmorReduction;
  bool sameRounds;

  sameSpells = Spell::operator==(rValue);
  sameOponentArmorReduction =
    (this->oponentArmorReduction == rValue.oponentArmorReduction) ? true : false;
  sameRounds = (this->rounds == rValue.rounds) ? true : false;

  return (sameSpells && sameOponentArmorReduction && sameRounds);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xed7e
movl %eax, %ecx
movl 0x50(%r14), %eax
cmpl 0x50(%rbx), %eax
sete %al
testb %cl, %cl
je 0xec90
movsd 0x48(%r14), %xmm0
ucomisd 0x48(%rbx), %xmm0
jne 0xec90
jnp 0xec92
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/spells/Spell.cpp
// Function: Spell::operator==(Spell const&) const
bool Spell :: operator==(const Spell& rValue) const {
  bool sameName;
  bool sameValue;
  bool sameMinLevel;
  bool sameMagicPowerRequired;
  bool sameMinDamage;
  bool sameMaxDamage;

  sameName = (this->name == rValue.name) ? true : false;
  sameValue = (this->value == rValue.value) ? true : false;
  sameMinLevel = (this->minLevel == rValue.minLevel) ? true : false;
  sameMagicPowerRequired =
    (this->magicPowerRequired == rValue.magicPowerRequired) ? true : false;
  sameMinDamage = (this->minDamage == rValue.minDamage) ? true : false;
  sameMaxDamage = (this->maxDamage == rValue.maxDamage) ? true : false;

  return (sameName && sameValue && sameMinLevel &&
	  sameMagicPowerRequired && sameMinDamage && sameMaxDamage);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %rdi
addq $0x10, %rsi
callq 0x57df
testb %al, %al
je 0xedbc
movl 0x40(%rbx), %eax
xorl 0x40(%r14), %eax
movdqu 0x30(%r14), %xmm0
movdqu 0x30(%rbx), %xmm1
pcmpeqd %xmm0, %xmm1
movmskps %xmm1, %ecx
xorl $0xf, %ecx
orl %eax, %ecx
sete %al
jmp 0xedbe
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::~Hero()
Hero :: ~Hero() {
  delete leftHandWeapon;
  delete rightHandWeapon;
  delete shield;

  while (spells.empty() == false) {
    delete spells.front();
    spells.pop_front();
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1198a(%rip), %rax     # 0x208f0
movq %rax, (%rdi)
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0xef78
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0xef87
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0xef96
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x60(%rbx), %r14
movq (%r14), %rax
cmpq %r14, %rax
je 0xefbb
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0xefb1
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
callq 0xbc7c
jmp 0xef9a
leaq 0x138(%rbx), %rdi
callq 0x57c8
leaq 0x118(%rbx), %rdi
callq 0x57c8
leaq 0xc0(%rbx), %rdi
callq 0xa2fc
leaq 0x78(%rbx), %rdi
callq 0x1283e
movq %r14, %rdi
callq 0xbd58
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12a42
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::getDamageReductionFactor() const
double Hero::getDamageReductionFactor() const {
	double result = 0.0;

	if (shield != NULL) {
		result += shield->getDamageReductionFactor();
	}

	return result;
}

// Assembly:
movq 0x58(%rdi), %rdi
testq %rdi, %rdi
je 0xf072
pushq %rax
callq 0x13e10
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
addsd %xmm1, %xmm0
addq $0x8, %rsp
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::updatePotions()
void Hero::updatePotions() {
  // (George): Alternative Implementation

  list<Potion*> :: iterator potionsIterator = potions.begin();  

  for ( ; potionsIterator != potions.end(); ++potionsIterator) {
    (*potionsIterator)->roundPassed();

    if ((*potionsIterator)->getRoundsEffective() == -1) {
      double strengthBoost = (*potionsIterator)->getStrengthBoost();
      double agilityBoost = (*potionsIterator)->getAgilityBoost();
      double dexterityBoost = (*potionsIterator)->getDexterityBoost();
      
      if (strengthBoost != 0.0) {
	this->strength /= strengthBoost + 1.0;
      }

      if (agilityBoost != 0.0) {
	this->agility /= agilityBoost + 1.0;
      }

      if (dexterityBoost != 0.0) {
	this->dexterity = dexterityBoost + 1.0;
      }      

      // Rounding up 1 digit (It's like calling ceil())
      this->strength += (strengthBoost == 0.0) ? 0 : 1;
      this->dexterity += (dexterityBoost == 0.0) ? 0 : 1;

      list<Potion*> :: iterator temp = potionsIterator++;
      delete (*temp);
      potions.erase(temp);
    }    
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x78(%rdi), %r14
movq %r14, %r15
movq (%r15), %r15
cmpq %r14, %r15
je 0xf8d4
movq 0x10(%r15), %rdi
callq 0x14160
movq 0x10(%r15), %rdi
callq 0x1415c
cmpl $-0x1, %eax
jne 0xf7d3
movq 0x10(%r15), %rdi
callq 0x14156
movsd %xmm0, 0x8(%rsp)
movq 0x10(%r15), %rdi
callq 0x1414a
movsd %xmm0, 0x10(%rsp)
movq 0x10(%r15), %rdi
callq 0x14150
movsd 0x8(%rsp), %xmm5
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm5
movsd 0x650d(%rip), %xmm4     # 0x15d40
jne 0xf837
jnp 0xf855
movapd %xmm5, %xmm1
addsd %xmm4, %xmm1
cvtsi2sdl 0x98(%rbx), %xmm2
divsd %xmm1, %xmm2
cvttsd2si %xmm2, %eax
movl %eax, 0x98(%rbx)
movsd 0x10(%rsp), %xmm2
ucomisd %xmm3, %xmm2
jne 0xf863
jnp 0xf87b
addsd %xmm4, %xmm2
movsd 0xa0(%rbx), %xmm1
divsd %xmm2, %xmm1
movsd %xmm1, 0xa0(%rbx)
movapd %xmm0, %xmm1
addsd %xmm4, %xmm1
cvttsd2si %xmm1, %eax
cmpneqsd %xmm3, %xmm5
movq %xmm5, %rcx
subl %ecx, 0x98(%rbx)
incl %eax
ucomisd %xmm3, %xmm0
movl 0xa8(%rbx), %ecx
cmovnel %eax, %ecx
cmovpl %eax, %ecx
movl %ecx, 0xa8(%rbx)
movq (%r15), %r12
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0xf8c1
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1268e
movq %r12, %r15
jmp 0xf7d3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::levelUp()
void Hero::levelUp() {
	level++;			// These are common for all Heroes.
	strength += 10;
	agility += 10;
	dexterity += 10;
	magicPower += 5;
}

// Assembly:
incl 0x10(%rdi)
movsd 0xa0(%rdi), %xmm0
addsd 0x6455(%rip), %xmm0     # 0x15d48
movsd %xmm0, 0xa0(%rdi)
addl $0xa, 0xa8(%rdi)
movq 0x94(%rdi), %xmm0
paddd 0x641e(%rip), %xmm0     # 0x15d30
movq %xmm0, 0x94(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::operator==(Hero const&) const
bool Hero :: operator==(const Hero& rValue) const {
  bool sameLiving;
  bool sameMagicPower;
  bool sameStrength;
  bool sameAgility;
  bool sameDexterity;
  bool sameMoney;
  bool sameExperience;
  sameLiving = Living::operator==(rValue);
  sameMagicPower = (this->magicPower == rValue.magicPower) ? true : false;
  sameStrength = (this->strength == rValue.strength) ? true : false;
  sameAgility = (this->agility == rValue.agility) ? true : false;
  sameDexterity = (this->dexterity == rValue.dexterity) ? true : false;
  sameMoney = (this->money == rValue.money) ? true : false;
  sameExperience = (this->expirience == rValue.expirience) ? true : false;

  return (sameLiving && sameMagicPower &&
	  sameStrength && sameDexterity &&
	  sameAgility && sameMoney &&
	  sameExperience);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x12a7e
testb %al, %al
je 0xf99a
movl 0xb0(%rbx), %eax
xorl 0xb0(%r14), %eax
movdqu 0xa8(%r14), %xmm0
movdqu 0xa8(%rbx), %xmm1
movsd 0xa0(%r14), %xmm2
ucomisd 0xa0(%rbx), %xmm2
setnp %cl
sete %dl
andb %cl, %dl
movdqu 0x94(%r14), %xmm2
punpcklqdq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0]
movdqu 0x94(%rbx), %xmm0
punpcklqdq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0]
pcmpeqd %xmm2, %xmm0
movmskps %xmm0, %ecx
xorl $0xf, %ecx
orl %eax, %ecx
sete %al
andb %dl, %al
jmp 0xf99c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::moveUp()
void Hero :: moveUp() {
  int heroY = this->getPosition().getY();
  int heroX = this->getPosition().getX();

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x12af8
movq %rax, %rdi
callq 0x12b0a
movl %eax, %r14d
movq %rbx, %rdi
callq 0x12af8
movq %rax, %rdi
callq 0x12b06
movl %eax, %ebp
movq 0x8(%rbx), %rdi
callq 0x5cfa
decl %eax
cmpl %eax, %r14d
je 0xfa44
movq 0x8(%rbx), %rdi
leal 0x1(%r14), %r15d
movl %r15d, %esi
movl %ebp, %edx
callq 0x5d58
movq %rax, %rdi
callq 0x5b82
testb %al, %al
jne 0xfa8f
movq 0x8(%rbx), %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x5dd6
movq %rbx, %rdi
callq 0x12af8
movq %rax, %rdi
movl %r15d, %esi
callq 0x12b12
movq 0x8(%rbx), %rdi
movl %r15d, %esi
movl %ebp, %edx
movq %rbx, %rcx
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5d70
pushq $0x28
popq %rdi
callq 0x4130
movq %rax, %rbx
leaq 0x639b(%rip), %rsi      # 0x15df1
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4a58
xorl %ebp, %ebp
leaq 0x10bca(%rip), %rsi     # 0x20648
leaq -0xaff7(%rip), %rdx     # 0x4a8e
movq %rbx, %rdi
callq 0x43f0
jmp 0xfad8
pushq $0x28
popq %rdi
callq 0x4130
movq %rax, %rbx
leaq 0x636e(%rip), %rsi      # 0x15e0f
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4a58
xorl %ebp, %ebp
leaq 0x10b7f(%rip), %rsi     # 0x20648
leaq -0xb042(%rip), %rdx     # 0x4a8e
movq %rbx, %rdi
callq 0x43f0
jmp 0xfadc
jmp 0xfaf0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4470
testb %bpl, %bpl
jne 0xfaf3
jmp 0xfafb
movq %rax, %r14
movq %rbx, %rdi
callq 0x41d0
movq %r14, %rdi
callq 0x4410
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::moveDown()
void Hero :: moveDown() {
  int heroY = this->getPosition().getY();
  int heroX = this->getPosition().getX();
 
  if (heroY == 0) {
    throw HeroMoveException("You can't  down any further");
  } else if (this->grid->getTile(heroY - 1, heroX).isNonAccessible()) {
    throw HeroMoveException("You can't move in a non accessible tile");
  } else {
    this->grid->removeLiving(heroY, heroX, this);
    this->getPosition().setY(heroY - 1);
    this->grid->addLiving(heroY - 1, heroX, this);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x12af8
movq %rax, %rdi
callq 0x12b0a
movl %eax, %r14d
movq %rbx, %rdi
callq 0x12af8
movq %rax, %rdi
callq 0x12b06
testl %r14d, %r14d
je 0xfb99
movl %eax, %ebp
movq 0x8(%rbx), %rdi
leal -0x1(%r14), %r15d
movl %r15d, %esi
movl %eax, %edx
callq 0x5d58
movq %rax, %rdi
callq 0x5b82
testb %al, %al
jne 0xfbe4
movq 0x8(%rbx), %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x5dd6
movq %rbx, %rdi
callq 0x12af8
movq %rax, %rdi
movl %r15d, %esi
callq 0x12b12
movq 0x8(%rbx), %rdi
movl %r15d, %esi
movl %ebp, %edx
movq %rbx, %rcx
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5d70
pushq $0x28
popq %rdi
callq 0x4130
movq %rax, %rbx
leaq 0x628c(%rip), %rsi      # 0x15e37
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4a58
xorl %ebp, %ebp
leaq 0x10a75(%rip), %rsi     # 0x20648
leaq -0xb14c(%rip), %rdx     # 0x4a8e
movq %rbx, %rdi
callq 0x43f0
jmp 0xfc2d
pushq $0x28
popq %rdi
callq 0x4130
movq %rax, %rbx
leaq 0x6219(%rip), %rsi      # 0x15e0f
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4a58
xorl %ebp, %ebp
leaq 0x10a2a(%rip), %rsi     # 0x20648
leaq -0xb197(%rip), %rdx     # 0x4a8e
movq %rbx, %rdi
callq 0x43f0
jmp 0xfc31
jmp 0xfc45
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4470
testb %bpl, %bpl
jne 0xfc48
jmp 0xfc50
movq %rax, %r14
movq %rbx, %rdi
callq 0x41d0
movq %r14, %rdi
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::moveLeft()
void Hero :: moveLeft() {
  int heroY = this->getPosition().getY();
  int heroX = this->getPosition().getX();

  if (heroX == 0) {
    throw HeroMoveException("You can't move left 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 0x12af8
movq %rax, %rdi
callq 0x12b0a
movl %eax, %ebp
movq %rbx, %rdi
callq 0x12af8
movq %rax, %rdi
callq 0x12b06
testl %eax, %eax
je 0xfcec
movl %eax, %r15d
movq 0x8(%rbx), %rdi
leal -0x1(%r15), %r14d
movl %ebp, %esi
movl %r14d, %edx
callq 0x5d58
movq %rax, %rdi
callq 0x5b82
testb %al, %al
jne 0xfd37
movq 0x8(%rbx), %rdi
movl %ebp, %esi
movl %r15d, %edx
movq %rbx, %rcx
callq 0x5dd6
movq %rbx, %rdi
callq 0x12af8
movq %rax, %rdi
movl %r14d, %esi
callq 0x12b0e
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 0x5d70
pushq $0x28
popq %rdi
callq 0x4130
movq %rax, %rbx
leaq 0x6155(%rip), %rsi      # 0x15e53
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4a58
xorl %ebp, %ebp
leaq 0x10922(%rip), %rsi     # 0x20648
leaq -0xb29f(%rip), %rdx     # 0x4a8e
movq %rbx, %rdi
callq 0x43f0
jmp 0xfd80
pushq $0x28
popq %rdi
callq 0x4130
movq %rax, %rbx
leaq 0x60c6(%rip), %rsi      # 0x15e0f
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4a58
xorl %ebp, %ebp
leaq 0x108d7(%rip), %rsi     # 0x20648
leaq -0xb2ea(%rip), %rdx     # 0x4a8e
movq %rbx, %rdi
callq 0x43f0
jmp 0xfd84
jmp 0xfd98
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4470
testb %bpl, %bpl
jne 0xfd9b
jmp 0xfda3
movq %rax, %r14
movq %rbx, %rdi
callq 0x41d0
movq %r14, %rdi
callq 0x4410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x12af8
movq %rax, %rdi
callq 0x12b0a
movl %eax, %ebp
movq %rbx, %rdi
callq 0x12af8
movq %rax, %rdi
callq 0x12b06
movl %eax, %r15d
movq 0x8(%rbx), %rdi
callq 0x5cf6
cmpl %eax, %r15d
je 0xfe4a
movq 0x8(%rbx), %rdi
leal 0x1(%r15), %r14d
movl %ebp, %esi
movl %r14d, %edx
callq 0x5d58
movq %rax, %rdi
callq 0x5b82
testb %al, %al
jne 0xfe95
movq 0x8(%rbx), %rdi
movl %ebp, %esi
movl %r15d, %edx
movq %rbx, %rcx
callq 0x5dd6
movq %rbx, %rdi
callq 0x12af8
movq %rax, %rdi
movl %r14d, %esi
callq 0x12b0e
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 0x5d70
pushq $0x28
popq %rdi
callq 0x4130
movq %rax, %rbx
leaq 0x6017(%rip), %rsi      # 0x15e73
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4a58
xorl %ebp, %ebp
leaq 0x107c4(%rip), %rsi     # 0x20648
leaq -0xb3fd(%rip), %rdx     # 0x4a8e
movq %rbx, %rdi
callq 0x43f0
jmp 0xfede
pushq $0x28
popq %rdi
callq 0x4130
movq %rax, %rbx
leaq 0x5f68(%rip), %rsi      # 0x15e0f
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4a58
xorl %ebp, %ebp
leaq 0x10779(%rip), %rsi     # 0x20648
leaq -0xb448(%rip), %rdx     # 0x4a8e
movq %rbx, %rdi
callq 0x43f0
jmp 0xfee2
jmp 0xfef6
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4470
testb %bpl, %bpl
jne 0xfef9
jmp 0xff01
movq %rax, %r14
movq %rbx, %rdi
callq 0x41d0
movq %r14, %rdi
callq 0x4410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
cmpl $0x3, %esi
ja 0xff5d
movl %esi, %eax
leaq 0x5e30(%rip), %rcx      # 0x15d50
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xf9a4
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xfc58
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xfdac
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xfb04
pushq $0x28
popq %rdi
callq 0x4130
movq %rax, %rbx
leaq 0x5f25(%rip), %rsi      # 0x15e94
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x578c
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4a58
xorl %ebp, %ebp
leaq 0x106b1(%rip), %rsi     # 0x20648
leaq -0xb510(%rip), %rdx     # 0x4a8e
movq %rbx, %rdi
callq 0x43f0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x4470
testb %bpl, %bpl
jne 0xffbd
jmp 0xffc5
movq %rax, %r14
movq %rbx, %rdi
callq 0x41d0
movq %r14, %rdi
callq 0x4410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10fe4(%rip), %rdi     # 0x20fc0
movq %rdx, %rsi
callq 0x4220
movq %rax, %rdi
callq 0x4120
movq %rax, %rdi
callq 0x4120
leaq 0x5041(%rip), %rsi      # 0x1503c
movq %rax, %rdi
callq 0x4250
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq 0x10fb6(%rip), %rdi     # 0x20fd0
movq %rbx, %rsi
callq 0x4060
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4470
movq %r14, %rdi
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::equip(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Hero :: equip(const string& name) {
  Item* itemToEquip = inventory.getItemByName(name);

  if (itemToEquip != NULL) {
    string kind = itemToEquip->kindOf();

    if (kind == "Weapon") {
      Weapon* weaponToEquip = static_cast<Weapon*>(itemToEquip);
      this->equipWeapon(weaponToEquip);
    } else if (kind == "Armor") {
      Armor* armorToEquip = static_cast<Armor*>(itemToEquip);
      this->equipArmor(armorToEquip);

    } else if (kind == "Potion") {
      cout << endl << "You can't equip a potion" << endl;
      return false;
    }
    this->inventory.removeItem(itemToEquip);
    return true;
  }

  Spell* spellToEquip = inventory.getSpellByName(name);

  if (spellToEquip != NULL) {
    this->equipSpell(spellToEquip);
    this->inventory.removeSpell(spellToEquip);
    return true;
  }

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r12
movq %rdi, %r15
leaq 0xc0(%rdi), %rbx
movq %rbx, %rdi
callq 0xb8e4
testq %rax, %rax
je 0x1009b
movq %rax, %r14
movq (%rax), %rax
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq *0x18(%rax)
leaq 0x5b23(%rip), %rsi      # 0x15ba2
movq %r12, %rdi
callq 0x5b02
testb %al, %al
je 0x100cd
movq %r15, %rdi
movq %r14, %rsi
callq 0x1018a
jmp 0x10127
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb94c
testq %rax, %rax
je 0x1014c
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0x10392
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb8a6
movb $0x1, %bpl
jmp 0x1013d
leaq 0x5ad5(%rip), %rsi      # 0x15ba9
movq %rsp, %rdi
callq 0x5b02
testb %al, %al
je 0x100ed
movq %r15, %rdi
movq %r14, %rsi
callq 0x10366
jmp 0x10127
leaq 0x5e33(%rip), %rsi      # 0x15f27
movq %rsp, %rdi
callq 0x5b02
testb %al, %al
je 0x10127
movq 0x10eb9(%rip), %rdi     # 0x20fc0
callq 0x4120
leaq 0x5d93(%rip), %rsi      # 0x15ea6
movq %rax, %rdi
callq 0x4250
movq %rax, %rdi
callq 0x4120
xorl %ebp, %ebp
jmp 0x10135
movb $0x1, %bpl
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb86e
movq %rsp, %rdi
callq 0x4470
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x10e6d(%rip), %rdi     # 0x20fc0
callq 0x4120
leaq 0x5d60(%rip), %rsi      # 0x15ebf
movq %rax, %rdi
callq 0x4250
movq %rax, %rdi
callq 0x4120
xorl %ebp, %ebp
jmp 0x1013d
jmp 0x10177
jmp 0x10177
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4470
movq %rbx, %rdi
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb8e4
testq %rax, %rax
je 0x103d7
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb7be
jmp 0x103f2
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb94c
testq %rax, %rax
je 0x103fc
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb816
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x10bbd(%rip), %rdi     # 0x20fc0
callq 0x4120
leaq 0x5ab0(%rip), %rsi      # 0x15ebf
movq %rax, %rdi
callq 0x4250
movq %rax, %rdi
callq 0x4120
xorl %eax, %eax
jmp 0x103f4
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x30, %rsp
movq %rdi, %r14
leaq 0xc0(%rdi), %r15
movq %r15, %rdi
callq 0xb8e4
movq %rax, %rbx
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x10493
movq (%rbx), %rax
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
leaq 0x5ac0(%rip), %rsi      # 0x15f27
movq %r12, %rdi
callq 0x5808
movl %eax, %ebp
movq %r12, %rdi
callq 0x4470
testb %bpl, %bpl
je 0x104bb
movq 0x10b3b(%rip), %rdi     # 0x20fc0
callq 0x4120
leaq 0x5a78(%rip), %rsi      # 0x15f09
jmp 0x104a6
movq 0x10b26(%rip), %rdi     # 0x20fc0
callq 0x4120
leaq 0x5a49(%rip), %rsi      # 0x15eef
movq %rax, %rdi
callq 0x4250
movq %rax, %rdi
callq 0x4120
jmp 0x1054d
leaq 0x78(%r14), %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
callq 0x1269c
movq (%r12), %rsi
movq %r15, %rdi
callq 0xb86e
movq (%r12), %rdi
callq 0x14156
addsd 0x5857(%rip), %xmm0     # 0x15d40
cvtsi2sdl 0x98(%r14), %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, 0x98(%r14)
movq (%r12), %rdi
callq 0x1414a
addsd 0x582e(%rip), %xmm0     # 0x15d40
mulsd 0xa0(%r14), %xmm0
movsd %xmm0, 0xa0(%r14)
movq (%r12), %rdi
callq 0x14150
addsd 0x580b(%rip), %xmm0     # 0x15d40
cvtsi2sdl 0xa8(%r14), %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, 0xa8(%r14)
testq %rbx, %rbx
setne %al
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb8e4
testq %rax, %rax
je 0x10c4a
movq %rax, %r15
movq 0x1040c(%rip), %rdi     # 0x20fc0
callq 0x4120
leaq 0x54f3(%rip), %rsi      # 0x160b3
movq %rax, %rdi
callq 0x4250
movq %rax, %rdi
movq %r12, %rsi
callq 0x4220
leaq 0x54b1(%rip), %rsi      # 0x1608b
movq %rax, %rdi
callq 0x4250
movq %rax, %r12
movq (%r15), %rax
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq *0x18(%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x4220
leaq 0x49b3(%rip), %rsi      # 0x155bb
movq %rax, %rdi
callq 0x4250
leaq 0x8(%rsp), %rdi
callq 0x4470
movq %r14, %rdi
movq %r15, %rsi
callq 0xb7be
movl 0xac(%rbx), %ebp
movq %r15, %rdi
callq 0x14596
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 0xb94c
movq %rax, %rbx
movq 0x10361(%rip), %rdi     # 0x20fc0
callq 0x4120
testq %rbx, %rbx
jne 0x10c8e
leaq 0x541e(%rip), %rsi      # 0x1608e
movq %rax, %rdi
callq 0x4250
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4120
leaq 0x541e(%rip), %rsi      # 0x160b3
movq %rax, %rdi
callq 0x4250
movq %rax, %rdi
movq %r12, %rsi
callq 0x4220
leaq 0x53dc(%rip), %rsi      # 0x1608b
movq %rax, %rdi
callq 0x4250
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4470
movq %rbx, %rdi
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, %r15
addq $0x60, %r15
xorl %ebx, %ebx
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x10fe0
movq 0x10(%r12), %rdi
callq 0xed62
movq %rax, %rdi
movq %r14, %rsi
callq 0x57df
testb %al, %al
je 0x10fb9
movq 0x10(%r12), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x113c4
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %r14
andq $0x0, 0x10(%r14)
leaq 0x30(%rsp), %rax
andq $0x0, 0x10(%rax)
movaps %xmm0, (%r14)
movaps %xmm0, (%rax)
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
leaq 0x68(%rsp), %r13
leaq 0x494e(%rip), %rbp      # 0x15c32
leaq 0x8(%rsp), %r12
cmpq %rbx, %r15
je 0x11388
movq 0x10(%r15), %rsi
movq (%rsi), %rax
movq %r13, %rdi
callq *0x18(%rax)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x5b02
testb %al, %al
je 0x11324
movq 0x10(%r15), %rax
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0xc390
jmp 0x11378
movq %r13, %rdi
leaq 0x490d(%rip), %rsi      # 0x15c3b
callq 0x5b02
testb %al, %al
je 0x1134f
movq 0x10(%r15), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
movq %r12, %rsi
callq 0xc50c
jmp 0x11378
movq %r13, %rdi
leaq 0x48ec(%rip), %rsi      # 0x15c45
callq 0x5b02
testb %al, %al
je 0x11378
movq 0x10(%r15), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0xc688
movq %r13, %rdi
callq 0x4470
movq (%r15), %r15
jmp 0x112e9
leaq 0x50(%rsp), %rsi
callq 0x120d6
leaq 0x30(%rsp), %rsi
callq 0x11dfa
leaq 0x10(%rsp), %rsi
callq 0x123b2
leaq 0x10(%rsp), %rdi
callq 0xc35c
leaq 0x30(%rsp), %rdi
callq 0xc328
leaq 0x50(%rsp), %rdi
callq 0xc2f4
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x113eb
jmp 0x113dc
jmp 0x113dc
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x4470
jmp 0x113ee
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc35c
leaq 0x30(%rsp), %rdi
callq 0xc328
leaq 0x50(%rsp), %rdi
callq 0xc2f4
movq %rbx, %rdi
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4acc
movq %rbx, %rdi
callq 0x12bfc
callq 0x4b00
testb %al, %al
je 0x11464
movq 0xfb7a(%rip), %rdi      # 0x20fc0
callq 0x4120
leaq 0x4dd5(%rip), %rsi      # 0x16227
movq %rax, %rdi
callq 0x4250
movq %rax, %rdi
callq 0x4120
jmp 0x114b4
movl 0x98(%r14), %ebp
movq 0x48(%r14), %rdi
testq %rdi, %rdi
je 0x1147b
callq 0x13a5c
addl %eax, %ebp
movq 0x50(%r14), %rdi
testq %rdi, %rdi
je 0x1148b
callq 0x13a5c
addl %eax, %ebp
movq %rbx, %rdi
callq 0x12bf6
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
nop