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

{
  a_v(s,"space",getName());	// Just append the proper attributes
  s << ' ' << "offset=\"";
  printOffset(s,offset);
  s << "\"";
  a_v_i(s,"size",size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x2f0f9(%rip), %rsi     # 0x86afd
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x515e0
addq $0x38, %r15
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4dd90
leaq 0x8(%rsp), %rdi
callq 0x4e020
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x4fc10
leaq 0x2ed13(%rip), %rsi     # 0x86756
movq %rax, %rdi
callq 0x4f5b0
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4ef30
leaq 0x30b5f(%rip), %rsi     # 0x885bc
movq %rbx, %rdi
callq 0x4f5b0
leaq 0x34d01(%rip), %rsi     # 0x8c76d
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x515e0
movslq %ebp, %rdx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x50e20
leaq 0x8(%rsp), %rdi
callq 0x4e020
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x57aa4
jmp 0x57ab3
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4e020
jmp 0x57ab6
movq %rax, %rbx
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/space.cc
// Function: AddrSpace::restoreXmlAttributes(Element const*, unsigned int&) const
uintb AddrSpace::restoreXmlAttributes(const Element *el,uint4 &size) const

{
  uintb offset;
  int4 num = el->getNumAttributes();
  bool foundoffset = false;
  for(int4 i=0;i<num;++i) {
    if (el->getAttributeName(i)=="offset") {
      foundoffset = true;
      istringstream s1(el->getAttributeValue(i));
      s1.unsetf(ios::dec | ios::hex | ios::oct);
      s1 >> offset;
    }
    else if (el->getAttributeName(i)=="size") {
      istringstream s2(el->getAttributeValue(i));
      s2.unsetf(ios::dec | ios::hex | ios::oct);
      s2 >> size;
    }
  }
  if (!foundoffset)
    throw LowlevelError("Address is missing offset");

  return offset;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %rbx
movq 0x48(%rsi), %r13
subq 0x40(%rsi), %r13
shrq $0x5, %r13
xorl %r14d, %r14d
testl %r13d, %r13d
cmovlel %r14d, %r13d
movq %rdx, 0x8(%rsp)
shlq $0x5, %r13
leaq 0x2f206(%rip), %r15     # 0x86cfe
leaq 0x18(%rsp), %r12
xorl %ebp, %ebp
cmpq %r14, %r13
je 0x57baa
movq 0x40(%rbx), %rdi
addq %r14, %rdi
movq %r15, %rsi
callq 0x520f0
testb %al, %al
je 0x57b55
movq 0x58(%rbx), %rsi
addq %r14, %rsi
movq %r12, %rdi
pushq $0x8
popq %rdx
callq 0x51500
movq 0x18(%rsp), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x30(%rsp,%rax)
movq %r12, %rdi
leaq 0x10(%rsp), %rsi
callq 0x4e460
movq %r12, %rdi
callq 0x4e070
movb $0x1, %bpl
jmp 0x57ba1
movq 0x40(%rbx), %rdi
addq %r14, %rdi
leaq 0x34c0a(%rip), %rsi     # 0x8c76d
callq 0x520f0
testb %al, %al
je 0x57ba1
movq 0x58(%rbx), %rsi
addq %r14, %rsi
movq %r12, %rdi
pushq $0x8
popq %rdx
callq 0x51500
movq 0x18(%rsp), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x30(%rsp,%rax)
movq %r12, %rdi
movq 0x8(%rsp), %rsi
callq 0x51830
movq %r12, %rdi
callq 0x4e070
addq $0x20, %r14
jmp 0x57aff
testb $0x1, %bpl
je 0x57bc7
movq 0x10(%rsp), %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
leaq 0x2eb86(%rip), %rsi     # 0x8675f
leaq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x515e0
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x5729f(%rip), %rsi     # 0xaeea0
movq 0x57030(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x57c27
jmp 0x57c40
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
jmp 0x57c40
jmp 0x57c33
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x4e070
movq %r14, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl 0x58(%rdi), %ebp
cmpl $0x5, %ebp
jl 0x57c7b
movq %r14, %rax
shrq $0x20, %rax
jne 0x57c6e
pushq $0x4
popq %rbp
jmp 0x57c7b
movq %r14, %rax
shrq $0x30, %rax
pushq $0x6
popq %rax
cmovel %eax, %ebp
leaq 0x30402(%rip), %rsi     # 0x88084
movq %rbx, %rdi
callq 0x4f5b0
pushq $0x30
popq %rsi
movq %rax, %rdi
callq 0x50ee0
movq %rax, %rdi
addl %ebp, %ebp
movq (%rax), %rax
movq -0x18(%rax), %rcx
movslq %ebp, %rdx
movq %rdx, 0x10(%rdi,%rcx)
movq -0x18(%rax), %rax
movl 0x18(%rdi,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rdi,%rax)
movl 0x5c(%r15), %ecx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rsi
callq 0x4e990
movl 0x5c(%r15), %ecx
cmpq $0x2, %rcx
jb 0x57d1e
movq %r14, %rax
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
je 0x57d1e
movq %rdx, %r14
pushq $0x2b
popq %rsi
movq %rbx, %rdi
callq 0x4fc10
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
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x51690
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %rdi
movq %rdx, %rsi
callq 0x508c0
movq %rax, %r14
movq 0x8(%rax), %rax
subq (%r14), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movq %rax, %r15
pushq $0x7b
popq %rsi
movq %rbx, %rdi
callq 0x4fc10
xorl %r12d, %r12d
testl %r15d, %r15d
movl $0x0, %eax
movq %r15, (%rsp)
cmovgl %r15d, %eax
imulq $0x18, %rax, %r13
pushq $0x2c
popq %rbp
cmpq %r12, %r13
je 0x58f6d
movq (%r14), %r15
testq %r12, %r12
je 0x58f55
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4fc10
movq (%r15,%r12), %rdi
movq 0x8(%r15,%r12), %rdx
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x50(%rax)
addq $0x18, %r12
jmp 0x58f3e
cmpl $0x1, (%rsp)
jne 0x58f8c
movl 0x28(%r14), %ebp
pushq $0x3a
popq %rsi
movq %rbx, %rdi
callq 0x4fc10
movq %rax, %rdi
movl %ebp, %esi
callq 0x51690
pushq $0x7d
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4fc10
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2d5c0(%rip), %rsi     # 0x868de
movq %rbx, %rdi
callq 0x4f5b0
leaq 0x2cd04(%rip), %rsi     # 0x86031
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x515e0
leaq 0x38(%r14), %rdx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4dd90
leaq 0x8(%rsp), %rdi
callq 0x4e020
leaq 0x2d3c8(%rip), %rsi     # 0x86726
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x515e0
movslq 0x60(%r14), %rdx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x50e20
leaq 0x8(%rsp), %rdi
callq 0x4e020
leaq 0x2d6f8(%rip), %rsi     # 0x86a87
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x515e0
movq 0x70(%r14), %rdx
addq $0x38, %rdx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4dd90
leaq 0x8(%rsp), %rdi
callq 0x4e020
leaq 0x2e431(%rip), %rsi     # 0x877f5
movq %rbx, %rdi
callq 0x4f5b0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x593dc
jmp 0x593eb
jmp 0x593dc
jmp 0x593eb
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4e020
jmp 0x593ee
movq %rax, %rbx
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2d132(%rip), %rsi     # 0x86afd
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x515e0
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x50230
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4e400
leaq 0x28(%rsp), %rdi
callq 0x4e020
leaq 0x32d6a(%rip), %rsi     # 0x8c76d
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x515e0
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x50230
leaq 0x28(%rsp), %rdi
pushq $0x8
popq %rdx
movq %rax, %rsi
callq 0x51500
leaq 0x8(%rsp), %rdi
callq 0x4e020
leaq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x40(%rsp,%rax)
addq $0x20, %rbx
movq %rbx, %rsi
callq 0x51830
leaq 0x28(%rsp), %rdi
callq 0x4e070
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4e070
jmp 0x59a98
jmp 0x59a7c
movq %rax, %rbx
jmp 0x59a98
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x59a93
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4e020
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
cmpb $0x1, 0x78(%rdi)
jne 0x59b47
leaq 0x80(%r14), %rdi
movq %r15, %rsi
callq 0x51e60
testb %al, %al
jne 0x59bab
cmpb %bpl, 0x79(%r14)
jne 0x59bab
movb $0x1, 0x78(%r14)
movb %bpl, 0x79(%r14)
movups (%r15), %xmm0
movups %xmm0, 0x98(%r14)
movq 0x10(%r15), %rax
movq %rax, 0xa8(%r14)
movups (%r15), %xmm0
movups %xmm0, 0x80(%r14)
movq 0x10(%r15), %rax
movq %rax, 0x90(%r14)
subl %ebx, %eax
je 0x59ba0
leaq 0x80(%r14), %rcx
movq (%rcx), %rcx
testb $0x1, 0x24(%rcx)
je 0x59b99
addq %rax, 0x88(%r14)
movl %ebx, 0x90(%r14)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
addq $0x38, %r14
leaq 0x2ce5f(%rip), %rsi     # 0x86a20
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x4f1c0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x552b9(%rip), %rsi     # 0xaeea0
movq 0x5504a(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x59c0d
jmp 0x59c15
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
movq %r14, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2cd1e(%rip), %rsi     # 0x86a80
movq %rbx, %rdi
callq 0x4f5b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4fb50
leaq 0x2cd10(%rip), %rsi     # 0x86a8c
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x515e0
movq 0x70(%r14), %rdx
addq $0x38, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4dd90
leaq 0x10(%rsp), %rdi
callq 0x4e020
leaq 0x2da43(%rip), %rsi     # 0x877f5
movq %rbx, %rdi
callq 0x4f5b0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4e020
movq %rbx, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x51840
addq $0x40, %rbx
cmpq %rbx, %rax
je 0x59e6e
movq 0x40(%rax), %rax
jmp 0x59e70
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x28(%rsi), %eax
cmpl %eax, 0x28(%rdi)
jne 0x59efb
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x18
popq %r12
xorl %r13d, %r13d
movq %r12, %r15
xorl %ebp, %ebp
movq (%r14), %rdi
movq 0x8(%r14), %rax
subq %rdi, %rax
cqto
idivq %r12
movq %rax, %rcx
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
cqto
idivq %r12
cmpq %rcx, %rbp
je 0x59f00
cmpq %rax, %rbp
je 0x59f08
addq %r13, %rdi
addq %r13, %rsi
callq 0x51e60
incq %rbp
addq $-0x18, %r15
addq $0x18, %r13
testb %al, %al
je 0x59e97
movq (%r14), %rdi
subq %r15, %rdi
movq (%rbx), %rsi
subq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4f540
setb %al
jmp 0x59f0a
cmpq %rbp, %rax
seta %al
jmp 0x59f0a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::AddrSpaceManager()
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 0x55087(%rip), %rax     # 0xaefa8
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x40(%rdi), %rax
andl $0x0, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movq %rax, 0x50(%rdi)
movq %rax, 0x58(%rdi)
andq $0x0, 0x60(%rdi)
leaq 0x70(%rdi), %rax
andl $0x0, 0x70(%rdi)
andq $0x0, 0x78(%rdi)
movq %rax, 0x80(%rdi)
movq %rax, 0x88(%rdi)
andq $0x0, 0x90(%rdi)
andl $0x0, 0xe0(%rdi)
leaq 0xe0(%rdi), %rax
andq $0x0, 0xe8(%rdi)
movq %rax, 0xf0(%rdi)
movq %rax, 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)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x2caa5(%rip), %rsi     # 0x86a81
movq %rbx, %rdi
callq 0x520f0
testb %al, %al
je 0x5a008
movl $0xb0, %edi
callq 0x4f5d0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x512e0
jmp 0x5a0ae
leaq 0x2c7df(%rip), %rsi     # 0x867ee
movq %rbx, %rdi
callq 0x520f0
testb %al, %al
je 0x5a036
pushq $0x70
popq %rdi
callq 0x4f5d0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x4e9c0
jmp 0x5a0ae
leaq 0x2c7a4(%rip), %rsi     # 0x867e1
movq %rbx, %rdi
callq 0x520f0
testb %al, %al
je 0x5a064
pushq $0x70
popq %rdi
callq 0x4f5d0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x4e860
jmp 0x5a0ae
leaq 0x2c874(%rip), %rsi     # 0x868df
movq %rbx, %rdi
callq 0x520f0
testb %al, %al
je 0x5a092
pushq $0x78
popq %rdi
callq 0x4f5d0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x50cf0
jmp 0x5a0ae
pushq $0x70
popq %rdi
callq 0x4f5d0
movq %rax, %r15
pushq $0x1
popq %rcx
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x4dab0
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x68(%rax)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x5a0d4
movq %rax, %rbx
pushq $0x78
jmp 0x5a0d9
jmp 0x5a0d4
movq %rax, %rbx
pushq $0x70
popq %rsi
jmp 0x5a0e4
movq %rax, %rbx
movl $0xb0, %esi
movq %r15, %rdi
callq 0x4f670
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::restoreXmlSpaces(Element const*, Translate const*)
void AddrSpaceManager::restoreXmlSpaces(const Element *el,const Translate *trans)

{
  // The first space should always be the constant space
  insertSpace(new ConstantSpace(this,trans,"const",AddrSpace::constant_space_index));

  string defname(el->getAttributeValue("defaultspace"));
  const List &list(el->getChildren());
  List::const_iterator iter;
  iter = list.begin();
  while(iter!=list.end()) {
    AddrSpace *spc = restoreXmlSpace(*iter,trans);
    insertSpace(spc);
    ++iter;
  }
  AddrSpace *spc = getSpaceByName(defname);
  if (spc == (AddrSpace *)0)
    throw LowlevelError("Bad 'defaultspace' attribute: "+defname);
  setDefaultSpace(spc->getIndex());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x70
popq %rdi
callq 0x4f5d0
movq %rax, %r12
leaq 0x2c979(%rip), %rsi     # 0x86a94
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x515e0
movb $0x1, %bpl
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %r8d, %r8d
callq 0x50b00
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4e0b0
leaq 0x10(%rsp), %rdi
callq 0x4e020
leaq 0x2c939(%rip), %rsi     # 0x86a9a
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x515e0
leaq 0x30(%rsp), %rsi
movq %r15, %rdi
callq 0x50230
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x50630
leaq 0x30(%rsp), %rdi
callq 0x4e020
movq 0x78(%r15), %r12
cmpq 0x80(%r15), %r12
je 0x5a1c1
movq (%r12), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4f130
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4e0b0
addq $0x8, %r12
jmp 0x5a198
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x519f0
testq %rax, %rax
je 0x5a1f5
movl 0x60(%rax), %esi
movq %rbx, %rdi
callq 0x52110
leaq 0x10(%rsp), %rdi
callq 0x4e020
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %r14
leaq 0x2c8a0(%rip), %rsi     # 0x86aa7
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x4f1c0
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x54c71(%rip), %rsi     # 0xaeea0
movq 0x54a02(%rip), %rdx     # 0xaec38
movq %r14, %rdi
callq 0x51630
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x5a255
jmp 0x5a297
movq %rax, %rbx
movq %r14, %rdi
callq 0x4ea60
jmp 0x5a297
movq %rax, %rbx
jmp 0x5a2a1
movq %rax, %rbx
jmp 0x5a287
jmp 0x5a294
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x5a29c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
je 0x5a2a1
pushq $0x70
popq %rsi
movq %r12, %rdi
callq 0x4f670
jmp 0x5a2a1
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4e020
movq %rbx, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
cmpq $0x0, 0xa0(%rdi)
jne 0x5a7ed
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movslq %esi, %rcx
cmpq %rcx, %rdx
jbe 0x5a7a2
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0x5a7a2
movq %rax, 0xa0(%rdi)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
leaq 0x2c333(%rip), %rsi     # 0x86ae7
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x515e0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x546c4(%rip), %rsi     # 0xaeea0
movq 0x54455(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
jmp 0x5a836
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
leaq 0x2c2c7(%rip), %rsi     # 0x86ac6
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x515e0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x54679(%rip), %rsi     # 0xaeea0
movq 0x5440a(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
jmp 0x5a83a
jmp 0x5a84e
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x5a851
jmp 0x5a859
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
movq %r14, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5a8a3
movl 0x8(%rbx), %eax
cmpq $0x6, %rax
ja 0x5a8ce
leaq 0x2c14b(%rip), %rcx     # 0x869e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x23, %r12b
jmp 0x5a910
addq $0x68, %r14
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movq %rbx, 0x8(%rsi)
movq %r14, %rdi
callq 0x51670
jmp 0x5a963
movb $0x66, %r12b
jmp 0x5a910
movb $0x73, %r12b
jmp 0x5a910
movb $0x75, %r12b
jmp 0x5a910
movb $0x78, %r12b
jmp 0x5a910
leaq 0x38(%rbx), %r15
leaq 0x2c06e(%rip), %rsi     # 0x8694c
movq %r15, %rdi
callq 0x520f0
movb $0x25, %r12b
testb %al, %al
jne 0x5a910
movq (%r15), %rax
movzbl (%rax), %eax
leal -0x41(%rax), %ecx
movl %eax, %edx
orb $0x20, %dl
cmpb $0x1a, %cl
movzbl %dl, %r12d
cmovael %eax, %r12d
jmp 0x5a910
movb $0x69, %r12b
jmp 0x5a910
movb $0x6a, %r12b
addq $0x68, %r14
pushq $0x1a
popq %rbp
leaq 0x8(%rsp), %r15
pushq $0x61
popq %r13
movsbl %r12b, %eax
movl %eax, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x51670
testb $0x1, %dl
jne 0x5a959
subl $0x1, %ebp
jb 0x5a95f
leal 0x1(%r12), %eax
addb $-0x7a, %r12b
cmpb $-0x1a, %r12b
movzbl %al, %r12d
cmovbl %r13d, %r12d
jmp 0x5a920
movb %r12b, 0x30(%rbx)
jmp 0x5a963
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_O2/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
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0x5a9aa
movq (%rax,%r15,8), %rsi
testq %rsi, %rsi
je 0x5a9a5
movq %rbx, %rdi
callq 0x4e0b0
incq %r15
jmp 0x5a980
movq 0xa0(%r14), %rax
movl 0x60(%rax), %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x52110
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %r15
movslq 0x60(%rsi), %r13
leaq 0x20(%rdi), %r14
leaq 0x8(%rsp), %r12
movq 0x20(%r15), %rax
movq 0x28(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
ja 0x5aa19
andq $0x0, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x4d7b0
jmp 0x5a9f2
movq (%rax,%r13,8), %rdi
testq %rdi, %rdi
je 0x5aa2b
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
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x54555(%rip), %rax     # 0xaefa8
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x8(%rdi), %rax
movq %rax, (%rsp)
movq 0x8(%rdi), %rbx
cmpq 0x10(%r14), %rbx
je 0x5aa8f
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5aa89
movl 0x20(%rdi), %eax
cmpl $0x2, %eax
jl 0x5aa83
decl %eax
movl %eax, 0x20(%rdi)
jmp 0x5aa89
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %rbx
jmp 0x5aa66
leaq 0x20(%r14), %r15
xorl %ebx, %ebx
movq 0x20(%r14), %rax
movq 0x28(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rbx, %rcx
jbe 0x5aabd
movq (%rax,%rbx,8), %rdi
testq %rdi, %rdi
je 0x5aab8
movq (%rdi), %rax
callq *0x8(%rax)
incq %rbx
jmp 0x5aa95
leaq 0x108(%r14), %r12
xorl %ebx, %ebx
pushq $0x30
popq %r13
movq 0x108(%r14), %rax
movq 0x110(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rbx, %rcx
jbe 0x5ab05
movq (%rax,%rbx,8), %rbp
testq %rbp, %rbp
je 0x5aaf5
movq %rbp, %rdi
callq 0x4f8c0
movq %rbp, %rdi
movq %r13, %rsi
callq 0x4f670
incq %rbx
jmp 0x5aaca
movq %r12, %rdi
callq 0x4d160
leaq 0xd8(%r14), %rdi
callq 0x51610
leaq 0x68(%r14), %rdi
callq 0x4d1a0
addq $0x38, %r14
movq %r14, %rdi
callq 0x4f950
movq %r15, %rdi
callq 0x4fbd0
movq (%rsp), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4e440
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::getSpaceByShortcut(char) const
AddrSpace *AddrSpaceManager::getSpaceByShortcut(char sc) const

{
  map<int4,AddrSpace *>::const_iterator iter;
  iter = shortcut2Space.find(sc);
  if (iter == shortcut2Space.end())
    return (AddrSpace *)0;
  return (*iter).second;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x68, %rdi
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
movq %rax, %rsi
callq 0x516e0
addq $0x70, %rbx
cmpq %rbx, %rax
je 0x5ab90
movq 0x28(%rax), %rax
jmp 0x5ab92
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5abdd
movq (%rdi,%rdx,8), %rsi
testq %rsi, %rsi
je 0x5abdd
movq (%rsi), %r10
movq %rbx, %rdi
movq %rcx, %rdx
movl %r8d, %ecx
movq %r9, %r8
movq %rax, %r9
callq *0x10(%r10)
jmp 0x5ac0d
movq %rcx, (%rax)
movl 0x5c(%r10), %eax
imulq %rcx, %rax
movq 0x28(%r10), %rcx
cmpq %rax, %rcx
jae 0x5ac06
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_O2/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 0x5ac25
testq %rsi, %rsi
jne 0x5ac28
movq 0x8(%rdi), %rax
movq (%rax), %rax
retq
xorl %eax, %eax
retq
movslq 0x60(%rsi), %rcx
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
subq %rdx, %rsi
sarq $0x3, %rsi
incq %rcx
pushq $-0x1
popq %rdi
cmpq %rcx, %rsi
jbe 0x5ac53
movq (%rdx,%rcx,8), %rax
incq %rcx
testq %rax, %rax
je 0x5ac41
retq
movq %rdi, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x519f0
testq %rax, %rax
je 0x5b01b
movl 0x20(%r14), %esi
movq %rax, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x50920
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
leaq 0x2bc60(%rip), %rsi     # 0x86c8d
movq %rsp, %rdi
movq %r14, %rdx
callq 0x4f1c0
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x53e51(%rip), %rsi     # 0xaeea0
movq 0x53be2(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
movq %rsp, %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x5b073
jmp 0x5b07b
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
movq %r14, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5b0ad
movq (%r12), %rax
movq %rax, (%rbx)
movq 0x8(%r12), %rax
movq %rax, 0x8(%rbx)
jmp 0x5b10f
movl %r8d, %ebp
movl %ecx, %r15d
movq %rsi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
callq 0x4d0e0
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 0x50400
movups 0x18(%rax), %xmm0
movups %xmm0, (%rbx)
movq %rsp, %rdi
callq 0x4f8c0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5b121
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4f8c0
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
incq %rdi
xorl %ecx, %ecx
xorl %eax, %eax
cmpq $0x42, %rcx
ja 0x5b693
movzbl -0x1(%rdi), %edx
cmpq $0x60, %rdx
je 0x5b684
addq $-0x20, %rdx
shlq %cl, %rdx
orq %rdx, %rax
addq $0x6, %rcx
incq %rdi
jmp 0x5b661
movq %rax, (%rsi)
movq %rdi, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
leaq 0x2b64e(%rip), %rsi     # 0x86cf3
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x515e0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x537d3(%rip), %rsi     # 0xaeea0
movq 0x53564(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x5b6f3
jmp 0x5b6fb
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
movq %r14, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movzbl (%rdi), %eax
cmpl $0x24, %eax
je 0x5b74a
cmpl $0x25, %eax
jne 0x5b77e
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 0x4f5f0
movq %rax, %rdi
movzbl (%rax), %eax
incq %rdi
addl $-0x20, %eax
jmp 0x5b76f
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)
pushq $0x8
popq %rax
movl %eax, 0x10(%rbx)
movq %rdi, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
leaq 0x2b575(%rip), %rsi     # 0x86d05
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x515e0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x536e8(%rip), %rsi     # 0xaeea0
movq 0x53479(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x5b7de
jmp 0x5b7e6
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
movq %r14, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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, %r12
movq %rdx, %r15
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
movzbl 0x1(%rdx), %ebp
cmpb $0x23, 0x2(%rdx)
jne 0x5b826
addq $0x3, %r15
movq $0x0, 0x8(%rsp)
jmp 0x5b842
addq $0x2, %r15
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
movq %rsi, 0x8(%rsp)
movq %r12, %rdx
callq 0x506e0
movq %rax, %r15
xorl %ebx, %ebx
leaq 0x30(%rsp), %r13
cmpb $0x60, (%r15)
je 0x5b868
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x506e0
movq %rax, %r15
incl %ebx
addq $0x18, %r13
jmp 0x5b849
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
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
andq $0x0, 0x60(%rdi)
andq $0x0, 0x70(%rdi)
xorps %xmm0, %xmm0
andq $0x0, 0x90(%rdi)
movups %xmm0, 0x80(%rdi)
andl $0x0, (%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movq %rsi, 0x30(%rdi)
testq %rsi, %rsi
je 0x5ca89
leaq 0x38(%rbx), %r14
leaq 0x80(%rbx), %r15
movq (%rsi), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, 0x28(%rbx)
movl %eax, %ecx
shlq $0x2, %rcx
testl %eax, %eax
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
callq 0x4d060
jmp 0x5ca8f
andl $0x0, 0x28(%rbx)
xorl %eax, %eax
movq %rax, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x4e3b0
movq %r14, %rdi
callq 0x4ff30
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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, %ebp
movq %rdi, %rbx
movq %rcx, 0x8(%rdi)
leaq 0x80(%rdi), %r14
movslq %esi, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x507e0
movq 0x80(%rbx), %rax
andq $0x0, 0x58(%rax)
movslq %ebp, %r15
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
imulq $0x68, %r12, %r12
movq (%r14), %rax
cmpq %r13, %r12
je 0x5cb18
leaq (%rax,%r13), %rdi
addq $0x40, %rdi
movq %r15, %rsi
callq 0x4f230
addq $0x68, %r13
jmp 0x5cafa
movq %rax, 0x98(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
addl %ecx, %esi
cmpl $0x10, %esi
jae 0x5cb6c
movl %esi, %eax
leaq (%rdi,%rax), %rcx
addq $0x10, %rcx
xorl %esi, %esi
testl %edx, %edx
cmovlel %esi, %edx
xorl %eax, %eax
cmpq %rsi, %rdx
je 0x5cb63
shll $0x8, %eax
movzbl (%rcx,%rsi), %edi
orl %edi, %eax
incq %rsi
jmp 0x5cb50
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
leaq 0x2a1c0(%rip), %rsi     # 0x86d3e
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x515e0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x51faa(%rip), %rsi     # 0xaeb50
movq 0x5208b(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x5cbcc
jmp 0x5cbd4
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
movq %r14, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movl %edx, %r8d
movl %esi, %eax
pushq $0x8
popq %r9
cltd
idivl %r9d
addl %ecx, %eax
cmpl $0x10, %eax
jae 0x5cc52
movl %edx, %esi
movl %eax, %r10d
leal (%r8,%rsi), %eax
decl %eax
cltd
idivl %r9d
testl %eax, %eax
pushq $-0x1
popq %rcx
cmovnsl %eax, %ecx
addq %r10, %rdi
addq $0x10, %rdi
incl %ecx
xorl %r9d, %r9d
xorl %edx, %edx
cmpq %r9, %rcx
je 0x5cc32
shll $0x8, %edx
movzbl (%rdi,%r9), %r10d
orl %r10d, %edx
incq %r9
jmp 0x5cc1d
shll $0x3, %eax
subl %eax, %esi
addb $0x18, %sil
movl %esi, %ecx
shll %cl, %edx
negb %r8b
movl %r8d, %ecx
shrl %cl, %edx
movl %edx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
leaq 0x2a0da(%rip), %rsi     # 0x86d3e
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x515e0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x51ec4(%rip), %rsi     # 0xaeb50
movq 0x51fa5(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x5ccb2
jmp 0x5ccba
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
movq %r14, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5cd0e
incl %r8d
cmpl 0x28(%rdi), %r8d
jge 0x5cd0e
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_O2/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, %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r13
addq $0x38, %rdi
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
callq 0x4dad0
movq 0x40(%r13), %rax
movq %r12, -0x20(%rax)
movq %rbx, -0x18(%rax)
movl %r15d, -0x10(%rax)
movl %r14d, -0xc(%rax)
movq 0x20(%r13), %rcx
movslq %r15d, %rdx
andl (%rcx,%rdx,4), %r14d
movl %r14d, -0x8(%rax)
movb %bpl, -0x4(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq