LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::parseFromNewFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void SleighCompile::parseFromNewFile(const string &fname)

{
  string base,path;
  FileManage::splitPath(fname,path,base);
  filename.push_back(base);
  if (relpath.empty() || FileManage::isAbsolutePath(path))
    relpath.push_back(path);
  else {			// Relative paths from successive includes, combine
    string totalpath = relpath.back();
    totalpath += path;
    relpath.push_back(totalpath);
  }
  lineno.push_back(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x11700
leaq -0x50(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x11700
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
movq -0x10(%rbp), %rdi
callq 0x21740
jmp 0x637c7
movq -0xa0(%rbp), %rdi
addq $0x300, %rdi            # imm = 0x300
leaq -0x30(%rbp), %rsi
callq 0x22430
jmp 0x637e0
movq -0xa0(%rbp), %rdi
addq $0x2e8, %rdi            # imm = 0x2E8
callq 0x6b990
testb $0x1, %al
jne 0x63814
leaq -0x50(%rbp), %rdi
callq 0x227a0
movb %al, -0xa1(%rbp)
jmp 0x63808
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x63814
jmp 0x63840
movq -0xa0(%rbp), %rdi
addq $0x2e8, %rdi            # imm = 0x2E8
leaq -0x50(%rbp), %rsi
callq 0x22430
jmp 0x6382d
jmp 0x638ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x638ec
movq -0xa0(%rbp), %rdi
addq $0x2e8, %rdi            # imm = 0x2E8
callq 0x224a0
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
callq 0x11200
jmp 0x63861
leaq -0x80(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x11620
jmp 0x63870
movq -0xa0(%rbp), %rdi
addq $0x2e8, %rdi            # imm = 0x2E8
leaq -0x80(%rbp), %rsi
callq 0x22430
jmp 0x63889
leaq -0x80(%rbp), %rdi
callq 0x11300
jmp 0x638ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x11300
jmp 0x638ec
movq -0xa0(%rbp), %rdi
addq $0x318, %rdi            # imm = 0x318
movl $0x1, -0x84(%rbp)
leaq -0x84(%rbp), %rsi
callq 0x6a880
jmp 0x638d1
leaq -0x50(%rbp), %rdi
callq 0x11300
leaq -0x30(%rbp), %rdi
callq 0x11300
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0x11300
leaq -0x30(%rbp), %rdi
callq 0x11300
movq -0x58(%rbp), %rdi
callq 0x118b0
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::getPreprocValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
bool SleighCompile::getPreprocValue(const string &nm,string &res) const

{
  map<string,string>::const_iterator iter = preproc_defines.find(nm);
  if (iter == preproc_defines.end()) return false;
  res = (*iter).second;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x210, %rdi            # imm = 0x210
movq -0x18(%rbp), %rsi
callq 0x6ba40
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x210, %rdi            # imm = 0x210
callq 0x6baa0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6ba70
testb $0x1, %al
jne 0x63a87
jmp 0x63a8d
movb $0x0, -0x1(%rbp)
jmp 0x63aaa
leaq -0x28(%rbp), %rdi
callq 0x6bad0
movq %rax, %rsi
addq $0x20, %rsi
movq -0x20(%rbp), %rdi
callq 0x11050
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::undefinePreprocValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool SleighCompile::undefinePreprocValue(const string &nm)

{
  map<string,string>::iterator iter = preproc_defines.find(nm);
  if (iter==preproc_defines.end()) return false;
  preproc_defines.erase(iter);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x210, %rdi            # imm = 0x210
movq -0x18(%rbp), %rsi
callq 0x6bbd0
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x210, %rdi            # imm = 0x210
callq 0x6bc30
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6bc00
testb $0x1, %al
jne 0x63b63
jmp 0x63b69
movb $0x0, -0x1(%rbp)
jmp 0x63b8d
movq -0x40(%rbp), %rdi
addq $0x210, %rdi            # imm = 0x210
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x6bc60
movq %rax, -0x38(%rbp)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::defineToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, unsigned long*)
TokenSymbol *SleighCompile::defineToken(string *name,uintb *sz)

{
  uint4 size = *sz;
  delete sz;
  if ((size&7)!=0) {
    reportError(*name+"token size must be multiple of 8",true);
    size = (size/8)+1;
  }
  else
    size = size/8;
  Token *newtoken = new Token(*name,size,isBigEndian(),tokentable.size());
  tokentable.push_back(newtoken);
  delete name;
  TokenSymbol *res = new TokenSymbol(newtoken);
  addSymbol(res);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x63be5
movq -0x68(%rbp), %rdi
movl $0x8, %esi
callq 0x11450
movl -0x1c(%rbp), %eax
andl $0x7, %eax
cmpl $0x0, %eax
je 0x63c4d
movq -0x10(%rbp), %rsi
leaq 0x75a7d(%rip), %rdx     # 0xd9678
leaq -0x40(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x151f0
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
movl $0x1, %edx
callq 0x603b0
jmp 0x63c1c
leaq -0x40(%rbp), %rdi
callq 0x11300
movl -0x1c(%rbp), %eax
shrl $0x3, %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x63c56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x11300
jmp 0x63d8d
movl -0x1c(%rbp), %eax
shrl $0x3, %eax
movl %eax, -0x1c(%rbp)
movl $0x30, %edi
callq 0x11440
movq -0x70(%rbp), %rdi
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x80(%rbp)
callq 0x57c80
movb %al, -0x79(%rbp)
jmp 0x63c86
movq -0x70(%rbp), %rdi
addq $0x270, %rdi            # imm = 0x270
callq 0x6bca0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movl -0x80(%rbp), %edx
movq %rax, %rcx
movb -0x79(%rbp), %al
movl %ecx, %r8d
movzbl %al, %ecx
andl $0x1, %ecx
callq 0x6bcc0
jmp 0x63cbd
movq -0x70(%rbp), %rdi
movq -0x90(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x270, %rdi            # imm = 0x270
leaq -0x58(%rbp), %rsi
callq 0x6bd10
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
cmpq $0x0, %rax
je 0x63d0a
movq -0x98(%rbp), %rdi
callq 0x11300
movq -0x98(%rbp), %rdi
movl $0x20, %esi
callq 0x11450
movl $0x38, %edi
callq 0x11440
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq -0x58(%rbp), %rsi
callq 0x6bd80
jmp 0x63d2c
movq -0x70(%rbp), %rdi
movq -0xa0(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rsi
callq 0x60f90
movq -0x60(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
movl $0x30, %esi
callq 0x11450
jmp 0x63d8d
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
movl $0x38, %esi
callq 0x11450
movq -0x48(%rbp), %rdi
callq 0x118b0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::addContextField(VarnodeSymbol*, FieldQuality*)
bool SleighCompile::addContextField(VarnodeSymbol *sym,FieldQuality *qual)

{
  if (contextlock)
    return false;		// Context layout has already been satisfied

  contexttable.push_back(FieldContext(sym,qual));
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, 0x2e0(%rax)
je 0x63ecb
movb $0x0, -0x1(%rbp)
jmp 0x63efb
movq -0x38(%rbp), %rax
addq $0x240, %rax            # imm = 0x240
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x6be20
movq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6bdf0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::newSectionSymbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
SectionSymbol *SleighCompile::newSectionSymbol(const string &nm)

{
  SectionSymbol *sym = new SectionSymbol(nm,sections.size());
  try {
    symtab.addGlobalSymbol(sym);
  } catch(SleighError &err) {
    reportError(err.explain,true);
  }
  sections.push_back(sym);
  numSections = sections.size();
  return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x40, %edi
callq 0x11440
movq -0x50(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x2a0, %rdi            # imm = 0x2A0
callq 0x6be70
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl %eax, %edx
callq 0x6be90
jmp 0x64273
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x198, %rdi            # imm = 0x198
movq -0x18(%rbp), %rsi
callq 0xa2ca0
jmp 0x64291
jmp 0x642f0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x40, %esi
callq 0x11450
jmp 0x64340
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x64340
movq -0x20(%rbp), %rdi
callq 0x111e0
movq -0x50(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movl $0x1, %edx
callq 0x603b0
jmp 0x642eb
callq 0x11810
movq -0x50(%rbp), %rdi
addq $0x2a0, %rdi            # imm = 0x2A0
leaq -0x18(%rbp), %rsi
callq 0x6bee0
movq -0x50(%rbp), %rdi
addq $0x2a0, %rdi            # imm = 0x2A0
callq 0x6be70
movq %rax, %rcx
movq -0x50(%rbp), %rax
movl %ecx, 0x1d8(%rax)
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x11810
jmp 0x6433e
jmp 0x64340
movq -0x20(%rbp), %rdi
callq 0x118b0
movq %rax, %rdi
callq 0x15590
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::defineVarnodes(SpaceSymbol*, unsigned long*, unsigned long*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*)
void SleighCompile::defineVarnodes(SpaceSymbol *spacesym,uintb *off,uintb *size,vector<string> *names)

{
  AddrSpace *spc = spacesym->getSpace();
  uintb myoff = *off;
  for(int4 i=0;i<names->size();++i) {
    if ((*names)[i] != "_")
      addSymbol( new VarnodeSymbol((*names)[i],spc,myoff,*size) );
    myoff += *size;
  }
  delete names;
  delete off;
  delete size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x47c50
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movslq -0x3c(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rdi
callq 0x15090
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x644b0
movq -0x28(%rbp), %rdi
movslq -0x3c(%rbp), %rsi
callq 0x1bb40
movq %rax, %rdi
leaq 0x752bb(%rip), %rsi     # 0xd96d9
callq 0x22690
testb $0x1, %al
jne 0x64429
jmp 0x64493
movl $0x58, %edi
callq 0x11440
movq %rax, -0x68(%rbp)
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x3c(%rbp), %rsi
callq 0x1bb40
movq -0x68(%rbp), %rdi
movq %rax, %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movl (%rax), %r8d
callq 0xa6800
jmp 0x64465
movq -0x70(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x60f90
jmp 0x64493
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
movl $0x58, %esi
callq 0x11450
jmp 0x6451c
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x643e6
movq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, %rax
je 0x644d5
movq -0x78(%rbp), %rdi
callq 0x1bc40
movq -0x78(%rbp), %rdi
movl $0x18, %esi
callq 0x11450
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0x644f1
movq -0x80(%rbp), %rdi
movl $0x8, %esi
callq 0x11450
movq -0x20(%rbp), %rax
movq %rax, -0x88(%rbp)
cmpq $0x0, %rax
je 0x64513
movq -0x88(%rbp), %rdi
movl $0x8, %esi
callq 0x11450
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x118b0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::addUserOp(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*)
void SleighCompile::addUserOp(vector<string> *names)

{
  for(int4 i=0;i<names->size();++i) {
    UserOpSymbol *sym = new UserOpSymbol((*names)[i]);
    sym->setIndex(userop_count++);
    addSymbol( sym );
  }
  delete names;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x15090
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x6493a
movl $0x38, %edi
callq 0x11440
movq %rax, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x1bb40
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x6bfb0
jmp 0x648dd
movq -0x38(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl 0x330(%rax), %esi
movl %esi, %ecx
addl $0x1, %ecx
movl %ecx, 0x330(%rax)
callq 0x6bff0
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x60f90
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6488f
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x38, %esi
callq 0x11450
jmp 0x64965
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x6495f
movq -0x58(%rbp), %rdi
callq 0x1bc40
movq -0x58(%rbp), %rdi
movl $0x18, %esi
callq 0x11450
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x118b0
nop
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::dedupSymbolList(std::vector<SleighSymbol*, std::allocator<SleighSymbol*>>*)
SleighSymbol *SleighCompile::dedupSymbolList(vector<SleighSymbol *> *symlist)

{				// Find duplicates in -symlist-, null out all but first
  SleighSymbol *res = (SleighSymbol *)0;
  for(int4 i=0;i<symlist->size();++i) {
    SleighSymbol *sym = (*symlist)[i];
    if (sym == (SleighSymbol *)0) continue;
    for(int4 j=i+1;j<symlist->size();++j) {
      if ((*symlist)[j] == sym) { // Found a duplicate
	res = sym;		// Return example duplicate for error reporting
	(*symlist)[j] = (SleighSymbol *)0; // Null out the duplicate
      }
    }
  }
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6c010
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x64a42
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x6c030
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x649cd
jmp 0x64a34
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6c010
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x64a32
movq -0x10(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x6c030
movq (%rax), %rax
cmpq -0x28(%rbp), %rax
jne 0x64a25
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x6c030
movq $0x0, (%rax)
jmp 0x64a27
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x649d6
jmp 0x64a34
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6498f
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::newTable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
SubtableSymbol *SleighCompile::newTable(string *nm)

{
  SubtableSymbol *sym = new SubtableSymbol(*nm);
  addSymbol(sym);
  tables.push_back(sym);
  delete nm;
  return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x60, %edi
callq 0x11440
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0xadc70
jmp 0x65497
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x60f90
movq -0x38(%rbp), %rdi
addq $0x288, %rdi            # imm = 0x288
leaq -0x18(%rbp), %rsi
callq 0x6a810
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x654e5
movq -0x40(%rbp), %rdi
callq 0x11300
movq -0x40(%rbp), %rdi
movl $0x20, %esi
callq 0x11450
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x60, %esi
callq 0x11450
movq -0x20(%rbp), %rdi
callq 0x118b0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::newOperand(Constructor*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void SleighCompile::newOperand(Constructor *ct,string *nm)

{
  int4 index = ct->getNumOperands();
  OperandSymbol *sym = new OperandSymbol(*nm,index,ct);
  addSymbol(sym);
  ct->addOperand(sym);
  delete nm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x52760
movl %eax, -0x1c(%rbp)
movl $0x60, %edi
callq 0x11440
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x10(%rbp), %rcx
callq 0xa81d0
jmp 0x6556e
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x60f90
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xaa4e0
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x655b5
movq -0x50(%rbp), %rdi
callq 0x11300
movq -0x50(%rbp), %rdi
movl $0x20, %esi
callq 0x11450
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x60, %esi
callq 0x11450
movq -0x30(%rbp), %rdi
callq 0x118b0
nop
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::constrainOperand(OperandSymbol*, PatternExpression*)
PatternEquation *SleighCompile::constrainOperand(OperandSymbol *sym,PatternExpression *patexp)

{				// Create constraint on operand
  PatternEquation *res;
  FamilySymbol *famsym = dynamic_cast<FamilySymbol *>(sym->getDefiningSymbol());
  if (famsym != (FamilySymbol *)0) { // Operand already defined as family symbol
				// This equation must be a constraint
    res = new EqualEquation(famsym->getPatternValue(),patexp);
  }
  else {			// Operand is currently undefined, so we can't constrain
    PatternExpression::release(patexp);
    res = (PatternEquation *)0;
  }
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x52780
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x65628
movq -0x40(%rbp), %rdi
leaq 0xca216(%rip), %rsi     # 0x12f828
leaq 0xca2a7(%rip), %rdx     # 0x12f8c0
xorl %eax, %eax
movl %eax, %ecx
callq 0x11530
movq %rax, -0x48(%rbp)
jmp 0x65630
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x65630
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x65699
movl $0x48, %edi
callq 0x11440
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
movq 0x60(%rax), %rax
callq *%rax
movq %rax, -0x50(%rbp)
jmp 0x65660
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rdx
callq 0x6c270
jmp 0x65673
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x656aa
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x48, %esi
callq 0x11450
jmp 0x656b4
movq -0x18(%rbp), %rdi
callq 0x88e20
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x118b0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::defineOperand(OperandSymbol*, PatternExpression*)
void SleighCompile::defineOperand(OperandSymbol *sym,PatternExpression *patexp)

{				// Define operand in terms of PatternExpression
  try {
    sym->defineOperand(patexp);
    sym->setOffsetIrrelevant();	// If not a self-definition, the operand has no
				// pattern directly associated with it, so
				// the operand's offset is irrelevant
  }
  catch(SleighError &err) {
    reportError(err.explain,true);
    PatternExpression::release(patexp);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa82a0
jmp 0x656eb
movq -0x10(%rbp), %rdi
callq 0x6c2c0
jmp 0x656f6
jmp 0x65741
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x6575c
movq -0x20(%rbp), %rdi
callq 0x111e0
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movl $0x1, %edx
callq 0x603b0
jmp 0x65731
movq -0x18(%rbp), %rdi
callq 0x88e20
jmp 0x6573c
callq 0x11810
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x11810
jmp 0x6575a
jmp 0x6575c
movq -0x20(%rbp), %rdi
callq 0x118b0
movq %rax, %rdi
callq 0x15590
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::defineInvisibleOperand(TripleSymbol*)
PatternEquation *SleighCompile::defineInvisibleOperand(TripleSymbol *sym)

{
  int4 index = curct->getNumOperands();
  OperandSymbol *opsym = new OperandSymbol(sym->getName(),index,curct);
  addSymbol(opsym);
  curct->addInvisibleOperand(opsym);
  PatternEquation *res = new OperandEquation(opsym->getIndex());
  SleighSymbol::symbol_type tp = sym->getType();
  try {
    if ((tp==SleighSymbol::value_symbol)||(tp==SleighSymbol::context_symbol)) {
      opsym->defineOperand(sym->getPatternExpression());
    }
    else {
      opsym->defineOperand(sym);
      //      reportWarning("Defining invisible operand "+sym->getName(),true);
    }
  }
  catch(SleighError &err) {
    reportError(err.explain,true);
  }
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq 0x2d0(%rax), %rdi
callq 0x52760
movl %eax, -0x14(%rbp)
movl $0x60, %edi
callq 0x11440
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x401a0
movq %rax, -0x50(%rbp)
jmp 0x657b7
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rax
movl -0x14(%rbp), %edx
movq 0x2d0(%rax), %rcx
callq 0xa81d0
jmp 0x657d4
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x60f90
movq -0x60(%rbp), %rax
movq 0x2d0(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0xaa4b0
movl $0x40, %edi
callq 0x11440
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rdi
callq 0x17860
movl %eax, -0x64(%rbp)
jmp 0x65819
movl -0x64(%rbp), %esi
movq -0x70(%rbp), %rdi
callq 0x6c2e0
jmp 0x65827
movq -0x70(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, -0x3c(%rbp)
cmpl $0x3, -0x3c(%rbp)
je 0x6584c
cmpl $0xf, -0x3c(%rbp)
jne 0x65901
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movq %rax, -0x78(%rbp)
jmp 0x65867
movq -0x78(%rbp), %rsi
movq -0x80(%rbp), %rdi
callq 0xa82a0
jmp 0x65876
jmp 0x65912
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x60, %esi
callq 0x11450
jmp 0x65929
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x40, %esi
callq 0x11450
jmp 0x65929
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x65929
movq -0x28(%rbp), %rdi
callq 0x111e0
movq -0x60(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
movl $0x1, %edx
callq 0x603b0
jmp 0x658ef
callq 0x11810
movq -0x38(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa83a0
jmp 0x65910
jmp 0x65912
jmp 0x658f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x11810
jmp 0x65927
jmp 0x65929
movq -0x28(%rbp), %rdi
callq 0x118b0
movq %rax, %rdi
callq 0x15590
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::selfDefine(OperandSymbol*)
void SleighCompile::selfDefine(OperandSymbol *sym)

{				// Define operand as global symbol of same name
  TripleSymbol *glob = dynamic_cast<TripleSymbol *>(symtab.findSymbol(sym->getName(),1));
  if (glob == (TripleSymbol *)0) {
    reportError(sym->getName()+": No matching global symbol",true);
    return;
  }
  SleighSymbol::symbol_type tp = glob->getType();
  try {
    if ((tp==SleighSymbol::value_symbol)||(tp==SleighSymbol::context_symbol)) {
      sym->defineOperand(glob->getPatternExpression());
    }
    else
      sym->defineOperand(glob);
  }
  catch(SleighError &err) {
    reportError(err.explain,true);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x198, %rax            # imm = 0x198
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x401a0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x6c320
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x659aa
movq -0x58(%rbp), %rdi
leaq 0xcb69c(%rip), %rsi     # 0x131030
leaq 0xc9e8d(%rip), %rdx     # 0x12f828
xorl %eax, %eax
movl %eax, %ecx
callq 0x11530
movq %rax, -0x70(%rbp)
jmp 0x659b2
xorl %eax, %eax
movq %rax, -0x70(%rbp)
jmp 0x659b2
movq -0x70(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x65a1d
movq -0x10(%rbp), %rdi
callq 0x401a0
movq %rax, %rsi
leaq 0x73e4a(%rip), %rdx     # 0xd981e
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x151f0
movq -0x68(%rbp), %rdi
movq -0x78(%rbp), %rsi
movl $0x1, %edx
callq 0x603b0
jmp 0x659f5
leaq -0x38(%rbp), %rdi
callq 0x11300
jmp 0x65aa6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11300
jmp 0x65ad7
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, -0x48(%rbp)
cmpl $0x3, -0x48(%rbp)
je 0x65a36
cmpl $0xf, -0x48(%rbp)
jne 0x65aaf
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movq %rax, -0x80(%rbp)
jmp 0x65a54
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdi
callq 0xa82a0
jmp 0x65a66
jmp 0x65ac0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x65ad7
movq -0x40(%rbp), %rdi
callq 0x111e0
movq -0x68(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rsi
movl $0x1, %edx
callq 0x603b0
jmp 0x65aa1
callq 0x11810
addq $0x90, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa83a0
jmp 0x65abe
jmp 0x65ac0
jmp 0x65aa6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x11810
jmp 0x65ad5
jmp 0x65ad7
movq -0x40(%rbp), %rdi
callq 0x118b0
movq %rax, %rdi
callq 0x15590
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::setResultVarnode(ConstructTpl*, VarnodeTpl*)
ConstructTpl *SleighCompile::setResultVarnode(ConstructTpl *ct,VarnodeTpl *vn)

{				// Set constructors handle to indicate given varnode
  HandleTpl *res = new HandleTpl(vn);
  delete vn;
  ct->setResult(res);
  return ct;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0xe0, %edi
callq 0x11440
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rsi
callq 0x4c090
jmp 0x65b23
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x65b47
movq -0x40(%rbp), %rdi
movl $0x68, %esi
callq 0x11450
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6c360
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0xe0, %esi
callq 0x11450
movq -0x28(%rbp), %rdi
callq 0x118b0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::setResultStarVarnode(ConstructTpl*, StarQuality*, VarnodeTpl*)
ConstructTpl *SleighCompile::setResultStarVarnode(ConstructTpl *ct,StarQuality *star,VarnodeTpl *vn)

{				// Set constructors handle to be the value pointed
				// at by -vn-
  HandleTpl *res = new HandleTpl(star->id,ConstTpl(ConstTpl::real,star->size),vn,
				   getUniqueSpace(),getUniqueAddr());
  delete star;
  delete vn;
  ct->setResult(res);
  return ct;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movl $0xe0, %edi
callq 0x11440
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movl 0x20(%rax), %eax
movl %eax, %edx
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x49ef0
jmp 0x65bdb
movq -0x70(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0x48190
movq %rax, -0x78(%rbp)
jmp 0x65bf2
movq -0x70(%rbp), %rdi
callq 0x60ba0
movq %rax, -0x88(%rbp)
jmp 0x65c04
movq -0x88(%rbp), %r9
movq -0x78(%rbp), %r8
movq -0x80(%rbp), %rcx
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x4c1d0
jmp 0x65c26
movq -0x68(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
cmpq $0x0, %rax
je 0x65c50
movq -0x90(%rbp), %rdi
movl $0x28, %esi
callq 0x11450
movq -0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
cmpq $0x0, %rax
je 0x65c72
movq -0x98(%rbp), %rdi
movl $0x68, %esi
callq 0x11450
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6c360
movq -0x10(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0xe0, %esi
callq 0x11450
movq -0x50(%rbp), %rdi
callq 0x118b0
nop
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::contextSet(std::vector<ContextChange*, std::allocator<ContextChange*>>*, TripleSymbol*, ContextSymbol*)
void SleighCompile::contextSet(vector<ContextChange *> *vec,TripleSymbol *sym,
				ContextSymbol *cvar)

{ // A permanent (global) change to context.  During parsing of an instruction, this change
  // is put off until the full instruction has been parsed.  The existing value in the context
  // field is set permanently to that value starting at the address given by the address expression
  ContextField *field = (ContextField *)cvar->getPatternValue();
  ContextCommit *op = new ContextCommit(sym,field->getStartBit(),field->getEndBit(),cvar->getFlow());
  vec->push_back(op);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
movq 0x60(%rax), %rax
callq *%rax
movq %rax, -0x28(%rbp)
movl $0x20, %edi
callq 0x11440
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rdi
callq 0x57870
movl %eax, -0x4c(%rbp)
jmp 0x65edd
movq -0x28(%rbp), %rdi
callq 0x57890
movl %eax, -0x64(%rbp)
jmp 0x65eeb
movq -0x20(%rbp), %rdi
callq 0x6c440
movb %al, -0x65(%rbp)
jmp 0x65ef9
movl -0x64(%rbp), %ecx
movl -0x4c(%rbp), %edx
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdi
movb -0x65(%rbp), %al
movzbl %al, %r8d
andl $0x1, %r8d
callq 0xb13d0
jmp 0x65f19
movq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x6a480
addq $0x70, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x20, %esi
callq 0x11450
movq -0x38(%rbp), %rdi
callq 0x118b0
nop
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::compareMacroParams(MacroSymbol*, std::vector<ExprTree*, std::allocator<ExprTree*>> const&)
void SleighCompile::compareMacroParams(MacroSymbol *sym,const vector<ExprTree *> &param)

{ // Match up any qualities of the macro's OperandSymbols with
  // any OperandSymbol passed into the macro
  for(uint4 i=0;i<param.size();++i) {
    VarnodeTpl *outvn = param[i]->getOut();
    if (outvn == (VarnodeTpl *)0) continue;
    // Check if an OperandSymbol was passed into this macro
    if (outvn->getOffset().getType() != ConstTpl::handle) continue;
    int4 hand = outvn->getOffset().getHandleIndex();

    // The matching operands
    OperandSymbol *macroop = sym->getOperand(i);
    OperandSymbol *parentop;
    if (curct == (Constructor *)0)
      parentop = curmacro->getOperand(hand);
    else
      parentop = curct->getOperand(hand);

    // This is the only property we check right now
    if (macroop->isCodeAddress())
      parentop->setCodeAddress();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3f860
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x6624e
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x6c510
movq (%rax), %rdi
callq 0x6c530
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x661a9
jmp 0x66240
movq -0x28(%rbp), %rdi
callq 0x3fca0
movq %rax, %rdi
callq 0x3fc10
cmpl $0x1, %eax
je 0x661c1
jmp 0x66240
movq -0x28(%rbp), %rdi
callq 0x3fca0
movq %rax, %rdi
callq 0x402b0
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x6c550
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x38(%rbp)
cmpq $0x0, 0x2d0(%rax)
jne 0x6620f
movq -0x48(%rbp), %rax
movq 0x2d8(%rax), %rdi
movl -0x2c(%rbp), %esi
callq 0x6c550
movq %rax, -0x40(%rbp)
jmp 0x66226
movq -0x48(%rbp), %rax
movq 0x2d0(%rax), %rdi
movl -0x2c(%rbp), %esi
callq 0x179c0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x6c580
testb $0x1, %al
jne 0x66235
jmp 0x6623e
movq -0x40(%rbp), %rdi
callq 0x6c5a0
jmp 0x66240
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x66163
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::firstNamedSection(ConstructTpl*, SectionSymbol*)
SectionVector *SleighCompile::firstNamedSection(ConstructTpl *main,SectionSymbol *sym)

{ // Start the first named p-code section after the main p-code section
  sym->incrementDefineCount();
  SymbolScope *curscope = symtab.getCurrentScope(); // This should be a Constructor scope
  SymbolScope *parscope = curscope->getParent();
  if (parscope != symtab.getGlobalScope())
    throw LowlevelError("firstNamedSection called when not in Constructor scope"); // Unrecoverable error
  symtab.addScope();		// Add new scope under the Constructor scope
  SectionVector *res = new SectionVector(main,curscope);
  res->setNextIndex(sym->getTemplateId());
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6c620
movq -0x78(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
callq 0x6c600
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6c640
movq -0x78(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
addq $0x198, %rdi            # imm = 0x198
callq 0x576f0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
je 0x666a3
movb $0x1, -0x5d(%rbp)
movl $0x20, %edi
callq 0x11250
movq %rax, -0x88(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x118c0
movq -0x80(%rbp), %rdx
leaq 0x7326b(%rip), %rsi     # 0xd9889
leaq -0x48(%rbp), %rdi
callq 0x14430
jmp 0x66629
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x14900
jmp 0x6663b
movq -0x88(%rbp), %rdi
movb $0x0, -0x5d(%rbp)
leaq 0xc71b3(%rip), %rsi     # 0x12d800
leaq -0x51d04(%rip), %rdx    # 0x14950
callq 0x11860
jmp 0x66739
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x66681
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x11300
leaq -0x49(%rbp), %rdi
callq 0x114d0
testb $0x1, -0x5d(%rbp)
jne 0x66692
jmp 0x6669e
movq -0x88(%rbp), %rdi
callq 0x11360
jmp 0x66730
movq -0x78(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
callq 0xa2b60
movl $0x30, %edi
callq 0x11440
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5a470
jmp 0x666d9
movq -0x90(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6c680
movq -0x98(%rbp), %rdi
movl %eax, %esi
callq 0x6c660
movq -0x68(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
movl $0x30, %esi
callq 0x11450
movq -0x58(%rbp), %rdi
callq 0x118b0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::nextNamedSection(SectionVector*, ConstructTpl*, SectionSymbol*)
SectionVector *SleighCompile::nextNamedSection(SectionVector *vec,ConstructTpl *section,SectionSymbol *sym)

{ // Add additional named p-code sections
  sym->incrementDefineCount();
  symtab.popScope();		// Pop the scope of the last named section
  SymbolScope *curscope = symtab.getCurrentScope(); // This should now be the Constructor scope
  SymbolScope *parscope = curscope->getParent();
  if (parscope != symtab.getGlobalScope())
    throw LowlevelError("nextNamedSection called when not in section scope"); // Unrecoverable
  symtab.addScope();		// Add new scope under the Constructor scope (not the last section scope)
  vec->append(section,curscope); // Associate finished section
  vec->setNextIndex(sym->getTemplateId()); // Set index for the NEXT section (not been fully parsed yet)
  return vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6c620
movq -0x78(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
callq 0xa2c00
movq -0x78(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
callq 0x6c600
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6c640
movq -0x78(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
addq $0x198, %rdi            # imm = 0x198
callq 0x576f0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
je 0x66874
movb $0x1, -0x65(%rbp)
movl $0x20, %edi
callq 0x11250
movq %rax, -0x88(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x118c0
movq -0x80(%rbp), %rdx
leaq 0x730ce(%rip), %rsi     # 0xd98c0
leaq -0x50(%rbp), %rdi
callq 0x14430
jmp 0x667fd
movq -0x88(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x14900
jmp 0x6680f
movq -0x88(%rbp), %rdi
movb $0x0, -0x65(%rbp)
leaq 0xc6fdf(%rip), %rsi     # 0x12d800
leaq -0x51ed8(%rip), %rdx    # 0x14950
callq 0x11860
jmp 0x668cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x66855
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x11300
leaq -0x51(%rbp), %rdi
callq 0x114d0
testb $0x1, -0x65(%rbp)
jne 0x66866
jmp 0x66872
movq -0x88(%rbp), %rdi
callq 0x11360
jmp 0x668c4
movq -0x78(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
callq 0xa2b60
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x5a4d0
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6c680
movq -0x90(%rbp), %rdi
movl %eax, %esi
callq 0x6c660
movq -0x10(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x118b0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::finalNamedSection(SectionVector*, ConstructTpl*)
SectionVector *SleighCompile::finalNamedSection(SectionVector *vec,ConstructTpl *section)

{ // Fill-in final named section to match the previous SectionSymbol
  vec->append(section,symtab.getCurrentScope());
  symtab.popScope();		// Pop the section scope
  return vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x198, %rdi            # imm = 0x198
callq 0x6c600
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x5a4d0
movq -0x20(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
callq 0xa2c00
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::createCrossBuild(VarnodeTpl*, SectionSymbol*)
vector<OpTpl *> *SleighCompile::createCrossBuild(VarnodeTpl *addr,SectionSymbol *sym)

{ // Create the crossbuild directive as a pcode template
  unique_allocatemask = 1;
  vector<OpTpl *> *res = new vector<OpTpl *>();
  VarnodeTpl *sectionid = new VarnodeTpl(ConstTpl(getConstantSpace()),
                                         ConstTpl(ConstTpl::real,sym->getTemplateId()),
                                         ConstTpl(ConstTpl::real,4));
  // This is simply a single pcodeop (template), where the opcode indicates the crossbuild directive
  OpTpl *op = new OpTpl( CROSSBUILD );
  op->addInput(addr);		// The first input is the VarnodeTpl representing the address
  op->addInput(sectionid);	// The second input is the indexed representing the named pcode section to build
  res->push_back(op);
  sym->incrementRefCount();	// Keep track of the references to the section symbol
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movl $0x1, 0x1d4(%rax)
movl $0x18, %edi
callq 0x11440
movq %rax, %rdi
movq %rdi, -0xc0(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x3f710
movq -0xc0(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x68, %edi
callq 0x11440
movq -0xb8(%rbp), %rdi
movq %rax, -0xb0(%rbp)
callq 0x48150
movq %rax, -0xa8(%rbp)
jmp 0x669c4
movq -0xa8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x49f90
jmp 0x669d6
movq -0x18(%rbp), %rdi
callq 0x6c680
movl %eax, -0xc4(%rbp)
jmp 0x669e7
movl -0xc4(%rbp), %eax
movslq %eax, %rdx
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
callq 0x49ef0
jmp 0x669fd
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x49ef0
jmp 0x66a12
movq -0xb0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x78(%rbp), %rdx
leaq -0x98(%rbp), %rcx
callq 0x4bac0
jmp 0x66a2f
movq -0xb0(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x28, %edi
callq 0x11440
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movl $0x42, %esi
callq 0x3fbb0
jmp 0x66a5d
movq -0xd0(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3fa10
movq -0xa0(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3fa10
movq -0x20(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x3f730
movq -0x18(%rbp), %rdi
callq 0x6c6a0
movq -0x20(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0x68, %esi
callq 0x11450
jmp 0x66aed
movq -0xd0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0x28, %esi
callq 0x11450
movq -0x50(%rbp), %rdi
callq 0x118b0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::createConstructor(SubtableSymbol*)
Constructor *SleighCompile::createConstructor(SubtableSymbol *sym)

{
  if (sym == (SubtableSymbol *)0)
    sym = WithBlock::getCurrentSubtable(withstack);
  if (sym == (SubtableSymbol *)0)
    sym = root;
  curmacro = (MacroSymbol *)0;	// Not currently defining a macro
  curct = new Constructor(sym);
  curct->setLineno(lineno.back());
  sym->addConstructor(curct);
  symtab.addScope();		// Make a new symbol scope for our constructor
  pcode.resetLabelCount();
  return curct;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x66b33
movq -0x28(%rbp), %rdi
addq $0x2b8, %rdi            # imm = 0x2B8
callq 0x5ab40
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x66b49
movq -0x28(%rbp), %rax
movq 0x190(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, 0x2d8(%rax)
movl $0x98, %edi
callq 0x11440
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0xaa250
jmp 0x66b77
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, 0x2d0(%rdi)
movq 0x2d0(%rdi), %rax
movq %rax, -0x38(%rbp)
addq $0x318, %rdi            # imm = 0x318
callq 0x6a930
movq -0x38(%rbp), %rdi
movl (%rax), %esi
callq 0x6c6c0
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x2d0(%rax), %rsi
callq 0x6c6e0
movq -0x28(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
callq 0xa2b60
movq -0x28(%rbp), %rdi
addq $0x1e0, %rdi            # imm = 0x1E0
callq 0x48050
movq -0x28(%rbp), %rax
movq 0x2d0(%rax), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x98, %esi
callq 0x11450
movq -0x18(%rbp), %rdi
callq 0x118b0