LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/rfotino[P]consolite-compiler/src/util.cpp
// Function: getLabel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::shared_ptr<LabelStatement>, std::allocator<std::shared_ptr<LabelStatement>>> const&)
std::shared_ptr<LabelStatement> getLabel(
      const std::string& name,
      const std::vector<std::shared_ptr<LabelStatement>>& labels) {
  for (auto label : labels) {
    if (label->name() == name) {
      return label;
    }
  }
  return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdx), %r13
movq 0x8(%rdx), %rbp
cmpq %rbp, %r13
je 0x34119
movq %rsi, %r14
movq (%r13), %rax
movq %rax, (%rbx)
movq 0x8(%r13), %rcx
movq %rcx, 0x8(%rbx)
testq %rcx, %rcx
je 0x3408b
movq 0x12f1e(%rip), %rdx     # 0x46f98
cmpb $0x0, (%rdx)
je 0x34084
incl 0x8(%rcx)
jmp 0x3408b
lock
incl 0x8(%rcx)
movq (%rbx), %rax
leaq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xbd58
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x340d2
movq 0x8(%rsp), %r12
testq %rdx, %rdx
je 0x340dc
movq (%r14), %rsi
movq %r12, %rdi
callq 0x72e0
testl %eax, %eax
sete %r15b
jmp 0x340df
movq 0x8(%rsp), %r12
xorl %r15d, %r15d
jmp 0x340df
movb $0x1, %r15b
leaq 0x18(%rsp), %rax
cmpq %rax, %r12
je 0x340f9
movq 0x18(%rsp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x72c0
testb %r15b, %r15b
jne 0x3411f
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3410c
callq 0x8036
addq $0x10, %r13
cmpq %rbp, %r13
jne 0x3405f
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x34142
callq 0x8036
movq %r14, %rdi
callq 0x74f0
// File: /workspace/github_cpp_makefile_star2_O3/rfotino[P]consolite-compiler/src/util.cpp
// Function: error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void _error(const std::string& msg, int lineNum) {
  // TODO: It would be nice to have error messages that showed you
  // the source line and pointed to the token causing an error.
  std::cerr << "Error:";
  if (0 < lineNum) {
    std::cerr << lineNum << ":";
  }
  std::cerr << " " << msg << std::endl;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x12e60(%rip), %rdi     # 0x46fe8
leaq 0x34d3(%rip), %rsi      # 0x37662
movl $0x6, %edx
callq 0x7340
testl %ebp, %ebp
jle 0x341bf
movq 0x12e44(%rip), %rdi     # 0x46fe8
movl %ebp, %esi
callq 0x74d0
leaq 0x34be(%rip), %rsi      # 0x37670
movl $0x1, %edx
movq %rax, %rdi
callq 0x7340
movq 0x12e22(%rip), %r14     # 0x46fe8
leaq 0xf78(%rip), %rsi       # 0x35145
movl $0x1, %edx
movq %r14, %rdi
callq 0x7340
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x7340
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7290
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x71f0
// File: /workspace/github_cpp_makefile_star2_O3/rfotino[P]consolite-compiler/src/util.cpp
// Function: warn(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void _warn(const std::string& msg, int lineNum) {
  std::cerr << "Warning:";
  if (0 < lineNum) {
    std::cerr << lineNum << ":";
  }
  std::cerr << " " << msg << std::endl;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x12dc1(%rip), %rdi     # 0x46fe8
leaq 0x343b(%rip), %rsi      # 0x37669
movl $0x8, %edx
callq 0x7340
testl %ebp, %ebp
jle 0x3425e
movq 0x12da5(%rip), %rdi     # 0x46fe8
movl %ebp, %esi
callq 0x74d0
leaq 0x341f(%rip), %rsi      # 0x37670
movl $0x1, %edx
movq %rax, %rdi
callq 0x7340
movq 0x12d83(%rip), %r14     # 0x46fe8
leaq 0xed9(%rip), %rsi       # 0x35145
movl $0x1, %edx
movq %r14, %rdi
callq 0x7340
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x7340
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7290
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x71f0
// File: /workspace/github_cpp_makefile_star2_O3/hobbitsyfeet[P]Turn/main.cc
// Function: welcome(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void welcome(string input){
  char block;
  ifstream fin;
  fin.open(input.c_str());
  while(!fin.eof()){
    fin>>block;
    if(block == '!')
      cout<<'\xDC';
    else if(block == '#')
      cout<<'\xDB';
    else if (block == '@')
      cout<<'\xB2';
    else if(block == '-')
      cout<<' ';
    else if(block == '^')
      cout<<'\xB1';
    else if(block =='%')
      cout<<'\xB0';
    else if(block == '$')
      cout<<'\xDF';
    else if(block ==',')
      cout<<'\xB3';
    else if (block == 'e')
      cout<<'\n';
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdi, %rbx
leaq -0x238(%rbp), %r14
movq %r14, %rdi
callq 0x2220
movq (%rbx), %rsi
movq %r14, %rdi
movl $0x8, %edx
callq 0x2160
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x218(%rbp,%rax)
jne 0x2cdc
leaq -0x238(%rbp), %rbx
leaq -0x2a(%rbp), %r14
leaq 0x845e(%rip), %r13      # 0xb004
movq 0xc423(%rip), %r15      # 0xefd0
leaq -0x29(%rbp), %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2260
movzbl -0x2a(%rbp), %eax
cmpl $0x3f, %eax
jg 0x2bf4
addl $-0x21, %eax
cmpl $0xc, %eax
ja 0x2cc3
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movb $-0x24, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2230
jmp 0x2cc3
cmpl $0x40, %eax
je 0x2c99
cmpl $0x5e, %eax
je 0x2caf
cmpl $0x65, %eax
jne 0x2cc3
movb $0xa, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2230
jmp 0x2cc3
movb $-0x4d, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2230
jmp 0x2cc3
movb $-0x21, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2230
jmp 0x2cc3
movb $-0x50, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2230
jmp 0x2cc3
movb $-0x25, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2230
jmp 0x2cc3
movb $0x20, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2230
jmp 0x2cc3
movb $-0x4e, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2230
jmp 0x2cc3
movb $-0x4f, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2230
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x218(%rbp,%rax)
je 0x2bb1
leaq -0x238(%rbp), %rdi
callq 0x2090
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2cfc
movq %rax, %rbx
leaq -0x238(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/hobbitsyfeet[P]Turn/unit.cc
// Function: Unit::Unit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, int, int, int, int, int, int, int, int, int, int, int, bool, bool, bool, bool, bool, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Unit::Unit(string Name,int Level, int Health,int MaxHealth,int Attack,int Range,int Defence,
	int Exp, int MaxExp, int Gold, int Stam, int Dice, int xpos, int ypos,
bool lEquip, bool rEquip, bool hEquip,bool tEquip, bool legEquip, bool ftEquip,
 string cWorld){
  name=Name;
  level = Level;

  health=Health;
  maxHealth=MaxHealth;

  attack=Attack;
  range=Range;
  defence=Defence;

  gold=Gold;

  experience=Exp;
  maxExperience = MaxExp;
  stamina = Stam;
  dice = Dice;

  posX = xpos;
  posY = ypos;


//need to pass in or else will always spawn with empty items, thus will enable equiping multiple items.
	leftHandEquipped = lEquip;
	rightHandEquipped =rEquip;
  torsoEquipped = tEquip;
	headEquipped =hEquip;
	legsEquipped =legEquip;
	feetEquipped =ftEquip;

  currentWorld = cWorld;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %r13d
movl %r8d, %r12d
movl %ecx, %ebx
movl %edx, %r15d
movq %rdi, %r14
leaq 0x10(%rdi), %rax
movq %rax, -0x48(%rbp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x58(%rdi), %rcx
movq %rcx, -0x38(%rbp)
leaq 0x68(%rdi), %rcx
movq %rcx, -0x30(%rbp)
movq %rcx, 0x58(%rdi)
movq %rax, 0x60(%rdi)
movb %al, 0x68(%rdi)
leaq 0x80(%rdi), %rcx
movq %rcx, -0x40(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rdi)
movq %rax, 0x90(%rdi)
callq 0x2140
movl %r15d, 0x44(%r14)
movl %ebx, 0x20(%r14)
movl %r12d, 0x24(%r14)
movl %r13d, 0x2c(%r14)
movl 0x10(%rbp), %eax
movl %eax, 0x30(%r14)
movl 0x18(%rbp), %eax
movl %eax, 0x34(%r14)
movl 0x30(%rbp), %eax
movl %eax, 0x38(%r14)
movl 0x20(%rbp), %eax
movl %eax, 0x40(%r14)
movl 0x28(%rbp), %eax
movl %eax, 0x3c(%r14)
movl 0x38(%rbp), %eax
movl %eax, 0x28(%r14)
movl 0x40(%rbp), %eax
movl %eax, 0x48(%r14)
movl 0x48(%rbp), %eax
movl %eax, 0x78(%r14)
movl 0x50(%rbp), %eax
movl %eax, 0x7c(%r14)
movb 0x80(%rbp), %al
movb 0x58(%rbp), %cl
movb %cl, 0x98(%r14)
movb 0x60(%rbp), %cl
movb %cl, 0x99(%r14)
movb 0x70(%rbp), %cl
movb %cl, 0x9b(%r14)
movb 0x68(%rbp), %cl
movb %cl, 0x9a(%r14)
movb 0x78(%rbp), %cl
movb %cl, 0x9c(%r14)
movb %al, 0x9d(%r14)
movq 0x88(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x2140
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
callq 0x33d8
movq -0x38(%rbp), %rax
movq (%rax), %rdi
cmpq -0x30(%rbp), %rdi
je 0x36fc
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2200
movq %r14, %rdi
movq -0x48(%rbp), %rsi
callq 0x2380
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/hobbitsyfeet[P]Turn/unit.cc
// Function: Unit::levelUp()
void Unit::levelUp(){
  if(experience >= maxExperience){
    //increases level
    level++;
    //resets exp starting from 0+excess experience
    experience -= maxExperience;
    //increase maxExperience with equation y=(x^2)+(22x)+22
    maxExperience = ( ((level)*(level)) + (22*(level)) +(22) );

    maxHealth++;
    if(level %3 ==0){
      maxHealth++;
    }
    if(level%5 == 0){
      maxHealth++;
    }
    if(level%10 == 0){
      attack++;
      defence++;
      dice++;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x40(%rdi), %eax
subl 0x3c(%rdi), %eax
jl 0x3886
movl 0x44(%rdi), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x44(%rdi)
movl %eax, 0x40(%rdi)
leal 0x17(%rcx), %eax
imull %edx, %eax
addl $0x16, %eax
movl %eax, 0x3c(%rdi)
imull $0xaaaaaaab, %ecx, %eax # imm = 0xAAAAAAAB
addl $0xd5555555, %eax       # imm = 0xD5555555
xorl %edx, %edx
cmpl $0x55555555, %eax       # imm = 0x55555555
setb %dl
imull $0xcccccccd, %ecx, %eax # imm = 0xCCCCCCCD
leal -0x1999999a(%rax), %ecx
cmpl $0x33333333, %ecx       # imm = 0x33333333
adcl 0x24(%rdi), %edx
incl %edx
movl %edx, 0x24(%rdi)
addl $0xe6666665, %eax       # imm = 0xE6666665
rorl %eax
cmpl $0x19999998, %eax       # imm = 0x19999998
ja 0x3886
incl 0x2c(%rdi)
incl 0x34(%rdi)
incl 0x48(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hobbitsyfeet[P]Turn/unit.cc
// Function: Unit::saveUnit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Unit::saveUnit(string file){
  this->name = file;
  ofstream fout;
  fout.open(("./saves/" + file).c_str());
  fout<<*this;
  fout.close();
  inv.saveInventory(file);
  cout<<"unit saved\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2140
leaq -0x258(%rbp), %rdi
callq 0x22f0
leaq 0x70ec(%rip), %rsi      # 0xb322
leaq -0x58(%rbp), %rdi
movq %r14, %rdx
callq 0x58c9
movq -0x58(%rbp), %rsi
leaq -0x258(%rbp), %rdi
movl $0x10, %edx
callq 0x2060
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4270
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2200
leaq -0x258(%rbp), %rdi
movq %rbx, %rsi
callq 0x54df
leaq -0x258(%rbp), %rdi
callq 0x2270
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rdi
callq 0x347c
subq $-0x80, %rbx
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x94de
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x42cb
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2200
movq 0xacfe(%rip), %rdi      # 0xefd0
leaq 0x707e(%rip), %rsi      # 0xb357
movl $0xb, %edx
callq 0x2230
movq 0xacde(%rip), %rax      # 0xefc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x250(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x258(%rbp,%rcx)
callq 0x21b0
leaq -0x160(%rbp), %rdi
callq 0x20e0
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x435c
movq -0x28(%rbp), %rsi
jmp 0x434d
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x435c
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2200
jmp 0x435c
jmp 0x4359
movq %rax, %rbx
leaq -0x258(%rbp), %rdi
callq 0x2290
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/hobbitsyfeet[P]Turn/unit.cc
// Function: Unit::loadUnit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Unit::loadUnit(string file){
  ifstream fin;
	string temp ="./saves/" + file;
  fin.open(temp.c_str());
  while(fin.fail()){
    cout<<"invalid player, enter a name>> ";
    cin>>file;
    fin.open(("./saves/" + file).c_str());
  }
  fin>>*this;
  fin.close();
  inv.loadInventory(file);
  cout<<"unit Loaded";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leaq -0x298(%rbp), %rdi
callq 0x2220
leaq 0x6140(%rip), %rsi      # 0xb322
leaq -0x90(%rbp), %rdi
movq %r14, %rdx
callq 0x58c9
movq -0x90(%rbp), %rsi
leaq -0x298(%rbp), %rdi
movl $0x8, %edx
callq 0x2160
movq -0x298(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x278(%rbp,%rax)
je 0x52ab
movq 0x9db7(%rip), %r13      # 0xefe0
leaq 0x60f2(%rip), %rbx      # 0xb322
leaq -0x50(%rbp), %r15
leaq -0x298(%rbp), %r12
movl $0x1f, %edx
movq 0x9d89(%rip), %rdi      # 0xefd0
leaq 0x60dd(%rip), %rsi      # 0xb32b
callq 0x2230
movq %r13, %rdi
movq %r14, %rsi
callq 0x2250
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x58c9
movq -0x50(%rbp), %rsi
movq %r12, %rdi
movl $0x8, %edx
callq 0x2160
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5296
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2200
movq -0x298(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x278(%rbp,%rax)
jne 0x523b
leaq -0x298(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x53c0
leaq -0x298(%rbp), %rdi
callq 0x2080
leaq -0x60(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %rdi
callq 0x347c
movq -0x30(%rbp), %rdi
subq $-0x80, %rdi
leaq -0x70(%rbp), %rsi
callq 0x988a
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x5308
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2200
movq 0x9cc1(%rip), %rdi      # 0xefd0
leaq 0x6035(%rip), %rsi      # 0xb34b
movl $0xb, %edx
callq 0x2230
leaq -0x80(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5339
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x2200
leaq -0x298(%rbp), %rdi
callq 0x2090
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x5393
movq -0x60(%rbp), %rsi
jmp 0x5386
movq %rax, %rbx
jmp 0x53ac
jmp 0x5390
jmp 0x5390
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5393
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2200
jmp 0x5393
movq %rax, %rbx
leaq -0x80(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x53ac
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x2200
leaq -0x298(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/hobbitsyfeet[P]Turn/unit.cc
// Function: operator>>(std::istream&, Unit&)
istream& operator >> (istream& iStr, Unit& i){
  iStr>>i.name>>i.level>>i.health>>i.maxHealth>>i.stamina>>i.attack>>i.range>>i.defence>>i.gold>>i.experience>>i.maxExperience>>i.dice;
  iStr>>i.leftHandEquipped>>i.rightHandEquipped>>i.headEquipped>>i.torsoEquipped>>i.legsEquipped>>i.feetEquipped;
  iStr>>i.posX>>i.posY;
  iStr>>i.currentWorld;
  return iStr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2250
leaq 0x44(%r14), %rsi
movq %rax, %rdi
callq 0x2150
leaq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x2150
leaq 0x24(%r14), %rsi
movq %rax, %rdi
callq 0x2150
leaq 0x28(%r14), %rsi
movq %rax, %rdi
callq 0x2150
leaq 0x2c(%r14), %rsi
movq %rax, %rdi
callq 0x2150
leaq 0x30(%r14), %rsi
movq %rax, %rdi
callq 0x2150
leaq 0x34(%r14), %rsi
movq %rax, %rdi
callq 0x2150
leaq 0x38(%r14), %rsi
movq %rax, %rdi
callq 0x2150
leaq 0x40(%r14), %rsi
movq %rax, %rdi
callq 0x2150
leaq 0x3c(%r14), %rsi
movq %rax, %rdi
callq 0x2150
leaq 0x48(%r14), %rsi
movq %rax, %rdi
callq 0x2150
leaq 0x98(%r14), %rsi
movq %rbx, %rdi
callq 0x21c0
leaq 0x99(%r14), %rsi
movq %rax, %rdi
callq 0x21c0
leaq 0x9a(%r14), %rsi
movq %rax, %rdi
callq 0x21c0
leaq 0x9b(%r14), %rsi
movq %rax, %rdi
callq 0x21c0
leaq 0x9c(%r14), %rsi
movq %rax, %rdi
callq 0x21c0
leaq 0x9d(%r14), %rsi
movq %rax, %rdi
callq 0x21c0
leaq 0x78(%r14), %rsi
movq %rbx, %rdi
callq 0x2150
leaq 0x7c(%r14), %rsi
movq %rax, %rdi
callq 0x2150
addq $0x58, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2250
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hobbitsyfeet[P]Turn/item.cc
// Function: Item::Item(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, int, int, int, bool)
Item::Item(string n , string type,int ran, int dam, int def, int val,int dur, bool held){
  itemName=n;
  itemType = type;
  itemRange = ran;
  itemDamage=dam;
  itemDefence=def;
  itemWorth=val;
  itemIsEquipped = held;
  itemDurability= dur;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, -0x30(%rbp)
movl %r8d, -0x2c(%rbp)
movl %ecx, %r13d
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x38(%rbp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %r15
leaq 0x30(%rdi), %r12
movq %r12, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
callq 0x2140
movq %r15, %rdi
movq %r14, %rsi
callq 0x2140
movb 0x20(%rbp), %al
movl 0x18(%rbp), %ecx
movl 0x10(%rbp), %edx
movl %r13d, 0x40(%rbx)
movl -0x2c(%rbp), %esi
movl %esi, 0x44(%rbx)
movl -0x30(%rbp), %esi
movl %esi, 0x48(%rbx)
movl %edx, 0x4c(%rbx)
movb %al, 0x54(%rbx)
movl %ecx, 0x50(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x5ac1
movq (%r12), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
movq -0x38(%rbp), %rsi
callq 0x239a
movq %r14, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O3/hobbitsyfeet[P]Turn/item.cc
// Function: Item::viewItem()
void Item::viewItem(){
  cout<<itemName<<' ';
  cout<<itemType<<' ';
  if(itemRange != 0)
    cout<<"RANGE["<<itemRange<<"] ";
  if(itemDamage != 0)
    cout<<"DAMAGE:["<<itemDamage<<"] ";
  if(itemDefence != 0)
    cout<<"DEFENCE:["<<itemDefence<<"] ";
  if(itemWorth != 0)
    cout<<"WORTH:["<<itemWorth<<"] ";
  cout<<"Durability:["<<itemDurability<<"] ";
  if(itemIsEquipped == true)
    cout<<" [EQUIPPED]";
  cout<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq 0x9449(%rip), %r14      # 0xefd0
movq %r14, %rdi
callq 0x2230
movb $0x20, %r15b
leaq -0x19(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq %r14, %rdi
callq 0x2230
leaq -0x1a(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
cmpl $0x0, 0x40(%rbx)
je 0x5c0a
movq 0x93f9(%rip), %r14      # 0xefd0
leaq 0x5785(%rip), %rsi      # 0xb363
movl $0x6, %edx
movq %r14, %rdi
callq 0x2230
movl 0x40(%rbx), %esi
movq %r14, %rdi
callq 0x2300
leaq 0x576d(%rip), %rsi      # 0xb36a
movl $0x2, %edx
movq %rax, %rdi
callq 0x2230
cmpl $0x0, 0x44(%rbx)
je 0x5c4a
movq 0x93b9(%rip), %r14      # 0xefd0
leaq 0x574f(%rip), %rsi      # 0xb36d
movl $0x8, %edx
movq %r14, %rdi
callq 0x2230
movl 0x44(%rbx), %esi
movq %r14, %rdi
callq 0x2300
leaq 0x572d(%rip), %rsi      # 0xb36a
movl $0x2, %edx
movq %rax, %rdi
callq 0x2230
cmpl $0x0, 0x48(%rbx)
je 0x5c8a
movq 0x9379(%rip), %r14      # 0xefd0
leaq 0x5718(%rip), %rsi      # 0xb376
movl $0x9, %edx
movq %r14, %rdi
callq 0x2230
movl 0x48(%rbx), %esi
movq %r14, %rdi
callq 0x2300
leaq 0x56ed(%rip), %rsi      # 0xb36a
movl $0x2, %edx
movq %rax, %rdi
callq 0x2230
cmpl $0x0, 0x4c(%rbx)
je 0x5cca
movq 0x9339(%rip), %r14      # 0xefd0
leaq 0x56e2(%rip), %rsi      # 0xb380
movl $0x7, %edx
movq %r14, %rdi
callq 0x2230
movl 0x4c(%rbx), %esi
movq %r14, %rdi
callq 0x2300
leaq 0x56ad(%rip), %rsi      # 0xb36a
movl $0x2, %edx
movq %rax, %rdi
callq 0x2230
movq 0x92ff(%rip), %r14      # 0xefd0
leaq 0x56b0(%rip), %rsi      # 0xb388
movl $0xc, %edx
movq %r14, %rdi
callq 0x2230
movl 0x50(%rbx), %esi
movq %r14, %rdi
callq 0x2300
leaq 0x5673(%rip), %rsi      # 0xb36a
movl $0x2, %edx
movq %rax, %rdi
callq 0x2230
cmpb $0x1, 0x54(%rbx)
jne 0x5d22
movq 0x92bf(%rip), %rdi      # 0xefd0
leaq 0x567d(%rip), %rsi      # 0xb395
movl $0xb, %edx
callq 0x2230
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2170
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hobbitsyfeet[P]Turn/item.cc
// Function: operator<<(std::ostream&, Item const&)
ostream& operator<<(ostream& oStr,const Item& i){
  oStr<<i.itemName<<' ';
  oStr<<i.itemType<<' ';
  oStr<<i.itemRange<<' ';
  oStr<<i.itemDamage<<' ';
  oStr<<i.itemDefence<<' ';
  oStr<<i.itemWorth<<' ';
  oStr<<i.itemDurability<<' ';
  oStr<<i.itemIsEquipped;
  return oStr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
callq 0x2230
movb $0x20, %r15b
leaq -0x19(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rbx, %rdi
callq 0x2230
leaq -0x1a(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
movl 0x40(%r14), %esi
movq %rbx, %rdi
callq 0x2300
leaq -0x1b(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
movl 0x44(%r14), %esi
movq %rbx, %rdi
callq 0x2300
leaq -0x1c(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
movl 0x48(%r14), %esi
movq %rbx, %rdi
callq 0x2300
leaq -0x1d(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
movl 0x4c(%r14), %esi
movq %rbx, %rdi
callq 0x2300
leaq -0x1e(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
movl 0x50(%r14), %esi
movq %rbx, %rdi
callq 0x2300
leaq -0x1f(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
movzbl 0x54(%r14), %esi
movq %rbx, %rdi
callq 0x22e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hobbitsyfeet[P]Turn/turn.cc
// Function: Turn::welcomeBanner(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Turn::welcomeBanner(string input){
char block;
ifstream fin;
fin.open(input.c_str());
	while(!fin.eof()){
	fin>>block;
		if(block == '!')
			cout<<'\xDC';
		else if(block == '#')
			cout<<'\xDB';
		else if (block == '@')
			cout<<'\xB2';
		else if(block == '-')
			cout<<' ';
		else if(block == '^')
			cout<<'\xB1';
		else if(block =='%')
			cout<<'\xB0';
		else if(block == '$')
			cout<<'\xDF';
		else if(block ==',')
			cout<<'\xB3';
		else if (block == 'e')
			cout<<'\n';
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %rbx
leaq -0x238(%rbp), %r14
movq %r14, %rdi
callq 0x2220
movq (%rbx), %rsi
movq %r14, %rdi
movl $0x8, %edx
callq 0x2160
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x218(%rbp,%rax)
jne 0x73ef
leaq -0x238(%rbp), %rbx
leaq -0x2a(%rbp), %r14
leaq 0x40f3(%rip), %r13      # 0xb3ac
movq 0x7d10(%rip), %r15      # 0xefd0
leaq -0x29(%rbp), %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2260
movzbl -0x2a(%rbp), %eax
cmpl $0x3f, %eax
jg 0x7307
addl $-0x21, %eax
cmpl $0xc, %eax
ja 0x73d6
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movb $-0x24, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2230
jmp 0x73d6
cmpl $0x40, %eax
je 0x73ac
cmpl $0x5e, %eax
je 0x73c2
cmpl $0x65, %eax
jne 0x73d6
movb $0xa, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2230
jmp 0x73d6
movb $-0x4d, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2230
jmp 0x73d6
movb $-0x21, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2230
jmp 0x73d6
movb $-0x50, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2230
jmp 0x73d6
movb $-0x25, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2230
jmp 0x73d6
movb $0x20, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2230
jmp 0x73d6
movb $-0x4e, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2230
jmp 0x73d6
movb $-0x4f, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2230
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x218(%rbp,%rax)
je 0x72c4
leaq -0x238(%rbp), %rdi
callq 0x2090
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x740f
movq %rax, %rbx
leaq -0x238(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/hobbitsyfeet[P]Turn/chart.cc
// Function: Chart::Chart(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, bool)
Chart::Chart(string ChartName,int ChartWidth, int ChartHeight, bool FoW){
  chartWidth = ChartWidth;
  chartHeight = ChartHeight;
  fogOfWar = FoW;
  worldName = ChartName;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
leaq 0x18(%rdi), %r14
leaq 0x28(%rdi), %r15
movq %r15, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movb %al, 0x28(%rdi)
leaq 0x58(%rdi), %r13
movq %r13, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movb %al, 0x58(%rdi)
movl %edx, 0x3c(%rdi)
movl %ecx, 0x40(%rdi)
movb %r8b, 0x38(%rdi)
movq %r14, %rdi
callq 0x2140
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq 0x48(%rbx), %rdi
cmpq %r13, %rdi
je 0x7b54
movq (%r13), %rsi
incq %rsi
callq 0x2200
movq %r14, %rdi
movq %r15, %rsi
callq 0x23b4
movq %rbx, %rdi
callq 0x7a18
movq %r12, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O3/hobbitsyfeet[P]Turn/chart.cc
// Function: Chart::displayWorld()
void Chart::displayWorld(){
  vector<vector<container> >::iterator row;
  vector<container>::iterator col;
  for(row = world.begin(); row < world.end() ; row++){
    for(col = row->begin(); col < row->end(); col++){

      if(col->getGeoType()=='-' || col->getGeoType() =='O')
	cout<<"  ";
      else{
	        col->displayType();
	        cout<<' ';
      }
      //cout<<col->getOccupance();
      //	cout<<col->getLink();
    }
    cout<<endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rdi), %rbx
movq %rdi, -0x38(%rbp)
cmpq 0x8(%rdi), %rbx
jae 0x843f
movq 0x6c29(%rip), %r14      # 0xefd0
leaq 0x3385(%rip), %r15      # 0xb733
leaq -0x2a(%rbp), %r13
movq (%rbx), %r12
cmpq 0x8(%rbx), %r12
jae 0x8406
movzbl 0x9(%r12), %eax
cmpl $0x4f, %eax
je 0x83cb
cmpl $0x2d, %eax
jne 0x83d8
movl $0x2, %edx
movq %r14, %rdi
movq %r15, %rsi
jmp 0x83fb
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %r14, %rdi
leaq -0x29(%rbp), %rsi
callq 0x2230
movb $0x20, -0x2a(%rbp)
movl $0x1, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x2230
addq $0x30, %r12
jmp 0x83b5
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2170
addq $0x18, %rbx
movq -0x38(%rbp), %rax
cmpq 0x8(%rax), %rbx
jb 0x83b2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hobbitsyfeet[P]Turn/chart.cc
// Function: Chart::isPortal(int, int, bool&)
void Chart::isPortal(int x,int y,bool& gotLink){
  //cout<<"starting portal search"<<endl;
  vector<vector <container> >::iterator row = world.end()-y;
  vector<container> ::iterator col = row->begin()+x-1;
  //cout<<col->getPosX()<<col->getPosY()<<col->getLink();
  if(col->getLink() != ""){
    gotLink = true;
    this->loadWorld(col->getLink().c_str());
    //	cout<<"going to"<< col->getLink()<<endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq 0x8(%rdi), %rax
movslq %edx, %rcx
negq %rcx
leaq (%rcx,%rcx,2), %rcx
movq (%rax,%rcx,8), %r13
movslq %esi, %rax
leaq (%rax,%rax,2), %r14
shlq $0x4, %r14
leaq -0x50(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq -0x20(%r13,%r14), %rsi
movq -0x18(%r13,%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %r12
movq %r12, %rdi
callq 0x347c
leaq 0x2d34(%rip), %rsi      # 0xb4f4
movq %r12, %rdi
callq 0x20c0
movl %eax, %r15d
movq (%r12), %rdi
cmpq %rbx, %rdi
je 0x87e0
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2200
testl %r15d, %r15d
je 0x8854
addq %r14, %r13
movq -0x40(%rbp), %rax
movb $0x1, (%rax)
leaq -0x60(%rbp), %r14
movq %rbx, (%r14)
movq -0x20(%r13), %rsi
movq -0x18(%r13), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x347c
movq (%r14), %rsi
leaq -0x80(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x8912
leaq -0x80(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x7b70
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x883f
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x2200
movq -0x60(%rbp), %rdi
cmpq %rbx, %rdi
je 0x8854
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2200
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %r12
movq %rax, %rbx
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x888a
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x2200
jmp 0x888a
movq %rbx, %r12
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x889f
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O3/hobbitsyfeet[P]Turn/inventory.cc
// Function: Inventory::displayInv()
void Inventory::displayInv(){
  vector<Item>::iterator it;
  cout<<"===============Inventory==============="<<endl;
  for(it= invContainer.begin(); it< invContainer.end(); it++){
    cout<<"- ";
    it->viewItem();
  }
  cout<<"=======================================";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x5b9f(%rip), %r14      # 0xefd0
leaq 0x234c(%rip), %rsi      # 0xb784
movl $0x27, %edx
movq %r14, %rdi
callq 0x2230
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2170
movq (%rbx), %r14
cmpq 0x8(%rbx), %r14
jae 0x94a5
movq 0x5b54(%rip), %r15      # 0xefd0
leaq 0x22b6(%rip), %r12      # 0xb739
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2230
movq %r14, %rdi
callq 0x5b6c
addq $0x58, %r14
cmpq 0x8(%rbx), %r14
jb 0x9483
movq 0x5b24(%rip), %rdi      # 0xefd0
leaq 0x22f9(%rip), %rsi      # 0xb7ac
movl $0x27, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O3/hobbitsyfeet[P]Turn/inventory.cc
// Function: Inventory::searchWeaponEquipped()
bool Inventory::searchWeaponEquipped(){
  vector<Item>::iterator it;

  for(it=invContainer.begin(); it< invContainer.end(); it++){
    if(it->itemGetType() == "Right-Hand" && it->itemGetEquipped() == true){
      return true;
    }
    else if(it->itemGetType() == "Left-Hand" && it->itemGetEquipped() == true){
       return true;
    }
    else if(it->itemGetType() == "Two-Hands" && it->itemGetEquipped() == true){
        return true;
    }
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %r14
cmpq 0x8(%rdi), %r14
jae 0x9d7b
movq %rdi, %rbx
leaq -0x38(%rbp), %r12
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5b02
movq %r15, %rdi
leaq 0x1633(%rip), %rsi      # 0xb2a3
callq 0x20c0
testl %eax, %eax
je 0x9c90
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x9cb9
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2200
jmp 0x9cb9
movq %r14, %rdi
callq 0x5b62
movl %eax, %r13d
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x9cb0
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2200
testb %r13b, %r13b
jne 0x9d7f
movq %r15, %rdi
movq %r14, %rsi
callq 0x5b02
movq %r15, %rdi
leaq 0x15e0(%rip), %rsi      # 0xb2ae
callq 0x20c0
testl %eax, %eax
je 0x9cee
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x9d13
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2200
jmp 0x9d13
movq %r14, %rdi
callq 0x5b62
movl %eax, %r13d
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x9d0e
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2200
testb %r13b, %r13b
jne 0x9d7f
movq %r15, %rdi
movq %r14, %rsi
callq 0x5b02
movq %r15, %rdi
leaq 0x1590(%rip), %rsi      # 0xb2b8
callq 0x20c0
testl %eax, %eax
je 0x9d48
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x9d6d
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2200
jmp 0x9d6d
movq %r14, %rdi
callq 0x5b62
movl %eax, %r13d
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x9d68
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2200
testb %r13b, %r13b
jne 0x9d7f
addq $0x58, %r14
cmpq 0x8(%rbx), %r14
jb 0x9c5b
xorl %eax, %eax
jmp 0x9d81
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9d94
jmp 0x9d94
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x9dac
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/hobbitsyfeet[P]Turn/inventory.cc
// Function: Inventory::getSearch(Item)
Item Inventory::getSearch(Item iSearch){
  vector<Item>::iterator it;
  for(it=invContainer.begin(); it< invContainer.end(); it++){
    if (*it == iSearch)
      return *it;
  }
  return *it;
  cout<<"test";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %r14
cmpq 0x8(%rsi), %r14
jae 0x9deb
movq %rdx, %r15
movq %rsi, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x5e3c
testb %al, %al
jne 0x9e22
addq $0x58, %r14
cmpq 0x8(%r12), %r14
jb 0x9dd1
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x347c
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
callq 0x347c
jmp 0x9e57
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x347c
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
callq 0x347c
movq 0x4d(%r14), %rax
movq %rax, 0x4d(%rbx)
movups 0x40(%r14), %xmm0
movups %xmm0, 0x40(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9e76
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x9e8c
movq (%r15), %rsi
incq %rsi
callq 0x2200
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/hobbitsyfeet[P]Turn/inventory.cc
// Function: Inventory::getItemEquipped()
Item& Inventory::getItemEquipped(){

    vector<Item>::iterator it= invContainer.begin();
        Item& temp=*it;
    for(it=invContainer.begin(); it< invContainer.end(); it++){

      if(it->itemGetType() == "Right-Hand" && it->itemGetEquipped() == true)
        temp = *it;
      else if(it->itemGetType() == "Left-Hand" && it->itemGetEquipped() == true)
        temp =*it;
      else if(it->itemGetType() == "Two-Hands" && it->itemGetEquipped() == true)
        temp= *it;
  }
  return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
movq %rax, -0x30(%rbp)
cmpq 0x8(%rdi), %rax
jae 0x9ff1
movq %rdi, %r14
leaq -0x40(%rbp), %r13
leaq -0x50(%rbp), %r15
movq -0x30(%rbp), %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5b02
movq %r15, %rdi
leaq 0x13c9(%rip), %rsi      # 0xb2a3
callq 0x20c0
testl %eax, %eax
je 0x9efa
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x9f23
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2200
jmp 0x9f23
movq %rbx, %rdi
callq 0x5b62
movl %eax, %r12d
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x9f1a
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2200
testb %r12b, %r12b
jne 0x9fd7
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5b02
movq %r15, %rdi
leaq 0x1376(%rip), %rsi      # 0xb2ae
callq 0x20c0
testl %eax, %eax
je 0x9f58
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x9f7d
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2200
jmp 0x9f7d
movq %rbx, %rdi
callq 0x5b62
movl %eax, %r12d
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x9f78
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2200
testb %r12b, %r12b
jne 0x9fd7
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5b02
movq %r15, %rdi
leaq 0x1326(%rip), %rsi      # 0xb2b8
callq 0x20c0
testl %eax, %eax
je 0x9fb2
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x9fe3
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2200
jmp 0x9fe3
movq %rbx, %rdi
callq 0x5b62
movl %eax, %r12d
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x9fd2
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2200
testb %r12b, %r12b
je 0x9fe3
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x5e96
addq $0x58, %rbx
cmpq 0x8(%r14), %rbx
jb 0x9ec5
movq -0x30(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa008
jmp 0xa008
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0xa020
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: insert_docs_into_trie(my_trie*, char**, unsigned int*, unsigned int)
unsigned int insert_docs_into_trie(my_trie * my_trie_ptr, char ** docs,
    unsigned int * docs_word_counter, unsigned int nlines)
{//inserting every doc's word into trie, counting each doc's number of words - returns total number of all docs' words
    unsigned int total_word_counter = 0;

    for(unsigned int i = 0; i < nlines; i++)
    { //for each doc
        char * line_cp = (char *) malloc((strlen(docs[i]) + 1) * sizeof(char));
        strcpy(line_cp, docs[i]);
        char * word = strtok (line_cp, " \t");
        unsigned int line_word_counter = 0;

        while (word != NULL)
        {//for each doc's word
            line_word_counter++;
            my_trie_ptr->insert_word(word, i);
            word = strtok (NULL, " \t");
        }

        free(line_cp);

        docs_word_counter[i] = line_word_counter;
        total_word_counter += line_word_counter;
    }

    return total_word_counter;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
testl %ecx, %ecx
je 0x2f6f
movq %rdi, %r15
movl %ecx, %eax
movq %rax, (%rsp)
xorl %r12d, %r12d
leaq 0x234b(%rip), %r13      # 0x5238
xorl %ebp, %ebp
movq 0x8(%rsp), %rax
movq (%rax,%r12,8), %r14
movq %r14, %rdi
callq 0x2050
leaq 0x1(%rax), %rdi
callq 0x2170
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x20c0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x21f0
movl $0x0, %r14d
testq %rax, %rax
je 0x2f50
xorl %r14d, %r14d
incl %r14d
movq %r15, %rdi
movq %rax, %rsi
movl %r12d, %edx
callq 0x40aa
xorl %edi, %edi
movq %r13, %rsi
callq 0x21f0
testq %rax, %rax
jne 0x2f30
movq %rbx, %rdi
callq 0x2140
movq 0x10(%rsp), %rax
movl %r14d, (%rax,%r12,4)
addl %r14d, %ebp
incq %r12
cmpq (%rsp), %r12
jne 0x2eef
jmp 0x2f71
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: strip_line_into_words(char*, unsigned int&)
char ** strip_line_into_words(char * cmd, unsigned int & cmd_nwords)
{//returns a char * array which contains each cmd's word
    char ** cmd_words = NULL;
    char * word = strtok (cmd, " \t");

    unsigned int word_counter = 0;

    while (word != NULL)
    { //for each cmd's word
        cmd_words = (char **) realloc(cmd_words, (word_counter + 1) * sizeof(char *));
        cmd_words[word_counter] = (char *) malloc((strlen(word) + 1) * sizeof(char));  // plus one for \0
        strcpy(cmd_words[word_counter], word);
        word_counter++;
        word = strtok (NULL, " \t");
    }

    cmd_nwords = word_counter;
    return cmd_words;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x22a1(%rip), %rsi      # 0x5238
callq 0x21f0
testq %rax, %rax
je 0x3000
movq %rax, %r12
xorl %ebp, %ebp
leaq 0x228b(%rip), %r15      # 0x5238
xorl %r14d, %r14d
leal 0x1(%rbp), %r13d
leaq (,%r13,8), %rsi
movq %r14, %rdi
callq 0x2220
movq %rax, %r14
movq %r12, %rdi
callq 0x2050
leaq 0x1(%rax), %rdi
callq 0x2170
movl %ebp, %ecx
movq %rax, (%r14,%rcx,8)
movq %rax, %rdi
movq %r12, %rsi
callq 0x20c0
xorl %edi, %edi
movq %r15, %rsi
callq 0x21f0
movq %rax, %r12
movl %r13d, %ebp
testq %rax, %rax
jne 0x2fb0
jmp 0x3006
xorl %r14d, %r14d
xorl %r13d, %r13d
movl %r13d, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: delete_docs(char**, unsigned int*, unsigned int)
void delete_docs(char ** docs, unsigned int * docs_word_counter, unsigned int nlines)
{
    for(unsigned int i = 0; i < nlines; i++)
    {
        if (docs[i] != NULL)
        {
            free(docs[i]);
        }
    }

    free(docs);
    free(docs_word_counter);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
je 0x3079
movl %edx, %r15d
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdi
testq %rdi, %rdi
je 0x3071
callq 0x2140
incq %r12
cmpq %r12, %r15
jne 0x3063
movq %r14, %rdi
callq 0x2140
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: read_str(unsigned int)
char * read_str(unsigned int str_len)
{ //reads and returns string of unknown length
    char * str = (char *) malloc((str_len) * sizeof(char));
    int ch;
    unsigned int i = 0;

    while(((ch = getchar()) != '\n') && (ch != EOF))
    {
        str[i] = ch;
        i++;
        if(i == str_len)
        {
            str_len++;
            str = (char *) realloc(str, str_len * sizeof(char));
        }
    }

    str[i] = '\0';  // add \0 at the end of the string
    return str;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
movl %edi, %edi
callq 0x2170
movq %rax, %r14
xorl %ebp, %ebp
callq 0x2180
movl %ebp, %ecx
cmpl $-0x1, %eax
je 0x30d3
cmpl $0xa, %eax
je 0x30d3
movb %al, (%r14,%rcx)
incl %ebp
cmpl %ebp, %ebx
jne 0x30a6
incl %ebx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2220
movq %rax, %r14
jmp 0x30a6
movb $0x0, (%r14,%rcx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: get_unq_doc_ids(char**, posting_list**, my_trie*, unsigned int, unsigned int&)
unsigned int * get_unq_doc_ids(char ** cmd_words, posting_list ** pl_array, my_trie * trie_ptr,
    unsigned int nqs, unsigned int & unq_doc_ids_size)
{//returns an array that contains every unique doc id taken from each query's posting list
 //also all queries' posting lists pointers are stored in an array
    unsigned int * unq_doc_ids = NULL;
    unq_doc_ids_size = 0;

    for(unsigned int i = 1; i <= nqs; i++)
    { // for each query (max = 10)
        posting_list * pl_ptr = trie_ptr->search_word(cmd_words[i]);  //check if query exists in trie
        pl_array[i-1] = pl_ptr;  //store query's posting list pointer

        if(pl_ptr != NULL)
        { // if query exists
            unq_doc_ids = pl_ptr->add_doc_id_to_array(unq_doc_ids, unq_doc_ids_size);  //update unique doc ids array from query's posting list
        }
    }

    return unq_doc_ids;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, (%rsp)
movl $0x0, (%r8)
testl %ecx, %ecx
je 0x3209
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x1, %ebx
xorl %r13d, %r13d
movl %ebx, %eax
movq (%r12,%rax,8), %rsi
movq %r14, %rdi
callq 0x430c
leal -0x1(%rbx), %ecx
movq %rax, (%r15,%rcx,8)
testq %rax, %rax
je 0x3201
movq %rax, %rdi
movq %r13, %rsi
movq (%rsp), %rdx
callq 0x46aa
movq %rax, %r13
incl %ebx
cmpl %ebp, %ebx
jbe 0x31d5
jmp 0x320c
xorl %r13d, %r13d
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: get_number_of_digits(int)
unsigned int get_number_of_digits(int num)
{
    if (num == 0)
    {
        return 1;
    }
    else
    {
        return floor(log10(abs(num))) + 1;   //https://stackoverflow.com/questions/3068397/finding-the-length-of-an-integer-in-c
    }
}

// Assembly:
testl %edi, %edi
je 0x324a
pushq %rax
movl %edi, %eax
negl %eax
cmovsl %edi, %eax
cvtsi2sd %eax, %xmm0
callq 0x2070
callq 0x2230
addsd 0x1fc0(%rip), %xmm0     # 0x5200
cvttsd2si %xmm0, %rax
addq $0x8, %rsp
retq
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: init_newline(unsigned int, unsigned int&)
void init_newline(unsigned int init_llen, unsigned int & curr_llen)
{//go to new line and set cursor to the correct spot for printing
    cout<<endl;
    curr_llen = init_llen;
    for(unsigned int i = 0; i < init_llen; i++)
    {
        cout<<" ";
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
movq 0x4bae(%rip), %r15      # 0x7fd0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x20d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
movl %ebx, (%r14)
testl %ebx, %ebx
je 0x3472
movq 0x4b79(%rip), %r14      # 0x7fd0
leaq 0x20c3(%rip), %r15      # 0x5521
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2120
decl %ebx
jne 0x345e
popq %rbx
popq %r14
popq %r15
retq