LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::battle(std::__cxx11::list<Monster*, std::allocator<Monster*>>&)
void Hero :: battle(list<Monster*>& monsters) {
  int selection;
  battleMenu.displayMenu();
  while ((selection = battleMenu.getSelection())) {
    battleMenu.clearMenu();
    switch (selection) {
    case 1: {
      printStats();
      break;
    }
    case 2: {
      printMonsters(monsters);
      handleAttackCase(monsters);
      return;
    }
    case 3: {
      printMonsters(monsters);
      if (handleCastSpellCase(monsters)) return;      
      break;
    }
    case 4: {
      if (handleUseCase()) return;
      break;
    }
    case 5: {
      if (handleEquipCase()) return;
      break;
    }
    case 6: {
      handleQuitCase();
      if (quitGame) return;
      battleMenu.clearMenu();
      break;
    }             
    }    
    battleMenu.displayMenu();
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x118(%rdi), %r15
leaq 0x48a5(%rip), %r13      # 0x15d8c
leaq 0xfd6b(%rip), %rbp      # 0x21259
movq %r15, %rdi
callq 0x4b62
movq %r15, %rdi
callq 0x4c44
testl %eax, %eax
je 0x1156d
movl %eax, %r12d
movq %r15, %rdi
callq 0x4bf4
decl %r12d
cmpl $0x5, %r12d
ja 0x114ee
movslq (%r13,%r12,4), %rax
addq %r13, %rax
jmpq *%rax
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
jmp 0x114ee
movq %r14, %rdi
callq 0x11cee
jmp 0x11552
movq %rbx, %rsi
callq 0x1159e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11976
jmp 0x11552
movq %r14, %rdi
callq 0x11bb8
testb %al, %al
je 0x114ee
jmp 0x1156d
callq 0x7833
cmpb $0x0, (%rbp)
jne 0x1156d
movq %r15, %rdi
callq 0x4bf4
jmp 0x114ee
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rsi
callq 0x1159e
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11768
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::printMonsters(std::__cxx11::list<Monster*, std::allocator<Monster*>>&)
void Hero :: printMonsters(list<Monster*>& monsters) {
  printMonsterFrame();
  cout << '|'
       << setw(14) << "NAME" << setw(11) << '|'
       << setw(7) << "LEVEL" << setw(3) << '|'
       << setw(5) << "HP" << setw(4) << '|'
       << setw(11) << "MIN DAMAGE" << setw(2) << '|'
       << setw(11) << "MAX DAMAGE" << setw(2) << '|'
       << setw(7) << "ARMOR" << setw(3) << '|'
       << setw(7) << "DODGE" << setw(3) << '|'
       << endl;
  list<Monster*> :: iterator it = monsters.begin();
  for ( ; it != monsters.end(); ++it) {
    (*it)->printStats();    
  }
  printMonsterFrame();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x9188
movq 0xfa08(%rip), %rdi      # 0x20fc0
pushq $0x7c
popq %rbp
movl %ebp, %esi
callq 0x42c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0xe, 0x10(%rax,%rcx)
leaq 0x4539(%rip), %rsi      # 0x15b12
movq %rax, %rdi
callq 0x4250
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
pushq $0xb
popq %r12
movq %r12, 0x10(%rax,%rcx)
movq %rax, %rdi
movl %ebp, %esi
callq 0x42c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
pushq $0x7
popq %r14
movq %r14, 0x10(%rax,%rcx)
leaq 0x450f(%rip), %rsi      # 0x15b21
movq %rax, %rdi
callq 0x4250
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
pushq $0x3
popq %r15
movq %r15, 0x10(%rax,%rcx)
movq %rax, %rdi
movl %ebp, %esi
callq 0x42c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x5, 0x10(%rax,%rcx)
leaq 0x4765(%rip), %rsi      # 0x15db0
movq %rax, %rdi
callq 0x4250
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x4, 0x10(%rax,%rcx)
movq %rax, %rdi
movl %ebp, %esi
callq 0x42c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r12, 0x10(%rax,%rcx)
leaq 0x4545(%rip), %rsi      # 0x15bc5
movq %rax, %rdi
callq 0x4250
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
pushq $0x2
popq %r13
movq %r13, 0x10(%rax,%rcx)
movq %rax, %rdi
movl %ebp, %esi
callq 0x42c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r12, 0x10(%rax,%rcx)
leaq 0x451b(%rip), %rsi      # 0x15bd0
movq %rax, %rdi
callq 0x4250
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r13, 0x10(%rax,%rcx)
movq %rax, %rdi
movl %ebp, %esi
callq 0x42c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r14, 0x10(%rax,%rcx)
leaq 0x4b64(%rip), %rsi      # 0x1624a
movq %rax, %rdi
callq 0x4250
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r15, 0x10(%rax,%rcx)
movq %rax, %rdi
movl %ebp, %esi
callq 0x42c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r14, 0x10(%rax,%rcx)
leaq 0x4b39(%rip), %rsi      # 0x16250
movq %rax, %rdi
callq 0x4250
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r15, 0x10(%rax,%rcx)
movq %rax, %rdi
movl %ebp, %esi
callq 0x42c0
movq %rax, %rdi
callq 0x4120
movq %rbx, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x11754
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x11740
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9188
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0xc0(%rdi), %r14
movq %r14, %rdi
callq 0xa39c
testb %al, %al
je 0x11ca7
movq %r14, %rdi
callq 0xb99a
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0xf3c0(%rip), %rdi      # 0x20fc0
callq 0x4120
leaq 0x4398(%rip), %rsi      # 0x15fa4
movq %rax, %rdi
callq 0x4250
movq %rax, %rdi
callq 0x4120
movq %rax, %rdi
callq 0x4120
leaq 0x3411(%rip), %rsi      # 0x1503c
movq %rax, %rdi
callq 0x4250
movq 0xf396(%rip), %rdi      # 0x20fd0
leaq 0x8(%rsp), %rsi
callq 0x4060
movq %rbx, (%rsp)
addq $0x78, %rbx
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rbx, %r13
movq (%r13), %r13
cmpq %rbx, %r13
setne %bpl
je 0x11c9b
movq 0x10(%r13), %rsi
movq %r14, %rdi
callq 0x14584
movq %r15, %rdi
movq %r14, %rsi
callq 0x57df
movl %eax, %r12d
movq %r14, %rdi
callq 0x4470
testb %r12b, %r12b
je 0x11c59
leaq 0x8(%rsp), %rsi
movq (%rsp), %rdi
callq 0x10424
leaq 0x8(%rsp), %rdi
callq 0x4470
jmp 0x11cc4
movq 0xf312(%rip), %rdi      # 0x20fc0
leaq 0x465c(%rip), %rsi      # 0x16311
callq 0x4250
movq %rax, %rdi
callq 0x4120
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11cd9
jmp 0x11cd9
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::handleEquipCase()
bool Hero :: handleEquipCase() {
  if (!this->getInventory().hasItems()) {
    cout << endl << "You have no items in your Inventory." << endl;
    return false;
  }
  string name;
  do {
    clearScreen();
    inventory.printInfo();
    cout << endl
	 << "Please enter the name of the weapon/armor you want to equip"
	 << endl << endl << "> ";
    getline(cin, name);    
  } while (equip(name) == false);
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0xc0(%rdi), %r15
movq %r15, %rdi
callq 0xa384
movl %eax, %ebx
testb %al, %al
je 0x11db0
movb %bl, 0x7(%rsp)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x4625(%rip), %r13      # 0x16359
leaq 0x3301(%rip), %rbp      # 0x1503c
movq 0xf28e(%rip), %rbx      # 0x20fd0
leaq 0x8(%rsp), %r12
callq 0x7951
movq %r15, %rdi
callq 0xb738
movq 0xf265(%rip), %rdi      # 0x20fc0
callq 0x4120
movq %rax, %rdi
movq %r13, %rsi
callq 0x4250
movq %rax, %rdi
callq 0x4120
movq %rax, %rdi
callq 0x4120
movq %rax, %rdi
movq %rbp, %rsi
callq 0x4250
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4060
movq %r14, %rdi
movq %r12, %rsi
callq 0x10040
testb %al, %al
je 0x11d47
leaq 0x8(%rsp), %rdi
callq 0x4470
movb 0x7(%rsp), %bl
jmp 0x11dd3
movq 0xf209(%rip), %rdi      # 0x20fc0
callq 0x4120
leaq 0x4571(%rip), %rsi      # 0x16334
movq %rax, %rdi
callq 0x4250
movq %rax, %rdi
callq 0x4120
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4470
movq %rbx, %rdi
callq 0x4410
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/livings/Living.cpp
// Function: Living::operator==(Living const&) const
bool Living :: operator==(const Living& rValue) const {
  bool sameName;
  bool sameLevel;
  bool sameHealthPower;
  bool samePosition;

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x20, %rdi
addq $0x20, %rsi
callq 0x57df
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0x12ad3
movl 0x10(%rbx), %ecx
cmpl %ecx, 0x10(%r14)
jne 0x12ad3
movq 0x18(%r14), %xmm0
movq 0x18(%rbx), %xmm1
pcmpeqd %xmm0, %xmm1
pshufd $0x50, %xmm1, %xmm0     # xmm0 = xmm1[0,0,1,1]
movmskpd %xmm0, %ecx
movl %ecx, %edx
andb $0x2, %dl
shrb %dl
movl 0x40(%r14), %eax
cmpl 0x40(%rbx), %eax
sete %al
andb %cl, %al
andb %dl, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/livings/Monster.cpp
// Function: Monster::attack(Hero*)
void Monster::attack(Hero* hero) {
  Random random;

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

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

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

    hero->receiveDamage(monsterDamage - damageReduction);
  }

}

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x60(%rdi), %r14
movq %r14, %rsi
movq (%rsi), %rsi
cmpq %r14, %rsi
je 0x130e3
subl $0x1, 0x10(%rsi)
jae 0x1306f
movl 0x20(%rsi), %eax
testl %eax, %eax
je 0x130c4
cmpl $0x2, %eax
je 0x130b3
cmpl $0x1, %eax
jne 0x130d3
movsd 0x2caa(%rip), %xmm0     # 0x15d40
subsd 0x18(%rsi), %xmm0
cvtdq2pd 0x44(%rbx), %xmm1
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
divpd %xmm0, %xmm1
cvttpd2dq %xmm1, %xmm0
movlpd %xmm0, 0x44(%rbx)
jmp 0x130d3
movsd 0x18(%rsi), %xmm0
addsd 0x58(%rbx), %xmm0
movsd %xmm0, 0x58(%rbx)
jmp 0x130d3
movsd 0x18(%rsi), %xmm0
addsd 0x50(%rbx), %xmm0
movsd %xmm0, 0x50(%rbx)
movq (%rsi), %r15
movq %r14, %rdi
callq 0x130f6
movq %r15, %rsi
jmp 0x1306f
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/livings/heroes/Sorcerer.cpp
// Function: Sorcerer::operator==(Sorcerer const&) const
bool Sorcerer :: operator==(const Sorcerer& rValue) const {
  bool sameHeros;
  bool sameAgilityBonus;
  bool sameDexterityBonus;

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

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

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

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

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

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

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

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

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

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

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

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

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

  return (sameItems && sameReduceDamageTakenBy);
}

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

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

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

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x145a4
movsd 0x40(%rbx), %xmm0
ucomisd 0x40(%r14), %xmm0
jne 0x144f6
jp 0x144f6
movsd 0x50(%rbx), %xmm0
movsd 0x50(%r14), %xmm1
movsd 0x48(%r14), %xmm2
movsd 0x48(%rbx), %xmm3
cmpeqpd %xmm2, %xmm3
cmpeqpd %xmm0, %xmm1
andpd %xmm3, %xmm1
movd %xmm1, %ecx
andb %cl, %al
jmp 0x144f8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/items/Item.cpp
// Function: Item::operator==(Item const&) const
bool Item :: operator==(const Item& rValue) const {
  bool sameName;
  bool sameValue;
  bool sameSellingPrice;
  bool sameMinLevel;

  sameName = (this->name == rValue.name) ? true : false;
  sameValue = (this->value == rValue.value) ? true : false;
  sameSellingPrice = (this->sellFor == rValue.sellFor) ? true : false;
  sameMinLevel = (this->minLevel == rValue.minLevel) ? true : false;

  return (sameName && sameValue && sameSellingPrice && sameMinLevel);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
addq $0x8, %rsi
callq 0x57df
testb %al, %al
je 0x145ee
movq 0x2c(%r14), %xmm0
movq 0x2c(%rbx), %xmm1
pcmpeqd %xmm0, %xmm1
pshufd $0x50, %xmm1, %xmm0     # xmm0 = xmm1[0,0,1,1]
movmskpd %xmm0, %ecx
movl %ecx, %edx
andb $0x2, %dl
shrb %dl
movl 0x28(%r14), %eax
cmpl 0x28(%rbx), %eax
sete %al
andb %cl, %al
andb %dl, %al
jmp 0x145f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Teris45[P]Maze-Game/main.cpp
// Function: main
int main(int argc, char *argv[]) {
    initscr();
    cbreak();
    keypad(stdscr, TRUE);
    clear();

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

    getstr(name);



    noecho();

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

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

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

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

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

//    sleep(2);

    delete engine;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movl %edi, %ebx
callq 0x2300
callq 0x20b0
movq 0x79bf(%rip), %r12      # 0x9fd0
movq (%r12), %rdi
pushq $0x1
popq %rsi
callq 0x20f0
callq 0x23a0
movq (%r12), %rdi
leaq 0x39d7(%rip), %rsi      # 0x6004
pushq $-0x1
popq %r15
movl %r15d, %edx
callq 0x20c0
movq (%r12), %rdi
leaq -0x52(%rbp), %rsi
movl %r15d, %edx
callq 0x2310
callq 0x2240
cmpl $0x2, %ebx
jle 0x2721
movl $0x1a0, %edi            # imm = 0x1A0
callq 0x2200
movq %rax, %rbx
movq 0x8(%r14), %rsi
leaq -0x48(%rbp), %rdi
leaq -0x22(%rbp), %rdx
callq 0x2100
movq 0x10(%r14), %rsi
leaq -0x78(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x2100
leaq -0x48(%rbp), %rsi
leaq -0x78(%rbp), %rdx
leaq -0x52(%rbp), %rcx
movq %rbx, %rdi
callq 0x29e8
leaq -0x78(%rbp), %rdi
callq 0x2120
leaq -0x48(%rbp), %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x3050
callq 0x2370
pushq $0x1
popq %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x3596
testb %al, %al
jne 0x26d7
movq %rbx, %rdi
callq 0x31ac
jmp 0x26c1
movq 0x10(%r14), %rsi
leaq -0x48(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x2100
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x365c
leaq -0x48(%rbp), %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x3128
movl $0x1a0, %esi            # imm = 0x1A0
movq %rbx, %rdi
callq 0x2210
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x2140
leaq 0x38ea(%rip), %rcx      # 0x601a
movq %rcx, (%rax)
movq 0x7886(%rip), %rsi      # 0x9fc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x2380
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x2120
jmp 0x2783
movq %rax, %r14
jmp 0x2783
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x2120
jmp 0x2768
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x2120
jmp 0x2776
movq %rax, %r14
movl $0x1a0, %esi            # imm = 0x1A0
movq %rbx, %rdi
callq 0x2210
movq %r14, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Teris45[P]Maze-Game/Engine.cpp
// Function: Engine::printMaze()
void Engine::printMaze(){
    for(auto & it : maze)
    {
        for(auto & it1 : it){
            if(it1 == WALL)
                addch('*');
            else if(it1 == DIADROMOS)
                addch(' ');
            else if(it1 == GOBLINAKOS)
                addch('G');
            else if(it1 == TRAALINAKOS)
                addch('T');
            else if(it1 == POTERAKOS)
                addch('P');
            else if(it1 == GEM)
                addch('0');

        }
        addch('\n');

    }

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

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rdi), %r12
movq %rdi, -0x30(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x38(%rbp)
movq 0x6f59(%rip), %r15      # 0x9fd0
leaq 0x2fea(%rip), %rbx      # 0x6068
cmpq -0x38(%rbp), %r12
je 0x30c0
movq (%r12), %r14
movq 0x8(%r12), %r13
cmpq %r13, %r14
je 0x30af
movl (%r14), %eax
decl %eax
cmpl $0x5, %eax
ja 0x30a9
movl %eax, %eax
movl (%rbx,%rax,4), %esi
movq (%r15), %rdi
callq 0x20a0
addq $0x4, %r14
jmp 0x308d
movq (%r15), %rdi
pushq $0xa
popq %rsi
callq 0x20a0
addq $0x18, %r12
jmp 0x307e
movq (%r15), %rdi
leaq 0x2fda(%rip), %rsi      # 0x60a4
pushq $-0x1
popq %r14
movl %r14d, %edx
callq 0x20c0
movq (%r15), %rdi
leaq 0x2ff0(%rip), %rsi      # 0x60d0
movl %r14d, %edx
callq 0x20c0
movq -0x30(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
callq 0x52b6
movq (%r15), %rdi
movq %rax, %rsi
movl %r14d, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/Teris45[P]Maze-Game/Engine.cpp
// Function: Engine::gameLoop()
void Engine::gameLoop() {
    Engine::GetInput();
    Engine::checkEnding();
    Engine::makeMove();
    Engine::checkEnding();
    refresh();
}

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

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

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

    }


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %eax
movslq %esi, %rcx
movq (%rdi), %rsi
imulq $0x18, %rcx, %r15
movslq %edx, %r14
movq (%rsi,%r15), %rcx
movl (%rcx,%r14,4), %ecx
addl $-0x2, %ecx
cmpl $0x5, %ecx
ja 0x358c
movq %rdi, %rbx
leaq 0x2bb2(%rip), %rdx      # 0x6050
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movb $0x0, 0x19c(%rbx)
jmp 0x358c
incl 0x198(%rbx)
leaq 0x38(%rbx), %rdi
movl %r14d, %esi
movl %eax, %edx
callq 0x455c
movq (%rbx), %rax
movq (%rax,%r15), %rax
movl $0x3, (%rax,%r14,4)
cmpl $0xa, 0x198(%rbx)
jne 0x358c
movq %rbx, %rdi
callq 0x35a2
leaq 0x120(%rbx), %r14
leaq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x4fde
movq %r14, %rdi
callq 0x5056
cltq
movq (%rbx), %rbx
imulq $0x18, %rax, %r15
movq %r14, %rdi
callq 0x5060
cltq
movq (%rbx,%r15), %rcx
movl $0x7, (%rcx,%rax,4)
movq 0x6aa5(%rip), %r12      # 0x9fd0
movq (%r12), %rbx
movq %r14, %rdi
callq 0x5056
movl %eax, %r15d
movq %r14, %rdi
callq 0x5060
movq %rbx, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x2220
cmpl $-0x1, %eax
je 0x358c
movq (%r12), %rdi
pushq $0x23
popq %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20a0
movb $0x1, 0x19d(%rbx)
leaq 0x38(%rbx), %rdi
movl %r14d, %esi
movl %eax, %edx
callq 0x455c
movq (%rbx), %rax
movq (%rax,%r15), %rax
movl $0x3, (%rax,%r14,4)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Teris45[P]Maze-Game/Engine.cpp
// Function: Engine::setAvailablePoints()
void Engine::setAvailablePoints() {
    this->available_points.clear();
    for(int y = 0; y<(int) maze.size();y++){
        for(int x=0;x<(int) maze[y].size();x++){
            if(maze[y][x] == DIADROMOS){
                Point p1(x,y);
                available_points.push_back(p1);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
addq $0x18, %rdi
movq %rdi, -0x30(%rbp)
callq 0x3948
movq (%rbx), %rcx
xorl %r15d, %r15d
leaq -0x40(%rbp), %r12
movq 0x8(%rbx), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cltq
cmpq %rax, %r15
jge 0x3638
imulq $0x18, %r15, %r14
xorl %r13d, %r13d
movq (%rcx,%r14), %rax
movq 0x8(%rcx,%r14), %rdx
subq %rax, %rdx
shrq $0x2, %rdx
movslq %edx, %rdx
cmpq %rdx, %r13
jge 0x3633
cmpl $0x2, (%rax,%r13,4)
jne 0x362e
movq %r12, %rdi
movl %r13d, %esi
movl %r15d, %edx
callq 0x4652
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x3734
movq %r12, %rdi
callq 0x4668
movq (%rbx), %rcx
incq %r13
jmp 0x35ea
incq %r15
jmp 0x35cd
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x4668
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Teris45[P]Maze-Game/Engine.cpp
// Function: Engine::updateHG(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Engine::updateHG(const string& filename) {

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

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

    hg.save(file);

    file.close();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %r14
movl 0x198(%rdi), %r13d
movb 0x19d(%rdi), %r12b
leaq 0x130(%rdi), %rbx
leaq 0x178(%rdi), %rsi
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x22c0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5232
imull $0xa, %r13d, %ecx
leal 0xa(%rcx), %esi
testb %r12b, %r12b
cmovel %ecx, %esi
movq %rax, %rdi
callq 0x528e
leaq -0x48(%rbp), %rdi
callq 0x2120
leaq -0x248(%rbp), %r15
pushq $0x14
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x23d0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x510e
leaq -0x248(%rbp), %rdi
callq 0x22d0
leaq -0x248(%rbp), %rdi
callq 0x22f0
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x248(%rbp), %rdi
callq 0x22f0
jmp 0x372b
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Teris45[P]Maze-Game/Living.cpp
// Function: Point::euclidean(Point const&)
float Point:: euclidean(const Point &point){
    int x2 = this->x - point.x;
    int y2 = this->y - point.y;

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

    int distance = x2 + y2;

    return sqrt(distance);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x8(%rdi), %eax
subl 0x8(%rsi), %eax
movl 0xc(%rdi), %ecx
subl 0xc(%rsi), %ecx
imull %eax, %eax
imull %ecx, %ecx
addl %eax, %ecx
cvtsi2sd %ecx, %xmm0
sqrtsd %xmm0, %xmm0
cvtsd2ss %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Teris45[P]Maze-Game/Living.cpp
// Function: Living::setPoint(std::vector<Point, std::allocator<Point>>&)
void Living::setPoint(vector<Point> &starting) {
    srand(time(nullptr));

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

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

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

}

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


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

    possibleMoveSet = get_possible_moveset(p,maze);

    possibleMoveSet.push_back(p);

    p = getShortestEuclidean(poter,possibleMoveSet);

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


    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
andq $0x0, -0x30(%rbp)
callq 0x4612
movq 0x5784(%rip), %rax      # 0x9fd0
movq (%rax), %r12
movq %rbx, %rdi
callq 0x4552
movl %eax, %r13d
movq %rbx, %rdi
callq 0x453e
movq %r12, %rdi
movl %r13d, %esi
movl %eax, %edx
callq 0x2220
cmpl $-0x1, %eax
je 0x4886
movq 0x5755(%rip), %rax      # 0x9fd0
movq (%rax), %rdi
pushq $0x20
popq %rsi
callq 0x20a0
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x495e
leaq -0x40(%rbp), %r15
leaq -0x58(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x4f62
movq %r12, %rdi
callq 0x3804
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3734
leaq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rdx
movq %r14, %rsi
callq 0x4ae0
leaq -0x58(%rbp), %rdi
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rbx)
callq 0x4668
movq 0x56ed(%rip), %rax      # 0x9fd0
movq (%rax), %r14
movq %rbx, %rdi
callq 0x4552
movl %eax, %r15d
movq %rbx, %rdi
callq 0x453e
movq %r14, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x2220
cmpl $-0x1, %eax
je 0x491d
movq 0x56be(%rip), %rax      # 0x9fd0
movq (%rax), %rdi
pushq $0x54
popq %rsi
callq 0x20a0
leaq -0x40(%rbp), %rdi
callq 0x3804
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4941
jmp 0x4941
movq %rax, %r14
jmp 0x494c
movq %rax, %r14
movq %rbx, %rdi
callq 0x4668
leaq -0x40(%rbp), %rdi
callq 0x3804
movq %r14, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Teris45[P]Maze-Game/Moving.cpp
// Function: MyMoving::get_possible_moveset(Point const&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&)
vector<Point> MyMoving :: get_possible_moveset(const Point &p, const vector<vector<int>> &maze){
    vector<Point> possibleMoveSet;

    int y = p.getY();
    int x = p.getX();

    if(maze[y+1][x] == DIADROMOS || maze[y+1][x] == POTERAKOS ) {

        Point p1(x,y+1);
        possibleMoveSet.push_back(p1);
    }

    if(maze[y-1][x] == DIADROMOS || maze[y-1][x] == POTERAKOS) {
        Point p1(x,y-1);
        possibleMoveSet.push_back(p1);
    }

    if(maze[y][x+1] == DIADROMOS || maze[y][x+1] == POTERAKOS) {
        Point p1(x+1,y);
        possibleMoveSet.push_back(p1);
    }

    if(maze[y][x-1] == DIADROMOS || maze[y][x-1] == POTERAKOS) {
        Point p1(x-1,y);
        possibleMoveSet.push_back(p1);
    }


    return possibleMoveSet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x40(%rbp)
andq $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x4552
movl %eax, %r14d
movq %r12, %rdi
callq 0x453e
movl %eax, %r12d
leal 0x1(%r14), %edx
movslq %edx, %rcx
movq (%rbx), %rax
imulq $0x18, %rcx, %rcx
movslq %r12d, %r13
movq (%rax,%rcx), %rcx
movl (%rcx,%r13,4), %ecx
andl $-0x2, %ecx
cmpl $0x2, %ecx
jne 0x49e0
leaq -0x38(%rbp), %rdi
movl %r12d, %esi
callq 0x4652
leaq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x3734
leaq -0x38(%rbp), %rdi
callq 0x4668
movq (%rbx), %rax
leal -0x1(%r14), %edx
movslq %edx, %rcx
imulq $0x18, %rcx, %rcx
movq (%rax,%rcx), %rcx
movl (%rcx,%r13,4), %ecx
andl $-0x2, %ecx
cmpl $0x2, %ecx
jne 0x4a20
leaq -0x38(%rbp), %rdi
movl %r12d, %esi
callq 0x4652
leaq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x3734
leaq -0x38(%rbp), %rdi
callq 0x4668
movq (%rbx), %rax
movslq %r14d, %rcx
imulq $0x18, %rcx, %r15
movq (%rax,%r15), %rax
movl 0x4(%rax,%r13,4), %ecx
andl $-0x2, %ecx
cmpl $0x2, %ecx
jne 0x4a66
leal 0x1(%r12), %esi
leaq -0x38(%rbp), %rdi
movl %r14d, %edx
callq 0x4652
leaq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x3734
leaq -0x38(%rbp), %rdi
callq 0x4668
movq (%rbx), %rax
movq (%rax,%r15), %rax
movl -0x4(%rax,%r13,4), %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x4a9b
decl %r12d
leaq -0x38(%rbp), %rdi
movl %r12d, %esi
movl %r14d, %edx
callq 0x4652
leaq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x3734
leaq -0x38(%rbp), %rdi
callq 0x4668
movq -0x40(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4aba
jmp 0x4acc
jmp 0x4aba
jmp 0x4acc
jmp 0x4aba
jmp 0x4acc
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x4668
jmp 0x4acf
jmp 0x4acc
jmp 0x4acc
movq %rax, %r14
movq -0x40(%rbp), %rdi
callq 0x3804
movq %r14, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O2/Teris45[P]Maze-Game/Moving.cpp
// Function: MyMoving::getShortestEuclidean(Poter&, std::vector<Point, std::allocator<Point>> const&)
Point MyMoving::getShortestEuclidean(Poter &poter, const vector<Point> &possibleMoveSet) {
    int flag_first = 0;
    Point p(0,0);
    float min_euclidean = 0.0;
    for(Point points:possibleMoveSet){
        if(flag_first == 0){
            flag_first = 1;
            p.setY(points.getY());
            p.setX(points.getX());
            min_euclidean = points.euclidean(poter.getPoint());
        }
        else{
            float temp = points.euclidean(poter.getPoint());
            if(temp<min_euclidean){
                p.setY(points.getY());
                p.setX(points.getX());
            }
        }
    }

    return p;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, -0x38(%rbp)
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x4652
movq (%r15), %r13
movq 0x8(%r15), %rax
movq %rax, -0x40(%rbp)
movb $0x1, %al
xorps %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
leaq 0x5148(%rip), %r14      # 0x9c68
addq $0x10, %r14
leaq -0x50(%rbp), %r15
leaq -0x60(%rbp), %r12
cmpq -0x40(%rbp), %r13
je 0x4bf6
movq %r14, -0x50(%rbp)
movq 0x8(%r13), %rcx
movq %rcx, -0x48(%rbp)
testb $0x1, %al
je 0x4b90
movq %r15, %rdi
callq 0x4552
movq %rbx, %rdi
movl %eax, %esi
callq 0x4548
movq %r15, %rdi
callq 0x453e
movq %rbx, %rdi
movl %eax, %esi
callq 0x4534
movq %r12, %rdi
movq -0x38(%rbp), %rsi
callq 0x4612
movq %r15, %rdi
movq %r12, %rsi
callq 0x44fc
movss %xmm0, -0x2c(%rbp)
movq %r12, %rdi
callq 0x4668
jmp 0x4be3
movq %r12, %rdi
movq -0x38(%rbp), %rsi
callq 0x4612
movq %r15, %rdi
movq %r12, %rsi
callq 0x44fc
movss %xmm0, -0x30(%rbp)
movq %r12, %rdi
callq 0x4668
movss -0x2c(%rbp), %xmm0
ucomiss -0x30(%rbp), %xmm0
jbe 0x4be3
movq %r15, %rdi
callq 0x4552
movq %rbx, %rdi
movl %eax, %esi
callq 0x4548
movq %r15, %rdi
callq 0x453e
movq %rbx, %rdi
movl %eax, %esi
callq 0x4534
movq %r15, %rdi
callq 0x4668
addq $0x10, %r13
xorl %eax, %eax
jmp 0x4b2c
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4c1e
jmp 0x4c1e
jmp 0x4c0e
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x4668
jmp 0x4c21
jmp 0x4c1e
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x4668
movq %rbx, %rdi
callq 0x4668
movq %r14, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O2/Teris45[P]Maze-Game/Moving.cpp
// Function: MyMoving::Move(Goblin&, Poter&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&)
Point MyMoving::Move(Goblin &goblin, Poter &poter, const vector<vector<int>> &maze) {
    vector<Point> possibleMoveSet;


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

    possibleMoveSet = get_possible_moveset(p,maze);

    possibleMoveSet.push_back(p);

    p = getShortestEuclidean(poter,possibleMoveSet);

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


    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
andq $0x0, -0x30(%rbp)
callq 0x4612
movq 0x5364(%rip), %rax      # 0x9fd0
movq (%rax), %r12
movq %rbx, %rdi
callq 0x4552
movl %eax, %r13d
movq %rbx, %rdi
callq 0x453e
movq %r12, %rdi
movl %r13d, %esi
movl %eax, %edx
callq 0x2220
cmpl $-0x1, %eax
je 0x4ca6
movq 0x5335(%rip), %rax      # 0x9fd0
movq (%rax), %rdi
pushq $0x20
popq %rsi
callq 0x20a0
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x495e
leaq -0x40(%rbp), %r15
leaq -0x58(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x4f62
movq %r12, %rdi
callq 0x3804
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3734
leaq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rdx
movq %r14, %rsi
callq 0x4ae0
leaq -0x58(%rbp), %rdi
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rbx)
callq 0x4668
movq 0x52cd(%rip), %rax      # 0x9fd0
movq (%rax), %r14
movq %rbx, %rdi
callq 0x4552
movl %eax, %r15d
movq %rbx, %rdi
callq 0x453e
movq %r14, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x2220
cmpl $-0x1, %eax
je 0x4d3d
movq 0x529e(%rip), %rax      # 0x9fd0
movq (%rax), %rdi
pushq $0x47
popq %rsi
callq 0x20a0
leaq -0x40(%rbp), %rdi
callq 0x3804
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4d61
jmp 0x4d61
movq %rax, %r14
jmp 0x4d6c
movq %rax, %r14
movq %rbx, %rdi
callq 0x4668
leaq -0x40(%rbp), %rdi
callq 0x3804
movq %r14, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Teris45[P]Maze-Game/Gem.cpp
// Function: Gem::setPoint(std::vector<Point, std::allocator<Point>>&)
void Gem::setPoint(vector<Point> &startingPoints) {
    srand(time(nullptr));

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

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


    startingPoints.erase(startingPoints.begin()+0);


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
callq 0x21d0
movl %eax, %edi
callq 0x21e0
movq 0x8(%rbx), %r15
subq (%rbx), %r15
shrq $0x4, %r15
callq 0x2080
cltd
idivl %r15d
movslq %edx, %r15
shlq $0x4, %r15
movq (%rbx), %rdi
addq %r15, %rdi
callq 0x453e
movq %r14, %rdi
movl %eax, %esi
callq 0x4534
addq (%rbx), %r15
movq %r15, %rdi
callq 0x4552
movq %r14, %rdi
movl %eax, %esi
callq 0x4548
movq (%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4792
// File: /workspace/github_cpp_makefile_star2_O2/Teris45[P]Maze-Game/HighScore.cpp
// Function: HighScore::save(std::basic_ofstream<char, std::char_traits<char>>&)
void HighScore::save(ofstream &of) {
    for(int i=0;i<5;i++){
        if(score[i]!=-1){
            name[i].save(of);
            string str = to_string(score[i]);
            char *writeable = new char[str.size() + 1];
            copy(str.begin(),str.end(),writeable);
            writeable[str.size()] = '\0';
            of.write(writeable,sizeof(int));

        }
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %r14
xorl %ebx, %ebx
leaq -0x58(%rbp), %r15
cmpq $0x5, %rbx
je 0x51b1
cmpl $-0x1, 0x34(%r14,%rbx,4)
je 0x51a5
movq %rdi, -0x38(%rbp)
movq -0x30(%rbp), %rsi
callq 0x508a
movq %r14, %r13
movl 0x34(%r14,%rbx,4), %esi
movq %r15, %r14
movq %r15, %rdi
callq 0x54fb
movq -0x50(%rbp), %r12
leaq 0x1(%r12), %rdi
callq 0x2030
movq %rax, %r15
testq %r12, %r12
je 0x517f
movq -0x58(%rbp), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2350
movb $0x0, (%r15,%r12)
movq -0x30(%rbp), %rdi
movq %r15, %rsi
pushq $0x4
popq %rdx
callq 0x22b0
movq %r14, %r15
movq %r14, %rdi
callq 0x2120
movq %r13, %r14
movq -0x38(%rbp), %rdi
incq %rbx
addq $0xa, %rdi
jmp 0x512c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O2/Teris45[P]Maze-Game/HighScore.cpp
// Function: HighScore::load(std::basic_ifstream<char, std::char_traits<char>>&)
void HighScore::load(ifstream &inf) {
    int i=0;
    while (inf.eof()){
        name[i].load(inf);
        char *val = nullptr;
        inf.read(val,sizeof(int));
        this->score[i] = atoi(val);
        i++;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x34(%rdi), %r12
pushq $0x4
popq %r15
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rbx,%rax)
je 0x5228
movq %r14, %rdi
movq %rbx, %rsi
callq 0x506c
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2290
xorl %edi, %edi
callq 0x2330
movl %eax, (%r12)
addq $0x4, %r12
addq $0xa, %r14
jmp 0x51ed
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Teris45[P]Maze-Game/HighScore.cpp
// Function: HighScore::operator<<(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
HighScore &HighScore::operator<<(string myname) {
    for(int i=0;i<4;i++){
        name[i+1] = name[i];
    }

    name[0].setname(std::move(myname));
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
pushq $0xa
popq %rax
cmpq $0x32, %rax
je 0x5262
movzwl -0x2(%rbx,%rax), %ecx
movw %cx, 0x8(%rbx,%rax)
movq -0xa(%rbx,%rax), %rcx
movq %rcx, (%rbx,%rax)
addq $0xa, %rax
jmp 0x5243
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x22a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x50a8
movq %r14, %rdi
callq 0x2120
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Teris45[P]Maze-Game/HighScore.cpp
// Function: HighScore::operator<<(int)
HighScore &HighScore::operator<<(int myscore) {
    for(int i=0;i<4;i++){
        score[i+1] = score[i];
    }
    score[0] = myscore;
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movabsq $0xe, %rcx
cmpq $0x12, %rcx
je 0x52b1
movl -0x4(%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
incq %rcx
jmp 0x529f
movl %esi, 0x34(%rax)
popq %rbp
retq