LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: genFullExpr::prepMultiWord()
void prepMultiWord() {
        bool l5var1z;
        InsnList * l5var2z;

        l5var1z = otherIns->regsused.has(12);
        setAddrTo(12);
        if (l5var1z) {
            addToInsnList(KITA+12);
            addToInsnList(macro + mcPUSH);
        }
        l5var2z = insnList;
        insnList = otherIns;
        setAddrTo(14);
        if (l5var1z) {
            addToInsnList(macro + mcPOP);
            addToInsnList(KATI+12);
        }
        l5var2z->regsused = insnList->regsused + l5var2z->regsused;
        l5var2z->next->next = insnList->next2;
        l5var2z->next = insnList->next;
        insnList = l5var2z;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rax), %r15
leaq 0x38(%rsp), %rdi
pushq $0xc
popq %rsi
callq 0x13c48
btq $0x23, %r15
jae 0x13f4e
movl $0x2200c, %edi          # imm = 0x2200C
callq 0x794e
movl $0x1000005, %edi        # imm = 0x1000005
callq 0x794e
movq 0x4fb53(%rip), %r14     # 0x63aa8
movq 0x10(%rbx), %rax
movq %rax, 0x4fb48(%rip)     # 0x63aa8
movq %rsp, %rdi
pushq $0xe
popq %rsi
callq 0x13c48
btq $0x23, %r15
jae 0x13f86
movl $0x1000004, %edi        # imm = 0x1000004
callq 0x794e
movl $0x2000c, %edi          # imm = 0x2000C
callq 0x794e
movq 0x4fb1b(%rip), %rax     # 0x63aa8
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq 0x18(%rax), %rcx
orq %rcx, 0x18(%r14)
movq 0x8(%rax), %rax
movq (%r14), %rcx
movq %rax, (%rcx)
movq 0x4faf8(%rip), %rax     # 0x63aa8
movq (%rax), %rax
movq %rax, (%r14)
movq %r14, 0x4faeb(%rip)     # 0x63aa8
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: genFullExpr::genHelper()
void genHelper() {
        InsnList * &saved = formOperator::super.back()->saved;
        P4606();
        saved = insnList;
        insnList = otherIns;
        prepLoad();
        addToInsnList(getHelperProc(formOperator::super.back()->nextInsn));
        insnList->regsused = insnList->regsused + saved->regsused + BitRange(11,14);
        saved->next->next = insnList->next2;
        insnList->next2 = saved->next2;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xa83e9(%rip), %rax     # 0xbc3c0
movq -0x8(%rax), %r14
callq 0x7ccd
movq 0x4fac1(%rip), %rax     # 0x63aa8
movq %rax, 0x58(%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x4fab2(%rip)     # 0x63aa8
callq 0x79ed
movq 0xa83be(%rip), %rax     # 0xbc3c0
movq -0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x52d1
movq %rax, %rdi
callq 0x794e
movq 0x4fa8a(%rip), %rbx     # 0x63aa8
movq 0x58(%r14), %rax
movq 0x18(%rbx), %r15
orq 0x18(%rax), %r15
pushq $0xb
popq %rdi
pushq $0xe
popq %rsi
callq 0x37ec
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq %r15, %rcx
orq %rax, %rcx
movq %rcx, 0x18(%rbx)
movq 0x8(%rbx), %rax
movq 0x58(%r14), %rcx
movq (%rcx), %rcx
movq %rax, (%rcx)
movq 0x58(%r14), %rax
movq 0x8(%rax), %rax
movq 0x4fa42(%rip), %rcx     # 0x63aa8
movq %rax, 0x8(%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: genFullExpr::negateCond()
void negateCond () {
        if (insnList->ilm == ilCONST) {
            insnList->ilf5.ii = not insnList->ilf5.ii;
        } else {
            insnList->regsused = insnList->regsused ^ Bits(16);
        }
    }

// Assembly:
movq 0x4f903(%rip), %rax     # 0x63aa8
cmpl $0x0, 0x20(%rax)
je 0x141c3
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq 0x18(%rax), %rcx
btcq $0x1f, %rcx
movq %rcx, 0x18(%rax)
retq
xorl %ecx, %ecx
cmpq $0x0, 0x28(%rax)
sete %cl
movq %rcx, 0x28(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: genFullExpr::genConstDiv()
void genConstDiv() {
        // TODO correctly
        curVal.ii = (1L<<47)|(1L << 40)/arg2Val.i; // PASDIV(1/arg2Val.i);
        ++curVal.ii;
        addToInsnList(KMUL+I8 + getFCSToffset());
    }

// Assembly:
pushq %rax
movq 0x20(%rdi), %rcx
shlq $0x17, %rcx
sarq $0x17, %rcx
movabsq $0x10000000000, %rax    # imm = 0x10000000000
xorl %edx, %edx
idivq %rcx
btsq $0x2f, %rax
incq %rax
movq %rax, 0x4f5c1(%rip)     # 0x63a30
callq 0x554f
leaq 0x80f000(%rax), %rdi
popq %rax
jmp 0x794e
nop
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: genFullExpr::P5155()
void P5155() {
        prepLoad();
        insnList->ilm = il1;
        insnList->st = st0;
        insnList->ilf6 = 0;
        insnList->ilf5.i = 0;
        insnList->ilf7 = 18;
    }

// Assembly:
pushq %rax
callq 0x79ed
movq 0x4f44f(%rip), %rax     # 0x63aa8
movl $0x1, 0x20(%rax)
andl $0x0, 0x40(%rax)
andq $0x0, 0x30(%rax)
movzwl 0x2e(%rax), %ecx
shlq $0x30, %rcx
movabsq $0xd00000000000, %rdx   # imm = 0xD00000000000
orq %rcx, %rdx
movq %rdx, 0x28(%rax)
movq $0x12, 0x38(%rax)
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: parseTypeRef::definExprPtrType(Types*)
void definExprPtrType(TypesPtr toType) {
        IdentRecPtr & typelist = programme::super.back()->typelist;
        curType = new PtrT(15, toType);
        curEnum = new IdentRec(curIdent, lineCnt, typelist, curType, TYPEID);
        typelist = curEnum;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0xa7bcc(%rip), %rax     # 0xbc378
movq -0x8(%rax), %r15
pushq $0x20
popq %rdi
callq 0x390b
movq $0x1, (%rax)
movq $0xf, 0x8(%rax)
movl $0x3, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %rax, 0xf0(%r14)
pushq $0x60
popq %rdi
callq 0x390b
movq 0x4f258(%rip), %rcx     # 0x63a40
movq 0x4f0c1(%rip), %rdx     # 0x638b0
movq 0x10(%r15), %rsi
movq 0xf0(%r14), %rdi
movq %rcx, (%rax)
movq %rdx, 0x8(%rax)
movq %rsi, 0x10(%rax)
movq %rdi, 0x18(%rax)
andl $0x0, 0x20(%rax)
movq %rax, 0xc8(%r14)
movq %rax, 0x10(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: initScalars::regSysType(long, Types*)
void regSysType(int64_t l4arg1z, TypesPtr l4arg2z) {
        curIdRec = new IdentRec;
        // curIdRec@ := [l4arg1z, 0, , l4arg2z, TYPEID];
        curIdRec->id = l4arg1z;
        curIdRec->offset = 0;
        curIdRec->typ = l4arg2z;
        curIdRec->cl = TYPEID;
        addToHashTab(curIdRec);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x60
popq %rdi
callq 0x390b
movl $0x6, 0x20(%rax)
movq 0x58(%r15), %rcx
movq %rax, (%rcx)
movq 0x58(%r15), %rax
movq (%rax), %rcx
movq %r14, (%rcx)
andq $0x0, 0x8(%rcx)
movq %rbx, 0x18(%rcx)
movq (%rax), %rdi
andl $0x0, 0x20(%rdi)
popq %rbx
popq %r14
popq %r15
jmp 0x4ebf
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: initScalars::regSysEnum(long, long)
void regSysEnum(int64_t l4arg1z, int64_t l4arg2z) {
        curIdRec = new IdentRec;
        // curIdRec@ := [l4arg1z, 48, , temptype, ENUMID, NULL, l4arg2z];
        curIdRec->id = l4arg1z;
        curIdRec->offset = 48;
        curIdRec->typ = temptype;
        curIdRec->cl = ENUMID;
        curIdRec->list() = NULL;
        curIdRec->value() = l4arg2z;
        addToHashTab(curIdRec);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
pushq $0x60
popq %rdi
callq 0x390b
movl $0x6, 0x20(%rax)
movq 0x58(%r14), %rcx
movq %rax, (%rcx)
movq 0x58(%r14), %rax
movq (%rax), %rcx
movq %r15, (%rcx)
movq $0x30, 0x8(%rcx)
movq 0x48(%r14), %rdx
movq %rdx, 0x18(%rcx)
movq (%rax), %rdi
movl $0x1, 0x20(%rdi)
callq 0x12d6e
andq $0x0, (%rax)
movq 0x58(%r14), %rax
movq (%rax), %rdi
callq 0x12c80
movq %rbx, (%rax)
movq 0x58(%r14), %rax
movq (%rax), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4ebf
nop
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: initScalars::regSysProc(long)
void regSysProc(int64_t l4arg1z) {
        curIdRec = new IdentRec;
        // curIdRec@ := [l4arg1z, 0, , temptype, ROUTINEID, l3var9z];
        curIdRec->id = l4arg1z;
        curIdRec->offset = 0;
        curIdRec->typ = temptype;
        curIdRec->cl = ROUTINEID;
        curIdRec->procno() = l3var9z;
        l3var9z = l3var9z + 1;
        addToHashTab(curIdRec);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x60
popq %rdi
callq 0x390b
movl $0x6, 0x20(%rax)
movq 0x58(%r14), %rcx
movq %rax, (%rcx)
movq 0x58(%r14), %rax
movq (%rax), %rcx
movq %rbx, (%rcx)
andq $0x0, 0x8(%rcx)
movq 0x48(%r14), %rdx
movq %rdx, 0x18(%rcx)
movq (%rax), %rdi
movl $0x2, 0x20(%rdi)
movq 0x40(%r14), %rbx
callq 0x1683e
movq %rbx, (%rax)
incq 0x40(%r14)
movq 0x58(%r14), %rax
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4ebf
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: Real::operator=(long)
void operator=(int64_t i) {
        mantissa = i  & ((1L<<48)-1); exponent = 104;
        if (mantissa == 0)
            exponent = 0;
        else
            while ((mantissa >> 39) == 0 || (mantissa >> 39) == -1) { exponent--; mantissa <<= 1; }
    }

// Assembly:
movabsq $0x1fffffffffe, %rax    # imm = 0x1FFFFFFFFFE
movzwl 0x6(%rdi), %edx
shlq $0x30, %rdx
leaq 0x1(%rax), %r8
andq %rsi, %r8
orq %r8, %rdx
movabsq $0xd00000000000, %rcx   # imm = 0xD00000000000
orq %rdx, %rcx
movq %rcx, (%rdi)
testq %r8, %r8
je 0x162f1
movabsq $-0x1000000000000, %rdx # imm = 0xFFFF000000000000
movabsq $0xfe0000000000, %rsi   # imm = 0xFE0000000000
movabsq $0x18000000000, %r8     # imm = 0x18000000000
movq %rcx, %r9
andq %r8, %r9
cmpq %r8, %r9
je 0x162d3
testq %r9, %r9
jne 0x162f4
leaq (%rcx,%rsi), %r9
andq %rsi, %r9
movq %rcx, %r10
andq %rdx, %r10
orq %r9, %r10
addq %rcx, %rcx
andq %rax, %rcx
orq %r10, %rcx
movq %rcx, (%rdi)
jmp 0x162c3
movq %rdx, (%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: genOneOp::addJumpInsn(long)
void addJumpInsn(int64_t opcode) {
        if (not F3413()) {
            l4inl7z = new OneInsn;
            l4inl7z->next = l4inl6z;
            l4inl7z->mode = curInsn.i;
            l4inl7z->code = 0;
            l4inl7z->offset = 0;
            l4inl6z = l4inl7z;
        };
        addInsnToBuf(macro + opcode + ord(l4inl7z));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x163b6
testb %al, %al
je 0x16363
movq 0x30(%rbx), %rdi
jmp 0x16397
pushq $0x20
popq %rdi
callq 0x390b
movq %rax, %rdi
movq %rax, 0x30(%rbx)
movq 0x28(%rbx), %rax
movq %rax, (%rdi)
movq 0x690(%rbx), %rax
shlq $0x17, %rax
sarq $0x17, %rax
movq %rax, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq %rdi, 0x28(%rbx)
callq 0x3a1d
leaq (%r14,%rax), %rsi
addq $0x1000000, %rsi        # imm = 0x1000000
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x162f6
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: genOneOp::F3413()
bool F3413() {
        bool ret;
        l4inl7z = l4inl6z;
        while (l4inl7z != NULL) {
            if (l4inl7z->mode == curInsn.i) {
                ret = true;
                while (l4inl7z->code == macro) {
                    l4inl7z = reinterpret_cast<OneInsn*>(ptr(l4inl7z->offset));
                }
                return ret;
            } else {
                l4inl7z = l4inl7z->next;
            }
        }
        return false;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
movq 0x690(%rdi), %rax
shlq $0x17, %rax
sarq $0x17, %rax
movq (%r14), %r14
movq %r14, 0x30(%rbx)
testq %r14, %r14
je 0x163fe
cmpq %rax, 0x8(%r14)
jne 0x163d0
movq %r14, %rax
cmpq $0x1000000, 0x10(%rax)  # imm = 0x1000000
jne 0x163fe
movq 0x18(%rax), %rdi
callq 0x39d0
movq %rax, 0x30(%rbx)
jmp 0x163e5
testq %r14, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: ParseData::P16432(long)
void P16432(int64_t l5arg1z) {
        DATAREC l5var1z;

        l5var1z.assn(0, allocDataRef(l4var4z.i));
        if (FcstCnt == l4var3z.i) {
            curVal = l4var8z;
            curVal.i = addCurValToFCST();
        } else {
            curVal = l4var3z;
        }
        l5var1z.assn(1, allocSymtab(0400100000000L | (curVal.ii & halfWord)));
        l5var1z.assn(2, allocDataRef(l5arg1z));
        if (l4var9z.i == 0) {
            curVal.m = l4var7z.m >> 24;
        } else {
            curVal.i = allocSymtab(l4var7z.ii | (l4var9z.ii & halfWord));
        }
        l5var1z.assn(3, curVal.i);
        l4var9z.i = l5arg1z * l4var4z.i + l4var9z.i;
        F.push_back(l5var1z);
        setcount = setcount + 1;
        l4var4z.i = 0;
        l4var3z.i = FcstCnt;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
andq $0x0, 0x10(%rsp)
movq %rdi, %rbx
movq 0x18(%rdi), %rsi
shlq $0x17, %rsi
sarq $0x17, %rsi
callq 0x16a04
movq %rax, %r12
movq 0x10(%rbx), %rax
movq %rax, %rcx
shlq $0x17, %rcx
sarq $0x17, %rcx
cmpq %rcx, 0x4cf80(%rip)     # 0x63830
jne 0x168dd
movq 0x38(%rbx), %rax
movq %rax, 0x4d173(%rip)     # 0x63a30
leaq 0x4d16c(%rip), %r15     # 0x63a30
callq 0x5333
movq %r15, %rdi
movq %rax, %rsi
callq 0x381c
movq 0x4d155(%rip), %rax     # 0x63a30
jmp 0x168e4
movq %rax, 0x4d14c(%rip)     # 0x63a30
leaq 0x10(%rbx), %rcx
movq %rcx, 0x8(%rsp)
andl $0xffffff, %eax         # imm = 0xFFFFFF
movabsq $0x801000000, %rdi      # imm = 0x801000000
orq %rax, %rdi
callq 0x546d
movq %rax, %rbp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16a04
movq %rax, %r15
leaq 0x40(%rbx), %r13
movq 0x30(%rbx), %rdi
movq 0x40(%rbx), %rsi
movq %rsi, %rax
shlq $0x17, %rax
je 0x16954
andl $0xffffff, %esi         # imm = 0xFFFFFF
orq %rsi, %rdi
callq 0x546d
leaq 0x4d0f1(%rip), %rdi     # 0x63a30
movq %rax, %rsi
callq 0x381c
movq 0x4d0e2(%rip), %rdi     # 0x63a30
movq (%r13), %rsi
jmp 0x16965
shrq $0x18, %rdi
andl $0xffffff, %edi         # imm = 0xFFFFFF
movq %rdi, 0x4d0cb(%rip)     # 0x63a30
shll $0xc, %r15d
andl $0xfff000, %r15d        # imm = 0xFFF000
movl $0xfff, %eax            # imm = 0xFFF
andq %rax, %rbp
shlq $0x18, %rbp
andq %rax, %r12
shlq $0x24, %r12
orq %rbp, %r12
orq %r15, %r12
andq %rax, %rdi
orq %r12, %rdi
leaq 0x10(%rsp), %r15
movq %rdi, (%r15)
movq 0x18(%rbx), %rax
shlq $0x17, %rax
sarq $0x17, %rax
imulq %r14, %rax
shlq $0x17, %rsi
sarq $0x17, %rsi
addq %rax, %rsi
movq %r13, %rdi
callq 0x381c
leaq 0x48(%rbx), %rdi
movq %r15, %rsi
callq 0x16a38
incq 0x8(%rbx)
movzwl 0x1e(%rbx), %eax
shlq $0x30, %rax
movabsq $0xd00000000000, %rcx   # imm = 0xD00000000000
orq %rax, %rcx
movq %rcx, 0x18(%rbx)
movq 0x4ce46(%rip), %rsi     # 0x63830
movq 0x8(%rsp), %rdi
callq 0x381c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: ParseData::allocDataRef(long)
int64_t allocDataRef(int64_t l6arg1z) {
        if (l6arg1z >= 2048) {
            curVal.i = l6arg1z;
            return allocSymtab((curVal.ii | 040000000) & halfWord);
        } else {
            return l6arg1z;
        }
    }

// Assembly:
cmpq $0x800, %rsi            # imm = 0x800
jl 0x16a34
pushq %rax
leaq 0x4d01b(%rip), %rdi     # 0x63a30
callq 0x381c
movq 0x4d00f(%rip), %rdi     # 0x63a30
andl $0x7fffff, %edi         # imm = 0x7FFFFF
orq $0x800000, %rdi         # imm = 0x800000
popq %rax
jmp 0x546d
movq %rsi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: standProc::verifyType(Types*)
void verifyType(TypesPtr l5arg1z) {
        if (hashTravPtr != NULL and
            hashTravPtr->cl >= VARID) {
            parseLval();
            if (l5arg1z != NULL and
                not typeCheck(l5arg1z, curExpr->typ))
                error(errNeedOtherTypesOfOperands);
        } else {
            error(errNotDefined);
            curExpr = uVarPtr;
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x4c956(%rip), %rax     # 0x639a0
testq %rax, %rax
je 0x17092
cmpl $0x3, 0x20(%rax)
jl 0x17092
movq %rsi, %rbx
callq 0xcda9
testq %rbx, %rbx
je 0x170a8
movq 0x4ca37(%rip), %rax     # 0x63aa0
movq (%rax), %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x74d4
addq $-0x8, 0xa5326(%rip)    # 0xbc3a8
cmpb $0x0, (%r14)
jne 0x170a8
pushq $0x15
popq %rdi
callq 0x4f2c
jmp 0x170a8
pushq $0xb
popq %rdi
callq 0x4f2c
movq 0x4c9f7(%rip), %rax     # 0x63a98
movq %rax, 0x4c9f8(%rip)     # 0x63aa0
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1703c
movq 0x4c9da(%rip), %rax     # 0x63aa0
movq %rax, 0x40(%rbx)
movq (%rax), %rdi
movq %rdi, (%rbx)
cmpl $0x5, 0x10(%rdi)
jne 0x170e1
callq 0x12c02
cmpb $0x1, 0x28(%rax)
jne 0x170e9
pushq $0x15
popq %rdi
callq 0x4f2c
pushq $0xe
popq %rdi
callq 0x7429
movb $0x0, 0x4c87d(%rip)     # 0x63975
callq 0xd048
movq 0x4c99c(%rip), %rax     # 0x63aa0
movq %rax, 0x38(%rbx)
movq (%rbx), %rdi
cmpl $0x5, 0x10(%rdi)
jne 0x17143
callq 0x12c02
movq 0x20(%rax), %rsi
movq 0x38(%rbx), %rax
movq (%rax), %rdx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x74d4
addq $-0x8, 0xa5272(%rip)    # 0xbc3a8
cmpb $0x0, (%rbx)
jne 0x17143
pushq $0x15
popq %rdi
callq 0x4f2c
addq $0x50, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq 0x390b
movq %rax, 0x30(%rbx)
movq (%rbx), %rdi
callq 0x12c02
movq 0x18(%rax), %rax
movq 0x30(%rbx), %rcx
movq %rax, (%rcx)
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), %r12
cmpl $0x5, 0x10(%r12)
jne 0x17208
cmpb $0x1, 0x28(%r12)
jne 0x17208
movq 0x18(%r12), %r14
movq (%rbx), %rdi
callq 0x12c02
movq 0x18(%rax), %rdx
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x74d4
cmpb $0x0, (%r15)
je 0x17200
movq (%rbx), %rdi
callq 0x12c02
movq 0x20(%rax), %rsi
movq 0x20(%r12), %rdx
movq %rsp, %rdi
callq 0x74d4
addq $-0x10, 0xa51b0(%rip)   # 0xbc3a8
cmpb $0x0, (%rsp)
je 0x17208
jmp 0x17210
addq $-0x8, 0xa51a0(%rip)    # 0xbc3a8
pushq $0x15
popq %rdi
callq 0x4f2c
pushq $0x20
popq %rdi
callq 0x390b
movq %rax, 0x4c881(%rip)     # 0x63aa0
movb 0x68(%rbx), %cl
addb $0x32, %cl
movsbq %cl, %rcx
movq %rcx, (%rax)
movq 0x30(%rbx), %rax
movq 0x4c869(%rip), %rcx     # 0x63aa0
movq %rax, 0x10(%rcx)
movq 0x28(%rbx), %rax
movq %rax, 0x18(%rcx)
leaq 0x90(%rsp), %rdi
pushq $0x10
popq %rsi
callq 0xaa9a
addq $-0x8, 0xa5165(%rip)    # 0xbc3c0
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
addq $-0x8, 0xa5136(%rip)    # 0xbc3a8
movq %rax, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x4c64e(%rip)  # imm = 0xFFF7
movq %rdi, %rbx
cmpq $0x31, 0x70(%rdi)
jne 0x17451
movq $0x1e, 0x70(%rbx)
pushq $0x10
popq %rax
movq 0x28(%rbx), %rcx
movq 0x30(%rbx), %rdx
movq %rdx, (%rcx,%rax)
movq 0x28(%rbx), %rax
movq %rax, 0x4c66e(%rip)     # 0x63aa0
leaq 0x50(%rsp), %rdi
pushq $0x7
popq %rsi
callq 0xaa9a
addq $-0x8, 0xa4f79(%rip)    # 0xbc3c0
movq %rbx, %rdi
callq 0x17622
jmp 0x17494
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
movq (%rcx), %rsi
movq (%rax), %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x74d4
addq $-0x8, 0xa4f34(%rip)    # 0xbc3a8
cmpb $0x0, (%r14)
je 0x1748c
movq 0x70(%rbx), %rax
cmpq $0x1d, %rax
je 0x1749f
cmpq $0x31, %rax
je 0x17410
jmp 0x17418
pushq $0x22
popq %rdi
callq 0x4f2c
addq $0xb8, %rsp
popq %rbx
popq %r14
retq
pushq $0x18
jmp 0x1741a
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x4c5a3(%rip)  # imm = 0xFFF7
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movl 0x10(%rdi), %eax
cmpl $0x2, %eax
jne 0x174d0
callq 0x12d9c
movq 0x18(%rax), %rdi
movq %rdi, 0x10(%rbx)
movl 0x10(%rdi), %eax
movl %eax, 0x4c432(%rip)     # 0x63908
movq $0x24, 0x70(%rbx)
cmpq 0x4c503(%rip), %rdi     # 0x639e8
je 0x17515
cmpq 0x4c502(%rip), %rdi     # 0x639f0
je 0x1751f
cmpq 0x4c501(%rip), %rdi     # 0x639f8
je 0x17531
cmpl $0x1, %eax
jne 0x17543
movq $0x29, 0x70(%rbx)
callq 0xc60a
movq $0x8, 0x60(%rbx)
jmp 0x17541
movq $0xa, 0x60(%rbx)
jmp 0x17541
movq $0x25, 0x70(%rbx)
movq $0xe, 0x60(%rbx)
jmp 0x17541
movq $0x26, 0x70(%rbx)
movq $0x1, 0x60(%rbx)
popq %rbx
retq
callq 0xcd87
movq 0x10(%rbx), %rdi
testb %al, %al
je 0x17588
callq 0x12c02
movq 0x20(%rax), %rax
movq 0x30(%rax), %rcx
subq 0x28(%rax), %rcx
incq %rcx
movq %rcx, 0x60(%rbx)
movq 0x10(%rbx), %rdi
callq 0x12c02
cmpb $0x0, 0x28(%rax)
je 0x175a0
cmpq $0x6, 0x60(%rbx)
jg 0x175b3
movq $0x27, 0x70(%rbx)
jmp 0x17541
cmpq $0x1, (%rdi)
jne 0x175aa
movq $0x2a, 0x70(%rbx)
movq $0x11, 0x60(%rbx)
jmp 0x17541
movq $0x51, 0x70(%rbx)
jmp 0x17541
pushq $0x22
popq %rdi
popq %rbx
jmp 0x4f2c
movq $0x28, 0x70(%rbx)
jmp 0x17541
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd048
movq 0x4c414(%rip), %rsi     # 0x639e8
movq 0x4c4c5(%rip), %rax     # 0x63aa0
movq (%rax), %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x74d4
movb (%r14), %al
addq $-0x8, 0xa4db4(%rip)    # 0xbc3a8
cmpb $0x1, %al
jne 0x17601
movq 0x4c4a1(%rip), %rax     # 0x63aa0
jmp 0x17617
pushq $0xe
popq %rdi
callq 0x4f2c
movq 0x4c488(%rip), %rax     # 0x63a98
movq %rax, 0x4c489(%rip)     # 0x63aa0
movq %rax, (%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x70, %rsp
movq %rdi, %rbx
testb $0x8, 0x4c423(%rip)     # 0x63a54
jne 0x17639
cmpb $0x1, 0x4a(%rbx)
jne 0x17659
movq 0x40(%rbx), %rax
movq %rax, 0x4c45c(%rip)     # 0x63aa0
leaq 0x8(%rsp), %rdi
pushq $0x8
popq %rsi
callq 0xaa9a
addq $-0x8, 0xa4d67(%rip)    # 0xbc3c0
movb $0x0, 0x4a(%rbx)
movq 0x70(%rbx), %rdi
callq 0x52d1
movq %rax, %rdi
callq 0x51c4
callq 0x5107
addq $0x70, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
andq $0x0, 0x4c1ae(%rip)     # 0x63830
andq $0x0, 0x4c2a6(%rip)     # 0x63930
pushq $0x3
popq %rdx
pushq $0x1
popq %rax
leaq 0x506b9(%rip), %rcx     # 0x67d50
movq %rdx, (%rdi)
cmpq $0x7, %rdx
jge 0x176d0
addq $-0x2, %rdx
movq %rax, %rsi
movq %rsi, 0x8(%rdi)
movq (%rdi), %r8
cmpq %rdx, %rsi
jg 0x176c8
imulq $0x28, %r8, %r8
addq %rcx, %r8
andq $0x0, (%r8,%rsi,8)
movq 0x8(%rdi), %rsi
incq %rsi
jmp 0x176a7
incq %r8
movq %r8, %rdx
jmp 0x17697
pushq $0x1
popq %rcx
leaq 0x522f6(%rip), %rax     # 0x699d0
movq %rcx, (%rdi)
cmpq $0x63, %rcx
jg 0x176f0
andq $0x0, (%rax,%rcx,8)
movq (%rdi), %rcx
incq %rcx
jmp 0x176da
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: initTables::regKeyWords()
void regKeyWords() {
        SY = MULOP;
        charClass = AMPERS;
        regResWord(toText("AND"));
        regResWord(toText("DIV"));
        regResWord(toText("MOD"));
        SY = GTSY; /* reused as NILSY */
        charClass = NOOP;
        regResWord(toText("NIL"));
        SY = ADDOP;
        charClass = OROP;
        regResWord(toText("OR"));
        SY = RELOP;
        charClass = INOP;
        regResWord(toText("IN"));
        SY = NOTSY;
        charClass = NOOP;
        regResWord(toText("NOT"));
        SY = LABELSY;
        charClass = NOOP;
        for (idx = 0; idx <= 29; ++idx)
            regResWord(resWordNameBase[idx]);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x9, 0x4be4b(%rip)     # 0x6381c
movl $0x2, 0x4be3d(%rip)     # 0x63818
leaq 0x2e83(%rip), %rdi      # 0x1a865
callq 0x4dbc
movq %rbx, %rdi
movq %rax, %rsi
callq 0x17b02
leaq 0x2e70(%rip), %rdi      # 0x1a869
callq 0x4dbc
movq %rbx, %rdi
movq %rax, %rsi
callq 0x17b02
leaq 0x2e5d(%rip), %rdi      # 0x1a86d
callq 0x4dbc
movq %rbx, %rdi
movq %rax, %rsi
callq 0x17b02
movl $0x5, 0x4bdf2(%rip)     # 0x6381c
pushq $0x2e
popq %rbp
movl %ebp, 0x4bde5(%rip)     # 0x63818
leaq 0x2355(%rip), %rdi      # 0x19d8f
callq 0x4dbc
movq %rbx, %rdi
movq %rax, %rsi
callq 0x17b02
movl $0xa, 0x4bdc8(%rip)     # 0x6381c
movl $0x7, 0x4bdba(%rip)     # 0x63818
leaq 0x2e0c(%rip), %rdi      # 0x1a871
callq 0x4dbc
movq %rbx, %rdi
movq %rax, %rsi
callq 0x17b02
movl $0xb, 0x4bd9d(%rip)     # 0x6381c
movl $0xe, 0x4bd8f(%rip)     # 0x63818
leaq 0x28d8(%rip), %rdi      # 0x1a368
callq 0x4dbc
movq %rbx, %rdi
movq %rax, %rsi
callq 0x17b02
movl $0x6, 0x4bd72(%rip)     # 0x6381c
movl %ebp, 0x4bd68(%rip)     # 0x63818
leaq 0x2dbd(%rip), %rdi      # 0x1a874
callq 0x4dbc
movq %rbx, %rdi
movq %rax, %rsi
callq 0x17b02
movl $0x14, 0x4bd4b(%rip)    # 0x6381c
movl %ebp, 0x4bd41(%rip)     # 0x63818
xorl %eax, %eax
leaq 0xbbc0(%rip), %r14      # 0x236a0
movq %rax, (%rbx)
cmpq $0x1d, %rax
jg 0x17afd
movq (%r14,%rax,8), %rsi
movq %rbx, %rdi
callq 0x17b02
movq (%rbx), %rax
incq %rax
jmp 0x17ae0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x4bf23(%rip)     # 0x63a30
leaq 0x4bf1c(%rip), %rdi     # 0x63a30
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rsi, %rax
movl $0xffff, %ecx           # imm = 0xFFFF
xorl %edx, %edx
divq %rcx
andl $0x7f, %edx
movq %rdx, %rsi
callq 0x381c
pushq $0x18
popq %rdi
callq 0x390b
movq %rbx, (%rax)
leaq 0x4bcd4(%rip), %rcx     # 0x6381c
movl 0x4bcce(%rip), %edx     # 0x6381c
movl %edx, 0x8(%rax)
leaq 0x4bcc0(%rip), %rsi     # 0x63818
movl 0x4bcba(%rip), %edi     # 0x63818
movl %edi, 0xc(%rax)
movq 0x4bec8(%rip), %r8      # 0x63a30
shlq $0x17, %r8
sarq $0x17, %r8
leaq 0x50e59(%rip), %r9      # 0x689d0
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_O2/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
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
testl %edx, %edx
cmovlel %r12d, %ebx
cmpq %r12, %rbx
je 0x4bda
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
testl %eax, %eax
js 0x4bd7
movb %al, (%r14,%r12)
incq %r12
jmp 0x4bbd
movl %r12d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4c5b
testq %rdi, %rdi
je 0x4c54
movslq %eax, %rsi
callq 0x40f0
andq $0x0, (%r14)
andl $0x0, (%rbx)
testl %ebp, %ebp
jle 0x4c8a
movl %ebp, %esi
xorl %r15d, %r15d
pushq $0x7
popq %rdx
pushq $0x22
popq %rcx
pushq $-0x1
popq %r8
xorl %edi, %edi
xorl %r9d, %r9d
callq 0x4330
cmpq $-0x1, %rax
cmoveq %r15, %rax
movq %rax, (%r14)
testq %rax, %rax
je 0x4c95
movl %ebp, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
andl $0x0, (%rbx)
leaq 0x1d121(%rip), %rdi     # 0x21dc0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x44dc
// File: /workspace/github_cpp_makefile_star2_O2/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:
andq $0x0, (%rdi)
movaps 0x195c7(%rip), %xmm0    # 0x1e280
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
// File: /workspace/github_cpp_makefile_star2_O2/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
movl $0x1ff, %ebp            # imm = 0x1FF
movq %rbx, %rdi
callq 0x1c31c
movl (%rbx), %eax
andl %ebp, %eax
xorl %esi, %esi
cmpl $0x1c0, %eax            # imm = 0x1C0
jne 0x4cec
movq %r14, %rsi
shrq $0x38, %rsi
movq %rbx, %rdi
callq 0x1c31c
movq %r14, %rsi
shrq $0x30, %rsi
movq %rbx, %rdi
callq 0x1c31c
movq %r14, %rsi
shrq $0x28, %rsi
movq %rbx, %rdi
callq 0x1c31c
movq %r14, %rsi
shrq $0x20, %rsi
movq %rbx, %rdi
callq 0x1c31c
movq %r14, %rsi
shrq $0x18, %rsi
movq %rbx, %rdi
callq 0x1c31c
movq %r14, %rsi
shrq $0x10, %rsi
movq %rbx, %rdi
callq 0x1c31c
movq %r14, %rsi
shrq $0x8, %rsi
movq %rbx, %rdi
callq 0x1c31c
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1c31c
leaq 0x5c(%rbx), %rax
pushq $0x5f
popq %rcx
cmpq $0x73, %rcx
je 0x4d92
movl -0x57(%rbx,%rcx), %edx
bswapl %edx
movl %edx, -0x3(%rbx,%rcx)
addq $0x4, %rcx
jmp 0x4d7c
andq $0x0, (%rbx)
movaps 0x194e3(%rip), %xmm0    # 0x1e280
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_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %r12
sarq $0x3f, %r12
andq %rdx, %r12
testq %r15, %r15
jle 0x4e32
movzwl (%r14), %eax
testw $0x1ff, %ax             # imm = 0x1FF
je 0x4dfd
movzbl (%rbx), %esi
incq %rbx
movq %r14, %rdi
callq 0x1c31c
decq %r15
jmp 0x4ddb
movq %r15, %r12
jmp 0x4e32
xorl %r15d, %r15d
cmpq $0x40, %r15
je 0x4e1c
movl (%rbx,%r15), %eax
bswapl %eax
movl %eax, 0x1c(%r14,%r15)
addq $0x4, %r15
jmp 0x4e05
addq $0x200, (%r14)          # imm = 0x200
movq %r14, %rdi
callq 0x4e5c
addq $-0x40, %r12
addq %r15, %rbx
cmpq $0x40, %r12
jge 0x4e02
jmp 0x4e4b
movzbl (%rbx), %esi
incq %rbx
movq %r14, %rdi
callq 0x1c31c
decq %r12
testq %r12, %r12
jg 0x4e3a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x181cf(%rip), %xmm0    # 0x1e290
movups %xmm0, (%rdi)
movaps 0x181d5(%rip), %xmm0    # 0x1e2a0
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_O2/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
movl $0x1ff, %r15d           # imm = 0x1FF
movq %rbx, %rdi
callq 0x1c34a
movl (%rbx), %eax
andl %r15d, %eax
xorl %esi, %esi
cmpl $0x1c0, %eax            # imm = 0x1C0
jne 0x8535
movl %r14d, %esi
shrl $0x18, %esi
movq %rbx, %rdi
callq 0x1c34a
movl %r14d, %esi
shrl $0x10, %esi
movq %rbx, %rdi
callq 0x1c34a
movl %r14d, %esi
shrl $0x8, %esi
movq %rbx, %rdi
callq 0x1c34a
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1c34a
movl %ebp, %esi
shrl $0x18, %esi
movq %rbx, %rdi
callq 0x1c34a
movl %ebp, %esi
shrl $0x10, %esi
movq %rbx, %rdi
callq 0x1c34a
movl %ebp, %esi
shrl $0x8, %esi
movq %rbx, %rdi
callq 0x1c34a
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1c34a
leaq 0x68(%rbx), %r14
pushq $0x6b
popq %rax
cmpq $0x8b, %rax
je 0x85d0
movl -0x63(%rbx,%rax), %ecx
bswapl %ecx
movl %ecx, -0x3(%rbx,%rax)
addq $0x4, %rax
jmp 0x85b8
movq %rbx, %rdi
callq 0x60ba
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq %rcx, %r13
shrq $0x4, %r13
movslq %edx, %rbp
addq %rcx, %rbp
shrq $0x4, %rbp
movl %r13d, %r12d
shll $0x4, %r12d
subl %ecx, %r12d
cmpq %rbp, %r13
ja 0x8ed2
movl 0x14f4(%r15), %esi
movl 0x14f8(%r15), %edx
movq %r13, %rcx
shrq $0x20, %rcx
movq %r15, %rdi
movl %r13d, %r8d
movq %rsp, %r9
callq 0x8ab6
xorl %eax, %eax
cmpq $0x10, %rax
je 0x8ec9
leaq (%r12,%rax), %rcx
testl %ecx, %ecx
sets %dl
cmpl %ebx, %ecx
setge %sil
orb %dl, %sil
jne 0x8ec4
movb (%rsp,%rax), %dl
movl %ecx, %ecx
xorb %dl, (%r14,%rcx)
incq %rax
jmp 0x8ea1
incq %r13
addq $0x10, %r12
jmp 0x8e77
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::pbkdf2(char const*, int, char const*, int, int, char*, int)
static void pbkdf2(const char* pw, int pwLen, const char* salt, int saltLen,
                   int c, char* buf, int dkLen) {
  assert(c==1);
  assert(dkLen%32==0);
  assert(pwLen<=64);

  libzpaq::SHA256 sha256;
  char b[32];
  for (int i=1; i*32<=dkLen; ++i) {
    for (int j=0; j<pwLen; ++j) sha256.put(pw[j]^0x36);
    for (int j=pwLen; j<64; ++j) sha256.put(0x36);
    for (int j=0; j<saltLen; ++j) sha256.put(salt[j]);
    for (int j=24; j>=0; j-=8) sha256.put(i>>j);
    memcpy(b, sha256.result(), 32);
    for (int j=0; j<pwLen; ++j) sha256.put(pw[j]^0x5c);
    for (int j=pwLen; j<64; ++j) sha256.put(0x5c);
    for (int j=0; j<32; ++j) sha256.put(b[j]);
    memcpy(buf+i*32-32, sha256.result(), 32);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %ecx, %r14d
movq %rdx, 0x28(%rsp)
movq %rdi, %r12
movaps 0x150ca(%rip), %xmm0    # 0x1e290
leaq 0x50(%rsp), %r13
movaps %xmm0, (%r13)
movaps 0x150c9(%rip), %xmm0    # 0x1e2a0
movaps %xmm0, 0x10(%r13)
movabsq $0x5be0cd191f83d9ab, %rax # imm = 0x5BE0CD191F83D9AB
movq %rax, 0x20(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r13)
movups %xmm0, 0x38(%r13)
movups %xmm0, 0x48(%r13)
movups %xmm0, 0x58(%r13)
addq $-0x20, %r8
movq %r8, 0x10(%rsp)
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ebp
movl %esi, 0xc(%rsp)
cmovgl %esi, %ebp
testl %ecx, %ecx
cmovlel %eax, %r14d
movslq %r9d, %rax
movq %rax, 0x18(%rsp)
pushq $0x1
popq %r15
movq %r15, %rax
shlq $0x5, %rax
cmpq 0x18(%rsp), %rax
jg 0x9340
movq %rax, 0x20(%rsp)
xorl %ebx, %ebx
cmpq %rbx, %rbp
je 0x925f
movsbl (%r12,%rbx), %esi
xorl $0x36, %esi
movq %r13, %rdi
callq 0x1c34a
incq %rbx
jmp 0x9245
movl 0xc(%rsp), %ebx
cmpl $0x40, %ebx
jge 0x9277
movq %r13, %rdi
pushq $0x36
popq %rsi
callq 0x1c34a
incl %ebx
jmp 0x9263
xorl %ebx, %ebx
cmpq %rbx, %r14
je 0x9294
movq 0x28(%rsp), %rax
movsbl (%rax,%rbx), %esi
movq %r13, %rdi
callq 0x1c34a
incq %rbx
jmp 0x9279
pushq $0x18
popq %rbx
testl %ebx, %ebx
js 0x92af
movl %r15d, %esi
movl %ebx, %ecx
shrl %cl, %esi
movq %r13, %rdi
callq 0x1c34a
addl $-0x8, %ebx
jmp 0x9297
movq %r13, %rdi
callq 0x851a
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
xorl %ebx, %ebx
cmpq %rbx, %rbp
je 0x92e4
movsbl (%r12,%rbx), %esi
xorl $0x5c, %esi
movq %r13, %rdi
callq 0x1c34a
incq %rbx
jmp 0x92ca
movl 0xc(%rsp), %ebx
cmpl $0x40, %ebx
jge 0x92fc
movq %r13, %rdi
pushq $0x5c
popq %rsi
callq 0x1c34a
incl %ebx
jmp 0x92e8
xorl %ebx, %ebx
cmpq $0x20, %rbx
je 0x9316
movsbl 0x30(%rsp,%rbx), %esi
movq %r13, %rdi
callq 0x1c34a
incq %rbx
jmp 0x92fe
movq %r13, %rdi
callq 0x851a
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movups %xmm0, (%rax,%rcx)
movups %xmm1, 0x10(%rax,%rcx)
incq %r15
jmp 0x922c
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x18a3f(%rip), %rdi     # 0x21dce
leaq 0x18a45(%rip), %rsi     # 0x21ddb
callq 0x41f0
testq %rax, %rax
je 0x93c6
movq %rax, %r14
movslq %ebp, %r15
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %rax, %rcx
callq 0x4290
cmpl %r15d, %eax
jne 0x93c6
movq %r14, %rdi
callq 0x4170
jmp 0x93d2
leaq 0x18a11(%rip), %rdi     # 0x21dde
callq 0x44dc
testl %ebp, %ebp
jle 0x93e7
movzbl (%rbx), %eax
cmpl $0x7a, %eax
je 0x93e3
cmpl $0x37, %eax
jne 0x93e7
addb $-0x80, %al
movb %al, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x20(%rbx)
xorl %esi, %esi
xorl %edx, %edx
callq 0x1c3a4
leaq 0x40(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1c46e
addq $0x58, %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
jmp 0x1c528
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, 0x30(%rdi)
andq $0x0, 0x28(%rdi)
addq $0x10, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x9c(%rbx)
andq $0x0, 0xac(%rbx)
xorl %esi, %esi
xorl %edx, %edx
callq 0x1c46e
leaq 0x50(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1c3a4
leaq 0x38(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1c46e
leaq 0x68(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1c3a4
leaq 0xb8(%rbx), %rdi
addq $0xb4, %rbx
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
jmp 0x4c24
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1c5f0
leaq 0x38(%r12), %r14
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1c5f0
leaq 0x50(%r12), %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1c600
leaq 0x68(%r12), %r13
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1c600
leaq 0x80(%r12), %rbp
movq %rbp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1c380
andq $0x0, 0xb8(%r12)
andl $0x0, 0xb4(%r12)
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movq %r12, %rdi
callq 0x96e0
movl $0x4000, %esi           # imm = 0x4000
movq %rbp, %rdi
xorl %edx, %edx
callq 0x1c610
andl $0x0, 0x98(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
jmp 0x9819
movq %rax, %r12
jmp 0x9821
movq %rax, %r12
jmp 0x9829
movq %rax, %r12
jmp 0x9831
movq %rax, %r12
movq %rbp, %rdi
callq 0x1c390
movq %r13, %rdi
callq 0x1c6ca
movq %r15, %rdi
callq 0x1c6ca
movq %r14, %rdi
callq 0x1c6de
movq %rbx, %rdi
callq 0x1c6de
movq %r12, %rdi
callq 0x4320
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
cmpl $0x21, %esi
jl 0x98ca
leaq 0x185a4(%rip), %rdi     # 0x21e69
callq 0x44dc
cmpl $0x21, %ebp
jl 0x98db
leaq 0x1859d(%rip), %rdi     # 0x21e73
callq 0x44dc
leaq 0x50(%rbx), %rdi
pushq $0x1
popq %r15
movq %r15, %rsi
movl %r14d, %edx
callq 0x1c3a4
leaq 0x38(%rbx), %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x1c46e
leaq 0x68(%rbx), %rdi
movl $0x100, %esi            # imm = 0x100
xorl %edx, %edx
callq 0x1c3a4
xorps %xmm0, %xmm0
movups %xmm0, 0x9c(%rbx)
andq $0x0, 0xac(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop