LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: besm6[P]pascal-re/pascompl.cc
// Function: checkRecord(IdentRec*, IdentRec*)
bool checkRecord(IdentRecPtr l4arg1z, IdentRecPtr l4arg2z)
{
    bool l4var1z = (l4arg1z == NULL) or (l4arg2z == NULL);
    if (l4var1z) {
        return l4arg1z == l4arg2z;
    } else {
        return typeCheck(l4arg1z->typ, l4arg2z->typ) and
            checkRecord(l4arg1z->list(), l4arg2z->list());
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x1, %al
cmpq $0x0, -0x10(%rbp)
movb %al, -0x75(%rbp)
je 0xb17a
cmpq $0x0, -0x18(%rbp)
sete %al
movb %al, -0x75(%rbp)
movb -0x75(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0xb19d
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xb268
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
leaq -0x68(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xb280
movq -0x80(%rbp), %rdi
callq 0x1e950
movb %al, -0x76(%rbp)
jmp 0xb1c8
movb -0x76(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x81(%rbp)
jne 0xb1da
jmp 0xb23b
movq -0x10(%rbp), %rdi
callq 0x1e970
movq %rax, -0x90(%rbp)
jmp 0xb1ec
movq -0x90(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1e970
movq %rax, -0x98(%rbp)
jmp 0xb20f
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rax
movq (%rax), %rsi
callq 0xb150
movb %al, -0xa1(%rbp)
jmp 0xb22d
movb -0xa1(%rbp), %al
movb %al, -0x81(%rbp)
jmp 0xb23b
movb -0x81(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1e9c0
jmp 0xb268
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1e9c0
jmp 0xb276
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x44c0
nop
// File: besm6[P]pascal-re/pascompl.cc
// Function: F3307(IdentRec*)
int64_t F3307(IdentRecPtr l3arg1z)
{
    int64_t l3var1z;
    IdentRecPtr l3var2z;
    l3var2z = l3arg1z->argList();
    l3var1z = 0;
    if (l3var2z != NULL)
        while (l3var2z != l3arg1z) {
            l3var1z = l3var1z + 1;
            l3var2z = l3var2z->list();
        }
    return l3var1z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ec30
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb987
jmp 0xb95d
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0xb985
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1e970
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xb95d
jmp 0xb987
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: makeNameWithStars(bool)
int64_t makeNameWithStars(bool isProc)
{
    bool wantBoth = not isProc and (extSymAdornment == 0);
    if (curVal.m * BitRange(0, 5) == Bits()) {
        curVal.m = curVal.m << 6;
        if (wantBoth or (extSymAdornment == 1))
            curVal.m = curVal.m + Bits(44, 46);
        while (curVal.m * BitRange(0, 11) == Bits()) {
            curVal.m = curVal.m << 6;
        }
        if (curVal.m * BitRange(0, 5) == Bits()) {
            if (wantBoth)
                curVal.m = Bits(2, 4) + curVal.m;
            else {
                curVal.m = curVal.m << 6;
            }
        }
    }
    return curVal.ii;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
xorl %eax, %eax
testb $0x1, -0x1(%rbp)
movb %al, -0x91(%rbp)
jne 0xb9d2
cmpq $0x0, 0x747bf(%rip)     # 0x80188
sete %al
movb %al, -0x91(%rbp)
movb -0x91(%rbp), %al
andb $0x1, %al
movb %al, -0x2(%rbp)
xorl %eax, %eax
movl %eax, %edi
movl $0x5, %esi
callq 0x4a60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x746f6(%rip), %rdi     # 0x800f0
callq 0x1e580
movq %rax, -0x10(%rbp)
callq 0x48c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x1e420
testb $0x1, %al
jne 0xba22
jmp 0xbb9e
leaq 0x746c7(%rip), %rdi     # 0x800f0
movl $0x6, %esi
callq 0x1e650
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, 0x746ae(%rip)     # 0x800f0
testb $0x1, -0x2(%rbp)
jne 0xba52
cmpq $0x1, 0x74738(%rip)     # 0x80188
jne 0xba84
movl $0x2c, %edi
movl $0x2e, %esi
callq 0x4940
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
leaq 0x74680(%rip), %rdi     # 0x800f0
callq 0x1db20
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, 0x7466c(%rip)     # 0x800f0
jmp 0xba86
xorl %eax, %eax
movl %eax, %edi
movl $0xb, %esi
callq 0x4a60
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
leaq 0x7464d(%rip), %rdi     # 0x800f0
callq 0x1e580
movq %rax, -0x40(%rbp)
callq 0x48c0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x1e420
testb $0x1, %al
jne 0xbac8
jmp 0xbaea
leaq 0x74621(%rip), %rdi     # 0x800f0
movl $0x6, %esi
callq 0x1e650
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, 0x74608(%rip)     # 0x800f0
jmp 0xba86
xorl %eax, %eax
movl %eax, %edi
movl $0x5, %esi
callq 0x4a60
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rsi
leaq 0x745e9(%rip), %rdi     # 0x800f0
callq 0x1e580
movq %rax, -0x60(%rbp)
callq 0x48c0
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x1e420
testb $0x1, %al
jne 0xbb2c
jmp 0xbb9c
testb $0x1, -0x2(%rbp)
je 0xbb74
movl $0x2, %edi
movl $0x4, %esi
callq 0x4940
movq %rax, -0x80(%rbp)
movq 0x745a4(%rip), %rax     # 0x800f0
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x1db20
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, 0x7457e(%rip)     # 0x800f0
jmp 0xbb9a
leaq 0x74575(%rip), %rdi     # 0x800f0
movl $0x6, %esi
callq 0x1e650
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq %rax, 0x74556(%rip)     # 0x800f0
jmp 0xbb9c
jmp 0xbb9e
movq 0x7454b(%rip), %rax     # 0x800f0
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: besm6[P]pascal-re/pascompl.cc
// Function: addToInsnList(long)
void addToInsnList(int64_t insn)
{
    OneInsnPtr elt = new OneInsn;
    elt->next = NULL;
    elt->mode = 0;
    elt->code = insn;
    elt->offset = 0;
    if (insnList->next == NULL)
        insnList->next2 = elt;
    else
        insnList->next->next = elt;
    insnList->next = elt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x20, %edi
callq 0x1e2e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq 0x74568(%rip), %rax     # 0x80168
cmpq $0x0, (%rax)
jne 0xbc17
movq -0x10(%rbp), %rcx
movq 0x74557(%rip), %rax     # 0x80168
movq %rcx, 0x8(%rax)
jmp 0xbc28
movq -0x10(%rbp), %rcx
movq 0x74546(%rip), %rax     # 0x80168
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x74535(%rip), %rax     # 0x80168
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: addxToInsnList(long)
void addxToInsnList(int64_t insn)
{
    OneInsnPtr elt = new OneInsn;
    elt->next = insnList->next2;
    elt->mode = 0;
    elt->code = insn;
    elt->offset = 0;
    if (insnList->next2 == NULL)  {
        insnList->next = elt;
    }
    insnList->next2 = elt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x20, %edi
callq 0x1e2e0
movq %rax, -0x10(%rbp)
movq 0x744c7(%rip), %rax     # 0x80168
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq 0x74491(%rip), %rax     # 0x80168
cmpq $0x0, 0x8(%rax)
jne 0xbcec
movq -0x10(%rbp), %rcx
movq 0x7447f(%rip), %rax     # 0x80168
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x74471(%rip), %rax     # 0x80168
movq %rcx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: P5117(Operator)
void P5117(Operator op)
{
    int64_t & localSize = programme::super.back()->localSize;
    int64_t & l2int21z = programme::super.back()->l2int21z;

    addInsnAndOffset(curFrameRegTemplate, localSize);
    curExpr = new Expr;
    curExpr->typ = insnList->typ;
    genOneOp();
    curExpr->op = op;
    curExpr->num1 = localSize;
    localSize = localSize + 1;
    if (l2int21z < localSize)
        l2int21z = localSize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x6d0, %rsp            # imm = 0x6D0
movl %edi, -0x4(%rbp)
leaq 0xcc54b(%rip), %rdi     # 0xd8a30
callq 0x1e890
movq (%rax), %rax
addq $0x90, %rax
movq %rax, -0x10(%rbp)
leaq 0xcc532(%rip), %rdi     # 0xd8a30
callq 0x1e890
movq (%rax), %rax
addq $0x98, %rax
movq %rax, -0x18(%rbp)
movq 0x73a41(%rip), %rdi     # 0x7ff58
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0xbc40
movl $0x20, %edi
callq 0x1e2e0
movq %rax, 0x73c2c(%rip)     # 0x80160
movq 0x73c2d(%rip), %rax     # 0x80168
movq 0x10(%rax), %rcx
movq 0x73c1a(%rip), %rax     # 0x80160
movq %rcx, (%rax)
leaq -0x6c8(%rbp), %rdi
callq 0x1ed00
movl -0x4(%rbp), %ecx
movq 0x73c01(%rip), %rax     # 0x80160
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq 0x73bf0(%rip), %rax     # 0x80160
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jge 0xc5a4
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x6d0, %rsp            # imm = 0x6D0
popq %rbp
retq
nopl (%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: insnCount()
int64_t insnCount()
{
    int64_t cnt;
    OneInsnPtr cur;
    cnt = 0;
    cur = insnList->next2;
    while (cur != NULL) {
        cur = cur->next;
        cnt = cnt + 1;
    }
    return cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq $0x0, -0x8(%rbp)
movq 0x73ba5(%rip), %rax     # 0x80168
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xc5eb
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xc5cb
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: allocGlobalObject(IdentRec*)
int64_t allocGlobalObject(IdentRecPtr l6arg1z)
{
    if (l6arg1z->pos() == 0) {
        if (l6arg1z->flags() * Bits(20, 21) != Bits()) {
            curVal.ii = l6arg1z->id;
            curVal.ii = makeNameWithStars(true);
            l6arg1z->pos() = allocExtSymbol(extSymMask);
        } else {
            l6arg1z->pos() = symTabPos;
            putToSymTab(0);
        }
    }
    return l6arg1z->pos();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20910
cmpq $0x0, (%rax)
jne 0xd281
movq -0x8(%rbp), %rdi
callq 0x20960
movq %rax, -0x28(%rbp)
movl $0x14, %edi
movl $0x15, %esi
callq 0x4940
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x1e580
movq %rax, -0x10(%rbp)
callq 0x48c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x1e550
testb $0x1, %al
jne 0xd21c
jmp 0xd25b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x72ec6(%rip)     # 0x800f0
movl $0x1, %edi
callq 0xb9a0
movq %rax, 0x72eb5(%rip)     # 0x800f0
movl $0x8c0000, %edi         # imm = 0x8C0000
callq 0x7fb0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20910
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
jmp 0xd27f
movq 0x72c96(%rip), %rax     # 0x7fef8
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20910
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x7f50
jmp 0xd281
movq -0x8(%rbp), %rdi
callq 0x20910
movq (%rax), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: genEntry::traceEntry(bool)
void genEntry::traceEntry(bool isEntry)
{
    if (not optSflags.m.has(DebugEntry))
        return;
    curVal.ii = l5idr5z->id;
    addToInsnList(KVTM+I10 + addCurValToFCST());
    if (isEntry)
        addToInsnList(KVTM+I11 + lineCnt);
    addToInsnList(getHelperProc(isEntry * 22 + 57)); /* P/C(E|I) */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x72e6d(%rip), %rdi     # 0x80130
movl $0x2f, %esi
callq 0x1e5f0
testb $0x1, %al
jne 0xd2d3
jmp 0xd330
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq %rax, 0x72e0b(%rip)     # 0x800f0
callq 0x8170
movq %rax, %rdi
addq $0xaa0000, %rdi         # imm = 0xAA0000
callq 0xbbb0
testb $0x1, -0x9(%rbp)
je 0xd312
movq 0x72c6a(%rip), %rdi     # 0x7ff70
addq $0xba0000, %rdi         # imm = 0xBA0000
callq 0xbbb0
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
imull $0x16, %eax, %eax
addl $0x39, %eax
movslq %eax, %rdi
callq 0x80d0
movq %rax, %rdi
callq 0xbbb0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: startInsnList(ilmode)
void startInsnList(ilmode l5arg1z)
{
    ExprPtr & exprToGen = genFullExpr::super.back()->exprToGen;
    insnList = new InsnList;
    insnList->next = NULL;
    insnList->next2 = NULL;
    insnList->typ = exprToGen->typ;
    insnList->regsused = Bits();
    insnList->ilm = l5arg1z;
    if (l5arg1z == ilCONST) {
        insnList->ilf5.ii = exprToGen->num1;
        insnList->ilf7 = exprToGen->num2;
    } else {
        insnList->st = st0;
        insnList->ilf7 = 18;
        insnList->ilf5.ii = curFrameRegTemplate;
        insnList->ilf6 = exprToGen->num1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
leaq 0xca6be(%rip), %rdi     # 0xd8a90
callq 0x203b0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x58, %edi
callq 0x1e2e0
movq %rax, 0x71d79(%rip)     # 0x80168
movq 0x71d72(%rip), %rax     # 0x80168
movq $0x0, (%rax)
movq 0x71d64(%rip), %rax     # 0x80168
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq 0x71d4b(%rip), %rax     # 0x80168
movq %rcx, 0x10(%rax)
callq 0x48c0
movq %rax, -0x18(%rbp)
movq 0x71d37(%rip), %rax     # 0x80168
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl -0x4(%rbp), %ecx
movq 0x71d25(%rip), %rax     # 0x80168
movl %ecx, 0x20(%rax)
cmpl $0x0, -0x4(%rbp)
jne 0xe47a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq 0x71d0a(%rip), %rax     # 0x80168
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rcx
movq 0x71cf4(%rip), %rax     # 0x80168
movq %rcx, 0x38(%rax)
jmp 0xe4bf
movq 0x71ce7(%rip), %rax     # 0x80168
movl $0x0, 0x40(%rax)
movq 0x71cd9(%rip), %rax     # 0x80168
movq $0x12, 0x38(%rax)
movq 0x71aba(%rip), %rcx     # 0x7ff58
movq 0x71cc3(%rip), %rax     # 0x80168
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq 0x71cad(%rip), %rax     # 0x80168
movq %rcx, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: genCopy()
void genCopy()
{
    int64_t size;
    InsnList * &saved = formOperator::super.back()->saved;
    int64_t &work = genFullExpr::super.back()->work;
    InsnList * &otherIns = genFullExpr::super.back()->otherIns;

    size = insnList->typ->size;
    if (size == 1) {
        saved = insnList;
        insnList = otherIns;
        prepLoad();
        genOneOp();
        insnList = saved;
        prepStore();
        genOneOp();
    } else {
        genFullExpr::super.back()->prepMultiWord();
        genOneOp();
        size = size - 1;
        formAndAlign(KVTM+I13 + getValueOrAllocSymtab(-size));
        work = moduleOffset;
        form2Insn(KUTC+I14 + size, KXTA+I13);
        form3Insn(KUTC+I12 + size, KATX+I13,
                  KVLM+I13 + work);
        regsUsed = regsUsed + BitRange(12,14);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1440, %rsp           # imm = 0x1440
leaq 0xca596(%rip), %rdi     # 0xd8a78
callq 0x203f0
movq (%rax), %rax
addq $0x58, %rax
movq %rax, -0x10(%rbp)
leaq 0xca597(%rip), %rdi     # 0xd8a90
callq 0x203b0
movq (%rax), %rax
addq $0x30, %rax
movq %rax, -0x18(%rbp)
leaq 0xca580(%rip), %rdi     # 0xd8a90
callq 0x203b0
movq (%rax), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq 0x71c41(%rip), %rax     # 0x80168
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x1, -0x8(%rbp)
jne 0xe58a
movq 0x71c28(%rip), %rcx     # 0x80168
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x71c13(%rip)     # 0x80168
callq 0xbd10
leaq -0x6d0(%rbp), %rdi
callq 0x1ed00
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x71bf4(%rip)     # 0x80168
callq 0xc210
leaq -0xd80(%rbp), %rdi
callq 0x1ed00
jmp 0xe656
leaq 0xca4ff(%rip), %rdi     # 0xd8a90
callq 0x203b0
movq (%rax), %rdi
callq 0x209b0
leaq -0x1430(%rbp), %rdi
callq 0x1ed00
movq -0x8(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
subq -0x8(%rbp), %rdi
callq 0x8870
movq %rax, %rdi
addq $0xda0000, %rdi         # imm = 0xDA0000
callq 0x7f20
movq 0x7196f(%rip), %rcx     # 0x7ff48
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
addq $0xe90000, %rdi         # imm = 0xE90000
movl $0xd08000, %esi         # imm = 0xD08000
callq 0x7da0
movq -0x8(%rbp), %rdi
addq $0xc90000, %rdi         # imm = 0xC90000
movq -0x18(%rbp), %rax
movq (%rax), %rdx
addq $0xdf8000, %rdx         # imm = 0xDF8000
movl $0xd00000, %esi         # imm = 0xD00000
callq 0x7dd0
movl $0xc, %edi
movl $0xe, %esi
callq 0x4a60
movq %rax, -0x1440(%rbp)
movq -0x1440(%rbp), %rsi
leaq 0x71ad4(%rip), %rdi     # 0x80110
callq 0x1db20
movq %rax, -0x1438(%rbp)
movq -0x1438(%rbp), %rax
movq %rax, 0x71aba(%rip)     # 0x80110
addq $0x1440, %rsp           # imm = 0x1440
popq %rbp
retq
nop
// File: besm6[P]pascal-re/pascompl.cc
// Function: dumpEnumNames(ScalarT*)
void dumpEnumNames(ScalarT * l3arg1z)
{
    IdentRecPtr l3var1z;
    if (l3arg1z->start == 0) {
        l3arg1z->start = FcstCnt;
        l3var1z = l3arg1z->enums;
        while (l3var1z != NULL) {
            curVal.ii = l3var1z->id;
            l3var1z = l3var1z->list();
            toFCST();
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x140c0
movq 0x6be72(%rip), %rcx     # 0x7fef0
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x140be
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x6c049(%rip)     # 0x800f0
movq -0x10(%rbp), %rdi
callq 0x1e970
movq (%rax), %rax
movq %rax, -0x10(%rbp)
callq 0x8140
jmp 0x14092
jmp 0x140c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: castToReal(Expr*&)
void castToReal(ExprPtr & value)
{
    ExprPtr cast;
    cast = new Expr;
    cast->typ = RealType;
    cast->op = TOREAL;
    cast->expr1 = value;
    value = cast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x20, %edi
callq 0x1e2e0
movq %rax, -0x10(%rbp)
movq 0x6afaf(%rip), %rcx     # 0x800b0
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x29, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: areTypesCompatible(Expr*&)
bool areTypesCompatible(ExprPtr & l4arg1z)
{
    if (arg1Type == RealType) {
        if (typeCheck(IntegerType, arg2Type)) {
            castToReal(l4arg1z);
            return true;
        }
    } else if (arg2Type == RealType and
               typeCheck(IntegerType, arg1Type)) {
        castToReal(curExpr);
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq 0x6af72(%rip), %rax     # 0x800c8
cmpq 0x6af53(%rip), %rax     # 0x800b0
jne 0x151d7
movq 0x6af42(%rip), %rsi     # 0x800a8
movq 0x6af63(%rip), %rdx     # 0x800d0
leaq -0x58(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0xb280
movq -0xc0(%rbp), %rdi
callq 0x1e950
movb %al, -0xb2(%rbp)
jmp 0x15191
leaq -0x58(%rbp), %rdi
callq 0x1e9c0
movb -0xb2(%rbp), %al
testb $0x1, %al
jne 0x151a6
jmp 0x151d2
movq -0x10(%rbp), %rdi
callq 0x150e0
movb $0x1, -0x1(%rbp)
jmp 0x152af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1e9c0
jmp 0x152bd
jmp 0x152ab
movq 0x6aef2(%rip), %rcx     # 0x800d0
movq 0x6aecb(%rip), %rdx     # 0x800b0
movb $0x0, -0xb1(%rbp)
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0xc1(%rbp)
jne 0x15243
movq 0x6aea8(%rip), %rsi     # 0x800a8
movq 0x6aec1(%rip), %rdx     # 0x800c8
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0xb280
movq -0xd0(%rbp), %rdi
movb $0x1, -0xb1(%rbp)
callq 0x1e950
movb %al, -0xc2(%rbp)
jmp 0x15235
movb -0xc2(%rbp), %al
movb %al, -0xc1(%rbp)
jmp 0x15243
movb -0xc1(%rbp), %al
movb %al, -0xd1(%rbp)
testb $0x1, -0xb1(%rbp)
jne 0x1525a
jmp 0x15266
leaq -0xb0(%rbp), %rdi
callq 0x1e9c0
movb -0xd1(%rbp), %al
testb $0x1, %al
jne 0x15272
jmp 0x152a9
leaq 0x6aee7(%rip), %rdi     # 0x80160
callq 0x150e0
movb $0x1, -0x1(%rbp)
jmp 0x152af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
testb $0x1, -0xb1(%rbp)
jne 0x1529b
jmp 0x152a7
leaq -0xb0(%rbp), %rdi
callq 0x1e9c0
jmp 0x152bd
jmp 0x152ab
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xe0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x44c0
nopw %cs:(%rax,%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: withStatement()
void withStatement()
{
    ExprPtr l4exp1z;
    Bitset l4var2z, l4var3z;
    int64_t l4var4z;
    int64_t & localSize = programme::super.back()->localSize;

    l4exp1z = expr63z;
    l4var4z = localSize;
    l4var2z = set147z;
    l4var3z = Bits();
    do {
        inSymbol();
        if (hashTravPtr != NULL and
            hashTravPtr->cl >= VARID) {
            parseLval();
            if (curExpr->typ->k == kindRecord) {
                (void) formOperator(SETREG);
                l4var3z = (l4var3z + Bits(curVal.i)) * set148z;
            } else {
                error(71); /* errWithOperatorNotOfARecord */
            }
        } else {
            error(72); /* errWithOperatorNotOfAVariable */
        }
    } while (SY == COMMA);
    checkSymAndRead(DOSY);
    Statement();
    expr63z = l4exp1z;
    localSize = l4var4z;
    set147z = l4var2z;
    regsUsed = regsUsed + l4var3z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
leaq 0xc284e(%rip), %rdi     # 0xd8a30
callq 0x1e890
movq (%rax), %rax
addq $0x90, %rax
movq %rax, -0x28(%rbp)
movq 0x69d1d(%rip), %rax     # 0x7ff18
movq %rax, -0x8(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq 0x69f0f(%rip), %rax     # 0x80120
movq %rax, -0x10(%rbp)
callq 0x48c0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x9790
cmpq $0x0, 0x69e26(%rip)     # 0x80060
je 0x162fa
movq 0x69e19(%rip), %rax     # 0x80060
cmpl $0x3, 0x20(%rax)
jl 0x162fa
callq 0x14ae0
movq 0x69f03(%rip), %rax     # 0x80160
movq (%rax), %rax
cmpl $0x6, 0x10(%rax)
jne 0x162ee
leaq -0x208(%rbp), %rdi
movl $0x4, %esi
callq 0x112d0
leaq -0x208(%rbp), %rdi
callq 0x21850
leaq 0x69e62(%rip), %rdi     # 0x800f0
callq 0x1dfb0
movq %rax, %rdi
callq 0x48e0
movq %rax, -0x220(%rbp)
movq -0x220(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x1db20
movq %rax, -0x218(%rbp)
movq 0x69e68(%rip), %rax     # 0x80128
movq %rax, -0x228(%rbp)
movq -0x228(%rbp), %rsi
leaq -0x218(%rbp), %rdi
callq 0x1e580
movq %rax, -0x210(%rbp)
movq -0x210(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x162f8
movl $0x47, %edi
callq 0x7b40
jmp 0x16304
movl $0x48, %edi
callq 0x7b40
jmp 0x16306
cmpl $0xe, 0x69bcf(%rip)     # 0x7fedc
je 0x16226
movl $0x2b, %edi
callq 0xb110
leaq -0x280(%rbp), %rdi
callq 0x173f0
leaq -0x280(%rbp), %rdi
callq 0x229f0
movq -0x8(%rbp), %rax
movq %rax, 0x69bd8(%rip)     # 0x7ff18
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x69dca(%rip)     # 0x80120
movq -0x18(%rbp), %rax
movq %rax, -0x290(%rbp)
movq -0x290(%rbp), %rsi
leaq 0x69da1(%rip), %rdi     # 0x80110
callq 0x1db20
movq %rax, -0x288(%rbp)
movq -0x288(%rbp), %rax
movq %rax, 0x69d87(%rip)     # 0x80110
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: compoundStatement()
void compoundStatement()
{
    do {
        Statement();
        if (SY == SEMICOLON) {
            inSymbol();
        } else
            break;
    } while(true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
leaq -0x58(%rbp), %rdi
callq 0x173f0
leaq -0x58(%rbp), %rdi
callq 0x229f0
cmpl $0xf, 0x68bc8(%rip)     # 0x7fedc
jne 0x17324
leaq -0x1c8(%rbp), %rdi
callq 0x9790
jmp 0x17326
jmp 0x17330
jmp 0x17328
movb $0x1, %al
testb $0x1, %al
jne 0x172fb
jmp 0x17330
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
nopl (%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: ifWhileStatement(Symbol)
void ifWhileStatement(Symbol delim)
{
    int64_t &l3var10z = Statement::super.back()->l3var10z;

    disableNorm();
    expression();
    jumpTarget = 0;
    if (curExpr->typ != BooleanType)
        error(errBooleanNeeded);
    else {
        (void) formOperator(CONDJUMP);
    }
    l3var10z = jumpTarget;
    checkSymAndRead(delim);
    Statement();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl %edi, -0x4(%rbp)
leaq 0xc178b(%rip), %rdi     # 0xd8ae0
callq 0x22a10
movq (%rax), %rax
addq $0x40, %rax
movq %rax, -0x10(%rbp)
callq 0x7e00
callq 0x14e90
movq $0x0, 0x68b4e(%rip) # 0x7fec8
movq 0x68ddf(%rip), %rax     # 0x80160
movq (%rax), %rax
cmpq 0x68d0d(%rip), %rax     # 0x80098
je 0x17398
xorl %eax, %eax
movl %eax, %edi
callq 0x7b40
jmp 0x173af
leaq -0x78(%rbp), %rdi
movl $0xf, %esi
callq 0x112d0
leaq -0x78(%rbp), %rdi
callq 0x21850
movq 0x68b12(%rip), %rcx     # 0x7fec8
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x4(%rbp), %edi
callq 0xb110
leaq -0xd0(%rbp), %rdi
callq 0x173f0
leaq -0xd0(%rbp), %rdi
callq 0x229f0
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: outputObjFile()
void outputObjFile()
{
    int64_t idx;

    padToLeft();
    objBufIdx = objBufIdx - 1;
    for (idx = 1; idx <= objBufIdx; ++idx)
        CHILD.push_back(objBuffer[idx]);
    lineStartOffset = moduleOffset;
    prevOpcode = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x7ef0
movq 0x67ec4(%rip), %rax     # 0x7fff8
subq $0x1, %rax
movq %rax, 0x67eb9(%rip)     # 0x7fff8
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq 0x67ea6(%rip), %rax     # 0x7fff8
jg 0x18180
movq -0x8(%rbp), %rax
leaq 0xb0781(%rip), %rsi     # 0xc88e0
shlq $0x3, %rax
addq %rax, %rsi
leaq 0xc089b(%rip), %rdi     # 0xd8a08
callq 0x1e3b0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x18147
movq 0x67dc1(%rip), %rax     # 0x7ff48
movq %rax, 0x67dc2(%rip)     # 0x7ff50
movq $0x0, 0x67e7f(%rip) # 0x80018
addq $0x10, %rsp
popq %rbp
retq
nop
// File: besm6[P]pascal-re/pascompl.cc
// Function: makeExtFile()
void makeExtFile()
{
    ExprPtr &l2var10z = programme::super.back()->l2var10z;
    IdentRecPtr &workidr = programme::super.back()->workidr;
    l2var10z = new Expr;
    l2var10z->typ = reinterpret_cast<TypesPtr>(curExternFile);
    l2var10z->id2 = workidr;
    l2var10z->expr1 = curExpr;
    curExpr = l2var10z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xbeba1(%rip), %rdi     # 0xd8a30
callq 0x1e890
movq (%rax), %rax
addq $0x40, %rax
movq %rax, -0x8(%rbp)
leaq 0xbeb8a(%rip), %rdi     # 0xd8a30
callq 0x1e890
movq (%rax), %rax
addq $0x30, %rax
movq %rax, -0x10(%rbp)
movl $0x20, %edi
callq 0x1e2e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq 0x660ff(%rip), %rcx     # 0x7ffd0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x18(%rax)
movq 0x6626c(%rip), %rcx     # 0x80160
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x66253(%rip)     # 0x80160
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: exitScope(IdentRec**)
void exitScope(IdentRecPtr arg[128])
{
    IdentRecPtr &workidr = programme::super.back()->workidr;
    IdentRecPtr &scopeBound = programme::super.back()->scopeBound;

    for (int ii = 0; ii <= 127; ++ii) {
        workidr = arg[ii];
        while (workidr != NULL and
              workidr >= scopeBound)
            workidr = workidr->next;
        arg[ii] = workidr;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xbe46d(%rip), %rdi     # 0xd8a30
callq 0x1e890
movq (%rax), %rax
addq $0x30, %rax
movq %rax, -0x10(%rbp)
leaq 0xbe456(%rip), %rdi     # 0xd8a30
callq 0x1e890
movq (%rax), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x7f, -0x1c(%rbp)
jg 0x1a668
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x1d(%rbp)
je 0x1a62d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
setae %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x1a636
jmp 0x1a64a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1a60a
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1a5f1
addq $0x20, %rsp
popq %rbp
retq
nop
// File: besm6[P]pascal-re/pascompl.cc
// Function: utf8_getc(_IO_FILE*)
static int utf8_getc(FILE *fin)
{
    int c1, c2, c3;
    c1 = getc (fin);
    if (c1 < 0 || ! (c1 & 0x80))
        return c1;
    c2 = getc (fin);
    if (! (c1 & 0x20))
        return (c1 & 0x1f) << 6 | (c2 & 0x3f);
    c3 = getc (fin);
    return (c1 & 0x0f) << 12 | (c2 & 0x3f) << 6 | (c3 & 0x3f);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40a0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x1daab
movl -0x14(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x1dab3
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1db0b
movq -0x10(%rbp), %rdi
callq 0x40a0
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
jne 0x1dae0
movl -0x14(%rbp), %eax
andl $0x1f, %eax
shll $0x6, %eax
movl -0x18(%rbp), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x1db0b
movq -0x10(%rbp), %rdi
callq 0x40a0
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
andl $0xf, %eax
shll $0xc, %eax
movl -0x18(%rbp), %ecx
andl $0x3f, %ecx
shll $0x6, %ecx
orl %ecx, %eax
movl -0x1c(%rbp), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: besm6[P]pascal-re/pascompl.cc
// Function: IdentRec::p[abi:cxx11](bool) const
std::string p(bool verbose = false) const {
        std::string ret;
        char * strp;
        switch (cl) {
        default: ret = toAscii(id);
            return ret.substr(ret.find_last_of(' ')+1, std::string::npos);
        case ROUTINEID:
            ret = toAscii(id);
            if (verbose) {
                if (0 <= asprintf(&strp, "(routine) procno: %ld value: %ld argl: %ld predef: %ld level: %ld pos: %ld flags: %lx",
                                  procno_, value_, ord(argList_), ord(preDefLink_), level_, pos_, flags_.val)) {
                    ret += strp;
                    free(strp);
                } else perror("asprintf");
            }
        }
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xa8(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4400
movq -0x98(%rbp), %rax
movl 0x20(%rax), %eax
subl $0x2, %eax
je 0x1e0c7
jmp 0x1e024
movq -0x98(%rbp), %rax
movq (%rax), %rsi
leaq -0x60(%rbp), %rdi
callq 0x6d20
jmp 0x1e039
leaq -0x38(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
leaq -0x60(%rbp), %rsi
movq %rsi, -0xc0(%rbp)
callq 0x43b0
movq -0xc0(%rbp), %rdi
callq 0x4588
movq -0xb8(%rbp), %rdi
movl $0x20, %esi
movq $-0x1, %rdx
movq %rdx, -0xb0(%rbp)
callq 0x4550
movq -0xa8(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rcx
movq %rax, %rdx
incq %rdx
callq 0x42e0
jmp 0x1e0a1
movl $0x1, -0x70(%rbp)
jmp 0x1e1e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4588
jmp 0x1e200
movq -0x98(%rbp), %rax
movq (%rax), %rsi
leaq -0x90(%rbp), %rdi
callq 0x6d20
jmp 0x1e0df
leaq -0x38(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x43b0
leaq -0x90(%rbp), %rdi
callq 0x4588
testb $0x1, -0x11(%rbp)
je 0x1e1ce
movq -0x98(%rbp), %rax
movq 0x28(%rax), %rcx
movq %rcx, -0xd8(%rbp)
movq 0x30(%rax), %rcx
movq %rcx, -0xd0(%rbp)
movq 0x38(%rax), %rdi
callq 0x4ea0
movq %rax, %rcx
movq -0x98(%rbp), %rax
movq %rcx, -0xc8(%rbp)
movq 0x40(%rax), %rdi
callq 0x4ea0
movq -0x98(%rbp), %rsi
movq -0xd8(%rbp), %rdx
movq -0xd0(%rbp), %rcx
movq -0xc8(%rbp), %r8
movq %rax, %r9
movq 0x48(%rsi), %r11
movq 0x50(%rsi), %r10
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x58(%rsi), %rax
leaq -0x40(%rbp), %rdi
leaq 0x14d2f(%rip), %rsi     # 0x32eb4
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movb $0x0, %al
callq 0x40c0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x1e1bc
movq -0x40(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x4280
jmp 0x1e1b1
movq -0x40(%rbp), %rdi
callq 0x4390
jmp 0x1e1cc
leaq 0x13a98(%rip), %rdi     # 0x31c5b
callq 0x4240
jmp 0x1e1ca
jmp 0x1e1cc
jmp 0x1e1ce
jmp 0x1e1d0
movq -0xa8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4150
movl $0x1, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4588
movq -0xa0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x44c0
nopl (%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: Real::operator=(double)
void operator=(double d) {
        int exp;
        double mant = frexp(d, &exp);
        mantissa = ldexp(mant, 40);
        exponent = exp + 64;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
leaq -0x14(%rbp), %rdi
callq 0x4520
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movl $0x28, %edi
callq 0x4450
movq -0x28(%rbp), %rax
cvttsd2si %xmm0, %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)
movl -0x14(%rbp), %ecx
addl $0x40, %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)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: besm6[P]pascal-re/pascompl.cc
// Function: genFullExpr::genCheckBounds(RangeT*)
void genCheckBounds(RangeT * l5arg1z) {
        int64_t l5var1z;
        Word /* l5var2z, l5var3z, */ l5var4z;

        l5var1z = l5arg1z->checker;
        if (l5var1z == 0) {
            curVal.i = l5arg1z->left;
            l5var4z.i = l5arg1z->right;
            if (l5arg1z->base != IntegerType) {
                curVal.m = curVal.m * BitRange(7,47);
                l5var4z.m = l5var4z.m * BitRange(7,47);
            }
            prevOpcode = 0;
            formAndAlign(KUJ+5 + moduleOffset);
            l5arg1z->checker = moduleOffset;
            l5var1z = moduleOffset;
            P0715(1, l5var4z.i);
            formAndAlign(KUJ+I13);
        }
        prepLoad();
        addToInsnList(KVTM+I14 + lineCnt);
        addToInsnList(KVJM+I13 + l5var1z);
        insnList->next->mode = 1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2056b
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
leaq 0x5fc6a(%rip), %rdi     # 0x800f0
callq 0x4ad0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
leaq -0x20(%rbp), %rdi
callq 0x4ad0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq 0x5fbfd(%rip), %rax     # 0x800a8
je 0x20513
movl $0x7, %edi
movl $0x2f, %esi
callq 0x4a60
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
leaq 0x5fc25(%rip), %rdi     # 0x800f0
callq 0x1e580
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, 0x5fc11(%rip)     # 0x800f0
leaq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x7, %edi
movl $0x2f, %esi
callq 0x4a60
movq -0x48(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0x1e580
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, 0x5fafa(%rip) # 0x80018
movq 0x5fa23(%rip), %rdi     # 0x7ff48
addq $0xc0005, %rdi          # imm = 0xC0005
callq 0x7f20
movq 0x5fa10(%rip), %rcx     # 0x7ff48
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq 0x5fa01(%rip), %rax     # 0x7ff48
movq %rax, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1dfb0
movq %rax, %rsi
movl $0x1, %edi
callq 0x8910
movl $0xdc0000, %edi         # imm = 0xDC0000
callq 0x7f20
callq 0xbd10
movq 0x5f9f9(%rip), %rdi     # 0x7ff70
addq $0xea0000, %rdi         # imm = 0xEA0000
callq 0xbbb0
movq -0x18(%rbp), %rdi
addq $0xdc8000, %rdi         # imm = 0xDC8000
callq 0xbbb0
movq 0x5fbce(%rip), %rax     # 0x80168
movq (%rax), %rax
movq $0x1, 0x8(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq 0x10(%rax), %rdi
addq $0x18, %rdi
movl $0xc, %esi
callq 0x1e5f0
andb $0x1, %al
movb %al, -0x9(%rbp)
leaq -0x50(%rbp), %rdi
movl $0xc, %esi
callq 0x205b0
testb $0x1, -0x9(%rbp)
je 0x20a09
movl $0x2200c, %edi          # imm = 0x2200C
callq 0xbbb0
movl $0x1000005, %edi        # imm = 0x1000005
callq 0xbbb0
movq -0xa0(%rbp), %rax
movq 0x5f751(%rip), %rcx     # 0x80168
movq %rcx, -0x18(%rbp)
movq 0x10(%rax), %rax
movq %rax, 0x5f742(%rip)     # 0x80168
leaq -0x88(%rbp), %rdi
movl $0xe, %esi
callq 0x205b0
testb $0x1, -0x9(%rbp)
je 0x20a51
movl $0x1000004, %edi        # imm = 0x1000004
callq 0xbbb0
movl $0x2000c, %edi          # imm = 0x2000C
callq 0xbbb0
movq 0x5f710(%rip), %rdi     # 0x80168
addq $0x18, %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rsi
callq 0x1db20
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rax
movq -0x90(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq 0x5f6d4(%rip), %rax     # 0x80168
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq 0x5f6bf(%rip), %rax     # 0x80168
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x5f6aa(%rip)     # 0x80168
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0xb7f8d(%rip), %rdi     # 0xd8a78
callq 0x203f0
movq (%rax), %rax
addq $0x58, %rax
movq %rax, -0x10(%rbp)
callq 0xc1f0
movq -0x38(%rbp), %rax
movq 0x5f65d(%rip), %rdx     # 0x80168
movq -0x10(%rbp), %rcx
movq %rdx, (%rcx)
movq 0x10(%rax), %rax
movq %rax, 0x5f64b(%rip)     # 0x80168
callq 0xbd10
leaq 0xb7f4f(%rip), %rdi     # 0xd8a78
callq 0x203f0
movq (%rax), %rax
movq 0x18(%rax), %rdi
callq 0x80d0
movq %rax, %rdi
callq 0xbbb0
movq 0x5f61f(%rip), %rdi     # 0x80168
addq $0x18, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x1db20
movq %rax, -0x20(%rbp)
movl $0xb, %edi
movl $0xe, %esi
callq 0x4a60
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x1db20
movq %rax, -0x18(%rbp)
movq 0x5f5d4(%rip), %rax     # 0x80168
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq 0x5f5c5(%rip), %rax     # 0x80168
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq 0x5f5a2(%rip), %rax     # 0x80168
movq %rcx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x5f345(%rip), %rax     # 0x80168
cmpl $0x0, 0x20(%rax)
jne 0x20e4e
movq 0x5f338(%rip), %rax     # 0x80168
cmpq $0x0, 0x28(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, %ecx
movq 0x5f320(%rip), %rax     # 0x80168
movq %rcx, 0x28(%rax)
jmp 0x20e8b
movq 0x5f313(%rip), %rax     # 0x80168
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movl $0x10, %edi
callq 0x48e0
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x20f20
movq %rax, -0x10(%rbp)
movq 0x5f2e5(%rip), %rax     # 0x80168
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x1dfb0
movq %rax, %rcx
movabsq $0x10000000000, %rax    # imm = 0x10000000000
cqto
idivq %rcx
movabsq $0x800000000000, %rcx   # imm = 0x800000000000
orq %rcx, %rax
movq %rax, 0x5ecd1(%rip)     # 0x800f0
movq 0x5ecca(%rip), %rax     # 0x800f0
addq $0x1, %rax
movq %rax, 0x5ecbf(%rip)     # 0x800f0
callq 0x8580
movq %rax, %rdi
addq $0x80f000, %rdi         # imm = 0x80F000
callq 0xbbb0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0xbd10
movq 0x5ea20(%rip), %rax     # 0x80168
movl $0x1, 0x20(%rax)
movq 0x5ea12(%rip), %rax     # 0x80168
movl $0x0, 0x40(%rax)
movq 0x5ea04(%rip), %rax     # 0x80168
movq $0x0, 0x30(%rax)
movq 0x5e9f5(%rip), %rdi     # 0x80168
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4ad0
movq 0x5e9e1(%rip), %rax     # 0x80168
movq $0x12, 0x38(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: besm6[P]pascal-re/pascompl.cc
// Function: parseRecordDecl::addFieldToHash()
void addFieldToHash() {
        IdentRecPtr &curEnum = parseTypeRef::super.back()->curEnum;
        TypesPtr &curType = parseTypeRef::super.back()->curType;
        bool &isPacked = parseTypeRef::super.back()->isPacked;
        curEnum->id = curIdent;
        curEnum->next = typeHashTabBase[bucket];
        curEnum->cl = FIELDID;
        curEnum->uptype() = curType;
        curEnum->pckfield() = isPacked;
        typeHashTabBase[bucket] = curEnum;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xb6f5d(%rip), %rdi     # 0xd8ab0
callq 0x21970
movq (%rax), %rax
addq $0xc8, %rax
movq %rax, -0x10(%rbp)
leaq 0xb6f44(%rip), %rdi     # 0xd8ab0
callq 0x21970
movq (%rax), %rax
addq $0xf0, %rax
movq %rax, -0x18(%rbp)
leaq 0xb6f2b(%rip), %rdi     # 0xd8ab0
callq 0x21970
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq 0x5e564(%rip), %rcx     # 0x80100
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq 0x5e3cb(%rip), %rcx     # 0x7ff78
leaq 0x640dc(%rip), %rax     # 0x85c90
movq (%rax,%rcx,8), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl $0x5, 0x20(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1e700
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x21690
movb -0x21(%rbp), %cl
andb $0x1, %cl
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq 0x5e35e(%rip), %rcx     # 0x7ff78
leaq 0x6406f(%rip), %rax     # 0x85c90
movq %rdx, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0xb6bc1(%rip), %rdi     # 0xd8a30
callq 0x1e890
movq (%rax), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movl $0x20, %edi
callq 0x1e2e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdx
movl $0xf, %esi
callq 0x21f50
jmp 0x21ea3
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0xf0(%rax)
movl $0x60, %edi
callq 0x1e2e0
movq %rax, %rdi
movq -0x38(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x40(%rbp)
movq 0x5e22f(%rip), %rsi     # 0x80100
movq 0x5e098(%rip), %rdx     # 0x7ff70
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq 0xf0(%rax), %r8
xorl %r9d, %r9d
callq 0x26db0
jmp 0x21ef0
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0xc8(%rax)
movq 0xc8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
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
jmp 0x21f3f
movq -0x40(%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,%rax)