LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: arisKoutsou[P]oopproj/./src/menu/Menu.cpp
// Function: Menu::displayMenu() const
void Menu :: displayMenu() const {
  cout << endl << endl;
  for (size_t i = 0; i != options.size(); ++i) {
    cout << i + 1 << ". " << options[i] << endl;
  }
  cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x39ee5(%rip), %rdi     # 0x3ffc0
movq 0x39ebe(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, %rdi
movq 0x39eaf(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x6390
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
je 0x6183
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
movq 0x39e92(%rip), %rdi     # 0x3ffc0
callq 0x50b0
movq %rax, %rdi
leaq 0x27ee3(%rip), %rsi     # 0x2e020
callq 0x52f0
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x63b0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x52a0
movq %rax, %rdi
movq 0x39e33(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x60fe
movq 0x39e36(%rip), %rdi     # 0x3ffc0
movq 0x39e0f(%rip), %rsi     # 0x3ffa0
callq 0x5330
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: arisKoutsou[P]oopproj/./src/menu/Menu.cpp
// Function: Menu::getSelection()
int Menu :: getSelection() {
  string input;
  int option;
  do {
    cout << endl << "Please enter an option: "
	 << endl << endl << "> ";
    getline(cin, input);
    option = atoi(input.c_str());
  } while (option < 1 || option > options.size());
  return option;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5460
movq 0x39d59(%rip), %rdi     # 0x3ffc0
movq 0x39d32(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, -0x50(%rbp)
jmp 0x6279
movq -0x50(%rbp), %rdi
leaq 0x27d9f(%rip), %rsi     # 0x2e023
callq 0x52f0
movq %rax, -0x58(%rbp)
jmp 0x628f
movq -0x58(%rbp), %rdi
movq 0x39d06(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, -0x60(%rbp)
jmp 0x62a5
movq -0x60(%rbp), %rdi
movq 0x39cf0(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, -0x68(%rbp)
jmp 0x62bb
movq -0x68(%rbp), %rdi
leaq 0x27d76(%rip), %rsi     # 0x2e03c
callq 0x52f0
jmp 0x62cd
movq 0x39d04(%rip), %rdi     # 0x3ffd8
leaq -0x28(%rbp), %rsi
callq 0x5070
jmp 0x62df
leaq -0x28(%rbp), %rdi
callq 0x5110
movq %rax, %rdi
callq 0x54c0
movl %eax, -0x2c(%rbp)
movb $0x1, %al
cmpl $0x1, -0x2c(%rbp)
movb %al, -0x69(%rbp)
jl 0x6323
movq -0x48(%rbp), %rdi
movslq -0x2c(%rbp), %rax
movq %rax, -0x78(%rbp)
addq $0x8, %rdi
callq 0x6390
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
seta %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x6260
movl -0x2c(%rbp), %eax
movl %eax, -0x7c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x55d0
movl -0x7c(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x55d0
movq -0x38(%rbp), %rdi
callq 0x5550
nopw (%rax,%rax)
// File: arisKoutsou[P]oopproj/./src/menu/AllMenus.cpp
// Function: BasicMenu::BasicMenu()
BasicMenu :: BasicMenu()
  : Menu() {
  options.push_back("Display stats");
  options.push_back("Check invnentory");
  options.push_back("Move");
  options.push_back("Go to Main Menu");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x6070
movq -0xd0(%rbp), %rax
leaq 0x3914b(%rip), %rcx     # 0x3f688
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, -0xc8(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x5560
movq -0xc0(%rbp), %rdx
leaq 0x27adc(%rip), %rsi     # 0x2e045
leaq -0x28(%rbp), %rdi
callq 0x7d20
jmp 0x6574
movq -0xc8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7cf0
jmp 0x6586
leaq -0x28(%rbp), %rdi
callq 0x55d0
leaq -0x29(%rbp), %rdi
callq 0x5350
movq -0xd0(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xe0(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x5560
movq -0xd8(%rbp), %rdx
leaq 0x27a8b(%rip), %rsi     # 0x2e053
leaq -0x60(%rbp), %rdi
callq 0x7d20
jmp 0x65d3
movq -0xe0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x7cf0
jmp 0x65e5
leaq -0x60(%rbp), %rdi
callq 0x55d0
leaq -0x61(%rbp), %rdi
callq 0x5350
movq -0xd0(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xf0(%rbp)
leaq -0x89(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x5560
movq -0xe8(%rbp), %rdx
leaq 0x27a3a(%rip), %rsi     # 0x2e064
leaq -0x88(%rbp), %rdi
callq 0x7d20
jmp 0x6638
movq -0xf0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x7cf0
jmp 0x664d
leaq -0x88(%rbp), %rdi
callq 0x55d0
leaq -0x89(%rbp), %rdi
callq 0x5350
movq -0xd0(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x100(%rbp)
leaq -0xb1(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x5560
movq -0xf8(%rbp), %rdx
leaq 0x279d1(%rip), %rsi     # 0x2e069
leaq -0xb0(%rbp), %rdi
callq 0x7d20
jmp 0x66a6
movq -0x100(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x7cf0
jmp 0x66bb
leaq -0xb0(%rbp), %rdi
callq 0x55d0
leaq -0xb1(%rbp), %rdi
callq 0x5350
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x66ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x55d0
leaq -0x29(%rbp), %rdi
callq 0x5350
jmp 0x67a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x6730
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x55d0
leaq -0x61(%rbp), %rdi
callq 0x5350
jmp 0x67a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x6761
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x55d0
leaq -0x89(%rbp), %rdi
callq 0x5350
jmp 0x67a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x6795
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x55d0
leaq -0xb1(%rbp), %rdi
callq 0x5350
movq -0xd0(%rbp), %rdi
callq 0x7dd0
movq -0x38(%rbp), %rdi
callq 0x5550
nopw %cs:(%rax,%rax)
// File: arisKoutsou[P]oopproj/./src/menu/AllMenus.cpp
// Function: MainMenu::MainMenu()
MainMenu :: MainMenu()
  : Menu() {
  options.push_back("Play");
  options.push_back("GenerateMap");
  options.push_back("Help");
  options.push_back("Quit");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x6070
movq -0xd0(%rbp), %rax
leaq 0x383cb(%rip), %rcx     # 0x3f6e8
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, -0xc8(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x5560
movq -0xc0(%rbp), %rdx
leaq 0x26ddf(%rip), %rsi     # 0x2e128
leaq -0x28(%rbp), %rdi
callq 0x7d20
jmp 0x7354
movq -0xc8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7cf0
jmp 0x7366
leaq -0x28(%rbp), %rdi
callq 0x55d0
leaq -0x29(%rbp), %rdi
callq 0x5350
movq -0xd0(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xe0(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x5560
movq -0xd8(%rbp), %rdx
leaq 0x26d85(%rip), %rsi     # 0x2e12d
leaq -0x60(%rbp), %rdi
callq 0x7d20
jmp 0x73b3
movq -0xe0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x7cf0
jmp 0x73c5
leaq -0x60(%rbp), %rdi
callq 0x55d0
leaq -0x61(%rbp), %rdi
callq 0x5350
movq -0xd0(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xf0(%rbp)
leaq -0x89(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x5560
movq -0xe8(%rbp), %rdx
leaq 0x26d2f(%rip), %rsi     # 0x2e139
leaq -0x88(%rbp), %rdi
callq 0x7d20
jmp 0x7418
movq -0xf0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x7cf0
jmp 0x742d
leaq -0x88(%rbp), %rdi
callq 0x55d0
leaq -0x89(%rbp), %rdi
callq 0x5350
movq -0xd0(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x100(%rbp)
leaq -0xb1(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x5560
movq -0xf8(%rbp), %rdx
leaq 0x26cc6(%rip), %rsi     # 0x2e13e
leaq -0xb0(%rbp), %rdi
callq 0x7d20
jmp 0x7486
movq -0x100(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x7cf0
jmp 0x749b
leaq -0xb0(%rbp), %rdi
callq 0x55d0
leaq -0xb1(%rbp), %rdi
callq 0x5350
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x74df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x55d0
leaq -0x29(%rbp), %rdi
callq 0x5350
jmp 0x7581
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x7510
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x55d0
leaq -0x61(%rbp), %rdi
callq 0x5350
jmp 0x7581
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x7541
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x55d0
leaq -0x89(%rbp), %rdi
callq 0x5350
jmp 0x7581
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x7575
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x55d0
leaq -0xb1(%rbp), %rdi
callq 0x5350
movq -0xd0(%rbp), %rdi
callq 0x7dd0
movq -0x38(%rbp), %rdi
callq 0x5550
nopw %cs:(%rax,%rax)
// File: arisKoutsou[P]oopproj/./src/menu/AllMenus.cpp
// Function: MainMenu::welcome() const
void MainMenu :: welcome() const {  
  cout << endl << "Welcome to ..." << endl;

  displayMenu();

  cout << "Type any of the above options to enter (i.e : \"GenerateMap\" or \"Help\")"
       << endl << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x38a05(%rip), %rdi     # 0x3ffc0
movq 0x389de(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, %rdi
leaq 0x26b72(%rip), %rsi     # 0x2e143
callq 0x52f0
movq %rax, %rdi
movq 0x389c0(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq 0x389cb(%rip), %rdi     # 0x3ffc0
leaq 0x26b56(%rip), %rsi     # 0x2e152
callq 0x52f0
movq %rax, %rdi
movq 0x38995(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, %rdi
movq 0x38986(%rip), %rsi     # 0x3ffa0
callq 0x5330
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: arisKoutsou[P]oopproj/./src/menu/AllMenus.cpp
// Function: MainMenu::displayMenu() const
void MainMenu :: displayMenu() const {

  cout << endl;
  cout << "+---+---+---+---+"                 << endl;
  cout << "| R | o | l | e |"                 << endl;
  cout << "+---+---+---+---+---+---+---+---+" << endl;
  cout << "    | P | l | a | y | i | n | g |" << endl;
  cout << "    +---+---+---+---+---+---+---+" << endl;
  cout << "        | G | a | m | e |"         << endl;
  cout << "        +---+---+---+---+"	      << endl;
  cout << endl;

  for (size_t i = 0; i != options.size(); ++i) {
    cout << "•" << options[i] << endl;
  }
  cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x38695(%rip), %rdi     # 0x3ffc0
movq 0x3866e(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq 0x38682(%rip), %rdi     # 0x3ffc0
leaq 0x26914(%rip), %rsi     # 0x2e259
callq 0x52f0
movq %rax, %rdi
movq 0x3864c(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq 0x38660(%rip), %rdi     # 0x3ffc0
leaq 0x26858(%rip), %rsi     # 0x2e1bf
callq 0x52f0
movq %rax, %rdi
movq 0x3862a(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq 0x3863e(%rip), %rdi     # 0x3ffc0
leaq 0x26848(%rip), %rsi     # 0x2e1d1
callq 0x52f0
movq %rax, %rdi
movq 0x38608(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq 0x3861c(%rip), %rdi     # 0x3ffc0
leaq 0x26848(%rip), %rsi     # 0x2e1f3
callq 0x52f0
movq %rax, %rdi
movq 0x385e6(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq 0x385fa(%rip), %rdi     # 0x3ffc0
leaq 0x26848(%rip), %rsi     # 0x2e215
callq 0x52f0
movq %rax, %rdi
movq 0x385c4(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq 0x385d8(%rip), %rdi     # 0x3ffc0
leaq 0x26848(%rip), %rsi     # 0x2e237
callq 0x52f0
movq %rax, %rdi
movq 0x385a2(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq 0x385b6(%rip), %rdi     # 0x3ffc0
leaq 0x26840(%rip), %rsi     # 0x2e251
callq 0x52f0
movq %rax, %rdi
movq 0x38580(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq 0x38594(%rip), %rdi     # 0x3ffc0
movq 0x3856d(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x6390
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
je 0x7ab2
movq 0x38558(%rip), %rdi     # 0x3ffc0
leaq 0x267fc(%rip), %rsi     # 0x2e26b
callq 0x52f0
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x63b0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x52a0
movq %rax, %rdi
movq 0x38501(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7a40
movq 0x38507(%rip), %rdi     # 0x3ffc0
movq 0x384e0(%rip), %rsi     # 0x3ffa0
callq 0x5330
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: arisKoutsou[P]oopproj/./src/menu/AllMenus.cpp
// Function: MainMenu::help() const
void MainMenu::help() const {
	ifstream helpFile;

	helpFile.open("input/help.info");

	if (helpFile.is_open()) {
		cout << endl;
		cout << helpFile.rdbuf();
	} else {
		cerr << "A problem occured while opening \"input/help.info\" ";
		cout << endl<< endl;
	}

	string answer;
	  while (answer != "Y" && answer != "y") {
		cout << endl << "Exit to Main Menu?(Y/n) : ";
		cin >> answer;
	  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x8(%rbp)
leaq -0x210(%rbp), %rdi
movq %rdi, -0x248(%rbp)
callq 0x53a0
movq -0x248(%rbp), %rdi
leaq 0x2676f(%rip), %rsi     # 0x2e26f
movl $0x8, %edx
callq 0x51c0
jmp 0x7b0c
leaq -0x210(%rbp), %rdi
callq 0x54f0
movb %al, -0x249(%rbp)
jmp 0x7b20
movb -0x249(%rbp), %al
testb $0x1, %al
jne 0x7b2c
jmp 0x7b84
movq 0x3848d(%rip), %rdi     # 0x3ffc0
movq 0x38466(%rip), %rsi     # 0x3ffa0
callq 0x5330
jmp 0x7b41
leaq -0x210(%rbp), %rdi
callq 0x54d0
movq %rax, -0x258(%rbp)
jmp 0x7b56
movq -0x258(%rbp), %rsi
movq 0x3845c(%rip), %rdi     # 0x3ffc0
callq 0x5090
jmp 0x7b6b
jmp 0x7bcc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
jmp 0x7cc9
movq 0x38465(%rip), %rdi     # 0x3fff0
leaq 0x266ed(%rip), %rsi     # 0x2e27f
callq 0x52f0
jmp 0x7b99
movq 0x38420(%rip), %rdi     # 0x3ffc0
movq 0x383f9(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, -0x260(%rbp)
jmp 0x7bb5
movq -0x260(%rbp), %rdi
movq 0x383dd(%rip), %rsi     # 0x3ffa0
callq 0x5330
jmp 0x7bca
jmp 0x7bcc
leaq -0x240(%rbp), %rdi
callq 0x5460
leaq 0x271a7(%rip), %rsi     # 0x2ed86
leaq -0x240(%rbp), %rdi
callq 0x7f10
movb %al, -0x261(%rbp)
jmp 0x7bf3
movb -0x261(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x262(%rbp)
jne 0x7c08
jmp 0x7c31
leaq 0x2651c(%rip), %rsi     # 0x2e12b
leaq -0x240(%rbp), %rdi
callq 0x7f10
movb %al, -0x263(%rbp)
jmp 0x7c23
movb -0x263(%rbp), %al
movb %al, -0x262(%rbp)
jmp 0x7c31
movb -0x262(%rbp), %al
testb $0x1, %al
jne 0x7c3d
jmp 0x7ca8
movq 0x3837c(%rip), %rdi     # 0x3ffc0
movq 0x38355(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, -0x270(%rbp)
jmp 0x7c59
movq -0x270(%rbp), %rdi
leaq 0x2664b(%rip), %rsi     # 0x2e2b2
callq 0x52f0
jmp 0x7c6e
movq 0x38363(%rip), %rdi     # 0x3ffd8
leaq -0x240(%rbp), %rsi
callq 0x5410
jmp 0x7c83
jmp 0x7bd8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x55d0
jmp 0x7cc9
leaq -0x240(%rbp), %rdi
callq 0x55d0
leaq -0x210(%rbp), %rdi
callq 0x55c0
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
leaq -0x210(%rbp), %rdi
callq 0x55c0
movq -0x218(%rbp), %rdi
callq 0x5550
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: arisKoutsou[P]oopproj/./src/grid/Grid.cpp
// Function: Grid::Tile::~Tile()
Grid :: Tile :: ~Tile() {
  while (livings.empty() == false) {
    delete livings.front();
    livings.pop_front();
  }

  delete market;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x97d0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x8eee
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x97f0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x8edf
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x9820
jmp 0x8ea4
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x8f17
movq -0x20(%rbp), %rdi
callq 0x1db20
movq -0x20(%rbp), %rdi
movl $0x58, %esi
callq 0x5310
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x9850
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movl -0x10(%rbp), %eax
movl %eax, (%rdi)
movl -0xc(%rbp), %eax
movl %eax, 0x4(%rdi)
addq $0x8, %rdi
movq %rdi, -0x90(%rbp)
callq 0x98a0
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x98(%rbp), %rcx
movq -0x28(%rbp), %rax
movslq 0x4(%rcx), %rcx
cmpq %rcx, %rax
je 0x91e3
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x98c0
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rsi
addq $0x8, %rdi
callq 0x98e0
jmp 0x90e0
movq $0x0, -0x58(%rbp)
movq -0x98(%rbp), %rcx
movq -0x58(%rbp), %rax
movslq (%rcx), %rcx
cmpq %rcx, %rax
je 0x91b2
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movb %al, -0x59(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movb 0x1(%rax,%rcx), %al
andb $0x1, %al
movb %al, -0x5a(%rbp)
movzbl -0x5a(%rbp), %edx
movzbl -0x59(%rbp), %esi
andl $0x1, %esi
andl $0x1, %edx
leaq -0x88(%rbp), %rdi
callq 0x8e40
jmp 0x913c
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rsi
callq 0x9950
movq %rax, %rdi
leaq -0x88(%rbp), %rsi
callq 0x9970
jmp 0x9161
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x8e90
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x90e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x91cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x8e90
jmp 0x91cc
leaq -0x40(%rbp), %rdi
callq 0x99e0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x909f
leaq -0x40(%rbp), %rdi
callq 0x99e0
movq -0x90(%rbp), %rdi
callq 0x9a40
jmp 0x91ec
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5550
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x8, %rdi
movslq -0xc(%rbp), %rsi
callq 0x9950
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x9aa0
movq %rax, %rdi
callq 0x8f80
testb $0x1, %al
jne 0x9295
jmp 0x92b9
movq 0x36d54(%rip), %rdi     # 0x3fff0
leaq 0x250ad(%rip), %rsi     # 0x2e350
callq 0x52f0
movq %rax, %rdi
movq 0x36cee(%rip), %rsi     # 0x3ffa0
callq 0x5330
jmp 0x9335
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movslq -0xc(%rbp), %rsi
callq 0x9950
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x9aa0
movq %rax, %rdi
callq 0x8f30
testb $0x1, %al
jne 0x92e4
jmp 0x9308
movq 0x36d05(%rip), %rdi     # 0x3fff0
leaq 0x2508c(%rip), %rsi     # 0x2e37e
callq 0x52f0
movq %rax, %rdi
movq 0x36c9f(%rip), %rsi     # 0x3ffa0
callq 0x5330
jmp 0x9335
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x8, %rdi
movslq -0xc(%rbp), %rsi
callq 0x9950
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x9aa0
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x8, %rdi
movslq -0xc(%rbp), %rsi
callq 0x9950
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x9aa0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x9b00
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x9b30
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
movslq -0xc(%rbp), %rsi
callq 0x9950
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x9aa0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x9b80
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9b30
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9b50
testb $0x1, %al
jne 0x9421
jmp 0x9445
leaq -0x20(%rbp), %rdi
callq 0x9bb0
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x9438
jmp 0x94c1
jmp 0x943a
leaq -0x20(%rbp), %rdi
callq 0x9be0
jmp 0x93d4
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
movslq -0xc(%rbp), %rsi
callq 0x9950
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x9aa0
movq %rax, %rdi
callq 0x8f30
testb $0x1, %al
jne 0x9470
jmp 0x9494
movq 0x36b79(%rip), %rdi     # 0x3fff0
leaq 0x24f30(%rip), %rsi     # 0x2e3ae
callq 0x52f0
movq %rax, %rdi
movq 0x36b13(%rip), %rsi     # 0x3ffa0
callq 0x5330
jmp 0x94c1
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
movslq -0xc(%rbp), %rsi
callq 0x9950
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x9aa0
movq %rax, %rdi
addq $0x8, %rdi
leaq -0x18(%rbp), %rsi
callq 0x9c00
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x5580
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xd45c
movq -0x8(%rbp), %rdi
leaq 0x32ecf(%rip), %rsi     # 0x40310
callq 0x5070
leaq 0x32ec3(%rip), %rdi     # 0x40310
callq 0xdd90
testb $0x1, %al
jne 0xd458
jmp 0xd45a
jmp 0xd41c
jmp 0xd45c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5460
movq $0x0, -0x30(%rbp)
leaq 0x32e7c(%rip), %rdi     # 0x40310
movl $0x2c, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x5450
movq %rax, -0x30(%rbp)
cmpq $-0x1, %rax
je 0xd528
movq -0x30(%rbp), %rcx
leaq 0x32e59(%rip), %rsi     # 0x40310
xorl %eax, %eax
movl %eax, %edx
leaq -0x50(%rbp), %rdi
callq 0x5320
jmp 0xd4c6
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
leaq -0x50(%rbp), %rsi
movq %rsi, -0x70(%rbp)
callq 0x53f0
movq -0x70(%rbp), %rdi
callq 0x55d0
movq -0x68(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x13330
jmp 0xd4f3
movq -0x30(%rbp), %rdx
incq %rdx
leaq 0x32e0f(%rip), %rdi     # 0x40310
xorl %eax, %eax
movl %eax, %esi
callq 0x50a0
jmp 0xd50c
jmp 0xd48d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x55d0
jmp 0xd537
leaq -0x28(%rbp), %rdi
callq 0x55d0
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x5550
// File: arisKoutsou[P]oopproj/./src/game_utils.cpp
// Function: isCommentOrWhitespace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool isCommentOrWhitespace(const string& str) {
  if (str[0] == '#') return true;
  for (size_t i = 0U; i != str.length(); ++i) {
    if (!isspace(str[i])) return false;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5380
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0xddb7
movb $0x1, -0x1(%rbp)
jmp 0xde10
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x54a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
je 0xde0c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5380
movsbl (%rax), %edi
callq 0x5050
cmpl $0x0, %eax
jne 0xddfc
movb $0x0, -0x1(%rbp)
jmp 0xde10
jmp 0xddfe
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xddbf
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x22030
movq %rax, %rdi
callq 0x61a0
movq -0x8(%rbp), %rdi
callq 0x22030
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x8(%rbp), %rdi
callq 0x22030
movq %rax, %rdi
callq 0x6240
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0xdf06
movq -0x8(%rbp), %rdi
callq 0x22030
movq %rax, %rdi
callq 0x61a0
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0xdeee
movq -0x18(%rbp), %rax
leaq 0x20591(%rip), %rcx     # 0x2e428
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0xdef0
movq -0x8(%rbp), %rdi
callq 0x24750
jmp 0xdf06
movq -0x8(%rbp), %rdi
callq 0x266b0
movq -0x8(%rbp), %rdi
callq 0xdf10
jmp 0xdf06
callq 0xe390
movq -0x8(%rbp), %rdi
callq 0x22030
movq %rax, %rdi
callq 0x61a0
testb $0x1, 0x32421(%rip)     # 0x40309
je 0xdeec
jmp 0xdf06
jmp 0xdef0
jmp 0xdef0
movq -0x8(%rbp), %rdi
callq 0x22030
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
jmp 0xde4e
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: arisKoutsou[P]oopproj/./src/game_utils.cpp
// Function: handleQuitCase()
void handleQuitCase(void) {
  string answer;

  while (true) {
    cout << endl
	 << "Do you you really want to go to the main menu? (Y|n)" << endl
	 << "(If you answer Y the current session will be terminated)"
	 << endl << endl;
    cout << "> ";
    cin >> answer;
    transform(answer.begin(), answer.end(), answer.begin(), :: tolower);
    if (answer == "y") {
      quitGame = true;
      break;
    } else if (answer == "n") {
      cout << endl;
      break;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq -0x20(%rbp), %rdi
callq 0x5460
jmp 0xe3a6
movq 0x31c13(%rip), %rdi     # 0x3ffc0
movq 0x31bec(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, -0x58(%rbp)
jmp 0xe3bf
movq -0x58(%rbp), %rdi
leaq 0x20430(%rip), %rsi     # 0x2e7fa
callq 0x52f0
movq %rax, -0x60(%rbp)
jmp 0xe3d5
movq -0x60(%rbp), %rdi
movq 0x31bc0(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, -0x68(%rbp)
jmp 0xe3eb
movq -0x68(%rbp), %rdi
leaq 0x20439(%rip), %rsi     # 0x2e82f
callq 0x52f0
movq %rax, -0x70(%rbp)
jmp 0xe401
movq -0x70(%rbp), %rdi
movq 0x31b94(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, -0x78(%rbp)
jmp 0xe417
movq -0x78(%rbp), %rdi
movq 0x31b7e(%rip), %rsi     # 0x3ffa0
callq 0x5330
jmp 0xe429
movq 0x31b90(%rip), %rdi     # 0x3ffc0
leaq 0x1fc05(%rip), %rsi     # 0x2e03c
callq 0x52f0
jmp 0xe43e
movq 0x31b93(%rip), %rdi     # 0x3ffd8
leaq -0x20(%rbp), %rsi
callq 0x5410
jmp 0xe450
leaq -0x20(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x5280
movq -0x88(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x5190
movq -0x88(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x5280
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq 0x31b31(%rip), %rcx     # 0x3ffc8
callq 0x7e00
movq %rax, -0x80(%rbp)
jmp 0xe4a2
movq -0x80(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x1fc7a(%rip), %rsi     # 0x2e12b
leaq -0x20(%rbp), %rdi
callq 0x8e10
movb %al, -0x89(%rbp)
jmp 0xe4c2
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0xe4ce
jmp 0xe4ee
movb $0x1, 0x31e34(%rip)     # 0x40309
jmp 0xe530
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x55d0
jmp 0xe542
leaq 0x203dc(%rip), %rsi     # 0x2e8d1
leaq -0x20(%rbp), %rdi
callq 0x8e10
movb %al, -0x8a(%rbp)
jmp 0xe506
movb -0x8a(%rbp), %al
testb $0x1, %al
jne 0xe512
jmp 0xe529
movq 0x31aa7(%rip), %rdi     # 0x3ffc0
movq 0x31a80(%rip), %rsi     # 0x3ffa0
callq 0x5330
jmp 0xe527
jmp 0xe530
jmp 0xe52b
jmp 0xe3a4
leaq -0x20(%rbp), %rdi
callq 0x55d0
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5550
nopl (%rax,%rax)
// File: arisKoutsou[P]oopproj/./src/game_utils.cpp
// Function: heroesAlive()
int heroesAlive(void) {
  int alive = 0;
  for (size_t i = 0U; i != heroes.size(); ++i) {
    if (heroes[i]->getHealthPower() != 0) ++alive;
  }
  return alive;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x3146a(%rip), %rdi     # 0x40330
callq 0x133f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
je 0xef0d
movq -0x10(%rbp), %rsi
leaq 0x3144e(%rip), %rdi     # 0x40330
callq 0x133d0
movq (%rax), %rdi
callq 0x298a0
cmpl $0x0, %eax
je 0xeefd
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xeeff
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xeeb7
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: arisKoutsou[P]oopproj/./src/game_utils.cpp
// Function: monstersWon()
bool monstersWon(void) {
  size_t dead = 0U;
  for (size_t i = 0U; i != heroes.size(); ++i) {
    if (heroes[i]->getHealthPower() == 0) ++dead;
  }
  return (dead == heroes.size()) ? true : false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x311d9(%rip), %rdi     # 0x40330
callq 0x133f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
je 0xf1a1
movq -0x10(%rbp), %rsi
leaq 0x311bd(%rip), %rdi     # 0x40330
callq 0x133d0
movq (%rax), %rdi
callq 0x298a0
cmpl $0x0, %eax
jne 0xf191
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xf193
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xf148
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x31180(%rip), %rdi     # 0x40330
callq 0x133f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
sete %al
negb %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: arisKoutsou[P]oopproj/./src/game_utils.cpp
// Function: updatePotionsAndNerfs()
void updatePotionsAndNerfs(void) {
  for (size_t i = 0U; i != heroes.size(); ++i) {
    heroes[i]->updatePotions();   
  }
  list<Monster*> :: iterator it = monsters.begin();
  for ( ; it != monsters.end(); ++it) {
    (*it)->updateNerfs();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x30d81(%rip), %rdi     # 0x40330
callq 0x133f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
je 0xf5e6
movq -0x8(%rbp), %rsi
leaq 0x30d65(%rip), %rdi     # 0x40330
callq 0x133d0
movq (%rax), %rdi
callq 0x230f0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xf5a0
leaq 0x30dd3(%rip), %rdi     # 0x403c0
callq 0x13410
movq %rax, -0x10(%rbp)
leaq 0x30dc3(%rip), %rdi     # 0x403c0
callq 0x135a0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x135d0
testb $0x1, %al
jne 0xf619
jmp 0xf635
leaq -0x10(%rbp), %rdi
callq 0x13600
movq (%rax), %rdi
callq 0x2a4f0
leaq -0x10(%rbp), %rdi
callq 0x13620
jmp 0xf5f6
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: arisKoutsou[P]oopproj/./src/game_utils.cpp
// Function: restoreHeroes()
void restoreHeroes(void) {
  for (size_t i = 0U; i != heroes.size(); ++i) {
    heroes[i]->resetBattleStats();
    if (heroes[i]->getHealthPower() == 0) {
      heroes[i]->respawn();
    }
  }  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x30cd1(%rip), %rdi     # 0x40330
callq 0x133f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
je 0xf6cd
movq -0x8(%rbp), %rsi
leaq 0x30cb5(%rip), %rdi     # 0x40330
callq 0x133d0
movq (%rax), %rdi
callq 0x22110
movq -0x8(%rbp), %rsi
leaq 0x30c9d(%rip), %rdi     # 0x40330
callq 0x133d0
movq (%rax), %rdi
callq 0x298a0
cmpl $0x0, %eax
jne 0xf6bd
movq -0x8(%rbp), %rsi
leaq 0x30c80(%rip), %rdi     # 0x40330
callq 0x133d0
movq (%rax), %rdi
callq 0x22190
jmp 0xf6bf
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xf650
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
leaq 0x2fdbd(%rip), %rdi     # 0x403d8
leaq 0x1df8b(%rip), %rsi     # 0x2e5ad
movl $0x8, %edx
callq 0x51c0
leaq 0x2fda5(%rip), %rdi     # 0x403d8
callq 0x54f0
testb $0x1, %al
jne 0x10668
movq 0x2f9ad(%rip), %rdi     # 0x3fff0
leaq 0x1e416(%rip), %rsi     # 0x2ea60
callq 0x52f0
movq %rax, %rdi
movq 0x2f947(%rip), %rsi     # 0x3ffa0
callq 0x5330
movl $0x1, %edi
callq 0x53e0
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movb $0x1, %al
cmpl $0x1, -0x4(%rbp)
movb %al, -0x5(%rbp)
jl 0x10694
cmpl $0x3, -0x4(%rbp)
setg %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
testb $0x1, %al
jne 0x106a0
jmp 0x1073f
movq 0x2f919(%rip), %rdi     # 0x3ffc0
movq 0x2f8f2(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, %rdi
leaq 0x1e3dd(%rip), %rsi     # 0x2ea9a
callq 0x52f0
movq %rax, %rdi
leaq 0x1e402(%rip), %rsi     # 0x2eace
callq 0x52f0
movq %rax, %rdi
movq 0x2f8c5(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, %rdi
movq 0x2f8b6(%rip), %rsi     # 0x3ffa0
callq 0x5330
movq %rax, %rdi
leaq 0x1d943(%rip), %rsi     # 0x2e03c
callq 0x52f0
movq 0x2f8d3(%rip), %rdi     # 0x3ffd8
leaq -0x4(%rbp), %rsi
callq 0x51b0
movq 0x2f8ab(%rip), %rdi     # 0x3ffc0
movq 0x2f884(%rip), %rsi     # 0x3ffa0
callq 0x5330
callq 0x136b0
movq %rax, %rsi
movq 0x2f8a8(%rip), %rdi     # 0x3ffd8
movl $0xa, %edx
callq 0x51d0
jmp 0x1067f
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x2fe81(%rip), %rax     # 0x405e0
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x10780
movq -0x8(%rbp), %rdi
callq 0x9200
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x5310
leaq 0x2fba9(%rip), %rdi     # 0x40330
callq 0x136c0
leaq 0x2fbb5(%rip), %rdi     # 0x40348
callq 0x13310
leaq 0x2fbc1(%rip), %rdi     # 0x40360
callq 0x13310
leaq 0x2fbcd(%rip), %rdi     # 0x40378
callq 0x13310
leaq 0x2fbd9(%rip), %rdi     # 0x40390
callq 0x13310
leaq 0x2fbe5(%rip), %rdi     # 0x403a8
callq 0x13310
leaq 0x2fc09(%rip), %rdi     # 0x403d8
callq 0x5080
movb $0x0, 0x2fb2e(%rip)     # 0x40309
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x10610
callq 0x100c0
callq 0x10670
movl %eax, -0x4(%rbp)
callq 0xcfe0
movl -0x4(%rbp), %edi
callq 0xf740
movl $0x0, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movb 0x2fae1(%rip), %al      # 0x40309
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x108b1
movslq -0x8(%rbp), %rsi
leaq 0x2faf3(%rip), %rdi     # 0x40330
callq 0x133d0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
cltd
idivl -0x4(%rbp)
movl %edx, -0x8(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x1089f
movq -0x18(%rbp), %rdi
callq 0x22050
movq %rax, %rdi
movl -0x4(%rbp), %esi
callq 0x8fc0
testb $0x1, %al
jne 0x10876
jmp 0x1089f
movsd 0x1dba2(%rip), %xmm0    # 0x2e420
callq 0x5fe0
testb $0x1, %al
jne 0x10889
jmp 0x1089d
callq 0xe5e0
movq -0x18(%rbp), %rdi
callq 0x230f0
movb $0x1, -0x9(%rbp)
jmp 0x10822
jmp 0x1089f
movq -0x18(%rbp), %rdi
callq 0xde20
movb $0x0, -0x9(%rbp)
jmp 0x10822
callq 0x10750
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x10b26
movl $0x1, -0x4(%rbp)
jmp 0x10b52
movl $0x0, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x10b4c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x8(%rbp)
jmp 0x10b2d
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq 0x2e8be(%rip), %rdi     # 0x3ffc0
movl $0x2b, %esi
callq 0x53d0
movq %rax, -0xc0(%rbp)
leaq -0x21(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x5560
movq -0xb8(%rbp), %rcx
leaq -0x20(%rbp), %rdi
movl $0x18, %esi
movl $0x2d, %edx
callq 0x63d0
jmp 0x1173f
movq -0xc0(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x52a0
jmp 0x11751
leaq -0x20(%rbp), %rdi
callq 0x55d0
leaq -0x21(%rbp), %rdi
callq 0x5350
movq 0x2e856(%rip), %rdi     # 0x3ffc0
movl $0x2b, %esi
callq 0x53d0
movq %rax, -0xd0(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x5560
movq -0xc8(%rbp), %rcx
leaq -0x58(%rbp), %rdi
movl $0x7, %esi
movl $0x2d, %edx
callq 0x63d0
jmp 0x117a7
movq -0xd0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x52a0
jmp 0x117b9
leaq -0x58(%rbp), %rdi
callq 0x55d0
leaq -0x59(%rbp), %rdi
callq 0x5350
movq 0x2e7ee(%rip), %rdi     # 0x3ffc0
movl $0x2b, %esi
callq 0x53d0
movq %rax, -0xe0(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x5560
movq -0xd8(%rbp), %rcx
leaq -0x80(%rbp), %rdi
movl $0xb, %esi
movl $0x2d, %edx
callq 0x63d0
jmp 0x11812
movq -0xe0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x52a0
jmp 0x11824
leaq -0x80(%rbp), %rdi
callq 0x55d0
leaq -0x81(%rbp), %rdi
callq 0x5350
movq 0x2e780(%rip), %rdi     # 0x3ffc0
movl $0x2b, %esi
callq 0x53d0
movq %rax, -0xf0(%rbp)
leaq -0xa9(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x5560
movq -0xe8(%rbp), %rcx
leaq -0xa8(%rbp), %rdi
movl $0x12, %esi
movl $0x2d, %edx
callq 0x63d0
jmp 0x11883
movq -0xf0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x52a0
jmp 0x11898
leaq -0xa8(%rbp), %rdi
callq 0x55d0
leaq -0xa9(%rbp), %rdi
callq 0x5350
movq 0x2e709(%rip), %rdi     # 0x3ffc0
movl $0x2b, %esi
callq 0x53d0
movq %rax, %rdi
movq 0x2e6d5(%rip), %rsi     # 0x3ffa0
callq 0x5330
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x118fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x55d0
leaq -0x21(%rbp), %rdi
callq 0x5350
jmp 0x1199b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x1192d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x55d0
leaq -0x59(%rbp), %rdi
callq 0x5350
jmp 0x1199b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x1195b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x55d0
leaq -0x81(%rbp), %rdi
callq 0x5350
jmp 0x1199b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x1198f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x55d0
leaq -0xa9(%rbp), %rdi
callq 0x5350
movq -0x30(%rbp), %rdi
callq 0x5550
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x17a50
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x14b5e
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x17a70
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x14b4f
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x17aa0
jmp 0x14b14
jmp 0x14b60
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x17ad0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x14baa
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x17af0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x14b9b
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x17b20
jmp 0x14b60
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x17b50
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x17a10
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x17a30
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: arisKoutsou[P]oopproj/./src/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x8, %rdi
callq 0x17bd0
movq %rax, -0x18(%rbp)
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
callq 0x17c30
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x17c00
testb $0x1, %al
jne 0x14d15
jmp 0x14d8c
leaq -0x18(%rbp), %rdi
callq 0x17c60
movq (%rax), %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq *%rax
movq -0x70(%rbp), %rdi
leaq 0x1a1c2(%rip), %rsi     # 0x2eeff
callq 0x8e10
movb %al, -0x61(%rbp)
jmp 0x14d47
leaq -0x40(%rbp), %rdi
callq 0x55d0
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x14d59
jmp 0x14d76
movb $0x1, -0x1(%rbp)
jmp 0x14d90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x55d0
jmp 0x14d9b
jmp 0x14d78
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x17c90
movq %rax, -0x58(%rbp)
jmp 0x14cf1
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5550
nopw %cs:(%rax,%rax)
// File: arisKoutsou[P]oopproj/./src/inventory/Inventory.cpp
// Function: Inventory::addItem(Item*)
void Inventory :: addItem(Item* item) {
  if (this->getCurrentCapacity() == maxCapacity) {
    cout << "Your inventory is full" << endl;
    return;
  }

  items.push_back(item);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x14bf0
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x17099
movq 0x28f44(%rip), %rdi     # 0x3ffc0
leaq 0x17bc1(%rip), %rsi     # 0x2ec44
callq 0x52f0
movq %rax, %rdi
movq 0x28f0e(%rip), %rsi     # 0x3ffa0
callq 0x5330
jmp 0x170aa
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq -0x10(%rbp), %rsi
callq 0x18420
addq $0x20, %rsp
popq %rbp
retq
// File: arisKoutsou[P]oopproj/./src/inventory/Inventory.cpp
// Function: Inventory::addSpell(Spell*)
void Inventory :: addSpell(Spell* spell) {
  if (this->getCurrentCapacity() == maxCapacity) {
    cout << "Your inventory is full" << endl;
    return;
  }

  spells.push_back(spell);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x14bf0
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x170f9
movq 0x28ee4(%rip), %rdi     # 0x3ffc0
leaq 0x17b61(%rip), %rsi     # 0x2ec44
callq 0x52f0
movq %rax, %rdi
movq 0x28eae(%rip), %rsi     # 0x3ffa0
callq 0x5330
jmp 0x1710a
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
leaq -0x10(%rbp), %rsi
callq 0x18460
addq $0x20, %rsp
popq %rbp
retq