LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %rax
movslq 0x60(%rdx), %rdx
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdi
subq %rsi, %rdi
sarq $0x3, %rdi
cmpq %rdx, %rdi
jbe 0x73b5f
movq (%rsi,%rdx,8), %rdi
testq %rdi, %rdi
je 0x73b5f
movq %rcx, %rsi
movl %r8d, %edx
movq %rax, %rcx
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x407a0
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
addq $0x38, %r14
leaq 0xe061(%rip), %rsi      # 0x81bd8
movq %rsp, %rdi
movq %r14, %rdx
callq 0x40510
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x2f30f(%rip), %rsi     # 0xa2ea8
movq 0x2f098(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x73bc6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x73bd0
jmp 0x73bd8
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %rax
movslq 0x60(%rdx), %rdx
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdi
subq %rsi, %rdi
sarq $0x3, %rdi
cmpq %rdx, %rdi
jbe 0x73c25
movq (%rsi,%rdx,8), %rdi
testq %rdi, %rdi
je 0x73c25
movq %rcx, %rsi
movl %r8d, %edx
movq %rax, %rcx
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x40e80
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
addq $0x38, %r14
leaq 0xdfc6(%rip), %rsi      # 0x81c03
movq %rsp, %rdi
movq %r14, %rdx
callq 0x40510
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x2f249(%rip), %rsi     # 0xa2ea8
movq 0x2efd2(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x73c8c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x73c96
jmp 0x73c9e
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/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:
testl %edx, %edx
jle 0x75211
movq %rcx, %rax
shll $0x3, %edx
addb $-0x8, %dl
movl $0x80, %esi
movl %edx, %ecx
shlq %cl, %rsi
movq %rsi, %rcx
andq %rax, %rcx
andq %r8, %rsi
cmpq %rsi, %rcx
jne 0x75215
cmpq %r8, %rax
setb %al
jmp 0x7521b
xorl %eax, %eax
jmp 0x7521b
testq %rcx, %rcx
setne %al
movzbl %al, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorIntSext::recoverInputUnary(int, unsigned long, int) const
uintb OpBehaviorIntSdiv::evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const

{
  if (in2 == 0)
    throw EvaluationError("Divide by 0");
  intb num = in1;		// Convert to signed
  intb denom = in2;
  sign_extend(num,8*sizein-1);
  sign_extend(denom,8*sizein-1);
  intb sres = num/denom;	// Do the signed division
  zero_extend(sres,8*sizeout-1); // Cut to appropriate size
  return (uintb)sres;		// Recast as unsigned
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x8, %ecx
movl $0x8, %edi
cmovgel %edi, %ecx
movslq %ecx, %rax
movq 0x2d86d(%rip), %rcx     # 0xa2bd0
movq (%rcx,%rax,8), %rax
movq %rax, %r8
shrq %r8
xorq %rax, %r8
testq %rdx, %r8
je 0x75395
cmpl $0x8, %esi
cmovll %esi, %edi
movslq %edi, %rsi
movq (%rcx,%rsi,8), %rcx
xorq %rax, %rcx
movq %rdx, %rsi
notq %rsi
testq %rsi, %rcx
jne 0x753a8
andq %rdx, %rax
jmp 0x7539d
andq %rdx, %rax
cmpq %rdx, %rax
jne 0x75400
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xc975(%rip), %rsi      # 0x81d3a
leaq 0xc996(%rip), %rdx      # 0x81d62
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x2da39(%rip), %rsi     # 0xa2e28
movq 0x2d842(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
jmp 0x75456
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xc91d(%rip), %rsi      # 0x81d3a
leaq 0xc93e(%rip), %rdx      # 0x81d62
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x2d9e1(%rip), %rsi     # 0xa2e28
movq 0x2d7ea(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
jmp 0x7545a
jmp 0x7547b
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x75474
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x7547e
jmp 0x75486
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq %rcx, %rax
negq %rax
testl %esi, %esi
cmoveq %rcx, %rax
addq %r9, %rax
cmpl $0x8, %edx
movl $0x8, %ecx
cmovll %edx, %ecx
movslq %ecx, %rcx
movq 0x2d6c0(%rip), %rdx     # 0xa2bd0
andq (%rdx,%rcx,8), %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
testl %esi, %esi
jne 0x75623
movq %rcx, %rax
leal (,%rdx,8), %ecx
subl %r9d, %ecx
movq %rax, %rsi
shlq %cl, %rsi
cmpl $0x8, %edx
movl $0x8, %ecx
cmovll %edx, %ecx
movslq %ecx, %rcx
movq 0x2d5c4(%rip), %rdx     # 0xa2bd0
testq %rsi, (%rdx,%rcx,8)
jne 0x75628
movl %r9d, %ecx
shrq %cl, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x41a10
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xc71e(%rip), %rsi      # 0x81d63
leaq 0xc745(%rip), %rdx      # 0x81d91
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x2d7b9(%rip), %rsi     # 0xa2e28
movq 0x2d5c2(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x75698
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x756a2
jmp 0x756aa
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorIntRight::recoverInputBinary(int, int, unsigned long, int, unsigned long) const
uintb OpBehaviorIntRight::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*sizein-sa))!=0)
    throw EvaluationError("Output is not in range of right shift operation");
  return out << sa;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
testl %esi, %esi
jne 0x7570d
movq %rcx, %rax
shll $0x3, %r8d
subl %r9d, %r8d
movq %rcx, %rdx
movl %r8d, %ecx
shrq %cl, %rdx
testq %rdx, %rdx
jne 0x75712
movl %r9d, %ecx
shlq %cl, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x41a10
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xc663(%rip), %rsi      # 0x81d92
leaq 0xc68b(%rip), %rdx      # 0x81dc1
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x2d6cf(%rip), %rsi     # 0xa2e28
movq 0x2d4d8(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x75782
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x7578c
jmp 0x75794
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorIntSright::evaluateBinary(int, int, unsigned long, unsigned long) const
uintb OpBehaviorIntSright::evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const

{
  uintb res;
  if (signbit_negative(in1,sizein)) {
    res = in1 >> in2;
    uintb mask = calc_mask(sizein);
    mask = (mask >> in2) ^ mask;
    res |= mask;
  }
  else {
    res = in1 >> in2;
  }
  return res;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %r8, %r14
movq %rcx, %rbx
movl %edx, %ebp
movq %rcx, %rdi
movl %edx, %esi
callq 0x3f5e0
movl %r14d, %ecx
shrq %cl, %rbx
testb %al, %al
je 0x757e3
cmpl $0x8, %ebp
movl $0x8, %eax
cmovll %ebp, %eax
cltq
movq 0x2d400(%rip), %rcx     # 0xa2bd0
movq (%rcx,%rax,8), %rax
movq %rax, %rdx
movl %r14d, %ecx
shrq %cl, %rdx
xorq %rax, %rdx
orq %rdx, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorIntSright::recoverInputBinary(int, int, unsigned long, int, unsigned long) const
uintb OpBehaviorIntSright::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;
  uintb testval = out>>(sizein*8-sa-1);
  int4 count=0;
  for(int4 i=0;i<=sa;++i) {
    if ((testval&1)!=0) count += 1;
    testval >>= 1;
  }
  if (count != sa+1)
    throw EvaluationError("Output is not in range of right shift operation");
  return out<<sa;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
testl %esi, %esi
jne 0x75842
movq %rcx, %rax
testl %r9d, %r9d
js 0x75827
movl %r9d, %ecx
notl %ecx
leal (%rcx,%r8,8), %ecx
movq %rax, %rdx
shrq %cl, %rdx
leal 0x1(%r9), %esi
xorl %ecx, %ecx
movl %edx, %edi
andl $0x1, %edi
addl %edi, %ecx
shrq %rdx
decl %esi
jne 0x75817
jmp 0x75829
xorl %ecx, %ecx
leal 0x1(%r9), %edx
cmpl %edx, %ecx
jne 0x75847
movl %r9d, %ecx
shlq %cl, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x41a10
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xc52e(%rip), %rsi      # 0x81d92
leaq 0xc556(%rip), %rdx      # 0x81dc1
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x2d59a(%rip), %rsi     # 0xa2e28
movq 0x2d3a3(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x758b7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x758c1
jmp 0x758c9
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorIntRem::evaluateBinary(int, int, unsigned long, unsigned long) const
uintb OpBehaviorIntRem::evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const

{
  if (in2 == 0)
    throw EvaluationError("Remainder by 0");
  
  uintb res = in1 % in2;
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
testq %r8, %r8
je 0x75ab9
movq %rcx, %rax
xorl %edx, %edx
divq %r8
movq %rdx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xc2f8(%rip), %rsi      # 0x81dce
leaq 0xc2ff(%rip), %rdx      # 0x81ddc
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x2d328(%rip), %rsi     # 0xa2e28
movq 0x2d131(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x75b29
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x75b33
jmp 0x75b3b
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorIntSrem::evaluateBinary(int, int, unsigned long, unsigned long) const
uintb OpBehaviorIntSrem::evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const

{
  if (in2 == 0)
    throw EvaluationError("Remainder by 0");
  intb val = in1;
  intb mod = in2;
  sign_extend(val,8*sizein-1);	// Convert inputs to signed values
  sign_extend(mod,8*sizein-1);
  intb sres = in1 % in2;	// Do the remainder
  zero_extend(sres,8*sizeout-1); // Convert back to unsigned
  return (uintb)sres;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
testq %r8, %r8
je 0x75bb3
movq %r8, %r14
movq %rcx, %r15
movl %esi, %ebx
movq %rsp, %rdi
movq %rcx, (%rdi)
leaq 0x28(%rsp), %r12
movq %r8, (%r12)
leal -0x1(,%rdx,8), %ebp
movl %ebp, %esi
callq 0x40550
movq %r12, %rdi
movl %ebp, %esi
callq 0x40550
movq %r15, %rax
xorl %edx, %edx
divq %r14
leaq 0x20(%rsp), %r14
movq %rdx, (%r14)
leal -0x1(,%rbx,8), %esi
movq %r14, %rdi
callq 0x41bd0
movq (%r14), %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xc1fe(%rip), %rsi      # 0x81dce
leaq 0xc205(%rip), %rdx      # 0x81ddc
movq %rsp, %rdi
callq 0x3f8a0
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x2d232(%rip), %rsi     # 0xa2e28
movq 0x2d03b(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x75c1e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x75c28
jmp 0x75c30
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorFloatEqual::evaluateBinary(int, int, unsigned long, unsigned long) const
uintb OpBehaviorFloatEqual::evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const

{
  const FloatFormat *format = translate->getFloatFormat(sizein);
  if (format == (const FloatFormat *)0)
    return OpBehavior::evaluateBinary(sizeout,sizein,in1,in2);

  return format->opEqual(in1,in2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
movl %edx, %esi
callq 0x40460
testq %rax, %rax
je 0x75c89
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x41b00
movq %r15, %rdi
callq 0x3f620
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorFloatNotEqual::evaluateBinary(int, int, unsigned long, unsigned long) const
uintb OpBehaviorFloatNotEqual::evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const

{
  const FloatFormat *format = translate->getFloatFormat(sizein);
  if (format == (const FloatFormat *)0)
    return OpBehavior::evaluateBinary(sizeout,sizein,in1,in2);

  return format->opNotEqual(in1,in2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
movl %edx, %esi
callq 0x40460
testq %rax, %rax
je 0x75cc3
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x40c00
movq %r15, %rdi
callq 0x3f620
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorFloatLess::evaluateBinary(int, int, unsigned long, unsigned long) const
uintb OpBehaviorFloatLess::evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const

{
  const FloatFormat *format = translate->getFloatFormat(sizein);
  if (format == (const FloatFormat *)0)
    return OpBehavior::evaluateBinary(sizeout,sizein,in1,in2);

  return format->opLess(in1,in2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
movl %edx, %esi
callq 0x40460
testq %rax, %rax
je 0x75cfd
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x3fa60
movq %r15, %rdi
callq 0x3f620
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorFloatLessEqual::evaluateBinary(int, int, unsigned long, unsigned long) const
uintb OpBehaviorFloatLessEqual::evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const

{
  const FloatFormat *format = translate->getFloatFormat(sizein);
  if (format == (const FloatFormat *)0)
    return OpBehavior::evaluateBinary(sizeout,sizein,in1,in2);

  return format->opLessEqual(in1,in2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
movl %edx, %esi
callq 0x40460
testq %rax, %rax
je 0x75d37
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x41e50
movq %r15, %rdi
callq 0x3f620
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorFloatNan::evaluateUnary(int, int, unsigned long) const
uintb OpBehaviorFloatNan::evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const

{
  const FloatFormat *format = translate->getFloatFormat(sizein);
  if (format == (const FloatFormat *)0)
    return OpBehavior::evaluateUnary(sizeout,sizein,in1);

  return format->opNan(in1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movl %edx, %esi
callq 0x40460
testq %rax, %rax
je 0x75d6c
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x409d0
movq %r14, %rdi
callq 0x42160
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorFloatAdd::evaluateBinary(int, int, unsigned long, unsigned long) const
uintb OpBehaviorFloatAdd::evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const

{
  const FloatFormat *format = translate->getFloatFormat(sizein);
  if (format == (const FloatFormat *)0)
    return OpBehavior::evaluateBinary(sizeout,sizein,in1,in2);

  return format->opAdd(in1,in2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
movl %edx, %esi
callq 0x40460
testq %rax, %rax
je 0x75da5
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x3f9c0
movq %r15, %rdi
callq 0x3f620
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorFloatDiv::evaluateBinary(int, int, unsigned long, unsigned long) const
uintb OpBehaviorFloatDiv::evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const

{
  const FloatFormat *format = translate->getFloatFormat(sizein);
  if (format == (const FloatFormat *)0)
    return OpBehavior::evaluateBinary(sizeout,sizein,in1,in2);

  return format->opDiv(in1,in2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
movl %edx, %esi
callq 0x40460
testq %rax, %rax
je 0x75ddf
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x40dd0
movq %r15, %rdi
callq 0x3f620
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorFloatSub::evaluateBinary(int, int, unsigned long, unsigned long) const
uintb OpBehaviorFloatSub::evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const

{
  const FloatFormat *format = translate->getFloatFormat(sizein);
  if (format == (const FloatFormat *)0)
    return OpBehavior::evaluateBinary(sizeout,sizein,in1,in2);

  return format->opSub(in1,in2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
movl %edx, %esi
callq 0x40460
testq %rax, %rax
je 0x75e53
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x41020
movq %r15, %rdi
callq 0x3f620
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorFloatNeg::evaluateUnary(int, int, unsigned long) const
uintb OpBehaviorFloatNeg::evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const

{
  const FloatFormat *format = translate->getFloatFormat(sizein);
  if (format == (const FloatFormat *)0)
    return OpBehavior::evaluateUnary(sizeout,sizein,in1);

  return format->opNeg(in1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movl %edx, %esi
callq 0x40460
testq %rax, %rax
je 0x75e88
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x420a0
movq %r14, %rdi
callq 0x42160
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorFloatAbs::evaluateUnary(int, int, unsigned long) const
uintb OpBehaviorFloatAbs::evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const

{
  const FloatFormat *format = translate->getFloatFormat(sizein);
  if (format == (const FloatFormat *)0)
    return OpBehavior::evaluateUnary(sizeout,sizein,in1);

  return format->opAbs(in1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movl %edx, %esi
callq 0x40460
testq %rax, %rax
je 0x75ebc
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x41a70
movq %r14, %rdi
callq 0x42160
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorFloatSqrt::evaluateUnary(int, int, unsigned long) const
uintb OpBehaviorFloatSqrt::evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const

{
  const FloatFormat *format = translate->getFloatFormat(sizein);
  if (format == (const FloatFormat *)0)
    return OpBehavior::evaluateUnary(sizeout,sizein,in1);

  return format->opSqrt(in1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movl %edx, %esi
callq 0x40460
testq %rax, %rax
je 0x75ef0
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40c70
movq %r14, %rdi
callq 0x42160
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorFloatInt2Float::evaluateUnary(int, int, unsigned long) const
uintb OpBehaviorFloatInt2Float::evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const

{
  const FloatFormat *format = translate->getFloatFormat(sizeout);
  if (format == (const FloatFormat *)0)
    return OpBehavior::evaluateUnary(sizeout,sizein,in1);

  return format->opInt2Float(in1,sizein);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movl %edx, %ebx
movq %rdi, %r15
movq 0x10(%rdi), %rdi
callq 0x40460
testq %rax, %rax
je 0x75f25
movq %rax, %rdi
movq %r14, %rsi
movl %ebx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x3f5d0
movq %r15, %rdi
callq 0x42160
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorFloatFloat2Float::evaluateUnary(int, int, unsigned long) const
uintb OpBehaviorFloatFloat2Float::evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const

{
  const FloatFormat *formatout = translate->getFloatFormat(sizeout);
  if (formatout == (const FloatFormat *)0)
    return OpBehavior::evaluateUnary(sizeout,sizein,in1);
  const FloatFormat *formatin = translate->getFloatFormat(sizein);
  if (formatin == (const FloatFormat *)0)
    return OpBehavior::evaluateUnary(sizeout,sizein,in1);

  return formatin->opFloat2Float(in1,*formatout);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r14
movq 0x10(%rdi), %rdi
callq 0x40460
testq %rax, %rax
je 0x75f76
movq %rax, %r15
movq 0x10(%r14), %rdi
movl %ebp, %esi
callq 0x40460
testq %rax, %rax
je 0x75f76
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3f460
movq %r14, %rdi
callq 0x42160
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorFloatTrunc::evaluateUnary(int, int, unsigned long) const
uintb OpBehaviorFloatTrunc::evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const

{
  const FloatFormat *format = translate->getFloatFormat(sizein);
  if (format == (const FloatFormat *)0)
    return OpBehavior::evaluateUnary(sizeout,sizein,in1);

  return format->opTrunc(in1,sizeout);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movl %edx, %esi
callq 0x40460
testq %rax, %rax
je 0x75fab
movq %rax, %rdi
movq %rbx, %rsi
movl %ebp, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x3f1d0
movq %r14, %rdi
callq 0x42160
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorFloatCeil::evaluateUnary(int, int, unsigned long) const
uintb OpBehaviorFloatCeil::evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const

{
  const FloatFormat *format = translate->getFloatFormat(sizein);
  if (format == (const FloatFormat *)0)
    return OpBehavior::evaluateUnary(sizeout,sizein,in1);

  return format->opCeil(in1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movl %edx, %esi
callq 0x40460
testq %rax, %rax
je 0x75fe0
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x406e0
movq %r14, %rdi
callq 0x42160
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorFloatFloor::evaluateUnary(int, int, unsigned long) const
uintb OpBehaviorFloatFloor::evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const

{
  const FloatFormat *format = translate->getFloatFormat(sizein);
  if (format == (const FloatFormat *)0)
    return OpBehavior::evaluateUnary(sizeout,sizein,in1);

  return format->opFloor(in1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movl %edx, %esi
callq 0x40460
testq %rax, %rax
je 0x76014
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x42330
movq %r14, %rdi
callq 0x42160
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/hutch.cpp
// Function: bytePosition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned char*, unsigned long)
uintmax_t bytePosition (string byte, uint1* buf, size_t sz)
{
    static uint1* sbufp = nullptr;
    static uintmax_t spos = 0;  // i.e., s(aved)pos(ition)

    sbufp = (buf != nullptr) ? buf : sbufp;
    spos = (buf != nullptr) ? 0 : spos;

    for (; spos <= sz; ++spos) {
        if (0 == memcmp((uint1*)byte.c_str(), &sbufp[spos], sizeof(uint1))) {
            return spos++;      // Post increment side effect is important here.
        }
    }

    return 0;
}

// Assembly:
xorl %eax, %eax
testq %rsi, %rsi
cmoveq 0x2e3d3(%rip), %rsi     # 0xa4af0
movq %rsi, 0x2e3cc(%rip)     # 0xa4af0
movq 0x2e3cd(%rip), %rcx     # 0xa4af8
movl $0x0, %r8d
cmoveq %rcx, %r8
cmpq %rdx, %r8
ja 0x7675c
movq (%rdi), %rax
movb (%rax), %dil
xorl %eax, %eax
movq %r8, %rcx
cmpb (%rsi,%r8), %dil
je 0x76756
leaq 0x1(%rcx), %r8
cmpq %rdx, %r8
jbe 0x76742
jmp 0x76759
movq %rcx, %rax
incq %rcx
movq %rcx, 0x2e395(%rip)     # 0xa4af8
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/hutch.cpp
// Function: printVarnodeData(std::ostream&, VarnodeData*)
void printVarnodeData (ostream& s, VarnodeData* data)
{
    if (data == nullptr)
        return;

    s << '(' << data->space->getName () << ',';

    const Translate* trans = data->space->getTrans ();

    if (data->space->getName () == "register") {
        s << trans->getRegisterName (data->space, data->offset, data->size);
    } else {
        data->space->printOffset (s, data->offset);
    }
    s << ',' << dec << data->size << ')';
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rsi, %rsi
je 0x76880
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movb $0x28, (%r15)
movl $0x1, %edx
movq %r15, %rsi
callq 0x40b90
movq (%rbx), %rcx
movq 0x38(%rcx), %rsi
movq 0x40(%rcx), %rdx
movq %rax, %rdi
callq 0x40b90
movb $0x2c, (%r15)
leaq 0x8(%rsp), %rsi
movl $0x1, %edx
movq %rax, %rdi
callq 0x40b90
movq (%rbx), %rdi
movq 0x18(%rdi), %r15
addq $0x38, %rdi
leaq 0x917d(%rip), %rsi      # 0x7f94c
callq 0x3f590
testl %eax, %eax
je 0x767e9
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
movq %r14, %rsi
callq 0x40390
jmp 0x76831
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
movl 0x10(%rbx), %r8d
movq (%r15), %rax
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq *0x40(%rax)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r14, %rdi
callq 0x40b90
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x76831
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
leaq 0x8(%rsp), %r15
movb $0x2c, (%r15)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x40b90
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
movl 0x10(%rbx), %esi
movq %rax, %rdi
callq 0x3ffc0
movb $0x29, (%r15)
leaq 0x8(%rsp), %rsi
movl $0x1, %edx
movq %rax, %rdi
callq 0x40b90
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x768aa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/hutch.cpp
// Function: printPcode(PcodeData)
void printPcode (PcodeData pcode)
{
    if (pcode.outvar) {
        printVarnodeData(cout, pcode.outvar);
        cout << " =  ";
    }
    cout << get_opname(pcode.opc);
    for (auto i = 0; i < pcode.isize; ++i) {
        cout << ' ';
        printVarnodeData(cout, &pcode.invar[i]);
    }
    cout << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x768ee
movq 0x2c52e(%rip), %r14     # 0xa2e00
movq %r14, %rdi
callq 0x40b50
leaq 0xb983(%rip), %rsi      # 0x82264
movl $0x4, %edx
movq %r14, %rdi
callq 0x40b90
movl (%rbx), %edi
callq 0x402f0
testq %rax, %rax
je 0x76919
movq %rax, %r14
movq %rax, %rdi
callq 0x3f9e0
movq 0x2c4f4(%rip), %rdi     # 0xa2e00
movq %r14, %rsi
movq %rax, %rdx
callq 0x40b90
jmp 0x76937
movq 0x2c4e0(%rip), %rax     # 0xa2e00
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x41d30
cmpl $0x0, 0x18(%rbx)
jle 0x76983
xorl %r12d, %r12d
movq 0x2c4b9(%rip), %r14     # 0xa2e00
leaq 0xf(%rsp), %r15
xorl %r13d, %r13d
movb $0x20, 0xf(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x40b90
movq 0x10(%rbx), %rsi
addq %r12, %rsi
movq %r14, %rdi
callq 0x40b50
incq %r13
movslq 0x18(%rbx), %rax
addq $0x18, %r12
cmpq %rax, %r13
jl 0x7694f
movq 0x2c476(%rip), %rbx     # 0xa2e00
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x40750
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3f0a0
movq %rax, %rdi
callq 0x3ffd0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/hutch.cpp
// Function: DefaultLoadImage::loadFill(unsigned char*, int, Address const&)
void DefaultLoadImage::loadFill (uint1* ptr, int4 size,
                                 const Address& addr)
{
    auto start = addr.getOffset ();
    auto max = baseaddr + (bufsize - 1);
    for (auto i = 0; i < size; ++i) { // For every byte request
        auto curoff = start + i;      // Calculate offset of byte.
        if ((curoff < this->baseaddr) ||
            (curoff > max)) { // if byte does not fall in window,
            ptr[i] = 0;       // return 0
            continue;
        }
        // Otherwise return data from our window.
        auto diff = curoff - baseaddr;
        ptr[i] = this->buf[(int4)diff];
    }
}

// Assembly:
testl %edx, %edx
jle 0x76a2c
pushq %r14
pushq %rbx
movq 0x8(%rcx), %rax
movq 0x28(%rdi), %rcx
movq 0x38(%rdi), %r8
addq %r8, %rcx
decq %rcx
movl %edx, %edx
movq %rax, %r8
shlq $0x20, %r8
xorl %r9d, %r9d
movabsq $0x100000000, %r10      # imm = 0x100000000
leaq (%rax,%r9), %r14
movq 0x28(%rdi), %rbx
xorl %r11d, %r11d
cmpq %rbx, %r14
jb 0x76a1a
cmpq %rcx, %r14
ja 0x76a1a
movq 0x30(%rdi), %r11
shlq $0x20, %rbx
movq %r8, %r14
subq %rbx, %r14
sarq $0x20, %r14
movb (%r11,%r14), %r11b
movb %r11b, (%rsi,%r9)
incq %r9
addq %r10, %r8
cmpq %r9, %rdx
jne 0x769ef
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/hutch.cpp
// Function: Hutch::preconfigure(int)
void Hutch::preconfigure (int4 cpu_arch)
{
    this->arch = cpu_arch;
    switch (cpu_arch) {
    case IA32:
        docname    = "../../processors/x86/languages/x86.sla";
        cpucontext = { { "addrsize", 1 }, { "opsize", 1 } };

        break;
    default:
        // IA32 is default.
        cpucontext = { { "addrsize", 1 }, { "opsize", 1 } };
        break;
    }

    Element* ast_root = docstorage.openDocument (this->docname)->getRoot ();
    docstorage.registerTag (ast_root);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movl %esi, 0x20(%rdi)
testl %esi, %esi
je 0x76c81
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xb68f(%rip), %rsi      # 0x82290
leaq 0xb690(%rip), %rdx      # 0x82298
movq %rsp, %rdi
callq 0x3f8a0
leaq 0x28(%rsp), %rdi
movl $0x1, -0x8(%rdi)
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xb66d(%rip), %rsi      # 0x82299
leaq 0xb66c(%rip), %rdx      # 0x8229f
callq 0x3f8a0
leaq 0x50(%rsp), %r14
movl $0x1, -0x8(%r14)
leaq 0x150(%rbx), %rdi
movq %rsp, %rsi
movq %r14, %rdx
callq 0x3fc50
movq $-0x50, %r14
movq -0x10(%r15), %rdi
cmpq %rdi, %r15
je 0x76c72
movq (%r15), %rsi
incq %rsi
callq 0x40880
addq $-0x28, %r15
addq $0x28, %r14
jne 0x76c5e
jmp 0x76d27
movq 0x8(%rbx), %rdx
leaq 0xb5dd(%rip), %rcx      # 0x82269
movl $0x26, %r8d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x417d0
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xb5e4(%rip), %rsi      # 0x82290
leaq 0xb5e5(%rip), %rdx      # 0x82298
movq %rsp, %rdi
callq 0x3f8a0
leaq 0x28(%rsp), %rdi
movl $0x1, -0x8(%rdi)
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xb5c2(%rip), %rsi      # 0x82299
leaq 0xb5c1(%rip), %rdx      # 0x8229f
callq 0x3f8a0
leaq 0x50(%rsp), %r14
movl $0x1, -0x8(%r14)
leaq 0x150(%rbx), %rdi
movq %rsp, %rsi
movq %r14, %rdx
callq 0x3fc50
movq $-0x50, %r14
movq -0x10(%r15), %rdi
cmpq %rdi, %r15
je 0x76d1d
movq (%r15), %rsi
incq %rsi
callq 0x40880
addq $-0x28, %r15
addq $0x28, %r14
jne 0x76d09
leaq 0x28(%rbx), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40aa0
movq 0x78(%rax), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x40480
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rsi
movq %r14, %rdi
callq 0x428bb
jmp 0x76d91
jmp 0x76d73
jmp 0x76d8e
movq %rax, %rbx
movq %rsp, %rsi
movq %r14, %rdi
callq 0x42888
jmp 0x76d91
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x76d91
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40880
jmp 0x76d91
movq %rax, %rbx
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/hutch.cpp
// Function: Hutch::initialize(unsigned char const*, unsigned long, unsigned long)
void Hutch::initialize (const uint1* buf, uintb bufsize, uintb begaddr)
{
    this->loader = make_unique<DefaultLoadImage>(begaddr, buf, bufsize);
    this->trans = make_unique<Sleigh>(this->loader.get(), &this->context);
    this->trans->initialize (this->docstorage);

    for (auto [option, setting] : this->cpucontext)
        this->context.setVariableDefault (option, setting);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movl $0x40, %edi
callq 0x40810
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x3fdc0
movq 0x140(%r14), %rdi
movq %r15, 0x140(%r14)
testq %rdi, %rdi
je 0x76df1
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x140(%r14), %r15
leaq 0x70(%r14), %rbx
movl $0x260, %edi            # imm = 0x260
callq 0x40810
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3f140
movq 0x148(%r14), %rdi
movq %r12, 0x148(%r14)
testq %rdi, %rdi
je 0x76e30
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x148(%r14), %r12
leaq 0x28(%r14), %rsi
movq (%r12), %rax
movq %r12, %rdi
callq *0x10(%rax)
movq 0x150(%r14), %r15
movq 0x158(%r14), %r12
cmpq %r12, %r15
je 0x76ea5
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r14
movq %r13, 0x8(%rsp)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x3f8e0
movl 0x20(%r15), %edx
movl %edx, 0x28(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3fa50
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x76e9c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
addq $0x28, %r15
cmpq %r12, %r15
jne 0x76e5b
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x260, %esi            # imm = 0x260
movq %r12, %rdi
jmp 0x76ee2
movq %rax, %rbx
movl $0x40, %esi
movq %r15, %rdi
jmp 0x76ee2
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x76ee7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/hutch.cpp
// Function: Hutch::printInstructionBytes(Instruction const&)
void Hutch::printInstructionBytes (const Instruction& insn)
{
    for (auto i = 0; i < insn.bytelength; ++i) {
        cout << "0x" << hex << (int)insn.raw[i] << " ";
    }
    cout << endl;
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpq $0x0, 0x8(%rsi)
je 0x76fd5
movq %rsi, %rbx
xorl %r13d, %r13d
movq 0x2be87(%rip), %r14     # 0xa2e00
leaq 0xa134(%rip), %r15      # 0x810b4
leaq 0x95b6(%rip), %r12      # 0x8053d
movl $0x2, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x40b90
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x18(%r14,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r14,%rax)
movzbl 0x48(%rbx,%r13), %esi
movq %r14, %rdi
callq 0x41db0
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x40b90
incq %r13
cmpq %r13, 0x8(%rbx)
ja 0x76f87
movq 0x2be24(%rip), %rbx     # 0xa2e00
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x40750
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3f0a0
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3ffd0
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/hutch.cpp
// Function: Hutch::printInstructionBytes(__gnu_cxx::__normal_iterator<Instruction*, std::vector<Instruction, std::allocator<Instruction>>>)
void Hutch::printInstructionBytes (vector<Instruction>::iterator instr)
{
    for (auto i = 0; i < instr->bytelength; ++i) {
        cout << "0x" << hex << (int)instr->raw[i] << " ";
    }
    cout << endl;
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpq $0x0, 0x8(%rsi)
je 0x77085
movq %rsi, %rbx
xorl %r13d, %r13d
movq 0x2bdd7(%rip), %r14     # 0xa2e00
leaq 0xa084(%rip), %r15      # 0x810b4
leaq 0x9506(%rip), %r12      # 0x8053d
movl $0x2, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x40b90
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x18(%r14,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r14,%rax)
movzbl 0x48(%rbx,%r13), %esi
movq %r14, %rdi
callq 0x41db0
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x40b90
incq %r13
cmpq %r13, 0x8(%rbx)
ja 0x77037
movq 0x2bd74(%rip), %rbx     # 0xa2e00
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x40750
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3f0a0
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3ffd0
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/hutch.cpp
// Function: Hutch::disassemble_iter(unsigned long, Hutch_Emit*)
uint Hutch::disassemble_iter(uintb offset, Hutch_Emit* emitter)
{
    uintb baseaddr = this->loader->getBaseAddr ();

    Address addr (this->trans->getDefaultSpace (), baseaddr);
    Address lastaddr (this->trans->getDefaultSpace (),
                      baseaddr + this->loader->getBufferSize ());

    addr = addr + offset;

    if (lastaddr <= addr) {
        // cout << "exceeded last available address\n";
        return 0;
    }
    auto len = 0;

    try {
        len = this->trans->printAssembly(*emitter, addr);
        this->trans->oneInstruction(*emitter, addr);
    } catch (const BadDataError&) {
        len = 0;
        emitter->removeBadInstruction ();
    }

    if (auto e = dynamic_cast<Hutch_Instructions*>(emitter))
        storeRawInstructionBytes(*e->currentinsn);

    return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x140(%rdi), %rax
movq 0x28(%rax), %rdx
movq 0x148(%rdi), %rdi
movq 0xa0(%rdi), %r8
movq 0x38(%rax), %rcx
addq %rdx, %rcx
movslq %esi, %rax
addq %rdx, %rax
movq 0x28(%r8), %rsi
cmpq %rax, %rsi
jae 0x77110
incq %rsi
cqto
idivq %rsi
movq %rdx, %rax
sarq $0x3f, %rax
andq %rsi, %rax
addq %rdx, %rax
movq %r8, 0x8(%rsp)
movq %rax, 0x10(%rsp)
xorl %ebp, %ebp
cmpq %rax, %rcx
jbe 0x77193
leaq 0x8(%r14), %rsi
movq (%rdi), %rax
leaq 0x8(%rsp), %rdx
callq *0x68(%rax)
movl %eax, %ebp
movq 0x148(%rbx), %rdi
movq (%rdi), %rax
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
callq *0x60(%rax)
testq %r14, %r14
je 0x77193
movq 0x2bd25(%rip), %rsi     # 0xa2e78
movq 0x2bc86(%rip), %rdx     # 0xa2de0
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x40b60
testq %rax, %rax
je 0x77193
movq 0x28(%rax), %rdx
movq 0x148(%rbx), %rdi
movq 0xa0(%rdi), %rax
movq (%rdx), %rcx
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movq %rcx, 0x8(%rsi)
addq $0x48, %rdx
callq 0x3f8b0
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
cmpl $0x1, %edx
jne 0x771ca
movq %r15, %rdi
callq 0x3f910
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
callq 0x41aa0
xorl %ebp, %ebp
jmp 0x7714c
movq %rax, %r15
callq 0x41aa0
movq %r15, %rdi
callq 0x41f10
movq %rax, %rdi
callq 0x47736
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/hutch.cpp
// Function: Hutch_Emit::dumpPcode(Address const&, OpCode, VarnodeData*, VarnodeData*, int)
void Hutch_Emit::dumpPcode (Address const& addr, OpCode opc,
                                 VarnodeData* outvar, VarnodeData* vars,
                                 int4 isize)
{
    if (outvar != (VarnodeData*)0) {
        printVarnodeData (cout, outvar);
        cout << " = ";
    }
    cout << get_opname (opc);
    // Possibly check for a code reference or a space reference.
    for (int4 i = 0; i < isize; ++i) {
        cout << ' ';
        printVarnodeData (cout, &vars[i]);
    }
    cout << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r9d, %ebp
movq %r8, %rbx
movl %edx, %r14d
testq %rcx, %rcx
je 0x77420
movq 0x2b9ff(%rip), %r15     # 0xa2e00
movq %r15, %rdi
movq %rcx, %rsi
callq 0x40b50
leaq 0xae8d(%rip), %rsi      # 0x822a0
movl $0x3, %edx
movq %r15, %rdi
callq 0x40b90
movl %r14d, %edi
callq 0x402f0
testq %rax, %rax
je 0x7744c
movq %rax, %r14
movq %rax, %rdi
callq 0x3f9e0
movq 0x2b9c1(%rip), %rdi     # 0xa2e00
movq %r14, %rsi
movq %rax, %rdx
callq 0x40b90
jmp 0x7746a
movq 0x2b9ad(%rip), %rax     # 0xa2e00
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x41d30
testl %ebp, %ebp
jle 0x774a6
movl %ebp, %r12d
movq 0x2b988(%rip), %r14     # 0xa2e00
leaq 0xf(%rsp), %r15
movb $0x20, 0xf(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x40b90
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40b50
addq $0x18, %rbx
decq %r12
jne 0x7747d
movq 0x2b953(%rip), %rbx     # 0xa2e00
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x40750
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3f0a0
movq %rax, %rdi
callq 0x3ffd0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/include/sleigh.hh
// Function: PcodeData::operator==(PcodeData const&)
bool operator==(const PcodeData &Pcode)
    {
        if ((outvar != nullptr) && (Pcode.outvar != nullptr)
            ? (*outvar == *Pcode.outvar) ? true : false
            : (outvar == nullptr) && (Pcode.outvar == nullptr) ? true : false)
        {
            if ((opc == Pcode.opc)
                ? (isize == Pcode.isize) ? true : false
                : false)
            {
                for (auto i = 0; i != isize; ++i) {
                    if (invar[i] != Pcode.invar[i]) {
                        return false;
                    }
                }
                return true;
            }
        }
        return false;
    }

// Assembly:
movq 0x8(%rdi), %rcx
movq 0x8(%rsi), %rax
testq %rcx, %rcx
je 0x78fec
testq %rax, %rax
je 0x79047
movq (%rcx), %rdx
cmpq (%rax), %rdx
jne 0x79047
movq 0x8(%rcx), %rdx
cmpq 0x8(%rax), %rdx
jne 0x79047
movl 0x10(%rcx), %ecx
cmpl 0x10(%rax), %ecx
je 0x78ff1
jmp 0x79047
testq %rax, %rax
jne 0x79047
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x79047
movl 0x18(%rdi), %r8d
cmpl 0x18(%rsi), %r8d
jne 0x79047
movb $0x1, %al
testq %r8, %r8
je 0x79049
movq 0x10(%rdi), %rcx
movq 0x10(%rsi), %rdx
shlq $0x3, %r8
leaq (%r8,%r8,2), %rsi
xorl %edi, %edi
movq (%rcx,%rdi), %r8
cmpq (%rdx,%rdi), %r8
jne 0x79047
movq 0x8(%rcx,%rdi), %r8
cmpq 0x8(%rdx,%rdi), %r8
jne 0x79047
movl 0x10(%rcx,%rdi), %r8d
cmpl 0x10(%rdx,%rdi), %r8d
jne 0x79047
addq $0x18, %rdi
cmpq %rdi, %rsi
jne 0x7901a
jmp 0x79049
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/app/genipareach/genipareach.cpp
// Function: readNextNumber(_IO_FILE*, int)
int readNextNumber(FILE* f, int c) {
	while (!isdigit(c)) {
		c = fgetc(f);
	}
	int num = 0;
	while (isdigit(c)) {
		num = num*10 + (c-'0');
		c = fgetc(f);
	}
	return num;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %eax
movq %rdi, %rbx
leal -0x3a(%rax), %ecx
cmpl $-0xb, %ecx
ja 0x17ad
movq %rbx, %rdi
callq 0x1200
leal -0x3a(%rax), %ecx
cmpl $-0xa, %ecx
jb 0x179d
addl $-0x30, %eax
xorl %r14d, %r14d
leal (%r14,%r14,4), %ecx
leal (%rax,%rcx,2), %r14d
movq %rbx, %rdi
callq 0x1200
addl $-0x30, %eax
cmpl $0xa, %eax
jb 0x17b3
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq