LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/space.cc
// Function: AddrSpace::printRaw(std::ostream&, unsigned long) const
void AddrSpace::printRaw(ostream &s,uintb offset) const

{
  int4 sz = getAddrSize();
  if (sz > 4) {
    if ((offset>>32) == 0)
      sz = 4;			// Don't print a bunch of zeroes at front of address
    else if ((offset>>48) == 0)
      sz = 6;
  }
  s << "0x" << setfill('0') << setw(2*sz) << hex << byteToAddress(offset,wordsize);
  if (wordsize>1) {
    int4 cut = offset % wordsize;
    if (cut != 0)
      s << '+' << dec << cut;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl 0x58(%rdi), %eax
cmpl $0x5, %eax
jl 0x4995c
movq %r14, %rcx
shrq $0x20, %rcx
movl $0x4, %ebp
je 0x4995e
movq %r14, %rcx
shrq $0x30, %rcx
movl $0x6, %ecx
cmovel %ecx, %eax
movl %eax, %ebp
leaq 0x3774f(%rip), %rsi     # 0x810b4
movl $0x2, %edx
movq %rbx, %rdi
callq 0x40b80
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %r12
cmpb $0x0, 0xe1(%rbx,%rax)
jne 0x499a5
movq %r12, %rdi
movl $0x20, %esi
callq 0x40740
movb %al, 0xe0(%r12)
movb $0x1, 0xe1(%r12)
movb $0x30, 0xe0(%r12)
addl %ebp, %ebp
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movslq %ebp, %rdx
movq %rdx, 0x10(%rbx,%rcx)
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
movl 0x5c(%r15), %ecx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3ffb0
movl 0x5c(%r15), %ecx
cmpq $0x2, %rcx
jb 0x49a37
movq %r14, %rax
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
je 0x49a37
movq %rdx, %r14
leaq 0xf(%rsp), %rsi
movb $0x2b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b80
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
movl %r14d, %esi
callq 0x41da0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/space.cc
// Function: JoinSpace::printRaw(std::ostream&, unsigned long) const
void JoinSpace::printRaw(ostream &s,uintb offset) const

{
  JoinRecord *rec = getManager()->findJoin(offset);
  int4 szsum = 0;
  int4 num = rec->numPieces();
  s << '{';
  for(int4 i=0;i<num;++i) {
    const VarnodeData &vdat( rec->getPiece(i) );
    szsum += vdat.size;
    if (i!=0)
      s << ',';
    vdat.space->printRaw(s,vdat.offset);
  }
  if (num == 1) {
    szsum = rec->getUnified().size;
    s << ':' << szsum;
  }
  s << '}';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq 0x10(%rdi), %rdi
movq %rdx, %rsi
callq 0x41410
movq %rax, %r14
movq 0x8(%rax), %rax
subq (%r14), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r15
leaq 0xd(%rsp), %rsi
movb $0x7b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b80
movq %r15, 0x10(%rsp)
testl %r15d, %r15d
jle 0x4b417
movq 0x10(%rsp), %r13
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
movl $0x8, %ebp
xorl %r12d, %r12d
movq (%r14), %r15
testq %r12, %r12
je 0x4b3f9
movb $0x2c, 0xc(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
leaq 0xc(%rsp), %rsi
callq 0x40b80
movq -0x8(%r15,%rbp), %rdi
movq (%r15,%rbp), %rdx
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x50(%rax)
incq %r12
addq $0x18, %rbp
cmpq %r12, %r13
jne 0x4b3da
cmpl $0x1, 0x10(%rsp)
jne 0x4b441
movl 0x28(%r14), %ebp
leaq 0xe(%rsp), %rsi
movb $0x3a, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b80
movq %rax, %rdi
movl %ebp, %esi
callq 0x41da0
leaq 0xf(%rsp), %rsi
movb $0x7d, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b80
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/space.cc
// Function: OverlaySpace::saveXml(std::ostream&) const
void OverlaySpace::saveXml(ostream &s) const

{
  s << "<space_overlay";
  a_v(s,"name",name);
  a_v_i(s,"index",index);
  a_v(s,"base",baseSpace->getName());
  s << "/>\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x33fdc(%rip), %rsi     # 0x7f8de
movl $0xe, %edx
movq %rbx, %rdi
callq 0x40b80
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x33712(%rip), %rsi     # 0x7f031
leaq 0x3370f(%rip), %rdx     # 0x7f035
leaq 0x10(%rsp), %rdi
callq 0x3f8a0
leaq 0xf(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rdi
callq 0x40b80
leaq 0x35dfa(%rip), %rsi     # 0x81758
movl $0x2, %edx
movq %rax, %rdi
callq 0x40b80
movq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x3f3d0
leaq 0x35c69(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x4b9a2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40870
leaq 0x10(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x33d75(%rip), %rsi     # 0x7f726
leaq 0x33d73(%rip), %rdx     # 0x7f72b
callq 0x3f8a0
movslq 0x60(%r14), %r15
leaq 0xf(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rdi
callq 0x40b80
movq %rax, %r12
leaq 0x35d66(%rip), %rsi     # 0x81758
movl $0x2, %edx
movq %rax, %rdi
callq 0x40b80
movq (%r12), %rax
movq -0x18(%rax), %rax
movl 0x18(%r12,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%r12,%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0x406f0
leaq 0x35bbe(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rax, %rdi
callq 0x40b80
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x4ba4d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40870
leaq 0x10(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x3404b(%rip), %rsi     # 0x7faa7
leaq 0x34048(%rip), %rdx     # 0x7faab
callq 0x3f8a0
movq 0x70(%r14), %r14
leaq 0xf(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rdi
callq 0x40b80
leaq 0x35cbe(%rip), %rsi     # 0x81758
movl $0x2, %edx
movq %rax, %rdi
callq 0x40b80
movq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x3f3d0
leaq 0x35b2d(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x4bade
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40870
leaq 0x34d30(%rip), %rsi     # 0x80815
movl $0x3, %edx
movq %rbx, %rdi
callq 0x40b80
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4bb04
jmp 0x4bb04
movq %rax, %rbx
jmp 0x4bb27
jmp 0x4bb0d
jmp 0x4bb0d
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x4bb27
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: TruncationTag::restoreXml(Element const*)
void TruncationTag::restoreXml(const Element *el)

{
  spaceName = el->getAttributeValue("space");
  istringstream s(el->getAttributeValue("size"));
  s.unsetf(ios::dec | ios::hex | ios::oct);
  s >> size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3386b(%rip), %rsi     # 0x7fb1d
leaq 0x33869(%rip), %rdx     # 0x7fb22
leaq 0x20(%rsp), %rdi
callq 0x3f8a0
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x40f70
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3fc60
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x4c2f2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x40870
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3949b(%rip), %rsi     # 0x8579d
leaq 0x39498(%rip), %rdx     # 0x857a1
movq %rsp, %rdi
callq 0x3f8a0
movq %rsp, %rsi
movq %r14, %rdi
callq 0x40f70
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x41c80
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4c344
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40870
leaq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x38(%rsp,%rax)
addq $0x20, %rbx
movq %rbx, %rsi
callq 0x41eb0
movq 0x569a8(%rip), %rsi     # 0xa2d10
leaq 0x20(%rsp), %rdi
callq 0x41440
leaq 0x98(%rsp), %rdi
callq 0x3f730
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x5697a(%rip), %rsi     # 0xa2d10
leaq 0x20(%rsp), %rdi
callq 0x41440
leaq 0x98(%rsp), %rdi
callq 0x3f730
jmp 0x4c3e3
jmp 0x4c3b1
movq %rax, %rbx
jmp 0x4c3e3
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4c3e3
movq 0x10(%rsp), %rsi
jmp 0x4c3db
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x4c3e3
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: SpacebaseSpace::setBaseRegister(VarnodeData const&, int, bool)
void SpacebaseSpace::setBaseRegister(const VarnodeData &data,int4 truncSize,bool stackGrowth)

{
  if (hasbaseregister) {
    if ((baseloc != data)||(isNegativeStack != stackGrowth))
      throw LowlevelError("Attempt to assign more than one base register to space: "+getName());
  }
  hasbaseregister = true;
  isNegativeStack = stackGrowth;
  baseOrig = data;
  baseloc = data;
  if (truncSize != baseloc.size) {
    if (baseloc.space->isBigEndian())
      baseloc.offset += (baseloc.size - truncSize);
    baseloc.size = truncSize;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
cmpb $0x1, 0x78(%rdi)
jne 0x4c4a0
movq 0x80(%r14), %rax
cmpq (%rsi), %rax
jne 0x4c500
movq 0x88(%r14), %rax
cmpq 0x8(%rsi), %rax
jne 0x4c500
movl 0x90(%r14), %eax
cmpl 0x10(%rsi), %eax
jne 0x4c500
cmpb %cl, 0x79(%r14)
jne 0x4c500
movb $0x1, 0x78(%r14)
movb %cl, 0x79(%r14)
movups (%rsi), %xmm0
movups %xmm0, 0x98(%r14)
movq 0x10(%rsi), %rax
movq %rax, 0xa8(%r14)
movups (%rsi), %xmm0
movups %xmm0, 0x80(%r14)
movq 0x10(%rsi), %rax
movq %rax, 0x90(%r14)
subl %edx, %eax
je 0x4c4f7
leaq 0x80(%r14), %rcx
movq (%rcx), %rcx
testb $0x1, 0x24(%rcx)
je 0x4c4f0
addq %rax, 0x88(%r14)
movl %edx, 0x90(%r14)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
addq $0x38, %r14
leaq 0x33528(%rip), %rsi     # 0x7fa40
movq %rsp, %rdi
movq %r14, %rdx
callq 0x40500
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x5696e(%rip), %rsi     # 0xa2ea8
movq 0x566f7(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d60
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4c56f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40870
jmp 0x4c56f
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x4c57c
movq %rbx, %rdi
callq 0x40080
movq %r14, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: SpacebaseSpace::saveXml(std::ostream&) const
void SpacebaseSpace::saveXml(ostream &s) const

{
  s << "<space_base";
  saveBasicAttributes(s);
  a_v(s,"contain",contain->getName());
  s << "/>\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x333a8(%rip), %rsi     # 0x7faa0
movl $0xb, %edx
movq %rbx, %rdi
callq 0x40b80
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40bb0
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3338c(%rip), %rsi     # 0x7faac
leaq 0x3338c(%rip), %rdx     # 0x7fab3
leaq 0x10(%rsp), %rdi
callq 0x3f8a0
movq 0x70(%r14), %r14
leaq 0xf(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rdi
callq 0x40b80
leaq 0x34ff5(%rip), %rsi     # 0x81758
movl $0x2, %edx
movq %rax, %rdi
callq 0x40b80
movq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x3f3d0
leaq 0x34e64(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x4c7a7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40870
leaq 0x34067(%rip), %rsi     # 0x80815
movl $0x3, %edx
movq %rbx, %rdi
callq 0x40b80
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x4c7df
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::getSpaceByName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
AddrSpace *AddrSpaceManager::getSpaceByName(const string &nm) const

{
  map<string,AddrSpace *>::const_iterator iter = name2Space.find(nm);
  if (iter == name2Space.end())
    return (AddrSpace *)0;
  return (*iter).second;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x38, %rdi
callq 0x41ec0
addq $0x40, %rbx
cmpq %rbx, %rax
je 0x4c8b4
movq 0x40(%rax), %rax
jmp 0x4c8b6
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: JoinRecord::operator<(JoinRecord const&) const
bool JoinRecord::operator<(const JoinRecord &op2) const

{
  // Some joins may have same piece but different unified size  (floating point)
  if (unified.size != op2.unified.size) // Compare size first
    return (unified.size < op2.unified.size);
  // Lexigraphic sort on pieces
  int4 i=0;
  for(;;) {
    if (pieces.size()==i) {
      return (op2.pieces.size()>i); // If more pieces in op2, it is bigger (return true), if same number this==op2, return false
    }
    if (op2.pieces.size()==i) return false; // More pieces in -this-, so it is bigger, return false
    if (pieces[i] != op2.pieces[i])
      return (pieces[i] < op2.pieces[i]);
    i += 1;
  }
}

// Assembly:
movl 0x28(%rsi), %eax
cmpl %eax, 0x28(%rdi)
jne 0x4c935
pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rdx
movq 0x8(%rdi), %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
subq %rdx, %rax
je 0x4c939
sarq $0x3, %rax
imulq %rcx, %rax
movq (%rsi), %rdi
movq 0x8(%rsi), %r9
subq %rdi, %r9
sarq $0x3, %r9
imulq %rcx, %r9
movl $0x10, %r8d
xorl %r10d, %r10d
cmpq %r10, %r9
je 0x4c963
movq -0x10(%rdx,%r8), %r11
movq -0x10(%rdi,%r8), %rbx
cmpq %rbx, %r11
jne 0x4c957
movq -0x8(%rdx,%r8), %r14
cmpq -0x8(%rdi,%r8), %r14
jne 0x4c952
movl (%rdx,%r8), %ebp
cmpl (%rdi,%r8), %ebp
jne 0x4c952
incq %r10
addq $0x18, %r8
cmpq %r10, %rax
jne 0x4c8fd
jmp 0x4c93b
setb %al
retq
xorl %eax, %eax
movq 0x8(%rsi), %rdx
subq (%rsi), %rdx
sarq $0x3, %rdx
imulq %rcx, %rdx
cmpq %rax, %rdx
seta %al
jmp 0x4c980
cmpq %rbx, %r11
je 0x4c967
movl 0x60(%r11), %eax
cmpl 0x60(%rbx), %eax
setl %al
jmp 0x4c980
xorl %eax, %eax
jmp 0x4c980
movq -0x8(%rdi,%r8), %rax
cmpq %rax, -0x8(%rdx,%r8)
jne 0x4c97d
movl (%rdx,%r8), %eax
cmpl (%rdi,%r8), %eax
jmp 0x4c94d
setb %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: Translate::Translate()
AddrSpaceManager::AddrSpaceManager(void)

{
  defaultspace = (AddrSpace *)0;
  constantspace = (AddrSpace *)0;
  iopspace = (AddrSpace *)0;
  fspecspace = (AddrSpace *)0;
  joinspace = (AddrSpace *)0;
  stackspace = (AddrSpace *)0;
  uniqspace = (AddrSpace *)0;
  joinallocate = 0;
}

// Assembly:
movq 0x54ce7(%rip), %rax     # 0xa2fb0
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x40(%rdi), %rcx
xorl %eax, %eax
movl %eax, 0x40(%rdi)
movq %rax, 0x48(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movq %rcx, 0x50(%rdi)
movq %rcx, 0x58(%rdi)
movq %rax, 0x60(%rdi)
leaq 0x70(%rdi), %rcx
movl %eax, 0x70(%rdi)
movq %rax, 0x78(%rdi)
movq %rcx, 0x80(%rdi)
movq %rcx, 0x88(%rdi)
movq %rax, 0x90(%rdi)
leaq 0xe0(%rdi), %rcx
movl %eax, 0xe0(%rdi)
movq %rax, 0xe8(%rdi)
movq %rcx, 0xf0(%rdi)
movq %rcx, 0xf8(%rdi)
movups %xmm0, 0xc8(%rdi)
movups %xmm0, 0xb8(%rdi)
movups %xmm0, 0xa8(%rdi)
movups %xmm0, 0x98(%rdi)
movups %xmm0, 0x110(%rdi)
movups %xmm0, 0x100(%rdi)
movq 0x54c6d(%rip), %rcx     # 0xa2fd8
addq $0x10, %rcx
movq %rcx, (%rdi)
movq %rax, 0x140(%rdi)
movups %xmm0, 0x130(%rdi)
movb $0x0, 0x120(%rdi)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x124(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::restoreXmlSpace(Element const*, Translate const*)
AddrSpace *AddrSpaceManager::restoreXmlSpace(const Element *el,const Translate *trans)

{
  AddrSpace *res;
  const string &tp(el->getName());
  if (tp == "space_base")
    res = new SpacebaseSpace(this,trans);
  else if (tp == "space_unique")
    res = new UniqueSpace(this,trans);
  else if (tp == "space_other")
    res = new OtherSpace(this,trans);
  else if (tp == "space_overlay")
    res = new OverlaySpace(this,trans);
  else
    res = new AddrSpace(this,trans,IPTR_PROCESSOR);

  res->restoreXml(el);
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x3305f(%rip), %rsi     # 0x7faa1
movq %rbx, %rdi
callq 0x3f590
testl %eax, %eax
je 0x4caa9
leaq 0x32d99(%rip), %rsi     # 0x7f7ee
movq %rbx, %rdi
callq 0x3f590
testl %eax, %eax
je 0x4cac6
leaq 0x32d79(%rip), %rsi     # 0x7f7e1
movq %rbx, %rdi
callq 0x3f590
testl %eax, %eax
je 0x4cae3
leaq 0x32e64(%rip), %rsi     # 0x7f8df
movq %rbx, %rdi
callq 0x3f590
testl %eax, %eax
je 0x4cb00
movl $0x70, %edi
callq 0x40800
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x3f680
jmp 0x4cb1b
movl $0xb0, %edi
callq 0x40800
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x41b10
jmp 0x4cb1b
movl $0x70, %edi
callq 0x40800
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3fff0
jmp 0x4cb1b
movl $0x70, %edi
callq 0x40800
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3ff20
jmp 0x4cb1b
movl $0x78, %edi
callq 0x40800
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x416f0
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x68(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x78, %esi
jmp 0x4cb56
jmp 0x4cb44
jmp 0x4cb44
movq %rax, %rbx
movl $0x70, %esi
jmp 0x4cb56
movq %rax, %rbx
movl $0xb0, %esi
movq %r14, %rdi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::setDefaultSpace(int)
void AddrSpaceManager::setDefaultSpace(int4 index)

{
  if (defaultspace != (AddrSpace *)0)
    throw LowlevelError("Default space set multiple times");
  if (baselist.size()<=index || baselist[index] == (AddrSpace *)0)
    throw LowlevelError("Bad index for default space");
  defaultspace = baselist[index];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpq $0x0, 0xa0(%rdi)
jne 0x4d4ae
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movslq %esi, %rcx
cmpq %rcx, %rdx
jbe 0x4d456
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0x4d456
movq %rax, 0xa0(%rdi)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x32694(%rip), %rsi     # 0x7fb07
leaq 0x326a8(%rip), %rdx     # 0x7fb22
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x55a0b(%rip), %rsi     # 0xa2ea8
movq 0x55794(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d60
jmp 0x4d504
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3261b(%rip), %rsi     # 0x7fae6
leaq 0x32634(%rip), %rdx     # 0x7fb06
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x559b3(%rip), %rsi     # 0xa2ea8
movq 0x5573c(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d60
jmp 0x4d508
jmp 0x4d524
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4d52a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
jmp 0x4d52a
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x4d537
movq %rbx, %rdi
callq 0x40080
movq %r14, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::assignShortcut(AddrSpace*)
void AddrSpaceManager::assignShortcut(AddrSpace *spc)

{
  if (spc->shortcut != ' ') {	// If the shortcut is already assigned
    shortcut2Space.insert(pair<int4,AddrSpace *>(spc->shortcut,spc));
    return;
  }
  char shortcut;
  switch(spc->getType()) {
  case IPTR_CONSTANT:
    shortcut = '#';
    break;
  case IPTR_PROCESSOR:
    if (spc->getName() == "register")
      shortcut = '%';
    else
      shortcut = spc->getName()[0];
    break;
  case IPTR_SPACEBASE:
    shortcut = 's';
    break;
  case IPTR_INTERNAL:
    shortcut = 'u';
    break;
  case IPTR_FSPEC:
    shortcut = 'f';
    break;
  case IPTR_JOIN:
    shortcut = 'j';
    break;
  case IPTR_IOP:
    shortcut = 'i';
    break;
  default:
    shortcut = 'x';
    break;
  }

  if (shortcut >= 'A' && shortcut <= 'Z')
    shortcut += 0x20;

  int4 collisionCount = 0;
  while(!shortcut2Space.insert(pair<int4,AddrSpace *>(shortcut,spc)).second) {
    collisionCount += 1;
    if (collisionCount >26) {
      // Could not find a unique shortcut, but we just re-use 'z' as we
      // can always use the long form to specify the address if there are really so many
      // spaces that need to be distinguishable (in the console mode)
      spc->shortcut = 'z';
      return;
    }
    shortcut += 1;
    if (shortcut < 'a' || shortcut > 'z')
      shortcut = 'a';
  }
  spc->shortcut = (char)shortcut;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsbl 0x30(%rsi), %eax
cmpl $0x20, %eax
jne 0x4d580
movl 0x8(%rbx), %eax
cmpq $0x6, %rax
ja 0x4d5a8
leaq 0x3246d(%rip), %rcx     # 0x7f9e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x23, %al
jmp 0x4d5d4
addq $0x68, %r14
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movq %rbx, 0x8(%rsi)
movq %r14, %rdi
callq 0x41d80
jmp 0x4d657
movb $0x66, %al
jmp 0x4d5d4
movb $0x73, %al
jmp 0x4d5d4
movb $0x75, %al
jmp 0x4d5d4
movb $0x78, %al
jmp 0x4d5d4
leaq 0x38(%rbx), %r15
leaq 0x32395(%rip), %rsi     # 0x7f94c
movq %r15, %rdi
callq 0x3f590
testl %eax, %eax
je 0x4d5d2
movq (%r15), %rax
movb (%rax), %al
jmp 0x4d5d4
movb $0x69, %al
jmp 0x4d5d4
movb $0x6a, %al
jmp 0x4d5d4
movb $0x25, %al
leal -0x41(%rax), %ecx
movzbl %al, %edx
orb $0x20, %al
cmpb $0x1a, %cl
movzbl %al, %r12d
cmovael %edx, %r12d
addq $0x68, %r14
movsbl %r12b, %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movq %rbx, 0x8(%rsi)
movq %r14, %rdi
callq 0x41d80
testb $0x1, %dl
jne 0x4d64d
movl $0x1b, %ebp
movl $0x61, %r13d
leaq 0x8(%rsp), %r15
decl %ebp
je 0x4d653
leal 0x1(%r12), %eax
addb $-0x7a, %r12b
cmpb $-0x1a, %r12b
movzbl %al, %r12d
cmovbl %r13d, %r12d
movsbl %r12b, %eax
movl %eax, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x41d80
testb $0x1, %dl
je 0x4d617
movb %r12b, 0x30(%rbx)
jmp 0x4d657
movb $0x7a, 0x30(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::copySpaces(AddrSpaceManager const*)
void AddrSpaceManager::copySpaces(const AddrSpaceManager *op2)

{ // Insert every space in -op2- into -this- manager
  for(int4 i=0;i<op2->baselist.size();++i) {
    AddrSpace *spc = op2->baselist[i];
    if (spc != (AddrSpace *)0)
      insertSpace(spc);
  }
  setDefaultSpace(op2->getDefaultSpace()->getIndex());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
cmpq %rax, 0x10(%rsi)
je 0x4d6a6
xorl %r15d, %r15d
movq (%rax,%r15,8), %rsi
testq %rsi, %rsi
je 0x4d68f
movq %rbx, %rdi
callq 0x3faa0
incq %r15
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
ja 0x4d67e
movq 0xa0(%r14), %rax
movl 0x60(%rax), %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x42460
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::insertResolver(AddrSpace*, AddressResolver*)
void AddrSpaceManager::insertResolver(AddrSpace *spc,AddressResolver *rsolv)

{
  int4 ind = spc->getIndex();
  while(resolvelist.size() <= ind)
    resolvelist.push_back((AddressResolver *)0);
  if (resolvelist[ind] != (AddressResolver *)0)
    delete resolvelist[ind];
  resolvelist[ind] = rsolv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movslq 0x60(%rsi), %r13
leaq 0x20(%rdi), %r14
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
ja 0x4d72a
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq $0x0, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x3f4c0
movq 0x20(%r15), %rax
movq 0x28(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jbe 0x4d702
movq (%rax,%r13,8), %rdi
testq %rdi, %rdi
je 0x4d739
movq (%rdi), %rax
callq *0x8(%rax)
movq (%r14), %rax
movq %rbx, (%rax,%r13,8)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::~AddrSpaceManager()
AddrSpaceManager::~AddrSpaceManager(void)

{
  for(vector<AddrSpace *>::iterator iter=baselist.begin();iter!=baselist.end();++iter) {
    AddrSpace *spc = *iter;
    if (spc == (AddrSpace *)0) continue;
    if (spc->refcount > 1)
      spc->refcount -= 1;
    else
      delete spc;
  }
  for(int4 i=0;i<resolvelist.size();++i) {
    if (resolvelist[i] != (AddressResolver *)0)
      delete resolvelist[i];
  }
  for(int4 i=0;i<splitlist.size();++i)
    delete splitlist[i];	// Delete any join records
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x55853(%rip), %rax     # 0xa2fb0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %r14
cmpq 0x10(%rdi), %r14
je 0x4d795
movq (%r14), %rdi
testq %rdi, %rdi
je 0x4d78b
movl 0x20(%rdi), %eax
cmpl $0x2, %eax
jl 0x4d785
decl %eax
movl %eax, 0x20(%rdi)
jmp 0x4d78b
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
cmpq 0x10(%rbx), %r14
jne 0x4d76e
movq 0x20(%rbx), %rax
cmpq %rax, 0x28(%rbx)
je 0x4d7c8
xorl %r14d, %r14d
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x4d7b1
movq (%rdi), %rax
callq *0x8(%rax)
incq %r14
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
ja 0x4d7a2
movq 0x108(%rbx), %rdi
cmpq %rdi, 0x110(%rbx)
je 0x4d822
xorl %r15d, %r15d
movq (%rdi,%r15,8), %r14
testq %r14, %r14
je 0x4d805
movq (%r14), %rdi
testq %rdi, %rdi
je 0x4d7f8
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x40870
movl $0x30, %esi
movq %r14, %rdi
callq 0x40870
incq %r15
movq 0x108(%rbx), %rdi
movq 0x110(%rbx), %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %r15, %rax
ja 0x4d7db
testq %rdi, %rdi
je 0x4d836
movq 0x118(%rbx), %rsi
subq %rdi, %rsi
callq 0x40870
leaq 0xd8(%rbx), %rdi
callq 0x41d40
leaq 0x68(%rbx), %rdi
callq 0x3f130
leaq 0x38(%rbx), %rdi
callq 0x40a60
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x4d869
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x40870
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x4d883
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x40870
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::resolveConstant(AddrSpace*, unsigned long, int, Address const&, unsigned long&) const
Address AddrSpaceManager::resolveConstant(AddrSpace *spc,uintb val,int4 sz,const Address &point,uintb &fullEncoding) const

{
  int4 ind = spc->getIndex();
  if (ind < resolvelist.size()) {
    AddressResolver *resolve = resolvelist[ind];
    if (resolve != (AddressResolver *)0)
      return resolve->resolve(val,sz,point,fullEncoding);
  }
  fullEncoding = val;
  val = AddrSpace::addressToByte(val,spc->getWordSize());
  val = spc->wrapOffset(val);
  return Address(spc,val);
}

// Assembly:
pushq %rbx
movq %rdx, %r10
movq %rdi, %rbx
movq 0x10(%rsp), %rax
movslq 0x60(%rdx), %rdx
movq 0x20(%rsi), %rdi
movq 0x28(%rsi), %rsi
subq %rdi, %rsi
sarq $0x3, %rsi
cmpq %rdx, %rsi
jbe 0x4d92f
movq (%rdi,%rdx,8), %rsi
testq %rsi, %rsi
je 0x4d92f
movq (%rsi), %r10
movq %rbx, %rdi
movq %rcx, %rdx
movl %r8d, %ecx
movq %r9, %r8
movq %rax, %r9
callq *0x10(%r10)
jmp 0x4d95f
movq %rcx, (%rax)
movl 0x5c(%r10), %eax
imulq %rcx, %rax
movq 0x28(%r10), %rcx
cmpq %rax, %rcx
jae 0x4d958
incq %rcx
cqto
idivq %rcx
movq %rdx, %rax
sarq $0x3f, %rax
andq %rcx, %rax
addq %rdx, %rax
movq %r10, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::getNextSpaceInOrder(AddrSpace*) const
AddrSpace *AddrSpaceManager::getNextSpaceInOrder(AddrSpace *spc) const
{
  if (spc == (AddrSpace *)0) {
    return baselist[0];
  }
  if (spc == (AddrSpace *) ~((uintp)0)) {
    return (AddrSpace *)0;
  }
  int4 index = spc->getIndex() + 1;
  while (index < baselist.size()) {
    AddrSpace *res = baselist[index];
    if (res != (AddrSpace *)0)
      return res;
    index += 1;
  }
  return (AddrSpace *) ~((uintp)0);
}

// Assembly:
cmpq $-0x1, %rsi
je 0x4d977
testq %rsi, %rsi
jne 0x4d97a
movq 0x8(%rdi), %rax
movq (%rax), %rax
retq
xorl %eax, %eax
retq
movl 0x60(%rsi), %eax
incl %eax
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
movslq %eax, %rsi
cmpq %rsi, %rdx
jbe 0x4d9a7
movq (%rcx,%rsi,8), %rdi
incq %rsi
testq %rdi, %rdi
cmovneq %rdi, %rax
je 0x4d991
retq
movq $-0x1, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::truncateSpace(TruncationTag const&)
void AddrSpaceManager::truncateSpace(const TruncationTag &tag)

{
  AddrSpace *spc = getSpaceByName(tag.getName());
  if (spc == (AddrSpace *)0)
    throw LowlevelError("Unknown space in <truncate_space> command: "+tag.getName());
  spc->truncateSpace(tag.getSize());
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x38, %rdi
callq 0x41ec0
addq $0x40, %rbx
cmpq %rbx, %rax
je 0x4de44
movq 0x40(%rax), %rdi
jmp 0x4de46
xorl %edi, %edi
testq %rdi, %rdi
je 0x4de5c
movl 0x20(%r14), %esi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x41430
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x31e3d(%rip), %rsi     # 0x7fcad
movq %rsp, %rdi
movq %r14, %rdx
callq 0x40500
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x55016(%rip), %rsi     # 0xa2ea8
movq 0x54d9f(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d60
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4dec7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40870
jmp 0x4dec7
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x4ded4
movq %rbx, %rdi
callq 0x40080
movq %r14, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::constructFloatExtensionAddress(Address const&, int, int)
Address AddrSpaceManager::constructFloatExtensionAddress(const Address &realaddr,int4 realsize,
							 int4 logicalsize)
{
  if (logicalsize == realsize)
    return realaddr;
  vector<VarnodeData> pieces;
  pieces.push_back(VarnodeData());
  pieces.back().space = realaddr.getSpace();
  pieces.back().offset = realaddr.getOffset();
  pieces.back().size = realsize;

  JoinRecord *join = findAddJoin(pieces,logicalsize);
  return join->getUnified().getAddr();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r12
movq %rdi, %rbx
cmpl %ecx, %r8d
jne 0x4df08
movq (%r12), %rax
movq %rax, (%rbx)
movq 0x8(%r12), %rax
movq %rax, 0x8(%rbx)
jmp 0x4df9a
movl %r8d, %ebp
movl %ecx, %r15d
movq %rsi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq %rax, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x4df46
movups %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
addq $0x18, 0x8(%rsp)
jmp 0x4df53
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x41460
movq (%r12), %rax
movq %rsp, %rsi
movq 0x8(%rsi), %rcx
movq %rax, -0x18(%rcx)
movq 0x8(%r12), %rax
movq 0x8(%rsi), %rcx
movq %rax, -0x10(%rcx)
movl %r15d, -0x8(%rcx)
movq %r14, %rdi
movl %ebp, %edx
callq 0x410a0
movups 0x18(%rax), %xmm0
movups %xmm0, (%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4df9a
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x40870
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4dfac
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4dfc5
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: PcodeEmit::unpackOffset(unsigned char const*, unsigned long&)
const uint1 *PcodeEmit::unpackOffset(const uint1 *ptr,uintb &off)

{
  uintb res = 0;
  int4 shift;
  for(shift=0;shift<67;shift+=6) {
    uint1 val = *ptr++;
    if (val == end_tag) {
      off = res;
      return ptr;
    }
    uintb bits = ((uintb)(val-0x20))<<shift;
    res |= bits;
  }
  throw LowlevelError("Bad packed offset");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
incq %rdi
movq $-0x6, %rcx
xorl %edx, %edx
addq $0x6, %rcx
movzbl -0x1(%rdi), %r8d
cmpq $0x60, %r8
jne 0x4e77b
movq %rdx, (%rsi)
movq %rdi, %rax
jmp 0x4e785
leaq -0x20(%r8), %r9
shlq %cl, %r9
orq %r9, %rdx
cmpl $0x60, %r8d
je 0x4e7ea
incq %rdi
cmpq $0x3c, %rcx
jbe 0x4e764
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x31562(%rip), %rsi     # 0x7fd13
leaq 0x3156c(%rip), %rdx     # 0x7fd24
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x546cd(%rip), %rsi     # 0xa2ea8
movq 0x54456(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d60
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4e817
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
jmp 0x4e817
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x4e824
movq %rbx, %rdi
callq 0x40080
movq %r14, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: PcodeEmit::unpackVarnodeData(unsigned char const*, VarnodeData&, AddrSpaceManager const*)
const uint1 *PcodeEmit::unpackVarnodeData(const uint1 *ptr,VarnodeData &v,const AddrSpaceManager *manage)

{
  uint1 tag = *ptr++;
  if (tag == addrsz_tag) {
    int4 spcindex = (int4)(*ptr++ - 0x20);
    v.space = manage->getSpace(spcindex);
    ptr = unpackOffset(ptr,v.offset);
    v.size = (uint4)(*ptr++ - 0x20);
  }
  else if (tag == spaceid_tag) {
    v.space = manage->getConstantSpace();
    int4 spcindex = (int4)(*ptr++ - 0x20);
    v.offset = (uintb)(uintp)manage->getSpace( spcindex );
    v.size = sizeof(void *);
  }
  else
    throw LowlevelError("Bad packed VarnodeData");
  return ptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movzbl (%rdi), %eax
cmpl $0x24, %eax
je 0x4e874
cmpl $0x25, %eax
jne 0x4e8ac
movzbl 0x1(%rdi), %eax
addq $0x2, %rdi
movq 0x8(%rdx), %rcx
movq -0x100(%rcx,%rax,8), %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rsi
callq 0x40810
movq %rax, %rdi
movzbl (%rax), %eax
incq %rdi
addl $-0x20, %eax
jmp 0x4e89b
movq 0x98(%rdx), %rax
movq %rax, (%rbx)
movzbl 0x1(%rdi), %eax
addq $0x2, %rdi
movq 0x8(%rdx), %rcx
movq -0x100(%rcx,%rax,8), %rax
movq %rax, 0x8(%rbx)
movl $0x8, %eax
movl %eax, 0x10(%rbx)
movq %rdi, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3145c(%rip), %rsi     # 0x7fd25
leaq 0x3146b(%rip), %rdx     # 0x7fd3b
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x545b5(%rip), %rsi     # 0xa2ea8
movq 0x5433e(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d60
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4e924
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
jmp 0x4e924
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x4e931
movq %rbx, %rdi
callq 0x40080
movq %r14, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: PcodeEmit::restorePackedOp(Address const&, unsigned char const*, AddrSpaceManager const*)
const uint1 *PcodeEmit::restorePackedOp(const Address &addr,const uint1 *ptr,const AddrSpaceManager *manage)

{
  int4 opcode;
  VarnodeData outvar;
  VarnodeData invar[30];
  VarnodeData *outptr;

  ptr += 1;			// Consume the -op- tag
  opcode = (int4)(*ptr++ - 0x20);	// Opcode
  if (*ptr == void_tag) {
    ptr += 1;
    outptr = (VarnodeData *)0;
  }
  else {
    ptr = unpackVarnodeData(ptr,outvar,manage);
    outptr = &outvar;
  }
  int4 isize = 0;
  while(*ptr != end_tag) {
    ptr = unpackVarnodeData(ptr,invar[isize],manage);
    isize += 1;
  }
  ptr += 1;			// Consume the end tag
  dump(addr,(OpCode)opcode,outptr,invar,isize);
  return ptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x308, %rsp            # imm = 0x308
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
movzbl 0x1(%rdx), %ebp
cmpb $0x23, 0x2(%rdx)
jne 0x4e972
addq $0x3, %r15
movq $0x0, 0x8(%rsp)
jmp 0x4e98e
addq $0x2, %r15
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
movq %rsi, 0x8(%rsp)
movq %r13, %rdx
callq 0x412a0
movq %rax, %r15
xorl %ebx, %ebx
cmpb $0x60, (%r15)
je 0x4e9b9
leaq 0x30(%rsp), %r12
xorl %ebx, %ebx
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x412a0
movq %rax, %r15
addq $0x18, %r12
incl %ebx
cmpb $0x60, (%rax)
jne 0x4e99d
addl $-0x20, %ebp
incq %r15
movq (%r14), %rax
leaq 0x30(%rsp), %r8
movq %r14, %rdi
movq 0x10(%rsp), %rsi
movl %ebp, %edx
movq 0x8(%rsp), %rcx
movl %ebx, %r9d
callq *0x10(%rax)
movq %r15, %rax
addq $0x308, %rsp            # imm = 0x308
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/context.cc
// Function: ParserContext::ParserContext(ContextCache*)
ParserContext::ParserContext(ContextCache *ccache)

{
  parsestate = 0;
  contcache = ccache;
  if (ccache != (ContextCache *)0) {
    contextsize = ccache->getDatabase()->getContextSize();
    context = new uintm[ contextsize ];
  }
  else {
    contextsize = 0;
    context = (uintm *)0;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x60(%rdi)
movq %rax, 0x70(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rdi)
movq %rax, 0x90(%rdi)
movl $0x0, (%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movq %rsi, 0x30(%rdi)
testq %rsi, %rsi
je 0x4fb66
leaq 0x38(%rbx), %r12
leaq 0x80(%rbx), %r14
movq (%rsi), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, 0x28(%rbx)
cltq
leaq (,%rax,4), %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x3f060
jmp 0x4fb6f
movl $0x0, 0x28(%rbx)
xorl %eax, %eax
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x3fc10
movq (%r12), %rdi
testq %rdi, %rdi
je 0x4fb9f
movq 0x48(%rbx), %rsi
subq %rdi, %rsi
callq 0x40870
movq %r15, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/context.cc
// Function: ParserContext::initialize(int, int, AddrSpace*)
void ParserContext::initialize(int4 maxstate,int4 maxparam,AddrSpace *spc)

{
  const_space = spc;
  state.resize(maxstate);
  state[0].parent = (ConstructState *)0;
  for(int4 i=0;i<maxstate;++i)
    state[i].resolve.resize(maxparam);
  base_state = &state[0];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %rbx
movq %rcx, 0x8(%rdi)
leaq 0x80(%rdi), %r14
movslq %esi, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x41350
movq 0x80(%rbx), %rax
movq $0x0, 0x58(%rax)
testl %r12d, %r12d
jle 0x4fc10
movslq %r15d, %r15
movl %ebp, %eax
imulq $0x68, %rax, %r12
xorl %r13d, %r13d
movq (%r14), %rax
leaq (%rax,%r13), %rdi
addq $0x40, %rdi
movq %r15, %rsi
callq 0x40560
addq $0x68, %r13
cmpq %r13, %r12
jne 0x4fbf4
movq 0x80(%rbx), %rax
movq %rax, 0x98(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/context.cc
// Function: ParserContext::getInstructionBytes(int, int, unsigned int) const
uintm ParserContext::getInstructionBytes(int4 bytestart,int4 size,uint4 off) const

{				// Get bytes from the instruction stream into a intm
				// (assuming big endian format)
  off += bytestart;
  if (off >=16)
    throw BadDataError("Instruction is using more than 16 bytes"); 
  const uint1 *ptr = buf + off;
  uintm res = 0;
  for(int4 i=0;i<size;++i) {
    res <<= 8;
    res |= ptr[i];
  }
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
addl %ecx, %esi
cmpl $0x10, %esi
jae 0x4fc75
testl %edx, %edx
jle 0x4fc68
movl %esi, %eax
leaq (%rdi,%rax), %rcx
addq $0x10, %rcx
movl %edx, %edx
xorl %esi, %esi
xorl %edi, %edi
shll $0x8, %edi
movzbl (%rcx,%rsi), %eax
orl %edi, %eax
incq %rsi
movl %eax, %edi
cmpq %rsi, %rdx
jne 0x4fc53
jmp 0x4fc6a
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x300cc(%rip), %rsi     # 0x7fd5e
leaq 0x300ec(%rip), %rdx     # 0x7fd85
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x52e94(%rip), %rsi     # 0xa2b50
movq 0x52f75(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d60
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4fced
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
jmp 0x4fced
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x4fcfa
movq %rbx, %rdi
callq 0x40080
movq %r14, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/context.cc
// Function: ParserContext::getInstructionBits(int, int, unsigned int) const
uintm ParserContext::getInstructionBits(int4 startbit,int4 size,uint4 off) const

{
  off += (startbit/8);
  if (off >= 16)
    throw BadDataError("Instruction is using more than 16 bytes");
  const uint1 *ptr = buf + off;
  startbit = startbit % 8;
  int4 bytesize = (startbit+size-1)/8 + 1;
  uintm res = 0;
  for(int4 i=0;i<bytesize;++i) {
    res <<= 8;
    res |= ptr[i];
  }
  res <<= 8*(sizeof(uintm)-bytesize)+startbit; // Move starting bit to highest position
  res >>= 8*sizeof(uintm)-size;	// Shift to bottom of intm
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
leal 0x7(%rsi), %eax
testl %esi, %esi
cmovnsl %esi, %eax
movl %eax, %r8d
sarl $0x3, %r8d
addl %ecx, %r8d
cmpl $0x10, %r8d
jae 0x4fd91
andl $-0x8, %eax
subl %eax, %esi
leal (%rdx,%rsi), %r9d
decl %r9d
leal (%rdx,%rsi), %ecx
addl $0x6, %ecx
testl %r9d, %r9d
cmovnsl %r9d, %ecx
sarl $0x3, %ecx
xorl %eax, %eax
cmpl $-0x7, %r9d
jl 0x4fd73
movl %r8d, %eax
addq %rax, %rdi
addq $0x10, %rdi
leal 0x1(%rcx), %r8d
xorl %r9d, %r9d
xorl %r10d, %r10d
shll $0x8, %r10d
movzbl (%rdi,%r9), %eax
orl %r10d, %eax
incq %r9
movl %eax, %r10d
cmpq %r9, %r8
jne 0x4fd5c
shll $0x3, %ecx
subl %ecx, %esi
addb $0x18, %sil
movl %esi, %ecx
shll %cl, %eax
negb %dl
movl %edx, %ecx
shrl %cl, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2ffb0(%rip), %rsi     # 0x7fd5e
leaq 0x2ffd0(%rip), %rdx     # 0x7fd85
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x52d78(%rip), %rsi     # 0xa2b50
movq 0x52e59(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d60
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4fe09
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
jmp 0x4fe09
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x4fe16
movq %rbx, %rdi
callq 0x40080
movq %r14, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/context.cc
// Function: ParserContext::getContextBytes(int, int) const
uintm ParserContext::getContextBytes(int4 bytestart,int4 size) const

{				// Get bytes from context into a uintm
  int4 intstart = bytestart / sizeof(uintm);
  uintm res = context[ intstart ];
  int4 byteOffset = bytestart % sizeof(uintm);
  int4 unusedBytes = sizeof(uintm) - size;
  res <<= byteOffset*8;
  res >>= unusedBytes*8;
  int4 remaining = size - sizeof(uintm) + byteOffset;
  if ((remaining > 0)&&(++intstart < contextsize)) { // If we extend beyond boundary of a single uintm
    uintm res2 = context[ intstart ];
    unusedBytes = sizeof(uintm) - remaining;
    res2 >>= unusedBytes * 8;
    res |= res2;
  }
  return res;
}

// Assembly:
movl %esi, %r8d
sarl $0x2, %r8d
movq 0x20(%rdi), %r9
movslq %r8d, %rax
movl (%r9,%rax,4), %eax
andl $0x3, %esi
leal (,%rsi,8), %ecx
shll %cl, %eax
leal (,%rdx,8), %ecx
negb %cl
shrl %cl, %eax
leal (%rdx,%rsi), %ecx
addl $-0x4, %ecx
testl %ecx, %ecx
jle 0x4fe6a
incl %r8d
cmpl 0x28(%rdi), %r8d
jge 0x4fe6a
movslq %r8d, %rdx
movl (%r9,%rdx,4), %edx
shll $0x3, %ecx
negb %cl
shrl %cl, %edx
orl %edx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/context.cc
// Function: ParserContext::getContextBits(int, int) const
uintm ParserContext::getContextBits(int4 startbit,int4 size) const

{
  int4 intstart = startbit / (8*sizeof(uintm));
  uintm res = context[ intstart ]; // Get intm containing highest bit
  int4 bitOffset = startbit % (8*sizeof(uintm));
  int4 unusedBits = 8*sizeof(uintm) - size;
  res <<= bitOffset;	// Shift startbit to highest position
  res >>= unusedBits;
  int4 remaining = size - 8*sizeof(uintm) + bitOffset;
  if ((remaining > 0) && (++intstart < contextsize)) {
    uintm res2 = context[ intstart ];
    unusedBits = 8*sizeof(uintm) - remaining;
    res2 >>= unusedBits;
    res |= res2;
  }
  return res;
}

// Assembly:
movl %esi, %ecx
movl %esi, %r8d
sarl $0x5, %r8d
movq 0x20(%rdi), %r9
movslq %r8d, %rax
movl (%r9,%rax,4), %eax
andl $0x1f, %ecx
shll %cl, %eax
leal (%rdx,%rcx), %esi
addl $-0x20, %esi
movl %edx, %ecx
negb %cl
shrl %cl, %eax
testl %esi, %esi
jle 0x4feae
incl %r8d
cmpl 0x28(%rdi), %r8d
jge 0x4feae
movslq %r8d, %rcx
movl (%r9,%rcx,4), %edx
negb %sil
movl %esi, %ecx
shrl %cl, %edx
orl %edx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/context.cc
// Function: ParserContext::addCommit(TripleSymbol*, int, unsigned int, bool, ConstructState*)
void ParserContext::addCommit(TripleSymbol *sym,int4 num,uintm mask,bool flow,ConstructState *point)

{
  contextcommit.push_back(ContextSet());
  ContextSet &set(contextcommit.back());

  set.sym = sym;
  set.point = point;		// This is the current state
  set.num = num;
  set.mask = mask;
  set.value = context[num] & mask;
  set.flow = flow;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r15
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r13
movq %rdi, %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq 0x40(%rdi), %rsi
cmpq 0x48(%rdi), %rsi
je 0x4fef4
movups %xmm0, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x20, 0x40(%r12)
jmp 0x4ff01
leaq 0x38(%r12), %rdi
movq %rsp, %rdx
callq 0x410e0
movq 0x40(%r12), %rax
movq %r13, -0x20(%rax)
movq %r15, -0x18(%rax)
movl %r14d, -0x10(%rax)
movl %ebp, -0xc(%rax)
movq 0x20(%r12), %rcx
movslq %r14d, %rdx
andl (%rcx,%rdx,4), %ebp
movl %ebp, -0x8(%rax)
movb %bl, -0x4(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop