LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x67a8
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 0x6c12
cmpl $0x0, (%r15)
movq %r14, 0x10(%rsp)
je 0x6786
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 0x6c3e
addq $0x2, %r12
movq %r13, %rdi
callq 0x65fa
incq %r14
movslq (%r15), %rax
cmpq %rax, %r14
jne 0x673c
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x6c8e
movq 0x10(%rsp), %r14
incq %r14
movslq 0x4(%r15), %rax
cmpq %rax, %r14
jne 0x6708
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x67c9
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x65fa
leaq 0x20(%rsp), %rdi
callq 0x6c8e
movq 0x8(%rsp), %rdi
callq 0x6cd6
movq %r14, %rdi
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x682c
movq 0x1e7ca(%rip), %rbx     # 0x24fe8
leaq 0x14b4b(%rip), %rsi     # 0x1b370
movl $0x2d, %edx
jmp 0x6848
leaq (%rax,%rdx,8), %rax
cmpb $0x1, (%rax)
jne 0x6878
movq 0x1e7ac(%rip), %rbx     # 0x24fe8
leaq 0x14b5b(%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_O3/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 0x68d7
cmpq %rbx, 0x10(%rax)
jne 0x68c7
jmp 0x6941
cmpb $0x1, (%r15)
jne 0x6924
movq 0x1e704(%rip), %rbx     # 0x24fe8
leaq 0x14ae3(%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_O3/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 0x1d326(%rip), %r14     # 0x25270
movq (%rbx), %rax
movq -0x18(%rax), %rdi
testb $0x2, 0x20(%rbx,%rdi)
jne 0x7f7f
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4460
movq %r14, %rdi
callq 0x8745
testb %al, %al
jne 0x7f4a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1d2b8(%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 0x8029
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 0x800c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc588
incq %r13
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x4090
jmp 0x7fc2
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8045
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 0x8056
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8075
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13536
movq %rax, %rdi
callq 0x4f7c
movq %rbx, %rdi
callq 0x13536
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
movq %rbx, %rdi
callq 0x13536
movq %rax, %rdi
callq 0x4ff8
testl %eax, %eax
je 0x883b
movl %eax, %r14d
leaq 0x12c7f(%rip), %r15     # 0x1b448
movq %rbx, %rdi
callq 0x13536
movq %rax, %rdi
callq 0x4f7c
decl %r14d
cmpl $0x3, %r14d
ja 0x8814
movslq (%r15,%r14,4), %rax
addq %r15, %rax
jmpq *%rax
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
jmp 0x8814
callq 0x8c64
movq %rbx, %rdi
callq 0x13536
movq %rax, %rdi
callq 0x4f7c
cmpb $0x0, 0x1ca57(%rip)     # 0x25269
jne 0x883b
movq %rbx, %rdi
callq 0x13536
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
movq %rbx, %rdi
callq 0x13536
movq %rax, %rdi
callq 0x4ff8
movl %eax, %r14d
testl %eax, %eax
jne 0x87c9
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x14fec
movq %rbx, %rdi
callq 0x16822
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x8863
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1abd8(%rip), %rdi     # 0x25338
leaq 0x10e66(%rip), %rsi     # 0x1b5cd
movl $0x8, %edx
callq 0x4170
leaq 0x1ac38(%rip), %rdi     # 0x253b0
callq 0x40a0
testb %al, %al
je 0xa783
popq %rax
retq
movq 0x1a85e(%rip), %rdi     # 0x24fe8
leaq 0x112ef(%rip), %rsi     # 0x1ba80
callq 0x4280
movq %rax, %rdi
callq 0x4120
movl $0x1, %edi
callq 0x4310
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1a7fb(%rip), %r14     # 0x24fc0
leaq 0x11322(%rip), %r12     # 0x1baee
leaq 0x10899(%rip), %r13     # 0x1b06c
movq 0x1a7f6(%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 0x1129d(%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 0xa7e4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1ac42(%rip), %rbx     # 0x25540
testq %rbx, %rbx
je 0xa90b
movq %rbx, %rdi
callq 0x67e6
movl $0x20, %esi
movq %rbx, %rdi
callq 0x42a0
movq 0x1a971(%rip), %rax     # 0x25290
cmpq %rax, 0x1a972(%rip)     # 0x25298
je 0xa92f
movq %rax, 0x1a969(%rip)     # 0x25298
movq 0x1a972(%rip), %rsi     # 0x252a8
leaq 0x1a96b(%rip), %rdi     # 0x252a8
callq 0xc5c6
movq 0x1a977(%rip), %rsi     # 0x252c0
leaq 0x1a970(%rip), %rdi     # 0x252c0
callq 0xc5c6
movq 0x1a97c(%rip), %rsi     # 0x252d8
leaq 0x1a975(%rip), %rdi     # 0x252d8
callq 0xc5c6
movq 0x1a981(%rip), %rsi     # 0x252f0
leaq 0x1a97a(%rip), %rdi     # 0x252f0
callq 0xc5c6
movq 0x1a986(%rip), %rsi     # 0x25308
leaq 0x1a97f(%rip), %rdi     # 0x25308
callq 0xc5c6
leaq 0x1a9a3(%rip), %rdi     # 0x25338
callq 0x4070
movb $0x0, 0x1a8c8(%rip)     # 0x25269
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa758
callq 0xa4b5
callq 0xa7a8
movl %eax, %ebx
callq 0x7c5a
movl %ebx, %edi
callq 0x9b27
cmpb $0x0, 0x1a89b(%rip)     # 0x25269
jne 0xaa3e
xorl %ebp, %ebp
xorl %r15d, %r15d
xorl %eax, %eax
movl %r15d, %ecx
movq 0x1a8af(%rip), %rdx     # 0x25290
movq (%rdx,%rcx,8), %r14
incl %r15d
cmpl %ebx, %r15d
cmovel %ebp, %r15d
testb $0x1, %al
jne 0xaa2b
movq %r14, %rdi
callq 0x1353e
movq %rax, %rdi
movl %ebx, %esi
callq 0x66a0
testb %al, %al
je 0xaa2b
movsd 0x10a2f(%rip), %xmm0    # 0x1b440
callq 0x4dbc
testb %al, %al
je 0xaa2b
callq 0x8eda
movq %r14, %rdi
callq 0x13eb2
movb $0x1, %al
jmp 0xaa35
movq %r14, %rdi
callq 0x8786
xorl %eax, %eax
cmpb $0x0, 0x1a82d(%rip)     # 0x25269
je 0xa9d7
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa8f6
// File: /workspace/github_cpp_makefile_star2_O3/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 0xac8f
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 0xac6d
retq
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19be7(%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 0xb428
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rsp, %r14
movb $0x2b, (%r14)
movq 0x19b8a(%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 0xb482
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rsp, %r14
movb $0x2b, (%r14)
movq 0x19b30(%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 0xb4dc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rsp, %r14
movb $0x2b, (%r14)
movq 0x19ad6(%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 0xb536
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rsp, %rsi
movb $0x2b, (%rsi)
movq 0x19a7d(%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 0xb58d
jmp 0xb5a8
jmp 0xb58d
jmp 0xb5a8
jmp 0xb58d
jmp 0xb5a8
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xb5ab
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0xb5ab
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O3/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 0x199f7(%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 0xb618
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rsp, %r14
movb $0x2b, (%r14)
movq 0x1999a(%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 0xb672
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rsp, %r14
movb $0x2b, (%r14)
movq 0x19940(%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 0xb6cc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rsp, %r14
movb $0x2b, (%r14)
movq 0x198e6(%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 0xb726
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rsp, %r14
movb $0x2b, (%r14)
movq 0x1988c(%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 0xb780
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rsp, %rsi
movb $0x2b, (%rsi)
movq 0x19833(%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 0xb7db
jmp 0xb7f6
jmp 0xb7db
jmp 0xb7f6
jmp 0xb7db
jmp 0xb7f6
jmp 0xb7db
jmp 0xb7f6
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xb7f9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0xb7f9
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O3/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), %r14
cmpq %r15, %r14
je 0xc9bb
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xc99c
movq (%rdi), %rax
callq *0x8(%rax)
movq (%r15), %r14
decq 0x18(%rbx)
movq %r14, %rdi
callq 0x43f0
movl $0x18, %esi
movq %r14, %rdi
callq 0x42a0
movq 0x8(%rbx), %r14
jmp 0xc985
leaq 0x20(%rbx), %r12
movq 0x20(%rbx), %r14
cmpq %r12, %r14
je 0xc9f6
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xc9db
movq (%rdi), %rax
callq *0x8(%rax)
movq (%r12), %r14
decq 0x30(%rbx)
movq %r14, %rdi
callq 0x43f0
movl $0x18, %esi
movq %r14, %rdi
callq 0x42a0
jmp 0xc9bf
leaq 0x17c53(%rip), %rax     # 0x24650
addq $0x10, %rax
movq %rax, 0x38(%rbx)
leaq 0x40(%rbx), %rdi
callq 0x627c
movq 0x20(%rbx), %rdi
cmpq %r12, %rdi
je 0xca2c
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x42a0
movq %rbx, %rdi
cmpq %r12, %rbx
jne 0xca17
movq (%r15), %rdi
cmpq %r15, %rdi
je 0xca49
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x42a0
movq %rbx, %rdi
cmpq %r15, %rbx
jne 0xca34
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf48f(%rip), %r15      # 0x1bf37
movq %rbx, %r13
movq (%r13), %r13
cmpq %rbx, %r13
je 0xcae9
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 0xcae5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
testl %ebp, %ebp
jne 0xcaab
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_O3/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 0xebbb
addq $0x8, %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0xf316
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xebb5
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
movq 0x163fe(%rip), %rbx     # 0x24fc0
leaq 0xd0b2(%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_O3/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 0xec39
addq $0x20, %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0xf3a8
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xec33
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
movq 0x16380(%rip), %rbx     # 0x24fc0
leaq 0xd054(%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_O3/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 0xeca6
addq $0x8, %rdi
leaq 0x8(%rsp), %rsi
callq 0xf316
addq $0x10, %rsp
popq %rbx
retq
movq 0x16313(%rip), %rbx     # 0x24fc0
leaq 0xcfc7(%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_O3/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 0xed14
addq $0x20, %rdi
leaq 0x8(%rsp), %rsi
callq 0xf3a8
addq $0x10, %rsp
popq %rbx
retq
movq 0x162a5(%rip), %rbx     # 0x24fc0
leaq 0xcf59(%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_O3/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, %rbx
addq $0x8, %rbx
leaq 0x8(%rsp), %r12
movq %rbx, %r15
movq (%r15), %r15
cmpq %rbx, %r15
je 0xedef
movq 0x10(%r15), %rsi
movq %r12, %rdi
callq 0x1a7d8
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0xedbe
movq 0x8(%rsp), %r13
testq %rdx, %rdx
je 0xedc7
movq (%r14), %rsi
movq %r13, %rdi
callq 0x42b0
testl %eax, %eax
sete %bpl
jmp 0xedca
movq 0x8(%rsp), %r13
xorl %ebp, %ebp
jmp 0xedca
movb $0x1, %bpl
leaq 0x18(%rsp), %rax
cmpq %rax, %r13
je 0xede4
movq 0x18(%rsp), %rsi
incq %rsi
movq %r13, %rdi
callq 0x42a0
testb %bpl, %bpl
je 0xed82
movq 0x10(%r15), %rax
jmp 0xedf1
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_O3/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 0xee50
movq %rsi, %r14
xorl %ebx, %ebx
movq 0x10(%r12), %rdi
callq 0x13128
movq 0x8(%rax), %rdx
cmpq 0x8(%r14), %rdx
jne 0xee45
testq %rdx, %rdx
je 0xee54
movq (%r14), %rsi
movq (%rax), %rdi
callq 0x42b0
testl %eax, %eax
je 0xee54
movq (%r12), %r12
cmpq %r15, %r12
jne 0xee1d
jmp 0xee59
xorl %ebx, %ebx
jmp 0xee59
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_O3/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), %r14
cmpq %r15, %r14
je 0xfdaf
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xfd90
movq (%rdi), %rax
callq *0x8(%rax)
movq (%r15), %r14
decq 0x18(%rbx)
movq %r14, %rdi
callq 0x43f0
movl $0x18, %esi
movq %r14, %rdi
callq 0x42a0
movq 0x8(%rbx), %r14
jmp 0xfd79
leaq 0x20(%rbx), %r12
movq 0x20(%rbx), %r14
cmpq %r12, %r14
je 0xfdea
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xfdcf
movq (%rdi), %rax
callq *0x8(%rax)
movq (%r12), %r14
decq 0x30(%rbx)
movq %r14, %rdi
callq 0x43f0
movl $0x18, %esi
movq %r14, %rdi
callq 0x42a0
jmp 0xfdb3
leaq 0x1485f(%rip), %rax     # 0x24650
addq $0x10, %rax
movq %rax, 0x38(%rbx)
leaq 0x40(%rbx), %rdi
callq 0x627c
movq 0x20(%rbx), %rdi
cmpq %r12, %rdi
je 0xfe20
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x42a0
movq %rbx, %rdi
cmpq %r12, %rbx
jne 0xfe0b
movq (%r15), %rdi
cmpq %r15, %rdi
je 0xfe3d
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x42a0
movq %rbx, %rdi
cmpq %r15, %rbx
jne 0xfe28
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
addq $0x8, %rbx
leaq 0x8(%rsp), %r12
movq %rbx, %r15
movq (%r15), %r15
cmpq %rbx, %r15
je 0x11f77
movq 0x10(%r15), %rsi
movq %r12, %rdi
callq 0x1a7d8
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x11f46
movq 0x8(%rsp), %r13
testq %rdx, %rdx
je 0x11f4f
movq (%r14), %rsi
movq %r13, %rdi
callq 0x42b0
testl %eax, %eax
sete %bpl
jmp 0x11f52
movq 0x8(%rsp), %r13
xorl %ebp, %ebp
jmp 0x11f52
movb $0x1, %bpl
leaq 0x18(%rsp), %rax
cmpq %rax, %r13
je 0x11f6c
movq 0x18(%rsp), %rsi
incq %rsi
movq %r13, %rdi
callq 0x42a0
testb %bpl, %bpl
je 0x11f0a
movq 0x10(%r15), %rax
jmp 0x11f79
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_O3/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 0x11fd8
movq %rsi, %r14
xorl %ebx, %ebx
movq 0x10(%r12), %rdi
callq 0x13128
movq 0x8(%rax), %rdx
cmpq 0x8(%r14), %rdx
jne 0x11fcd
testq %rdx, %rdx
je 0x11fdc
movq (%r14), %rsi
movq (%rax), %rdi
callq 0x42b0
testl %eax, %eax
je 0x11fdc
movq (%r12), %r12
cmpq %r15, %r12
jne 0x11fa5
jmp 0x11fe1
xorl %ebx, %ebx
jmp 0x11fe1
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_O3/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 0x13144
movl %eax, %ecx
movl 0x50(%r14), %eax
cmpl 0x50(%rbx), %eax
sete %al
testb %cl, %cl
je 0x12528
movsd 0x48(%r14), %xmm0
ucomisd 0x48(%rbx), %xmm0
jne 0x12528
jnp 0x1252a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13144
movl %eax, %ecx
movl 0x50(%r14), %eax
cmpl 0x50(%rbx), %eax
sete %al
testb %cl, %cl
je 0x12aa8
movsd 0x48(%r14), %xmm0
ucomisd 0x48(%rbx), %xmm0
jne 0x12aa8
jnp 0x12aaa
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13144
movl %eax, %ecx
movl 0x50(%r14), %eax
cmpl 0x50(%rbx), %eax
sete %al
testb %cl, %cl
je 0x13028
movsd 0x48(%r14), %xmm0
ucomisd 0x48(%rbx), %xmm0
jne 0x13028
jnp 0x1302a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1151a(%rip), %rax     # 0x248e0
movq %rax, (%rdi)
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x133d8
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x133e7
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x133f6
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x60(%rbx), %r15
movq 0x60(%rbx), %r14
cmpq %r15, %r14
je 0x13430
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x13415
movq (%rdi), %rax
callq *0x8(%rax)
movq (%r15), %r14
decq 0x70(%rbx)
movq %r14, %rdi
callq 0x43f0
movl $0x18, %esi
movq %r14, %rdi
callq 0x42a0
jmp 0x133fa
leaq 0x11219(%rip), %r14     # 0x24650
addq $0x10, %r14
movq %r14, 0x138(%rbx)
leaq 0x140(%rbx), %rdi
callq 0x627c
movq %r14, 0x118(%rbx)
leaq 0x120(%rbx), %rdi
callq 0x627c
leaq 0xc0(%rbx), %rdi
callq 0xc972
leaq 0x78(%rbx), %r14
movq 0x78(%rbx), %rdi
cmpq %r14, %rdi
je 0x1348f
movq (%rdi), %r12
movl $0x18, %esi
callq 0x42a0
movq %r12, %rdi
cmpq %r14, %r12
jne 0x1347a
movq (%r15), %rdi
cmpq %r15, %rdi
je 0x134ac
movq (%rdi), %r14
movl $0x18, %esi
callq 0x42a0
movq %r14, %rdi
cmpq %r15, %r14
jne 0x13497
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x186c8
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13532
pushq %rax
callq 0x19e8c
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
addsd %xmm1, %xmm0
addq $0x8, %rsp
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13fe7
movq %rdi, %rbx
movq 0x10(%r14), %rdi
callq 0x1a2ba
movq 0x10(%r14), %rdi
callq 0x1a2b6
cmpl $-0x1, %eax
je 0x13ef0
movq %r14, %r12
jmp 0x13fda
movq 0x10(%r14), %rdi
callq 0x1a2b0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%r14), %rdi
callq 0x1a2a4
movsd %xmm0, 0x10(%rsp)
movq 0x10(%r14), %rdi
callq 0x1a2aa
movsd 0x8(%rsp), %xmm5
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm5
movsd 0x7e23(%rip), %xmm4     # 0x1bd50
jne 0x13f31
jnp 0x13f52
movapd %xmm5, %xmm1
addsd %xmm4, %xmm1
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 0x13f60
jnp 0x13f78
addsd %xmm4, %xmm2
movsd 0xa0(%rbx), %xmm1
divsd %xmm2, %xmm1
movsd %xmm1, 0xa0(%rbx)
movapd %xmm0, %xmm1
addsd %xmm4, %xmm1
cvttsd2si %xmm1, %eax
cmpneqsd %xmm3, %xmm5
movq %xmm5, %rcx
subl %ecx, 0x98(%rbx)
incl %eax
ucomisd %xmm3, %xmm0
movl 0xa8(%rbx), %ecx
cmovnel %eax, %ecx
cmovpl %eax, %ecx
movl %ecx, 0xa8(%rbx)
movq (%r14), %r12
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x13fbe
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 0x13ed1
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/arisKoutsou[P]oopproj/./src/livings/Hero.cpp
// Function: Hero::levelUp()
void Hero::levelUp() {
	level++;			// These are common for all Heroes.
	strength += 10;
	agility += 10;
	dexterity += 10;
	magicPower += 5;
}

// Assembly:
incl 0x10(%rdi)
movsd 0xa0(%rdi), %xmm0
addsd 0x7d51(%rip), %xmm0     # 0x1bd58
movsd %xmm0, 0xa0(%rdi)
addl $0xa, 0xa8(%rdi)
movq 0x94(%rdi), %xmm0
paddd 0x7d1a(%rip), %xmm0     # 0x1bd40
movq %xmm0, 0x94(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18716
testb %al, %al
je 0x140ae
movl 0xb0(%rbx), %eax
xorl 0xb0(%r14), %eax
movdqu 0xa8(%r14), %xmm0
movdqu 0xa8(%rbx), %xmm1
movsd 0xa0(%r14), %xmm2
ucomisd 0xa0(%rbx), %xmm2
setnp %cl
sete %dl
andb %cl, %dl
movdqu 0x94(%r14), %xmm2
punpcklqdq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0]
movdqu 0x94(%rbx), %xmm0
punpcklqdq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0]
pcmpeqd %xmm2, %xmm0
movmskps %xmm0, %ecx
xorl $0xf, %ecx
orl %eax, %ecx
sete %al
andb %dl, %al
jmp 0x140b0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x187a8
movq %rax, %rdi
callq 0x187ba
movl %eax, %r14d
movq %rbx, %rdi
callq 0x187a8
movq %rax, %rdi
callq 0x187b6
movl %eax, %ebp
movq 0x8(%rbx), %rdi
callq 0x67f4
decl %eax
cmpl %eax, %r14d
je 0x14158
movq 0x8(%rbx), %rdi
leal 0x1(%r14), %r15d
movl %r15d, %esi
movl %ebp, %edx
callq 0x687e
movq %rax, %rdi
callq 0x6682
testb %al, %al
jne 0x141b0
movq 0x8(%rbx), %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x6948
movq %rbx, %rdi
callq 0x187a8
movq %rax, %rdi
movl %r15d, %esi
callq 0x187c2
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 0x689a
movl $0x28, %edi
callq 0x4130
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7c8c(%rip), %rsi      # 0x1be01
leaq 0x7ca2(%rip), %rdx      # 0x1be1e
leaq 0x8(%rsp), %rdi
callq 0x654a
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4c58
xorl %ebp, %ebp
leaq 0x10499(%rip), %rsi     # 0x24638
leaq -0xf504(%rip), %rdx     # 0x4ca2
movq %rbx, %rdi
callq 0x4410
jmp 0x14206
movl $0x28, %edi
callq 0x4130
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7c52(%rip), %rsi      # 0x1be1f
leaq 0x7c72(%rip), %rdx      # 0x1be46
leaq 0x8(%rsp), %rdi
callq 0x654a
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4c58
xorl %ebp, %ebp
leaq 0x10441(%rip), %rsi     # 0x24638
leaq -0xf55c(%rip), %rdx     # 0x4ca2
movq %rbx, %rdi
callq 0x4410
jmp 0x1420a
jmp 0x1422b
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x14224
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
testb %bpl, %bpl
jne 0x1422e
jmp 0x14236
movq %rax, %r14
movq %rbx, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O3/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 0x187a8
movq %rax, %rdi
callq 0x187ba
movl %eax, %r14d
movq %rbx, %rdi
callq 0x187a8
movq %rax, %rdi
callq 0x187b6
testl %r14d, %r14d
je 0x142d3
movl %eax, %ebp
movq 0x8(%rbx), %rdi
leal -0x1(%r14), %r15d
movl %r15d, %esi
movl %eax, %edx
callq 0x687e
movq %rax, %rdi
callq 0x6682
testb %al, %al
jne 0x1432b
movq 0x8(%rbx), %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x6948
movq %rbx, %rdi
callq 0x187a8
movq %rax, %rdi
movl %r15d, %esi
callq 0x187c2
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 0x689a
movl $0x28, %edi
callq 0x4130
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7b57(%rip), %rsi      # 0x1be47
leaq 0x7b6b(%rip), %rdx      # 0x1be62
leaq 0x8(%rsp), %rdi
callq 0x654a
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4c58
xorl %ebp, %ebp
leaq 0x1031e(%rip), %rsi     # 0x24638
leaq -0xf67f(%rip), %rdx     # 0x4ca2
movq %rbx, %rdi
callq 0x4410
jmp 0x14381
movl $0x28, %edi
callq 0x4130
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7ad7(%rip), %rsi      # 0x1be1f
leaq 0x7af7(%rip), %rdx      # 0x1be46
leaq 0x8(%rsp), %rdi
callq 0x654a
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4c58
xorl %ebp, %ebp
leaq 0x102c6(%rip), %rsi     # 0x24638
leaq -0xf6d7(%rip), %rdx     # 0x4ca2
movq %rbx, %rdi
callq 0x4410
jmp 0x14385
jmp 0x143a6
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1439f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
testb %bpl, %bpl
jne 0x143a9
jmp 0x143b1
movq %rax, %r14
movq %rbx, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x187a8
movq %rax, %rdi
callq 0x187ba
movl %eax, %ebp
movq %rbx, %rdi
callq 0x187a8
movq %rax, %rdi
callq 0x187b6
testl %eax, %eax
je 0x1444e
movl %eax, %r15d
movq 0x8(%rbx), %rdi
leal -0x1(%r15), %r14d
movl %ebp, %esi
movl %r14d, %edx
callq 0x687e
movq %rax, %rdi
callq 0x6682
testb %al, %al
jne 0x144a6
movq 0x8(%rbx), %rdi
movl %ebp, %esi
movl %r15d, %edx
movq %rbx, %rcx
callq 0x6948
movq %rbx, %rdi
callq 0x187a8
movq %rax, %rdi
movl %r14d, %esi
callq 0x187be
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 0x689a
movl $0x28, %edi
callq 0x4130
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x79f8(%rip), %rsi      # 0x1be63
leaq 0x7a10(%rip), %rdx      # 0x1be82
leaq 0x8(%rsp), %rdi
callq 0x654a
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4c58
xorl %ebp, %ebp
leaq 0x101a3(%rip), %rsi     # 0x24638
leaq -0xf7fa(%rip), %rdx     # 0x4ca2
movq %rbx, %rdi
callq 0x4410
jmp 0x144fc
movl $0x28, %edi
callq 0x4130
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x795c(%rip), %rsi      # 0x1be1f
leaq 0x797c(%rip), %rdx      # 0x1be46
leaq 0x8(%rsp), %rdi
callq 0x654a
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4c58
xorl %ebp, %ebp
leaq 0x1014b(%rip), %rsi     # 0x24638
leaq -0xf852(%rip), %rdx     # 0x4ca2
movq %rbx, %rdi
callq 0x4410
jmp 0x14500
jmp 0x14521
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1451a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
testb %bpl, %bpl
jne 0x14524
jmp 0x1452c
movq %rax, %r14
movq %rbx, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x4430