LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/pascompl.cc
// Function: standProc::checkArrayArg()
void checkArrayArg() {
        verifyType(NULL);
        l4exp9z = curExpr;
        l4typ1z = curExpr->typ;
        if (l4typ1z->k != kindArray
            or l4typ1z->cast<ArrayT>().pck)
            error(errNeedOtherTypesOfOperands);
        checkSymAndRead(COMMA);
        bool102z = false;
        expression();
        l4exp8z = curExpr;
        if (l4typ1z->k == kindArray && not typeCheck(l4typ1z->cast<ArrayT>().range, l4exp8z->typ))
            error(errNeedOtherTypesOfOperands);
    }

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
xorl %esi, %esi
callq 0x1a4be
movq 0x4a554(%rip), %rax     # 0x64aa0
movq %rax, 0x40(%rbx)
movq (%rax), %rax
movq %rax, (%rbx)
cmpl $0x5, 0x10(%rax)
jne 0x1a562
cmpb $0x1, 0x28(%rax)
jne 0x1a56c
movl $0x15, %edi
callq 0x58ff
movl $0xe, %edi
callq 0x83e7
movb $0x0, 0x4a3f8(%rip)     # 0x64975
callq 0xee5e
movq 0x4a517(%rip), %rax     # 0x64aa0
movq %rax, 0x38(%rbx)
movq (%rbx), %rcx
cmpl $0x5, 0x10(%rcx)
jne 0x1a5c1
movq 0x20(%rcx), %rsi
movq (%rax), %rdx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x84c6
addq $-0x8, 0xa2df6(%rip)    # 0xbd3a8
cmpb $0x0, (%rbx)
jne 0x1a5c1
movl $0x15, %edi
callq 0x58ff
addq $0x50, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/pascompl.cc
// Function: standProc::doPackUnpack()
void doPackUnpack() {
        ArrayT * t;

        l4exp7z = new Expr;
        l4exp7z->typ = l4typ1z->cast<ArrayT>().base;
        l4exp7z->op = GETELT;
        l4exp7z->expr1 = l4exp9z;
        l4exp7z->expr2 = l4exp8z;
        t = static_cast<ArrayT*>(l4exp6z->typ);
        if ((t->k != kindArray) or
            not t->pck or
            not typeCheck(t->base, l4typ1z->cast<ArrayT>().base) or
            not typeCheck(l4typ1z->cast<ArrayT>().range, t->range))
            error(errNeedOtherTypesOfOperands);
        curExpr = new Expr;
        curExpr->val.ii = char(procNo + 50);
        curExpr->expr1 = l4exp7z;
        curExpr->expr2 = l4exp6z;
        (void) formOperator(PCKUNPCK);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %rbx
movl $0x20, %edi
callq 0x3d77
movq %rax, 0x30(%rbx)
movq (%rbx), %rcx
cmpl $0x5, 0x10(%rcx)
jne 0x1a6f3
movq 0x18(%rcx), %rcx
movq %rcx, (%rax)
movq 0x30(%rbx), %rax
movl $0x1c, 0x8(%rax)
movq 0x40(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
movq %rcx, 0x18(%rax)
movq 0x28(%rbx), %rax
movq (%rax), %r15
cmpl $0x5, 0x10(%r15)
jne 0x1a68d
cmpb $0x1, 0x28(%r15)
jne 0x1a68d
movq (%rbx), %rax
cmpl $0x5, 0x10(%rax)
jne 0x1a6f3
movq 0x18(%r15), %rsi
movq 0x18(%rax), %rdx
leaq 0x50(%rsp), %r14
movq %r14, %rdi
callq 0x84c6
cmpb $0x0, (%r14)
je 0x1a685
movq (%rbx), %rax
cmpl $0x5, 0x10(%rax)
jne 0x1a6f3
movq 0x20(%rax), %rsi
movq 0x20(%r15), %rdx
leaq 0x8(%rsp), %rdi
callq 0x84c6
addq $-0x10, 0xa2d2c(%rip)   # 0xbd3a8
cmpb $0x0, 0x8(%rsp)
je 0x1a68d
jmp 0x1a697
addq $-0x8, 0xa2d1b(%rip)    # 0xbd3a8
movl $0x15, %edi
callq 0x58ff
movl $0x20, %edi
callq 0x3d77
movq %rax, 0x4a3f8(%rip)     # 0x64aa0
movb 0x68(%rbx), %cl
addb $0x32, %cl
movsbq %cl, %rcx
movq %rcx, (%rax)
movq 0x30(%rbx), %rax
movq 0x4a3e0(%rip), %rcx     # 0x64aa0
movq %rax, 0x10(%rcx)
movq 0x28(%rbx), %rax
movq %rax, 0x18(%rcx)
leaq 0x98(%rsp), %rdi
movl $0x10, %esi
callq 0xc308
addq $-0x8, 0xa2cda(%rip)    # 0xbd3c0
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
leaq 0x320b(%rip), %rdi      # 0x1d905
leaq 0x2f73(%rip), %rsi      # 0x1d674
leaq 0x32d7(%rip), %rcx      # 0x1d9df
movl $0x1f7, %edx            # imm = 0x1F7
callq 0x3170
addq $-0x8, 0xa2c8e(%rip)    # 0xbd3a8
movq %rax, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/pascompl.cc
// Function: standProc::P17037()
void P17037() {
        regsUsed = regsUsed - Bits(12);
        if (helperNo != 49 and             /* P/RDC */
            not typeCheck(l4exp8z->typ, l4exp7z->typ))
            error(34); /* errTypeIsNotAFileElementType */
        else {
            if (helperNo == 29) {       /* P/PF */
                l4exp6z->expr2 = l4exp7z;
            } else {
                if (helperNo == 49)
                    helperNo = 30;         /* P/GF */
                l4exp6z->expr1 = l4exp7z;
            }
            curExpr = l4exp6z;
            (void) formOperator(APPLYEXPR);
            callHelperWithArg();
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0xb8, %rsp
andl $0xfff7, 0x4a17c(%rip)  # imm = 0xFFF7
movq %rdi, %rbx
cmpq $0x31, 0x70(%rdi)
jne 0x1a927
movq $0x1e, 0x70(%rbx)
movl $0x10, %eax
movq 0x28(%rbx), %rcx
movq 0x30(%rbx), %rdx
movq %rdx, (%rcx,%rax)
movq 0x28(%rbx), %rax
movq %rax, 0x4a19a(%rip)     # 0x64aa0
leaq 0x50(%rsp), %rdi
movl $0x7, %esi
callq 0xc308
addq $-0x8, 0xa2aa3(%rip)    # 0xbd3c0
movq %rbx, %rdi
callq 0x1aaf0
jmp 0x1a96c
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
movq (%rcx), %rsi
movq (%rax), %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x84c6
addq $-0x8, 0xa2a5e(%rip)    # 0xbd3a8
cmpb $0x0, (%r14)
je 0x1a962
movq 0x70(%rbx), %rax
cmpq $0x1d, %rax
je 0x1a977
cmpq $0x31, %rax
je 0x1a8e2
jmp 0x1a8ea
movl $0x22, %edi
callq 0x58ff
addq $0xb8, %rsp
popq %rbx
popq %r14
retq
movl $0x18, %eax
jmp 0x1a8ef
nop
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/pascompl.cc
// Function: standProc::checkElementForReadWrite()
void checkElementForReadWrite() {
        RangeT * l5typ1z;

        regsUsed = regsUsed - Bits(12);
        if (l4typ3z->k == kindRange)
            l4typ3z = l4typ3z->cast<RangeT>().base;
        curVarKind = l4typ3z->k;
        helperNo = 36;                   /* P/WI */
        if (l4typ3z == IntegerType)
            l4var15z = 10;
        else if (l4typ3z == RealType) {
            helperNo = 37;               /* P/WR */
            l4var15z = 14;
        } else if (l4typ3z == CharType) {
            helperNo = 38;               /* P/WC */
            l4var15z = 1;
        } else if (curVarKind == kindScalar) {
            helperNo = 41;               /* P/WX */
            dumpEnumNames(static_cast<ScalarT*>(l4typ3z));
            l4var15z = 8;
        } else if (isCharArray(l4typ3z)) {
            l5typ1z = l4typ3z->cast<ArrayT>().range;
            l4var15z = l5typ1z->right - l5typ1z->left + 1;
            if (not l4typ3z->cast<ArrayT>().pck)
                helperNo = 81;            /* P/WA */
            else if (6 >= l4var15z)
                helperNo = 39;            /* P/A6 */
            else
                helperNo = 40;           /* P/A7 */
        } else if (l4typ3z->size == 1) {
            helperNo = 42;               /* P/WO */
            l4var15z = 17;
        } else {
            error(34); /* errTypeIsNotAFileElementType */
        }
    }

// Assembly:
pushq %rbx
andl $0xfff7, 0x4a0c7(%rip)  # imm = 0xFFF7
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movl 0x10(%rdi), %eax
cmpl $0x2, %eax
jne 0x1a9a7
movq 0x18(%rdi), %rdi
movq %rdi, 0x10(%rbx)
movl 0x10(%rdi), %eax
movl %eax, 0x49f5b(%rip)     # 0x64908
movq $0x24, 0x70(%rbx)
cmpq 0x4a02c(%rip), %rdi     # 0x649e8
je 0x1a9f4
cmpq 0x4a02b(%rip), %rdi     # 0x649f0
je 0x1a9fe
movq 0x4a02a(%rip), %rcx     # 0x649f8
cmpq %rcx, %rdi
je 0x1aa10
cmpl $0x5, %eax
je 0x1aa22
cmpl $0x1, %eax
jne 0x1aa28
movq $0x29, 0x70(%rbx)
callq 0xe239
movq $0x8, 0x60(%rbx)
jmp 0x1aa3e
movq $0xa, 0x60(%rbx)
jmp 0x1aa3e
movq $0x25, 0x70(%rbx)
movq $0xe, 0x60(%rbx)
jmp 0x1aa3e
movq $0x26, 0x70(%rbx)
movq $0x1, 0x60(%rbx)
jmp 0x1aa3e
cmpq %rcx, 0x18(%rdi)
je 0x1aa4b
cmpq $0x1, (%rdi)
jne 0x1aa40
movq $0x2a, 0x70(%rbx)
movq $0x11, 0x60(%rbx)
popq %rbx
retq
movl $0x22, %edi
popq %rbx
jmp 0x58ff
movq 0x20(%rdi), %rcx
movq 0x30(%rcx), %rax
subq 0x28(%rcx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x60(%rbx)
cmpb $0x0, 0x28(%rdi)
je 0x1aa75
cmpq $0x5, %rax
jg 0x1aa7f
movq $0x27, 0x70(%rbx)
jmp 0x1aa3e
movq $0x51, 0x70(%rbx)
jmp 0x1aa3e
movq $0x28, 0x70(%rbx)
jmp 0x1aa3e
nop
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/pascompl.cc
// Function: standProc::parseWidthSpecifier(Expr*&)
void parseWidthSpecifier(ExprPtr &l5arg1z) {
        expression();
        if (not typeCheck(IntegerType, curExpr->typ)) {
            error(14); /* errExprIsNotInteger */
            curExpr = uVarPtr;
        }
        l5arg1z = curExpr;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
callq 0xee5e
movq 0x49f48(%rip), %rsi     # 0x649e8
movq 0x49ff9(%rip), %rax     # 0x64aa0
movq (%rax), %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x84c6
movb (%r14), %al
addq $-0x8, 0xa28e8(%rip)    # 0xbd3a8
cmpb $0x1, %al
jne 0x1aacd
movq 0x49fd5(%rip), %rax     # 0x64aa0
jmp 0x1aae5
movl $0xe, %edi
callq 0x58ff
movq 0x49fba(%rip), %rax     # 0x64a98
movq %rax, 0x49fbb(%rip)     # 0x64aa0
movq %rax, (%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/pascompl.cc
// Function: standProc::callHelperWithArg()
void callHelperWithArg() {
        if (regsUsed.has(12) or l4bool12z) {
            curExpr = l4exp9z;
            (void) formOperator(ADDRTOR12);
        }
        l4bool12z= false;
        formAndAlign(getHelperProc(helperNo));
        disableNorm();
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
testb $0x8, 0x49f53(%rip)     # 0x64a54
jne 0x1ab09
cmpb $0x1, 0x4a(%rbx)
jne 0x1ab29
movq 0x40(%rbx), %rax
movq %rax, 0x49f8c(%rip)     # 0x64aa0
movq %rsp, %rdi
movl $0x8, %esi
callq 0xc308
addq $-0x8, 0xa2897(%rip)    # 0xbd3c0
movb $0x0, 0x4a(%rbx)
movq 0x70(%rbx), %rbx
leaq 0x4fe98(%rip), %r14     # 0x6a9d0
movq (%r14,%rbx,8), %rdi
testq %rdi, %rdi
jne 0x1ab64
leaq 0x9838(%rip), %rax      # 0x24380
movq (%rax,%rbx,8), %rax
movq %rax, 0x49edd(%rip)     # 0x64a30
movl $0x8c0000, %edi         # imm = 0x8C0000
callq 0x5c15
movq %rax, %rdi
movq %rax, (%r14,%rbx,8)
addq $0xdc8000, %rdi         # imm = 0xDC8000
callq 0x5bb2
cmpq $0x1, 0x49d60(%rip)     # 0x648d8
je 0x1ab91
movq 0x9707(%rip), %rdi      # 0x24288
callq 0x59a2
movq $0x1, 0x49d47(%rip) # 0x648d8
addq $0x68, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/pascompl.cc
// Function: initTables::initArrays()
void initArrays() {
        // int64_t l3var1z;
        int64_t l3var2z;
        FcstCnt = 0;
        FcstTotal = 0;
        for (idx = 3; idx <= 6; ++idx) {
            l3var2z = idx - 2;
            for (jdx=1; jdx <= l3var2z; ++jdx)
                frameRestore[idx][jdx] = 0;
        }
        for (idx=1; idx <= 99; ++idx)
            helperMap[idx] = 0;
    }

// Assembly:
xorl %eax, %eax
movq %rax, 0x49c8d(%rip)     # 0x64830
movq %rax, 0x49d86(%rip)     # 0x64930
movq $0x3, (%rdi)
movl $0x3, %ecx
leaq 0x4e193(%rip), %rax     # 0x68d50
movq $0x1, 0x8(%rdi)
cmpq $0x3, %rcx
jl 0x1abfb
addq $-0x2, %rcx
movl $0x1, %edx
movq (%rdi), %rsi
leaq (%rsi,%rsi,4), %rsi
leaq (%rax,%rsi,8), %rsi
movq $0x0, (%rsi,%rdx,8)
movq 0x8(%rdi), %rsi
leaq 0x1(%rsi), %rdx
movq %rdx, 0x8(%rdi)
cmpq %rcx, %rsi
jl 0x1abd4
movq (%rdi), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rdi)
cmpq $0x6, %rcx
movq %rdx, %rcx
jl 0x1abbd
movq $0x1, (%rdi)
movl $0x1, %ecx
leaq 0x4fdb2(%rip), %rax     # 0x6a9d0
movq $0x0, (%rax,%rcx,8)
movq (%rdi), %rdx
leaq 0x1(%rdx), %rcx
movq %rcx, (%rdi)
cmpq $0x63, %rdx
jl 0x1ac1e
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/pascompl.cc
// Function: initTables::regResWord(long)
void regResWord(int64_t l4arg1z) {
        KeyWord * kw;
        Word l4var2z;
        curVal.ii = l4arg1z;
        curVal.i = (curVal.m.val % 65535) % 128;
        l4var2z.ii = l4arg1z;
        kw = new KeyWord;
        kw->w = l4var2z;
        kw->sym = SY;
        kw->op = charClass;
        kw->next = KeyWordHashTabBase[curVal.i];
        KeyWordHashTabBase[curVal.i] = kw;
        if (charClass == NOOP) {
            succ(SY);
        } else {
            succ(charClass);
        }
    }

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rsi, 0x49941(%rip)     # 0x64a30
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rsi, %rax
movabsq $0x1000100010002, %rcx  # imm = 0x1000100010002
mulq %rcx
leaq 0x49920(%rip), %rdi     # 0x64a30
addl %edx, %esi
andl $0x7f, %esi
callq 0x3c48
movl $0x18, %edi
callq 0x3d77
movq %rbx, (%rax)
leaq 0x496ee(%rip), %rcx     # 0x6481c
movl 0x496e8(%rip), %edx     # 0x6481c
movl %edx, 0x8(%rax)
leaq 0x496da(%rip), %rsi     # 0x64818
movl 0x496d4(%rip), %edi     # 0x64818
movl %edi, 0xc(%rax)
movq 0x498e2(%rip), %r8      # 0x64a30
shlq $0x17, %r8
sarq $0x17, %r8
leaq 0x4e873(%rip), %r9      # 0x699d0
movq (%r9,%r8,8), %r10
movq %r10, 0x10(%rax)
movq %rax, (%r9,%r8,8)
cmpl $0x2e, %edi
cmovel %edx, %edi
cmoveq %rcx, %rsi
incl %edi
movl %edi, (%rsi)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Reader::read(char*, int)
int Reader::read(char* buf, int n) {
  int i=0, c;
  while (i<n && (c=get())>=0)
    buf[i++]=c;
  return i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0x4ecc
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %r12d
xorl %ebx, %ebx
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
testl %eax, %eax
js 0x4ece
movb %al, (%r14,%rbx)
incq %rbx
cmpq %rbx, %r12
jne 0x4eaf
movl %r12d, %ebx
jmp 0x4ece
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::allocx(unsigned char*&, int&, int)
void allocx(U8* &p, int &n, int newsize) {
#ifdef NOJIT
  p=0;
  n=0;
#else
  if (p || n) {
    if (p)
#ifdef unix
      munmap(p, n);
#else // Windows
      VirtualFree(p, 0, MEM_RELEASE);
#endif
    p=0;
    n=0;
  }
  if (newsize>0) {
#ifdef unix
    p=(U8*)mmap(0, newsize, PROT_READ|PROT_WRITE|PROT_EXEC,
                MAP_PRIVATE|MAP_ANON, -1, 0);
    if ((void*)p==MAP_FAILED) p=0;
#else
    p=(U8*)VirtualAlloc(0, newsize, MEM_RESERVE|MEM_COMMIT,
                        PAGE_EXECUTE_READWRITE);
#endif
    if (p)
      n=newsize;
    else {
      n=0;
      error("allocx failed");
    }
  }
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
sete %cl
movl (%rsi), %eax
testl %eax, %eax
sete %dl
testb %dl, %cl
jne 0x4f52
testq %rdi, %rdi
je 0x4f45
movslq %eax, %rsi
callq 0x40f0
movq $0x0, (%r14)
movl $0x0, (%rbx)
testl %ebp, %ebp
jle 0x4f87
movl %ebp, %esi
xorl %r15d, %r15d
xorl %edi, %edi
movl $0x7, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x4320
cmpq $-0x1, %rax
cmoveq %r15, %rax
movq %rax, (%r14)
testq %rax, %rax
je 0x4f92
movl %ebp, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x0, (%rbx)
leaq 0x345c1(%rip), %rdi     # 0x39560
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x455c
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::SHA1::init()
void SHA1::init() {
  len=0;
  h[0]=0x67452301;
  h[1]=0xEFCDAB89;
  h[2]=0x98BADCFE;
  h[3]=0x10325476;
  h[4]=0xC3D2E1F0;
  memset(w, 0, sizeof(w));
}

// Assembly:
movq $0x0, (%rdi)
movaps 0x302c4(%rip), %xmm0    # 0x35280
movups %xmm0, 0x8(%rdi)
movl $0xc3d2e1f0, 0x18(%rdi) # imm = 0xC3D2E1F0
xorps %xmm0, %xmm0
movups %xmm0, 0x1c(%rdi)
movups %xmm0, 0x2c(%rdi)
movups %xmm0, 0x3c(%rdi)
movups %xmm0, 0x4c(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::SHA1::result()
const char* SHA1::result() {

  // pad and append length
  const U64 s=len;
  put(0x80);
  while ((len&511)!=448)
    put(0);
  put(s>>56);
  put(s>>48);
  put(s>>40);
  put(s>>32);
  put(s>>24);
  put(s>>16);
  put(s>>8);
  put(s);

  // copy h to hbuf
  for (int i=0; i<5; ++i) {
    hbuf[4*i]=h[i]>>24;
    hbuf[4*i+1]=h[i]>>16;
    hbuf[4*i+2]=h[i]>>8;
    hbuf[4*i+3]=h[i];
  }

  // return hash prior to clearing state
  init();
  return hbuf;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movl $0x80, %esi
callq 0x33712
movl $0x1ff, %ebp            # imm = 0x1FF
movl (%rbx), %eax
andl %ebp, %eax
cmpl $0x1c0, %eax            # imm = 0x1C0
je 0x500c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x33712
jmp 0x4ff5
movq %r14, %rsi
shrq $0x38, %rsi
movq %rbx, %rdi
callq 0x33712
movq %r14, %rsi
shrq $0x30, %rsi
movq %rbx, %rdi
callq 0x33712
movq %r14, %rsi
shrq $0x28, %rsi
movq %rbx, %rdi
callq 0x33712
movq %r14, %rsi
shrq $0x20, %rsi
movq %rbx, %rdi
callq 0x33712
movq %r14, %rsi
shrq $0x18, %rsi
movq %rbx, %rdi
callq 0x33712
movq %r14, %rsi
shrq $0x10, %rsi
movq %rbx, %rdi
callq 0x33712
movq %r14, %rsi
shrq $0x8, %rsi
movq %rbx, %rdi
callq 0x33712
movq %rbx, %rdi
movl %r14d, %esi
callq 0x33712
leaq 0x5c(%rbx), %rax
movl $0x5f, %ecx
movl -0x57(%rbx,%rcx), %edx
bswapl %edx
movl %edx, -0x3(%rbx,%rcx)
addq $0x4, %rcx
cmpq $0x73, %rcx
jne 0x5089
movq $0x0, (%rbx)
movaps 0x301d5(%rip), %xmm0    # 0x35280
movups %xmm0, 0x8(%rbx)
movl $0xc3d2e1f0, 0x18(%rbx) # imm = 0xC3D2E1F0
xorps %xmm0, %xmm0
movups %xmm0, 0x1c(%rbx)
movups %xmm0, 0x2c(%rbx)
movups %xmm0, 0x3c(%rbx)
movups %xmm0, 0x4c(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::SHA1::write(char const*, long)
void SHA1::write(const char* buf, int64_t n) {
  const unsigned char* p=(const unsigned char*) buf;
  for (; n>0 && (U32(len)&511)!=0; --n) put(*p++);
  for (; n>=64; n-=64) {
    for (int i=0; i<16; ++i)
      w[i]=p[0]<<24|p[1]<<16|p[2]<<8|p[3], p+=4;
    len+=512;
    process();
  }
  for (; n>0; --n) put(*p++);
}

// Assembly:
testq %rdx, %rdx
jle 0x5189
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movzwl (%rbx), %eax
testl $0x1ff, %eax            # imm = 0x1FF
je 0x5113
movzbl (%r15), %esi
incq %r15
movq %rbx, %rdi
callq 0x33712
leaq -0x1(%r14), %rax
cmpq $0x1, %r14
movq %rax, %r14
jg 0x50eb
jmp 0x517b
cmpq $0x40, %r14
jb 0x5160
movq %r14, %rbp
movq %r15, %r12
xorl %r13d, %r13d
movl (%r12,%r13), %eax
bswapl %eax
movl %eax, 0x1c(%rbx,%r13)
addq $0x4, %r13
cmpq $0x40, %r13
jne 0x5122
addq $0x200, (%rbx)          # imm = 0x200
movq %rbx, %rdi
callq 0x518a
leaq -0x40(%rbp), %r14
leaq (%r12,%r13), %r15
cmpq $0x7f, %rbp
jg 0x5119
cmpq $0x41, %rbp
jl 0x517b
addq %r13, %r12
movq %r12, %r15
incq %r14
movzbl (%r15), %esi
incq %r15
movq %rbx, %rdi
callq 0x33712
decq %r14
cmpq $0x1, %r14
ja 0x5163
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::SHA256::init()
void SHA256::init() {
  len0=len1=0;
  s[0]=0x6a09e667;
  s[1]=0xbb67ae85;
  s[2]=0x3c6ef372;
  s[3]=0xa54ff53a;
  s[4]=0x510e527f;
  s[5]=0x9b05688c;
  s[6]=0x1f83d9ab;
  s[7]=0x5be0cd19;
  memset(w, 0, sizeof(w));
}

// Assembly:
movaps 0x2eea1(%rip), %xmm0    # 0x35290
movups %xmm0, (%rdi)
movaps 0x2eea7(%rip), %xmm0    # 0x352a0
movups %xmm0, 0x10(%rdi)
movabsq $0x5be0cd191f83d9ab, %rax # imm = 0x5BE0CD191F83D9AB
movq %rax, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::SHA256::result()
const char* SHA256::result() {

  // pad and append length
  const unsigned s1=len1, s0=len0;
  put(0x80);
  while ((len0&511)!=448) put(0);
  put(s1>>24);
  put(s1>>16);
  put(s1>>8);
  put(s1);
  put(s0>>24);
  put(s0>>16);
  put(s0>>8);
  put(s0);

  // copy s to hbuf
  for (int i=0; i<8; ++i) {
    hbuf[4*i]=s[i]>>24;
    hbuf[4*i+1]=s[i]>>16;
    hbuf[4*i+2]=s[i]>>8;
    hbuf[4*i+3]=s[i];
  }

  // return hash prior to clearing state
  init();
  return hbuf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %ebp
movl 0x4(%rdi), %r14d
movl $0x80, %esi
callq 0x33742
movl $0x1ff, %r15d           # imm = 0x1FF
movl (%rbx), %eax
andl %r15d, %eax
cmpl $0x1c0, %eax            # imm = 0x1C0
je 0x8880
movq %rbx, %rdi
xorl %esi, %esi
callq 0x33742
jmp 0x8868
movl %r14d, %esi
shrl $0x18, %esi
movq %rbx, %rdi
callq 0x33742
movl %r14d, %esi
shrl $0x10, %esi
movq %rbx, %rdi
callq 0x33742
movl %r14d, %esi
shrl $0x8, %esi
movq %rbx, %rdi
callq 0x33742
movq %rbx, %rdi
movl %r14d, %esi
callq 0x33742
movl %ebp, %esi
shrl $0x18, %esi
movq %rbx, %rdi
callq 0x33742
movl %ebp, %esi
shrl $0x10, %esi
movq %rbx, %rdi
callq 0x33742
movl %ebp, %esi
shrl $0x8, %esi
movq %rbx, %rdi
callq 0x33742
movq %rbx, %rdi
movl %ebp, %esi
callq 0x33742
leaq 0x68(%rbx), %rax
movl $0x6b, %ecx
movl -0x63(%rbx,%rcx), %edx
bswapl %edx
movl %edx, -0x3(%rbx,%rcx)
addq $0x4, %rcx
cmpq $0x8b, %rcx
jne 0x88ef
movaps 0x2c983(%rip), %xmm0    # 0x35290
movups %xmm0, (%rbx)
movaps 0x2c989(%rip), %xmm0    # 0x352a0
movups %xmm0, 0x10(%rbx)
movabsq $0x5be0cd191f83d9ab, %rcx # imm = 0x5BE0CD191F83D9AB
movq %rcx, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::AES_CTR::encrypt(char*, int, unsigned long)
void AES_CTR::encrypt(char* buf, int n, U64 offset) {
  for (U64 i=offset/16; i<=(offset+n)/16; ++i) {
    unsigned char ct[16];
    encrypt(iv0, iv1, i>>32, i, ct);
    for (int j=0; j<16; ++j) {
      const int k=i*16-offset+j;
      if (k>=0 && k<n)
        buf[k]^=ct[j];
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r13
shrq $0x4, %r13
movslq %edx, %rbp
addq %rcx, %rbp
shrq $0x4, %rbp
cmpq %rbp, %r13
ja 0x9233
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl %r13d, %r12d
shll $0x4, %r12d
subl %ecx, %r12d
movl 0x14f4(%r15), %esi
movl 0x14f8(%r15), %edx
movq %r13, %rcx
shrq $0x20, %rcx
movq %r15, %rdi
movl %r13d, %r8d
movq %rsp, %r9
callq 0x8e12
xorl %eax, %eax
leaq (%r12,%rax), %rcx
testl %ecx, %ecx
sets %dl
cmpl %ebx, %ecx
setge %sil
orb %dl, %sil
jne 0x921a
movb (%rsp,%rax), %dl
movl %ecx, %ecx
xorb %dl, (%r14,%rcx)
incq %rax
cmpq $0x10, %rax
jne 0x91fd
leaq 0x1(%r13), %rax
addq $0x10, %r12
cmpq %rbp, %r13
movq %rax, %r13
jne 0x91d8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::random(char*, int)
void random(char* buf, int n) {
#ifdef unix
  FILE* in=fopen("/dev/urandom", "rb");
  if (in && int(fread(buf, 1, n, in))==n)
    fclose(in);
  else {
    error("key generation failed");
  }
#else
  HCRYPTPROV h;
  if (CryptAcquireContext(&h, NULL, NULL, PROV_RSA_FULL,
      CRYPT_VERIFYCONTEXT) && CryptGenRandom(h, n, (BYTE*)buf))
    CryptReleaseContext(h, 0);
  else {
    fprintf(stderr, "CryptGenRandom: error %d\n", int(GetLastError()));
    error("key generation failed");
  }
#endif
  if (n>=1 && (buf[0]=='z' || buf[0]=='7'))
    buf[0]^=0x80;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x2fdb7(%rip), %rdi     # 0x3956e
leaq 0x2fdbd(%rip), %rsi     # 0x3957b
callq 0x41f0
testq %rax, %rax
je 0x97f0
movq %rax, %r14
movslq %ebp, %r15
movl $0x1, %esi
movq %rbx, %rdi
movq %r15, %rdx
movq %rax, %rcx
callq 0x4270
cmpl %r15d, %eax
jne 0x97f0
movq %r14, %rdi
callq 0x4160
jmp 0x97fc
leaq 0x2fd87(%rip), %rdi     # 0x3957e
callq 0x455c
testl %ebp, %ebp
jle 0x9811
movzbl (%rbx), %eax
cmpl $0x7a, %eax
je 0x980d
cmpl $0x37, %eax
jne 0x9811
addb $-0x80, %al
movb %al, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Component::init()
void Component::init() {
  limit=cxt=a=b=c=0;
  cm.resize(0);
  ht.resize(0);
  a16.resize(0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x28, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq $0x0, 0x20(%rbx)
xorl %esi, %esi
xorl %edx, %edx
callq 0x3378c
leaq 0x40(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3386a
addq $0x58, %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
jmp 0x33938
nop
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::ZPAQL::clear()
void ZPAQL::clear() {
  cend=hbegin=hend=0;  // COMP and HCOMP locations
  a=b=c=d=f=pc=0;      // machine state
  header.resize(0);
  h.resize(0);
  m.resize(0);
  r.resize(0);
  allocx(rcode, rcode_size, 0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x0, 0x30(%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
addq $0x10, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x9c(%rbx)
movq %rax, 0xac(%rbx)
xorl %esi, %esi
xorl %edx, %edx
callq 0x3386a
leaq 0x50(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3378c
leaq 0x38(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3386a
leaq 0x68(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3378c
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
sete %cl
movl 0xb4(%rbx), %eax
testl %eax, %eax
sete %dl
testb %dl, %cl
jne 0x9c00
testq %rdi, %rdi
je 0x9beb
movslq %eax, %rsi
callq 0x40f0
movq $0x0, 0xb8(%rbx)
movl $0x0, 0xb4(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::ZPAQL::ZPAQL()
ZPAQL::ZPAQL() {
  output=0;
  sha1=0;
  rcode=0;
  rcode_size=0;
  clear();
  outbuf.resize(1<<14);
  bufptr=0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
leaq 0x10(%rdi), %rbx
xorl %r15d, %r15d
movl %r15d, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3386a
leaq 0x38(%r12), %r14
movl %r15d, 0x48(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r12)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3386a
leaq 0x50(%r12), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r12)
movl $0x0, 0x60(%r12)
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3378c
leaq 0x68(%r12), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%r12)
movl $0x0, 0x78(%r12)
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3378c
leaq 0x80(%r12), %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%r12)
movl $0x0, 0x90(%r12)
movq %rbp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33a16
movq $0x0, 0xb8(%r12)
movl $0x0, 0xb4(%r12)
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movq %r12, %rdi
callq 0x9b6c
movl $0x4000, %esi           # imm = 0x4000
movq %rbp, %rdi
xorl %edx, %edx
callq 0x33a16
movl $0x0, 0x98(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
jmp 0x9d30
movq %rax, %r12
jmp 0x9d38
movq %rax, %r12
jmp 0x9d40
movq %rax, %r12
jmp 0x9d48
movq %rax, %r12
movq %rbp, %rdi
callq 0x33778
movq %r13, %rdi
callq 0x33ae4
movq %r15, %rdi
callq 0x33ae4
movq %r14, %rdi
callq 0x33af8
movq %rbx, %rdi
callq 0x33af8
movq %r12, %rdi
callq 0x4310
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::ZPAQL::init(int, int)
void ZPAQL::init(int hbits, int mbits) {
  assert(header.isize()>0);
  assert(cend>=7);
  assert(hbegin>=cend+128);
  assert(hend>=hbegin);
  assert(hend<header.isize()-130);
  assert(header[0]+256*header[1]==cend-2+hend-hbegin);
  assert(bufptr==0);
  assert(outbuf.isize()>0);
  if (hbits>32) error("H too big");
  if (mbits>32) error("M too big");
  h.resize(1, hbits);
  m.resize(1, mbits);
  r.resize(256);
  a=b=c=d=pc=f=0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
cmpl $0x21, %esi
jl 0x9dfd
leaq 0x2f811(%rip), %rdi     # 0x39609
callq 0x455c
cmpl $0x21, %ebp
jl 0x9e0e
leaq 0x2f80a(%rip), %rdi     # 0x39613
callq 0x455c
leaq 0x50(%rbx), %rdi
movl $0x1, %esi
movl %r14d, %edx
callq 0x3378c
leaq 0x38(%rbx), %rdi
movl $0x1, %esi
movl %ebp, %edx
callq 0x3386a
leaq 0x68(%rbx), %rdi
movl $0x100, %esi            # imm = 0x100
xorl %edx, %edx
callq 0x3378c
xorps %xmm0, %xmm0
movups %xmm0, 0x9c(%rbx)
movq $0x0, 0xac(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::ZPAQL::run0(unsigned int)
void ZPAQL::run0(U32 input) {
  assert(cend>6);
  assert(hbegin>=cend+128);
  assert(hend>=hbegin);
  assert(hend<header.isize()-130);
  assert(m.size()>0);
  assert(h.size()>0);
  assert(header[0]+256*header[1]==cend+hend-hbegin-2);
  pc=hbegin;
  a=input;
  while (execute()) ;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x2c(%rdi), %eax
movl %eax, 0xb0(%rdi)
movl %esi, 0x9c(%rdi)
movq %rbx, %rdi
callq 0xa0a0
testl %eax, %eax
jne 0xa091
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Predictor::Predictor(libzpaq::ZPAQL&)
Predictor::Predictor(ZPAQL& zr):
    c8(1), hmap4(1), z(zr) {
  assert(sizeof(U8)==1);
  assert(sizeof(U16)==2);
  assert(sizeof(U32)==4);
  assert(sizeof(U64)==8);
  assert(sizeof(short)==2);
  assert(sizeof(int)==4);
  pcode=0;
  pcode_size=0;
  initTables=false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, (%rdi)
movq %rsi, 0x808(%rdi)
leaq 0x810(%rdi), %r14
xorl %r15d, %r15d
leaq (%r14,%r15), %rdi
callq 0x33b4e
addq $0x70, %r15
cmpq $0x7000, %r15           # imm = 0x7000
jne 0xb166
leaq 0x1ac14(%rbx), %rdi
leaq 0x2b506(%rip), %rsi     # 0x36690
movl $0x400, %edx            # imm = 0x400
callq 0x4140
movq $0x0, 0x1b018(%rbx)
movl $0x0, 0x1b020(%rbx)
movb $0x0, 0x7810(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
testq %r15, %r15
je 0xb1d4
addq $0x7a0, %rbx            # imm = 0x7A0
leaq (%rbx,%r15), %rdi
callq 0x33bf4
addq $-0x70, %r15
jne 0xb1c5
movq %r14, %rdi
callq 0x4310
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Predictor::find(libzpaq::Array<unsigned char>&, int, unsigned int)
size_t Predictor::find(Array<U8>& ht, int sizebits, U32 cxt) {
  assert(initTables);
  assert(ht.size()==size_t(16)<<sizebits);
  int chk=cxt>>sizebits&255;
  size_t h0=(cxt*16)&(ht.size()-16);
  if (ht[h0]==chk) return h0;
  size_t h1=h0^16;
  if (ht[h1]==chk) return h1;
  size_t h2=h0^32;
  if (ht[h2]==chk) return h2;
  if (ht[h0+1]<=ht[h1+1] && ht[h0+1]<=ht[h2+1])
    return memset(&ht[h0], 0, 16), ht[h0]=chk, h0;
  else if (ht[h1+1]<ht[h2+1])
    return memset(&ht[h1], 0, 16), ht[h1]=chk, h1;
  else
    return memset(&ht[h2], 0, 16), ht[h2]=chk, h2;
}

// Assembly:
movl %ecx, %edi
movl %edx, %ecx
movl %edi, %edx
shrl %cl, %edx
shll $0x4, %edi
movl 0x8(%rsi), %eax
addl $-0x10, %eax
andl %edi, %eax
movq (%rsi), %rcx
cmpb %dl, (%rcx,%rax)
jne 0xc168
retq
movq %rax, %rdi
xorq $0x10, %rdi
cmpb %dl, (%rcx,%rdi)
jne 0xc178
movq %rdi, %rax
retq
movq %rax, %r8
xorq $0x20, %r8
cmpb %dl, (%rcx,%r8)
jne 0xc189
movq %r8, %rax
retq
movb 0x1(%rcx,%rax), %r9b
movb 0x1(%rcx,%rdi), %r10b
movq %r8, %r11
orq $0x1, %r11
cmpb %r10b, %r9b
ja 0xc1a5
cmpb (%rcx,%r11), %r9b
jbe 0xc1be
leaq (%rcx,%rdi), %rax
leaq (%rcx,%r8), %r9
cmpb (%rcx,%r11), %r10b
cmovbq %rax, %r9
cmovbq %rdi, %r8
movq %r8, %rax
jmp 0xc1c4
addq %rax, %rcx
movq %rcx, %r9
xorps %xmm0, %xmm0
movups %xmm0, (%r9)
movq (%rsi), %rcx
movb %dl, (%rcx,%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::ZPAQL::run(unsigned int)
void ZPAQL::run(U32 input) {
#ifdef NOJIT
  run0(input);
#else
  if (!rcode) {
    allocx(rcode, rcode_size, (hend*10+4096)&-4096);
    int n=assemble();
    if (n>rcode_size) {
      allocx(rcode, rcode_size, n);
      n=assemble();
    }
    if (!rcode || n<10 || rcode_size<10)
      error("run JIT failed");
  }
  a=input;
  const U32 rc=((int(*)())(&rcode[0]))();
  if (rc==0) return;
  else if (rc==1) libzpaq::error("Bad ZPAQL opcode");
  else if (rc==2) libzpaq::error("Out of memory");
  else if (rc==3) libzpaq::error("Write error");
  else libzpaq::error("ZPAQL execution error");
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0xb8(%rdi), %rax
testq %rax, %rax
jne 0xc779
leaq 0xb8(%r14), %r15
leaq 0xb4(%r14), %r12
movl 0x30(%r14), %eax
addl %eax, %eax
leal (%rax,%rax,4), %edx
andl $0xfffff000, %edx       # imm = 0xFFFFF000
addl $0x1000, %edx           # imm = 0x1000
movq %r15, %rdi
movq %r12, %rsi
callq 0x4f15
movq %r14, %rdi
callq 0x10d96
movl 0xb4(%r14), %ecx
cmpl %ecx, %eax
jle 0xc758
movq %r15, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x4f15
movq %r14, %rdi
callq 0x10d96
movl 0xb4(%r14), %ecx
cmpl $0xa, %eax
jl 0xc76a
movq (%r15), %rax
testq %rax, %rax
je 0xc76a
cmpl $0x9, %ecx
jg 0xc779
leaq 0x2d6ec(%rip), %rdi     # 0x39e5d
callq 0x455c
movq (%r15), %rax
movl %ebx, 0x9c(%r14)
callq *%rax
cmpl $0x3, %eax
ja 0xc7c0
movl %eax, %eax
leaq 0x29808(%rip), %rcx     # 0x35f98
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2d6d1(%rip), %rdi     # 0x39e7d
jmp 0xc7c7
leaq 0x2d6d6(%rip), %rdi     # 0x39e8b
jmp 0xc7c7
leaq 0x2d6ae(%rip), %rdi     # 0x39e6c
jmp 0xc7c7
leaq 0x2ce56(%rip), %rdi     # 0x3961d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x455c
nop
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Decoder::decode(int)
int Decoder::decode(int p) {
  assert(pr.isModeled());
  assert(p>=0 && p<65536);
  assert(high>low && low>0);
  if (curr<low || curr>high) error("archive corrupted");
  assert(curr>=low && curr<=high);
  U32 mid=low+U32(((high-low)*U64(U32(p)))>>16);  // split range
  assert(high>mid && mid>=low);
  int y;
  if (curr<=mid) y=1, high=mid;  // pick half
  else y=0, low=mid+1;
  while ((high^low)<0x1000000) { // shift out identical leading bytes
    high=high<<8|255;
    low=low<<8;
    low+=(low==0);
    int c=get();
    if (c<0) error("unexpected end of file");
    curr=curr<<8|c;
  }
  return y;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x18(%rdi), %esi
movl 0x10(%rdi), %eax
movl 0x14(%rdi), %edx
cmpl %eax, %esi
setb %cl
cmpl %edx, %esi
seta %dil
orb %cl, %dil
cmpb $0x1, %dil
jne 0xc8be
leaq 0x2ced0(%rip), %rdi     # 0x39780
callq 0x455c
movl 0x10(%rbx), %eax
movl 0x14(%rbx), %edx
movl 0x18(%rbx), %esi
movl %edx, %edi
subl %eax, %edi
movl %ebp, %ecx
imulq %rdi, %rcx
shrq $0x10, %rcx
addl %eax, %ecx
cmpl %ecx, %esi
jbe 0xc8df
incl %ecx
movl %ecx, 0x10(%rbx)
xorl %ebp, %ebp
movl %ecx, %eax
movl %edx, %ecx
jmp 0xc8e7
movl %ecx, 0x14(%rbx)
movl $0x1, %ebp
movl %eax, %edx
xorl %ecx, %edx
cmpl $0xffffff, %edx         # imm = 0xFFFFFF
ja 0xc948
leaq 0x2cc9a(%rip), %r14     # 0x39594
shll $0x8, %ecx
orl $0xff, %ecx
movl %ecx, 0x14(%rbx)
xorl %ecx, %ecx
shll $0x8, %eax
sete %cl
orl %eax, %ecx
movl %ecx, 0x10(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movl %eax, %r15d
testl %eax, %eax
jns 0xc92a
movq %r14, %rdi
callq 0x455c
movl 0x18(%rbx), %eax
shll $0x8, %eax
orl %r15d, %eax
movl %eax, 0x18(%rbx)
movl 0x10(%rbx), %eax
movl 0x14(%rbx), %ecx
movl %eax, %edx
xorl %ecx, %edx
cmpl $0x1000000, %edx        # imm = 0x1000000
jb 0xc8fa
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Decoder::decompress()
int Decoder::decompress() {
  if (pr.isModeled()) {  // n>0 components?
    if (curr==0) {  // segment initialization
      for (int i=0; i<4; ++i)
        curr=curr<<8|get();
    }
    if (decode(0)) {
      if (curr!=0) error("decoding end of stream");
      return -1;
    }
    else {
      int c=1;
      while (c<256) {  // get 8 bits
        int p=pr.predict()*2+1;
        c+=c+decode(p);
        pr.update(c&1);
      }
      return c-256;
    }
  }
  else {
    if (curr==0) {
      for (int i=0; i<4; ++i) curr=curr<<8|get();
      if (curr==0) return -1;
    }
    --curr;
    return get();
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x830(%rdi), %rax
movq 0x10(%rax), %rax
cmpb $0x0, 0x6(%rax)
movl 0x18(%rdi), %eax
je 0xc9c1
testl %eax, %eax
jne 0xc995
xorl %ebp, %ebp
movl $0x4, %r14d
shll $0x8, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
orl %eax, %ebp
movl %ebp, 0x18(%rbx)
decl %r14d
jne 0xc980
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc880
testl %eax, %eax
je 0xca00
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmpl $0x0, 0x18(%rbx)
je 0xca3f
leaq 0x2cdd8(%rip), %rdi     # 0x39792
callq 0x455c
jmp 0xca3f
testl %eax, %eax
jne 0xc9e9
xorl %eax, %eax
movl $0x4, %ebp
movl %eax, %r14d
shll $0x8, %r14d
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
orl %r14d, %eax
movl %eax, 0x18(%rbx)
decl %ebp
jne 0xc9cc
testl %eax, %eax
je 0xca4d
decl %eax
movl %eax, 0x18(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *(%rax)
leaq 0x28(%rbx), %r15
movl $0x1, %r14d
movq %r15, %rdi
callq 0xca56
leal 0x1(,%rax,2), %esi
movq %rbx, %rdi
callq 0xc880
leal (%rax,%r14,2), %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0xcaf6
cmpl $0x100, %r14d           # imm = 0x100
jl 0xca0a
addl $0xffffff00, %r14d      # imm = 0xFFFFFF00
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0xca3f
nop
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Predictor::predict()
int Predictor::predict() {
#ifdef NOJIT
  return predict0();
#else
  if (!pcode) {
    allocx(pcode, pcode_size, (z.cend*100+4096)&-4096);
    int n=assemble_p();
    if (n>pcode_size) {
      allocx(pcode, pcode_size, n);
      n=assemble_p();
    }
    if (!pcode || n<15 || pcode_size<15)
      error("run JIT failed");
  }
  assert(pcode && pcode[0]);
  return ((int(*)(Predictor*))&pcode[10])(this);
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x1b018(%rdi), %rax
testq %rax, %rax
jne 0xcae8
leaq 0x1b018(%rbx), %r14
leaq 0x1b020(%rbx), %r15
movq 0x808(%rbx), %rax
imull $0x64, 0x28(%rax), %edx
andl $0xfffff000, %edx       # imm = 0xFFFFF000
addl $0x1000, %edx           # imm = 0x1000
movq %r14, %rdi
movq %r15, %rsi
callq 0x4f15
movq %rbx, %rdi
callq 0x148f8
movl 0x1b020(%rbx), %ecx
cmpl %ecx, %eax
jle 0xcac7
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x4f15
movq %rbx, %rdi
callq 0x148f8
movl 0x1b020(%rbx), %ecx
cmpl $0xf, %eax
jl 0xcad9
movq (%r14), %rax
testq %rax, %rax
je 0xcad9
cmpl $0xe, %ecx
jg 0xcae8
leaq 0x2d37d(%rip), %rdi     # 0x39e5d
callq 0x455c
movq (%r14), %rax
addq $0xa, %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Predictor::update(int)
void Predictor::update(int y) {
#ifdef NOJIT
  update0(y);
#else
  assert(pcode && pcode[5]);
  ((void(*)(Predictor*, int))&pcode[5])(this, y);

  // Save bit y in c8, hmap4 (not implemented in JIT)
  c8+=c8+y;
  if (c8>=256) {
    z.run(c8-256);
    hmap4=1;
    c8=1;
    for (int i=0; i<z.header[6]; ++i) h[i]=z.H(i);
  }
  else if (c8>=16 && c8<32)
    hmap4=(hmap4&0xf)<<5|y<<4|1;
  else
    hmap4=(hmap4&0x1f0)|(((hmap4&0xf)*2+y)&0xf);
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq 0x1b018(%rdi), %rax
addq $0x5, %rax
callq *%rax
movl (%rbx), %eax
leal (%r14,%rax,2), %esi
movl %esi, (%rbx)
cmpl $0x100, %esi            # imm = 0x100
jl 0xcb7a
movq 0x808(%rbx), %rdi
addl $0xffffff00, %esi       # imm = 0xFFFFFF00
callq 0xc6e2
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, (%rbx)
movq 0x808(%rbx), %rsi
movq 0x10(%rsi), %rax
cmpb $0x0, 0x6(%rax)
je 0xcbae
movq 0x50(%rsi), %rcx
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
addq 0x58(%rsi), %rdx
xorl %esi, %esi
movq %rdx, %rdi
andq %rsi, %rdi
movl (%rcx,%rdi,4), %edi
movl %edi, 0x408(%rbx,%rsi,4)
incq %rsi
movzbl 0x6(%rax), %edi
cmpq %rdi, %rsi
jb 0xcb5c
jmp 0xcbae
andl $-0x10, %esi
movl 0x4(%rbx), %eax
cmpl $0x10, %esi
jne 0xcb97
andl $0xf, %eax
shll $0x5, %eax
shll $0x4, %r14d
orl %eax, %r14d
incl %r14d
jmp 0xcbaa
movl %eax, %ecx
andl $0x1f0, %ecx            # imm = 0x1F0
leal (%r14,%rax,2), %r14d
andl $0xf, %r14d
orl %ecx, %r14d
movl %r14d, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Decoder::skip()
int Decoder::skip() {
  int c=-1;
  if (pr.isModeled()) {
    while (curr==0)  // at start?
      curr=get();
    while (curr && (c=get())>=0)  // find 4 zeros
      curr=curr<<8|c;
    while ((c=get())==0) ;  // might be more than 4
    return c;
  }
  else {
    if (curr==0)  // at start?
      for (int i=0; i<4 && (c=get())>=0; ++i) curr=curr<<8|c;
    while (curr>0) {
      while (curr>0) {
        --curr;
        if (get()<0) return error("skipped to EOF"), -1;
      }
      for (int i=0; i<4 && (c=get())>=0; ++i) curr=curr<<8|c;
    }
    if (c>=0) c=get();
    return c;
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x830(%rdi), %rax
movq 0x10(%rax), %rax
cmpb $0x0, 0x6(%rax)
movl 0x18(%rdi), %ecx
je 0xcc0a
testl %ecx, %ecx
jne 0xcbe3
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movl %eax, 0x18(%rbx)
testl %eax, %eax
je 0xcbd4
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
testl %eax, %eax
js 0xcbfc
movl 0x18(%rbx), %ecx
shll $0x8, %ecx
orl %eax, %ecx
movl %ecx, 0x18(%rbx)
jne 0xcbe3
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
testl %eax, %eax
je 0xcbfc
jmp 0xcc7d
testl %ecx, %ecx
jne 0xcc32
movl $0x4, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movl 0x18(%rbx), %ecx
testl %eax, %eax
js 0xcc2e
shll $0x8, %ecx
orl %eax, %ecx
movl %ecx, 0x18(%rbx)
decl %ebp
jne 0xcc13
testl %ecx, %ecx
je 0xcc84
decl %ecx
movl %ecx, 0x18(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
testl %eax, %eax
js 0xcc6c
movl 0x18(%rbx), %ecx
testl %ecx, %ecx
jne 0xcc32
movl $0x4, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movl 0x18(%rbx), %ecx
testl %eax, %eax
js 0xcc2e
shll $0x8, %ecx
orl %eax, %ecx
movl %ecx, 0x18(%rbx)
decl %ebp
jne 0xcc4f
jmp 0xcc2e
leaq 0x2cb36(%rip), %rdi     # 0x397a9
callq 0x455c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
testl %eax, %eax
js 0xcc7d
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *(%rax)
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Decompresser::findBlock(double*)
bool Decompresser::findBlock(double* memptr) {
  assert(state==BLOCK);

  // Find start of block
  U32 h1=0x3D49B113, h2=0x29EB7F93, h3=0x2614BE13, h4=0x3828EB13;
  // Rolling hashes initialized to hash of first 13 bytes
  int c;
  while ((c=dec.get())!=-1) {
    h1=h1*12+c;
    h2=h2*20+c;
    h3=h3*28+c;
    h4=h4*44+c;
    if (h1==0xB16B88F1 && h2==0xFF5376F1 && h3==0x72AC5BF1 && h4==0x2F909AF1)
      break;  // hash of 16 byte string
  }
  if (c==-1) return false;

  // Read header
  if ((c=dec.get())!=1 && c!=2) error("unsupported ZPAQ level");
  if (dec.get()!=1) error("unsupported ZPAQL type");
  z.read(&dec);
  if (c==1 && z.header.isize()>6 && z.header[6]==0)
    error("ZPAQ level 1 requires at least 1 component");
  if (memptr) *memptr=z.memory();
  state=FILENAME;
  decode_state=FIRSTSEG;
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc0(%rdi), %r15
movdqa 0x28509(%rip), %xmm2    # 0x35380
pshufd $0xf5, 0x28510(%rip), %xmm0 # xmm0 = mem[1,1,3,3]
movdqa %xmm0, (%rsp)
movdqa %xmm2, 0x10(%rsp)
movq %r15, %rdi
callq 0x33c18
movl %eax, %ebp
cmpl $-0x1, %eax
je 0xcf69
movdqa 0x10(%rsp), %xmm1
pshufd $0xf5, %xmm1, %xmm0     # xmm0 = xmm1[1,1,3,3]
pmuludq 0x284df(%rip), %xmm1    # 0x35390
pshufd $0xe8, %xmm1, %xmm1     # xmm1 = xmm1[0,2,2,3]
pmuludq (%rsp), %xmm0
pshufd $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3]
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movd %ebp, %xmm0
pshufd $0x0, %xmm0, %xmm2      # xmm2 = xmm0[0,0,0,0]
paddd %xmm1, %xmm2
movdqa %xmm2, %xmm0
pcmpeqd 0x284c3(%rip), %xmm0    # 0x353a0
movmskps %xmm0, %eax
xorl $0xf, %eax
jne 0xce85
movq %r15, %rdi
callq 0x33c18
movl %eax, %r12d
leal -0x3(%r12), %eax
cmpl $-0x3, %eax
ja 0xcf06
leaq 0x2c8ef(%rip), %rdi     # 0x397f0
callq 0x455c
movq %r15, %rdi
callq 0x33c18
cmpl $0x1, %eax
je 0xcf1f
leaq 0x2c8ed(%rip), %rdi     # 0x39807
callq 0x455c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x991a
cmpl $0x1, %r12d
jne 0xcf4c
cmpl $0x7, 0x18(%rbx)
jl 0xcf4c
movq 0x10(%rbx), %rax
cmpb $0x0, 0x6(%rax)
jne 0xcf4c
leaq 0x2c8d7(%rip), %rdi     # 0x3981e
callq 0x455c
testq %r14, %r14
je 0xcf5e
movq %rbx, %rdi
callq 0x9eb4
movq %xmm0, (%r14)
movq $0x1, 0x1b1f8(%rbx)
cmpl $-0x1, %ebp
setne %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Decompresser::findFilename(libzpaq::Writer*)
bool Decompresser::findFilename(Writer* filename) {
  assert(state==FILENAME);
  int c=dec.get();
  if (c==1) {  // segment found
    while (true) {
      c=dec.get();
      if (c==-1) error("unexpected EOF");
      if (c==0) {
        state=COMMENT;
        return true;
      }
      if (filename) filename->put(c);
    }
  }
  else if (c==255) {  // end of block found
    state=BLOCK;
    return false;
  }
  else
    error("missing segment or end of block");
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0xc0(%rdi), %r12
movq %r12, %rdi
callq 0x33c18
movl %eax, %ebx
cmpl $0x1, %eax
jne 0xcfe5
leaq 0x2c89f(%rip), %r13     # 0x39849
movq %r12, %rdi
callq 0x33c18
movl %eax, %ebp
cmpl $-0x1, %eax
je 0xcfbf
testl %ebp, %ebp
jne 0xcfc7
jmp 0xcfd8
movq %r13, %rdi
callq 0x455c
testq %r15, %r15
je 0xcfaa
movq (%r15), %rax
movq %r15, %rdi
movl %ebp, %esi
callq *(%rax)
jmp 0xcfaa
movl $0x2, 0x1b1f8(%r14)
jmp 0xd006
cmpl $0xff, %ebx
jne 0xcffa
movl $0x0, 0x1b1f8(%r14)
jmp 0xd006
leaq 0x2c857(%rip), %rdi     # 0x39858
callq 0x455c
cmpl $0x1, %ebx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::Decompresser::readComment(libzpaq::Writer*)
void Decompresser::readComment(Writer* comment) {
  assert(state==COMMENT);
  state=DATA;
  while (true) {
    int c=dec.get();
    if (c==-1) error("unexpected EOF");
    if (c==0) break;
    if (comment) comment->put(c);
  }
  if (dec.get()!=0) error("missing reserved byte");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x3, 0x1b1f8(%rdi)
addq $0xc0, %rbx
leaq 0x2c808(%rip), %r15     # 0x39849
movq %rbx, %rdi
callq 0x33c18
movl %eax, %ebp
cmpl $-0x1, %eax
je 0xd056
testl %ebp, %ebp
jne 0xd05e
jmp 0xd06f
movq %r15, %rdi
callq 0x455c
testq %r14, %r14
je 0xd041
movq (%r14), %rax
movq %r14, %rdi
movl %ebp, %esi
callq *(%rax)
jmp 0xd041
movq %rbx, %rdi
callq 0x33c18
testl %eax, %eax
je 0xd091
leaq 0x2c7f6(%rip), %rdi     # 0x39878
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x455c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq