LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13728(%rip), %rdi     # 0x47fe8
leaq 0x3d2a(%rip), %rsi      # 0x385f1
movl $0x8, %edx
callq 0x7340
testl %ebp, %ebp
jle 0x348f7
movq 0x1370c(%rip), %rdi     # 0x47fe8
movl %ebp, %esi
callq 0x74d0
leaq 0x3d0e(%rip), %rsi      # 0x385f8
movl $0x1, %edx
movq %rax, %rdi
callq 0x7340
movq 0x136ea(%rip), %r14     # 0x47fe8
leaq 0x1840(%rip), %rsi      # 0x36145
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_O1/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 0x2230
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 0x2caa
leaq -0x238(%rbp), %rbx
leaq -0x2a(%rbp), %r14
leaq 0x8490(%rip), %r13      # 0xb004
movq 0xc455(%rip), %r15      # 0xefd0
leaq -0x29(%rbp), %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2270
movzbl -0x2a(%rbp), %eax
cmpl $0x3f, %eax
jg 0x2bc2
addl $-0x21, %eax
cmpl $0xc, %eax
ja 0x2c91
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movb $-0x24, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2240
jmp 0x2c91
cmpl $0x40, %eax
je 0x2c67
cmpl $0x5e, %eax
je 0x2c7d
cmpl $0x65, %eax
jne 0x2c91
movb $0xa, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2240
jmp 0x2c91
movb $-0x4d, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2240
jmp 0x2c91
movb $-0x21, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2240
jmp 0x2c91
movb $-0x50, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2240
jmp 0x2c91
movb $-0x25, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2240
jmp 0x2c91
movb $0x20, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2240
jmp 0x2c91
movb $-0x4e, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2240
jmp 0x2c91
movb $-0x4f, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2240
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x218(%rbp,%rax)
je 0x2b7f
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 0x2cca
movq %rax, %rbx
leaq -0x238(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33a6
movq -0x38(%rbp), %rax
movq (%rax), %rdi
cmpq -0x30(%rbp), %rdi
je 0x36c4
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2210
movq %r14, %rdi
movq -0x48(%rbp), %rsi
callq 0x2390
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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), %ecx
subl 0x3c(%rdi), %ecx
jl 0x3851
movl 0x44(%rdi), %edx
leal 0x1(%rdx), %eax
movl %eax, 0x44(%rdi)
movl %ecx, 0x40(%rdi)
leal 0x17(%rdx), %ecx
imull %eax, %ecx
addl $0x16, %ecx
movl %ecx, 0x3c(%rdi)
imull $0xaaaaaaab, %edx, %ecx # imm = 0xAAAAAAAB
addl $0xd5555555, %ecx       # imm = 0xD5555555
cmpl $0x55555555, %ecx       # imm = 0x55555555
adcl $0x1, 0x24(%rdi)
imull $0xcccccccd, %edx, %ecx # imm = 0xCCCCCCCD
addl $0xe6666666, %ecx       # imm = 0xE6666666
cmpl $0x33333332, %ecx       # imm = 0x33333332
ja 0x3835
incl 0x24(%rdi)
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
movl $0x19999998, %ecx       # imm = 0x19999998
addl %ecx, %eax
rorl %eax
cmpl %ecx, %eax
ja 0x3851
incl 0x2c(%rdi)
incl 0x34(%rdi)
incl 0x48(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
subl 0x78(%rdi), %esi
imull %esi, %esi
subl 0x7c(%rdi), %edx
imull %edx, %edx
addl %esi, %edx
cvtsi2sd %edx, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x41f2
sqrtsd %xmm0, %xmm0
jmp 0x41fc
pushq %rbp
movq %rsp, %rbp
callq 0x21a0
popq %rbp
cvttsd2si %xmm0, %ecx
movl %ecx, %eax
negl %eax
cmovsl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2300
leaq 0x70ec(%rip), %rsi      # 0xb322
leaq -0x58(%rbp), %rdi
movq %r14, %rdx
callq 0x58b7
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 0x2210
leaq -0x258(%rbp), %rdi
movq %rbx, %rsi
callq 0x54cd
leaq -0x258(%rbp), %rdi
callq 0x2280
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rdi
callq 0x344a
subq $-0x80, %rbx
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x949e
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x42cb
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2210
movq 0xacfe(%rip), %rdi      # 0xefd0
leaq 0x707e(%rip), %rsi      # 0xb357
movl $0xb, %edx
callq 0x2240
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 0x21c0
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 0x2210
jmp 0x435c
jmp 0x4359
movq %rax, %rbx
leaq -0x258(%rbp), %rdi
callq 0x22a0
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2230
leaq 0x6152(%rip), %rsi      # 0xb322
leaq -0x90(%rbp), %rdi
movq %r14, %rdx
callq 0x58b7
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 0x5299
movq 0x9dc9(%rip), %r13      # 0xefe0
leaq 0x6104(%rip), %rbx      # 0xb322
leaq -0x50(%rbp), %r15
leaq -0x298(%rbp), %r12
movl $0x1f, %edx
movq 0x9d9b(%rip), %rdi      # 0xefd0
leaq 0x60ef(%rip), %rsi      # 0xb32b
callq 0x2240
movq %r13, %rdi
movq %r14, %rsi
callq 0x2260
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x58b7
movq -0x50(%rbp), %rsi
movq %r12, %rdi
movl $0x8, %edx
callq 0x2160
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5284
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2210
movq -0x298(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x278(%rbp,%rax)
jne 0x5229
leaq -0x298(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x53ae
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 0x344a
movq -0x30(%rbp), %rdi
subq $-0x80, %rdi
leaq -0x70(%rbp), %rsi
callq 0x984a
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x52f6
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2210
movq 0x9cd3(%rip), %rdi      # 0xefd0
leaq 0x6047(%rip), %rsi      # 0xb34b
movl $0xb, %edx
callq 0x2240
leaq -0x80(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5327
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x2210
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 0x5381
movq -0x60(%rbp), %rsi
jmp 0x5374
movq %rax, %rbx
jmp 0x539a
jmp 0x537e
jmp 0x537e
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5381
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2210
jmp 0x5381
movq %rax, %rbx
leaq -0x80(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x539a
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x2210
leaq -0x298(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2260
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 0x21d0
leaq 0x99(%r14), %rsi
movq %rax, %rdi
callq 0x21d0
leaq 0x9a(%r14), %rsi
movq %rax, %rdi
callq 0x21d0
leaq 0x9b(%r14), %rsi
movq %rax, %rdi
callq 0x21d0
leaq 0x9c(%r14), %rsi
movq %rax, %rdi
callq 0x21d0
leaq 0x9d(%r14), %rsi
movq %rax, %rdi
callq 0x21d0
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 0x2260
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2140
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movl 0x24(%r14), %eax
movl %eax, 0x24(%rbx)
movl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
movl 0x2c(%r14), %eax
movl %eax, 0x2c(%rbx)
movl 0x30(%r14), %eax
movl %eax, 0x30(%rbx)
movl 0x34(%r14), %eax
movl %eax, 0x34(%rbx)
movl 0x38(%r14), %eax
movl %eax, 0x38(%rbx)
movl 0x40(%r14), %eax
movl %eax, 0x40(%rbx)
movl 0x3c(%r14), %eax
movl %eax, 0x3c(%rbx)
movl 0x48(%r14), %eax
movl %eax, 0x48(%rbx)
movb 0x98(%r14), %al
movb %al, 0x98(%rbx)
movb 0x99(%r14), %al
movb %al, 0x99(%rbx)
movb 0x9b(%r14), %al
movb %al, 0x9b(%rbx)
movb 0x9c(%r14), %al
movb %al, 0x9c(%rbx)
movb 0x9d(%r14), %al
movb %al, 0x9d(%rbx)
movl 0x78(%r14), %eax
movl %eax, 0x78(%rbx)
movl 0x7c(%r14), %eax
movl %eax, 0x7c(%rbx)
leaq 0x58(%r14), %rsi
leaq 0x58(%rbx), %rdi
callq 0x2140
movl $0x80, %edi
addq %rdi, %r14
addq %rbx, %rdi
movq %r14, %rsi
callq 0x9ffc
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5aa9
movq (%r12), %rsi
incq %rsi
callq 0x2210
movq %rbx, %rdi
movq -0x38(%rbp), %rsi
callq 0x23aa
movq %r14, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9461(%rip), %r14      # 0xefd0
movq %r14, %rdi
callq 0x2240
movb $0x20, %r15b
leaq -0x19(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2240
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq %r14, %rdi
callq 0x2240
leaq -0x1a(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2240
cmpl $0x0, 0x40(%rbx)
je 0x5bf2
movq 0x9411(%rip), %r14      # 0xefd0
leaq 0x579d(%rip), %rsi      # 0xb363
movl $0x6, %edx
movq %r14, %rdi
callq 0x2240
movl 0x40(%rbx), %esi
movq %r14, %rdi
callq 0x2310
leaq 0x5785(%rip), %rsi      # 0xb36a
movl $0x2, %edx
movq %rax, %rdi
callq 0x2240
cmpl $0x0, 0x44(%rbx)
je 0x5c32
movq 0x93d1(%rip), %r14      # 0xefd0
leaq 0x5767(%rip), %rsi      # 0xb36d
movl $0x8, %edx
movq %r14, %rdi
callq 0x2240
movl 0x44(%rbx), %esi
movq %r14, %rdi
callq 0x2310
leaq 0x5745(%rip), %rsi      # 0xb36a
movl $0x2, %edx
movq %rax, %rdi
callq 0x2240
cmpl $0x0, 0x48(%rbx)
je 0x5c72
movq 0x9391(%rip), %r14      # 0xefd0
leaq 0x5730(%rip), %rsi      # 0xb376
movl $0x9, %edx
movq %r14, %rdi
callq 0x2240
movl 0x48(%rbx), %esi
movq %r14, %rdi
callq 0x2310
leaq 0x5705(%rip), %rsi      # 0xb36a
movl $0x2, %edx
movq %rax, %rdi
callq 0x2240
cmpl $0x0, 0x4c(%rbx)
je 0x5cb2
movq 0x9351(%rip), %r14      # 0xefd0
leaq 0x56fa(%rip), %rsi      # 0xb380
movl $0x7, %edx
movq %r14, %rdi
callq 0x2240
movl 0x4c(%rbx), %esi
movq %r14, %rdi
callq 0x2310
leaq 0x56c5(%rip), %rsi      # 0xb36a
movl $0x2, %edx
movq %rax, %rdi
callq 0x2240
movq 0x9317(%rip), %r14      # 0xefd0
leaq 0x56c8(%rip), %rsi      # 0xb388
movl $0xc, %edx
movq %r14, %rdi
callq 0x2240
movl 0x50(%rbx), %esi
movq %r14, %rdi
callq 0x2310
leaq 0x568b(%rip), %rsi      # 0xb36a
movl $0x2, %edx
movq %rax, %rdi
callq 0x2240
cmpb $0x1, 0x54(%rbx)
jne 0x5d0a
movq 0x92d7(%rip), %rdi      # 0xefd0
leaq 0x5695(%rip), %rsi      # 0xb395
movl $0xb, %edx
callq 0x2240
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21f0
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_O1/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2140
leaq 0x20(%rbx), %rsi
leaq 0x20(%r14), %rdi
callq 0x2140
movl 0x40(%rbx), %eax
movl %eax, 0x40(%r14)
movl 0x44(%rbx), %eax
movl %eax, 0x44(%r14)
movl 0x48(%rbx), %eax
movl %eax, 0x48(%r14)
movl 0x4c(%rbx), %eax
movl %eax, 0x4c(%r14)
movb 0x54(%rbx), %al
movb %al, 0x54(%r14)
movl 0x50(%rbx), %eax
movl %eax, 0x50(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2240
movb $0x20, %r15b
leaq -0x19(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2240
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rbx, %rdi
callq 0x2240
leaq -0x1a(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2240
movl 0x40(%r14), %esi
movq %rbx, %rdi
callq 0x2310
leaq -0x1b(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2240
movl 0x44(%r14), %esi
movq %rbx, %rdi
callq 0x2310
leaq -0x1c(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2240
movl 0x48(%r14), %esi
movq %rbx, %rdi
callq 0x2310
leaq -0x1d(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2240
movl 0x4c(%r14), %esi
movq %rbx, %rdi
callq 0x2310
leaq -0x1e(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2240
movl 0x50(%r14), %esi
movq %rbx, %rdi
callq 0x2310
leaq -0x1f(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2240
movzbl 0x54(%r14), %esi
movq %rbx, %rdi
callq 0x22f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2230
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 0x73c7
leaq -0x238(%rbp), %rbx
leaq -0x2a(%rbp), %r14
leaq 0x411b(%rip), %r13      # 0xb3ac
movq 0x7d38(%rip), %r15      # 0xefd0
leaq -0x29(%rbp), %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2270
movzbl -0x2a(%rbp), %eax
cmpl $0x3f, %eax
jg 0x72df
addl $-0x21, %eax
cmpl $0xc, %eax
ja 0x73ae
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movb $-0x24, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2240
jmp 0x73ae
cmpl $0x40, %eax
je 0x7384
cmpl $0x5e, %eax
je 0x739a
cmpl $0x65, %eax
jne 0x73ae
movb $0xa, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2240
jmp 0x73ae
movb $-0x4d, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2240
jmp 0x73ae
movb $-0x21, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2240
jmp 0x73ae
movb $-0x50, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2240
jmp 0x73ae
movb $-0x25, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2240
jmp 0x73ae
movb $0x20, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2240
jmp 0x73ae
movb $-0x4e, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2240
jmp 0x73ae
movb $-0x4f, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2240
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x218(%rbp,%rax)
je 0x729c
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 0x73e7
movq %rax, %rbx
leaq -0x238(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7af8
movq (%r13), %rsi
incq %rsi
callq 0x2210
movq %r14, %rdi
movq %r15, %rsi
callq 0x23c4
movq %rbx, %rdi
callq 0x79c4
movq %r12, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x83e1
movq 0x6c87(%rip), %r14      # 0xefd0
leaq 0x33d3(%rip), %r15      # 0xb723
leaq -0x2a(%rbp), %r13
movq (%rbx), %r12
cmpq 0x8(%rbx), %r12
jae 0x83a8
movzbl 0x9(%r12), %eax
cmpl $0x4f, %eax
je 0x836d
cmpl $0x2d, %eax
jne 0x837a
movl $0x2, %edx
movq %r14, %rdi
movq %r15, %rsi
jmp 0x839d
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %r14, %rdi
leaq -0x29(%rbp), %rsi
callq 0x2240
movb $0x20, -0x2a(%rbp)
movl $0x1, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x2240
addq $0x30, %r12
jmp 0x8357
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21f0
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 0x8354
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x8(%rdi), %rax
movslq %edx, %rcx
negq %rcx
leaq (%rcx,%rcx,2), %rcx
movq (%rax,%rcx,8), %rax
movslq %esi, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movb -0x28(%rax,%rcx), %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x344a
leaq 0x2d56(%rip), %rsi      # 0xb4f4
movq %r12, %rdi
callq 0x20c0
movl %eax, %r15d
movq (%r12), %rdi
cmpq %rbx, %rdi
je 0x87be
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2210
testl %r15d, %r15d
je 0x8832
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 0x344a
movq (%r14), %rsi
leaq -0x80(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x88f0
leaq -0x80(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x7b14
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x881d
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x2210
movq -0x60(%rbp), %rdi
cmpq %rbx, %rdi
je 0x8832
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2210
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 0x8868
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x2210
jmp 0x8868
movq %rbx, %r12
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x887d
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2210
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5bdf(%rip), %r14      # 0xefd0
leaq 0x237c(%rip), %rsi      # 0xb774
movl $0x27, %edx
movq %r14, %rdi
callq 0x2240
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2170
movq (%rbx), %r14
cmpq 0x8(%rbx), %r14
jae 0x9465
movq 0x5b94(%rip), %r15      # 0xefd0
leaq 0x22e6(%rip), %r12      # 0xb729
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2240
movq %r14, %rdi
callq 0x5b54
addq $0x58, %r14
cmpq 0x8(%rbx), %r14
jb 0x9443
movq 0x5b64(%rip), %rdi      # 0xefd0
leaq 0x2329(%rip), %rsi      # 0xb79c
movl $0x27, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, -0x50(%rbp)
cmpq 0x8(%rdi), %r14
setb %r13b
jae 0x9d48
leaq -0x38(%rbp), %rbx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5aea
movq %r15, %rdi
leaq 0x166e(%rip), %rsi      # 0xb2a3
callq 0x20c0
testl %eax, %eax
je 0x9c55
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x9c7e
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
jmp 0x9c7e
movq %r14, %rdi
callq 0x5b4a
movl %eax, %r12d
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x9c75
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
testb %r12b, %r12b
jne 0x9d48
movq %r15, %rdi
movq %r14, %rsi
callq 0x5aea
movq %r15, %rdi
leaq 0x161b(%rip), %rsi      # 0xb2ae
callq 0x20c0
testl %eax, %eax
je 0x9cb3
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x9cd8
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
jmp 0x9cd8
movq %r14, %rdi
callq 0x5b4a
movl %eax, %r12d
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x9cd3
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
testb %r12b, %r12b
jne 0x9d48
movq %r15, %rdi
movq %r14, %rsi
callq 0x5aea
movq %r15, %rdi
leaq 0x15cb(%rip), %rsi      # 0xb2b8
callq 0x20c0
testl %eax, %eax
je 0x9d0d
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x9d32
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
jmp 0x9d32
movq %r14, %rdi
callq 0x5b4a
movl %eax, %r12d
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x9d2d
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
testb %r12b, %r12b
jne 0x9d48
addq $0x58, %r14
movq -0x50(%rbp), %rax
cmpq 0x8(%rax), %r14
setb %r13b
jb 0x9c20
andb $0x1, %r13b
movl %r13d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9d62
jmp 0x9d62
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x9d7a
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9db9
movq %rdx, %r15
movq %rsi, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x5e24
testb %al, %al
jne 0x9df0
addq $0x58, %r14
cmpq 0x8(%r12), %r14
jb 0x9d9f
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x344a
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
callq 0x344a
jmp 0x9e25
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x344a
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
callq 0x344a
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 0x9e44
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x9e5a
movq (%r15), %rsi
incq %rsi
callq 0x2210
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9fbf
movq %rdi, %r14
leaq -0x40(%rbp), %r13
leaq -0x50(%rbp), %r15
movq -0x30(%rbp), %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5aea
movq %r15, %rdi
leaq 0x13fb(%rip), %rsi      # 0xb2a3
callq 0x20c0
testl %eax, %eax
je 0x9ec8
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x9ef1
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2210
jmp 0x9ef1
movq %rbx, %rdi
callq 0x5b4a
movl %eax, %r12d
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x9ee8
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2210
testb %r12b, %r12b
jne 0x9fa5
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5aea
movq %r15, %rdi
leaq 0x13a8(%rip), %rsi      # 0xb2ae
callq 0x20c0
testl %eax, %eax
je 0x9f26
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x9f4b
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2210
jmp 0x9f4b
movq %rbx, %rdi
callq 0x5b4a
movl %eax, %r12d
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x9f46
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2210
testb %r12b, %r12b
jne 0x9fa5
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5aea
movq %r15, %rdi
leaq 0x1358(%rip), %rsi      # 0xb2b8
callq 0x20c0
testl %eax, %eax
je 0x9f80
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x9fb1
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2210
jmp 0x9fb1
movq %rbx, %rdi
callq 0x5b4a
movl %eax, %r12d
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x9fa0
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2210
testb %r12b, %r12b
je 0x9fb1
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x5e7e
addq $0x58, %rbx
cmpq 0x8(%r14), %rbx
jb 0x9e93
movq -0x30(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9fd6
jmp 0x9fd6
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x9fee
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2210
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x21d0
xorl %ebp, %ebp
testl %eax, %eax
jne 0x2ce6
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x2200
xorl %ecx, %ecx
cmpl $0xa, %eax
sete %cl
addl %ecx, %ebp
movq %rbx, %rdi
callq 0x21d0
testl %eax, %eax
je 0x2cc8
movq %rbx, %rdi
callq 0x2040
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: is_number(char const*)
bool is_number(const char *str)
{
    for(unsigned int i=0; i < strlen(str); i++)
    { //iterating the whole string character by character
        if(!isdigit(str[i]))
        {// and checking if every character is a number
            return 0;
        }
    }

    return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2050
testq %rax, %rax
sete %cl
je 0x2d30
movsbl (%rbx), %edx
addl $-0x30, %edx
cmpl $0x9, %edx
ja 0x2d30
movl $0x1, %edx
movl %edx, %edx
cmpq %rdx, %rax
setbe %cl
jbe 0x2d30
movsbl (%rbx,%rdx), %esi
addl $-0x30, %esi
incl %edx
cmpl $0xa, %esi
jb 0x2d18
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2f84
movq %rdi, %r15
movl %ecx, %eax
movq %rax, (%rsp)
xorl %r12d, %r12d
leaq 0x2336(%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 0x2f65
xorl %r14d, %r14d
incl %r14d
movq %r15, %rdi
movq %rax, %rsi
movl %r12d, %edx
callq 0x4172
xorl %edi, %edi
movq %r13, %rsi
callq 0x21f0
testq %rax, %rax
jne 0x2f45
movq %rbx, %rdi
callq 0x2140
movq 0x10(%rsp), %rax
movl %r14d, (%rax,%r12,4)
addl %r14d, %ebp
incq %r12
cmpq (%rsp), %r12
jne 0x2f04
jmp 0x2f86
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_O1/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 0x228c(%rip), %rsi      # 0x5238
callq 0x21f0
testq %rax, %rax
je 0x3015
movq %rax, %r12
xorl %ebp, %ebp
leaq 0x2276(%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 0x2fc5
jmp 0x301b
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_O1/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 0x308e
movl %edx, %r15d
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdi
testq %rdi, %rdi
je 0x3086
callq 0x2140
incq %r12
cmpq %r12, %r15
jne 0x3078
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_O1/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 0x30e8
cmpl $0xa, %eax
je 0x30e8
movb %al, (%r14,%rcx)
incl %ebp
cmpl %ebp, %ebx
jne 0x30bb
incl %ebx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2220
movq %rax, %r14
jmp 0x30bb
movb $0x0, (%r14,%rcx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x321e
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 0x43f4
leal -0x1(%rbx), %ecx
movq %rax, (%r15,%rcx,8)
testq %rax, %rax
je 0x3216
movq %rax, %rdi
movq %r13, %rsi
movq (%rsp), %rdx
callq 0x47ba
movq %rax, %r13
incl %ebx
cmpl %ebp, %ebx
jbe 0x31ea
jmp 0x3221
xorl %r13d, %r13d
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq