LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/grid/Grid.cpp
// Function: Grid::Grid(int, int, bool*)
Grid :: Grid(int _maxY, int _maxX, bool* _tileInfo)

  : maxX(_maxX), maxY(_maxY) {

  size_t auxI = 0U;
  
  for (size_t i = 0U; i != maxY; ++i) {
    vector<Tile> newTileVector;
    tiles.push_back(newTileVector);
    
    for (size_t j = 0U; j != maxX; ++j) {

      bool nonAccessible = _tileInfo[auxI];
      bool common = _tileInfo[auxI + 1];

      Tile newTile(nonAccessible, common);
      tiles[i].push_back(newTile);
      
      auxI += 2U;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, 0x18(%rsp)
movl %edx, (%rdi)
movl %esi, 0x4(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
testl %esi, %esi
je 0x6778
movq %rdi, %r15
leaq 0x8(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rbp
xorl %r12d, %r12d
leaq 0x20(%rsp), %rbx
leaq 0x40(%rsp), %r13
xorl %r14d, %r14d
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x6bac
cmpl $0x0, (%r15)
movq %r14, 0x10(%rsp)
je 0x6756
leaq (%r14,%r14,2), %rbx
shlq $0x3, %rbx
xorl %r14d, %r14d
movq 0x18(%rsp), %rax
movzwl (%rax,%r12), %eax
movw %ax, 0x40(%rsp)
movq %rbp, 0x50(%rsp)
movq %rbp, 0x48(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
addq %rbx, %rdi
movq %r13, %rsi
callq 0x6bd8
addq $0x2, %r12
movq %r13, %rdi
callq 0x65ca
incq %r14
movslq (%r15), %rax
cmpq %rax, %r14
jne 0x670c
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x6c28
movq 0x10(%rsp), %r14
incq %r14
movslq 0x4(%r15), %rax
cmpq %rax, %r14
jne 0x66d8
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x6799
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x65ca
leaq 0x20(%rsp), %rdi
callq 0x6c28
movq 0x8(%rsp), %rdi
callq 0x6c6a
movq %r14, %rdi
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/grid/Grid.cpp
// Function: Grid::addMarket(int, int, Market*)
void Grid :: addMarket(int row, int col, Market* _market) {
  if (tiles[row][col].hasMarket()) {
    cerr << "You can't add more than one market in a tile." << endl;
    return;
  }
  
  if (tiles[row][col].isNonAccessible()) {
    cerr << "You can't add a market at a nonAccessible tile." << endl;
    return;
  }
  tiles[row][col].market = _market;  
}

// Assembly:
pushq %rbx
movslq %esi, %rax
movq 0x8(%rdi), %rsi
leaq (%rax,%rax,2), %rax
movslq %edx, %rdx
movq (%rsi,%rax,8), %rax
leaq (%rdx,%rdx,4), %rdx
cmpq $0x0, 0x20(%rax,%rdx,8)
je 0x67fc
movq 0x1e7fa(%rip), %rbx     # 0x24fe8
leaq 0x14b7b(%rip), %rsi     # 0x1b370
movl $0x2d, %edx
jmp 0x6818
leaq (%rax,%rdx,8), %rax
cmpb $0x1, (%rax)
jne 0x6848
movq 0x1e7dc(%rip), %rbx     # 0x24fe8
leaq 0x14b8b(%rip), %rsi     # 0x1b39e
movl $0x2f, %edx
movq %rbx, %rdi
callq 0x42f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
popq %rbx
jmp 0x41b0
movq %rcx, 0x20(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/grid/Grid.cpp
// Function: Grid::addLiving(int, int, Living*)
void Grid :: addLiving(int row, int col, Living* living) {
  list<Living*> :: const_iterator it = tiles[row][col].livings.begin();
  for ( ; it != tiles[row][col].livings.end(); ++it) {
    if ((*it) == living) {
      return;
    }
  }  
  if (tiles[row][col].isNonAccessible()) {
    cerr << "A Hero can't be on a nonAccessible Tile." << endl;
    return;
  }
  tiles[row][col].livings.push_back(living);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movslq %esi, %rax
movq 0x8(%rdi), %rcx
leaq (%rax,%rax,2), %rax
movslq %edx, %rdx
movq (%rcx,%rax,8), %rax
leaq (%rdx,%rdx,4), %rcx
leaq (%rax,%rcx,8), %r15
leaq (%rax,%rcx,8), %r14
addq $0x8, %r14
movq %r14, %rax
movq (%rax), %rax
cmpq %r14, %rax
je 0x68a7
cmpq %rbx, 0x10(%rax)
jne 0x6897
jmp 0x6911
cmpb $0x1, (%r15)
jne 0x68f4
movq 0x1e734(%rip), %rbx     # 0x24fe8
leaq 0x14b13(%rip), %rsi     # 0x1b3ce
movl $0x28, %edx
movq %rbx, %rdi
callq 0x42f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x41b0
movl $0x18, %edi
callq 0x4290
movq %rbx, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x4050
incq 0x18(%r15)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/game_utils.cpp
// Function: skipCommentsAndWhitespace(std::basic_ifstream<char, std::char_traits<char>>&)
void skipCommentsAndWhitespace(ifstream& stream) {
  while (stream.eof() == false) {
    getline(stream, buffer);
    if (isCommentOrWhitespace(buffer)) continue;
    break;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1d387(%rip), %r14     # 0x25270
movq (%rbx), %rax
movq -0x18(%rax), %rdi
testb $0x2, 0x20(%rbx,%rdi)
jne 0x7f1e
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4460
movq %r14, %rdi
callq 0x86e4
testb %al, %al
jne 0x7ee9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/game_utils.cpp
// Function: tokenize(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void tokenize(vector<string>& tokens) {
  string token;
  size_t pos = 0U;
  // Finding the position of the delimiter (',')
  // string :: npos is just the greatest value of size_t
  while ((pos = buffer.find(',')) != string :: npos) {
    token = buffer.substr(0, pos);
    tokens.push_back(token);
    buffer.erase(0, pos + 1);    
  }  
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x38(%rsp), %rbp
leaq 0x1d319(%rip), %r14     # 0x25270
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movl $0x2c, %esi
xorl %edx, %edx
callq 0x4350
cmpq $-0x1, %rax
je 0x7fc8
movq %rax, %r13
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x42c0
movq %r12, %rdi
movq %r15, %rsi
callq 0x4320
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7fab
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc51c
incq %r13
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x4090
jmp 0x7f61
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x7fe4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7ff5
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8014
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/game_utils.cpp
// Function: handleBasicCase(Hero*)
void handleBasicCase(Hero* currentHero) {
  int selection;
  currentHero->getGameMenu().clearMenu();
  currentHero->getGameMenu().displayMenu();
  while ((selection = currentHero->getGameMenu().getSelection())) {
    currentHero->getGameMenu().clearMenu();
    switch (selection) {    
    case 1: {      
      currentHero->printStats();
      break;
    }
    case 2: {      
      currentHero->checkInventory();
      return;
    }
    case 3: {
      currentHero->displayMap();
      handleMoveCase(currentHero);
      return; 
    }
    case 4: {      
      handleQuitCase();
      currentHero->getGameMenu().clearMenu();
      if (quitGame) return;
      break;
    }            
    default: break;
    }
    currentHero->getGameMenu().displayMenu();
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x134ce
movq %rax, %rdi
callq 0x4f74
movq %rbx, %rdi
callq 0x134ce
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
movq %rbx, %rdi
callq 0x134ce
movq %rax, %rdi
callq 0x4ff0
testl %eax, %eax
je 0x87f2
movl %eax, %r14d
leaq 0x12cc8(%rip), %r15     # 0x1b448
movq %rbx, %rdi
callq 0x134ce
movq %rax, %rdi
callq 0x4f74
decl %r14d
cmpl $0x3, %r14d
ja 0x87cb
movslq (%r15,%r14,4), %rax
addq %r15, %rax
jmpq *%rax
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
jmp 0x87cb
callq 0x8c1b
movq %rbx, %rdi
callq 0x134ce
movq %rax, %rdi
callq 0x4f74
cmpb $0x0, 0x1caa0(%rip)     # 0x25269
jne 0x87f2
movq %rbx, %rdi
callq 0x134ce
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
movq %rbx, %rdi
callq 0x134ce
movq %rax, %rdi
callq 0x4ff0
movl %eax, %r14d
testl %eax, %eax
jne 0x8780
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x14f80
movq %rbx, %rdi
callq 0x167c4
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x881a
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/game_utils.cpp
// Function: setMap()
void setMap(void) {
  map.open("input/map.txt");
  if (!map.is_open()) {
    cerr << "There was a problem opening the map file.\nExiting game..."
	 << endl;
    exit(EXIT_FAILURE);
  }
}

// Assembly:
pushq %rax
leaq 0x1ac5d(%rip), %rdi     # 0x25338
leaq 0x10eeb(%rip), %rsi     # 0x1b5cd
movl $0x8, %edx
callq 0x4170
leaq 0x1acbd(%rip), %rdi     # 0x253b0
callq 0x40a0
testb %al, %al
je 0xa6fe
popq %rax
retq
movq 0x1a8e3(%rip), %rdi     # 0x24fe8
leaq 0x11374(%rip), %rsi     # 0x1ba80
callq 0x4280
movq %rax, %rdi
callq 0x4120
movl $0x1, %edi
callq 0x4310
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/game_utils.cpp
// Function: getNumberOfHeroes()
int getNumberOfHeroes(void) {
  int numberOfHeroes = -1;
  while (numberOfHeroes < 1 || numberOfHeroes > 3) {
    cout << endl
	 << "Please enter the number of heroes you want to have "
	 << "(min: 1, max: 3)" << endl << endl << "> ";
    cin >> numberOfHeroes;
    cout << endl;
    cin.ignore(numeric_limits<streamsize> :: max(), '\n');
  }
  return numberOfHeroes;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x4(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq 0x1a880(%rip), %r14     # 0x24fc0
leaq 0x113a7(%rip), %r12     # 0x1baee
leaq 0x1091e(%rip), %r13     # 0x1b06c
movq 0x1a87b(%rip), %rbp     # 0x24fd0
movabsq $0x7fffffffffffffff, %r15 # imm = 0x7FFFFFFFFFFFFFFF
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41b0
movq %rax, %rbx
movl $0x33, %edx
movq %rax, %rdi
leaq 0x11322(%rip), %rsi     # 0x1baba
callq 0x42f0
movl $0x10, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x42f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41b0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41b0
movl $0x2, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x42f0
movq %rbp, %rdi
leaq 0x4(%rsp), %rsi
callq 0x4160
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41b0
movq %rbp, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x4180
movl 0x4(%rsp), %eax
leal -0x4(%rax), %ecx
cmpl $-0x3, %ecx
jb 0xa75f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/game_utils.cpp
// Function: cleanupResources()
void cleanupResources(void) {  
  delete gameGrid;
  heroes.clear();
  names.clear();
  weapons.clear();
  armors.clear();
  potions.clear();
  spells.clear();
  map.close();
  quitGame = false;
}

// Assembly:
pushq %rbx
movq 0x1acc7(%rip), %rbx     # 0x25540
testq %rbx, %rbx
je 0xa893
movq %rbx, %rdi
callq 0x67b6
movl $0x20, %esi
movq %rbx, %rdi
callq 0x42a0
movq 0x1a9f6(%rip), %rax     # 0x25290
cmpq %rax, 0x1a9f7(%rip)     # 0x25298
je 0xa8aa
movq %rax, 0x1a9ee(%rip)     # 0x25298
movq 0x1a9f7(%rip), %rsi     # 0x252a8
leaq 0x1a9f0(%rip), %rdi     # 0x252a8
callq 0xc55a
movq 0x1a9fc(%rip), %rsi     # 0x252c0
leaq 0x1a9f5(%rip), %rdi     # 0x252c0
callq 0xc55a
movq 0x1aa01(%rip), %rsi     # 0x252d8
leaq 0x1a9fa(%rip), %rdi     # 0x252d8
callq 0xc55a
movq 0x1aa06(%rip), %rsi     # 0x252f0
leaq 0x1a9ff(%rip), %rdi     # 0x252f0
callq 0xc55a
movq 0x1aa0b(%rip), %rsi     # 0x25308
leaq 0x1aa04(%rip), %rdi     # 0x25308
callq 0xc55a
leaq 0x1aa28(%rip), %rdi     # 0x25338
callq 0x4070
movb $0x0, 0x1a94d(%rip)     # 0x25269
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/game_utils.cpp
// Function: play()
void play(void) {
  setMap();
  readData();
  int numberOfHeroes = getNumberOfHeroes();
  initGrid();
  createHeroes(numberOfHeroes);
  int heroTurn = 0;
  bool battled = false;
  while (quitGame == false) {
    Hero* currentHero = heroes[heroTurn];
    heroTurn = (heroTurn + 1) % numberOfHeroes;
    if (!battled && currentHero->getTile().isQualifiedForBattle(numberOfHeroes)) {
      if (rng.boolean(battleProbability)) {
    	handleBattleCase();
	currentHero->updatePotions();
	battled = true;
	continue;
      }      
    }
    handleBasicCase(currentHero);
    battled = false;
  }
  cleanupResources();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0xa6d3
callq 0xa425
callq 0xa723
movl %eax, %ebx
callq 0x7bf8
movl %ebx, %edi
callq 0x9adc
cmpb $0x0, 0x1a920(%rip)     # 0x25269
jne 0xa9b9
xorl %ebp, %ebp
xorl %r15d, %r15d
xorl %eax, %eax
movl %r15d, %ecx
movq 0x1a934(%rip), %rdx     # 0x25290
movq (%rdx,%rcx,8), %r14
incl %r15d
cmpl %ebx, %r15d
cmovel %ebp, %r15d
testb $0x1, %al
jne 0xa9a6
movq %r14, %rdi
callq 0x134d6
movq %rax, %rdi
movl %ebx, %esi
callq 0x6670
testb %al, %al
je 0xa9a6
movsd 0x10ab4(%rip), %xmm0    # 0x1b440
callq 0x4db4
testb %al, %al
je 0xa9a6
callq 0x8e91
movq %r14, %rdi
callq 0x13e2a
movb $0x1, %al
jmp 0xa9b0
movq %r14, %rdi
callq 0x873d
xorl %eax, %eax
cmpb $0x0, 0x1a8b2(%rip)     # 0x25269
je 0xa952
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa871
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/game_utils.cpp
// Function: getDigits(int)
int getDigits(int n) {
  if (n == 0) return 1;
  int digits = 0;
  while (n) {
    ++digits;
    n /= 10;
  }
  return digits;
}

// Assembly:
testl %edi, %edi
je 0xac24
xorl %eax, %eax
incl %eax
movslq %edi, %rcx
imulq $0x66666667, %rcx, %rdi # imm = 0x66666667
movq %rdi, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rdi
addl %edx, %edi
addl $0x9, %ecx
cmpl $0x12, %ecx
ja 0xac02
retq
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/game_utils.cpp
// Function: printArmorFrame()
void printArmorFrame(void) {
  cout << '+' << string(24, '-'); 
  cout << '+' << string(7, '-');  
  cout << '+' << string(11, '-'); 
  cout << '+' << string(18, '-');
  cout << '+' << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsp, %rsi
movb $0x2b, (%rsi)
movq 0x19c52(%rip), %rdi     # 0x24fc0
movl $0x1, %edx
callq 0x42f0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rsp, %rdi
movl $0x18, %esi
movl $0x2d, %edx
callq 0x4300
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x42f0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xb3bd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rsp, %r14
movb $0x2b, (%r14)
movq 0x19bf5(%rip), %rdi     # 0x24fc0
movl $0x1, %edx
movq %r14, %rsi
callq 0x42f0
movq %rax, %rbx
movq %r15, (%r14)
movq %rsp, %rdi
movl $0x7, %esi
movl $0x2d, %edx
callq 0x4300
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x42f0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xb417
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rsp, %r14
movb $0x2b, (%r14)
movq 0x19b9b(%rip), %rdi     # 0x24fc0
movl $0x1, %edx
movq %r14, %rsi
callq 0x42f0
movq %rax, %rbx
movq %r15, (%r14)
movq %rsp, %rdi
movl $0xb, %esi
movl $0x2d, %edx
callq 0x4300
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x42f0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xb471
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rsp, %r14
movb $0x2b, (%r14)
movq 0x19b41(%rip), %rdi     # 0x24fc0
movl $0x1, %edx
movq %r14, %rsi
callq 0x42f0
movq %rax, %rbx
movq %r15, (%r14)
movq %rsp, %rdi
movl $0x12, %esi
movl $0x2d, %edx
callq 0x4300
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x42f0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xb4cb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rsp, %rsi
movb $0x2b, (%rsi)
movq 0x19ae8(%rip), %rdi     # 0x24fc0
movl $0x1, %edx
callq 0x42f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xb522
jmp 0xb53d
jmp 0xb522
jmp 0xb53d
jmp 0xb522
jmp 0xb53d
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xb540
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0xb540
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/game_utils.cpp
// Function: printWeaponFrame()
void printWeaponFrame(void) {
  cout << '+' << string(24, '-'); 
  cout << '+' << string(7, '-');  
  cout << '+' << string(11, '-'); 
  cout << '+' << string(8, '-');  
  cout << '+' << string(12, '-');
  cout << '+' << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsp, %rsi
movb $0x2b, (%rsi)
movq 0x19a62(%rip), %rdi     # 0x24fc0
movl $0x1, %edx
callq 0x42f0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rsp, %rdi
movl $0x18, %esi
movl $0x2d, %edx
callq 0x4300
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x42f0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xb5ad
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rsp, %r14
movb $0x2b, (%r14)
movq 0x19a05(%rip), %rdi     # 0x24fc0
movl $0x1, %edx
movq %r14, %rsi
callq 0x42f0
movq %rax, %rbx
movq %r15, (%r14)
movq %rsp, %rdi
movl $0x7, %esi
movl $0x2d, %edx
callq 0x4300
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x42f0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xb607
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rsp, %r14
movb $0x2b, (%r14)
movq 0x199ab(%rip), %rdi     # 0x24fc0
movl $0x1, %edx
movq %r14, %rsi
callq 0x42f0
movq %rax, %rbx
movq %r15, (%r14)
movq %rsp, %rdi
movl $0xb, %esi
movl $0x2d, %edx
callq 0x4300
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x42f0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xb661
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rsp, %r14
movb $0x2b, (%r14)
movq 0x19951(%rip), %rdi     # 0x24fc0
movl $0x1, %edx
movq %r14, %rsi
callq 0x42f0
movq %rax, %rbx
movq %r15, (%r14)
movq %rsp, %rdi
movl $0x8, %esi
movl $0x2d, %edx
callq 0x4300
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x42f0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xb6bb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rsp, %r14
movb $0x2b, (%r14)
movq 0x198f7(%rip), %rdi     # 0x24fc0
movl $0x1, %edx
movq %r14, %rsi
callq 0x42f0
movq %rax, %rbx
movq %r15, (%r14)
movq %rsp, %rdi
movl $0xc, %esi
movl $0x2d, %edx
callq 0x4300
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x42f0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xb715
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rsp, %rsi
movb $0x2b, (%rsi)
movq 0x1989e(%rip), %rdi     # 0x24fc0
movl $0x1, %edx
callq 0x42f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xb770
jmp 0xb78b
jmp 0xb770
jmp 0xb78b
jmp 0xb770
jmp 0xb78b
jmp 0xb770
jmp 0xb78b
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xb78e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0xb78e
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/inventory/Inventory.cpp
// Function: Inventory::~Inventory()
Inventory :: ~Inventory() {
  while(items.empty() == false) {
    delete items.front();
    items.pop_front();
  }

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
movq 0x8(%rdi), %rax
cmpq %r15, %rax
je 0xc988
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0xc965
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rbx), %r14
decq 0x18(%rbx)
movq %r14, %rdi
callq 0x43f0
movl $0x18, %esi
movq %r14, %rdi
callq 0x42a0
movq 0x8(%rbx), %rax
jmp 0xc951
leaq 0x20(%rbx), %r12
movq 0x20(%rbx), %rax
cmpq %r12, %rax
je 0xc9c3
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0xc9a4
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %r14
decq 0x30(%rbx)
movq %r14, %rdi
callq 0x43f0
movl $0x18, %esi
movq %r14, %rdi
callq 0x42a0
jmp 0xc98c
leaq 0x17c86(%rip), %rax     # 0x24650
addq $0x10, %rax
movq %rax, 0x38(%rbx)
leaq 0x40(%rbx), %rdi
callq 0x625c
movq 0x20(%rbx), %rdi
cmpq %r12, %rdi
je 0xc9f9
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x42a0
movq %rbx, %rdi
cmpq %r12, %rbx
jne 0xc9e4
movq (%r15), %rdi
cmpq %r15, %rdi
je 0xca16
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x42a0
movq %rbx, %rdi
cmpq %r15, %rbx
jne 0xca01
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/inventory/Inventory.cpp
// Function: Inventory::hasPotions() const
bool Inventory::hasPotions() const {
  list<Item*> :: const_iterator itemIterator = items.begin();

  for ( ; itemIterator != items.end() ; itemIterator++) {
    if ((*itemIterator)->kindOf() == "Potion") {
      return true;
    }
  }

  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x8, %rbx
leaq 0x18(%rsp), %r12
leaq 0x8(%rsp), %r14
leaq 0xf4b3(%rip), %r15      # 0x1bf27
movq %rbx, %r13
movq (%r13), %r13
cmpq %rbx, %r13
je 0xcab5
movq 0x10(%r13), %rsi
movq (%rsi), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x40d0
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xcab1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
testl %ebp, %ebp
jne 0xca77
cmpq %rbx, %r13
setne %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/inventory/Inventory.cpp
// Function: Inventory::removeAndDeleteItem(Item*)
void Inventory :: removeAndDeleteItem(Item* item) {
  if (this->getCurrentCapacity() == 0) {
    cout << "Your inventory is already empty" << endl;
    return;
  }

  items.remove(item);
  delete item;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
movl 0x30(%rdi), %eax
addl 0x18(%rdi), %eax
je 0xeb87
addq $0x8, %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0xf2da
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xeb81
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
movq 0x16432(%rip), %rbx     # 0x24fc0
leaq 0xd0e6(%rip), %rsi      # 0x1bc7b
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x42f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x41b0
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/inventory/Inventory.cpp
// Function: Inventory::removeAndDeleteSpell(Spell*)
void Inventory :: removeAndDeleteSpell(Spell* spell) {
  if (this->getCurrentCapacity() == 0) {
    cout << "Your inventory is aldready empty" << endl;
    return;
  }

  spells.remove(spell);
  delete spell;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
movl 0x30(%rdi), %eax
addl 0x18(%rdi), %eax
je 0xec05
addq $0x20, %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0xf36c
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xebff
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
movq 0x163b4(%rip), %rbx     # 0x24fc0
leaq 0xd088(%rip), %rsi      # 0x1bc9b
movl $0x20, %edx
movq %rbx, %rdi
callq 0x42f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x41b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
movl 0x30(%rdi), %eax
addl 0x18(%rdi), %eax
je 0xec72
addq $0x8, %rdi
leaq 0x8(%rsp), %rsi
callq 0xf2da
addq $0x10, %rsp
popq %rbx
retq
movq 0x16347(%rip), %rbx     # 0x24fc0
leaq 0xcffb(%rip), %rsi      # 0x1bc7b
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x42f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x41b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
movl 0x30(%rdi), %eax
addl 0x18(%rdi), %eax
je 0xece0
addq $0x20, %rdi
leaq 0x8(%rsp), %rsi
callq 0xf36c
addq $0x10, %rsp
popq %rbx
retq
movq 0x162d9(%rip), %rbx     # 0x24fc0
leaq 0xcf8d(%rip), %rsi      # 0x1bc7b
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x42f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x41b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/inventory/Inventory.cpp
// Function: Inventory::getItemByName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
Item* Inventory::getItemByName(const string& itemName) const {
  list<Item*>::const_iterator it = items.begin();

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

  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
addq $0x8, %r15
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r12
movq %r15, %rbp
movq (%rbp), %rbp
cmpq %r15, %rbp
je 0xedb3
movq 0x10(%rbp), %rsi
movq %r12, %rdi
callq 0x1a714
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0xed8c
testq %rdx, %rdx
je 0xed90
movq (%r14), %rsi
movq 0x8(%rsp), %rdi
callq 0x42b0
testl %eax, %eax
sete %bl
jmp 0xed92
xorl %ebx, %ebx
jmp 0xed92
movb $0x1, %bl
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xeda9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
testb %bl, %bl
je 0xed53
movq 0x10(%rbp), %rax
jmp 0xedb5
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/inventory/Inventory.cpp
// Function: Inventory::getSpellByName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
Spell* Inventory::getSpellByName(const string& spellName) const {
  list<Spell*>::const_iterator it = spells.begin();

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

  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x20(%rdi), %r12
addq $0x20, %r15
cmpq %r15, %r12
je 0xee14
movq %rsi, %r14
xorl %ebx, %ebx
movq 0x10(%r12), %rdi
callq 0x130b4
movq 0x8(%rax), %rdx
cmpq 0x8(%r14), %rdx
jne 0xee09
testq %rdx, %rdx
je 0xee18
movq (%r14), %rsi
movq (%rax), %rdi
callq 0x42b0
testl %eax, %eax
je 0xee18
movq (%r12), %r12
cmpq %r15, %r12
jne 0xede1
jmp 0xee1d
xorl %ebx, %ebx
jmp 0xee1d
movq 0x10(%r12), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/market/Market.cpp
// Function: Market::~Market()
Market :: ~Market() {
  while(items.empty() == false) {
    delete items.front();
    items.pop_front();
  }

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
movq 0x8(%rdi), %rax
cmpq %r15, %rax
je 0xfd44
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0xfd21
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rbx), %r14
decq 0x18(%rbx)
movq %r14, %rdi
callq 0x43f0
movl $0x18, %esi
movq %r14, %rdi
callq 0x42a0
movq 0x8(%rbx), %rax
jmp 0xfd0d
leaq 0x20(%rbx), %r12
movq 0x20(%rbx), %rax
cmpq %r12, %rax
je 0xfd7f
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0xfd60
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %r14
decq 0x30(%rbx)
movq %r14, %rdi
callq 0x43f0
movl $0x18, %esi
movq %r14, %rdi
callq 0x42a0
jmp 0xfd48
leaq 0x148ca(%rip), %rax     # 0x24650
addq $0x10, %rax
movq %rax, 0x38(%rbx)
leaq 0x40(%rbx), %rdi
callq 0x625c
movq 0x20(%rbx), %rdi
cmpq %r12, %rdi
je 0xfdb5
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x42a0
movq %rbx, %rdi
cmpq %r12, %rbx
jne 0xfda0
movq (%r15), %rdi
cmpq %r15, %rdi
je 0xfdd2
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x42a0
movq %rbx, %rdi
cmpq %r15, %rbx
jne 0xfdbd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/market/Market.cpp
// Function: Market::getItemByName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Item* Market :: getItemByName(const string& name) {
  list<Item*> :: iterator itemIterator = items.begin();

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

  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
addq $0x8, %r15
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r12
movq %r15, %rbp
movq (%rbp), %rbp
cmpq %r15, %rbp
je 0x11f03
movq 0x10(%rbp), %rsi
movq %r12, %rdi
callq 0x1a714
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x11edc
testq %rdx, %rdx
je 0x11ee0
movq (%r14), %rsi
movq 0x8(%rsp), %rdi
callq 0x42b0
testl %eax, %eax
sete %bl
jmp 0x11ee2
xorl %ebx, %ebx
jmp 0x11ee2
movb $0x1, %bl
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x11ef9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
testb %bl, %bl
je 0x11ea3
movq 0x10(%rbp), %rax
jmp 0x11f05
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/market/Market.cpp
// Function: Market::getSpellByName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Spell* Market :: getSpellByName(const string& name) {
  list<Spell*> :: iterator spellIterator = spells.begin();

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

  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x20(%rdi), %r12
addq $0x20, %r15
cmpq %r15, %r12
je 0x11f64
movq %rsi, %r14
xorl %ebx, %ebx
movq 0x10(%r12), %rdi
callq 0x130b4
movq 0x8(%rax), %rdx
cmpq 0x8(%r14), %rdx
jne 0x11f59
testq %rdx, %rdx
je 0x11f68
movq (%r14), %rsi
movq (%rax), %rdi
callq 0x42b0
testl %eax, %eax
je 0x11f68
movq (%r12), %r12
cmpq %r15, %r12
jne 0x11f31
jmp 0x11f6d
xorl %ebx, %ebx
jmp 0x11f6d
movq 0x10(%r12), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/spells/IceSpell.cpp
// Function: IceSpell::operator==(IceSpell const&) const
bool IceSpell :: operator==(const IceSpell& rValue) const {
  bool sameSpells;
  bool sameOponentDamageReduction;
  bool sameRounds;

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

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

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

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

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

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x130d0
movl %eax, %ecx
movl 0x50(%r14), %eax
cmpl 0x50(%rbx), %eax
sete %al
testb %cl, %cl
je 0x12fb4
movsd 0x48(%r14), %xmm0
ucomisd 0x48(%rbx), %xmm0
jne 0x12fb4
jnp 0x12fb6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x11582(%rip), %rax     # 0x248e0
movq %rax, (%rdi)
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x13370
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x1337f
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x1338e
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x60(%rbx), %r15
movq 0x60(%rbx), %rax
cmpq %r15, %rax
je 0x133c9
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x133aa
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x60(%rbx), %r14
decq 0x70(%rbx)
movq %r14, %rdi
callq 0x43f0
movl $0x18, %esi
movq %r14, %rdi
callq 0x42a0
jmp 0x13392
leaq 0x11280(%rip), %r14     # 0x24650
addq $0x10, %r14
movq %r14, 0x138(%rbx)
leaq 0x140(%rbx), %rdi
callq 0x625c
movq %r14, 0x118(%rbx)
leaq 0x120(%rbx), %rdi
callq 0x625c
leaq 0xc0(%rbx), %rdi
callq 0xc93e
leaq 0x78(%rbx), %r14
movq 0x78(%rbx), %rdi
cmpq %r14, %rdi
je 0x13428
movq (%rdi), %r12
movl $0x18, %esi
callq 0x42a0
movq %r12, %rdi
cmpq %r14, %r12
jne 0x13413
movq (%r15), %rdi
cmpq %r15, %rdi
je 0x13445
movq (%rdi), %r14
movl $0x18, %esi
callq 0x42a0
movq %r14, %rdi
cmpq %r15, %r14
jne 0x13430
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x18660
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::getDamageReductionFactor() const
double Hero::getDamageReductionFactor() const {
	double result = 0.0;

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

	return result;
}

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

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

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

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

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x78(%rdi), %r15
movq 0x78(%rdi), %r14
cmpq %r15, %r14
je 0x13f69
movq %rdi, %rbx
movq 0x10(%r14), %rdi
callq 0x1a216
movq 0x10(%r14), %rdi
callq 0x1a212
cmpl $-0x1, %eax
je 0x13e68
movq %r14, %r12
jmp 0x13f5c
movq 0x10(%r14), %rdi
callq 0x1a20c
movsd %xmm0, 0x8(%rsp)
movq 0x10(%r14), %rdi
callq 0x1a200
movsd %xmm0, 0x10(%rsp)
movq 0x10(%r14), %rdi
callq 0x1a206
movsd 0x8(%rsp), %xmm4
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm4
jne 0x13ea1
jnp 0x13ec6
movapd %xmm4, %xmm1
addsd 0x7e93(%rip), %xmm1     # 0x1bd40
xorps %xmm2, %xmm2
cvtsi2sdl 0x98(%rbx), %xmm2
divsd %xmm1, %xmm2
cvttsd2si %xmm2, %eax
movl %eax, 0x98(%rbx)
movsd 0x10(%rsp), %xmm2
ucomisd %xmm3, %xmm2
jne 0x13ed4
jnp 0x13ef0
addsd 0x7e64(%rip), %xmm2     # 0x1bd40
movsd 0xa0(%rbx), %xmm1
divsd %xmm2, %xmm1
movsd %xmm1, 0xa0(%rbx)
ucomisd %xmm3, %xmm0
jne 0x13ef8
jnp 0x13f0e
movapd %xmm0, %xmm1
addsd 0x7e3c(%rip), %xmm1     # 0x1bd40
cvttsd2si %xmm1, %eax
movl %eax, 0xa8(%rbx)
cmpneqsd %xmm3, %xmm0
cmpneqsd %xmm3, %xmm4
movq %xmm4, %rax
subl %eax, 0x98(%rbx)
movq %xmm0, %rax
subl %eax, 0xa8(%rbx)
movq (%r14), %r12
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x13f40
movq (%rdi), %rax
callq *0x8(%rax)
decq 0x88(%rbx)
movq %r14, %rdi
callq 0x43f0
movl $0x18, %esi
movq %r14, %rdi
callq 0x42a0
movq (%r12), %r14
cmpq %r15, %r14
jne 0x13e49
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::levelUp()
void Hero::levelUp() {
	level++;			// These are common for all Heroes.
	strength += 10;
	agility += 10;
	dexterity += 10;
	magicPower += 5;
}

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x186ae
testb %al, %al
je 0x14032
movl 0xb0(%rbx), %eax
xorl 0xb0(%r14), %eax
movl 0xac(%rbx), %ecx
xorl 0xac(%r14), %ecx
movl 0xa8(%rbx), %edx
xorl 0xa8(%r14), %edx
movsd 0xa0(%r14), %xmm0
ucomisd 0xa0(%rbx), %xmm0
setnp %sil
sete %dil
andb %sil, %dil
movl 0x94(%r14), %esi
movl 0x98(%rbx), %r8d
xorl 0x98(%r14), %r8d
xorl 0x94(%rbx), %esi
orl %r8d, %esi
orl %ecx, %edx
orl %esi, %edx
orl %eax, %edx
sete %al
andb %dil, %al
jmp 0x14034
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::moveUp()
void Hero :: moveUp() {
  int heroY = this->getPosition().getY();
  int heroX = this->getPosition().getX();

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x18724
movq %rax, %rdi
callq 0x18736
movl %eax, %r14d
movq %rbx, %rdi
callq 0x18724
movq %rax, %rdi
callq 0x18732
movl %eax, %ebp
movq 0x8(%rbx), %rdi
callq 0x67c4
decl %eax
cmpl %eax, %r14d
je 0x140dc
movq 0x8(%rbx), %rdi
leal 0x1(%r14), %r15d
movl %r15d, %esi
movl %ebp, %edx
callq 0x684e
movq %rax, %rdi
callq 0x6652
testb %al, %al
jne 0x14134
movq 0x8(%rbx), %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x6918
movq %rbx, %rdi
callq 0x18724
movq %rax, %rdi
movl %r15d, %esi
callq 0x1873e
movq 0x8(%rbx), %rdi
movl %r15d, %esi
movl %ebp, %edx
movq %rbx, %rcx
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x686a
movl $0x28, %edi
callq 0x4130
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7cf8(%rip), %rsi      # 0x1bdf1
leaq 0x7d0e(%rip), %rdx      # 0x1be0e
leaq 0x8(%rsp), %rdi
callq 0x6520
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4c58
xorl %ebp, %ebp
leaq 0x10515(%rip), %rsi     # 0x24638
leaq -0xf488(%rip), %rdx     # 0x4ca2
movq %rbx, %rdi
callq 0x4410
jmp 0x1418a
movl $0x28, %edi
callq 0x4130
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7cbe(%rip), %rsi      # 0x1be0f
leaq 0x7cde(%rip), %rdx      # 0x1be36
leaq 0x8(%rsp), %rdi
callq 0x6520
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4c58
xorl %ebp, %ebp
leaq 0x104bd(%rip), %rsi     # 0x24638
leaq -0xf4e0(%rip), %rdx     # 0x4ca2
movq %rbx, %rdi
callq 0x4410
jmp 0x1418e
jmp 0x141aa
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x141b0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x141b0
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x141bd
movq %rbx, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::moveDown()
void Hero :: moveDown() {
  int heroY = this->getPosition().getY();
  int heroX = this->getPosition().getX();
 
  if (heroY == 0) {
    throw HeroMoveException("You can't  down any further");
  } else if (this->grid->getTile(heroY - 1, heroX).isNonAccessible()) {
    throw HeroMoveException("You can't move in a non accessible tile");
  } else {
    this->grid->removeLiving(heroY, heroX, this);
    this->getPosition().setY(heroY - 1);
    this->grid->addLiving(heroY - 1, heroX, this);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x18724
movq %rax, %rdi
callq 0x18736
movl %eax, %r14d
movq %rbx, %rdi
callq 0x18724
movq %rax, %rdi
callq 0x18732
testl %r14d, %r14d
je 0x1425b
movl %eax, %ebp
movq 0x8(%rbx), %rdi
leal -0x1(%r14), %r15d
movl %r15d, %esi
movl %eax, %edx
callq 0x684e
movq %rax, %rdi
callq 0x6652
testb %al, %al
jne 0x142b3
movq 0x8(%rbx), %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x6918
movq %rbx, %rdi
callq 0x18724
movq %rax, %rdi
movl %r15d, %esi
callq 0x1873e
movq 0x8(%rbx), %rdi
movl %r15d, %esi
movl %ebp, %edx
movq %rbx, %rcx
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x686a
movl $0x28, %edi
callq 0x4130
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7bbf(%rip), %rsi      # 0x1be37
leaq 0x7bd3(%rip), %rdx      # 0x1be52
leaq 0x8(%rsp), %rdi
callq 0x6520
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4c58
xorl %ebp, %ebp
leaq 0x10396(%rip), %rsi     # 0x24638
leaq -0xf607(%rip), %rdx     # 0x4ca2
movq %rbx, %rdi
callq 0x4410
jmp 0x14309
movl $0x28, %edi
callq 0x4130
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7b3f(%rip), %rsi      # 0x1be0f
leaq 0x7b5f(%rip), %rdx      # 0x1be36
leaq 0x8(%rsp), %rdi
callq 0x6520
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4c58
xorl %ebp, %ebp
leaq 0x1033e(%rip), %rsi     # 0x24638
leaq -0xf65f(%rip), %rdx     # 0x4ca2
movq %rbx, %rdi
callq 0x4410
jmp 0x1430d
jmp 0x14329
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1432f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x1432f
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1433c
movq %rbx, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O1/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::moveLeft()
void Hero :: moveLeft() {
  int heroY = this->getPosition().getY();
  int heroX = this->getPosition().getX();

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x18724
movq %rax, %rdi
callq 0x18736
movl %eax, %ebp
movq %rbx, %rdi
callq 0x18724
movq %rax, %rdi
callq 0x18732
testl %eax, %eax
je 0x143d8
movl %eax, %r15d
movq 0x8(%rbx), %rdi
leal -0x1(%r15), %r14d
movl %ebp, %esi
movl %r14d, %edx
callq 0x684e
movq %rax, %rdi
callq 0x6652
testb %al, %al
jne 0x14430
movq 0x8(%rbx), %rdi
movl %ebp, %esi
movl %r15d, %edx
movq %rbx, %rcx
callq 0x6918
movq %rbx, %rdi
callq 0x18724
movq %rax, %rdi
movl %r14d, %esi
callq 0x1873a
movq 0x8(%rbx), %rdi
movl %ebp, %esi
movl %r14d, %edx
movq %rbx, %rcx
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x686a
movl $0x28, %edi
callq 0x4130
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7a5e(%rip), %rsi      # 0x1be53
leaq 0x7a76(%rip), %rdx      # 0x1be72
leaq 0x8(%rsp), %rdi
callq 0x6520
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4c58
xorl %ebp, %ebp
leaq 0x10219(%rip), %rsi     # 0x24638
leaq -0xf784(%rip), %rdx     # 0x4ca2
movq %rbx, %rdi
callq 0x4410
jmp 0x14486
movl $0x28, %edi
callq 0x4130
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x79c2(%rip), %rsi      # 0x1be0f
leaq 0x79e2(%rip), %rdx      # 0x1be36
leaq 0x8(%rsp), %rdi
callq 0x6520
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4c58
xorl %ebp, %ebp
leaq 0x101c1(%rip), %rsi     # 0x24638
leaq -0xf7dc(%rip), %rdx     # 0x4ca2
movq %rbx, %rdi
callq 0x4410
jmp 0x1448a
jmp 0x144a6
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x144ac
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x144ac
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x144b9
movq %rbx, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x4430
nop