LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4f020
testq %rax, %rax
je 0x7daff
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x4ff40
movq %r15, %rdi
callq 0x4d9f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4f020
testq %rax, %rax
je 0x7db73
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x50330
movq %r15, %rdi
callq 0x4d9f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4f020
testq %rax, %rax
je 0x7dba8
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x51af0
movq %r14, %rdi
callq 0x51c30
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4f020
testq %rax, %rax
je 0x7dbdc
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x511e0
movq %r14, %rdi
callq 0x51c30
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4f020
testq %rax, %rax
je 0x7dc10
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4fcd0
movq %r14, %rdi
callq 0x51c30
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4f020
testq %rax, %rax
je 0x7dc45
movq %rax, %rdi
movq %r14, %rsi
movl %ebx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x4d960
movq %r15, %rdi
callq 0x51c30
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4f020
testq %rax, %rax
je 0x7dc96
movq %rax, %r15
movq 0x10(%r14), %rdi
movl %ebp, %esi
callq 0x4f020
testq %rax, %rax
je 0x7dc96
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4d710
movq %r14, %rdi
callq 0x51c30
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4f020
testq %rax, %rax
je 0x7dccb
movq %rax, %rdi
movq %rbx, %rsi
movl %ebp, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x4d270
movq %r14, %rdi
callq 0x51c30
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4f020
testq %rax, %rax
je 0x7dd00
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4f400
movq %r14, %rdi
callq 0x51c30
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4f020
testq %rax, %rax
je 0x7dd34
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x51ec0
movq %r14, %rdi
callq 0x51c30
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3376b(%rip), %rsi     # 0xb1960
movq %rsi, 0x33764(%rip)     # 0xb1960
movq 0x33765(%rip), %rcx     # 0xb1968
cmovneq %rax, %rcx
cmpq %rdx, %rcx
ja 0x7e226
movq (%rdi), %r8
movb (%r8), %r9b
leaq 0x1(%rcx), %r8
cmpb (%rsi,%rcx), %r9b
movq %r8, %rcx
jne 0x7e207
leaq -0x1(%r8), %rax
movq %r8, %rcx
movq %rcx, 0x3373b(%rip)     # 0xb1968
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7e2fd
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x28
popq %rsi
callq 0x4fc10
movq (%rbx), %rsi
addq $0x38, %rsi
movq %rax, %rdi
callq 0x4f1b0
pushq $0x2c
popq %rsi
movq %rax, %rdi
callq 0x4fc10
movq (%rbx), %rdi
movq 0x18(%rdi), %r15
addq $0x38, %rdi
leaq 0x86d0(%rip), %rsi      # 0x8694c
callq 0x520f0
testb %al, %al
je 0x7e2b8
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 %r14, %rdi
movq %r12, %rsi
callq 0x4f1b0
leaq 0x8(%rsp), %rdi
callq 0x4e020
jmp 0x7e2c7
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
movq %r14, %rsi
callq 0x4ef30
pushq $0x2c
popq %rsi
movq %r14, %rdi
callq 0x4fc10
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 0x4e990
pushq $0x29
popq %rsi
movq %rax, %rdi
callq 0x4fc10
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4e020
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x7e350
movq 0x30ab7(%rip), %r14     # 0xaedf0
movq %r14, %rdi
callq 0x4fa50
leaq 0xaef0(%rip), %rsi      # 0x89238
movq %r14, %rdi
callq 0x4f5b0
movl (%rbx), %edi
callq 0x4ee40
movq 0x30a92(%rip), %r14     # 0xaedf0
movq %r14, %rdi
movq %rax, %rsi
callq 0x4f5b0
xorl %r15d, %r15d
pushq $0x20
popq %rbp
xorl %r12d, %r12d
movslq 0x18(%rbx), %rax
cmpq %rax, %r12
jge 0x7e39d
movq %r14, %rdi
movl %ebp, %esi
callq 0x4fc10
movq 0x10(%rbx), %rsi
addq %r15, %rsi
movq %r14, %rdi
callq 0x4fa50
incq %r12
addq $0x18, %r15
jmp 0x7e372
movq 0x30a4c(%rip), %rdi     # 0xaedf0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4e140
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
movq 0x8(%rcx), %rax
movq 0x28(%rdi), %r8
movq 0x38(%rdi), %r9
xorl %ecx, %ecx
testl %edx, %edx
cmovlel %ecx, %edx
addq %r9, %r8
decq %r8
movq %rax, %r9
shlq $0x20, %r9
movabsq $0x100000000, %r10      # imm = 0x100000000
cmpq %rcx, %rdx
je 0x7e41b
leaq (%rax,%rcx), %r14
movq 0x28(%rdi), %rbx
xorl %r11d, %r11d
cmpq %rbx, %r14
jb 0x7e40f
cmpq %r8, %r14
ja 0x7e40f
movq 0x30(%rdi), %r11
shlq $0x20, %rbx
movq %r9, %r14
subq %rbx, %r14
sarq $0x20, %r14
movb (%r11,%r14), %r11b
movb %r11b, (%rsi,%rcx)
incq %rcx
addq %r10, %r9
jmp 0x7e3df
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movl %esi, 0x20(%rdi)
testl %esi, %esi
je 0x7e5a6
leaq 0x4(%rsp), %rdx
movl $0x1, (%rdx)
leaq 0xad15(%rip), %rsi      # 0x89264
leaq 0x8(%rsp), %rdi
callq 0x4e4d0
leaq 0x30(%rsp), %rdi
movq %rsp, %rdx
movl $0x1, (%rdx)
leaq 0xacff(%rip), %rsi      # 0x8926d
callq 0x50b30
leaq 0x150(%rbx), %rdi
leaq 0x58(%rsp), %rdx
leaq 0x8(%rsp), %rsi
callq 0x4e3f0
pushq $0x28
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x8, %rdi
callq 0x4e020
addq $-0x28, %r14
cmpq $-0x28, %r14
jne 0x7e58d
jmp 0x7e61c
leaq 0xac90(%rip), %rsi      # 0x8923d
movq %rbx, %rdi
callq 0x51eb0
leaq 0x4(%rsp), %rdx
movl $0x1, (%rdx)
leaq 0xac9d(%rip), %rsi      # 0x89264
leaq 0x8(%rsp), %rdi
callq 0x4e4d0
leaq 0x30(%rsp), %rdi
movq %rsp, %rdx
movl $0x1, (%rdx)
leaq 0xac87(%rip), %rsi      # 0x8926d
callq 0x50b30
leaq 0x150(%rbx), %rdi
leaq 0x58(%rsp), %rdx
leaq 0x8(%rsp), %rsi
callq 0x4e3f0
pushq $0x28
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x8, %rdi
callq 0x4e020
addq $-0x28, %r14
cmpq $-0x28, %r14
jne 0x7e605
leaq 0x28(%rbx), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4f980
movq 0x78(%rax), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x4f070
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
pushq $0x28
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x8, %rdi
callq 0x4e020
addq $-0x28, %r14
cmpq $-0x28, %r14
jne 0x7e649
jmp 0x7e698
jmp 0x7e686
jmp 0x7e695
movq %rax, %rbx
pushq $0x28
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x8, %rdi
callq 0x4e020
addq $-0x28, %r14
cmpq $-0x28, %r14
jne 0x7e66d
jmp 0x7e698
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4e020
jmp 0x7e698
movq %rax, %rbx
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x50(%rsp), %rax
movq %rsi, (%rax)
leaq 0x48(%rsp), %r8
movq %rdx, (%r8)
leaq 0x40(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rdx
movq %r8, %rcx
callq 0x51a40
movq (%r14), %rax
andq $0x0, (%r14)
movq 0x140(%rbx), %rdi
movq %rax, 0x140(%rbx)
testq %rdi, %rdi
je 0x7e709
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7e709
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x140(%rbx), %rax
leaq 0x38(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x70(%rbx), %r14
leaq 0x30(%rsp), %rdx
movq %r14, (%rdx)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x4e9d0
movq (%r15), %rax
andq $0x0, (%r15)
movq 0x148(%rbx), %rdi
movq %rax, 0x148(%rbx)
testq %rdi, %rdi
je 0x7e761
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7e761
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x148(%rbx), %rdi
leaq 0x28(%rbx), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x150(%rbx), %r15
movq 0x158(%rbx), %r12
leaq 0x8(%rsp), %rbx
cmpq %r12, %r15
je 0x7e7b2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4feb0
movl 0x28(%rsp), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4e030
movq %rbx, %rdi
callq 0x4e020
addq $0x28, %r15
jmp 0x7e785
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4e020
movq %rbx, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rsi, %rbx
xorl %r13d, %r13d
movq 0x3059a(%rip), %r14     # 0xaedf0
leaq 0x9827(%rip), %r15      # 0x88084
leaq 0x8cb9(%rip), %r12      # 0x8751d
cmpq %r13, 0x8(%rbx)
jbe 0x7e8a8
movq %r14, %rdi
movq %r15, %rsi
callq 0x4f5b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movzbl 0x48(%rbx,%r13), %esi
movq %rax, %rdi
callq 0x51690
movq %rax, %rdi
movq %r12, %rsi
callq 0x4f5b0
incq %r13
jmp 0x7e864
movq 0x30541(%rip), %rdi     # 0xaedf0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4e140
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rsi, %rbx
xorl %r13d, %r13d
movq 0x3051c(%rip), %r14     # 0xaedf0
leaq 0x97a9(%rip), %r15      # 0x88084
leaq 0x8c3b(%rip), %r12      # 0x8751d
cmpq %r13, 0x8(%rbx)
jbe 0x7e926
movq %r14, %rdi
movq %r15, %rsi
callq 0x4f5b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movzbl 0x48(%rbx,%r13), %esi
movq %rax, %rdi
callq 0x51690
movq %rax, %rdi
movq %r12, %rsi
callq 0x4f5b0
incq %r13
jmp 0x7e8e2
movq 0x304c3(%rip), %rdi     # 0xaedf0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4e140
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x140(%rdi), %rax
movq 0x28(%rax), %rcx
movq 0x148(%rdi), %rdx
movq 0xa0(%rdx), %rdi
leaq 0x8(%rsp), %r15
movq %rdi, (%r15)
movq %rcx, 0x8(%r15)
addq 0x38(%rax), %rcx
movq %rsi, %rdx
leaq 0x28(%rsp), %r12
movq %rdi, (%r12)
movq %rcx, 0x8(%r12)
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x4f560
movups (%r13), %xmm0
movups %xmm0, (%r15)
movq %r12, %rdi
movq %r15, %rsi
callq 0x50a80
xorl %ebp, %ebp
testb %al, %al
jne 0x7ea0f
movq 0x148(%rbx), %rdi
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 0x7ea0f
movq 0x3047b(%rip), %rsi     # 0xaee68
movq 0x303dc(%rip), %rdx     # 0xaedd0
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x4fa60
testq %rax, %rax
je 0x7ea0f
movq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x4e760
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
cmpl $0x1, %edx
jne 0x7ea4a
movq %r15, %rdi
callq 0x4de70
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
callq 0x51210
xorl %ebp, %ebp
jmp 0x7e9e6
movq %rax, %r15
callq 0x51210
movq %r15, %rdi
callq 0x518c0
movq %rax, %rdi
callq 0x55fd2
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movl %r9d, %ebp
movq %r8, %rbx
movl %edx, %r14d
testq %rcx, %rcx
je 0x7ec16
movq 0x301f4(%rip), %r15     # 0xaedf0
movq %r15, %rdi
movq %rcx, %rsi
callq 0x4fa50
leaq 0xa666(%rip), %rsi      # 0x89274
movq %r15, %rdi
callq 0x4f5b0
movl %r14d, %edi
callq 0x4ee40
movq 0x301cb(%rip), %r14     # 0xaedf0
movq %r14, %rdi
movq %rax, %rsi
callq 0x4f5b0
xorl %r15d, %r15d
testl %ebp, %ebp
cmovgl %ebp, %r15d
pushq $0x20
popq %rbp
subq $0x1, %r15
jb 0x7ec5d
movq %r14, %rdi
movl %ebp, %esi
callq 0x4fc10
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4fa50
addq $0x18, %rbx
jmp 0x7ec3c
movq 0x3018c(%rip), %rdi     # 0xaedf0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4e140
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rdi
movq 0x28(%rbx), %rsi
callq 0x4f900
cmpq 0x18(%rbx), %rax
leaq -0x58(%rax), %rcx
cmoveq %rcx, %rax
movq %rax, 0x28(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
addq $0x10, %rdi
addq $0x10, %rsi
movq %rdi, 0x10(%rsp)
callq 0x50630
leaq 0x30(%r14), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%r14)
movups %xmm0, 0x30(%r14)
andq $0x0, 0x50(%r14)
movq 0x30(%rbx), %r13
movq %rbx, %r12
movq 0x38(%rbx), %rbx
leaq 0x38(%rsp), %rbp
leaq 0x18(%rsp), %r15
cmpq %rbx, %r13
je 0x7fbe0
movq %rbp, %rdi
movq %r13, %rsi
callq 0x4e120
movq %r15, %rdi
movq %rbp, %rsi
callq 0x4e120
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x51ff0
addq $0x20, %r13
jmp 0x7fbb2
xorl %eax, %eax
cmpq $0x10, %rax
je 0x7fbf7
movb 0x48(%r12,%rax), %cl
movb %cl, 0x48(%r14,%rax)
incq %rax
jmp 0x7fbe2
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7fc08
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x4ffe0
movq 0x10(%rsp), %rdi
callq 0x4e020
movq %rbx, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
testq %rdi, %rdi
je 0x803d9
testq %rsi, %rsi
je 0x80421
callq 0x50530
testb %al, %al
jne 0x803de
jmp 0x80421
testq %rsi, %rsi
jne 0x80421
movl (%r14), %eax
cmpl (%rbx), %eax
jne 0x80421
movl 0x18(%r14), %eax
cmpl 0x18(%rbx), %eax
jne 0x80421
pushq $-0x1
popq %r15
xorl %esi, %esi
movl 0x18(%r14), %eax
incq %r15
cmpq %rax, %r15
sete %bpl
je 0x80423
leaq 0x18(%rsi), %r12
movq 0x10(%r14), %rdi
addq %rsi, %rdi
addq 0x10(%rbx), %rsi
callq 0x51e60
movq %r12, %rsi
testb %al, %al
je 0x803f4
jmp 0x80423
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %esi, %eax
movq %rdi, %rbx
leal -0x3a(%rax), %ecx
cmpl $-0xa, %ecx
jae 0x1366
movq %rbx, %rdi
callq 0x1200
jmp 0x1354
xorl %ebp, %ebp
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x137f
imull $0xa, %ebp, %ebp
addl %eax, %ebp
movq %rbx, %rdi
callq 0x1200
jmp 0x1368
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/app/genipareach/genipareach.cpp
// Function: loadReachabilityProblem(char const*, Formula*, Formula*, Formula*, Formula*)
bool loadReachabilityProblem(const char* filename, Formula* initial, Formula* universal, Formula* goal, Formula* transition) {
	FILE* f = fopen(filename, "r");
	if (f == NULL) {
		return false;
	}
	int c = 0;
	bool neg = false;
	Formula* current = goal;
	while (c != EOF) {
		c = fgetc(f);

		// comment line
		if (c == 'c') {
			readLine(f);
			continue;
		}
		// problem lines
		if (c == 'i' || c == 'u' || c == 'g' || c == 't') {
			switch (c) {
			case 'i':
				current = initial;
				break;
			case 'u':
				current = universal;
				break;
			case 'g':
				current = goal;
				break;
			case 't':
				current = transition;
				break;
			default:
				printf("Invalid character: \"%c\"\n", c);
				return false;
			}
			current->variables = readNextNumber(f, 0);
			readLine(f);
			continue;
		}
		// whitespace
		if (isspace(c)) {
			continue;
		}
		// negative
		if (c == '-') {
			neg = true;
			continue;
		}

		// number
		if (isdigit(c)) {
			int num = readNextNumber(f, c);
			if (neg) {
				num *= -1;
			}
			neg = false;
			current->addLit(num);
		}
	}
	fclose(f);

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
leaq 0x106fb(%rip), %rsi     # 0x11ab7
callq 0x1170
movq %rax, %r13
testq %rax, %rax
je 0x148a
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
xorl %ebp, %ebp
movl $0x0, 0x4(%rsp)
movq %rbx, %r14
movq %r13, %rdi
cmpl $-0x1, %ebp
je 0x1485
callq 0x1200
movl %eax, %ebp
cmpl $0x63, %eax
je 0x1478
cmpl $0x67, %ebp
je 0x1455
cmpl $0x69, %ebp
je 0x145a
cmpl $0x74, %ebp
je 0x1466
cmpl $0x75, %ebp
je 0x145f
movl %ebp, %edi
callq 0x1040
testl %eax, %eax
jne 0x13e4
cmpl $0x2d, %ebp
sete %r15b
je 0x144c
movl %ebp, %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x13e4
movq %r13, %rdi
movl %ebp, %esi
callq 0x134c
movl %eax, %esi
negl %esi
testb $0x1, 0x4(%rsp)
cmovel %eax, %esi
movq %r14, %rdi
callq 0x18b0
movl %r15d, %eax
movl %eax, 0x4(%rsp)
jmp 0x13e4
movq %rbx, %r14
jmp 0x146b
movq %r12, %r14
jmp 0x146b
movq 0x8(%rsp), %r14
jmp 0x146b
movq 0x10(%rsp), %r14
movq %r13, %rdi
xorl %esi, %esi
callq 0x134c
movl %eax, (%r14)
movq %r13, %rdi
callq 0x1388
jmp 0x13e4
callq 0x1110
testq %r13, %r13
setne %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %ebp
negl %ebp
xorl %esi, %esi
movq (%r14), %rcx
movq 0x8(%r14), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rdi
idivq %rdi
cmpq %rax, %rsi
jae 0x152d
imulq $0x18, %rsi, %r13
movq (%rcx,%r13), %rax
movq 0x8(%rcx,%r13), %rcx
cmpq %rax, %rcx
je 0x1528
movq %rsi, (%rsp)
xorl %r12d, %r12d
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rcx, %r12
jae 0x151a
movl (%rax,%r12,4), %eax
testl %eax, %eax
movl %ebp, %esi
cmovgl %ebx, %esi
addl %eax, %esi
movq %r15, %rdi
callq 0x1e57
incq %r12
movq (%r14), %rcx
movq (%rcx,%r13), %rax
movq 0x8(%rcx,%r13), %rcx
jmp 0x14e8
movq %r15, %rdi
xorl %esi, %esi
callq 0x1e57
movq (%rsp), %rsi
incq %rsi
jmp 0x14b8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/app/genipareach/genipareach.cpp
// Function: assumeLits(void*, std::vector<int, std::allocator<int>> const&, int)
void assumeLits(void* solver, const vector<int>& lits, int variableOffset) {
	for (size_t lid = 0; lid < lits.size(); lid++) {
		int lit = lits[lid];
		if (lit > 0) {
			ipasir_assume(solver, lit+variableOffset);
		} else {
			ipasir_assume(solver, lit-variableOffset);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %ebp
negl %ebp
xorl %r12d, %r12d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rcx, %r12
jae 0x1580
movl (%rax,%r12,4), %eax
testl %eax, %eax
movl %ebp, %esi
cmovgl %ebx, %esi
addl %eax, %esi
movq %r15, %rdi
callq 0x1e5c
incq %r12
jmp 0x1553
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/app/genipareach/genipareach.cpp
// Function: Formula::addLit(int)
void addLit(int lit) {
		if (lit == 0) {
			clausesCount++;
			clauses.push_back(tmpClause);
			tmpClause.clear();
		} else {
			tmpClause.push_back(lit);
		}
	}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
testl %esi, %esi
je 0x18d3
addq $0x20, %rbx
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x18f8
jmp 0x18f1
incl 0x4(%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x20(%rbx), %rsi
callq 0x1930
movq 0x20(%rbx), %rax
cmpq %rax, 0x28(%rbx)
je 0x18f1
movq %rax, 0x28(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/ipasirpicosatglue.c
// Function: ipasir_init
void * ipasir_init () { 
  char prefix[80];
  void * res = picosat_init ();
  sprintf (prefix, "c [%s] ", sig);
  picosat_set_prefix (res, prefix);
  picosat_set_verbosity (res, 1);
  picosat_set_output (res, stdout);
  return res;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
callq 0x2024
movq %rax, %rbx
leaq 0xd3cd(%rip), %rsi      # 0xf1cb
leaq 0xd3ce(%rip), %rdx      # 0xf1d3
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x1050
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4a44
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x4977
movq 0x14199(%rip), %rax     # 0x15fc8
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x4a14
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./blockwise_sa.h
// Function: KarkkainenBlockwiseSA<S2bDnaString>::qsort(EList<unsigned long, 128>&)
void KarkkainenBlockwiseSA<S2bDnaString>::qsort(EList<TIndexOffU>& bucket) {
	const S2bDnaString& t = this->text();
	TIndexOffU *s = &bucket[0];
	TIndexOffU slen = (TIndexOffU)bucket.size();
	TIndexOffU len = (TIndexOffU)t.length();
	if(_dc != NULL) {
		// Use the difference cover as a tie-breaker if we have it
		VMSG_NL("  (Using difference cover)");
		// Can't use the text's 'host' array because the backing
		// store for the packed string is not one-char-per-elt.
		mkeyQSortSufDcU8(t, t, len, s, slen, *_dc, 4,
				 this->verbose(), this->sanityCheck());
	} else {
		VMSG_NL("  (Not using difference cover)");
		// We don't have a difference cover - just do a normal
		// suffix sort
		mkeyQSortSuf(t, s, slen, 4,
			     this->verbose(), this->sanityCheck());
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rdi), %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0xd2a6
movq %rax, %r14
movq 0x18(%r15), %r15
movq 0x98(%r12), %r9
movb 0x1a(%r12), %al
testq %r9, %r9
je 0x4c67
movq 0x18(%rbx), %r13
testb %al, %al
je 0x4cc9
leaq 0x38(%rsp), %rdi
callq 0x41c0
leaq 0x48(%rsp), %rdi
leaq 0x23439(%rip), %rsi     # 0x28054
callq 0x42d0
movq %rax, %rdi
callq 0x4130
leaq 0x50(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x4520
leaq 0x18(%rsp), %rsi
movq %r12, %rdi
callq 0xd36c
leaq 0x18(%rsp), %rdi
callq 0x46c8
leaq 0x38(%rsp), %rdi
callq 0x4200
movq 0x98(%r12), %r9
movb 0x1a(%r12), %al
jmp 0x4ccb
testb %al, %al
je 0x4cfc
leaq 0x38(%rsp), %rdi
callq 0x41c0
leaq 0x48(%rsp), %rdi
leaq 0x233ea(%rip), %rsi     # 0x2806f
callq 0x42d0
movq %rax, %rdi
callq 0x4130
leaq 0x50(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x4520
leaq 0x18(%rsp), %rsi
movq %r12, %rdi
callq 0xd36c
leaq 0x18(%rsp), %rdi
callq 0x46c8
leaq 0x38(%rsp), %rdi
callq 0x4200
movb 0x1a(%r12), %al
jmp 0x4cfe
xorl %eax, %eax
movzbl 0x18(%r12), %ecx
movl %ecx, 0x10(%rsp)
movzbl %al, %eax
andl $0x1, %eax
movl %eax, 0x8(%rsp)
movl $0x4, (%rsp)
movq %rbx, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0xd38d
jmp 0x4d22
xorl %eax, %eax
movzbl 0x18(%r12), %r9d
orq $-0x1, (%rsp)
movzbl %al, %r8d
andl $0x1, %r8d
pushq $0x4
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xd440
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4d37
jmp 0x4d4a
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x46c8
jmp 0x4d4d
jmp 0x4d4a
jmp 0x4d4a
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x4200
movq %rbx, %rdi
callq 0x45e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./timer.h
// Function: logTime(std::ostream&, bool)
static inline void logTime(std::ostream& os, bool nl = true) {
	struct tm *current;
	time_t now;
	time(&now);
	current = localtime(&now);
	std::ostringstream oss;
	oss << setfill('0') << setw(2)
	    << current->tm_hour << ":"
	    << setfill('0') << setw(2)
	    << current->tm_min << ":"
	    << setfill('0') << setw(2)
	    << current->tm_sec;
	if(nl) oss << std::endl;
	os << oss.str().c_str();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x4290
movq %rbx, %rdi
callq 0x41f0
movq %rax, %rbx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x4410
pushq $0x30
popq %rsi
movq %r14, %rdi
callq 0x4510
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x2, 0x10(%rax,%rcx)
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x45d0
leaq 0x1fd22(%rip), %rsi     # 0x2973b
movq %rax, %rdi
callq 0x42d0
pushq $0x30
popq %rsi
movq %rax, %rdi
callq 0x4510
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x2, 0x10(%rax,%rcx)
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x45d0
leaq 0x1fced(%rip), %rsi     # 0x2973b
movq %rax, %rdi
callq 0x42d0
pushq $0x30
popq %rsi
movq %rax, %rdi
callq 0x4510
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x2, 0x10(%rax,%rcx)
movl (%rbx), %esi
movq %rax, %rdi
callq 0x45d0
leaq 0x30(%rsp), %rdi
callq 0x4130
leaq 0x38(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x4520
movq 0x8(%rsp), %rsi
movq 0x2a550(%rip), %rdi     # 0x33ff0
callq 0x42d0
leaq 0x8(%rsp), %rdi
callq 0x46c8
leaq 0x30(%rsp), %rdi
callq 0x40c0
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x46c8
jmp 0x9ad8
jmp 0x9ad5
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x40c0
movq %rbx, %rdi
callq 0x45e0
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./word_io.h
// Function: unsigned int readU<unsigned int>(_IO_FILE*, bool)
static inline T readU(FILE* in, bool swap) {
	T x;
	if(fread((void *)&x, 1, sizeof(T), in) != sizeof(T)) {
		assert(false);
	}
	if(swap) {
		if(sizeof(T) == 4) {
			return endianSwapU32(x);
		} else if(sizeof(T) == 8) {
			return endianSwapU64(x);
		} else {
			assert(false);
		}
	} else {
		return x;
	}
}

// Assembly:
pushq %rax
movq %rdi, %rcx
leaq 0x4(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x4
popq %rdx
callq 0x44b0
cmpq $0x4, %rax
jne 0x9b0a
movl 0x4(%rsp), %eax
popq %rcx
retq
leaq 0x20188(%rip), %rdi     # 0x29c99
leaq 0x20187(%rip), %rsi     # 0x29c9f
leaq 0x224a8(%rip), %rcx     # 0x2bfc7
pushq $0x4a
popq %rdx
callq 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./word_io.h
// Function: int readI<int>(_IO_FILE*, bool)
static inline T readI(FILE* in, bool swap) {
	T x;
	if(fread((void *)&x, 1, sizeof(T), in) != sizeof(T)) {
		assert(false);
	}
	if(swap) {
		if(sizeof(T) == 4) {
			return endianSwapI32(x);
		} else if(sizeof(T) == 8) {
			return endianSwapI64(x);
		} else {
			assert(false);
		}
	} else {
		return x;
	}
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %rcx
leaq 0xc(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x4
popq %rdx
callq 0x44b0
cmpq $0x4, %rax
jne 0x9bae
movl 0xc(%rsp), %ecx
movl %ecx, %eax
bswapl %eax
testb %bl, %bl
cmovel %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x200e4(%rip), %rdi     # 0x29c99
leaq 0x200e3(%rip), %rsi     # 0x29c9f
leaq 0x2242d(%rip), %rcx     # 0x2bff0
pushq $0x6f
popq %rdx
callq 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/bowtie_inspect.cpp
// Function: print_fasta_record(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void print_fasta_record(ostream& fout,
						const string& defline,
						const string& seq)
{
	fout << ">";
	fout << defline << endl;

	if(across > 0) {
		size_t i = 0;
		while (i + across < seq.length())
		{
			fout << seq.substr(i, across) << endl;
			i += across;
		}
		if (i < seq.length())
			fout << seq.substr(i) << endl;
	} else {
		fout << seq << endl;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x205fb(%rip), %rsi     # 0x2a716
callq 0x42d0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4270
movq %rax, %rdi
callq 0x4130
movl 0x2a237(%rip), %eax     # 0x34370
testl %eax, %eax
jle 0xa1d2
xorl %r15d, %r15d
leaq 0x8(%rsp), %r12
movslq %eax, %rcx
leaq (%r15,%rcx), %rdx
movq 0x8(%r14), %rax
cmpq %rax, %rdx
jae 0xa18e
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4310
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4270
movq %rax, %rdi
callq 0x4130
movq %r12, %rdi
callq 0x46c8
movslq 0x2a1e7(%rip), %rax     # 0x34370
addq %rax, %r15
jmp 0xa149
cmpq %rax, %r15
jae 0xa1c6
leaq 0x8(%rsp), %r12
pushq $-0x1
popq %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4310
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4270
movq %rax, %rdi
callq 0x4130
leaq 0x8(%rsp), %rdi
callq 0x46c8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4270
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4130
jmp 0xa1f2
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x46c8
movq %rbx, %rdi
callq 0x45e0
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/bowtie_inspect.cpp
// Function: print_alln_ref_sequence(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
void print_alln_ref_sequence(
	ostream& fout,
	const string& name,
	size_t len)
{
	fout << ">" << name << "\n";
	size_t j = 0;
	for(size_t i = 0; i < len; i += across) {
		while(j < len && j < i+across) {
			fout << 'N';
			j++;
		}
		fout << "\n";
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x204f4(%rip), %rsi     # 0x2a716
callq 0x42d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4270
leaq 0x1eb73(%rip), %rsi     # 0x28dac
movq %rax, %rdi
callq 0x42d0
xorl %r12d, %r12d
pushq $0x4e
popq %rbp
xorl %r13d, %r13d
cmpq %r15, %r13
jae 0xa29a
cmpq %r15, %r12
movq %r15, %rbx
cmovaq %r12, %rbx
cmpq %r12, %rbx
je 0xa27c
movslq 0x2a10b(%rip), %rax     # 0x34370
addq %r13, %rax
cmpq %rax, %r12
jae 0xa27f
movq %r14, %rdi
movl %ebp, %esi
callq 0x4380
incq %r12
jmp 0xa259
movq %rbx, %r12
movq %r14, %rdi
leaq 0x1eb23(%rip), %rsi     # 0x28dac
callq 0x42d0
movslq 0x2a0db(%rip), %rax     # 0x34370
addq %rax, %r13
jmp 0xa24a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/bowtie_inspect.cpp
// Function: print_ref_sequence(std::ostream&, BitPairReference&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, unsigned long)
void print_ref_sequence(
	ostream& fout,
	BitPairReference& ref,
	const string& name,
	size_t refi,
	size_t len)
{
	bool newlines = across > 0;
	int myacross = across > 0 ? across : 60;
	size_t incr = myacross * 1000;
	uint32_t *buf = new uint32_t[(incr + 128)/4];
	fout << ">" << name << "\n";
	for(size_t i = 0; i < len; i += incr) {
		size_t amt = min(incr, len-i);
		assert_leq(amt, incr);
		int off = ref.getStretch(buf, refi, i, amt);
		uint8_t *cb = ((uint8_t*)buf) + off;
		for(size_t j = 0; j < amt; j++) {
			if(newlines && j > 0 && (j % myacross) == 0) fout << "\n";
			assert_range(0, 4, (int)cb[j]);
			fout << "ACGTN"[(int)cb[j]];
		}
		fout << "\n";
	}
	delete[] buf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r14
movq %rcx, 0x28(%rsp)
movq %rdx, %rbx
movq %rsi, 0x20(%rsp)
movq %rdi, %r12
movslq 0x2a09f(%rip), %r15     # 0x34370
imull $0x3e8, %r15d, %eax     # imm = 0x3E8
testq %r15, %r15
movl $0xea60, %ecx           # imm = 0xEA60
cmovgl %eax, %ecx
movslq %ecx, %rbp
leaq 0x80(%rbp), %rdi
callq 0x4030
movq %rax, 0x10(%rsp)
leaq 0x20418(%rip), %rsi     # 0x2a716
movq %r12, %rdi
callq 0x42d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4270
leaq 0x1ea94(%rip), %rsi     # 0x28dac
movq %rax, %rdi
callq 0x42d0
xorl %ecx, %ecx
leaq 0x1e973(%rip), %rbx     # 0x28c9c
movq %r14, 0x30(%rsp)
movq %rbp, 0x18(%rsp)
movq %r14, %r13
subq %rbp, %r14
cmovaeq %rbp, %r13
movq 0x30(%rsp), %r8
subq %rcx, %r8
jbe 0xa422
movq %r14, 0x38(%rsp)
cmpq %rbp, %r8
cmovaeq %rbp, %r8
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %r14
movq %r14, %rsi
movq 0x28(%rsp), %rdx
movq %rcx, 0x40(%rsp)
callq 0x10620
movslq %eax, %rbp
addq %r14, %rbp
xorl %r14d, %r14d
cmpq %r14, %r13
je 0xa3fc
testl %r15d, %r15d
setle %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0xa3ad
movq %r14, %rax
xorl %edx, %edx
divq %r15
testq %rdx, %rdx
jne 0xa3ad
movq %r12, %rdi
leaq 0x1ea04(%rip), %rsi     # 0x28dac
callq 0x42d0
andl $0x0, 0xc(%rsp)
movl $0x4, 0x8(%rsp)
movzbl (%rbp,%r14), %eax
movl %eax, 0x4(%rsp)
leaq 0xc(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %rdx
leaq 0x1e8af(%rip), %rcx     # 0x28c89
movl $0xcf, %r8d
callq 0xa43a
movzbl (%rbp,%r14), %eax
movsbl (%rax,%rbx), %esi
movq %r12, %rdi
callq 0x4380
incq %r14
jmp 0xa37c
movq %r12, %rdi
leaq 0x1e9a6(%rip), %rsi     # 0x28dac
callq 0x42d0
movq 0x18(%rsp), %rbp
movq 0x40(%rsp), %rcx
addq %rbp, %rcx
movq 0x38(%rsp), %r14
jmp 0xa333
movq 0x10(%rsp), %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x43d0
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./assert_helpers.h
// Function: void assert_range_helper<int>(int const&, int const&, int const&, char const*, int)
inline static void assert_range_helper(const T& begin,
                                       const T& end,
                                       const T& val,
                                       const char *file,
                                       int line)
{
	if(val < begin || val > end) {
		std::cout << "assert_range: (" << val << ") not in  ["
		          << begin << ", " << end << "]" << std::endl;
		std::cout << file << ":" << line << std::endl;
		assert(0);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, %r13
movl (%rdx), %eax
cmpl (%rdi), %eax
jl 0xa46f
cmpl (%r12), %eax
jg 0xa46f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x29b42(%rip), %r15     # 0x33fb8
leaq 0x206c3(%rip), %rsi     # 0x2ab40
movq %r15, %rdi
callq 0x42d0
movl (%rbp), %esi
movq %rax, %rdi
callq 0x45d0
leaq 0x206b9(%rip), %rsi     # 0x2ab50
movq %rax, %rdi
callq 0x42d0
movl (%r13), %esi
movq %rax, %rdi
callq 0x45d0
leaq 0x1e248(%rip), %rsi     # 0x286fa
movq %rax, %rdi
callq 0x42d0
movl (%r12), %esi
movq %rax, %rdi
callq 0x45d0
leaq 0x1de42(%rip), %rsi     # 0x2830f
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
callq 0x4130
movq %r15, %rdi
movq %r14, %rsi
callq 0x42d0
leaq 0x1f24c(%rip), %rsi     # 0x2973b
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movl %ebx, %esi
callq 0x45d0
movq %rax, %rdi
callq 0x4130
leaq 0x1f10b(%rip), %rdi     # 0x2961b
leaq 0x20645(%rip), %rsi     # 0x2ab5c
leaq 0x20651(%rip), %rcx     # 0x2ab6f
movl $0xfd, %edx
callq 0x4190