LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x14bf0
cmpl $0x0, %eax
jne 0x17156
movq 0x28e87(%rip), %rdi     # 0x3ffc0
leaq 0x17b1b(%rip), %rsi     # 0x2ec5b
callq 0x52f0
movq %rax, %rdi
movq 0x28e51(%rip), %rsi     # 0x3ffa0
callq 0x5330
jmp 0x1717f
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq -0x10(%rbp), %rsi
callq 0x184a0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1717f
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x14bf0
cmpl $0x0, %eax
jne 0x171d6
movq 0x28e07(%rip), %rdi     # 0x3ffc0
leaq 0x17abb(%rip), %rsi     # 0x2ec7b
callq 0x52f0
movq %rax, %rdi
movq 0x28dd1(%rip), %rsi     # 0x3ffa0
callq 0x5330
jmp 0x171ff
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
leaq -0x10(%rbp), %rsi
callq 0x18580
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x171ff
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x14bf0
cmpl $0x0, %eax
jne 0x17256
movq 0x28d87(%rip), %rdi     # 0x3ffc0
leaq 0x17a1b(%rip), %rsi     # 0x2ec5b
callq 0x52f0
movq %rax, %rdi
movq 0x28d51(%rip), %rsi     # 0x3ffa0
callq 0x5330
jmp 0x17267
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq -0x10(%rbp), %rsi
callq 0x184a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x14bf0
cmpl $0x0, %eax
jne 0x172b6
movq 0x28d27(%rip), %rdi     # 0x3ffc0
leaq 0x179bb(%rip), %rsi     # 0x2ec5b
callq 0x52f0
movq %rax, %rdi
movq 0x28cf1(%rip), %rsi     # 0x3ffa0
callq 0x5330
jmp 0x172c7
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
leaq -0x10(%rbp), %rsi
callq 0x18580
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x8, %rdi
callq 0x17bd0
movq %rax, -0x20(%rbp)
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
callq 0x17c30
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x17c00
testb $0x1, %al
jne 0x17339
jmp 0x17395
leaq -0x20(%rbp), %rdi
callq 0x17c60
movq (%rax), %rsi
leaq -0x48(%rbp), %rdi
callq 0x2d510
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x7e80
movb %al, -0x59(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x55d0
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x17370
jmp 0x17382
leaq -0x20(%rbp), %rdi
callq 0x17c60
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1739d
jmp 0x17384
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x17c90
movq %rax, -0x50(%rbp)
jmp 0x17315
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x20, %rdi
callq 0x18660
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
callq 0x18690
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x181c0
testb $0x1, %al
jne 0x173f9
jmp 0x17441
leaq -0x20(%rbp), %rdi
callq 0x18220
movq (%rax), %rdi
callq 0x21a30
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x7e80
testb $0x1, %al
jne 0x1741c
jmp 0x1742e
leaq -0x20(%rbp), %rdi
callq 0x18220
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x17449
jmp 0x17430
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x186c0
movq %rax, -0x30(%rbp)
jmp 0x173d5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x17a50
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1db7e
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x17a70
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x1db6f
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x17aa0
jmp 0x1db34
jmp 0x1db80
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x17ad0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1dbca
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x17af0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1dbbb
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x17b20
jmp 0x1db80
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x20170
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x17a10
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x17a30
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x1dc10
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x1ff99
movq 0x20044(%rip), %rdi     # 0x3ffc0
leaq 0xed4a(%rip), %rsi      # 0x2eccd
callq 0x52f0
movq %rax, %rdi
movq 0x2000e(%rip), %rsi     # 0x3ffa0
callq 0x5330
jmp 0x1ffaa
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq -0x10(%rbp), %rsi
callq 0x18420
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x1dc10
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x1fff9
movq 0x1ffe4(%rip), %rdi     # 0x3ffc0
leaq 0xecea(%rip), %rsi      # 0x2eccd
callq 0x52f0
movq %rax, %rdi
movq 0x1ffae(%rip), %rsi     # 0x3ffa0
callq 0x5330
jmp 0x2000a
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
leaq -0x10(%rbp), %rsi
callq 0x18460
addq $0x20, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x8, %rdi
callq 0x17da0
movq %rax, -0x20(%rbp)
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
callq 0x17e50
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x186f0
testb $0x1, %al
jne 0x20059
jmp 0x200af
leaq -0x20(%rbp), %rdi
callq 0x18720
movq (%rax), %rsi
leaq -0x48(%rbp), %rdi
callq 0x2d510
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x7e80
movb %al, -0x51(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x55d0
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x20090
jmp 0x200a2
leaq -0x20(%rbp), %rdi
callq 0x18720
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x200b7
jmp 0x200a4
leaq -0x20(%rbp), %rdi
callq 0x18740
jmp 0x20035
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x20, %rdi
callq 0x18110
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0x181f0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1d6a0
testb $0x1, %al
jne 0x20119
jmp 0x2015b
leaq -0x20(%rbp), %rdi
callq 0x19190
movq (%rax), %rdi
callq 0x21a30
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x7e80
testb $0x1, %al
jne 0x2013c
jmp 0x2014e
leaq -0x20(%rbp), %rdi
callq 0x19190
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x20163
jmp 0x20150
leaq -0x20(%rbp), %rdi
callq 0x1d6d0
jmp 0x200f5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x21aa0
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, -0x11(%rbp)
movsd 0x48(%rax), %xmm0
movq -0x10(%rbp), %rcx
movsd 0x48(%rcx), %xmm1
ucomisd %xmm1, %xmm0
setnp %dl
sete %cl
andb %dl, %cl
movb %cl, -0x12(%rbp)
movl 0x50(%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x50(%rcx), %ecx
subl %ecx, %eax
sete %al
negb %al
andb $0x1, %al
movb %al, -0x13(%rbp)
xorl %eax, %eax
testb $0x1, -0x11(%rbp)
movb %al, -0x14(%rbp)
je 0x20879
xorl %eax, %eax
testb $0x1, -0x12(%rbp)
movb %al, -0x14(%rbp)
je 0x20879
movb -0x13(%rbp), %al
movb %al, -0x14(%rbp)
movb -0x14(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x7e80
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, -0x11(%rbp)
movl 0x30(%rax), %ecx
movq -0x10(%rbp), %rdx
movl 0x30(%rdx), %edx
subl %edx, %ecx
sete -0x12(%rbp)
movl 0x34(%rax), %ecx
movq -0x10(%rbp), %rdx
movl 0x34(%rdx), %edx
subl %edx, %ecx
sete -0x13(%rbp)
movl 0x38(%rax), %ecx
movq -0x10(%rbp), %rdx
movl 0x38(%rdx), %edx
subl %edx, %ecx
sete -0x14(%rbp)
movl 0x3c(%rax), %ecx
movq -0x10(%rbp), %rdx
movl 0x3c(%rdx), %edx
subl %edx, %ecx
sete -0x15(%rbp)
movl 0x40(%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x40(%rcx), %ecx
subl %ecx, %eax
sete %al
negb %al
andb $0x1, %al
movb %al, -0x16(%rbp)
xorl %eax, %eax
testb $0x1, -0x11(%rbp)
movb %al, -0x17(%rbp)
je 0x21b65
xorl %eax, %eax
testb $0x1, -0x12(%rbp)
movb %al, -0x17(%rbp)
je 0x21b65
xorl %eax, %eax
testb $0x1, -0x13(%rbp)
movb %al, -0x17(%rbp)
je 0x21b65
xorl %eax, %eax
testb $0x1, -0x14(%rbp)
movb %al, -0x17(%rbp)
je 0x21b65
xorl %eax, %eax
testb $0x1, -0x15(%rbp)
movb %al, -0x17(%rbp)
je 0x21b65
movb -0x16(%rbp), %al
movb %al, -0x17(%rbp)
movb -0x17(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x1db05(%rip), %rcx     # 0x3f8d0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x21dea
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x21e06
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x21e22
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x21e24
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
callq 0x17ad0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x21e6e
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
callq 0x17af0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x21e5f
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
callq 0x17b20
jmp 0x21e24
movq -0x18(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0x28670
movq -0x18(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
callq 0x28690
movq -0x18(%rbp), %rdi
addq $0xc0, %rdi
callq 0x14b00
movq -0x18(%rbp), %rdi
addq $0x78, %rdi
callq 0x286b0
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
callq 0x17a10
movq -0x18(%rbp), %rdi
callq 0x29850
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
cmpq $0x0, 0x58(%rax)
je 0x2201a
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x2c4c0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movl 0x98(%rax), %ecx
addl $0xa, %ecx
movl %ecx, 0x98(%rax)
movsd 0xb9e4(%rip), %xmm0     # 0x2ed20
addsd 0xa0(%rax), %xmm0
movsd %xmm0, 0xa0(%rax)
movl 0xa8(%rax), %ecx
addl $0xa, %ecx
movl %ecx, 0xa8(%rax)
movl 0x94(%rax), %ecx
addl $0x5, %ecx
movl %ecx, 0x94(%rax)
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x29990
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, -0x11(%rbp)
movl 0x94(%rax), %ecx
movq -0x10(%rbp), %rdx
movl 0x94(%rdx), %edx
subl %edx, %ecx
sete -0x12(%rbp)
movl 0x98(%rax), %ecx
movq -0x10(%rbp), %rdx
movl 0x98(%rdx), %edx
subl %edx, %ecx
sete -0x13(%rbp)
movsd 0xa0(%rax), %xmm0
movq -0x10(%rbp), %rcx
movsd 0xa0(%rcx), %xmm1
ucomisd %xmm1, %xmm0
setnp %dl
sete %cl
andb %dl, %cl
movb %cl, -0x14(%rbp)
movl 0xa8(%rax), %ecx
movq -0x10(%rbp), %rdx
movl 0xa8(%rdx), %edx
subl %edx, %ecx
sete -0x15(%rbp)
movl 0xac(%rax), %ecx
movq -0x10(%rbp), %rdx
movl 0xac(%rdx), %edx
subl %edx, %ecx
sete -0x16(%rbp)
movl 0xb0(%rax), %eax
movq -0x10(%rbp), %rcx
movl 0xb0(%rcx), %ecx
subl %ecx, %eax
sete %al
negb %al
andb $0x1, %al
movb %al, -0x17(%rbp)
xorl %eax, %eax
testb $0x1, -0x11(%rbp)
movb %al, -0x18(%rbp)
je 0x23499
xorl %eax, %eax
testb $0x1, -0x12(%rbp)
movb %al, -0x18(%rbp)
je 0x23499
xorl %eax, %eax
testb $0x1, -0x13(%rbp)
movb %al, -0x18(%rbp)
je 0x23499
xorl %eax, %eax
testb $0x1, -0x15(%rbp)
movb %al, -0x18(%rbp)
je 0x23499
xorl %eax, %eax
testb $0x1, -0x14(%rbp)
movb %al, -0x18(%rbp)
je 0x23499
xorl %eax, %eax
testb $0x1, -0x16(%rbp)
movb %al, -0x18(%rbp)
je 0x23499
movb -0x17(%rbp), %al
movb %al, -0x18(%rbp)
movb -0x18(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x29a80
movq %rax, %rdi
callq 0x29ae0
movq -0x78(%rbp), %rdi
movl %eax, -0xc(%rbp)
callq 0x29a80
movq %rax, %rdi
callq 0x29ad0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x237f7
movb $0x1, -0x45(%rbp)
movl $0x28, %edi
callq 0x5150
movq %rax, -0x88(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x5560
movq -0x80(%rbp), %rdx
leaq 0xb69d(%rip), %rsi      # 0x2ee0f
leaq -0x30(%rbp), %rdi
callq 0x7d20
jmp 0x2377d
movq -0x88(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5e70
jmp 0x2378f
movq -0x88(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x1be97(%rip), %rsi     # 0x3f638
leaq -0x1d8d8(%rip), %rdx    # 0x5ed0
callq 0x5530
jmp 0x23927
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x237d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x55d0
leaq -0x31(%rbp), %rdi
callq 0x5350
testb $0x1, -0x45(%rbp)
jne 0x237e6
jmp 0x237f2
movq -0x88(%rbp), %rdi
callq 0x5220
jmp 0x2391e
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
subl $0x1, %esi
movl -0x10(%rbp), %edx
callq 0x9340
movq %rax, %rdi
callq 0x8f30
testb $0x1, %al
jne 0x2381e
jmp 0x238d3
movb $0x1, -0x6a(%rbp)
movl $0x28, %edi
callq 0x5150
movq %rax, -0x98(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x5560
movq -0x90(%rbp), %rdx
leaq 0xb596(%rip), %rsi      # 0x2ede7
leaq -0x68(%rbp), %rdi
callq 0x7d20
jmp 0x2385c
movq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5e70
jmp 0x2386e
movq -0x98(%rbp), %rdi
movb $0x0, -0x6a(%rbp)
leaq 0x1bdb8(%rip), %rsi     # 0x3f638
leaq -0x1d9b7(%rip), %rdx    # 0x5ed0
callq 0x5530
jmp 0x23927
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x238b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x55d0
leaq -0x69(%rbp), %rdi
callq 0x5350
testb $0x1, -0x6a(%rbp)
jne 0x238c5
jmp 0x238d1
movq -0x98(%rbp), %rdi
callq 0x5220
jmp 0x2391e
movq -0x78(%rbp), %rcx
movq 0x8(%rcx), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x94d0
movq -0x78(%rbp), %rdi
callq 0x29a80
movq %rax, %rdi
movl -0xc(%rbp), %esi
subl $0x1, %esi
callq 0x29b20
movq -0x78(%rbp), %rcx
movq 0x8(%rcx), %rdi
movl -0xc(%rbp), %esi
subl $0x1, %esi
movl -0x10(%rbp), %edx
callq 0x9380
jmp 0x23915
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x5550
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x29a80
movq %rax, %rdi
callq 0x29ae0
movq -0x78(%rbp), %rdi
movl %eax, -0xc(%rbp)
callq 0x29a80
movq %rax, %rdi
callq 0x29ad0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x23a27
movb $0x1, -0x45(%rbp)
movl $0x28, %edi
callq 0x5150
movq %rax, -0x88(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x5560
movq -0x80(%rbp), %rdx
leaq 0xb489(%rip), %rsi      # 0x2ee2b
leaq -0x30(%rbp), %rdi
callq 0x7d20
jmp 0x239ad
movq -0x88(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5e70
jmp 0x239bf
movq -0x88(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x1bc67(%rip), %rsi     # 0x3f638
leaq -0x1db08(%rip), %rdx    # 0x5ed0
callq 0x5530
jmp 0x23b57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x23a05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x55d0
leaq -0x31(%rbp), %rdi
callq 0x5350
testb $0x1, -0x45(%rbp)
jne 0x23a16
jmp 0x23a22
movq -0x88(%rbp), %rdi
callq 0x5220
jmp 0x23b4e
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
subl $0x1, %edx
callq 0x9340
movq %rax, %rdi
callq 0x8f30
testb $0x1, %al
jne 0x23a4e
jmp 0x23b03
movb $0x1, -0x6a(%rbp)
movl $0x28, %edi
callq 0x5150
movq %rax, -0x98(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x5560
movq -0x90(%rbp), %rdx
leaq 0xb366(%rip), %rsi      # 0x2ede7
leaq -0x68(%rbp), %rdi
callq 0x7d20
jmp 0x23a8c
movq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5e70
jmp 0x23a9e
movq -0x98(%rbp), %rdi
movb $0x0, -0x6a(%rbp)
leaq 0x1bb88(%rip), %rsi     # 0x3f638
leaq -0x1dbe7(%rip), %rdx    # 0x5ed0
callq 0x5530
jmp 0x23b57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x23ae4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x55d0
leaq -0x69(%rbp), %rdi
callq 0x5350
testb $0x1, -0x6a(%rbp)
jne 0x23af5
jmp 0x23b01
movq -0x98(%rbp), %rdi
callq 0x5220
jmp 0x23b4e
movq -0x78(%rbp), %rcx
movq 0x8(%rcx), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x94d0
movq -0x78(%rbp), %rdi
callq 0x29a80
movq %rax, %rdi
movl -0x10(%rbp), %esi
subl $0x1, %esi
callq 0x29b00
movq -0x78(%rbp), %rcx
movq 0x8(%rcx), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
subl $0x1, %edx
callq 0x9380
jmp 0x23b45
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x5550
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x50(%rbp)
subq $0x3, %rax
ja 0x23e10
movq -0x50(%rbp), %rax
leaq 0xaf59(%rip), %rcx      # 0x2ed28
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x58(%rbp), %rdi
callq 0x234b0
jmp 0x23eb0
movq -0x58(%rbp), %rdi
callq 0x23700
jmp 0x23eb0
movq -0x58(%rbp), %rdi
callq 0x23930
jmp 0x23eb0
movq -0x58(%rbp), %rdi
callq 0x23b60
jmp 0x23eb0
movb $0x1, -0x45(%rbp)
movl $0x28, %edi
callq 0x5150
movq %rax, -0x68(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x5560
movq -0x60(%rbp), %rdx
leaq 0xb032(%rip), %rsi      # 0x2ee6c
leaq -0x30(%rbp), %rdi
callq 0x7d20
jmp 0x23e45
movq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5e70
jmp 0x23e54
movq -0x68(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x1b7d5(%rip), %rsi     # 0x3f638
leaq -0x1df9a(%rip), %rdx    # 0x5ed0
callq 0x5530
jmp 0x23ebf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x23e94
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x55d0
leaq -0x31(%rbp), %rdi
callq 0x5350
testb $0x1, -0x45(%rbp)
jne 0x23ea5
jmp 0x23eae
movq -0x68(%rbp), %rdi
callq 0x5220
jmp 0x23eb6
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x5550
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movq 0x1c0d6(%rip), %rdi     # 0x3ffc0
callq 0x52a0
movq %rax, %rdi
movq 0x1c0a7(%rip), %rsi     # 0x3ffa0
movq %rsi, -0x40(%rbp)
callq 0x5330
movq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x5330
movq %rax, %rdi
leaq 0xa124(%rip), %rsi      # 0x2e03c
callq 0x52f0
movq -0x38(%rbp), %rdi
movb $0x0, -0x19(%rbp)
callq 0x5460
movq -0x38(%rbp), %rsi
movq 0x1c0a3(%rip), %rdi     # 0x3ffd8
callq 0x5070
jmp 0x23f3c
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x23f68
jmp 0x23f5f
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x55d0
jmp 0x23f72
movq -0x38(%rbp), %rdi
callq 0x55d0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5550
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0xc0, %rdi
movq -0x18(%rbp), %rsi
callq 0x172f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x244fd
movq -0x30(%rbp), %rdi
addq $0xc0, %rdi
movq -0x20(%rbp), %rsi
callq 0x17110
movb $0x1, -0x1(%rbp)
jmp 0x2456b
movq -0x30(%rbp), %rdi
addq $0xc0, %rdi
movq -0x18(%rbp), %rsi
callq 0x173b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x24536
movq -0x30(%rbp), %rdi
addq $0xc0, %rdi
movq -0x28(%rbp), %rsi
callq 0x17190
movb $0x1, -0x1(%rbp)
jmp 0x2456b
movq 0x1ba83(%rip), %rdi     # 0x3ffc0
movq 0x1ba5c(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, %rdi
leaq 0xa944(%rip), %rsi      # 0x2ee97
callq 0x52f0
movq %rax, %rdi
movq 0x1ba3e(%rip), %rsi     # 0x3ffa0
callq 0x5330
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0xc0, %rdi
movq -0x18(%rbp), %rsi
callq 0x172f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x245ed
movq 0x1ba06(%rip), %rdi     # 0x3ffc0
movq 0x1b9df(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, %rdi
leaq 0xa8f7(%rip), %rsi      # 0x2eec7
callq 0x52f0
movq %rax, %rdi
movq 0x1b9c1(%rip), %rsi     # 0x3ffa0
callq 0x5330
movb $0x0, -0x1(%rbp)
jmp 0x24735
movq -0x20(%rbp), %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq *%rax
movq -0x68(%rbp), %rdi
leaq 0xa8f2(%rip), %rsi      # 0x2eeff
callq 0x7f10
movb %al, -0x59(%rbp)
jmp 0x24617
leaq -0x40(%rbp), %rdi
callq 0x55d0
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x24629
jmp 0x2467d
movq 0x1b990(%rip), %rdi     # 0x3ffc0
movq 0x1b969(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, %rdi
leaq 0xa89b(%rip), %rsi      # 0x2eee1
callq 0x52f0
movq %rax, %rdi
movq 0x1b94b(%rip), %rsi     # 0x3ffa0
callq 0x5330
movb $0x1, -0x1(%rbp)
jmp 0x24735
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x55d0
jmp 0x24740
jmp 0x2467f
movq -0x58(%rbp), %rdi
addq $0x78, %rdi
leaq -0x20(%rbp), %rsi
callq 0x28840
movq -0x58(%rbp), %rdi
addq $0xc0, %rdi
movq -0x20(%rbp), %rsi
callq 0x17210
movq -0x20(%rbp), %rdi
callq 0x2cb60
movq -0x58(%rbp), %rax
movaps %xmm0, %xmm1
movsd 0xa65c(%rip), %xmm0     # 0x2ed18
addsd %xmm0, %xmm1
cvtsi2sdl 0x98(%rax), %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movl %ecx, 0x98(%rax)
movq -0x20(%rbp), %rdi
callq 0x2cb20
movq -0x58(%rbp), %rax
movsd 0xa62d(%rip), %xmm1     # 0x2ed18
addsd %xmm1, %xmm0
mulsd 0xa0(%rax), %xmm0
movsd %xmm0, 0xa0(%rax)
movq -0x20(%rbp), %rdi
callq 0x2cb40
movq -0x58(%rbp), %rax
movaps %xmm0, %xmm1
movsd 0xa601(%rip), %xmm0     # 0x2ed18
addsd %xmm0, %xmm1
cvtsi2sdl 0xa8(%rax), %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movl %ecx, 0xa8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5550
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x60, %rdi
callq 0x18110
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x18140
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
callq 0x181f0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x18140
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x181c0
testb $0x1, %al
jne 0x25e23
jmp 0x25e65
leaq -0x20(%rbp), %rdi
callq 0x18220
movq (%rax), %rdi
callq 0x21a30
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x7e80
testb $0x1, %al
jne 0x25e46
jmp 0x25e58
leaq -0x20(%rbp), %rdi
callq 0x18220
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x25e6d
jmp 0x25e5a
leaq -0x20(%rbp), %rdi
callq 0x182e0
jmp 0x25df2
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x11(%rbp), %rdi
xorl %esi, %esi
callq 0x5f80
movq -0x10(%rbp), %rdi
callq 0x29d10
callq 0x5fe0
testb $0x1, %al
jne 0x265e7
jmp 0x2661d
movq 0x199d2(%rip), %rdi     # 0x3ffc0
movq 0x199ab(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, %rdi
leaq 0x8bfb(%rip), %rsi      # 0x2f1ff
callq 0x52f0
movq %rax, %rdi
movq 0x1998d(%rip), %rsi     # 0x3ffa0
callq 0x5330
jmp 0x266a5
movq -0x28(%rbp), %rax
movl $0x0, -0x18(%rbp)
movl 0x98(%rax), %ecx
addl -0x18(%rbp), %ecx
movl %ecx, -0x18(%rbp)
cmpq $0x0, 0x48(%rax)
je 0x2664e
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2bd20
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x2666c
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x2bd20
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x29cf0
cvtsi2sdl -0x18(%rbp), %xmm2
cvtsi2sdl -0x1c(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
subl -0x1c(%rbp), %esi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x118, %rdi            # imm = 0x118
callq 0x60c0
movq -0x20(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
callq 0x6240
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x267f8
movq -0x20(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
callq 0x61a0
movl -0x14(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x5, %eax
ja 0x267e3
movq -0x28(%rbp), %rax
leaq 0x8625(%rip), %rcx      # 0x2ed64
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x267e3
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x26800
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x26b20
jmp 0x267f8
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x26800
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x26ea0
testb $0x1, %al
jne 0x26796
jmp 0x26798
jmp 0x267f8
jmp 0x267e3
movq -0x20(%rbp), %rdi
callq 0x272b0
testb $0x1, %al
jne 0x267a9
jmp 0x267ab
jmp 0x267f8
jmp 0x267e3
movq -0x20(%rbp), %rdi
callq 0x274d0
testb $0x1, %al
jne 0x267bc
jmp 0x267be
jmp 0x267f8
jmp 0x267e3
callq 0xe390
leaq 0x19b3d(%rip), %rax     # 0x40309
testb $0x1, (%rax)
je 0x267d3
jmp 0x267f8
movq -0x20(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
callq 0x61a0
movq -0x20(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
callq 0x60c0
jmp 0x266f4
addq $0x30, %rsp
popq %rbp
retq
nop
// File: arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::handleUseCase()
bool Hero :: handleUseCase() {
  if (!this->getInventory().hasPotions()) {
    cout << "You have no Potions at the moment." << endl;
    return false;
  }
  inventory.printPotions();
  string name;

  cout << endl
       << "Please enter the name of the potion you want to use"
       << endl << endl << "> ";

  getline(cin, name);        
  for (list<Potion*> :: const_iterator it = potions.begin() ;
       it != potions.end() ; it++ ) {
    if (name == (*it)->getName()) {
      this->use(name);
      return true;
    }
  }

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x23370
movq %rax, %rdi
callq 0x14cd0
testb $0x1, %al
jne 0x27306
movq 0x18cde(%rip), %rdi     # 0x3ffc0
leaq 0x8000(%rip), %rsi      # 0x2f2e9
callq 0x52f0
movq %rax, %rdi
movq 0x18ca8(%rip), %rsi     # 0x3ffa0
callq 0x5330
movb $0x0, -0x1(%rbp)
jmp 0x274b9
movq -0x98(%rbp), %rdi
addq $0xc0, %rdi
callq 0x17460
leaq -0x30(%rbp), %rdi
callq 0x5460
movq 0x18c97(%rip), %rdi     # 0x3ffc0
movq 0x18c70(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, -0xa0(%rbp)
jmp 0x2733e
movq -0xa0(%rbp), %rdi
leaq 0x7c30(%rip), %rsi      # 0x2ef7c
callq 0x52f0
movq %rax, -0xa8(%rbp)
jmp 0x2735a
movq -0xa8(%rbp), %rdi
movq 0x18c38(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, -0xb0(%rbp)
jmp 0x27376
movq -0xb0(%rbp), %rdi
movq 0x18c1c(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, -0xb8(%rbp)
jmp 0x27392
movq -0xb8(%rbp), %rdi
leaq 0x6c9c(%rip), %rsi      # 0x2e03c
callq 0x52f0
jmp 0x273a7
movq 0x18c2a(%rip), %rdi     # 0x3ffd8
leaq -0x30(%rbp), %rsi
callq 0x5070
jmp 0x273b9
movq -0x98(%rbp), %rdi
addq $0x78, %rdi
callq 0x286d0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x28800
movq -0x98(%rbp), %rdi
addq $0x78, %rdi
callq 0x28730
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x28800
leaq -0x48(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x28b50
testb $0x1, %al
jne 0x27411
jmp 0x274a2
leaq -0x48(%rbp), %rdi
callq 0x28b80
movq (%rax), %rsi
leaq -0x80(%rbp), %rdi
callq 0x2d510
jmp 0x27428
leaq -0x30(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x7e80
movb %al, -0xb9(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x55d0
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x27450
jmp 0x27489
movq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x24580
jmp 0x27462
movb $0x1, -0x1(%rbp)
movl $0x1, -0x84(%rbp)
jmp 0x274b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x55d0
jmp 0x274c7
jmp 0x2748b
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x28bb0
movq %rax, -0x90(%rbp)
jmp 0x273da
movb $0x0, -0x1(%rbp)
movl $0x1, -0x84(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x55d0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5550
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x23370
movq %rax, %rdi
callq 0x14c70
testb $0x1, %al
jne 0x2752f
movq 0x18ac4(%rip), %rdi     # 0x3ffc0
movq 0x18a9d(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, %rdi
leaq 0x7dfa(%rip), %rsi      # 0x2f30c
callq 0x52f0
movq %rax, %rdi
movq 0x18a7f(%rip), %rsi     # 0x3ffa0
callq 0x5330
movb $0x0, -0x1(%rbp)
jmp 0x2761b
leaq -0x30(%rbp), %rdi
callq 0x5460
callq 0xe550
jmp 0x2753f
movq -0x48(%rbp), %rdi
addq $0xc0, %rdi
callq 0x17020
jmp 0x27551
movq 0x18a68(%rip), %rdi     # 0x3ffc0
movq 0x18a41(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, -0x50(%rbp)
jmp 0x2756a
movq -0x50(%rbp), %rdi
leaq 0x7dbc(%rip), %rsi      # 0x2f331
callq 0x52f0
movq %rax, -0x58(%rbp)
jmp 0x27580
movq -0x58(%rbp), %rdi
movq 0x18a15(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, -0x60(%rbp)
jmp 0x27596
movq -0x60(%rbp), %rdi
movq 0x189ff(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, -0x68(%rbp)
jmp 0x275ac
movq -0x68(%rbp), %rdi
leaq 0x6a85(%rip), %rsi      # 0x2e03c
callq 0x52f0
jmp 0x275be
movq 0x18a13(%rip), %rdi     # 0x3ffd8
leaq -0x30(%rbp), %rsi
callq 0x5070
jmp 0x275d0
jmp 0x275d2
movq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x23f80
movb %al, -0x69(%rbp)
jmp 0x275e4
movb -0x69(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x27538
movb $0x1, -0x1(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x55d0
jmp 0x2761b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x55d0
jmp 0x27626
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5550
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x7e80
movq -0x20(%rbp), %rdi
movb %al, -0x11(%rbp)
movl 0x10(%rdi), %eax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
subl %ecx, %eax
sete -0x12(%rbp)
movl 0x40(%rdi), %eax
movq -0x10(%rbp), %rcx
movl 0x40(%rcx), %ecx
subl %ecx, %eax
sete -0x13(%rbp)
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0x29a30
negb %al
andb $0x1, %al
movb %al, -0x14(%rbp)
xorl %eax, %eax
testb $0x1, -0x11(%rbp)
movb %al, -0x15(%rbp)
je 0x29a1f
xorl %eax, %eax
testb $0x1, -0x12(%rbp)
movb %al, -0x15(%rbp)
je 0x29a1f
xorl %eax, %eax
testb $0x1, -0x13(%rbp)
movb %al, -0x15(%rbp)
je 0x29a1f
movb -0x14(%rbp), %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: arisKoutsou[P]oopproj/./src/livings/Living.cpp
// Function: Living::Position::operator==(Living::Position const&) const
bool Living :: Position :: operator==(const Position& rValue) const {
  bool sameX;
  bool sameY;

  sameX = (this->x == rValue.x) ? true : false;
  sameY = (this->y == rValue.y) ? true : false;

  return (sameX && sameY);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rdx
movl (%rdx), %edx
subl %edx, %ecx
sete -0x11(%rbp)
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
subl %ecx, %eax
sete %al
negb %al
andb $0x1, %al
movb %al, -0x12(%rbp)
xorl %eax, %eax
testb $0x1, -0x11(%rbp)
movb %al, -0x13(%rbp)
je 0x29a75
movb -0x12(%rbp), %al
movb %al, -0x13(%rbp)
movb -0x13(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x11(%rbp), %rdi
xorl %esi, %esi
callq 0x5f80
movq -0x10(%rbp), %rdi
callq 0x21f00
callq 0x5fe0
testb $0x1, %al
jne 0x2a337
jmp 0x2a339
jmp 0x2a38e
movq -0x28(%rbp), %rax
movl $0x0, -0x18(%rbp)
movl 0x44(%rax), %edi
movl 0x48(%rax), %esi
callq 0x6040
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21fe0
cvtsi2sdl -0x18(%rbp), %xmm2
cvtsi2sdl -0x1c(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
subl -0x1c(%rbp), %esi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)