LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: PatternBlock::PatternBlock(int, unsigned int, unsigned int)
PatternBlock::PatternBlock(int4 off,uintm msk,uintm val)

{				// Define mask and value pattern, confined to one uintm
  offset = off;
  maskvec.push_back(msk);
  valvec.push_back(val);
  nonzerosize = sizeof(uintm);	// Assume all non-zero bytes before normalization
  normalize();
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movl %ecx, 0x34(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x8, %rdi
movq %rdi, 0x18(%rsp)
callq 0xcf460
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
movq %rdi, 0x8(%rsp)
callq 0xcf460
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
movl 0x3c(%rsp), %ecx
movl %ecx, (%rax)
leaq 0x38(%rsp), %rsi
callq 0xd2df0
jmp 0x13622c
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
leaq 0x34(%rsp), %rsi
callq 0xd2df0
jmp 0x136241
movq 0x10(%rsp), %rdi
movl $0x4, 0x4(%rdi)
callq 0xda700
jmp 0x136254
addq $0x48, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0xe3070
movq 0x18(%rsp), %rdi
callq 0xe3070
movq 0x28(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: PatternBlock::PatternBlock(bool)
PatternBlock::PatternBlock(bool tf)

{
  offset = 0;
  if (tf)
    nonzerosize = 0;
  else
    nonzerosize = -1;
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x8, %rdi
callq 0xcf460
movq (%rsp), %rdi
addq $0x20, %rdi
callq 0xcf460
movq (%rsp), %rax
movl $0x0, (%rax)
testb $0x1, 0xf(%rsp)
je 0x1362df
movq (%rsp), %rax
movl $0x0, 0x4(%rax)
jmp 0x1362ea
movq (%rsp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
addq $0x18, %rsp
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: PatternBlock::PatternBlock(PatternBlock const*, PatternBlock const*)
PatternBlock::PatternBlock(const PatternBlock *a,const PatternBlock *b)

{				// Construct PatternBlock by ANDing two others together
  PatternBlock *res = a->intersect(b);
  offset = res->offset;
  nonzerosize = res->nonzerosize;
  maskvec = res->maskvec;
  valvec = res->valvec;
  delete res;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x8, %rdi
movq %rdi, 0x8(%rsp)
callq 0xcf460
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
movq %rdi, 0x18(%rsp)
callq 0xcf460
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xdb440
movq %rax, 0x20(%rsp)
jmp 0x136344
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
movq 0x38(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x4(%rdi)
movq 0x38(%rsp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0xe2bd0
jmp 0x13637b
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rsi
addq $0x20, %rsi
addq $0x20, %rdi
callq 0xe2bd0
jmp 0x136394
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x1363ba
movq (%rsp), %rdi
callq 0xd2d60
movq (%rsp), %rdi
movl $0x38, %esi
callq 0xd8620
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0xe3070
movq 0x8(%rsp), %rdi
callq 0xe3070
movq 0x30(%rsp), %rdi
callq 0xe0be0
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: PatternBlock::PatternBlock(std::vector<PatternBlock*, std::allocator<PatternBlock*>>&)
PatternBlock::PatternBlock(vector<PatternBlock *> &list)

{				// AND several blocks together to construct new block
  PatternBlock *res,*next;

  if (list.empty()) {		// If not ANDing anything
    offset = 0;			// make constructed block always true
    nonzerosize = 0;
    return;
  }
  res = list[0];
  for(int4 i=1;i<list.size();++i) {
    next = res->intersect(list[i]);
    delete res;
    res = next;
  }
  offset = res->offset;
  nonzerosize = res->nonzerosize;
  maskvec = res->maskvec;
  valvec = res->valvec;
  delete res;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x30(%rsp)
addq $0x8, %rdi
movq %rdi, 0x28(%rsp)
callq 0xcf460
movq 0x30(%rsp), %rdi
addq $0x20, %rdi
movq %rdi, 0x38(%rsp)
callq 0xcf460
movq 0x68(%rsp), %rdi
callq 0xdbb30
testb $0x1, %al
jne 0x1366a9
jmp 0x1366c0
movq 0x30(%rsp), %rax
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
jmp 0x13680d
movq 0x68(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd7b80
movq (%rax), %rax
movq %rax, 0x60(%rsp)
movl $0x1, 0x54(%rsp)
movslq 0x54(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x68(%rsp), %rdi
callq 0xd6cf0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x1367a1
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rdi
movslq 0x54(%rsp), %rsi
callq 0xd7b80
movq 0x10(%rsp), %rdi
movq (%rax), %rsi
callq 0xdb440
movq %rax, 0x18(%rsp)
jmp 0x136730
movq 0x18(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x136763
movq 0x8(%rsp), %rdi
callq 0xd2d60
movq 0x8(%rsp), %rdi
movl $0x38, %esi
callq 0xd8620
movq 0x58(%rsp), %rax
movq %rax, 0x60(%rsp)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x1366de
movq 0x38(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0xe3070
movq 0x28(%rsp), %rdi
callq 0xe3070
jmp 0x136812
movq 0x30(%rsp), %rdi
movq 0x60(%rsp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
movq 0x60(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x4(%rdi)
movq 0x60(%rsp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0xe2bd0
jmp 0x1367ce
movq 0x30(%rsp), %rdi
movq 0x60(%rsp), %rsi
addq $0x20, %rsi
addq $0x20, %rdi
callq 0xe2bd0
jmp 0x1367e7
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x13680d
movq (%rsp), %rdi
callq 0xd2d60
movq (%rsp), %rdi
movl $0x38, %esi
callq 0xd8620
addq $0x78, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: PatternBlock::clone() const
PatternBlock *PatternBlock::clone(void) const

{
  PatternBlock *res = new PatternBlock(true);

  res->offset = offset;
  res->nonzerosize = nonzerosize;
  res->maskvec = maskvec;
  res->valvec = valvec;
  return res;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x38, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movl $0x1, %esi
callq 0xe26d0
jmp 0x136854
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movl (%rsi), %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
movl 0x4(%rsi), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x4(%rax)
addq $0x8, %rsi
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0xe2bd0
movq 0x8(%rsp), %rsi
addq $0x20, %rsi
movq 0x28(%rsp), %rdi
addq $0x20, %rdi
callq 0xe2bd0
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x38, %esi
callq 0xd8620
movq 0x20(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: PatternBlock::commonSubPattern(PatternBlock const*) const
PatternBlock *PatternBlock::commonSubPattern(const PatternBlock *b) const

{				// The resulting pattern has a 1-bit in the mask
				// only if the two pieces have a 1-bit and the
				// values agree
  PatternBlock *res = new PatternBlock(true);
  int4 maxlength = (getLength() > b->getLength()) ? getLength() : b->getLength();

  res->offset = 0;
  int4 offset = 0;
  uintm mask1,val1,mask2,val2;
  uintm resmask,resval;
  while(offset < maxlength) {
    mask1 = getMask(offset*8,sizeof(uintm)*8);
    val1 = getValue(offset*8,sizeof(uintm)*8);
    mask2 = b->getMask(offset*8,sizeof(uintm)*8);
    val2 = b->getValue(offset*8,sizeof(uintm)*8);
    resmask = mask1 & mask2 & ~(val1^val2);
    resval = val1 & val2 & resmask;
    res->maskvec.push_back(resmask);
    res->valvec.push_back(resval);
    offset += sizeof(uintm);
  }
  res->nonzerosize = maxlength;
  res->normalize();
  return res;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x38, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movl $0x1, %esi
callq 0xe26d0
jmp 0x136919
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x50(%rsp)
callq 0xdd3c0
movl %eax, 0xc(%rsp)
movq 0x58(%rsp), %rdi
callq 0xdd3c0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jle 0x136955
movq 0x10(%rsp), %rdi
callq 0xdd3c0
movl %eax, 0x8(%rsp)
jmp 0x136963
movq 0x58(%rsp), %rdi
callq 0xdd3c0
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x40(%rsp)
movq 0x50(%rsp), %rax
movl $0x0, (%rax)
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x40(%rsp), %eax
jge 0x136a74
movq 0x10(%rsp), %rdi
movl 0x3c(%rsp), %esi
shll $0x3, %esi
movl $0x20, %edx
callq 0xdf280
movq 0x10(%rsp), %rdi
movl %eax, 0x38(%rsp)
movl 0x3c(%rsp), %esi
shll $0x3, %esi
movl $0x20, %edx
callq 0xd7dc0
movl %eax, 0x34(%rsp)
movq 0x58(%rsp), %rdi
movl 0x3c(%rsp), %esi
shll $0x3, %esi
movl $0x20, %edx
callq 0xdf280
movl %eax, 0x30(%rsp)
movq 0x58(%rsp), %rdi
movl 0x3c(%rsp), %esi
shll $0x3, %esi
movl $0x20, %edx
callq 0xd7dc0
movl %eax, 0x2c(%rsp)
movl 0x38(%rsp), %eax
andl 0x30(%rsp), %eax
movl 0x34(%rsp), %ecx
xorl 0x2c(%rsp), %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movl %eax, 0x28(%rsp)
movl 0x34(%rsp), %eax
andl 0x2c(%rsp), %eax
andl 0x28(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x50(%rsp), %rdi
addq $0x8, %rdi
leaq 0x28(%rsp), %rsi
callq 0xd2df0
movq 0x50(%rsp), %rdi
addq $0x20, %rdi
leaq 0x24(%rsp), %rsi
callq 0xd2df0
movslq 0x3c(%rsp), %rax
addq $0x4, %rax
movl %eax, 0x3c(%rsp)
jmp 0x13697e
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
movl $0x38, %esi
callq 0xd8620
jmp 0x136a94
movl 0x40(%rsp), %ecx
movq 0x50(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x50(%rsp), %rdi
callq 0xda700
movq 0x50(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0xe0be0
nop
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: PatternBlock::isInstructionMatch(ParserWalker&) const
bool PatternBlock::isInstructionMatch(ParserWalker &walker) const

{
  if (nonzerosize<=0) return (nonzerosize==0);
  int4 off = offset;
  for(int4 i=0;i<maskvec.size();++i) {
    uintm data = walker.getInstructionBytes(off,sizeof(uintm));
    if ((maskvec[i] & data)!=valvec[i]) return false;
    off += sizeof(uintm);
  }
  return true;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x4(%rax)
jg 0x136ad5
movq 0x18(%rsp), %rax
cmpl $0x0, 0x4(%rax)
sete %al
andb $0x1, %al
movb %al, 0x47(%rsp)
jmp 0x136b88
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
callq 0xcec30
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x136b83
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl $0x4, %edx
callq 0xd6420
movq 0x18(%rsp), %rdi
movl %eax, 0x24(%rsp)
addq $0x8, %rdi
movslq 0x28(%rsp), %rsi
callq 0xd4aa0
movq 0x18(%rsp), %rdi
movl (%rax), %eax
andl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x20, %rdi
movslq 0x28(%rsp), %rsi
callq 0xd4aa0
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
je 0x136b66
movb $0x0, 0x47(%rsp)
jmp 0x136b88
movslq 0x2c(%rsp), %rax
addq $0x4, %rax
movl %eax, 0x2c(%rsp)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x136ae8
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: PatternBlock::isContextMatch(ParserWalker&) const
bool PatternBlock::isContextMatch(ParserWalker &walker) const

{
  if (nonzerosize<=0) return (nonzerosize==0);
  int4 off = offset;
  for(int4 i=0;i<maskvec.size();++i) {
    uintm data = walker.getContextBytes(off,sizeof(uintm));
    if ((maskvec[i] & data)!=valvec[i]) return false;
    off += sizeof(uintm);
  }
  return true;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x4(%rax)
jg 0x136bd5
movq 0x18(%rsp), %rax
cmpl $0x0, 0x4(%rax)
sete %al
andb $0x1, %al
movb %al, 0x47(%rsp)
jmp 0x136c88
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
callq 0xcec30
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x136c83
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl $0x4, %edx
callq 0xda7e0
movq 0x18(%rsp), %rdi
movl %eax, 0x24(%rsp)
addq $0x8, %rdi
movslq 0x28(%rsp), %rsi
callq 0xd4aa0
movq 0x18(%rsp), %rdi
movl (%rax), %eax
andl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x20, %rdi
movslq 0x28(%rsp), %rsi
callq 0xd4aa0
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
je 0x136c66
movb $0x0, 0x47(%rsp)
jmp 0x136c88
movslq 0x2c(%rsp), %rax
addq $0x4, %rax
movl %eax, 0x2c(%rsp)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x136be8
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: PatternBlock::saveXml(std::ostream&) const
void PatternBlock::saveXml(ostream &s) const

{
  s << "<pat_block ";
  s << "offset=\"" << dec << offset << "\" ";
  s << "nonzero=\"" << nonzerosize << "\">\n";
  for(int4 i=0;i<maskvec.size();++i) {
    s << "  <mask_word ";
    s << "mask=\"0x" << hex << maskvec[i] << "\" ";
    s << "val=\"0x" << valvec[i] << "\"/>\n";
  }
  s << "</pat_block>\n";
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x52142(%rip), %rsi     # 0x188e06
callq 0xd8300
movq 0x28(%rsp), %rdi
leaq 0x50b01(%rip), %rsi     # 0x1877d6
callq 0xd8300
movq %rax, %rdi
movq 0x910b4(%rip), %rsi     # 0x1c7d98
callq 0xd1180
movq %rax, %rdi
movq 0x18(%rsp), %rax
movl (%rax), %esi
callq 0xe03e0
movq %rax, %rdi
leaq 0x5153a(%rip), %rsi     # 0x18823c
callq 0xd8300
movq 0x28(%rsp), %rdi
leaq 0x520ff(%rip), %rsi     # 0x188e12
callq 0xd8300
movq %rax, %rdi
movq 0x18(%rsp), %rax
movl 0x4(%rax), %esi
callq 0xe03e0
movq %rax, %rdi
leaq 0x520ea(%rip), %rsi     # 0x188e1c
callq 0xd8300
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x24(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
callq 0xcec30
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x136e1e
movq 0x28(%rsp), %rdi
leaq 0x520ac(%rip), %rsi     # 0x188e20
callq 0xd8300
movq 0x28(%rsp), %rdi
leaq 0x528de(%rip), %rsi     # 0x189663
callq 0xd8300
movq %rax, %rdi
movq 0x91234(%rip), %rsi     # 0x1c7fc8
callq 0xd1180
movq 0x18(%rsp), %rdi
movq %rax, (%rsp)
addq $0x8, %rdi
movslq 0x24(%rsp), %rsi
callq 0xd4aa0
movq (%rsp), %rdi
movl (%rax), %esi
callq 0xdbce0
movq %rax, %rdi
leaq 0x51477(%rip), %rsi     # 0x18823c
callq 0xd8300
movq 0x28(%rsp), %rdi
leaq 0x514bb(%rip), %rsi     # 0x188291
callq 0xd8300
movq 0x18(%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0x20, %rdi
movslq 0x24(%rsp), %rsi
callq 0xd4aa0
movq 0x8(%rsp), %rdi
movl (%rax), %esi
callq 0xdbce0
movq %rax, %rdi
leaq 0x51a13(%rip), %rsi     # 0x18881c
callq 0xd8300
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x136d3f
movq 0x28(%rsp), %rdi
leaq 0x52004(%rip), %rsi     # 0x188e2e
callq 0xd8300
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: InstructionPattern::doOr(Pattern const*, int) const
Pattern *InstructionPattern::doOr(const Pattern *b,int4 sa) const

{
  if (b->numDisjoint()>0)
    return b->doOr(this,-sa);

  const CombinePattern *b2 = dynamic_cast<const CombinePattern *>(b);
  if (b2 != (const CombinePattern *)0)
    return b->doOr(this,-sa);

  DisjointPattern *res1,*res2;
  res1 = (DisjointPattern *)simplifyClone();
  res2 = (DisjointPattern *)b->simplifyClone();
  if (sa < 0)
    res1->shiftInstruction(-sa);
  else
    res2->shiftInstruction(sa);
  return new OrPattern(res1,res2);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movl %edx, 0x4c(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
cmpl $0x0, %eax
jle 0x137bcc
movq 0x18(%rsp), %rsi
movq 0x50(%rsp), %rdi
xorl %edx, %edx
subl 0x4c(%rsp), %edx
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, 0x60(%rsp)
jmp 0x137cd1
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x137bff
movq 0x10(%rsp), %rdi
movq 0x900c0(%rip), %rsi     # 0x1c7ca8
movq 0x90131(%rip), %rdx     # 0x1c7d20
xorl %eax, %eax
movl %eax, %ecx
callq 0xd99a0
movq %rax, 0x8(%rsp)
jmp 0x137c08
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x137c08
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x137c3a
movq 0x18(%rsp), %rsi
movq 0x50(%rsp), %rdi
xorl %edx, %edx
subl 0x4c(%rsp), %edx
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, 0x60(%rsp)
jmp 0x137cd1
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x30(%rsp)
cmpl $0x0, 0x4c(%rsp)
jge 0x137c74
movq 0x38(%rsp), %rdi
xorl %esi, %esi
subl 0x4c(%rsp), %esi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x137c83
movq 0x30(%rsp), %rdi
movl 0x4c(%rsp), %esi
movq (%rdi), %rax
callq *0x18(%rax)
movl $0x20, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0xd14d0
jmp 0x137ca8
movq (%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x137cd1
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x20, %esi
callq 0xd8620
jmp 0x137cdb
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: InstructionPattern::restoreXml(Element const*)
void InstructionPattern::restoreXml(const Element *el)

{
  const List &list(el->getChildren());
  List::const_iterator iter;
  iter = list.begin();
  maskvalue = new PatternBlock(true);
  maskvalue->restoreXml(*iter);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0xde930
movq %rax, 0x40(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xd03e0
movq 0x40(%rsp), %rdi
callq 0xd4960
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x38, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movl $0x1, %esi
callq 0xe26d0
jmp 0x137dab
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xddc90
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
callq 0xd2ad0
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x38, %esi
callq 0xd8620
movq 0x28(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: ContextPattern::doOr(Pattern const*, int) const
Pattern *ContextPattern::doOr(const Pattern *b,int4 sa) const

{
  const ContextPattern *b2 = dynamic_cast<const ContextPattern *>(b);
  if (b2 == (const ContextPattern *)0)
    return b->doOr(this,-sa);

  return new OrPattern((DisjointPattern *)simplifyClone(),(DisjointPattern *)b2->simplifyClone());
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movl %edx, 0x4c(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x137e5f
movq 0x28(%rsp), %rdi
movq 0x8fe60(%rip), %rsi     # 0x1c7ca8
movq 0x8fd11(%rip), %rdx     # 0x1c7b60
xorl %eax, %eax
movl %eax, %ecx
callq 0xd99a0
movq %rax, 0x18(%rsp)
jmp 0x137e68
xorl %eax, %eax
movq %rax, 0x18(%rsp)
jmp 0x137e68
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x137e97
movq 0x20(%rsp), %rsi
movq 0x50(%rsp), %rdi
xorl %edx, %edx
subl 0x4c(%rsp), %edx
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, 0x60(%rsp)
jmp 0x137f0f
movl $0x20, %edi
callq 0xd8380
movq 0x20(%rsp), %rdi
movq %rax, 0x8(%rsp)
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, 0x10(%rsp)
jmp 0x137ebb
movq 0x40(%rsp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, (%rsp)
jmp 0x137ecf
movq (%rsp), %rdx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0xd14d0
jmp 0x137ee4
movq 0x8(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x137f0f
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl $0x20, %esi
callq 0xd8620
jmp 0x137f19
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: ContextPattern::doAnd(Pattern const*, int) const
Pattern *ContextPattern::doAnd(const Pattern *b,int4 sa) const

{
  const ContextPattern *b2 = dynamic_cast<const ContextPattern *>(b);
  if (b2 == (const ContextPattern *)0)
    return b->doAnd(this,-sa);

  PatternBlock *resblock = maskvalue->intersect(b2->maskvalue);
  return new ContextPattern(resblock);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movl %edx, 0x4c(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x137f7f
movq 0x20(%rsp), %rdi
movq 0x8fd40(%rip), %rsi     # 0x1c7ca8
movq 0x8fbf1(%rip), %rdx     # 0x1c7b60
xorl %eax, %eax
movl %eax, %ecx
callq 0xd99a0
movq %rax, 0x10(%rsp)
jmp 0x137f88
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0x137f88
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x137fb7
movq 0x18(%rsp), %rsi
movq 0x50(%rsp), %rdi
xorl %edx, %edx
subl 0x4c(%rsp), %edx
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, 0x60(%rsp)
jmp 0x13801f
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xdb440
movq %rax, 0x38(%rsp)
movl $0x10, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rsi
callq 0xde600
jmp 0x137ff4
movq 0x8(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x13801f
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl $0x10, %esi
callq 0xd8620
jmp 0x138029
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: ContextPattern::commonSubPattern(Pattern const*, int) const
Pattern *ContextPattern::commonSubPattern(const Pattern *b,int4 sa) const

{
  const ContextPattern *b2 = dynamic_cast<const ContextPattern *>(b);
  if (b2 == (const ContextPattern *)0)
    return b->commonSubPattern(this,-sa);

  PatternBlock *resblock = maskvalue->commonSubPattern(b2->maskvalue);
  return new ContextPattern(resblock);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movl %edx, 0x4c(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x13808f
movq 0x20(%rsp), %rdi
movq 0x8fc30(%rip), %rsi     # 0x1c7ca8
movq 0x8fae1(%rip), %rdx     # 0x1c7b60
xorl %eax, %eax
movl %eax, %ecx
callq 0xd99a0
movq %rax, 0x10(%rsp)
jmp 0x138098
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0x138098
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x1380c7
movq 0x18(%rsp), %rsi
movq 0x50(%rsp), %rdi
xorl %edx, %edx
subl 0x4c(%rsp), %edx
movq (%rdi), %rax
callq *0x30(%rax)
movq %rax, 0x60(%rsp)
jmp 0x13812f
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xd0960
movq %rax, 0x38(%rsp)
movl $0x10, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rsi
callq 0xde600
jmp 0x138104
movq 0x8(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x13812f
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl $0x10, %esi
callq 0xd8620
jmp 0x138139
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: CombinePattern::~CombinePattern()
CombinePattern::~CombinePattern(void)

{
  if (context != (ContextPattern *)0)
    delete context;
  if (instr != (InstructionPattern *)0)
    delete instr;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8fb26(%rip), %rcx     # 0x1c7db0
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x8(%rax)
je 0x1382b9
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x1382b7
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1382b9
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1382e6
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1382e4
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1382e6
movq 0x18(%rsp), %rdi
callq 0xce3f0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: CombinePattern::doOr(Pattern const*, int) const
Pattern *CombinePattern::doOr(const Pattern *b,int4 sa) const

{
  if (b->numDisjoint() != 0)
    return b->doOr(this,-sa);

  DisjointPattern *res1 = (DisjointPattern *)simplifyClone();
  DisjointPattern *res2 = (DisjointPattern *)b->simplifyClone();
  if (sa < 0)
    res1->shiftInstruction(-sa);
  else
    res2->shiftInstruction(sa);
  OrPattern *tmp = new OrPattern(res1,res2);
  return tmp;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
cmpl $0x0, %eax
je 0x1389cc
movq 0x8(%rsp), %rsi
movq 0x40(%rsp), %rdi
xorl %edx, %edx
subl 0x3c(%rsp), %edx
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, 0x50(%rsp)
jmp 0x138a6d
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x28(%rsp)
cmpl $0x0, 0x3c(%rsp)
jge 0x138a06
movq 0x30(%rsp), %rdi
xorl %esi, %esi
subl 0x3c(%rsp), %esi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x138a15
movq 0x28(%rsp), %rdi
movl 0x3c(%rsp), %esi
movq (%rdi), %rax
callq *0x18(%rax)
movl $0x20, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0xd14d0
jmp 0x138a3a
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x138a6d
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x20, %esi
callq 0xd8620
jmp 0x138a77
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: CombinePattern::simplifyClone() const
Pattern *CombinePattern::simplifyClone(void) const

{				// We should only have to think at "our" level
  if (context->alwaysTrue())
    return instr->simplifyClone();
  if (instr->alwaysTrue())
    return context->simplifyClone();
  if (context->alwaysFalse()||instr->alwaysFalse())
    return new InstructionPattern(false);
  return new CombinePattern((ContextPattern *)context->simplifyClone(),
			    (InstructionPattern *)instr->simplifyClone());
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
testb $0x1, %al
jne 0x138ab3
jmp 0x138acc
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x40(%rsp)
jmp 0x138bf4
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
testb $0x1, %al
jne 0x138ae1
jmp 0x138afa
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x40(%rsp)
jmp 0x138bf4
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
testb $0x1, %al
jne 0x138b22
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
testb $0x1, %al
jne 0x138b22
jmp 0x138b71
movl $0x10, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
xorl %esi, %esi
callq 0xdbad0
jmp 0x138b40
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x138bf4
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl $0x10, %esi
callq 0xd8620
jmp 0x138bfe
movl $0x18, %edi
callq 0xd8380
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, 0x10(%rsp)
jmp 0x138b9c
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, (%rsp)
jmp 0x138bb4
movq (%rsp), %rdx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0xddac0
jmp 0x138bc9
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x138bf4
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl $0x18, %esi
callq 0xd8620
jmp 0x138bfe
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xe0be0
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: CombinePattern::saveXml(std::ostream&) const
void CombinePattern::saveXml(ostream &s) const

{
  s << "<combine_pat>\n";
  context->saveXml(s);
  instr->saveXml(s);
  s << "</combine_pat>\n";
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
leaq 0x50251(%rip), %rsi     # 0x188e84
callq 0xd8300
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rsp), %rsi
movq (%rdi), %rax
callq *0x68(%rax)
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rsi
movq (%rdi), %rax
callq *0x68(%rax)
movq 0x8(%rsp), %rdi
leaq 0x50229(%rip), %rsi     # 0x188e93
callq 0xd8300
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: CombinePattern::restoreXml(Element const*)
void CombinePattern::restoreXml(const Element *el)

{
  const List &list(el->getChildren());
  List::const_iterator iter;
  iter = list.begin();
  context = new ContextPattern();
  context->restoreXml(*iter);
  ++iter;
  instr = new InstructionPattern();
  instr->restoreXml(*iter);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
callq 0xde930
movq %rax, 0x50(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xd03e0
movq 0x50(%rsp), %rdi
callq 0xd4960
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x48(%rsp)
movl $0x10, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x28(%rsp)
callq 0xe2230
jmp 0x138ce6
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xddc90
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
movq (%rdi), %rax
movq 0x70(%rax), %rax
callq *%rax
movq 0x10(%rsp), %rdi
callq 0xd0700
movl $0x10, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
callq 0xd16e0
jmp 0x138d43
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rax
movq %rax, (%rsp)
leaq 0x48(%rsp), %rdi
callq 0xddc90
movq (%rsp), %rdi
movq (%rax), %rsi
movq (%rdi), %rax
callq *0x70(%rax)
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl $0x10, %esi
callq 0xd8620
jmp 0x138db1
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl $0x10, %esi
callq 0xd8620
movq 0x38(%rsp), %rdi
callq 0xe0be0
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: OrPattern::isMatch(ParserWalker&) const
bool OrPattern::isMatch(ParserWalker &walker) const

{
  for(int4 i=0;i<orlist.size();++i)
    if (orlist[i]->isMatch(walker))
      return true;
  return false;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
callq 0xdf0f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x139152
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movslq 0x1c(%rsp), %rsi
callq 0xe0130
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
testb $0x1, %al
jne 0x13913c
jmp 0x139143
movb $0x1, 0x37(%rsp)
jmp 0x139157
jmp 0x139145
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1390f0
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: OrPattern::alwaysTrue() const
bool OrPattern::alwaysTrue(void) const

{				// This isn't quite right because different branches
				// may cover the entire gamut
  vector<DisjointPattern *>::const_iterator iter;

  for(iter=orlist.begin();iter!=orlist.end();++iter)
    if ((*iter)->alwaysTrue()) return true;
  return false;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xe0480
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0xe0c70
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0xd1e10
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xe2bc0
testb $0x1, %al
jne 0x1391d2
jmp 0x139200
leaq 0x20(%rsp), %rdi
callq 0xd1260
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
testb $0x1, %al
jne 0x1391eb
jmp 0x1391f2
movb $0x1, 0x37(%rsp)
jmp 0x139205
jmp 0x1391f4
leaq 0x20(%rsp), %rdi
callq 0xe2a00
jmp 0x1391aa
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: OrPattern::alwaysFalse() const
bool OrPattern::alwaysFalse(void) const

{
  vector<DisjointPattern *>::const_iterator iter;

  for(iter=orlist.begin();iter!=orlist.end();++iter)
    if (!(*iter)->alwaysFalse()) return false;
  return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xe0480
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0xe0c70
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0xd1e10
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xe2bc0
testb $0x1, %al
jne 0x139272
jmp 0x13929e
leaq 0x20(%rsp), %rdi
callq 0xd1260
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
testb $0x1, %al
jne 0x139290
movb $0x0, 0x37(%rsp)
jmp 0x1392a3
jmp 0x139292
leaq 0x20(%rsp), %rdi
callq 0xe2a00
jmp 0x13924a
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: OrPattern::alwaysInstructionTrue() const
bool OrPattern::alwaysInstructionTrue(void) const

{
  vector<DisjointPattern *>::const_iterator iter;

  for(iter=orlist.begin();iter!=orlist.end();++iter)
    if (!(*iter)->alwaysInstructionTrue()) return false;
  return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xe0480
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0xe0c70
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0xd1e10
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xe2bc0
testb $0x1, %al
jne 0x139312
jmp 0x13933e
leaq 0x20(%rsp), %rdi
callq 0xd1260
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
testb $0x1, %al
jne 0x139330
movb $0x0, 0x37(%rsp)
jmp 0x139343
jmp 0x139332
leaq 0x20(%rsp), %rdi
callq 0xe2a00
jmp 0x1392ea
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: OrPattern::commonSubPattern(Pattern const*, int) const
Pattern *OrPattern::commonSubPattern(const Pattern *b,int4 sa) const

{
  vector<DisjointPattern *>::const_iterator iter;
  Pattern *res,*next;

  iter = orlist.begin();
  res = (*iter)->commonSubPattern(b,sa);
  iter++;

  if (sa > 0)
    sa = 0;
  while(iter!=orlist.end()) {
    next = (*iter)->commonSubPattern(res,sa);
    delete res;
    res = next;
    ++iter;
  }
  return res;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xe0480
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0xe0c70
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xd1260
movq (%rax), %rdi
movq 0x48(%rsp), %rsi
movl 0x44(%rsp), %edx
movq (%rdi), %rax
callq *0x30(%rax)
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0xdb080
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x44(%rsp)
jle 0x139704
movl $0x0, 0x44(%rsp)
jmp 0x139706
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0xd1e10
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xe2bc0
testb $0x1, %al
jne 0x13972e
jmp 0x13977e
leaq 0x38(%rsp), %rdi
callq 0xd1260
movq (%rax), %rdi
movq 0x30(%rsp), %rsi
movl 0x44(%rsp), %edx
movq (%rdi), %rax
callq *0x30(%rax)
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x139768
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xe2a00
jmp 0x139706
movq 0x30(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: OrPattern::saveXml(std::ostream&) const
void OrPattern::saveXml(ostream &s) const

{
  s << "<or_pat>\n";
  for(int4 i=0;i<orlist.size();++i)
    orlist[i]->saveXml(s);
  s << "</or_pat>\n";
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x4efef(%rip), %rsi     # 0x188ea3
callq 0xd8300
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rdi
movslq 0x14(%rsp), %rax
movq %rax, (%rsp)
addq $0x8, %rdi
callq 0xdf0f0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x139f12
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movslq 0x14(%rsp), %rsi
callq 0xe0130
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
callq *0x68(%rax)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x139ec1
movq 0x18(%rsp), %rdi
leaq 0x4ef8f(%rip), %rsi     # 0x188ead
callq 0xd8300
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: OrPattern::restoreXml(Element const*)
void OrPattern::restoreXml(const Element *el)

{
  const List &list(el->getChildren());
  List::const_iterator iter;
  iter = list.begin();
  while(iter != list.end()) {
    DisjointPattern *pat = DisjointPattern::restoreDisjoint(*iter);
    orlist.push_back(pat);
    ++iter;
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0xde930
movq %rax, 0x30(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xd03e0
movq 0x30(%rsp), %rdi
callq 0xd4960
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0xd7a70
movq %rax, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xd72b0
testb $0x1, %al
jne 0x139f9e
jmp 0x139fd4
leaq 0x28(%rsp), %rdi
callq 0xddc90
movq (%rax), %rdi
callq 0xe2e30
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
leaq 0x10(%rsp), %rsi
callq 0xdf880
leaq 0x28(%rsp), %rdi
callq 0xd0700
jmp 0x139f7a
addq $0x48, %rsp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: SymbolScope::addSymbol(SleighSymbol*)
SleighSymbol *SymbolScope::addSymbol(SleighSymbol *a)

{
  pair<SymbolTree::iterator,bool> res;
  
  res = tree.insert( a );
  if (!res.second)
    return *res.first;		// Symbol already exists in this table
  return a;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xd72e0
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
leaq 0x40(%rsp), %rsi
callq 0xdb7f0
movb %dl, 0x18(%rsp)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movb 0x18(%rsp), %al
movb %al, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xdfa40
testb $0x1, 0x38(%rsp)
jne 0x13d2aa
leaq 0x30(%rsp), %rdi
callq 0xe1aa0
movq (%rax), %rax
movq %rax, 0x50(%rsp)
jmp 0x13d2b4
movq 0x40(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: SymbolScope::findSymbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
SleighSymbol *SymbolScope::findSymbol(const string &nm) const

{
  SleighSymbol dummy(nm);
  SymbolTree::const_iterator iter;

  iter = tree.find( &dummy );
  if (iter != tree.end())
    return *iter;
  return (SleighSymbol *)0;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq 0x88(%rsp), %rax
movq %rax, (%rsp)
movq 0x80(%rsp), %rsi
leaq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xd7540
leaq 0x48(%rsp), %rdi
callq 0xd3950
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
addq $0x8, %rdi
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rsi
callq 0xd0110
movq %rax, 0x10(%rsp)
jmp 0x13d327
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x48(%rsp)
addq $0x8, %rdi
callq 0xdc6d0
movq %rax, 0x20(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xd8da0
testb $0x1, %al
jne 0x13d362
jmp 0x13d39b
leaq 0x48(%rsp), %rdi
callq 0xe1aa0
movq (%rax), %rax
movq %rax, 0x90(%rsp)
movl $0x1, 0x1c(%rsp)
jmp 0x13d3af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xdd3a0
jmp 0x13d3c9
movq $0x0, 0x90(%rsp)
movl $0x1, 0x1c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xdd3a0
movq 0x90(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: SymbolTable::~SymbolTable()
SymbolTable::~SymbolTable(void)

{
  vector<SymbolScope *>::iterator iter;
  for(iter=table.begin();iter!=table.end();++iter)
    delete *iter;
  vector<SleighSymbol *>::iterator siter;
  for(siter=symbollist.begin();siter!=symbollist.end();++siter)
    delete *siter;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xdbd90
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
callq 0xd30d0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
callq 0xd5030
movq %rax, 0x38(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xd7340
testb $0x1, %al
jne 0x13d442
jmp 0x13d481
leaq 0x48(%rsp), %rdi
callq 0xcfcb0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x13d473
movq 0x10(%rsp), %rdi
callq 0xdfe20
movq 0x10(%rsp), %rdi
movl $0x40, %esi
callq 0xd8620
jmp 0x13d475
leaq 0x48(%rsp), %rdi
callq 0xde8c0
jmp 0x13d41a
leaq 0x30(%rsp), %rdi
callq 0xdeca0
movq 0x18(%rsp), %rdi
callq 0xd7180
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x18(%rsp), %rdi
callq 0xd2b60
movq %rax, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xdda00
testb $0x1, %al
jne 0x13d4c8
jmp 0x13d4f9
leaq 0x30(%rsp), %rdi
callq 0xd2d20
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x13d4eb
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x13d4ed
leaq 0x30(%rsp), %rdi
callq 0xd59f0
jmp 0x13d4a4
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
callq 0xd4a40
movq 0x18(%rsp), %rdi
callq 0xd9420
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: SymbolTable::skipScope(int) const
SymbolScope *SymbolTable::skipScope(int4 i) const

{
  SymbolScope *res = curscope;
  while(i>0) {
    if (res->parent == (SymbolScope *)0) return res;
    res = res->parent;
    --i;
  }
  return res;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rsp)
cmpl $0x0, -0x14(%rsp)
jle 0x13d64f
movq -0x20(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x13d635
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x13d659
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movl -0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x13d617
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: SymbolTable::addGlobalSymbol(SleighSymbol*)
void SymbolTable::addGlobalSymbol(SleighSymbol *a)

{
  a->id = symbollist.size();
  symbollist.push_back(a);
  SymbolScope *scope = getGlobalScope();
  a->scopeid = scope->getId();
  SleighSymbol *res = scope->addSymbol(a);
  if (res != a)
    throw SleighError("Duplicate symbol name: "+a->getName());
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xd6170
movq 0x10(%rsp), %rdi
movl %eax, %ecx
movq 0x58(%rsp), %rax
movl %ecx, 0x28(%rax)
leaq 0x58(%rsp), %rsi
callq 0xd2240
movq 0x10(%rsp), %rdi
callq 0xd7210
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0xcf6c0
movl %eax, %ecx
movq 0x58(%rsp), %rax
movl %ecx, 0x2c(%rax)
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0xde8d0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
cmpq 0x58(%rsp), %rax
je 0x13d783
movb $0x1, 0x1b(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, (%rsp)
movq 0x58(%rsp), %rdi
callq 0xd1f90
movq %rax, 0x8(%rsp)
jmp 0x13d701
movq 0x8(%rsp), %rdx
leaq 0x4b7fb(%rip), %rsi     # 0x188f08
leaq 0x28(%rsp), %rdi
callq 0xd7370
jmp 0x13d719
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xd06e0
jmp 0x13d729
movq (%rsp), %rdi
movb $0x0, 0x1b(%rsp)
movq 0x8a72f(%rip), %rsi     # 0x1c7e68
movq 0x8a2e0(%rip), %rdx     # 0x1c7a20
callq 0xe01f0
jmp 0x13d792
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x13d76f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xd4550
testb $0x1, 0x1b(%rsp)
jne 0x13d778
jmp 0x13d781
movq (%rsp), %rdi
callq 0xd5400
jmp 0x13d788
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: SymbolTable::addSymbol(SleighSymbol*)
void SymbolTable::addSymbol(SleighSymbol *a)

{
  a->id = symbollist.size();
  symbollist.push_back(a);
  a->scopeid = curscope->getId();
  SleighSymbol *res = curscope->addSymbol(a);
  if (res != a)
    throw SleighError("Duplicate symbol name: "+a->getName());
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xd6170
movq 0x18(%rsp), %rdi
movl %eax, %ecx
movq 0x58(%rsp), %rax
movl %ecx, 0x28(%rax)
leaq 0x58(%rsp), %rsi
callq 0xd2240
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0xcf6c0
movl %eax, %edx
movq 0x18(%rsp), %rax
movq 0x58(%rsp), %rcx
movl %edx, 0x2c(%rcx)
movq 0x30(%rax), %rdi
movq 0x58(%rsp), %rsi
callq 0xde8d0
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
cmpq 0x58(%rsp), %rax
je 0x13d8c0
movb $0x1, 0x23(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
callq 0xd1f90
movq %rax, 0x10(%rsp)
jmp 0x13d83b
movq 0x10(%rsp), %rdx
leaq 0x4b6c1(%rip), %rsi     # 0x188f08
leaq 0x30(%rsp), %rdi
callq 0xd7370
jmp 0x13d853
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xd06e0
jmp 0x13d864
movq 0x8(%rsp), %rdi
movb $0x0, 0x23(%rsp)
movq 0x8a5f3(%rip), %rsi     # 0x1c7e68
movq 0x8a1a4(%rip), %rdx     # 0x1c7a20
callq 0xe01f0
jmp 0x13d8cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x13d8ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xd4550
testb $0x1, 0x23(%rsp)
jne 0x13d8b4
jmp 0x13d8be
movq 0x8(%rsp), %rdi
callq 0xd5400
jmp 0x13d8c5
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xe0be0
nop