LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryBank::constructValue(unsigned char const*, int, bool)
uintb MemoryBank::constructValue(const uint1 *ptr,int4 size,bool bigendian)

{
  uintb res = 0;

  if (bigendian) {
    for(int4 i=0;i<size;++i) {
      res <<= 8;
      res += (uintb) ptr[i];
    }
  }
  else {
    for(int4 i=size-1;i>=0;--i) {
      res <<= 8;
      res += (uintb) ptr[i];
    }
  }
  return res;
}

// Assembly:
movb %dl, %al
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
andb $0x1, %al
movb %al, -0xd(%rsp)
movq $0x0, -0x18(%rsp)
testb $0x1, -0xd(%rsp)
je 0x164938
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
cmpl -0xc(%rsp), %eax
jge 0x164936
movq -0x18(%rsp), %rax
shlq $0x8, %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movzbl (%rax,%rcx), %eax
addq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x1648f9
jmp 0x16497f
movl -0xc(%rsp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rsp)
cmpl $0x0, -0x20(%rsp)
jl 0x16497d
movq -0x18(%rsp), %rax
shlq $0x8, %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movslq -0x20(%rsp), %rcx
movzbl (%rax,%rcx), %eax
addq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movl -0x20(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x164943
jmp 0x16497f
movq -0x18(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryBank::deconstructValue(unsigned char*, unsigned long, int, bool)
void MemoryBank::deconstructValue(uint1 *ptr,uintb val,int4 size,bool bigendian)

{
  if (bigendian) {
    for(int4 i=size-1;i>=0;--i) {
      ptr[i] = (uint1) (val & 0xff);
      val >>= 8;
    }
  }
  else {
    for(int4 i=0;i<size;++i) {
      ptr[i] = (uint1) (val & 0xff);
      val >>= 8;
    }
  }
}

// Assembly:
movb %cl, %al
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
andb $0x1, %al
movb %al, -0x15(%rsp)
testb $0x1, -0x15(%rsp)
je 0x1649f6
movl -0x14(%rsp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rsp)
cmpl $0x0, -0x1c(%rsp)
jl 0x1649f4
movq -0x10(%rsp), %rax
andq $0xff, %rax
movb %al, %dl
movq -0x8(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rsp), %rax
shrq $0x8, %rax
movq %rax, -0x10(%rsp)
movl -0x1c(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x1649b8
jmp 0x164a3f
movl $0x0, -0x20(%rsp)
movl -0x20(%rsp), %eax
cmpl -0x14(%rsp), %eax
jge 0x164a3d
movq -0x10(%rsp), %rax
andq $0xff, %rax
movb %al, %dl
movq -0x8(%rsp), %rax
movslq -0x20(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rsp), %rax
shrq $0x8, %rax
movq %rax, -0x10(%rsp)
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x1649fe
jmp 0x164a3f
retq
// File: jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryBank::setChunk(unsigned long, int, unsigned char const*)
void MemoryBank::setChunk(uintb offset,int4 size,const uint1 *val)

{
  int4 cursize;
  int4 count;
  uintb pagemask = (uintb) (pagesize - 1);
  uintb offalign;
  int4 skip;

  count = 0;
  while(count < size) {
    cursize = pagesize;
    offalign = offset & ~pagemask;
    skip = 0;
    if (offalign != offset) {
      skip = offset - offalign;
      cursize -= skip;
    }
    if (size - count < cursize)
      cursize = size - count;
    setPage(offalign,val,skip,cursize);
    count += cursize;
    offset += cursize;
    val += cursize;
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movl 0xc(%rax), %eax
subl $0x1, %eax
cltq
movq %rax, 0x18(%rsp)
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0x16546f
movq (%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x38(%rsp), %rax
movq 0x18(%rsp), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x38(%rsp), %rax
je 0x165404
movq 0x38(%rsp), %rax
subq 0x10(%rsp), %rax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %ecx
movl 0x24(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x24(%rsp)
movl 0x34(%rsp), %eax
subl 0x20(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x16541e
movl 0x34(%rsp), %eax
subl 0x20(%rsp), %eax
movl %eax, 0x24(%rsp)
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl 0xc(%rsp), %ecx
movl 0x24(%rsp), %r8d
movq (%rdi), %rax
callq *0x18(%rax)
movl 0x24(%rsp), %eax
addl 0x20(%rsp), %eax
movl %eax, 0x20(%rsp)
movslq 0x24(%rsp), %rax
addq 0x38(%rsp), %rax
movq %rax, 0x38(%rsp)
movl 0x24(%rsp), %ecx
movq 0x28(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
jmp 0x1653a5
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryBank::getChunk(unsigned long, int, unsigned char*) const
void MemoryBank::getChunk(uintb offset,int4 size,uint1 *res) const

{
  int4 cursize,count;
  uintb pagemask = (uintb) (pagesize-1);
  uintb offalign;
  int4 skip;

  count = 0;
  while(count < size) {
    cursize = pagesize;
    offalign = offset & ~pagemask;
    skip = 0;
    if (offalign != offset) {
      skip = offset-offalign;
      cursize -= skip;
    }
    if (size - count < cursize)
      cursize = size - count;
    getPage(offalign,res,skip,cursize);
    count += cursize;
    offset += cursize;
    res += cursize;
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movl 0xc(%rax), %eax
subl $0x1, %eax
cltq
movq %rax, 0x18(%rsp)
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0x16557f
movq (%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x38(%rsp), %rax
movq 0x18(%rsp), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x38(%rsp), %rax
je 0x165514
movq 0x38(%rsp), %rax
subq 0x10(%rsp), %rax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %ecx
movl 0x24(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x24(%rsp)
movl 0x34(%rsp), %eax
subl 0x20(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x16552e
movl 0x34(%rsp), %eax
subl 0x20(%rsp), %eax
movl %eax, 0x24(%rsp)
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl 0xc(%rsp), %ecx
movl 0x24(%rsp), %r8d
movq (%rdi), %rax
callq *0x10(%rax)
movl 0x24(%rsp), %eax
addl 0x20(%rsp), %eax
movl %eax, 0x20(%rsp)
movslq 0x24(%rsp), %rax
addq 0x38(%rsp), %rax
movq %rax, 0x38(%rsp)
movl 0x24(%rsp), %ecx
movq 0x28(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
jmp 0x1654b5
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryImage::find(unsigned long) const
uintb MemoryImage::find(uintb addr) const

{ // Assume that -addr- is word aligned
  uintb res = 0;		// Make sure all bytes start as 0, as load may not fill all bytes
  AddrSpace *spc = getSpace();
  try {
    uint1 *ptr = (uint1 *)&res;
    ptr += (HOST_ENDIAN==1) ? (sizeof(uintb) - getWordSize()) : 0;
    loader->loadFill(ptr,getWordSize(),Address(spc,addr));
  } catch(DataUnavailError &err) {
    // Pages not mapped in the load image, are assumed to be zero
    res = 0;
  }
  if ((HOST_ENDIAN==1) != spc->isBigEndian())
    res = byte_swap(res,getWordSize());
  return res;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq $0x0, 0x60(%rsp)
callq 0xd9c10
movq 0x8(%rsp), %rdi
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rdi), %rax
movq %rax, 0x18(%rsp)
callq 0xdaee0
movl %eax, 0x24(%rsp)
jmp 0x1655e8
movq 0x58(%rsp), %rsi
movq 0x68(%rsp), %rdx
leaq 0x30(%rsp), %rdi
callq 0xd81b0
jmp 0x1655fe
movl 0x24(%rsp), %edx
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq 0x30(%rsp), %rcx
callq *%rax
jmp 0x16561c
jmp 0x165656
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x165698
movq 0x48(%rsp), %rdi
callq 0xd1d20
movq %rax, 0x28(%rsp)
movq $0x0, 0x60(%rsp)
callq 0xdf2c0
movq 0x58(%rsp), %rdi
callq 0xddec0
andb $0x1, %al
movzbl %al, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x16568e
movq 0x8(%rsp), %rdi
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
callq 0xdaee0
movq (%rsp), %rdi
movl %eax, %esi
callq 0xd0ce0
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryImage::getPage(unsigned long, unsigned char*, int, int) const
void MemoryImage::getPage(uintb addr,uint1 *res,int4 skip,int4 size) const

{  // Assume that -addr- is page aligned
  AddrSpace *spc = getSpace();

  try {
    loader->loadFill(res,size,Address(spc,addr+skip));
  }
  catch(DataUnavailError &err) {
    // Pages not mapped in the load image, are assumed to be zero
    for(int4 i=0;i<size;++i)
      res[i] = 0;
  }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movl %ecx, 0x5c(%rsp)
movl %r8d, 0x58(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xd9c10
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x50(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x58(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0x50(%rsp), %rsi
movq 0x68(%rsp), %rdx
movslq 0x5c(%rsp), %rax
addq %rax, %rdx
leaq 0x40(%rsp), %rdi
callq 0xd81b0
jmp 0x165721
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq 0x40(%rsp), %rcx
callq *%rax
jmp 0x16573f
jmp 0x16579d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1657a2
movq 0x38(%rsp), %rdi
callq 0xd1d20
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x58(%rsp), %eax
jge 0x165798
movq 0x60(%rsp), %rax
movslq 0x24(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x165773
callq 0xdf2c0
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryPageOverlay::insert(unsigned long, unsigned long)
void MemoryPageOverlay::insert(uintb addr,uintb val)

{
  uintb pageaddr = addr & ~((uintb)(getPageSize()-1));
  map<uintb,uint1 *>::iterator iter;

  uint1 *pageptr;

  iter = page.find(pageaddr);
  if (iter != page.end())
    pageptr = (*iter).second;
  else {
    pageptr = new uint1[getPageSize()];
    page[pageaddr] = pageptr;
    if (underlie == (MemoryBank *)0) {
      for(int4 i=0;i<getPageSize();++i)
	pageptr[i] = 0;
    }
    else
      underlie->getPage(pageaddr,pageptr,0,getPageSize());
  }
  
  uintb pageoffset = addr & ((uintb)(getPageSize()-1));
  deconstructValue(pageptr + pageoffset,val,getWordSize(),getSpace()->isBigEndian());
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x50(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x48(%rsp)
callq 0xd9f30
movl %eax, %ecx
movq 0x48(%rsp), %rax
subl $0x1, %ecx
movslq %ecx, %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, 0x88(%rsp)
leaq 0x80(%rsp), %rdi
callq 0xd4a60
movq 0x50(%rsp), %rdi
addq $0x20, %rdi
leaq 0x88(%rsp), %rsi
callq 0xd78e0
movq 0x50(%rsp), %rdi
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x80(%rsp)
addq $0x20, %rdi
callq 0xe2df0
movq %rax, 0x68(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xdefd0
testb $0x1, %al
jne 0x1658ca
jmp 0x1658e5
leaq 0x80(%rsp), %rdi
callq 0xcfec0
movq 0x8(%rax), %rax
movq %rax, 0x78(%rsp)
jmp 0x1659ba
movq 0x50(%rsp), %rdi
callq 0xd9f30
movslq %eax, %rdi
callq 0xce140
movq 0x50(%rsp), %rdi
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x40(%rsp)
addq $0x20, %rdi
leaq 0x88(%rsp), %rsi
callq 0xd69c0
movq 0x40(%rsp), %rdx
movq %rax, %rcx
movq 0x50(%rsp), %rax
movq %rdx, (%rcx)
cmpq $0x0, 0x18(%rax)
jne 0x165974
movl $0x0, 0x64(%rsp)
movq 0x50(%rsp), %rdi
movl 0x64(%rsp), %eax
movl %eax, 0x3c(%rsp)
callq 0xd9f30
movl %eax, %ecx
movl 0x3c(%rsp), %eax
cmpl %ecx, %eax
jge 0x165972
movq 0x78(%rsp), %rax
movslq 0x64(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x16593b
jmp 0x1659b8
movq 0x50(%rsp), %rdi
movq 0x18(%rdi), %rax
movq %rax, 0x20(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x30(%rsp)
callq 0xd9f30
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movl %eax, %r8d
movq (%rdi), %rax
xorl %ecx, %ecx
callq *0x10(%rax)
jmp 0x1659ba
movq 0x50(%rsp), %rdi
movq 0x98(%rsp), %rax
movq %rax, (%rsp)
callq 0xd9f30
movq 0x50(%rsp), %rdi
movl %eax, %ecx
movq (%rsp), %rax
subl $0x1, %ecx
movslq %ecx, %rcx
andq %rcx, %rax
movq %rax, 0x58(%rsp)
movq 0x78(%rsp), %rax
addq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xdaee0
movq 0x50(%rsp), %rdi
movl %eax, 0x1c(%rsp)
callq 0xd9c10
movq %rax, %rdi
callq 0xddec0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x1c(%rsp), %edx
movzbl %al, %ecx
andl $0x1, %ecx
callq 0xd2770
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryPageOverlay::find(unsigned long) const
uintb MemoryPageOverlay::find(uintb addr) const

{
  uintb pageaddr = addr & ~((uintb)(getPageSize()-1));
  map<uintb,uint1 *>::const_iterator iter;

  iter = page.find(pageaddr);
  if (iter == page.end()) {
    if (underlie == (MemoryBank *)0)
      return (uintb)0;
    return underlie->find(addr);
  }

  const uint1 *pageptr = (*iter).second;

  uintb pageoffset = addr & ((uintb)(getPageSize()-1));
  return constructValue(pageptr+pageoffset,getWordSize(),getSpace()->isBigEndian());
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0xd9f30
movl %eax, %ecx
movq 0x20(%rsp), %rax
subl $0x1, %ecx
movslq %ecx, %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, 0x58(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xd2730
movq 0x28(%rsp), %rdi
addq $0x20, %rdi
leaq 0x58(%rsp), %rsi
callq 0xd9b10
movq 0x28(%rsp), %rdi
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x50(%rsp)
addq $0x20, %rdi
callq 0xd1b40
movq %rax, 0x40(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xdcfd0
testb $0x1, %al
jne 0x165ae4
jmp 0x165b1c
movq 0x28(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x165afe
movq $0x0, 0x70(%rsp)
jmp 0x165ba0
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x60(%rsp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, 0x70(%rsp)
jmp 0x165ba0
leaq 0x50(%rsp), %rdi
callq 0xdf470
movq 0x28(%rsp), %rdi
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0xd9f30
movq 0x28(%rsp), %rdi
movl %eax, %ecx
movq 0x8(%rsp), %rax
subl $0x1, %ecx
movslq %ecx, %rcx
andq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
addq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xdaee0
movq 0x28(%rsp), %rdi
movl %eax, 0x1c(%rsp)
callq 0xd9c10
movq %rax, %rdi
callq 0xddec0
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
movzbl %al, %edx
andl $0x1, %edx
callq 0xda070
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryPageOverlay::getPage(unsigned long, unsigned char*, int, int) const
void MemoryPageOverlay::getPage(uintb addr,uint1 *res,int4 skip,int4 size) const

{
  map<uintb,uint1 *>::const_iterator iter;

  iter = page.find(addr);
  if (iter == page.end()) {
    if (underlie == (MemoryBank *)0) {
      for(int4 i=0;i<size;++i)
	res[i] = 0;
      return;
    }
    underlie->getPage(addr,res,skip,size);
    return;
  }
  const uint1 *pageptr = (*iter).second;
  memcpy(res,pageptr+skip,size);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
movl %r8d, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xd2730
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
leaq 0x48(%rsp), %rsi
callq 0xd9b10
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
addq $0x20, %rdi
callq 0xd1b40
movq %rax, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xdcfd0
testb $0x1, %al
jne 0x165c2a
jmp 0x165c89
movq 0x8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x165c65
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x38(%rsp), %eax
jge 0x165c63
movq 0x40(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x165c3e
jmp 0x165cb8
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movl 0x3c(%rsp), %ecx
movl 0x38(%rsp), %r8d
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x165cb8
leaq 0x30(%rsp), %rdi
callq 0xdf470
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
movslq 0x3c(%rsp), %rax
addq %rax, %rsi
movslq 0x38(%rsp), %rdx
callq 0xd68e0
addq $0x58, %rsp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryPageOverlay::setPage(unsigned long, unsigned char const*, int, int)
void MemoryPageOverlay::setPage(uintb addr,const uint1 *val,int4 skip,int4 size)

{
  map<uintb,uint1 *>::iterator iter;
  uint1 *pageptr;

  iter = page.find(addr);
  if (iter == page.end()) {
    pageptr = new uint1[getPageSize()];
    page[addr] = pageptr;
    if (size != getPageSize()) {
      if (underlie == (MemoryBank *)0) {
	for(int4 i=0;i<getPageSize();++i)
	  pageptr[i] = 0;
      }
      else
	underlie->getPage(addr,pageptr,0,getPageSize());
    }
  }
  else
    pageptr = (*iter).second;

  memcpy(pageptr+skip,val,size);
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movl %ecx, 0x6c(%rsp)
movl %r8d, 0x68(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xd4a60
movq 0x38(%rsp), %rdi
addq $0x20, %rdi
leaq 0x78(%rsp), %rsi
callq 0xd78e0
movq 0x38(%rsp), %rdi
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x60(%rsp)
addq $0x20, %rdi
callq 0xe2df0
movq %rax, 0x48(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xdd830
testb $0x1, %al
jne 0x165d46
jmp 0x165e34
movq 0x38(%rsp), %rdi
callq 0xd9f30
movslq %eax, %rdi
callq 0xce140
movq 0x38(%rsp), %rdi
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
addq $0x20, %rdi
leaq 0x78(%rsp), %rsi
callq 0xd69c0
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %rdi
movq %rcx, (%rax)
movl 0x68(%rsp), %eax
movl %eax, 0x34(%rsp)
callq 0xd9f30
movl %eax, %ecx
movl 0x34(%rsp), %eax
cmpl %ecx, %eax
je 0x165e32
movq 0x38(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x165def
movl $0x0, 0x44(%rsp)
movq 0x38(%rsp), %rdi
movl 0x44(%rsp), %eax
movl %eax, 0x24(%rsp)
callq 0xd9f30
movl %eax, %ecx
movl 0x24(%rsp), %eax
cmpl %ecx, %eax
jge 0x165ded
movq 0x58(%rsp), %rax
movslq 0x44(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x165db6
jmp 0x165e30
movq 0x38(%rsp), %rdi
movq 0x18(%rdi), %rax
movq %rax, 0x8(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0xd9f30
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl %eax, %r8d
movq (%rdi), %rax
xorl %ecx, %ecx
callq *0x10(%rax)
jmp 0x165e32
jmp 0x165e47
leaq 0x60(%rsp), %rdi
callq 0xcfec0
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
movslq 0x6c(%rsp), %rax
addq %rax, %rdi
movq 0x70(%rsp), %rsi
movslq 0x68(%rsp), %rdx
callq 0xd68e0
addq $0x88, %rsp
retq
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryHashOverlay::insert(unsigned long, unsigned long)
void MemoryHashOverlay::insert(uintb addr,uintb val)

{
  int4 size = address.size();
  uintb offset = (addr>>alignshift) % size;
  for(int4 i=0;i<size;++i) {
    if (address[offset] == addr) { // Address has been seen before
      value[offset] = val;	   // Replace old value
      return;
    }
    else if (address[offset] == (uintb)0xBADBEEF) { // Address not seen before
      address[offset] = addr;			    // Claim this hash slot
      value[offset] = val;			    // Set value
      return;
    }
    offset = (offset + collideskip) % size;
  }
  throw LowlevelError("Memory state hash_table is full");
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x28(%rsp)
addq $0x30, %rdi
callq 0xdd2a0
movq 0x28(%rsp), %rcx
movl %eax, 0x7c(%rsp)
movq 0x88(%rsp), %rax
movl 0x20(%rcx), %ecx
shrq %cl, %rax
movslq 0x7c(%rsp), %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, 0x70(%rsp)
movl $0x0, 0x6c(%rsp)
movl 0x6c(%rsp), %eax
cmpl 0x7c(%rsp), %eax
jge 0x16612e
movq 0x28(%rsp), %rdi
addq $0x30, %rdi
movq 0x70(%rsp), %rsi
callq 0xd05a0
movq (%rax), %rax
cmpq 0x88(%rsp), %rax
jne 0x16608e
movq 0x28(%rsp), %rdi
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
addq $0x48, %rdi
movq 0x70(%rsp), %rsi
callq 0xd05a0
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x1661dc
movq 0x28(%rsp), %rdi
addq $0x30, %rdi
movq 0x70(%rsp), %rsi
callq 0xd05a0
cmpq $0xbadbeef, (%rax)      # imm = 0xBADBEEF
jne 0x1660ff
movq 0x28(%rsp), %rdi
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x30, %rdi
movq 0x70(%rsp), %rsi
callq 0xd05a0
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rdi
movq %rcx, (%rax)
movq 0x80(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x48, %rdi
movq 0x70(%rsp), %rsi
callq 0xd05a0
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x1661dc
jmp 0x166101
movq 0x28(%rsp), %rcx
movq 0x70(%rsp), %rax
addq 0x28(%rcx), %rax
movslq 0x7c(%rsp), %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, 0x70(%rsp)
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0x166033
movb $0x1, 0x33(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, (%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe0c80
movq 0x8(%rsp), %rdx
leaq 0x23a9b(%rip), %rsi     # 0x189bf7
leaq 0x48(%rsp), %rdi
callq 0xe00a0
jmp 0x166168
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xd1ae0
jmp 0x166178
movq (%rsp), %rdi
movb $0x0, 0x33(%rsp)
movq 0x61d08(%rip), %rsi     # 0x1c7e90
movq 0x61a41(%rip), %rdx     # 0x1c7bd0
callq 0xe01f0
jmp 0x1661ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x1661be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xd4550
leaq 0x47(%rsp), %rdi
callq 0xd8ec0
testb $0x1, 0x33(%rsp)
jne 0x1661d1
jmp 0x1661da
movq (%rsp), %rdi
callq 0xd5400
jmp 0x1661e4
addq $0x98, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xe0be0
nop
// File: jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryHashOverlay::find(unsigned long) const
uintb MemoryHashOverlay::find(uintb addr) const

{ // Find address in hash-table, or return find from underlying memory
  int4 size = address.size();
  uintb offset = (addr>>alignshift) % size;
  for(int4 i=0;i<size;++i) {
    if (address[offset] == addr) // Address has been seen before
      return value[offset];
    else if (address[offset] == 0xBADBEEF) // Address not seen before
      break;
    offset = (offset + collideskip) % size;
  }

  // We didn't find the address in the hashtable
  if (underlie == (MemoryBank *)0)
    return (uintb)0;
  return underlie->find(addr);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x30, %rdi
callq 0xdd2a0
movq (%rsp), %rcx
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movl 0x20(%rcx), %ecx
shrq %cl, %rax
movslq 0x1c(%rsp), %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x1662cb
movq (%rsp), %rdi
addq $0x30, %rdi
movq 0x10(%rsp), %rsi
callq 0xd07f0
movq (%rax), %rax
cmpq 0x20(%rsp), %rax
jne 0x166280
movq (%rsp), %rdi
addq $0x48, %rdi
movq 0x10(%rsp), %rsi
callq 0xd07f0
movq (%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x1662f9
movq (%rsp), %rdi
addq $0x30, %rdi
movq 0x10(%rsp), %rsi
callq 0xd07f0
cmpq $0xbadbeef, (%rax)      # imm = 0xBADBEEF
jne 0x16629d
jmp 0x1662cb
jmp 0x16629f
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
addq 0x28(%rcx), %rax
movslq 0x1c(%rsp), %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x16623a
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x1662e1
movq $0x0, 0x30(%rsp)
jmp 0x1662f9
movq (%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryHashOverlay::MemoryHashOverlay(AddrSpace*, int, int, int, MemoryBank*)
MemoryHashOverlay::MemoryHashOverlay(AddrSpace *spc,int4 ws,int4 ps,int4 hashsize,MemoryBank *ul)
  : MemoryBank(spc,ws,ps), address(hashsize,0xBADBEEF), value(hashsize,0)
{
  underlie = ul;
  collideskip = 1023;

  uint4 tmp = ws - 1;
  alignshift = 0;
  while(tmp != 0) {
    alignshift += 1;
    tmp >>= 1;
  }
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movl %edx, 0x84(%rsp)
movl %ecx, 0x80(%rsp)
movl %r8d, 0x7c(%rsp)
movq %r9, 0x70(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x88(%rsp), %rsi
movl 0x84(%rsp), %edx
movl 0x80(%rsp), %ecx
callq 0xd2c70
movq 0x20(%rsp), %rax
movq 0x61c05(%rip), %rcx     # 0x1c7f78
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x30, %rax
movq %rax, 0x28(%rsp)
movslq 0x7c(%rsp), %rax
movq %rax, 0x30(%rsp)
movq $0xbadbeef, 0x68(%rsp)  # imm = 0xBADBEEF
leaq 0x67(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0xd82d0
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rcx
leaq 0x68(%rsp), %rdx
callq 0xd0040
jmp 0x1663c0
leaq 0x67(%rsp), %rdi
callq 0xd88b0
movq 0x20(%rsp), %rax
addq $0x48, %rax
movq %rax, 0x8(%rsp)
movslq 0x7c(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x48(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xd82d0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rcx
leaq 0x48(%rsp), %rdx
callq 0xd0040
jmp 0x166415
leaq 0x47(%rsp), %rdi
callq 0xd88b0
movq 0x20(%rsp), %rax
movq 0x70(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq $0x3ff, 0x28(%rax)      # imm = 0x3FF
movl 0x84(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, 0x40(%rsp)
movl $0x0, 0x20(%rax)
cmpl $0x0, 0x40(%rsp)
je 0x1664a9
movq 0x20(%rsp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movl 0x40(%rsp), %eax
shrl %eax
movl %eax, 0x40(%rsp)
jmp 0x16644a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x67(%rsp), %rdi
callq 0xd88b0
jmp 0x1664b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x47(%rsp), %rdi
callq 0xd88b0
movq 0x28(%rsp), %rdi
callq 0xd0cc0
jmp 0x1664b1
addq $0x98, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xd9660
movq 0x58(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryState::setMemoryBank(MemoryBank*)
void MemoryState::setMemoryBank(MemoryBank *bank)

{
  AddrSpace *spc = bank->getSpace();
  int4 index = spc->getIndex();

  while(index >= memspace.size())
    memspace.push_back((MemoryBank *)0);

  memspace[index] = bank;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0xd9c10
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0xd89c0
movl %eax, 0x2c(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x2c(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
callq 0xd8210
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jb 0x166548
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
movq $0x0, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0xe27f0
jmp 0x166505
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
movslq 0x2c(%rsp), %rsi
callq 0xde4d0
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryState::getMemoryBank(AddrSpace*) const
MemoryBank *MemoryState::getMemoryBank(AddrSpace *spc) const

{
  int4 index = spc->getIndex();
  if (index >= memspace.size())
    return (MemoryBank *)0;
  return memspace[index];
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0xd89c0
movq 0x8(%rsp), %rdi
movl %eax, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
callq 0xd8210
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jb 0x1665d6
movq $0x0, 0x30(%rsp)
jmp 0x1665f1
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movslq 0x1c(%rsp), %rsi
callq 0xd5df0
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryState::setValue(AddrSpace*, unsigned long, int, unsigned long)
void MemoryState::setValue(AddrSpace *spc,uintb off,int4 size,uintb cval)

{
  MemoryBank *mspace = getMemoryBank(spc);
  if (mspace == (MemoryBank *)0)
    throw LowlevelError("Setting value for unmapped memory space: "+spc->getName());
  mspace->setValue(off,size,cval);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movl %ecx, 0x5c(%rsp)
movq %r8, 0x50(%rsp)
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0xd26c0
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x48(%rsp)
jne 0x1666e6
movb $0x1, 0x1b(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rdi
callq 0xd06f0
movq %rax, 0x10(%rsp)
jmp 0x166661
movq 0x10(%rsp), %rdx
leaq 0x235aa(%rip), %rsi     # 0x189c17
leaq 0x28(%rsp), %rdi
callq 0xd7370
jmp 0x166679
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xd1ae0
jmp 0x16668a
movq 0x8(%rsp), %rdi
movb $0x0, 0x1b(%rsp)
movq 0x617f5(%rip), %rsi     # 0x1c7e90
movq 0x6152e(%rip), %rdx     # 0x1c7bd0
callq 0xe01f0
jmp 0x16670d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x1666d1
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 0x1666da
jmp 0x1666e4
movq 0x8(%rsp), %rdi
callq 0xd5400
jmp 0x166703
movq 0x48(%rsp), %rdi
movq 0x60(%rsp), %rsi
movl 0x5c(%rsp), %edx
movq 0x50(%rsp), %rcx
callq 0xd87f0
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryState::getValue(AddrSpace*, unsigned long, int) const
uintb MemoryState::getValue(AddrSpace *spc,uintb off,int4 size) const

{
  if (spc->getType() == IPTR_CONSTANT) return off;
  MemoryBank *mspace = getMemoryBank(spc);
  if (mspace == (MemoryBank *)0)
    throw LowlevelError("Getting value from unmapped memory space: "+spc->getName());
  return mspace->getValue(off,size);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movl %ecx, 0x54(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rdi
callq 0xcfb80
cmpl $0x0, %eax
jne 0x16674f
movq 0x58(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x16682d
movq 0x10(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0xd26c0
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x48(%rsp)
jne 0x166815
movb $0x1, 0x1b(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, (%rsp)
movq 0x60(%rsp), %rdi
callq 0xd06f0
movq %rax, 0x8(%rsp)
jmp 0x166793
movq 0x8(%rsp), %rdx
leaq 0x234a2(%rip), %rsi     # 0x189c41
leaq 0x28(%rsp), %rdi
callq 0xd7370
jmp 0x1667ab
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xd1ae0
jmp 0x1667bb
movq (%rsp), %rdi
movb $0x0, 0x1b(%rsp)
movq 0x616c5(%rip), %rsi     # 0x1c7e90
movq 0x613fe(%rip), %rdx     # 0x1c7bd0
callq 0xe01f0
jmp 0x166841
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x166801
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 0x16680a
jmp 0x166813
movq (%rsp), %rdi
callq 0xd5400
jmp 0x166837
movq 0x48(%rsp), %rdi
movq 0x58(%rsp), %rsi
movl 0x54(%rsp), %edx
callq 0xde150
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryState::getChunk(unsigned char*, AddrSpace*, unsigned long, int) const
void MemoryState::getChunk(uint1 *res,AddrSpace *spc,uintb off,int4 size) const

{
  MemoryBank *mspace = getMemoryBank(spc);
  if (mspace == (MemoryBank *)0)
    throw LowlevelError("Getting chunk from unmapped memory space: "+spc->getName());
  mspace->getChunk(off,size,res);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movl %r8d, 0x54(%rsp)
movq 0x70(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0xd26c0
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x48(%rsp)
jne 0x1669f7
movb $0x1, 0x1b(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rdi
callq 0xd06f0
movq %rax, 0x10(%rsp)
jmp 0x166972
movq 0x10(%rsp), %rdx
leaq 0x232ee(%rip), %rsi     # 0x189c6c
leaq 0x28(%rsp), %rdi
callq 0xd7370
jmp 0x16698a
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xd1ae0
jmp 0x16699b
movq 0x8(%rsp), %rdi
movb $0x0, 0x1b(%rsp)
movq 0x614e4(%rip), %rsi     # 0x1c7e90
movq 0x6121d(%rip), %rdx     # 0x1c7bd0
callq 0xe01f0
jmp 0x166a1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x1669e2
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 0x1669eb
jmp 0x1669f5
movq 0x8(%rsp), %rdi
callq 0xd5400
jmp 0x166a14
movq 0x48(%rsp), %rdi
movq 0x58(%rsp), %rsi
movl 0x54(%rsp), %edx
movq 0x68(%rsp), %rcx
callq 0xd7f50
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xe0be0
nop
// File: jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryState::setChunk(unsigned char const*, AddrSpace*, unsigned long, int)
void MemoryState::setChunk(const uint1 *val,AddrSpace *spc,uintb off,int4 size)

{
  MemoryBank *mspace = getMemoryBank(spc);
  if (mspace == (MemoryBank *)0)
    throw LowlevelError("Setting chunk of unmapped memory space: "+spc->getName());
  mspace->setChunk(off,size,val);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movl %r8d, 0x54(%rsp)
movq 0x70(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0xd26c0
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x48(%rsp)
jne 0x166b07
movb $0x1, 0x1b(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rdi
callq 0xd06f0
movq %rax, 0x10(%rsp)
jmp 0x166a82
movq 0x10(%rsp), %rdx
leaq 0x23209(%rip), %rsi     # 0x189c97
leaq 0x28(%rsp), %rdi
callq 0xd7370
jmp 0x166a9a
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xd1ae0
jmp 0x166aab
movq 0x8(%rsp), %rdi
movb $0x0, 0x1b(%rsp)
movq 0x613d4(%rip), %rsi     # 0x1c7e90
movq 0x6110d(%rip), %rdx     # 0x1c7bd0
callq 0xe01f0
jmp 0x166b2e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x166af2
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 0x166afb
jmp 0x166b05
movq 0x8(%rsp), %rdi
callq 0xd5400
jmp 0x166b24
movq 0x48(%rsp), %rdi
movq 0x58(%rsp), %rsi
movl 0x54(%rsp), %edx
movq 0x68(%rsp), %rcx
callq 0xdb010
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xe0be0
nop
// File: jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorIntSless::evaluateBinary(int, int, unsigned long, unsigned long) const
uintb OpBehaviorIntSless::evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const

{
  uintb res,mask,bit1,bit2;

  if (sizein<=0)
    res = 0;
  else {
    mask = 0x80;
    mask <<= 8*(sizein-1);
    bit1 = in1 & mask;		// Get the sign bits
    bit2 = in2 & mask;
    if (bit1 != bit2)
      res = (bit1 != 0) ? 1 : 0;
    else
      res = (in1 < in2) ? 1 : 0;
  }
  return res;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movq %rcx, -0x18(%rsp)
movq %r8, -0x20(%rsp)
cmpl $0x0, -0x10(%rsp)
jg 0x16b43c
movq $0x0, -0x28(%rsp)
jmp 0x16b4c4
movq $0x80, -0x30(%rsp)
movl -0x10(%rsp), %ecx
subl $0x1, %ecx
shll $0x3, %ecx
movq -0x30(%rsp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x30(%rsp)
movq -0x18(%rsp), %rax
andq -0x30(%rsp), %rax
movq %rax, -0x38(%rsp)
movq -0x20(%rsp), %rax
andq -0x30(%rsp), %rax
movq %rax, -0x40(%rsp)
movq -0x38(%rsp), %rax
cmpq -0x40(%rsp), %rax
je 0x16b4a4
movq -0x38(%rsp), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
cltq
movq %rax, -0x28(%rsp)
jmp 0x16b4c2
movq -0x18(%rsp), %rdx
movq -0x20(%rsp), %rsi
xorl %eax, %eax
movl $0x1, %ecx
cmpq %rsi, %rdx
cmovbl %ecx, %eax
cltq
movq %rax, -0x28(%rsp)
jmp 0x16b4c4
movq -0x28(%rsp), %rax
retq
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorIntZext::recoverInputUnary(int, unsigned long, int) const
uintb OpBehaviorIntZext::recoverInputUnary(int4 sizeout,uintb out,int4 sizein) const

{
  uintb mask = calc_mask(sizein);
  if ((mask&out)!=out)
    throw EvaluationError("Output is not in range of zext operation");
  return out;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movq %rdx, 0x60(%rsp)
movl %ecx, 0x5c(%rsp)
movl 0x5c(%rsp), %edi
callq 0xcfa60
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
andq 0x60(%rsp), %rax
cmpq 0x60(%rsp), %rax
je 0x16b71b
movb $0x1, 0x1b(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x8(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xe0c80
movq 0x10(%rsp), %rdx
leaq 0x1e70d(%rip), %rsi     # 0x189da5
leaq 0x30(%rsp), %rdi
callq 0xe00a0
jmp 0x16b6a4
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xd0cd0
jmp 0x16b6b5
movq 0x8(%rsp), %rdi
movb $0x0, 0x1b(%rsp)
movq 0x5c722(%rip), %rsi     # 0x1c7de8
movq 0x5c36b(%rip), %rdx     # 0x1c7a38
callq 0xe01f0
jmp 0x16b72f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x16b6fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xd4550
leaq 0x2f(%rsp), %rdi
callq 0xd8ec0
testb $0x1, 0x1b(%rsp)
jne 0x16b70f
jmp 0x16b719
movq 0x8(%rsp), %rdi
callq 0xd5400
jmp 0x16b725
movq 0x60(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xe0be0
nop
// File: jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorIntSext::recoverInputUnary(int, unsigned long, int) const
uintb OpBehaviorIntSext::recoverInputUnary(int4 sizeout,uintb out,int4 sizein) const

{
  uintb masklong = calc_mask(sizeout);
  uintb maskshort = calc_mask(sizein);

  if ((out & (maskshort ^ (maskshort>>1))) == 0) { // Positive input
    if ((out & maskshort) != out)
      throw EvaluationError("Output is not in range of sext operation");
  }
  else {			// Negative input
    if ((out & (masklong^maskshort)) != (masklong^maskshort))
      throw EvaluationError("Output is not in range of sext operation");
  }
  return (out&maskshort);
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movl %esi, 0xac(%rsp)
movq %rdx, 0xa0(%rsp)
movl %ecx, 0x9c(%rsp)
movl 0xac(%rsp), %edi
callq 0xcfa60
movq %rax, 0x90(%rsp)
movl 0x9c(%rsp), %edi
callq 0xcfa60
movq %rax, 0x88(%rsp)
movq 0xa0(%rsp), %rax
movq 0x88(%rsp), %rcx
movq 0x88(%rsp), %rdx
shrq %rdx
xorq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
jne 0x16b8c3
movq 0xa0(%rsp), %rax
andq 0x88(%rsp), %rax
cmpq 0xa0(%rsp), %rax
je 0x16b8be
movb $0x1, 0x53(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x18(%rsp)
leaq 0x67(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xe0c80
movq 0x20(%rsp), %rdx
leaq 0x1e599(%rip), %rsi     # 0x189dce
leaq 0x68(%rsp), %rdi
callq 0xe00a0
jmp 0x16b841
movq 0x18(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xd0cd0
jmp 0x16b852
movq 0x18(%rsp), %rdi
movb $0x0, 0x53(%rsp)
movq 0x5c585(%rip), %rsi     # 0x1c7de8
movq 0x5c1ce(%rip), %rdx     # 0x1c7a38
callq 0xe01f0
jmp 0x16b9cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x16b89c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xd4550
leaq 0x67(%rsp), %rdi
callq 0xd8ec0
testb $0x1, 0x53(%rsp)
jne 0x16b8af
jmp 0x16b8b9
movq 0x18(%rsp), %rdi
callq 0xd5400
jmp 0x16b9c3
jmp 0x16b9ab
movq 0xa0(%rsp), %rax
movq 0x90(%rsp), %rcx
xorq 0x88(%rsp), %rcx
andq %rcx, %rax
movq 0x90(%rsp), %rcx
xorq 0x88(%rsp), %rcx
cmpq %rcx, %rax
je 0x16b9a9
movb $0x1, 0x2e(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x8(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xe0c80
movq 0x10(%rsp), %rdx
leaq 0x1e4a8(%rip), %rsi     # 0x189dce
leaq 0x30(%rsp), %rdi
callq 0xe00a0
jmp 0x16b932
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xd0cd0
jmp 0x16b943
movq 0x8(%rsp), %rdi
movb $0x0, 0x2e(%rsp)
movq 0x5c494(%rip), %rsi     # 0x1c7de8
movq 0x5c0dd(%rip), %rdx     # 0x1c7a38
callq 0xe01f0
jmp 0x16b9cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x16b98a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xd4550
leaq 0x2f(%rsp), %rdi
callq 0xd8ec0
testb $0x1, 0x2e(%rsp)
jne 0x16b99d
jmp 0x16b9a7
movq 0x8(%rsp), %rdi
callq 0xd5400
jmp 0x16b9c3
jmp 0x16b9ab
movq 0xa0(%rsp), %rax
andq 0x88(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorIntSub::recoverInputBinary(int, int, unsigned long, int, unsigned long) const
uintb OpBehaviorIntSub::recoverInputBinary(int4 slot,int4 sizeout,uintb out,int4 sizein,uintb in) const

{
  uintb res;
  if (slot==0)
    res = in + out;
  else
    res = in - out;
  res &= calc_mask(sizeout);
  return res;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movl %r8d, 0x1c(%rsp)
movq %r9, 0x10(%rsp)
cmpl $0x0, 0x2c(%rsp)
jne 0x16baf8
movq 0x10(%rsp), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x16bb07
movq 0x10(%rsp), %rax
subq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x28(%rsp), %edi
callq 0xcfa60
andq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorIntScarry::evaluateBinary(int, int, unsigned long, unsigned long) const
uintb OpBehaviorIntScarry::evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const

{
  uintb res = in1 + in2;

  uint4 a = (in1>>(sizein*8-1))&1; // Grab sign bit
  uint4 b = (in2>>(sizein*8-1))&1; // Grab sign bit
  uint4 r = (res>>(sizein*8-1))&1; // Grab sign bit
  
  r ^= a;
  a ^= b;
  a ^= 1;
  r &= a;
  return (uintb)r;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movq %rcx, -0x18(%rsp)
movq %r8, -0x20(%rsp)
movq -0x18(%rsp), %rax
addq -0x20(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
movl -0x10(%rsp), %ecx
shll $0x3, %ecx
subl $0x1, %ecx
movl %ecx, %ecx
shrq %cl, %rax
andq $0x1, %rax
movl %eax, -0x2c(%rsp)
movq -0x20(%rsp), %rax
movl -0x10(%rsp), %ecx
shll $0x3, %ecx
subl $0x1, %ecx
movl %ecx, %ecx
shrq %cl, %rax
andq $0x1, %rax
movl %eax, -0x30(%rsp)
movq -0x28(%rsp), %rax
movl -0x10(%rsp), %ecx
shll $0x3, %ecx
subl $0x1, %ecx
movl %ecx, %ecx
shrq %cl, %rax
andq $0x1, %rax
movl %eax, -0x34(%rsp)
movl -0x2c(%rsp), %eax
xorl -0x34(%rsp), %eax
movl %eax, -0x34(%rsp)
movl -0x30(%rsp), %eax
xorl -0x2c(%rsp), %eax
movl %eax, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
xorl $0x1, %eax
movl %eax, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
andl -0x34(%rsp), %eax
movl %eax, -0x34(%rsp)
movl -0x34(%rsp), %eax
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorIntSborrow::evaluateBinary(int, int, unsigned long, unsigned long) const
uintb OpBehaviorIntSborrow::evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const

{
  uintb res = in1 - in2;

  uint4 a = (in1>>(sizein*8-1))&1; // Grab sign bit
  uint4 b = (in2>>(sizein*8-1))&1; // Grab sign bit
  uint4 r = (res>>(sizein*8-1))&1; // Grab sign bit

  a ^= r;
  r ^= b;
  r ^= 1;
  a &= r;
  return (uintb)a;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movq %rcx, -0x18(%rsp)
movq %r8, -0x20(%rsp)
movq -0x18(%rsp), %rax
subq -0x20(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
movl -0x10(%rsp), %ecx
shll $0x3, %ecx
subl $0x1, %ecx
movl %ecx, %ecx
shrq %cl, %rax
andq $0x1, %rax
movl %eax, -0x2c(%rsp)
movq -0x20(%rsp), %rax
movl -0x10(%rsp), %ecx
shll $0x3, %ecx
subl $0x1, %ecx
movl %ecx, %ecx
shrq %cl, %rax
andq $0x1, %rax
movl %eax, -0x30(%rsp)
movq -0x28(%rsp), %rax
movl -0x10(%rsp), %ecx
shll $0x3, %ecx
subl $0x1, %ecx
movl %ecx, %ecx
shrq %cl, %rax
andq $0x1, %rax
movl %eax, -0x34(%rsp)
movl -0x34(%rsp), %eax
xorl -0x2c(%rsp), %eax
movl %eax, -0x2c(%rsp)
movl -0x30(%rsp), %eax
xorl -0x34(%rsp), %eax
movl %eax, -0x34(%rsp)
movl -0x34(%rsp), %eax
xorl $0x1, %eax
movl %eax, -0x34(%rsp)
movl -0x34(%rsp), %eax
andl -0x2c(%rsp), %eax
movl %eax, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorIntLeft::recoverInputBinary(int, int, unsigned long, int, unsigned long) const
uintb OpBehaviorIntLeft::recoverInputBinary(int4 slot,int4 sizeout,uintb out,int4 sizein,uintb in) const

{
  if (slot!=0)
    return OpBehavior::recoverInputBinary(slot,sizeout,out,sizein,in);
  
  int4 sa = in;
  if (((out<<(8*sizeout-sa))&calc_mask(sizeout))!=0)
    throw EvaluationError("Output is not in range of left shift operation");
  return out >> sa;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movl %esi, 0x84(%rsp)
movl %edx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movl %r8d, 0x74(%rsp)
movq %r9, 0x68(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpl $0x0, 0x84(%rsp)
je 0x16bed7
movq 0x20(%rsp), %rdi
movl 0x84(%rsp), %esi
movl 0x80(%rsp), %edx
movq 0x78(%rsp), %rcx
movl 0x74(%rsp), %r8d
movq 0x68(%rsp), %r9
callq 0xdf110
movq %rax, 0x90(%rsp)
jmp 0x16bfe4
movq 0x68(%rsp), %rax
movl %eax, 0x64(%rsp)
movq 0x78(%rsp), %rax
movl 0x80(%rsp), %ecx
shll $0x3, %ecx
subl 0x64(%rsp), %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, 0x18(%rsp)
movl 0x80(%rsp), %edi
callq 0xcfa60
movq %rax, %rcx
movq 0x18(%rsp), %rax
andq %rcx, %rax
cmpq $0x0, %rax
je 0x16bfd0
movb $0x1, 0x2b(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x8(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xe0c80
movq 0x10(%rsp), %rdx
leaq 0x1deaa(%rip), %rsi     # 0x189df7
leaq 0x40(%rsp), %rdi
callq 0xe00a0
jmp 0x16bf59
movq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xd0cd0
jmp 0x16bf6a
movq 0x8(%rsp), %rdi
movb $0x0, 0x2b(%rsp)
movq 0x5be6d(%rip), %rsi     # 0x1c7de8
movq 0x5bab6(%rip), %rdx     # 0x1c7a38
callq 0xe01f0
jmp 0x16bffe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x16bfb1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xd4550
leaq 0x3f(%rsp), %rdi
callq 0xd8ec0
testb $0x1, 0x2b(%rsp)
jne 0x16bfc4
jmp 0x16bfce
movq 0x8(%rsp), %rdi
callq 0xd5400
jmp 0x16bff4
movq 0x78(%rsp), %rax
movl 0x64(%rsp), %ecx
shrq %cl, %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xe0be0
nop