LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x305f2(%rip), %rdi     # 0x9dfe8
leaq 0x3c44(%rip), %rsi      # 0x71641
callq 0x83d0
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jge 0x6da27
movl -0xc(%rbp), %esi
movq 0x305d5(%rip), %rdi     # 0x9dfe8
callq 0x8710
movq %rax, %rdi
leaq 0x3c26(%rip), %rsi      # 0x71648
callq 0x83d0
movq 0x305ba(%rip), %rdi     # 0x9dfe8
leaq 0x1704(%rip), %rsi      # 0x6f139
callq 0x83d0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x8390
movq %rax, %rdi
movq 0x30510(%rip), %rsi     # 0x9df60
callq 0x8430
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/pd2img/pd2img.cpp
// Function: main
int main(int argc, char **argv)
{
  // Parse program arguments
  if (!ParseArgs(argc, argv)) exit(-1);
  
  // Open pixel database
  R2PixelDatabase pd;
  if (!pd.OpenFile(input_pixel_database, "r")) exit(-1);

  // Write images
  if (!WriteImages(pd, output_image_directory)) exit(-1);

  // Close pixel database
  if (!pd.CloseFile()) exit(-1);

  // Return success
  return 0;
}

// Assembly:
subq $0x98, %rsp
movl $0x0, 0x94(%rsp)
movl %edi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movl 0x90(%rsp), %edi
movq 0x88(%rsp), %rsi
callq 0x6750
cmpl $0x0, %eax
jne 0x6674
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x5490
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1b5c0
movq 0x10(%rsp), %rdi
movq 0xb8dc9(%rip), %rsi     # 0xbf458
leaq 0x9cb1d(%rip), %rdx     # 0xa31b3
callq 0x1c730
movl %eax, 0x18(%rsp)
jmp 0x66a1
movl 0x18(%rsp), %eax
cmpl $0x0, %eax
jne 0x66ce
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x5490
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1b740
jmp 0x673f
movq 0xb8d8b(%rip), %rsi     # 0xbf460
leaq 0x28(%rsp), %rdi
callq 0x68d0
movl %eax, 0xc(%rsp)
jmp 0x66e5
movl 0xc(%rsp), %eax
cmpl $0x0, %eax
jne 0x66f8
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x5490
leaq 0x28(%rsp), %rdi
callq 0x1c910
movl %eax, 0x8(%rsp)
jmp 0x6708
movl 0x8(%rsp), %eax
cmpl $0x0, %eax
jne 0x671b
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x5490
movl $0x0, 0x94(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1b740
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x5680
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/pd2img/pd2img.cpp
// Function: ParseArgs(int, char**)
static int 
ParseArgs(int argc, char **argv)
{
  // Parse arguments
  argc--; argv++;
  while (argc > 0) {
    if ((*argv)[0] == '-') {
      if (!strcmp(*argv, "-v")) print_verbose = 1;
      else if (!strcmp(*argv, "-debug")) print_debug = 1;
      else { RNFail("Invalid program argument: %s", *argv); exit(1); }
      argv++; argc--;
    }
    else {
      if (!input_pixel_database) input_pixel_database = *argv;
      else if (!output_image_directory) output_image_directory = *argv;
      else { RNFail("Invalid program argument: %s", *argv); exit(1); }
      argv++; argc--;
    }
  }

  // Check filenames
  if (!input_pixel_database || !output_image_directory) {
    RNFail("Usage: pd2img inputpixeldatabase outputimagedirectory\n");
    return 0;
  }

  // Return OK status 
  return 1;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl 0x10(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x10(%rsp)
jle 0x6892
movq 0x8(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x681c
movq 0x8(%rsp), %rax
movq (%rax), %rdi
leaq 0x99860(%rip), %rsi     # 0xa0004
callq 0x5570
cmpl $0x0, %eax
jne 0x67ba
movl $0x1, 0xb8cb0(%rip)     # 0xbf468
jmp 0x6801
movq 0x8(%rsp), %rax
movq (%rax), %rdi
leaq 0x9983e(%rip), %rsi     # 0xa0007
callq 0x5570
cmpl $0x0, %eax
jne 0x67df
movl $0x1, 0xb8c8f(%rip)     # 0xbf46c
jmp 0x67ff
movq 0x8(%rsp), %rax
movq (%rax), %rsi
leaq 0x99820(%rip), %rdi     # 0xa000e
movb $0x0, %al
callq 0x41f80
movl $0x1, %edi
callq 0x5490
jmp 0x6801
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movl 0x10(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x688d
cmpq $0x0, 0xb8c34(%rip)     # 0xbf458
jne 0x6837
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0xb8c23(%rip)     # 0xbf458
jmp 0x6874
cmpq $0x0, 0xb8c21(%rip)     # 0xbf460
jne 0x6852
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0xb8c10(%rip)     # 0xbf460
jmp 0x6872
movq 0x8(%rsp), %rax
movq (%rax), %rsi
leaq 0x997ad(%rip), %rdi     # 0xa000e
movb $0x0, %al
callq 0x41f80
movl $0x1, %edi
callq 0x5490
jmp 0x6874
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movl 0x10(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x6776
cmpq $0x0, 0xb8bbe(%rip)     # 0xbf458
je 0x68a6
cmpq $0x0, 0xb8bbc(%rip)     # 0xbf460
jne 0x68be
leaq 0x9977e(%rip), %rdi     # 0xa002b
movb $0x0, %al
callq 0x41f80
movl $0x0, 0x14(%rsp)
jmp 0x68c6
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: 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
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x238(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x218(%rbp), %rdi
movq %rdi, -0x230(%rbp)
callq 0x3300
movq -0x238(%rbp), %rdi
callq 0x3130
movq -0x230(%rbp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x31d0
jmp 0x3d9b
jmp 0x3d9d
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x34a0
movb %al, -0x239(%rbp)
jmp 0x3dbd
movb -0x239(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3dce
jmp 0x3f35
leaq -0x218(%rbp), %rdi
leaq -0x9(%rbp), %rsi
callq 0x3370
jmp 0x3de0
movsbl -0x9(%rbp), %eax
cmpl $0x21, %eax
jne 0x3e24
movq 0x151e0(%rip), %rdi     # 0x18fd0
movl $0xffffffdc, %esi       # imm = 0xFFFFFFDC
callq 0x3320
jmp 0x3dfc
jmp 0x3f30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x30b0
jmp 0x3f4a
movsbl -0x9(%rbp), %eax
cmpl $0x23, %eax
jne 0x3e45
movq 0x1519c(%rip), %rdi     # 0x18fd0
movl $0xffffffdb, %esi       # imm = 0xFFFFFFDB
callq 0x3320
jmp 0x3e40
jmp 0x3f2e
movsbl -0x9(%rbp), %eax
cmpl $0x40, %eax
jne 0x3e66
movq 0x1517b(%rip), %rdi     # 0x18fd0
movl $0xffffffb2, %esi       # imm = 0xFFFFFFB2
callq 0x3320
jmp 0x3e61
jmp 0x3f2c
movsbl -0x9(%rbp), %eax
cmpl $0x2d, %eax
jne 0x3e87
movq 0x1515a(%rip), %rdi     # 0x18fd0
movl $0x20, %esi
callq 0x3320
jmp 0x3e82
jmp 0x3f2a
movsbl -0x9(%rbp), %eax
cmpl $0x5e, %eax
jne 0x3ea8
movq 0x15139(%rip), %rdi     # 0x18fd0
movl $0xffffffb1, %esi       # imm = 0xFFFFFFB1
callq 0x3320
jmp 0x3ea3
jmp 0x3f28
movsbl -0x9(%rbp), %eax
cmpl $0x25, %eax
jne 0x3ec6
movq 0x15118(%rip), %rdi     # 0x18fd0
movl $0xffffffb0, %esi       # imm = 0xFFFFFFB0
callq 0x3320
jmp 0x3ec4
jmp 0x3f26
movsbl -0x9(%rbp), %eax
cmpl $0x24, %eax
jne 0x3ee4
movq 0x150fa(%rip), %rdi     # 0x18fd0
movl $0xffffffdf, %esi       # imm = 0xFFFFFFDF
callq 0x3320
jmp 0x3ee2
jmp 0x3f24
movsbl -0x9(%rbp), %eax
cmpl $0x2c, %eax
jne 0x3f02
movq 0x150dc(%rip), %rdi     # 0x18fd0
movl $0xffffffb3, %esi       # imm = 0xFFFFFFB3
callq 0x3320
jmp 0x3f00
jmp 0x3f22
movsbl -0x9(%rbp), %eax
cmpl $0x65, %eax
jne 0x3f20
movq 0x150be(%rip), %rdi     # 0x18fd0
movl $0xa, %esi
callq 0x3320
jmp 0x3f1e
jmp 0x3f20
jmp 0x3f22
jmp 0x3f24
jmp 0x3f26
jmp 0x3f28
jmp 0x3f2a
jmp 0x3f2c
jmp 0x3f2e
jmp 0x3f30
jmp 0x3d9d
leaq -0x218(%rbp), %rdi
callq 0x30b0
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movl 0x40(%rcx), %eax
cmpl 0x3c(%rcx), %eax
jl 0x53a3
movq -0x10(%rbp), %rax
movl 0x44(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x44(%rax)
movl 0x3c(%rax), %edx
movl 0x40(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x40(%rax)
movl 0x44(%rax), %ecx
imull 0x44(%rax), %ecx
imull $0x16, 0x44(%rax), %edx
addl %edx, %ecx
addl $0x16, %ecx
movl %ecx, 0x3c(%rax)
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
movl 0x44(%rax), %eax
movl $0x3, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x534d
movq -0x10(%rbp), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rax
movl 0x44(%rax), %eax
movl $0x5, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x536e
movq -0x10(%rbp), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rax
movl 0x44(%rax), %eax
movl $0xa, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x53a1
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2c(%rax)
movl 0x34(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x34(%rax)
movl 0x48(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x48(%rax)
jmp 0x53a3
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hobbitsyfeet[P]Turn/unit.cc
// Function: Unit::displayStats()
void Unit::displayStats(){
  cout<<"==============STATS=============="<<endl;
  cout<<setfill(' ');
  cout<<"NAME:"<<name<<" x:"<<posX<<" y:"<< posY<<endl;
  cout<<"Health:"<<health<<'/'<<left<<setw(14)<<maxHealth<<"Experience:"<<experience<<endl;
  cout<<"Attack:"<<left<<setw(17)<<attack<<"Defence:"<<defence<<endl;
  cout<<setfill('=')<<setw(35)<<"==";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x13c05(%rip), %rdi     # 0x18fd0
leaq 0xcce5(%rip), %rsi      # 0x120b7
callq 0x3280
movq %rax, %rdi
movq 0x13bdf(%rip), %rsi     # 0x18fc0
callq 0x32b0
movl $0x20, %edi
callq 0x7a30
movb %al, -0x9(%rbp)
movq 0x13bd6(%rip), %rdi     # 0x18fd0
movzbl -0x9(%rbp), %esi
callq 0x33f0
movq 0x13bc6(%rip), %rdi     # 0x18fd0
leaq 0xccc8(%rip), %rsi      # 0x120d9
callq 0x3280
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x3270
movq %rax, %rdi
leaq 0xccb3(%rip), %rsi      # 0x120df
callq 0x3280
movq %rax, %rdi
movq -0x30(%rbp), %rax
movl 0x78(%rax), %esi
callq 0x3430
movq %rax, %rdi
leaq 0xcc99(%rip), %rsi      # 0x120e3
callq 0x3280
movq %rax, %rdi
movq -0x30(%rbp), %rax
movl 0x7c(%rax), %esi
callq 0x3430
movq %rax, %rdi
movq 0x13b58(%rip), %rsi     # 0x18fc0
callq 0x32b0
movq 0x13b5c(%rip), %rdi     # 0x18fd0
leaq 0xcc6c(%rip), %rsi      # 0x120e7
callq 0x3280
movq %rax, %rdi
movq -0x30(%rbp), %rax
movl 0x20(%rax), %esi
callq 0x3430
movq %rax, %rdi
movl $0x2f, %esi
callq 0x3320
movq %rax, %rdi
leaq 0x25aa(%rip), %rsi      # 0x7a50
callq 0x30f0
movq %rax, -0x40(%rbp)
movl $0xe, %edi
callq 0x7a80
movq -0x40(%rbp), %rdi
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %esi
callq 0x3310
movq %rax, %rdi
movq -0x30(%rbp), %rax
movl 0x24(%rax), %esi
callq 0x3430
movq %rax, %rdi
leaq 0xcc0e(%rip), %rsi      # 0x120ef
callq 0x3280
movq %rax, %rdi
movq -0x30(%rbp), %rax
movl 0x40(%rax), %esi
callq 0x3430
movq %rax, %rdi
movq 0x13ac1(%rip), %rsi     # 0x18fc0
callq 0x32b0
movq 0x13ac5(%rip), %rdi     # 0x18fd0
leaq 0xcbe9(%rip), %rsi      # 0x120fb
callq 0x3280
movq %rax, %rdi
leaq 0x252f(%rip), %rsi      # 0x7a50
callq 0x30f0
movq %rax, -0x38(%rbp)
movl $0x11, %edi
callq 0x7a80
movq -0x38(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
callq 0x3310
movq %rax, %rdi
movq -0x30(%rbp), %rax
movl 0x2c(%rax), %esi
callq 0x3430
movq %rax, %rdi
leaq 0xcba7(%rip), %rsi      # 0x12103
callq 0x3280
movq %rax, %rdi
movq -0x30(%rbp), %rax
movl 0x34(%rax), %esi
callq 0x3430
movq %rax, %rdi
movq 0x13a46(%rip), %rsi     # 0x18fc0
callq 0x32b0
movl $0x3d, %edi
callq 0x7a30
movb %al, -0x15(%rbp)
movq 0x13a3d(%rip), %rdi     # 0x18fd0
movzbl -0x15(%rbp), %esi
callq 0x33f0
movq %rax, -0x28(%rbp)
movl $0x23, %edi
callq 0x7a80
movq -0x28(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
callq 0x3310
movq %rax, %rdi
leaq 0xd306(%rip), %rsi      # 0x128c9
callq 0x3280
addq $0x40, %rsp
popq %rbp
retq
nop
// File: hobbitsyfeet[P]Turn/unit.cc
// Function: Unit::distanceTo(int, int)
int Unit::distanceTo(const int targetX, const int targetY){
  int dist;
  //distance between 2 points
  dist = sqrt( ( (targetX - this->getPosX())*(targetX - this->getPosX()) )
    +  ( targetY - this->getPosY())*(targetY - this->getPosY()) );
  //because distance cannot be negative
  if(dist< 0)
    return -(dist);
  else
    return dist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
callq 0x5260
movq -0x38(%rbp), %rdi
movl %eax, %ecx
movl -0x44(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x3c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x40(%rbp)
callq 0x5260
movl -0x40(%rbp), %ecx
movq -0x38(%rbp), %rdi
movl %eax, %edx
movl -0x3c(%rbp), %eax
subl %edx, %ecx
imull %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0x5240
movq -0x38(%rbp), %rdi
movl %eax, %ecx
movl -0x2c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
callq 0x5240
movl -0x28(%rbp), %ecx
movl -0x24(%rbp), %edi
movl %eax, %edx
movl -0x20(%rbp), %eax
subl %edx, %ecx
imull %ecx, %eax
addl %eax, %edi
callq 0x7db0
cvttsd2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x5d14
xorl %eax, %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5d1a
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x280, %rsp            # imm = 0x280
movq %rsi, -0x268(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x270(%rbp)
callq 0x3060
leaq -0x210(%rbp), %rdi
callq 0x3410
movq -0x268(%rbp), %rdx
leaq 0xc57a(%rip), %rsi      # 0x122ee
leaq -0x230(%rbp), %rdi
callq 0x7dd0
jmp 0x5d82
leaq -0x230(%rbp), %rdi
callq 0x3130
movq %rax, %rsi
leaq -0x210(%rbp), %rdi
movl $0x10, %edx
callq 0x3070
jmp 0x5da4
leaq -0x230(%rbp), %rdi
callq 0x31c0
movq -0x270(%rbp), %rsi
leaq -0x210(%rbp), %rdi
callq 0x7640
jmp 0x5dc5
leaq -0x210(%rbp), %rdi
callq 0x33a0
jmp 0x5dd3
movq -0x268(%rbp), %rsi
movq -0x270(%rbp), %rax
subq $-0x80, %rax
movq %rax, -0x278(%rbp)
leaq -0x260(%rbp), %rdi
callq 0x3140
jmp 0x5dfa
movq -0x278(%rbp), %rdi
leaq -0x260(%rbp), %rsi
callq 0xfc60
jmp 0x5e0f
leaq -0x260(%rbp), %rdi
callq 0x31c0
movq 0x131ae(%rip), %rdi     # 0x18fd0
leaq 0xc4fa(%rip), %rsi      # 0x12323
callq 0x3280
jmp 0x5e30
leaq -0x210(%rbp), %rdi
callq 0x33c0
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
jmp 0x5e97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x31c0
jmp 0x5e97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
leaq -0x260(%rbp), %rdi
callq 0x31c0
leaq -0x210(%rbp), %rdi
callq 0x33c0
movq -0x238(%rbp), %rdi
callq 0x3440
nop
// File: 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
subq $0x2b0, %rsp            # imm = 0x2B0
movq %rsi, -0x290(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x298(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x3300
movq -0x290(%rbp), %rdx
leaq 0xb03f(%rip), %rsi      # 0x122ee
leaq -0x238(%rbp), %rdi
callq 0x7dd0
jmp 0x72bd
leaq -0x238(%rbp), %rdi
callq 0x3130
movq %rax, %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x31d0
jmp 0x72df
jmp 0x72e1
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x3030
movb %al, -0x299(%rbp)
jmp 0x7301
movb -0x299(%rbp), %al
testb $0x1, %al
jne 0x7310
jmp 0x73da
movq 0x11cb9(%rip), %rdi     # 0x18fd0
leaq 0xafd9(%rip), %rsi      # 0x122f7
callq 0x3280
jmp 0x7325
movq -0x290(%rbp), %rsi
movq 0x11cad(%rip), %rdi     # 0x18fe0
callq 0x3350
jmp 0x733a
movq -0x290(%rbp), %rdx
leaq 0xafa6(%rip), %rsi      # 0x122ee
leaq -0x268(%rbp), %rdi
callq 0x7dd0
jmp 0x7356
leaq -0x268(%rbp), %rdi
callq 0x3130
movq %rax, %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x31d0
jmp 0x7378
leaq -0x268(%rbp), %rdi
callq 0x31c0
jmp 0x72e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
jmp 0x74a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
jmp 0x7499
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
leaq -0x268(%rbp), %rdi
callq 0x31c0
jmp 0x7499
movq -0x298(%rbp), %rsi
leaq -0x218(%rbp), %rdi
callq 0x74c0
jmp 0x73ef
leaq -0x218(%rbp), %rdi
callq 0x30a0
jmp 0x73fd
movq -0x290(%rbp), %rsi
movq -0x298(%rbp), %rax
subq $-0x80, %rax
movq %rax, -0x2a8(%rbp)
leaq -0x288(%rbp), %rdi
callq 0x3140
jmp 0x7424
movq -0x2a8(%rbp), %rdi
leaq -0x288(%rbp), %rsi
callq 0x100b0
jmp 0x7439
leaq -0x288(%rbp), %rdi
callq 0x31c0
movq 0x11b84(%rip), %rdi     # 0x18fd0
leaq 0xaec4(%rip), %rsi      # 0x12317
callq 0x3280
jmp 0x745a
leaq -0x238(%rbp), %rdi
callq 0x31c0
leaq -0x218(%rbp), %rdi
callq 0x30b0
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
leaq -0x288(%rbp), %rdi
callq 0x31c0
leaq -0x238(%rbp), %rdi
callq 0x31c0
leaq -0x218(%rbp), %rdi
callq 0x30b0
movq -0x240(%rbp), %rdi
callq 0x3440
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3350
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x44, %rsi
callq 0x31b0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x31b0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x24, %rsi
callq 0x31b0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x31b0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x2c, %rsi
callq 0x31b0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
callq 0x31b0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x34, %rsi
callq 0x31b0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
callq 0x31b0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
callq 0x31b0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x3c, %rsi
callq 0x31b0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x48, %rsi
callq 0x31b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x98, %rsi
callq 0x3250
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x99, %rsi
callq 0x3250
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x9a, %rsi
callq 0x3250
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x9b, %rsi
callq 0x3250
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x9c, %rsi
callq 0x3250
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x9d, %rsi
callq 0x3250
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x78, %rsi
callq 0x31b0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x7c, %rsi
callq 0x31b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x58, %rsi
callq 0x3350
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: hobbitsyfeet[P]Turn/unit.cc
// Function: Unit::operator=(Unit const&)
Unit& Unit::operator= (const Unit& i){
  name = i.name;
  health = i.health;
  maxHealth = i.maxHealth;
  stamina = i.stamina;
  attack = i.attack;
  range = i.range;
  defence = i.defence;
  gold = i.gold;
  experience = i.experience;
  maxExperience = i.maxExperience;
  dice = i.dice;
  leftHandEquipped = i.leftHandEquipped;
  rightHandEquipped = i.rightHandEquipped;
  torsoEquipped = i.torsoEquipped;
  legsEquipped = i.legsEquipped;
  feetEquipped = i.feetEquipped;
  posX = i.posX;
  posY = i.posY;
  currentWorld = i.currentWorld;
  inv = i.inv;
  return *this;
}

// 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)
movq -0x10(%rbp), %rsi
callq 0x3060
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x20(%rdi)
movq -0x10(%rbp), %rax
movl 0x24(%rax), %eax
movl %eax, 0x24(%rdi)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, 0x28(%rdi)
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x2c(%rdi)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, 0x30(%rdi)
movq -0x10(%rbp), %rax
movl 0x34(%rax), %eax
movl %eax, 0x34(%rdi)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, 0x38(%rdi)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, 0x40(%rdi)
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, 0x3c(%rdi)
movq -0x10(%rbp), %rax
movl 0x48(%rax), %eax
movl %eax, 0x48(%rdi)
movq -0x10(%rbp), %rax
movb 0x98(%rax), %al
andb $0x1, %al
movb %al, 0x98(%rdi)
movq -0x10(%rbp), %rax
movb 0x99(%rax), %al
andb $0x1, %al
movb %al, 0x99(%rdi)
movq -0x10(%rbp), %rax
movb 0x9b(%rax), %al
andb $0x1, %al
movb %al, 0x9b(%rdi)
movq -0x10(%rbp), %rax
movb 0x9c(%rax), %al
andb $0x1, %al
movb %al, 0x9c(%rdi)
movq -0x10(%rbp), %rax
movb 0x9d(%rax), %al
andb $0x1, %al
movb %al, 0x9d(%rdi)
movq -0x10(%rbp), %rax
movl 0x78(%rax), %eax
movl %eax, 0x78(%rdi)
movq -0x10(%rbp), %rax
movl 0x7c(%rax), %eax
movl %eax, 0x7c(%rdi)
movq -0x10(%rbp), %rsi
addq $0x58, %rsi
addq $0x58, %rdi
callq 0x3060
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x80, %rsi
addq $0x80, %rdi
callq 0x10ac0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdx, -0x60(%rbp)
movq %rsi, -0x40(%rbp)
movb 0x20(%rbp), %al
movl 0x18(%rbp), %r10d
movl 0x10(%rbp), %r10d
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
andb $0x1, %al
movb %al, -0x25(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0x3390
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x50(%rbp)
callq 0x3390
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x3060
jmp 0x86fb
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdi
addq $0x20, %rdi
callq 0x3060
jmp 0x870e
movq -0x58(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, 0x40(%rax)
movl -0x20(%rbp), %ecx
movl %ecx, 0x44(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x48(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x4c(%rax)
movb -0x25(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x54(%rax)
movl 0x18(%rbp), %ecx
movl %ecx, 0x50(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x31c0
movq -0x48(%rbp), %rdi
callq 0x31c0
movq -0x30(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x10(%rbp)
movq 0x10725(%rip), %rdi     # 0x18fd0
callq 0x3270
movq %rax, %rdi
movl $0x20, %esi
callq 0x3320
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
movq 0x10704(%rip), %rdi     # 0x18fd0
callq 0x3270
movq %rax, %rdi
movl $0x20, %esi
callq 0x3320
movq -0x10(%rbp), %rax
cmpl $0x0, 0x40(%rax)
je 0x8919
movq 0x106e1(%rip), %rdi     # 0x18fd0
leaq 0x9a39(%rip), %rsi      # 0x1232f
callq 0x3280
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x40(%rax), %esi
callq 0x3430
movq %rax, %rdi
leaq 0x9a22(%rip), %rsi      # 0x12336
callq 0x3280
movq -0x10(%rbp), %rax
cmpl $0x0, 0x44(%rax)
je 0x8954
movq 0x106a6(%rip), %rdi     # 0x18fd0
leaq 0x9a08(%rip), %rsi      # 0x12339
callq 0x3280
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x44(%rax), %esi
callq 0x3430
movq %rax, %rdi
leaq 0x99e7(%rip), %rsi      # 0x12336
callq 0x3280
movq -0x10(%rbp), %rax
cmpl $0x0, 0x48(%rax)
je 0x898f
movq 0x1066b(%rip), %rdi     # 0x18fd0
leaq 0x99d6(%rip), %rsi      # 0x12342
callq 0x3280
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x48(%rax), %esi
callq 0x3430
movq %rax, %rdi
leaq 0x99ac(%rip), %rsi      # 0x12336
callq 0x3280
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4c(%rax)
je 0x89ca
movq 0x10630(%rip), %rdi     # 0x18fd0
leaq 0x99a5(%rip), %rsi      # 0x1234c
callq 0x3280
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x4c(%rax), %esi
callq 0x3430
movq %rax, %rdi
leaq 0x9971(%rip), %rsi      # 0x12336
callq 0x3280
movq 0x105ff(%rip), %rdi     # 0x18fd0
leaq 0x997c(%rip), %rsi      # 0x12354
callq 0x3280
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x50(%rax), %esi
callq 0x3430
movq %rax, %rdi
leaq 0x9940(%rip), %rsi      # 0x12336
callq 0x3280
movq -0x10(%rbp), %rax
movb 0x54(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x8a1f
movq 0x105bd(%rip), %rdi     # 0x18fd0
leaq 0x9947(%rip), %rsi      # 0x12361
callq 0x3280
movq 0x105aa(%rip), %rdi     # 0x18fd0
movq 0x10593(%rip), %rsi     # 0x18fc0
callq 0x32b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: hobbitsyfeet[P]Turn/item.cc
// Function: Item::operator==(Item const&)
bool Item::operator == (const Item& i){
  if(itemName == i.itemName)
    return true;
  else
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7b60
testb $0x1, %al
jne 0x8c43
jmp 0x8c49
movb $0x1, -0x1(%rbp)
jmp 0x8c4d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: hobbitsyfeet[P]Turn/item.cc
// Function: Item::operator<(Item const&)
bool Item::operator <(const Item& i){
  if(itemName < i.itemName)
    return true;
  else
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8f00
testb $0x1, %al
jne 0x8c83
jmp 0x8c89
movb $0x1, -0x1(%rbp)
jmp 0x8c8d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: hobbitsyfeet[P]Turn/item.cc
// Function: Item::operator=(Item const&)
Item& Item::operator = (const Item& i){
  itemName = i.itemName;
  itemType = i.itemType;
  itemRange = i.itemRange;
  itemDamage = i.itemDamage;
  itemDefence = i.itemDefence;
  itemWorth = i.itemWorth;
  itemIsEquipped = i.itemIsEquipped;
  itemDurability = i.itemDurability;
  return *this;
}

// 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)
movq -0x10(%rbp), %rsi
callq 0x3060
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
addq $0x20, %rdi
callq 0x3060
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x40(%rcx), %ecx
movl %ecx, 0x40(%rax)
movq -0x10(%rbp), %rcx
movl 0x44(%rcx), %ecx
movl %ecx, 0x44(%rax)
movq -0x10(%rbp), %rcx
movl 0x48(%rcx), %ecx
movl %ecx, 0x48(%rax)
movq -0x10(%rbp), %rcx
movl 0x4c(%rcx), %ecx
movl %ecx, 0x4c(%rax)
movq -0x10(%rbp), %rcx
movb 0x54(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x54(%rax)
movq -0x10(%rbp), %rcx
movl 0x50(%rcx), %ecx
movl %ecx, 0x50(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3270
movq %rax, %rdi
movl $0x20, %esi
callq 0x3320
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x3270
movq %rax, %rdi
movl $0x20, %esi
callq 0x3320
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x40(%rax), %esi
callq 0x3430
movq %rax, %rdi
movl $0x20, %esi
callq 0x3320
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x44(%rax), %esi
callq 0x3430
movq %rax, %rdi
movl $0x20, %esi
callq 0x3320
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x48(%rax), %esi
callq 0x3430
movq %rax, %rdi
movl $0x20, %esi
callq 0x3320
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4c(%rax), %esi
callq 0x3430
movq %rax, %rdi
movl $0x20, %esi
callq 0x3320
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x50(%rax), %esi
callq 0x3430
movq %rax, %rdi
movl $0x20, %esi
callq 0x3320
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movb 0x54(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x3460
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x250, %rsp            # imm = 0x250
movq %rsi, -0x240(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x220(%rbp), %rdi
movq %rdi, -0x238(%rbp)
callq 0x3300
movq -0x240(%rbp), %rdi
callq 0x3130
movq -0x238(%rbp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x31d0
jmp 0xa5af
jmp 0xa5b1
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x34a0
movb %al, -0x241(%rbp)
jmp 0xa5d1
movb -0x241(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xa5e2
jmp 0xa749
leaq -0x220(%rbp), %rdi
leaq -0x11(%rbp), %rsi
callq 0x3370
jmp 0xa5f4
movsbl -0x11(%rbp), %eax
cmpl $0x21, %eax
jne 0xa638
movq 0xe9cc(%rip), %rdi      # 0x18fd0
movl $0xffffffdc, %esi       # imm = 0xFFFFFFDC
callq 0x3320
jmp 0xa610
jmp 0xa744
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x30b0
jmp 0xa75e
movsbl -0x11(%rbp), %eax
cmpl $0x23, %eax
jne 0xa659
movq 0xe988(%rip), %rdi      # 0x18fd0
movl $0xffffffdb, %esi       # imm = 0xFFFFFFDB
callq 0x3320
jmp 0xa654
jmp 0xa742
movsbl -0x11(%rbp), %eax
cmpl $0x40, %eax
jne 0xa67a
movq 0xe967(%rip), %rdi      # 0x18fd0
movl $0xffffffb2, %esi       # imm = 0xFFFFFFB2
callq 0x3320
jmp 0xa675
jmp 0xa740
movsbl -0x11(%rbp), %eax
cmpl $0x2d, %eax
jne 0xa69b
movq 0xe946(%rip), %rdi      # 0x18fd0
movl $0x20, %esi
callq 0x3320
jmp 0xa696
jmp 0xa73e
movsbl -0x11(%rbp), %eax
cmpl $0x5e, %eax
jne 0xa6bc
movq 0xe925(%rip), %rdi      # 0x18fd0
movl $0xffffffb1, %esi       # imm = 0xFFFFFFB1
callq 0x3320
jmp 0xa6b7
jmp 0xa73c
movsbl -0x11(%rbp), %eax
cmpl $0x25, %eax
jne 0xa6da
movq 0xe904(%rip), %rdi      # 0x18fd0
movl $0xffffffb0, %esi       # imm = 0xFFFFFFB0
callq 0x3320
jmp 0xa6d8
jmp 0xa73a
movsbl -0x11(%rbp), %eax
cmpl $0x24, %eax
jne 0xa6f8
movq 0xe8e6(%rip), %rdi      # 0x18fd0
movl $0xffffffdf, %esi       # imm = 0xFFFFFFDF
callq 0x3320
jmp 0xa6f6
jmp 0xa738
movsbl -0x11(%rbp), %eax
cmpl $0x2c, %eax
jne 0xa716
movq 0xe8c8(%rip), %rdi      # 0x18fd0
movl $0xffffffb3, %esi       # imm = 0xFFFFFFB3
callq 0x3320
jmp 0xa714
jmp 0xa736
movsbl -0x11(%rbp), %eax
cmpl $0x65, %eax
jne 0xa734
movq 0xe8aa(%rip), %rdi      # 0x18fd0
movl $0xa, %esi
callq 0x3320
jmp 0xa732
jmp 0xa734
jmp 0xa736
jmp 0xa738
jmp 0xa73a
jmp 0xa73c
jmp 0xa73e
jmp 0xa740
jmp 0xa742
jmp 0xa744
jmp 0xa5b1
leaq -0x220(%rbp), %rdi
callq 0x30b0
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq -0x228(%rbp), %rdi
callq 0x3440
nopw (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rsi, -0x38(%rbp)
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xcb90
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x40(%rbp)
callq 0x3390
movq -0x48(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x50(%rbp)
callq 0x3390
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x14(%rbp), %ecx
movl %ecx, 0x3c(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x40(%rax)
movb -0x19(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x38(%rax)
callq 0x3060
jmp 0xb609
addq $0x50, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x31c0
movq -0x40(%rbp), %rdi
callq 0x31c0
movq -0x48(%rbp), %rdi
callq 0xb090
movq -0x28(%rbp), %rdi
callq 0x3440
nop
// File: hobbitsyfeet[P]Turn/chart.cc
// Function: Chart::container::checkAvailable()
bool Chart::container::checkAvailable(){
  //if not occupied check if terrain is accessible
  //if(this->getOccupance() == false)
  switch(this->getGeoType()){
  case'!':
  case'=':
    //case'@':
  case'$':
  case'%':
  case'^':
  case'&':
  case'*':
  case'~':
  case'#':
  case'|':
  case'_':
  case'/':
    return false;
    break;
  default:
    return true;
  }
  //else return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc1a0
movsbl %al, %eax
addl $-0x21, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x5d, %eax
ja 0xc040
movq -0x18(%rbp), %rax
leaq 0x663f(%rip), %rcx      # 0x12670
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x0, -0x1(%rbp)
jmp 0xc044
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xcbb0
leaq -0x18(%rbp), %rdi
callq 0xcbd0
movq -0x50(%rbp), %rdi
callq 0xcdc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x50(%rbp), %rdi
callq 0xce30
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xcdf0
testb $0x1, %al
jne 0xc0ae
jmp 0xc199
leaq -0x10(%rbp), %rdi
callq 0xce60
movq %rax, %rdi
callq 0xce80
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xce60
movq %rax, %rdi
callq 0xcef0
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xceb0
testb $0x1, %al
jne 0xc0f3
jmp 0xc172
leaq -0x18(%rbp), %rdi
callq 0xd010
movq %rax, %rdi
callq 0xc1a0
movsbl %al, %eax
cmpl $0x2d, %eax
je 0xc125
leaq -0x18(%rbp), %rdi
callq 0xd010
movq %rax, %rdi
callq 0xc1a0
movsbl %al, %eax
cmpl $0x4f, %eax
jne 0xc13a
movq 0xcea4(%rip), %rdi      # 0x18fd0
leaq 0x66f8(%rip), %rsi      # 0x1282b
callq 0x3280
jmp 0xc15c
leaq -0x18(%rbp), %rdi
callq 0xd010
movq %rax, %rdi
callq 0xc1c0
movq 0xce7e(%rip), %rdi      # 0x18fd0
movl $0x20, %esi
callq 0x3320
jmp 0xc15e
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0xcf90
movq %rax, -0x40(%rbp)
jmp 0xc0cb
movq 0xce57(%rip), %rdi      # 0x18fd0
movq 0xce40(%rip), %rsi      # 0x18fc0
callq 0x32b0
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xcfd0
movq %rax, -0x48(%rbp)
jmp 0xc08b
addq $0x50, %rsp
popq %rbp
retq
nop
// File: hobbitsyfeet[P]Turn/chart.cc
// Function: Chart::canEnter(int, int)
bool Chart::canEnter(int x, int y){
  vector<vector <container> >::iterator row = world.end()-y;
  vector<container> ::iterator col = row->begin()+x-1;
  //cout<<col->getPosX()<<','<<col->getPosY()<<endl;
  if(col->getOccupance() == false){
    //cout<<"allowed to enter"<<endl;
    return false;
  }
  else return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xce30
movq %rax, -0x28(%rbp)
movslq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xd030
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xce60
movq %rax, %rdi
callq 0xce80
movq %rax, -0x40(%rbp)
movslq -0x14(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0xd070
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0xd0b0
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xd010
movq %rax, %rdi
callq 0xc690
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xc679
movb $0x0, -0x1(%rbp)
jmp 0xc67d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: hobbitsyfeet[P]Turn/chart.cc
// Function: Chart::setSpawn(char, int&, int&)
void Chart::setSpawn(char spawnPt, int& x, int&y){
  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(spawnPt == col->getGeoType()){
	x = col->getPosX();
	y = col->getPosY();
	return;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xcbb0
leaq -0x30(%rbp), %rdi
callq 0xcbd0
movq -0x68(%rbp), %rdi
callq 0xcdc0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x68(%rbp), %rdi
callq 0xce30
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xcdf0
testb $0x1, %al
jne 0xc7cc
jmp 0xc895
leaq -0x28(%rbp), %rdi
callq 0xce60
movq %rax, %rdi
callq 0xce80
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xce60
movq %rax, %rdi
callq 0xcef0
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xceb0
testb $0x1, %al
jne 0xc811
jmp 0xc87f
movsbl -0x9(%rbp), %eax
movl %eax, -0x6c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xd010
movq %rax, %rdi
callq 0xc1a0
movb %al, %cl
movl -0x6c(%rbp), %eax
movsbl %cl, %ecx
cmpl %ecx, %eax
jne 0xc869
leaq -0x30(%rbp), %rdi
callq 0xd010
movq %rax, %rdi
callq 0xc5a0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
leaq -0x30(%rbp), %rdi
callq 0xd010
movq %rax, %rdi
callq 0xc5b0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0xc895
jmp 0xc86b
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0xcf90
movq %rax, -0x58(%rbp)
jmp 0xc7e9
jmp 0xc881
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0xcfd0
movq %rax, -0x60(%rbp)
jmp 0xc7a9
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0xce30
movq %rax, -0x28(%rbp)
movslq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xd030
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xce60
movq %rax, %rdi
callq 0xce80
movq %rax, -0x40(%rbp)
movslq -0xc(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0xd070
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0xd0b0
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xd010
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0xcb00
movq -0xc0(%rbp), %rdi
leaq 0x5acb(%rip), %rsi      # 0x1248b
callq 0x48e0
movb %al, -0xb2(%rbp)
jmp 0xc9cd
leaq -0x60(%rbp), %rdi
callq 0x31c0
movb -0xb2(%rbp), %al
testb $0x1, %al
jne 0xc9e5
jmp 0xcadf
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
leaq -0x30(%rbp), %rdi
callq 0xd010
movq %rax, %rsi
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0xcb00
movq -0xe0(%rbp), %rdi
callq 0x3130
movq %rax, -0xd8(%rbp)
leaq -0xb1(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3450
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0x47d0
jmp 0xca4d
movq -0xc8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0xb640
jmp 0xca62
leaq -0x90(%rbp), %rdi
callq 0x31c0
leaq -0xb1(%rbp), %rdi
callq 0x32d0
leaq -0xb0(%rbp), %rdi
callq 0x31c0
jmp 0xcadf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x31c0
jmp 0xcae8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xcac5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x31c0
leaq -0xb1(%rbp), %rdi
callq 0x32d0
leaq -0xb0(%rbp), %rdi
callq 0x31c0
jmp 0xcae8
addq $0xe0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x7aa0
movq 0x946c(%rip), %rdi      # 0x18fd0
leaq 0x2d11(%rip), %rsi      # 0x1287c
callq 0x3280
movq %rax, %rdi
movq 0x9446(%rip), %rsi      # 0x18fc0
callq 0x32b0
movq -0x30(%rbp), %rdi
callq 0x7ac0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rdi
callq 0x7b30
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x7af0
testb $0x1, %al
jne 0xfbb4
jmp 0xfbe9
movq 0x9415(%rip), %rdi      # 0x18fd0
leaq 0x2c6f(%rip), %rsi      # 0x12831
callq 0x3280
leaq -0x10(%rbp), %rdi
callq 0x7bf0
movq %rax, %rdi
callq 0x8890
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x7d70
movq %rax, -0x28(%rbp)
jmp 0xfb94
movq 0x93e0(%rip), %rdi      # 0x18fd0
leaq 0x2cad(%rip), %rsi      # 0x128a4
callq 0x3280
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdx, -0x58(%rbp)
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7aa0
movq -0x40(%rbp), %rdi
callq 0x7ac0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rdi
callq 0x7b30
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7af0
testb $0x1, %al
jne 0x10729
jmp 0x1076e
leaq -0x20(%rbp), %rdi
callq 0x7c10
movq -0x58(%rbp), %rsi
movq %rax, %rdi
callq 0x8c20
testb $0x1, %al
jne 0x10744
jmp 0x1075b
leaq -0x20(%rbp), %rdi
callq 0x7c10
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x7c30
jmp 0x10783
jmp 0x1075d
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x7d70
movq %rax, -0x38(%rbp)
jmp 0x10709
leaq -0x20(%rbp), %rdi
callq 0x7c10
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x7c30
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: open_file(char*)
FILE * open_file(char * fn)
{
    FILE* random_file;
    random_file = fopen(fn, "r");

    if (!random_file)
    {
        fprintf(stderr, "-! ERROR - docfile does not exist !-\n");
        exit(1);
    }

    return random_file;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x35b1(%rip), %rsi      # 0x6208
callq 0x2120
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2c89
movq 0x636a(%rip), %rax      # 0x8fd8
movq (%rax), %rdi
leaq 0x3592(%rip), %rsi      # 0x620a
movb $0x0, %al
callq 0x21c0
movl $0x1, %edi
callq 0x2140
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: get_number_of_lines(_IO_FILE*)
unsigned int get_number_of_lines(FILE * fp)
{
    unsigned int lines = 0;
    int ch ;

    while(!feof(fp))
    {
      ch = fgetc(fp);
      if(ch == '\n')
      {
        lines++;
      }
    }

    rewind(fp);
    return lines ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x21e0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2cca
jmp 0x2ce7
movq -0x8(%rbp), %rdi
callq 0x2210
movl %eax, -0x10(%rbp)
cmpl $0xa, -0x10(%rbp)
jne 0x2ce5
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2cb3
movq -0x8(%rbp), %rdi
callq 0x2030
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)