LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movl %esi, 0x74(%rsp)
movl %edx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movl %r8d, 0x64(%rsp)
movq %r9, 0x58(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x74(%rsp)
je 0x16c0b2
movq 0x10(%rsp), %rdi
movl 0x74(%rsp), %esi
movl 0x70(%rsp), %edx
movq 0x68(%rsp), %rcx
movl 0x64(%rsp), %r8d
movq 0x58(%rsp), %r9
callq 0xdf110
movq %rax, 0x80(%rsp)
jmp 0x16c19c
movq 0x58(%rsp), %rax
movl %eax, 0x54(%rsp)
movq 0x68(%rsp), %rax
movl 0x64(%rsp), %ecx
shll $0x3, %ecx
subl 0x54(%rsp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
cmpq $0x0, %rax
je 0x16c188
movb $0x1, 0x1b(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, (%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe0c80
movq 0x8(%rsp), %rdx
leaq 0x1dd1e(%rip), %rsi     # 0x189e26
leaq 0x30(%rsp), %rdi
callq 0xe00a0
jmp 0x16c114
movq (%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xd0cd0
jmp 0x16c124
movq (%rsp), %rdi
movb $0x0, 0x1b(%rsp)
movq 0x5bcb4(%rip), %rsi     # 0x1c7de8
movq 0x5b8fd(%rip), %rdx     # 0x1c7a38
callq 0xe01f0
jmp 0x16c1b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x16c16a
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 0x16c17d
jmp 0x16c186
movq (%rsp), %rdi
callq 0xd5400
jmp 0x16c1ac
movq 0x68(%rsp), %rax
movl 0x54(%rsp), %ecx
shlq %cl, %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl 0x28(%rsp), %esi
callq 0xd0870
testb $0x1, %al
jne 0x16c1ef
jmp 0x16c237
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
shrq %cl, %rax
movq %rax, 0x10(%rsp)
movl 0x28(%rsp), %edi
callq 0xcfa60
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
shrq %cl, %rax
xorq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
orq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x16c249
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
shrq %cl, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
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, 0x10(%rsp)
cmpl $0x0, 0x84(%rsp)
je 0x16c2d7
movq 0x10(%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 0x16c420
movq 0x68(%rsp), %rax
movl %eax, 0x64(%rsp)
movq 0x78(%rsp), %rax
movl 0x74(%rsp), %ecx
shll $0x3, %ecx
subl 0x64(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, 0x58(%rsp)
movl $0x0, 0x54(%rsp)
movl $0x0, 0x50(%rsp)
movl 0x50(%rsp), %eax
cmpl 0x64(%rsp), %eax
jg 0x16c34b
movq 0x58(%rsp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x16c331
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
movq 0x58(%rsp), %rax
shrq %rax
movq %rax, 0x58(%rsp)
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x16c30d
movl 0x54(%rsp), %eax
movl 0x64(%rsp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
je 0x16c40c
movb $0x1, 0x1b(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, (%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe0c80
movq 0x8(%rsp), %rdx
leaq 0x1da9a(%rip), %rsi     # 0x189e26
leaq 0x30(%rsp), %rdi
callq 0xe00a0
jmp 0x16c398
movq (%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xd0cd0
jmp 0x16c3a8
movq (%rsp), %rdi
movb $0x0, 0x1b(%rsp)
movq 0x5ba30(%rip), %rsi     # 0x1c7de8
movq 0x5b679(%rip), %rdx     # 0x1c7a38
callq 0xe01f0
jmp 0x16c43a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x16c3ee
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 0x16c401
jmp 0x16c40a
movq (%rsp), %rdi
callq 0xd5400
jmp 0x16c430
movq 0x78(%rsp), %rax
movl 0x64(%rsp), %ecx
shlq %cl, %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xe0be0
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/opbehavior.cc
// Function: OpBehaviorIntSdiv::evaluateBinary(int, int, unsigned long, unsigned long) 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movl %edx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq %r8, 0x68(%rsp)
cmpq $0x0, 0x68(%rsp)
jne 0x16c672
movb $0x1, 0x33(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x8(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xe0c80
movq 0x10(%rsp), %rdx
leaq 0x1d86a(%rip), %rsi     # 0x189e56
leaq 0x48(%rsp), %rdi
callq 0xe00a0
jmp 0x16c5f8
movq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xd0cd0
jmp 0x16c609
movq 0x8(%rsp), %rdi
movb $0x0, 0x33(%rsp)
movq 0x5b7ce(%rip), %rsi     # 0x1c7de8
movq 0x5b417(%rip), %rdx     # 0x1c7a38
callq 0xe01f0
jmp 0x16c6ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x16c653
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 0x16c666
jmp 0x16c670
movq 0x8(%rsp), %rdi
callq 0xd5400
jmp 0x16c6e0
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x78(%rsp), %esi
shll $0x3, %esi
subl $0x1, %esi
leaq 0x28(%rsp), %rdi
callq 0xd74e0
movl 0x78(%rsp), %esi
shll $0x3, %esi
subl $0x1, %esi
leaq 0x20(%rsp), %rdi
callq 0xd74e0
movq 0x28(%rsp), %rax
cqto
idivq 0x20(%rsp)
movq %rax, 0x18(%rsp)
movl 0x7c(%rsp), %esi
shll $0x3, %esi
subl $0x1, %esi
leaq 0x18(%rsp), %rdi
callq 0xdfa80
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xe0be0
nopw (%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movl %edx, 0x68(%rsp)
movq %rcx, 0x60(%rsp)
movq %r8, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0x16c7c9
movb $0x1, 0x23(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x8(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xe0c80
movq 0x10(%rsp), %rdx
leaq 0x1d71c(%rip), %rsi     # 0x189e62
leaq 0x38(%rsp), %rdi
callq 0xe00a0
jmp 0x16c752
movq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xd0cd0
jmp 0x16c763
movq 0x8(%rsp), %rdi
movb $0x0, 0x23(%rsp)
movq 0x5b674(%rip), %rsi     # 0x1c7de8
movq 0x5b2bd(%rip), %rdx     # 0x1c7a38
callq 0xe01f0
jmp 0x16c7f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x16c7aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xd4550
leaq 0x37(%rsp), %rdi
callq 0xd8ec0
testb $0x1, 0x23(%rsp)
jne 0x16c7bd
jmp 0x16c7c7
movq 0x8(%rsp), %rdi
callq 0xd5400
jmp 0x16c7e6
movq 0x60(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x58(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xe0be0
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movl %edx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq %r8, 0x68(%rsp)
cmpq $0x0, 0x68(%rsp)
jne 0x16c8d2
movb $0x1, 0x33(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x8(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xe0c80
movq 0x10(%rsp), %rdx
leaq 0x1d616(%rip), %rsi     # 0x189e62
leaq 0x48(%rsp), %rdi
callq 0xe00a0
jmp 0x16c858
movq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xd0cd0
jmp 0x16c869
movq 0x8(%rsp), %rdi
movb $0x0, 0x33(%rsp)
movq 0x5b56e(%rip), %rsi     # 0x1c7de8
movq 0x5b1b7(%rip), %rdx     # 0x1c7a38
callq 0xe01f0
jmp 0x16c94c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x16c8b3
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 0x16c8c6
jmp 0x16c8d0
movq 0x8(%rsp), %rdi
callq 0xd5400
jmp 0x16c942
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x78(%rsp), %esi
shll $0x3, %esi
subl $0x1, %esi
leaq 0x28(%rsp), %rdi
callq 0xd74e0
movl 0x78(%rsp), %esi
shll $0x3, %esi
subl $0x1, %esi
leaq 0x20(%rsp), %rdi
callq 0xd74e0
movq 0x70(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x68(%rsp)
movq %rdx, 0x18(%rsp)
movl 0x7c(%rsp), %esi
shll $0x3, %esi
subl $0x1, %esi
leaq 0x18(%rsp), %rdi
callq 0xdfa80
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rax), %rdi
movl 0x20(%rsp), %esi
callq 0xd6c00
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x16ca70
movq (%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0xd09c0
movq %rax, 0x30(%rsp)
jmp 0x16ca89
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xdf4c0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rax), %rdi
movl 0x20(%rsp), %esi
callq 0xd6c00
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x16cb00
movq (%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0xd09c0
movq %rax, 0x30(%rsp)
jmp 0x16cb19
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xda080
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rax), %rdi
movl 0x20(%rsp), %esi
callq 0xd6c00
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x16cc20
movq (%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0xd09c0
movq %rax, 0x30(%rsp)
jmp 0x16cc39
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xe0790
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rax), %rdi
movl 0x20(%rsp), %esi
callq 0xd6c00
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x16cca8
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rcx
callq 0xe1ae0
movq %rax, 0x30(%rsp)
jmp 0x16ccbc
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xd8fb0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rax), %rdi
movl 0x20(%rsp), %esi
callq 0xd6c00
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x16cd30
movq (%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0xd09c0
movq %rax, 0x30(%rsp)
jmp 0x16cd49
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xd2160
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rax), %rdi
movl 0x20(%rsp), %esi
callq 0xd6c00
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x16cdc0
movq (%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0xd09c0
movq %rax, 0x30(%rsp)
jmp 0x16cdd9
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xdab20
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rax), %rdi
movl 0x20(%rsp), %esi
callq 0xd6c00
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x16cee0
movq (%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0xd09c0
movq %rax, 0x30(%rsp)
jmp 0x16cef9
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xdba60
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rax), %rdi
movl 0x20(%rsp), %esi
callq 0xd6c00
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x16cf68
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rcx
callq 0xe1ae0
movq %rax, 0x30(%rsp)
jmp 0x16cf7c
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xe1530
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rax), %rdi
movl 0x20(%rsp), %esi
callq 0xd6c00
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x16cfe8
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rcx
callq 0xe1ae0
movq %rax, 0x30(%rsp)
jmp 0x16cffc
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xdf270
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rax), %rdi
movl 0x24(%rsp), %esi
callq 0xd6c00
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x16d0e8
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rcx
callq 0xe1ae0
movq %rax, 0x30(%rsp)
jmp 0x16d100
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x20(%rsp), %edx
callq 0xd07e0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rax), %rdi
movl 0x24(%rsp), %esi
callq 0xd6c00
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x16d166
movq (%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rcx
callq 0xe1ae0
movq %rax, 0x30(%rsp)
jmp 0x16d1ba
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x20(%rsp), %esi
callq 0xd6c00
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x16d1a1
movq (%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rcx
callq 0xe1ae0
movq %rax, 0x30(%rsp)
jmp 0x16d1ba
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xcff40
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rax), %rdi
movl 0x20(%rsp), %esi
callq 0xd6c00
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x16d228
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rcx
callq 0xe1ae0
movq %rax, 0x30(%rsp)
jmp 0x16d240
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x24(%rsp), %edx
callq 0xce9a0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rax), %rdi
movl 0x20(%rsp), %esi
callq 0xd6c00
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x16d2a8
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rcx
callq 0xe1ae0
movq %rax, 0x30(%rsp)
jmp 0x16d2bc
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xd7c10
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rax), %rdi
movl 0x20(%rsp), %esi
callq 0xd6c00
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x16d328
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rcx
callq 0xe1ae0
movq %rax, 0x30(%rsp)
jmp 0x16d33c
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xe2630
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x17057c
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x170588
movq 0x6266d(%rip), %rax     # 0x1d2bf0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x6265c(%rip)     # 0x1d2bf0
cmpq $0x0, 0x20(%rsp)
je 0x1705a4
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x1705af
movq 0x6264d(%rip), %rax     # 0x1d2bf8
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x6263e(%rip)     # 0x1d2bf8
movq 0x62637(%rip), %rax     # 0x1d2bf8
cmpq 0x18(%rsp), %rax
ja 0x170627
movq 0x10(%rsp), %rdi
callq 0xd1d80
movq %rax, %rdi
movq 0x62614(%rip), %rsi     # 0x1d2bf0
addq 0x62615(%rip), %rsi     # 0x1d2bf8
movl $0x1, %edx
callq 0xd2390
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x170611
movq 0x625fc(%rip), %rax     # 0x1d2bf8
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x625ee(%rip)     # 0x1d2bf8
movq %rax, 0x30(%rsp)
jmp 0x170630
jmp 0x170613
movq 0x625de(%rip), %rax     # 0x1d2bf8
addq $0x1, %rax
movq %rax, 0x625d3(%rip)     # 0x1d2bf8
jmp 0x1705ba
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0x17065b
jmp 0x170789
movq 0x60(%rsp), %rdi
movl $0x28, %esi
callq 0xda0c0
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rax
movq (%rax), %rdi
callq 0xd06f0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0xd7350
movq %rax, %rdi
movl $0x2c, %esi
callq 0xda0c0
movq 0x58(%rsp), %rax
movq (%rax), %rdi
callq 0xdf7e0
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq (%rax), %rdi
callq 0xd06f0
movq %rax, %rdi
leaq 0x169f8(%rip), %rsi     # 0x1870b7
callq 0xe30f0
testb $0x1, %al
jne 0x1706ca
jmp 0x170733
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movl 0x10(%rax), %r8d
movq (%rsi), %rax
movq 0x40(%rax), %rax
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq *%rax
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xd7350
jmp 0x17070d
leaq 0x30(%rsp), %rdi
callq 0xd4550
jmp 0x17074e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xd4550
jmp 0x17078e
movq 0x58(%rsp), %rax
movq (%rax), %rdi
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rdx
callq 0xd68f0
movq 0x60(%rsp), %rdi
movl $0x2c, %esi
callq 0xda0c0
movq %rax, %rdi
movq 0x57631(%rip), %rsi     # 0x1c7d98
callq 0xd1180
movq %rax, %rdi
movq 0x58(%rsp), %rax
movl 0x10(%rax), %esi
callq 0xdbce0
movq %rax, %rdi
movl $0x29, %esi
callq 0xda0c0
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xe0be0
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, (%rsp)
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x8(%rdi)
je 0x1707db
movq (%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x57605(%rip), %rdi     # 0x1c7dc8
callq 0xd9950
movq 0x575f9(%rip), %rdi     # 0x1c7dc8
leaq 0x19b32(%rip), %rsi     # 0x18a308
callq 0xd8300
movq (%rsp), %rax
movl (%rax), %edi
callq 0xd64a0
movq %rax, %rsi
movq 0x575d8(%rip), %rdi     # 0x1c7dc8
callq 0xd8300
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x18(%rcx), %eax
jge 0x170848
movq 0x575b7(%rip), %rdi     # 0x1c7dc8
movl $0x20, %esi
callq 0xda0c0
movq (%rsp), %rax
movq 0x10(%rax), %rsi
movslq 0xc(%rsp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rsi
movq 0x57592(%rip), %rdi     # 0x1c7dc8
callq 0xd9950
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1707fd
movq 0x57579(%rip), %rdi     # 0x1c7dc8
movq 0x5726a(%rip), %rsi     # 0x1c7ac0
callq 0xd8a20
addq $0x18, %rsp
retq
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0xe03b0
movq 0x8(%rsp), %rcx
movq %rax, 0x30(%rsp)
movq 0x28(%rcx), %rax
movq 0x38(%rcx), %rcx
subq $0x1, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x170938
movq 0x8(%rsp), %rcx
movq 0x30(%rsp), %rax
movslq 0x24(%rsp), %rdx
addq %rdx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x28(%rcx), %rax
jb 0x1708e9
movq 0x18(%rsp), %rax
cmpq 0x28(%rsp), %rax
jbe 0x1708f9
movq 0x48(%rsp), %rax
movslq 0x24(%rsp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x170928
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
subq 0x28(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rcx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq 0x48(%rsp), %rax
movslq 0x24(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x1708b1
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rcx, 0x98(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x90(%rsp), %rdi
leaq 0x98(%rsp), %rsi
leaq 0xa8(%rsp), %rdx
leaq 0xa0(%rsp), %rcx
callq 0xe1270
movq 0x10(%rsp), %rdi
addq $0x140, %rdi            # imm = 0x140
leaq 0x90(%rsp), %rsi
callq 0xdc480
leaq 0x90(%rsp), %rdi
callq 0xdf870
movq 0x10(%rsp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0xce280
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x80(%rsp)
addq $0x70, %rax
movq %rax, 0x78(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x78(%rsp), %rdx
callq 0xd50b0
movq 0x10(%rsp), %rdi
addq $0x148, %rdi            # imm = 0x148
leaq 0x88(%rsp), %rsi
callq 0xde300
leaq 0x88(%rsp), %rdi
callq 0xd0850
movq 0x10(%rsp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0xddcb0
movq 0x10(%rsp), %rsi
movq %rax, %rdi
addq $0x28, %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x10(%rsp), %rax
addq $0x150, %rax            # imm = 0x150
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0xcf2d0
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rdi
callq 0xdc700
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xd5750
testb $0x1, %al
jne 0x170fc2
jmp 0x17104b
leaq 0x68(%rsp), %rdi
callq 0xdb3b0
movq %rax, %rsi
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xda880
movq 0x8(%rsp), %rdi
callq 0xd1ad0
movq 0x8(%rsp), %rdi
movq %rax, 0x30(%rsp)
callq 0xe0210
movq 0x10(%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x70, %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rax
movl (%rax), %edx
callq 0xd2400
jmp 0x171018
leaq 0x38(%rsp), %rdi
callq 0xd4f90
leaq 0x68(%rsp), %rdi
callq 0xd7c60
jmp 0x170faa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xd4f90
jmp 0x171053
addq $0xb8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movslq 0x4(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x1711eb
movq 0x56c2b(%rip), %rdi     # 0x1c7dc8
leaq 0x17db0(%rip), %rsi     # 0x188f54
callq 0xd8300
movq %rax, %rdi
movq 0x56e15(%rip), %rsi     # 0x1c7fc8
callq 0xd1180
movq %rax, %rdi
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movzbl 0x48(%rax,%rcx), %esi
callq 0xe03e0
movq %rax, %rdi
leaq 0x17360(%rip), %rsi     # 0x188539
callq 0xd8300
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x171186
movq 0x56bd6(%rip), %rdi     # 0x1c7dc8
movq 0x568c7(%rip), %rsi     # 0x1c7ac0
callq 0xd8a20
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movslq 0x14(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xd8060
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq 0x8(%rcx), %rax
jae 0x1712aa
movq 0x56b79(%rip), %rdi     # 0x1c7dc8
leaq 0x17cfe(%rip), %rsi     # 0x188f54
callq 0xd8300
movq %rax, %rdi
movq 0x56d63(%rip), %rsi     # 0x1c7fc8
callq 0xd1180
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0xd8060
movq (%rsp), %rdi
movslq 0x14(%rsp), %rcx
movzbl 0x48(%rax,%rcx), %esi
callq 0xe03e0
movq %rax, %rdi
leaq 0x172a4(%rip), %rsi     # 0x188539
callq 0xd8300
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x171226
movq 0x56b17(%rip), %rdi     # 0x1c7dc8
movq 0x56808(%rip), %rsi     # 0x1c7ac0
callq 0xd8a20
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x171acd
movq 0x18(%rsp), %rsi
movq 0x56313(%rip), %rdi     # 0x1c7dc8
callq 0xd9950
movq 0x56307(%rip), %rdi     # 0x1c7dc8
leaq 0x1887c(%rip), %rsi     # 0x18a344
callq 0xd8300
movl 0x24(%rsp), %edi
callq 0xd64a0
movq %rax, %rsi
movq 0x562e8(%rip), %rdi     # 0x1c7dc8
callq 0xd8300
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x171b32
movq 0x562ca(%rip), %rdi     # 0x1c7dc8
movl $0x20, %esi
callq 0xda0c0
movq 0x10(%rsp), %rsi
movslq 0x8(%rsp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rsi
movq 0x562a8(%rip), %rdi     # 0x1c7dc8
callq 0xd9950
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x171aed
movq 0x5628f(%rip), %rdi     # 0x1c7dc8
movq 0x55f80(%rip), %rsi     # 0x1c7ac0
callq 0xd8a20
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/hutch.cpp
// Function: Hutch_Instructions::removeBadInstruction()
void Hutch_Instructions::removeBadInstruction ()
{
    auto after = instructions.erase(current());
    auto index = distance(instructions.begin(), after);
    if (after == instructions.end()) {
        currentinsn = instructions.data() + index - 1;
    } else {
        currentinsn = instructions.data() + index;
    }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
callq 0xe08f0
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xd0230
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xd93c0
movq 0x10(%rsp), %rdi
movq %rax, 0x48(%rsp)
addq $0x10, %rdi
callq 0xdbd10
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xdd750
movq 0x10(%rsp), %rdi
movq %rax, 0x30(%rsp)
addq $0x10, %rdi
callq 0xd44c0
movq %rax, 0x18(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xda640
testb $0x1, %al
jne 0x172ea5
jmp 0x172ece
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0xd66a0
movq %rax, %rcx
movq 0x10(%rsp), %rax
imulq $0x58, 0x30(%rsp), %rdx
addq %rdx, %rcx
addq $-0x58, %rcx
movq %rcx, 0x28(%rax)
jmp 0x172ef1
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0xd66a0
movq %rax, %rcx
movq 0x10(%rsp), %rax
imulq $0x58, 0x30(%rsp), %rdx
addq %rdx, %rcx
movq %rcx, 0x28(%rax)
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/include/hutch.hpp
// Function: Instruction::Instruction(Instruction const&)
Instruction (const Instruction& other) :
        address (other.address), bytelength (other.bytelength),
        assembly (other.assembly)
    {
        for (auto i : other.pcode)
            pcode.push_back (PcodeData (i));
        for (auto i = 0; i < MAX_INSN_LEN; ++i)
            raw[i] = other.raw[i];
    }

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0xa8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rdi)
movq 0xa8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
movq %rdi, 0x10(%rsp)
movq 0xa8(%rsp), %rsi
addq $0x10, %rsi
callq 0xd2230
movq 0x20(%rsp), %rdi
addq $0x30, %rdi
movq %rdi, 0x18(%rsp)
callq 0xe28f0
movq 0x20(%rsp), %rax
addq $0x48, %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, 0x28(%rsp)
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
movb $0x0, (%rax)
addq $0x1, %rax
cmpq %rcx, %rax
movq %rax, 0x30(%rsp)
jne 0x176129
movq 0xa8(%rsp), %rax
addq $0x30, %rax
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rdi
callq 0xda610
movq %rax, 0x98(%rsp)
movq 0xa0(%rsp), %rdi
callq 0xd4b50
movq %rax, 0x90(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xdaa40
testb $0x1, %al
jne 0x1761a0
jmp 0x176221
leaq 0x98(%rsp), %rdi
callq 0xdab80
movq %rax, %rsi
leaq 0x70(%rsp), %rdi
callq 0xd2a10
jmp 0x1761bc
movq 0x20(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xd2a10
jmp 0x1761db
movq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xd1700
jmp 0x1761ec
jmp 0x1761ee
leaq 0x98(%rsp), %rdi
callq 0xe07f0
jmp 0x176182
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
callq 0xdeb10
movq 0x10(%rsp), %rdi
callq 0xd4550
jmp 0x176264
movl $0x0, 0x3c(%rsp)
cmpl $0x10, 0x3c(%rsp)
jge 0x17625c
movq 0x20(%rsp), %rax
movq 0xa8(%rsp), %rcx
movslq 0x3c(%rsp), %rdx
movb 0x48(%rcx,%rdx), %dl
movslq 0x3c(%rsp), %rcx
movb %dl, 0x48(%rax,%rcx)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x176229
addq $0xb8, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0xe0be0
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x8(%rax)
je 0x177c3c
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x177c3c
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xdc0b0
testb $0x1, %al
jne 0x177c26
jmp 0x177c31
movb $0x1, %al
testb $0x1, %al
jne 0x177c69
jmp 0x177d09
xorl %eax, %eax
testb $0x1, %al
jne 0x177c69
jmp 0x177d09
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x177c5e
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x177c5e
movb $0x1, %al
testb $0x1, %al
jne 0x177c69
jmp 0x177d09
xorl %eax, %eax
testb $0x1, %al
jne 0x177c69
jmp 0x177d09
movq (%rsp), %rax
movl (%rax), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jne 0x177c99
movq (%rsp), %rax
movl 0x18(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jne 0x177c91
movb $0x1, %al
testb $0x1, %al
jne 0x177ca1
jmp 0x177d07
xorl %eax, %eax
testb $0x1, %al
jne 0x177ca1
jmp 0x177d07
xorl %eax, %eax
testb $0x1, %al
jne 0x177ca1
jmp 0x177d07
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x18(%rcx), %eax
je 0x177d00
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movslq 0xc(%rsp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
movslq 0xc(%rsp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rsi
callq 0xe24a0
testb $0x1, %al
jne 0x177cea
jmp 0x177cf1
movb $0x0, 0x27(%rsp)
jmp 0x177d0e
jmp 0x177cf3
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x177ca9
movb $0x1, 0x27(%rsp)
jmp 0x177d0e
jmp 0x177d09
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x1100
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1385
jmp 0x1393
movq -0x8(%rbp), %rdi
callq 0x1210
movl %eax, -0xc(%rbp)
jmp 0x136f
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %edi
callq 0x1100
cmpl $0x0, %eax
je 0x13c4
imull $0xa, -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x30, %ecx
addl %ecx, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1210
movl %eax, -0xc(%rbp)
jmp 0x139a
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/app/genipareach/genipareach.cpp
// Function: addClauses(void*, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&, int)
void addClauses(void* solver, const vector<vector<int> >& clauses, int variableOffset) {
	for (size_t cid = 0; cid < clauses.size(); cid++) {
		if (clauses[cid].size() > 0) {
			for (size_t lid = 0; lid < clauses[cid].size(); lid++) {
				int lit = clauses[cid][lid];
				if (lit > 0) {
					ipasir_add(solver, lit+variableOffset);
					//printf("added %d\n", lit+variableOffset);
				} else {
					ipasir_add(solver, lit-variableOffset);
					//printf("added %d\n", lit-variableOffset);
				}
			}
			ipasir_add(solver, 0);
			//printf("added %d\n", 0);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ca0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x16ae
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1cd0
movq %rax, %rdi
callq 0x1cf0
cmpq $0x0, %rax
jbe 0x169b
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1cd0
movq %rax, %rdi
callq 0x1cf0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x1690
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1cd0
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x1d10
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x1671
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
addl -0x14(%rbp), %esi
callq 0x3c80
jmp 0x1680
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
subl -0x14(%rbp), %esi
callq 0x3c80
jmp 0x1682
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1613
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x3c80
jmp 0x169d
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x15cb
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)