LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x60, %edi
callq 0x1e2e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x21b20
jmp 0x23dc7
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdx
movq 0x58(%rax), %rcx
movq %rdx, (%rcx)
movq -0x10(%rbp), %rdx
movq 0x58(%rax), %rcx
movq (%rcx), %rcx
movq %rdx, (%rcx)
movq 0x58(%rax), %rcx
movq (%rcx), %rcx
movq $0x0, 0x8(%rcx)
movq -0x18(%rbp), %rdx
movq 0x58(%rax), %rcx
movq (%rcx), %rcx
movq %rdx, 0x18(%rcx)
movq 0x58(%rax), %rcx
movq (%rcx), %rcx
movl $0x0, 0x20(%rcx)
movq 0x58(%rax), %rax
movq (%rax), %rdi
callq 0x7a70
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1e330
movq -0x20(%rbp), %rdi
callq 0x44c0
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x60, %edi
callq 0x1e2e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x21b20
jmp 0x23e77
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdx
movq 0x58(%rax), %rcx
movq %rdx, (%rcx)
movq -0x10(%rbp), %rdx
movq 0x58(%rax), %rcx
movq (%rcx), %rcx
movq %rdx, (%rcx)
movq 0x58(%rax), %rcx
movq (%rcx), %rcx
movq $0x30, 0x8(%rcx)
movq 0x48(%rax), %rdx
movq 0x58(%rax), %rcx
movq (%rcx), %rcx
movq %rdx, 0x18(%rcx)
movq 0x58(%rax), %rcx
movq (%rcx), %rcx
movl $0x1, 0x20(%rcx)
movq 0x58(%rax), %rax
movq (%rax), %rdi
callq 0x1e970
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq $0x0, (%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq 0x58(%rax), %rax
movq (%rax), %rdi
callq 0x1e6b0
movq -0x40(%rbp), %rdx
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rdx, (%rcx)
movq 0x58(%rax), %rax
movq (%rax), %rdi
callq 0x7a70
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1e330
movq -0x20(%rbp), %rdi
callq 0x44c0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x60, %edi
callq 0x1e2e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x21b20
jmp 0x23fb3
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdx
movq 0x58(%rax), %rcx
movq %rdx, (%rcx)
movq -0x10(%rbp), %rdx
movq 0x58(%rax), %rcx
movq (%rcx), %rcx
movq %rdx, (%rcx)
movq 0x58(%rax), %rcx
movq (%rcx), %rcx
movq $0x0, 0x8(%rcx)
movq 0x48(%rax), %rdx
movq 0x58(%rax), %rcx
movq (%rcx), %rcx
movq %rdx, 0x18(%rcx)
movq 0x58(%rax), %rcx
movq (%rcx), %rcx
movl $0x2, 0x20(%rcx)
movq 0x40(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x58(%rax), %rax
movq (%rax), %rdi
callq 0x27580
movq -0x38(%rbp), %rdx
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rdx, (%rcx)
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
movq 0x58(%rax), %rax
movq (%rax), %rdi
callq 0x7a70
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1e330
movq -0x18(%rbp), %rdi
callq 0x44c0
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movabsq $0xffffffffffff, %rdx   # imm = 0xFFFFFFFFFFFF
andq -0x10(%rbp), %rdx
movq (%rax), %rcx
movabsq $0x1ffffffffff, %rsi    # imm = 0x1FFFFFFFFFF
andq %rsi, %rdx
movabsq $-0x20000000000, %rsi   # imm = 0xFFFFFE0000000000
andq %rsi, %rcx
orq %rdx, %rcx
movq %rcx, (%rax)
movabsq $-0xfe0000000001, %rcx  # imm = 0xFFFF01FFFFFFFFFF
andq (%rax), %rcx
movabsq $0xd00000000000, %rdx   # imm = 0xD00000000000
orq %rdx, %rcx
movq %rcx, (%rax)
movq (%rax), %rax
shlq $0x17, %rax
sarq $0x17, %rax
cmpq $0x0, %rax
jne 0x26400
movq -0x18(%rbp), %rax
movabsq $-0xfe0000000001, %rcx  # imm = 0xFFFF01FFFFFFFFFF
andq (%rax), %rcx
orq $0x0, %rcx
movq %rcx, (%rax)
jmp 0x264b2
jmp 0x26402
movq -0x18(%rbp), %rax
movq (%rax), %rcx
shlq $0x17, %rcx
sarq $0x17, %rcx
sarq $0x27, %rcx
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x19(%rbp)
je 0x2643d
movq -0x18(%rbp), %rax
movq (%rax), %rax
shlq $0x17, %rax
sarq $0x17, %rax
sarq $0x27, %rax
cmpq $-0x1, %rax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x26446
jmp 0x264b0
movq -0x18(%rbp), %rax
movq (%rax), %rcx
shrq $0x29, %rcx
andq $0x7f, %rcx
addl $-0x1, %ecx
movl %ecx, %ecx
movl %ecx, %edx
movq (%rax), %rcx
andq $0x7f, %rdx
shlq $0x29, %rdx
movabsq $-0xfe0000000001, %rsi  # imm = 0xFFFF01FFFFFFFFFF
andq %rsi, %rcx
orq %rdx, %rcx
movq %rcx, (%rax)
movq (%rax), %rdx
shlq $0x17, %rdx
sarq $0x17, %rdx
shlq %rdx
movq (%rax), %rcx
movabsq $0x1ffffffffff, %rsi    # imm = 0x1FFFFFFFFFF
andq %rsi, %rdx
movabsq $-0x20000000000, %rsi   # imm = 0xFFFFFE0000000000
andq %rsi, %rcx
orq %rdx, %rcx
movq %rcx, (%rax)
jmp 0x26402
jmp 0x264b2
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x26840
testb $0x1, %al
jne 0x26809
movl $0x20, %edi
callq 0x1e2e0
movq -0x18(%rbp), %rdi
movq %rax, 0x30(%rdi)
movq 0x28(%rdi), %rcx
movq 0x30(%rdi), %rax
movq %rcx, (%rax)
addq $0x690, %rdi            # imm = 0x690
callq 0x1dfb0
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
movq %rdx, 0x8(%rcx)
movq 0x30(%rax), %rcx
movq $0x0, 0x10(%rcx)
movq 0x30(%rax), %rcx
movq $0x0, 0x18(%rcx)
movq 0x30(%rax), %rcx
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0x1000000, %rcx        # imm = 0x1000000
movq %rcx, -0x20(%rbp)
movq 0x30(%rax), %rdi
callq 0x4ea0
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq %rax, %rsi
callq 0x266d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x28(%rax), %rcx
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x268e1
movq -0x20(%rbp), %rdi
movq 0x30(%rdi), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
addq $0x690, %rdi            # imm = 0x690
callq 0x1dfb0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jne 0x268cd
movb $0x1, -0x11(%rbp)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
cmpq $0x1000000, 0x10(%rax)  # imm = 0x1000000
jne 0x268c3
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x4e10
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x26893
movb -0x11(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x268e5
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rcx
movq (%rcx), %rcx
movq %rcx, 0x30(%rax)
jmp 0x2685c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: besm6[P]pascal-re/pascompl.cc
// Function: genOneOp::P3363()
void P3363() {
        if (l4var213z)
            form1Insn(InsnTemp[XTA]);
        else
            form1Insn(KXTA+E1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x6a8(%rax)
je 0x26917
movq 0x5e160(%rip), %rdi     # 0x84a70
callq 0x7c20
jmp 0x26921
movl $0x108008, %edi         # imm = 0x108008
callq 0x7c20
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x800, -0x18(%rbp)     # imm = 0x800
jl 0x27a9a
movq -0x18(%rbp), %rsi
leaq 0x5867b(%rip), %rdi     # 0x800f0
callq 0x4ad0
movq 0x5866f(%rip), %rdi     # 0x800f0
orq $0x800000, %rdi         # imm = 0x800000
andq $0xffffff, %rdi         # imm = 0xFFFFFF
callq 0x8390
movq %rax, -0x8(%rbp)
jmp 0x27aa2
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, 0x57428(%rip)     # 0x80060
je 0x28cb4
movq 0x5741f(%rip), %rax     # 0x80060
cmpl $0x3, 0x20(%rax)
jl 0x28cb4
callq 0x14ae0
movq -0x10(%rbp), %rcx
movb $0x0, -0x59(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x5a(%rbp)
je 0x28c88
movq -0x10(%rbp), %rsi
movq 0x574f6(%rip), %rax     # 0x80160
movq (%rax), %rdx
leaq -0x58(%rbp), %rdi
callq 0xb280
movb $0x1, -0x59(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1e950
xorb $-0x1, %al
movb %al, -0x5a(%rbp)
movb -0x5a(%rbp), %al
movb %al, -0x5b(%rbp)
testb $0x1, -0x59(%rbp)
jne 0x28c96
jmp 0x28c9f
leaq -0x58(%rbp), %rdi
callq 0x1e9c0
movb -0x5b(%rbp), %al
testb $0x1, %al
jne 0x28ca8
jmp 0x28cb2
movl $0x15, %edi
callq 0x7b40
jmp 0x28ccc
movl $0xb, %edi
callq 0x7b40
movq 0x57493(%rip), %rax     # 0x80158
movq %rax, 0x57494(%rip)     # 0x80160
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x28c20
movq -0x60(%rbp), %rax
movq 0x57458(%rip), %rcx     # 0x80160
movq %rcx, 0x40(%rax)
movq 0x5744d(%rip), %rcx     # 0x80160
movq (%rcx), %rcx
movq %rcx, (%rax)
movq (%rax), %rax
cmpl $0x5, 0x10(%rax)
jne 0x28d34
movq -0x60(%rbp), %rax
movq (%rax), %rdi
callq 0x1e210
testb $0x1, 0x28(%rax)
je 0x28d3e
movl $0x15, %edi
callq 0x7b40
movl $0xe, %edi
callq 0xb110
movb $0x0, 0x572e6(%rip)     # 0x80035
callq 0x14e90
movq -0x60(%rbp), %rax
movq 0x57401(%rip), %rcx     # 0x80160
movq %rcx, 0x38(%rax)
movq (%rax), %rax
movl 0x10(%rax), %ecx
movb $0x0, -0x51(%rbp)
xorl %eax, %eax
cmpl $0x5, %ecx
movb %al, -0x61(%rbp)
jne 0x28db0
movq -0x60(%rbp), %rax
movq (%rax), %rdi
callq 0x1e210
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq 0x20(%rcx), %rsi
movq 0x38(%rax), %rax
movq (%rax), %rdx
leaq -0x50(%rbp), %rdi
callq 0xb280
movb $0x1, -0x51(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1e950
xorb $-0x1, %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
movb %al, -0x62(%rbp)
testb $0x1, -0x51(%rbp)
jne 0x28dbe
jmp 0x28dc7
leaq -0x50(%rbp), %rdi
callq 0x1e9c0
movb -0x62(%rbp), %al
testb $0x1, %al
jne 0x28dd0
jmp 0x28dda
movl $0x15, %edi
callq 0x7b40
addq $0x70, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe0(%rbp)
movl $0xc, %edi
callq 0x48e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x56e6d(%rip), %rdi     # 0x80110
callq 0x1e4e0
movq %rax, %rcx
movq -0xe0(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x56e4f(%rip)     # 0x80110
movq 0x70(%rax), %rcx
movb $0x0, -0x61(%rbp)
xorl %eax, %eax
cmpq $0x31, %rcx
movb %al, -0xd1(%rbp)
je 0x2930a
movq -0xe0(%rbp), %rax
movq 0x38(%rax), %rcx
movq (%rcx), %rsi
movq 0x30(%rax), %rax
movq (%rax), %rdx
leaq -0x60(%rbp), %rdi
callq 0xb280
movb $0x1, -0x61(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1e950
xorb $-0x1, %al
movb %al, -0xd1(%rbp)
movb -0xd1(%rbp), %al
movb %al, -0xe1(%rbp)
testb $0x1, -0x61(%rbp)
jne 0x2931e
jmp 0x29327
leaq -0x60(%rbp), %rdi
callq 0x1e9c0
movb -0xe1(%rbp), %al
testb $0x1, %al
jne 0x29333
jmp 0x29342
movl $0x22, %edi
callq 0x7b40
jmp 0x293d0
movq -0xe0(%rbp), %rax
cmpq $0x1d, 0x70(%rax)
jne 0x29365
movq -0xe0(%rbp), %rax
movq 0x30(%rax), %rcx
movq 0x28(%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x29395
movq -0xe0(%rbp), %rax
cmpq $0x31, 0x70(%rax)
jne 0x29382
movq -0xe0(%rbp), %rax
movq $0x1e, 0x70(%rax)
movq -0xe0(%rbp), %rax
movq 0x30(%rax), %rcx
movq 0x28(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0xe0(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x56db9(%rip)     # 0x80160
leaq -0xd0(%rbp), %rdi
movl $0x7, %esi
callq 0x112d0
leaq -0xd0(%rbp), %rdi
callq 0x21850
movq -0xe0(%rbp), %rdi
callq 0x29660
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x14e90
movq 0x56aac(%rip), %rsi     # 0x800a8
movq 0x56b5d(%rip), %rax     # 0x80160
movq (%rax), %rdx
leaq -0x58(%rbp), %rdi
callq 0xb280
leaq -0x58(%rbp), %rdi
callq 0x1e950
xorb $-0x1, %al
movb %al, -0x59(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1e9c0
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x2962f
jmp 0x29647
movl $0xe, %edi
callq 0x7b40
movq 0x56b18(%rip), %rax     # 0x80158
movq %rax, 0x56b19(%rip)     # 0x80160
movq 0x56b12(%rip), %rcx     # 0x80160
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq 0x56a92(%rip), %rdi     # 0x80110
movl $0xc, %esi
callq 0x1e5f0
testb $0x1, %al
jne 0x29696
movq -0x78(%rbp), %rax
testb $0x1, 0x4a(%rax)
je 0x296bc
movq -0x78(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x56abb(%rip)     # 0x80160
leaq -0x70(%rbp), %rdi
movl $0x8, %esi
callq 0x112d0
leaq -0x70(%rbp), %rdi
callq 0x21850
movq -0x78(%rbp), %rax
movb $0x0, 0x4a(%rax)
movq 0x70(%rax), %rdi
callq 0x80d0
movq %rax, %rdi
callq 0x7f20
callq 0x7e00
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, 0x56775(%rip) # 0x7fef0
movq $0x0, 0x5686a(%rip) # 0x7fff0
movq $0x3, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x6, (%rax)
jg 0x297fe
movq -0x18(%rbp), %rax
movq (%rax), %rcx
subq $0x2, %rcx
movq %rcx, -0x10(%rbp)
movq $0x1, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jg 0x297ec
movq -0x18(%rbp), %rcx
leaq 0x5ac49(%rip), %rax     # 0x84410
imulq $0x28, (%rcx), %rdx
addq %rdx, %rax
movq 0x8(%rcx), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x297ae
jmp 0x297ee
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x2978d
movq -0x18(%rbp), %rax
movq $0x1, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x63, (%rax)
jg 0x29839
movq -0x18(%rbp), %rax
movq (%rax), %rcx
leaq 0x5c86f(%rip), %rax     # 0x86090
movq $0x0, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x29809
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x9, 0x561be(%rip)     # 0x7fedc
movl $0x2, 0x561b0(%rip)     # 0x7fed8
leaq 0x94ab(%rip), %rdi      # 0x331da
callq 0x7860
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x29fc0
leaq 0x9497(%rip), %rdi      # 0x331de
callq 0x7860
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x29fc0
leaq 0x9483(%rip), %rdi      # 0x331e2
callq 0x7860
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x29fc0
movl $0x5, 0x56162(%rip)     # 0x7fedc
movl $0x2e, 0x56154(%rip)    # 0x7fed8
leaq 0x805c(%rip), %rdi      # 0x31de7
callq 0x7860
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x29fc0
movl $0xa, 0x56136(%rip)     # 0x7fedc
movl $0x7, 0x56128(%rip)     # 0x7fed8
leaq 0x942f(%rip), %rdi      # 0x331e6
callq 0x7860
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x29fc0
movl $0xb, 0x5610a(%rip)     # 0x7fedc
movl $0xe, 0x560fc(%rip)     # 0x7fed8
leaq 0x85e4(%rip), %rdi      # 0x323c7
callq 0x7860
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x29fc0
movl $0x6, 0x560de(%rip)     # 0x7fedc
movl $0x2e, 0x560d0(%rip)    # 0x7fed8
leaq 0x93da(%rip), %rdi      # 0x331e9
callq 0x7860
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x29fc0
movq -0x10(%rbp), %rax
movl $0x14, 0x560ae(%rip)    # 0x7fedc
movl $0x2e, 0x560a0(%rip)    # 0x7fed8
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x1d, (%rax)
jg 0x29e70
movq -0x10(%rbp), %rdi
movq (%rdi), %rcx
leaq 0x15cf9(%rip), %rax     # 0x3fb50
movq (%rax,%rcx,8), %rsi
callq 0x29fc0
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x29e3f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x56115(%rip)     # 0x800f0
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x56104(%rip), %rax     # 0x800f0
movl $0xffff, %ecx           # imm = 0xFFFF
xorl %edx, %edx
divq %rcx
movq %rdx, %rsi
andq $0x7f, %rsi
leaq 0x560ec(%rip), %rdi     # 0x800f0
callq 0x4ad0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x18, %edi
callq 0x1e2e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movl 0x55eac(%rip), %ecx     # 0x7fedc
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl 0x55e9b(%rip), %ecx     # 0x7fed8
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
leaq 0x560a5(%rip), %rdi     # 0x800f0
callq 0x1dfb0
movq %rax, %rcx
leaq 0x5b036(%rip), %rax     # 0x85090
movq (%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x5607b(%rip), %rdi     # 0x800f0
callq 0x1dfb0
movq -0x28(%rbp), %rdx
movq %rax, %rcx
leaq 0x5b008(%rip), %rax     # 0x85090
movq %rdx, (%rax,%rcx,8)
cmpl $0x2e, 0x55e45(%rip)    # 0x7fed8
jne 0x2a0a3
leaq 0x55e40(%rip), %rdi     # 0x7fedc
callq 0x2a0c0
jmp 0x2a0af
leaq 0x55e2e(%rip), %rdi     # 0x7fed8
callq 0x29ea0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x29(%rbp)
jge 0x6534
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
setge %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x653d
jmp 0x6559
movl -0x1c(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x6512
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x65e6
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x6618
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6603
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rsi
callq 0x5160
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
cmpl $0x0, -0x14(%rbp)
jle 0x6691
movslq -0x14(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r9d
movl $0x7, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x54c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $-0x1, %rcx
cmpq %rcx, (%rax)
jne 0x6664
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6679
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x668f
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
leaq 0x31836(%rip), %rdi     # 0x37ec0
callq 0x5720
jmp 0x6691
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq $0x0, (%rdi)
movl $0x67452301, 0x8(%rdi)  # imm = 0x67452301
movl $0xefcdab89, 0xc(%rdi)  # imm = 0xEFCDAB89
movl $0x98badcfe, 0x10(%rdi) # imm = 0x98BADCFE
movl $0x10325476, 0x14(%rdi) # imm = 0x10325476
movl $0xc3d2e1f0, 0x18(%rdi) # imm = 0xC3D2E1F0
addq $0x1c, %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x5150
addq $0x10, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq (%rdi), %rax
movq %rax, -0x10(%rbp)
movl $0x80, %esi
callq 0x30080
movq -0x20(%rbp), %rax
movq (%rax), %rax
andq $0x1ff, %rax            # imm = 0x1FF
cmpq $0x1c0, %rax            # imm = 0x1C0
je 0x6737
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x30080
jmp 0x6715
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
shrq $0x38, %rax
movl %eax, %esi
callq 0x30080
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
shrq $0x30, %rax
movl %eax, %esi
callq 0x30080
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
shrq $0x28, %rax
movl %eax, %esi
callq 0x30080
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
shrq $0x20, %rax
movl %eax, %esi
callq 0x30080
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
shrq $0x18, %rax
movl %eax, %esi
callq 0x30080
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
shrq $0x10, %rax
movl %eax, %esi
callq 0x30080
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
shrq $0x8, %rax
movl %eax, %esi
callq 0x30080
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl %eax, %esi
callq 0x30080
movl $0x0, -0x14(%rbp)
cmpl $0x5, -0x14(%rbp)
jge 0x685c
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl 0x8(%rax,%rcx,4), %ecx
shrl $0x18, %ecx
movb %cl, %dl
movl -0x14(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
movb %dl, 0x5c(%rax,%rcx)
movslq -0x14(%rbp), %rcx
movl 0x8(%rax,%rcx,4), %ecx
shrl $0x10, %ecx
movb %cl, %dl
movl -0x14(%rbp), %ecx
shll $0x2, %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, 0x5c(%rax,%rcx)
movslq -0x14(%rbp), %rcx
movl 0x8(%rax,%rcx,4), %ecx
shrl $0x8, %ecx
movb %cl, %dl
movl -0x14(%rbp), %ecx
shll $0x2, %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb %dl, 0x5c(%rax,%rcx)
movslq -0x14(%rbp), %rcx
movl 0x8(%rax,%rcx,4), %ecx
movb %cl, %dl
movl -0x14(%rbp), %ecx
shll $0x2, %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movb %dl, 0x5c(%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x67d2
movq -0x20(%rbp), %rdi
callq 0x66a0
movq -0x20(%rbp), %rax
addq $0x5c, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x31(%rbp)
jle 0x68c5
movq -0x30(%rbp), %rax
movq (%rax), %rax
andl $0x1ff, %eax            # imm = 0x1FF
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x68ce
jmp 0x68f7
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %esi
callq 0x30080
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x68a4
jmp 0x68f9
cmpq $0x40, -0x18(%rbp)
jl 0x6988
movl $0x0, -0x24(%rbp)
cmpl $0x10, -0x24(%rbp)
jge 0x6962
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rcx), %edx
shll $0x18, %edx
movq -0x20(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %edx
movq -0x20(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %edx
movq -0x20(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
orl %ecx, %edx
movslq -0x24(%rbp), %rcx
movl %edx, 0x1c(%rax,%rcx,4)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x690b
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
addq $0x200, %rax            # imm = 0x200
movq %rax, (%rdi)
callq 0x69c0
movq -0x18(%rbp), %rax
subq $0x40, %rax
movq %rax, -0x18(%rbp)
jmp 0x68f9
jmp 0x698a
cmpq $0x0, -0x18(%rbp)
jle 0x69ba
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %esi
callq 0x30080
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x698a
addq $0x40, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x0, 0x4(%rdi)
movl $0x0, (%rdi)
movl $0x6a09e667, 0x8(%rdi)  # imm = 0x6A09E667
movl $0xbb67ae85, 0xc(%rdi)  # imm = 0xBB67AE85
movl $0x3c6ef372, 0x10(%rdi) # imm = 0x3C6EF372
movl $0xa54ff53a, 0x14(%rdi) # imm = 0xA54FF53A
movl $0x510e527f, 0x18(%rdi) # imm = 0x510E527F
movl $0x9b05688c, 0x1c(%rdi) # imm = 0x9B05688C
movl $0x1f83d9ab, 0x20(%rdi) # imm = 0x1F83D9AB
movl $0x5be0cd19, 0x24(%rdi) # imm = 0x5BE0CD19
addq $0x28, %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x5150
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl 0x4(%rdi), %eax
movl %eax, -0xc(%rbp)
movl (%rdi), %eax
movl %eax, -0x10(%rbp)
movl $0x80, %esi
callq 0x30100
movq -0x20(%rbp), %rax
movl (%rax), %eax
andl $0x1ff, %eax            # imm = 0x1FF
cmpl $0x1c0, %eax            # imm = 0x1C0
je 0xcaf8
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x30100
jmp 0xcad9
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
shrl $0x18, %esi
callq 0x30100
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
shrl $0x10, %esi
callq 0x30100
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
shrl $0x8, %esi
callq 0x30100
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x30100
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %esi
shrl $0x18, %esi
callq 0x30100
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %esi
shrl $0x10, %esi
callq 0x30100
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %esi
shrl $0x8, %esi
callq 0x30100
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x30100
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0xcbfb
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl 0x8(%rax,%rcx,4), %ecx
shrl $0x18, %ecx
movb %cl, %dl
movl -0x14(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
movb %dl, 0x68(%rax,%rcx)
movslq -0x14(%rbp), %rcx
movl 0x8(%rax,%rcx,4), %ecx
shrl $0x10, %ecx
movb %cl, %dl
movl -0x14(%rbp), %ecx
shll $0x2, %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, 0x68(%rax,%rcx)
movslq -0x14(%rbp), %rcx
movl 0x8(%rax,%rcx,4), %ecx
shrl $0x8, %ecx
movb %cl, %dl
movl -0x14(%rbp), %ecx
shll $0x2, %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb %dl, 0x68(%rax,%rcx)
movslq -0x14(%rbp), %rcx
movl 0x8(%rax,%rcx,4), %ecx
movb %cl, %dl
movl -0x14(%rbp), %ecx
shll $0x2, %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movb %dl, 0x68(%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcb71
movq -0x20(%rbp), %rdi
callq 0x8500
movq -0x20(%rbp), %rax
addq $0x68, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::STORE32H(unsigned int&, unsigned char*)
static inline void STORE32H(U32& x, unsigned char* y) {
  y[0]=x>>24;
  y[1]=x>>16;
  y[2]=x>>8;
  y[3]=x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x18, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
shrq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x14(%rbp), %rdx
addq %rdx, %rcx
shrq $0x4, %rcx
cmpq %rcx, %rax
ja 0xddac
movq -0x50(%rbp), %rdi
movl 0x14f4(%rdi), %esi
movl 0x14f8(%rdi), %edx
movq -0x28(%rbp), %rax
shrq $0x20, %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %eax, %r8d
leaq -0x40(%rbp), %r9
callq 0xd430
movl $0x0, -0x44(%rbp)
cmpl $0x10, -0x44(%rbp)
jge 0xdd99
movq -0x28(%rbp), %rax
shlq $0x4, %rax
subq -0x20(%rbp), %rax
movslq -0x44(%rbp), %rcx
addq %rcx, %rax
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x48(%rbp)
jl 0xdd8c
movl -0x48(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xdd8c
movslq -0x44(%rbp), %rax
movzbl -0x40(%rbp,%rax), %esi
movq -0x10(%rbp), %rax
movslq -0x48(%rbp), %rcx
movsbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
jmp 0xdd8e
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xdd48
jmp 0xdd9b
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xdcfb
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::scrypt(char const*, int, char const*, int, int, int, int, char*, int)
void scrypt(const char* pw, int pwlen,
            const char* salt, int saltlen,
            int n, int r, int p, char* buf, int buflen) {
  assert(r<=8);
  assert(n>0 && (n&(n-1))==0);  // power of 2?
  libzpaq::Array<char> b(p*r*128);
  pbkdf2(pw, pwlen, salt, saltlen, 1, &b[0], p*r*128);
  for (int i=0; i<p; ++i) smix(&b[i*r*128], r, n);
  pbkdf2(pw, pwlen, &b[0], p*r*128, 1, buf, buflen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl 0x10(%rbp), %eax
movl -0x24(%rbp), %ecx
imull %ecx, %eax
shll $0x7, %eax
movslq %eax, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x80(%rbp)
xorl %edx, %edx
movl %edx, -0x84(%rbp)
callq 0x30190
movl -0x84(%rbp), %eax
movq -0x80(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, -0x6c(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movl -0x1c(%rbp), %ecx
movl %ecx, -0x5c(%rbp)
movl %eax, %esi
callq 0x301d0
movq %rax, -0x58(%rbp)
jmp 0xde42
movq -0x58(%rbp), %r9
movl -0x5c(%rbp), %ecx
movq -0x68(%rbp), %rdx
movl -0x6c(%rbp), %esi
movq -0x78(%rbp), %rdi
movl 0x10(%rbp), %r8d
movl -0x24(%rbp), %eax
imull %eax, %r8d
shll $0x7, %r8d
movq %rsp, %rax
movl %r8d, (%rax)
movl $0x1, %r8d
callq 0xdf60
jmp 0xde76
movl $0x0, -0x50(%rbp)
movl -0x50(%rbp), %eax
cmpl 0x10(%rbp), %eax
jge 0xdede
movl -0x50(%rbp), %eax
movl -0x24(%rbp), %ecx
imull %ecx, %eax
shll $0x7, %eax
movslq %eax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x301d0
movq %rax, -0x90(%rbp)
jmp 0xdea6
movq -0x90(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x20(%rbp), %edx
callq 0xe210
jmp 0xdeba
jmp 0xdebc
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0xde7d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x301f0
jmp 0xdf55
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x9c(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
callq 0x301d0
movq %rax, -0x98(%rbp)
jmp 0xdf08
movq -0x98(%rbp), %rdx
movl -0x9c(%rbp), %esi
movq -0xa8(%rbp), %rdi
movl 0x10(%rbp), %ecx
movl -0x24(%rbp), %eax
imull %eax, %ecx
shll $0x7, %ecx
movq 0x18(%rbp), %r9
movl 0x20(%rbp), %r8d
movq %rsp, %rax
movl %r8d, (%rax)
movl $0x1, %r8d
callq 0xdf60
jmp 0xdf43
leaq -0x40(%rbp), %rdi
callq 0x301f0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5490
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x29928(%rip), %rdi     # 0x37ece
leaq 0x2992e(%rip), %rsi     # 0x37edb
callq 0x5310
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xe5e3
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x53f0
cmpl -0xc(%rbp), %eax
jne 0xe5e3
movq -0x18(%rbp), %rdi
callq 0x5260
jmp 0xe5ef
leaq 0x298f4(%rip), %rdi     # 0x37ede
callq 0x5720
cmpl $0x1, -0xc(%rbp)
jl 0xe61c
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7a, %eax
je 0xe60d
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x37, %eax
jne 0xe61c
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl $0x80, %ecx
movb %cl, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq $0x0, 0x20(%rdi)
movq $0x0, 0x18(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x8(%rdi)
movq $0x0, (%rdi)
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x30220
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x30370
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x304c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: twekkel[P]mzpq/libzpaq.cpp
// Function: libzpaq::ZPAQL::write(libzpaq::Writer*, bool)
bool ZPAQL::write(Writer* out2, bool pp) {
  if (header.size()<=6) return false;
  assert(header[0]+256*header[1]==cend-2+hend-hbegin);
  assert(cend>=7);
  assert(hbegin>=cend);
  assert(hend>=hbegin);
  assert(out2);
  if (!pp) {  // if not a postprocessor then write COMP
    for (int i=0; i<cend; ++i)
      out2->put(header[i]);
  }
  else {  // write PCOMP size only
    out2->put((hend-hbegin)&255);
    out2->put((hend-hbegin)>>8);
  }
  for (int i=hbegin; i<hend; ++i)
    out2->put(header[i]);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x10, %rdi
callq 0x30610
cmpq $0x6, %rax
ja 0xe717
movb $0x0, -0x1(%rbp)
jmp 0xe7db
testb $0x1, -0x19(%rbp)
jne 0xe762
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0xe760
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x10, %rdi
movslq -0x20(%rbp), %rsi
callq 0x30630
movq -0x38(%rbp), %rdi
movzbl (%rax), %esi
movq (%rdi), %rax
callq *(%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xe724
jmp 0xe791
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rdi
movl 0x30(%rax), %esi
subl 0x2c(%rax), %esi
andl $0xff, %esi
movq (%rdi), %rax
callq *(%rax)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rdi
movl 0x30(%rax), %esi
subl 0x2c(%rax), %esi
sarl $0x8, %esi
movq (%rdi), %rax
callq *(%rax)
movq -0x30(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x30(%rcx), %eax
jge 0xe7d7
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x10, %rdi
movslq -0x24(%rbp), %rsi
callq 0x30630
movq -0x40(%rbp), %rdi
movzbl (%rax), %esi
movq (%rdi), %rax
callq *(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xe79b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x0, 0x30(%rdi)
movl $0x0, 0x2c(%rdi)
movl $0x0, 0x28(%rdi)
movl $0x0, 0xb0(%rdi)
movl $0x0, 0xac(%rdi)
movl $0x0, 0xa8(%rdi)
movl $0x0, 0xa4(%rdi)
movl $0x0, 0xa0(%rdi)
movl $0x0, 0x9c(%rdi)
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x30370
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x30220
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x30370
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x30220
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0xb8, %rdi
addq $0xb4, %rsi
xorl %edx, %edx
callq 0x65c0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x10, %rdi
movq %rdi, -0x40(%rbp)
xorl %edx, %edx
movl %edx, -0x24(%rbp)
movl %edx, %esi
movq %rsi, -0x30(%rbp)
callq 0x30650
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x24(%rbp), %edx
addq $0x38, %rdi
movq %rdi, -0x20(%rbp)
callq 0x30650
jmp 0xec66
movq -0x38(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x48(%rbp)
xorl %edx, %edx
movl %edx, %esi
callq 0x30690
jmp 0xec7d
movq -0x38(%rbp), %rdi
addq $0x68, %rdi
movq %rdi, -0x50(%rbp)
xorl %edx, %edx
movl %edx, %esi
callq 0x30690
jmp 0xec94
movq -0x38(%rbp), %rdi
subq $-0x80, %rdi
movq %rdi, -0x58(%rbp)
xorl %edx, %edx
movl %edx, %esi
callq 0x30190
jmp 0xecab
movq -0x38(%rbp), %rdi
movq $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
movq $0x0, 0xb8(%rdi)
movl $0x0, 0xb4(%rdi)
callq 0xeb50
jmp 0xecda
movq -0x38(%rbp), %rdi
subq $-0x80, %rdi
movl $0x4000, %esi           # imm = 0x4000
xorl %edx, %edx
callq 0x306d0
jmp 0xecf0
movq -0x38(%rbp), %rax
movl $0x0, 0x98(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0xed6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0xed63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0xed5a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0xed51
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x301f0
movq -0x50(%rbp), %rdi
callq 0x30820
movq -0x48(%rbp), %rdi
callq 0x30820
movq -0x20(%rbp), %rdi
callq 0x30850
movq -0x40(%rbp), %rdi
callq 0x30850
movq -0x10(%rbp), %rdi
callq 0x5490
nop