LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: skipToEnd()
void skipToEnd()
{
    Symbol sym;
    sym = SY;
    while ((sym != ENDSY) or (SY != PERIOD)) {
        sym = SY;
        inSymbol();
    }
    if (CH == 'D' || CH == 'd')
        while (SY != ENDSY)
            inSymbol();
    throw 9999;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x2e8, %rsp            # imm = 0x2E8
movl 0x5c917(%rip), %ebp     # 0x6482c
leaq 0x178(%rsp), %rbx
movq %rbx, %rdi
callq 0x6e26
xorl $0x27, %ebp
movl 0x5c8fe(%rip), %eax     # 0x6482c
movl %eax, %ecx
xorl $0x10, %ecx
orl %ebp, %ecx
movl %eax, %ebp
jne 0x7f1d
movb 0x5c9ea(%rip), %al      # 0x64929
andb $-0x21, %al
cmpb $0x44, %al
jne 0x7f5b
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x6e26
cmpl $0x27, 0x5c8d3(%rip)    # 0x6482c
jne 0x7f4a
movl $0x4, %edi
callq 0x3110
movl $0x270f, (%rax)         # imm = 0x270F
movq 0x1c00e(%rip), %rsi     # 0x23f80
movq %rax, %rdi
xorl %edx, %edx
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: test1(Symbol, Bitset)
void test1(Symbol sym, Bitset toset)
{
    if (SY != sym) {
        requiredSymErr(sym);
        skip(toset);
    } else
        inSymbol();
}

// Assembly:
pushq %rbx
subq $0x170, %rsp            # imm = 0x170
cmpl %edi, 0x5c858(%rip)     # 0x6482c
jne 0x7fe7
movq %rsp, %rdi
callq 0x6e26
addq $0x170, %rsp            # imm = 0x170
popq %rbx
retq
movq %rsi, %rbx
movq 0x5c88f(%rip), %rax     # 0x64880
cmpq 0x5c890(%rip), %rax     # 0x64888
je 0x8005
addl $0x58, %edi
movslq %edi, %rdi
callq 0x589e
movq %rbx, %rdi
addq $0x170, %rsp            # imm = 0x170
popq %rbx
jmp 0x7f7c
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: P2672(IdentRec*&, IdentRec*)
void P2672(IdentRecPtr & l3arg1z, IdentRecPtr l3arg2z)
{
    bool l3var1z;
    int64_t l3var2z = 0;
    IdentRecPtr l3var3z, l3var4z;
    if (l3arg1z == NULL) {
        l3var2z = (l3arg2z->id % 65535) % 128;
        l3var1z = true;
        l3arg1z = symHashTabBase[l3var2z];
    } else {
        l3var1z = false;
    }
    if (l3arg1z == l3arg2z) {
        if (l3var1z) {
            symHashTabBase[l3var2z] =
                symHashTabBase[l3var2z]->next;
        } else {
            l3arg1z = l3arg2z->next;
        };
    } else {
        l3var3z = l3arg1z;
        while (l3var3z != l3arg2z) {
            l3var4z = l3var3z;
            if (l3var3z != NULL) {
                l3var3z = l3var3z->next;
            } else {
                return;
            }
        };
        l3var4z->next = l3arg2z->next;
    }
}

// Assembly:
movq (%rdi), %r8
testq %r8, %r8
je 0x81f6
xorl %ecx, %ecx
jmp 0x8248
movq (%rsi), %rcx
movabsq $-0x7fff7fff7fff7fff, %rdx # imm = 0x8000800080008001
movq %rcx, %rax
imulq %rdx
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
movq %rdx, %rax
shlq $0x10, %rax
subq %rax, %rdx
leaq (%rcx,%rdx), %rax
addq $0x7f, %rax
addq %rdx, %rcx
cmovnsq %rcx, %rax
andq $-0x80, %rax
subq %rax, %rcx
leaq 0x61f9f(%rip), %rax     # 0x6a1e0
movq (%rax,%rcx,8), %rax
movq %rax, (%rdi)
movq (%rdi), %rdx
cmpq %rsi, %rdx
je 0x826a
testq %rdx, %rdx
je 0x8269
movq %rdx, %rax
movq 0x10(%rdx), %rdx
cmpq %rsi, %rdx
jne 0x8250
movq 0x10(%rsi), %rcx
movq %rcx, 0x10(%rax)
retq
testq %r8, %r8
je 0x8277
movq 0x10(%rsi), %rax
movq %rax, (%rdi)
retq
leaq 0x61f62(%rip), %rax     # 0x6a1e0
movq (%rax,%rcx,8), %rdx
movq 0x10(%rdx), %rdx
movq %rdx, (%rax,%rcx,8)
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: checkSymAndRead(Symbol)
void checkSymAndRead(Symbol sym)
{
    if (SY != sym)
        requiredSymErr(sym);
    else
        inSymbol();
}

// Assembly:
cmpl %edi, 0x5c553(%rip)     # 0x6482c
jne 0x82f4
subq $0x178, %rsp            # imm = 0x178
leaq 0x8(%rsp), %rdi
callq 0x6e26
addq $0x178, %rsp            # imm = 0x178
retq
movq 0x5c585(%rip), %rax     # 0x64880
cmpq 0x5c586(%rip), %rax     # 0x64888
jne 0x8305
retq
addl $0x58, %edi
movslq %edi, %rdi
jmp 0x589e
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
jne 0x8337
cmpq %rbx, %r14
sete %al
jmp 0x8378
movq 0x18(%r14), %rsi
movq 0x18(%rbx), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x83b2
cmpb $0x1, (%r15)
jne 0x836e
cmpl $0x0, 0x20(%r14)
je 0x8382
cmpl $0x0, 0x20(%rbx)
je 0x8382
movq 0x28(%r14), %rdi
movq 0x28(%rbx), %rsi
callq 0x8310
jmp 0x8370
xorl %eax, %eax
addq $-0x8, 0xb5040(%rip)    # 0xbd3b8
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x15251(%rip), %rdi     # 0x1d5da
leaq 0x15224(%rip), %rsi     # 0x1d5b4
leaq 0x15356(%rip), %rcx     # 0x1d6ed
movl $0x2d5, %edx            # imm = 0x2D5
callq 0x3170
addq $-0x8, 0xb500f(%rip)    # 0xbd3b8
movq %rax, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
cmpl $0x2, 0x20(%rdi)
jne 0x8805
movq 0x38(%rdi), %rcx
testq %rcx, %rcx
sete %al
cmpq %rdi, %rcx
sete %dl
orb %al, %dl
je 0x87d0
xorl %eax, %eax
jmp 0x87e4
xorl %eax, %eax
cmpl $0x0, 0x20(%rcx)
je 0x87e6
incq %rax
movq 0x28(%rcx), %rcx
cmpq %rdi, %rcx
jne 0x87d2
popq %rcx
retq
leaq 0x14ded(%rip), %rdi     # 0x1d5da
leaq 0x14dc0(%rip), %rsi     # 0x1d5b4
leaq 0x14ef2(%rip), %rcx     # 0x1d6ed
movl $0x2d5, %edx            # imm = 0x2D5
callq 0x3170
leaq 0x14eff(%rip), %rdi     # 0x1d70b
leaq 0x14da1(%rip), %rsi     # 0x1d5b4
leaq 0x14f01(%rip), %rcx     # 0x1d71b
movl $0x2f1, %edx            # imm = 0x2F1
callq 0x3170
// File: /workspace/github_cpp_makefile_star2_O1/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:
movabsq $0xfc0000000000, %rax   # imm = 0xFC0000000000
movq 0x5c2a3(%rip), %r8      # 0x64ad8
testq %r8, %r8
sete %cl
movq 0x5c1fe(%rip), %rdx     # 0x64a40
testq %rax, %rdx
jne 0x88dd
notb %dil
andb %cl, %dil
movabsq $0xffffffffffc0, %rcx   # imm = 0xFFFFFFFFFFC0
movabsq $0xfc0000000, %rsi      # imm = 0xFC0000000
shlq $0x6, %rdx
andq %rcx, %rdx
leaq 0xa(%rdx), %r9
cmpq $0x1, %r8
cmoveq %r9, %rdx
testb %dil, %dil
cmovneq %r9, %rdx
leaq 0x40000000(%rsi), %r8
cmpq %r8, %rdx
jae 0x88a9
movabsq $0x3ffffffffc0, %r9     # imm = 0x3FFFFFFFFC0
movq %rdx, %r8
shlq $0x6, %r8
andq %r9, %r8
testq %rsi, %rdx
movq %r8, %rdx
je 0x8898
jmp 0x88ac
movq %rdx, %r8
movq %r8, 0x5c18d(%rip)      # 0x64a40
testq %rax, %r8
jne 0x88dd
movq %r8, %rax
shlq $0x6, %rax
andq %rcx, %rax
movabsq $0x280000000000, %rcx   # imm = 0x280000000000
orq %r8, %rcx
testb %dil, %dil
cmoveq %rax, %rcx
movq %rcx, 0x5c163(%rip)     # 0x64a40
movq 0x5c15c(%rip), %rax     # 0x64a40
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x20, %edi
callq 0x3d03
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rbx, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq 0x5c1ac(%rip), %rcx     # 0x64ab8
movq (%rcx), %rdx
addq $0x8, %rcx
testq %rdx, %rdx
cmovneq %rdx, %rcx
movq %rax, (%rcx)
movq 0x5c194(%rip), %rcx     # 0x64ab8
movq %rax, (%rcx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x20, %edi
callq 0x3d03
movq 0x5c161(%rip), %rcx     # 0x64ab8
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
xorl %edx, %edx
movq %rdx, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rdx, 0x18(%rax)
movq 0x5c145(%rip), %rcx     # 0x64ab8
cmpq %rdx, 0x8(%rcx)
jne 0x897c
movq %rax, (%rcx)
movq 0x5c135(%rip), %rcx     # 0x64ab8
movq %rax, 0x8(%rcx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x6b0, %rsp            # imm = 0x6B0
movl %edi, %ebx
movq 0xb4428(%rip), %rax     # 0xbd388
movq -0x8(%rax), %r14
movq 0x5b93d(%rip), %rdi     # 0x648a8
movq 0x90(%r14), %r15
callq 0x88e5
movq 0x5bb3a(%rip), %rax     # 0x64ab8
movq (%rax), %rax
movq %r15, 0x18(%rax)
movl $0x20, %edi
callq 0x3d03
movq %rax, 0x5bb1a(%rip)     # 0x64ab0
movq 0x5bb1b(%rip), %rcx     # 0x64ab8
movq 0x10(%rcx), %rcx
movq %rcx, (%rax)
movq %rsp, %rdi
callq 0x15a10
movq 0x5bafd(%rip), %rax     # 0x64ab0
movl %ebx, 0x8(%rax)
movq 0x90(%r14), %rcx
movq %rcx, 0x10(%rax)
movq 0x90(%r14), %rcx
movq 0x98(%r14), %rdx
leaq 0x1(%rcx), %rax
movq %rax, 0x90(%r14)
cmpq %rcx, %rdx
jg 0x8fe6
movq %rax, 0x98(%r14)
addq $0x6b0, %rsp            # imm = 0x6B0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0xb2f15(%rip), %rax     # 0xbd3e8
movq -0x8(%rax), %r14
movl $0x58, %edi
callq 0x3d03
movq %rax, 0x5a5d0(%rip)     # 0x64ab8
xorl %ecx, %ecx
movq %rcx, (%rax)
movq 0x5a5c4(%rip), %rax     # 0x64ab8
movq %rcx, 0x8(%rax)
movq (%r14), %rdx
movq (%rdx), %rdx
movq %rdx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movl %ebx, 0x20(%rax)
testl %ebx, %ebx
je 0xa52f
movl $0x0, 0x40(%rax)
movq $0x12, 0x38(%rax)
movl $0x30, %ecx
movl $0x10, %esi
leaq 0x5a37b(%rip), %rdx     # 0x648a8
jmp 0xa540
movq (%r14), %rdx
addq $0x10, %rdx
movl $0x38, %ecx
movl $0x18, %esi
movq (%rdx), %rdx
movq %rdx, 0x28(%rax)
movq (%r14), %rdx
movq (%rdx,%rsi), %rdx
movq %rdx, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
cmpq $0x0, 0x28(%rdi)
je 0xdf71
popq %rbx
retq
movq 0x568c8(%rip), %rax     # 0x64840
movq %rax, 0x28(%rdi)
movq 0x18(%rdi), %rbx
testq %rbx, %rbx
je 0xdf6f
movq (%rbx), %rax
movq %rax, 0x56ab1(%rip)     # 0x64a40
cmpl $0x0, 0x20(%rbx)
je 0xdfa0
movq 0x28(%rbx), %rbx
callq 0x5d02
jmp 0xdf80
leaq 0xf633(%rip), %rdi      # 0x1d5da
leaq 0xf606(%rip), %rsi      # 0x1d5b4
leaq 0xf738(%rip), %rcx      # 0x1d6ed
movl $0x2d5, %edx            # imm = 0x2D5
callq 0x3170
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x20, %edi
callq 0x3d03
movq 0x55c73(%rip), %rcx     # 0x64a00
movq %rcx, (%rax)
movl $0x29, 0x8(%rax)
movq (%rbx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq 0x55c65(%rip), %rdx     # 0x64a18
movq 0x55c46(%rip), %r14     # 0x64a00
cmpq %r14, %rdx
je 0xedcf
movq 0x55c5a(%rip), %r15     # 0x64a20
cmpq %r14, %r15
je 0xedfd
xorl %eax, %eax
jmp 0xee13
movq %rdi, %rbx
movq 0x55c1f(%rip), %rsi     # 0x649f8
movq 0x55c40(%rip), %rdx     # 0x64a20
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x83b2
addq $-0x8, 0xae5c3(%rip)    # 0xbd3b8
cmpb $0x0, (%r14)
jne 0xee2b
jmp 0xee54
movq 0x55bf4(%rip), %rsi     # 0x649f8
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x83b2
movb (%rbx), %al
cmpq %r14, %r15
jne 0xee20
addq $-0x8, 0xae598(%rip)    # 0xbd3b8
testb %al, %al
je 0xee54
leaq 0x55c85(%rip), %rbx     # 0x64ab0
movl $0x20, %edi
callq 0x3d03
movq 0x55bc4(%rip), %rcx     # 0x64a00
movq %rcx, (%rax)
movl $0x29, 0x8(%rax)
movq (%rbx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, (%rbx)
movb $0x1, %al
jmp 0xee56
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: compoundStatement()
void compoundStatement()
{
    do {
        Statement();
        if (SY == SEMICOLON) {
            inSymbol();
        } else
            break;
    } while(true);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsp, %rdi
callq 0x10652
addq $-0x8, 0xacecd(%rip)    # 0xbd438
cmpl $0xf, 0x542ba(%rip)     # 0x6482c
jne 0x1059d
leaq 0x58(%rsp), %rbx
movq %rsp, %r14
movq %rbx, %rdi
callq 0x6e26
movq %r14, %rdi
callq 0x10652
addq $-0x8, 0xacea4(%rip)    # 0xbd438
cmpl $0xf, 0x54291(%rip)     # 0x6482c
je 0x1057c
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0xc8, %rsp
movl %edi, %ebx
movq 0xace7d(%rip), %rax     # 0xbd438
movq -0x8(%rax), %r14
cmpq $0x1, 0x54321(%rip)     # 0x648e8
je 0x105e0
movq 0x13cc8(%rip), %rdi     # 0x24298
callq 0x5941
movq $0x1, 0x54308(%rip) # 0x648e8
callq 0xebcc
movq $0x0, 0x54228(%rip) # 0x64818
movq 0x544b9(%rip), %rax     # 0x64ab0
movq (%rax), %rax
cmpq 0x543e7(%rip), %rax     # 0x649e8
je 0x1060c
xorl %edi, %edi
callq 0x589e
jmp 0x10623
leaq 0x60(%rsp), %rdi
movl $0xf, %esi
callq 0xc044
addq $-0x8, 0xacdad(%rip)    # 0xbd3d0
movq 0x541ee(%rip), %rax     # 0x64818
movq %rax, 0x40(%r14)
movl %ebx, %edi
callq 0x82d3
leaq 0x8(%rsp), %rdi
callq 0x10652
addq $-0x8, 0xacdf1(%rip)    # 0xbd438
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
cmpl $0x2, 0x20(%rsi)
jne 0x15814
movl %edx, %ebp
movq (%r14), %rsi
leaq 0x48(%rsp), %rdi
callq 0x4f8f
leaq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %r15
movq %r15, %rsi
callq 0x3300
movq (%r15), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x15777
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3260
testb %bpl, %bpl
je 0x157f5
movq 0x28(%r14), %r15
movq 0x30(%r14), %rbp
movq 0x38(%r14), %rdi
callq 0x3d9a
movq %rax, %r13
movq 0x40(%r14), %rdi
callq 0x3d9a
movups 0x48(%r14), %xmm0
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq 0x58(%r14), %rcx
movq %rcx, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x7d78(%rip), %rsi      # 0x1d534
leaq 0x40(%rsp), %rdi
movq %r15, %rdx
movq %rbp, %rcx
movq %r13, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x30b0
testl %eax, %eax
js 0x158cb
movq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x3480
movq 0x40(%rsp), %rdi
callq 0x32e0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x20(%rsp), %rcx
cmpq %r12, %rcx
je 0x1587e
movq %rcx, (%rbx)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x15886
movq (%r14), %rsi
leaq 0x48(%rsp), %rdi
callq 0x4f8f
leaq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %r14
movq %r14, %rsi
callq 0x3300
movq (%r14), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x1584d
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3260
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x20, %esi
movq $-0x1, %rdx
callq 0x34a0
leaq 0x1(%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x3270
jmp 0x158a2
movups (%r12), %xmm0
movups %xmm0, (%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r12, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movb $0x0, 0x30(%rsp)
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x158b9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3260
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7301(%rip), %rdi      # 0x1cbd3
callq 0x31f0
jmp 0x157f5
jmp 0x158e0
jmp 0x158e0
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x158fa
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3260
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movq %r14, %rdi
callq 0x3450
movl $0x28, %edi
callq 0x3370
cvttsd2si %xmm0, %rax
movabsq $0x1ffffffffff, %rcx    # imm = 0x1FFFFFFFFFF
andq %rax, %rcx
movabsq $-0x20000000000, %rax   # imm = 0xFFFFFE0000000000
andq (%rbx), %rax
orq %rcx, %rax
movq %rax, (%rbx)
movl (%r14), %ecx
andl $0x7f, %ecx
xorl $0x40, %ecx
shlq $0x29, %rcx
movabsq $-0xfe0000000001, %rdx  # imm = 0xFFFF01FFFFFFFFFF
andq %rax, %rdx
orq %rcx, %rdx
movq %rdx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq 0x20(%rsi), %r14
testq %r14, %r14
jne 0x16a55
movq %rsi, %rbx
movq 0x28(%rsi), %rsi
leaq 0x4e05f(%rip), %rdi     # 0x64a40
callq 0x3bf2
movq 0x30(%rbx), %rsi
movq %rsp, %rdi
callq 0x3bf2
movq 0x18(%rbx), %rax
cmpq 0x4dffb(%rip), %rax     # 0x649f8
je 0x16a0e
movl $0x1ff, %eax            # imm = 0x1FF
andl %eax, 0x4e03a(%rip)     # 0x64a44
andl %eax, 0x4(%rsp)
movq $0x0, 0x4df4f(%rip) # 0x64968
movl $0xc0005, %edi          # imm = 0xC0005
addq 0x4de73(%rip), %rdi     # 0x64898
callq 0x5b45
movq 0x4de67(%rip), %r14     # 0x64898
movq %r14, 0x20(%rbx)
movq (%rsp), %rsi
shlq $0x17, %rsi
sarq $0x17, %rsi
movl $0x1, %edi
callq 0x617f
movl $0xdc0000, %edi         # imm = 0xDC0000
callq 0x5b45
callq 0x8989
movl $0xea0000, %edi         # imm = 0xEA0000
addq 0x4de5a(%rip), %rdi     # 0x648c0
callq 0x88e5
addq $0xdc8000, %r14         # imm = 0xDC8000
movq %r14, %rdi
callq 0x88e5
movq 0x4e037(%rip), %rax     # 0x64ab8
movq (%rax), %rax
movq $0x1, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: genFullExpr::prepMultiWord()
void prepMultiWord() {
        bool l5var1z;
        InsnList * l5var2z;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rax), %r15
leaq 0x38(%rsp), %rdi
movl $0xc, %esi
callq 0x16a94
btq $0x23, %r15
jae 0x16d44
movl $0x2200c, %edi          # imm = 0x2200C
callq 0x88e5
movl $0x1000005, %edi        # imm = 0x1000005
callq 0x88e5
movq 0x4dd6d(%rip), %r14     # 0x64ab8
movq 0x10(%rbx), %rax
movq %rax, 0x4dd62(%rip)     # 0x64ab8
movq %rsp, %rdi
movl $0xe, %esi
callq 0x16a94
btq $0x23, %r15
jae 0x16d7e
movl $0x1000004, %edi        # imm = 0x1000004
callq 0x88e5
movl $0x2000c, %edi          # imm = 0x2000C
callq 0x88e5
movq 0x4dd33(%rip), %rax     # 0x64ab8
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq 0x18(%rax), %rcx
orq %rcx, 0x18(%r14)
movq 0x8(%rax), %rax
movq (%r14), %rcx
movq %rax, (%rcx)
movq 0x4dd10(%rip), %rax     # 0x64ab8
movq (%rax), %rax
movq %rax, (%r14)
movq %r14, 0x4dd03(%rip)     # 0x64ab8
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xa6602(%rip), %rax     # 0xbd3d0
movq -0x8(%rax), %r14
callq 0x8989
movl $0x1000005, %edi        # imm = 0x1000005
callq 0x88e5
movq 0x4dcd0(%rip), %rax     # 0x64ab8
movq %rax, 0x58(%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x4dcc1(%rip)     # 0x64ab8
callq 0x8989
movq 0xa65cd(%rip), %rax     # 0xbd3d0
movq -0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x5cbc
movq %rax, %rdi
callq 0x88e5
movq 0x4dc99(%rip), %rax     # 0x64ab8
movq 0x8(%rax), %rcx
movq 0x18(%rax), %rdx
movq 0x58(%r14), %rsi
orq 0x18(%rsi), %rdx
movabsq $0xffe1ffffffff, %rsi   # imm = 0xFFE1FFFFFFFF
andq %rdx, %rsi
movabsq $0x1e00000000, %rdx     # imm = 0x1E00000000
orq %rsi, %rdx
movq %rdx, 0x18(%rax)
movq 0x58(%r14), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq 0x58(%r14), %rax
movq 0x8(%rax), %rax
movq 0x4dc52(%rip), %rcx     # 0x64ab8
movq %rax, 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: genFullExpr::genConstDiv()
void genConstDiv() {
        // TODO correctly
        curVal.ii = (1L<<47)|(1L << 40)/arg2Val.i; // PASDIV(1/arg2Val.i);
        ++curVal.ii;
        addToInsnList(KMUL+I8 + getFCSToffset());
    }

// Assembly:
pushq %rax
movq 0x20(%rdi), %rcx
shlq $0x17, %rcx
sarq $0x17, %rcx
movabsq $0x10000000000, %rax    # imm = 0x10000000000
xorl %edx, %edx
idivq %rcx
btsq $0x2f, %rax
incq %rax
movq %rax, 0x4d749(%rip)     # 0x64a40
callq 0x5f9d
leaq 0x80f000(%rax), %rdi
popq %rax
jmp 0x88e5
nop
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: parseTypeRef::definExprPtrType(Types*)
void definExprPtrType(TypesPtr toType) {
        IdentRecPtr & typelist = programme::super.back()->typelist;
        curType = new PtrT(15, toType);
        curEnum = new IdentRec(curIdent, lineCnt, typelist, curType, TYPEID);
        typelist = curEnum;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0xa5d86(%rip), %rax     # 0xbd388
movq -0x8(%rax), %r15
movl $0x20, %edi
callq 0x3d03
movq $0x1, (%rax)
movq $0xf, 0x8(%rax)
movl $0x3, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %rax, 0xf0(%r14)
movl $0x60, %edi
callq 0x3d03
movq 0x4d40e(%rip), %rcx     # 0x64a50
movq 0x4d277(%rip), %rdx     # 0x648c0
movq 0x10(%r15), %rsi
movq 0xf0(%r14), %rdi
movq %rcx, (%rax)
movq %rdx, 0x8(%rax)
movq %rsi, 0x10(%rax)
movq %rdi, 0x18(%rax)
movl $0x0, 0x20(%rax)
movq %rax, 0xc8(%r14)
movq %rax, 0x10(%r15)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: initScalars::regSysType(long, Types*)
void regSysType(int64_t l4arg1z, TypesPtr l4arg2z) {
        curIdRec = new IdentRec;
        // curIdRec@ := [l4arg1z, 0, , l4arg2z, TYPEID];
        curIdRec->id = l4arg1z;
        curIdRec->offset = 0;
        curIdRec->typ = l4arg2z;
        curIdRec->cl = TYPEID;
        addToHashTab(curIdRec);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x60, %edi
callq 0x3d03
movl $0x6, 0x20(%rax)
movq 0x58(%r15), %rcx
movq %rax, (%rcx)
movq 0x58(%r15), %rax
movq (%rax), %rcx
movq %r14, (%rcx)
movq $0x0, 0x8(%rcx)
movq %rbx, 0x18(%rcx)
movq (%rax), %rsi
movl $0x0, 0x20(%rsi)
movq (%rsi), %rcx
movabsq $-0x7fff7fff7fff7fff, %rdx # imm = 0x8000800080008001
movq %rcx, %rax
imulq %rdx
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
movq %rdx, %rax
shlq $0x10, %rax
subq %rax, %rdx
leaq (%rcx,%rdx), %rax
addq $0x7f, %rax
addq %rdx, %rcx
cmovnsq %rcx, %rax
movabsq $0x1fffffffffffff80, %rdx # imm = 0x1FFFFFFFFFFFFF80
andq %rax, %rdx
subq %rdx, %rcx
leaq 0x51680(%rip), %rax     # 0x6a1e0
movq (%rax,%rcx,8), %rdx
movq %rdx, 0x10(%rsi)
movq %rsi, (%rax,%rcx,8)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: initScalars::regSysEnum(long, long)
void regSysEnum(int64_t l4arg1z, int64_t l4arg2z) {
        curIdRec = new IdentRec;
        // curIdRec@ := [l4arg1z, 48, , temptype, ENUMID, NULL, l4arg2z];
        curIdRec->id = l4arg1z;
        curIdRec->offset = 48;
        curIdRec->typ = temptype;
        curIdRec->cl = ENUMID;
        curIdRec->list() = NULL;
        curIdRec->value() = l4arg2z;
        addToHashTab(curIdRec);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x60, %edi
callq 0x3d03
movl $0x6, 0x20(%rax)
movq 0x58(%r15), %rcx
movq %rax, (%rcx)
movq 0x58(%r15), %rax
movq (%rax), %rcx
movq %r14, (%rcx)
movq $0x30, 0x8(%rcx)
movq 0x48(%r15), %rdx
movq %rdx, 0x18(%rcx)
movq (%rax), %rax
movl $0x1, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq 0x58(%r15), %rax
movq (%rax), %rsi
cmpl $0x0, 0x20(%rsi)
je 0x18c3b
movq %rbx, 0x30(%rsi)
movq (%rsi), %rcx
movabsq $-0x7fff7fff7fff7fff, %rdx # imm = 0x8000800080008001
movq %rcx, %rax
imulq %rdx
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
movq %rdx, %rax
shlq $0x10, %rax
subq %rax, %rdx
leaq (%rcx,%rdx), %rax
addq $0x7f, %rax
addq %rdx, %rcx
cmovnsq %rcx, %rax
movabsq $0x1fffffffffffff80, %rdx # imm = 0x1FFFFFFFFFFFFF80
andq %rax, %rdx
subq %rdx, %rcx
leaq 0x515b7(%rip), %rax     # 0x6a1e0
movq (%rax,%rcx,8), %rdx
movq %rdx, 0x10(%rsi)
movq %rsi, (%rax,%rcx,8)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4998(%rip), %rdi      # 0x1d5da
leaq 0x496b(%rip), %rsi      # 0x1d5b4
leaq 0x4997(%rip), %rcx      # 0x1d5e7
movl $0x2d9, %edx            # imm = 0x2D9
callq 0x3170
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: initScalars::regSysProc(long)
void regSysProc(int64_t l4arg1z) {
        curIdRec = new IdentRec;
        // curIdRec@ := [l4arg1z, 0, , temptype, ROUTINEID, l3var9z];
        curIdRec->id = l4arg1z;
        curIdRec->offset = 0;
        curIdRec->typ = temptype;
        curIdRec->cl = ROUTINEID;
        curIdRec->procno() = l3var9z;
        l3var9z = l3var9z + 1;
        addToHashTab(curIdRec);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x60, %edi
callq 0x3d03
movl $0x6, 0x20(%rax)
movq 0x58(%r14), %rcx
movq %rax, (%rcx)
movq 0x58(%r14), %rax
movq (%rax), %rcx
movq %rbx, (%rcx)
movq $0x0, 0x8(%rcx)
movq 0x48(%r14), %rdx
movq %rdx, 0x18(%rcx)
movq (%rax), %rsi
movl $0x2, 0x20(%rsi)
movq 0x40(%r14), %rax
movq %rax, 0x28(%rsi)
incq 0x40(%r14)
movq (%rsi), %rcx
movabsq $-0x7fff7fff7fff7fff, %rdx # imm = 0x8000800080008001
movq %rcx, %rax
imulq %rdx
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
movq %rdx, %rax
shlq $0x10, %rax
subq %rax, %rdx
leaq (%rcx,%rdx), %rax
addq $0x7f, %rax
addq %rdx, %rcx
cmovnsq %rcx, %rax
movabsq $0x1fffffffffffff80, %rdx # imm = 0x1FFFFFFFFFFFFF80
andq %rax, %rdx
subq %rdx, %rcx
leaq 0x514e0(%rip), %rax     # 0x6a1e0
movq (%rax,%rcx,8), %rdx
movq %rdx, 0x10(%rsi)
movq %rsi, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: Real::operator=(long)
void operator=(int64_t i) {
        mantissa = i  & ((1L<<48)-1); exponent = 104;
        if (mantissa == 0)
            exponent = 0;
        else
            while ((mantissa >> 39) == 0 || (mantissa >> 39) == -1) { exponent--; mantissa <<= 1; }
    }

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1940a
testb %al, %al
jne 0x193da
movl $0x20, %edi
callq 0x3d03
movq %rax, 0x30(%rbx)
movq 0x28(%rbx), %rcx
movq %rcx, (%rax)
movq 0x690(%rbx), %rcx
shlq $0x17, %rcx
sarq $0x17, %rcx
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %rax, 0x28(%rbx)
movq 0x30(%rbx), %rdi
callq 0x3d9a
leaq (%r14,%rax), %rsi
addq $0x1000000, %rsi        # imm = 0x1000000
movq (%rbx), %rax
leaq (%rbx,%rax,8), %rdi
addq $0x48, %rdi
callq 0x3bf2
incq (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: genOneOp::F3413()
bool F3413() {
        bool ret;
        l4inl7z = l4inl6z;
        while (l4inl7z != NULL) {
            if (l4inl7z->mode == curInsn.i) {
                ret = true;
                while (l4inl7z->code == macro) {
                    l4inl7z = reinterpret_cast<OneInsn*>(ptr(l4inl7z->offset));
                }
                return ret;
            } else {
                l4inl7z = l4inl7z->next;
            }
        }
        return false;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
movq 0x690(%rdi), %rax
shlq $0x17, %rax
sarq $0x17, %rax
movq (%r14), %r14
movq %r14, 0x30(%rbx)
testq %r14, %r14
je 0x19453
cmpq %rax, 0x8(%r14)
jne 0x19424
movq 0x30(%rbx), %rax
cmpq $0x1000000, 0x10(%rax)  # imm = 0x1000000
jne 0x19453
movq 0x18(%rax), %rdi
callq 0x3d6b
movq %rax, 0x30(%rbx)
jmp 0x1943a
testq %r14, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: ParseData::allocDataRef(long)
int64_t allocDataRef(int64_t l6arg1z) {
        if (l6arg1z >= 2048) {
            curVal.i = l6arg1z;
            return allocSymtab((curVal.ii | 040000000) & halfWord);
        } else {
            return l6arg1z;
        }
    }

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x4a93a(%rip), %rax     # 0x649b0
testq %rax, %rax
je 0x1a0ad
cmpl $0x3, 0x20(%rax)
jl 0x1a0ad
movq %rsi, %rbx
callq 0xe885
testq %rbx, %rbx
je 0x1a0cd
movq 0x4aa1b(%rip), %rax     # 0x64ab0
movq (%rax), %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x83b2
movb (%r14), %al
xorb $0x1, %al
jmp 0x1a0cf
movl $0xb, %edi
callq 0x589e
movq 0x4a9ea(%rip), %rax     # 0x64aa8
movq %rax, 0x4a9eb(%rip)     # 0x64ab0
addq $0x48, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
testq %rbx, %rbx
je 0x1a0dc
addq $-0x8, 0xa32dc(%rip)    # 0xbd3b8
testb %al, %al
je 0x1a0c5
movl $0x15, %edi
callq 0x589e
jmp 0x1a0c5
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorl %esi, %esi
callq 0x1a068
movq 0x4a9ad(%rip), %rax     # 0x64ab0
movq %rax, 0x40(%rbx)
movq (%rax), %rax
movq %rax, (%rbx)
cmpl $0x5, 0x10(%rax)
jne 0x1a119
cmpb $0x1, 0x28(%rax)
jne 0x1a123
movl $0x15, %edi
callq 0x589e
movl $0xe, %edi
callq 0x82d3
movb $0x0, 0x4a851(%rip)     # 0x64985
callq 0xebcc
movq 0x4a970(%rip), %rax     # 0x64ab0
movq %rax, 0x38(%rbx)
movq (%rbx), %rcx
movl 0x10(%rcx), %ebp
cmpl $0x5, %ebp
jne 0x1a16d
cmpl $0x5, 0x10(%rcx)
jne 0x1a191
movq 0x20(%rcx), %rsi
movq (%rax), %rdx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x83b2
movb (%rbx), %al
xorb $0x1, %al
jmp 0x1a16f
xorl %eax, %eax
cmpl $0x5, %ebp
jne 0x1a17c
addq $-0x8, 0xa323c(%rip)    # 0xbd3b8
testb %al, %al
je 0x1a18a
movl $0x15, %edi
callq 0x589e
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
leaq 0x36b0(%rip), %rdi      # 0x1d848
leaq 0x3415(%rip), %rsi      # 0x1d5b4
leaq 0x377c(%rip), %rcx      # 0x1d922
movl $0x1f7, %edx            # imm = 0x1F7
callq 0x3170
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: standProc::doPackUnpack()
void doPackUnpack() {
        ArrayT * t;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %rbx
movl $0x20, %edi
callq 0x3d03
movq %rax, 0x30(%rbx)
movq (%rbx), %rcx
cmpl $0x5, 0x10(%rcx)
jne 0x1a2ff
movq 0x18(%rcx), %rcx
movq %rcx, (%rax)
movq 0x30(%rbx), %rax
movl $0x1c, 0x8(%rax)
movq 0x40(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
movq %rcx, 0x18(%rax)
movq 0x28(%rbx), %rax
movq (%rax), %r15
movb $0x1, %al
cmpl $0x5, 0x10(%r15)
jne 0x1a26e
cmpb $0x1, 0x28(%r15)
jne 0x1a26e
movq (%rbx), %rax
cmpl $0x5, 0x10(%rax)
jne 0x1a2ff
movq 0x18(%r15), %rsi
movq 0x18(%rax), %rdx
leaq 0x50(%rsp), %r14
movq %r14, %rdi
callq 0x83b2
cmpb $0x1, (%r14)
jne 0x1a2f4
movq (%rbx), %rax
cmpl $0x5, 0x10(%rax)
jne 0x1a2ff
movq 0x20(%rax), %rsi
movq 0x20(%r15), %rdx
leaq 0x8(%rsp), %rdi
callq 0x83b2
movb 0x8(%rsp), %al
xorb $0x1, %al
movb $0x1, %cl
movb $0x1, %dl
jmp 0x1a272
xorl %ecx, %ecx
xorl %edx, %edx
testb %dl, %dl
je 0x1a27e
addq $-0x8, 0xa313a(%rip)    # 0xbd3b8
testb %cl, %cl
je 0x1a28a
addq $-0x8, 0xa312e(%rip)    # 0xbd3b8
testb %al, %al
je 0x1a298
movl $0x15, %edi
callq 0x589e
movl $0x20, %edi
callq 0x3d03
movq %rax, 0x4a807(%rip)     # 0x64ab0
movb 0x68(%rbx), %cl
addb $0x32, %cl
movsbq %cl, %rcx
movq %rcx, (%rax)
movq 0x30(%rbx), %rax
movq 0x4a7ef(%rip), %rcx     # 0x64ab0
movq %rax, 0x10(%rcx)
movq 0x28(%rbx), %rax
movq %rax, 0x18(%rcx)
leaq 0x98(%rsp), %rdi
movl $0x10, %esi
callq 0xc044
addq $-0x8, 0xa30e9(%rip)    # 0xbd3d0
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
movb $0x1, %cl
xorl %edx, %edx
movb $0x1, %al
jmp 0x1a272
leaq 0x3542(%rip), %rdi      # 0x1d848
leaq 0x32a7(%rip), %rsi      # 0x1d5b4
leaq 0x360e(%rip), %rcx      # 0x1d922
movl $0x1f7, %edx            # imm = 0x1F7
callq 0x3170
addq $-0x8, 0xa3092(%rip)    # 0xbd3b8
movq %rax, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
andl $0xfff7, 0x4a578(%rip)  # imm = 0xFFF7
movq %rdi, %rbx
movq 0x70(%rdi), %r15
cmpq $0x31, %r15
jne 0x1a4fd
xorl %eax, %eax
jmp 0x1a51b
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
movq (%rcx), %rsi
movq (%rax), %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x83b2
movb (%r14), %al
xorb $0x1, %al
cmpq $0x31, %r15
je 0x1a529
addq $-0x8, 0xa2e8f(%rip)    # 0xbd3b8
testb %al, %al
je 0x1a539
movl $0x22, %edi
callq 0x589e
jmp 0x1a593
movq 0x70(%rbx), %rax
cmpq $0x1d, %rax
je 0x1a558
cmpq $0x31, %rax
jne 0x1a551
movq $0x1e, 0x70(%rbx)
movl $0x10, %eax
jmp 0x1a55d
movl $0x18, %eax
movq 0x28(%rbx), %rcx
movq 0x30(%rbx), %rdx
movq %rdx, (%rcx,%rax)
movq 0x28(%rbx), %rax
movq %rax, 0x4a53c(%rip)     # 0x64ab0
leaq 0x48(%rsp), %rdi
movl $0x7, %esi
callq 0xc044
addq $-0x8, 0xa2e45(%rip)    # 0xbd3d0
movq %rbx, %rdi
callq 0x1a732
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: standProc::checkElementForReadWrite()
void checkElementForReadWrite() {
        RangeT * l5typ1z;

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

// Assembly:
pushq %rbx
andl $0xfff7, 0x4a4b9(%rip)  # imm = 0xFFF7
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpl $0x2, 0x10(%rax)
jne 0x1a5c0
movq 0x18(%rax), %rax
movq %rax, 0x10(%rbx)
movq 0x10(%rbx), %rdi
movl 0x10(%rdi), %eax
movl %eax, 0x4a34b(%rip)     # 0x64918
movq $0x24, 0x70(%rbx)
cmpq 0x4a41c(%rip), %rdi     # 0x649f8
je 0x1a60f
cmpq 0x4a41b(%rip), %rdi     # 0x64a00
je 0x1a619
movq 0x4a41a(%rip), %rcx     # 0x64a08
cmpq %rcx, %rdi
je 0x1a62b
cmpl $0x1, %eax
jne 0x1a63d
movq $0x29, 0x70(%rbx)
callq 0xdf67
movq $0x8, 0x60(%rbx)
jmp 0x1a65e
movq $0xa, 0x60(%rbx)
jmp 0x1a65e
movq $0x25, 0x70(%rbx)
movq $0xe, 0x60(%rbx)
jmp 0x1a65e
movq $0x26, 0x70(%rbx)
movq $0x1, 0x60(%rbx)
jmp 0x1a65e
cmpl $0x5, %eax
jne 0x1a648
cmpq %rcx, 0x18(%rdi)
je 0x1a66b
cmpq $0x1, (%rdi)
jne 0x1a660
movq $0x2a, 0x70(%rbx)
movq $0x11, 0x60(%rbx)
popq %rbx
retq
movl $0x22, %edi
popq %rbx
jmp 0x589e
cmpl $0x5, %eax
jne 0x1a6ae
movq 0x20(%rdi), %rcx
movq 0x30(%rcx), %rax
subq 0x28(%rcx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x60(%rbx)
cmpb $0x0, 0x28(%rdi)
je 0x1a69a
cmpq $0x5, %rax
jg 0x1a6a4
movq $0x27, 0x70(%rbx)
jmp 0x1a65e
movq $0x51, 0x70(%rbx)
jmp 0x1a65e
movq $0x28, 0x70(%rbx)
jmp 0x1a65e
leaq 0x3193(%rip), %rdi      # 0x1d848
leaq 0x2ef8(%rip), %rsi      # 0x1d5b4
leaq 0x325f(%rip), %rcx      # 0x1d922
movl $0x1f7, %edx            # imm = 0x1F7
callq 0x3170
nop
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: standProc::parseWidthSpecifier(Expr*&)
void parseWidthSpecifier(ExprPtr &l5arg1z) {
        expression();
        if (not typeCheck(IntegerType, curExpr->typ)) {
            error(14); /* errExprIsNotInteger */
            curExpr = uVarPtr;
        }
        l5arg1z = curExpr;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
callq 0xebcc
movq 0x4a314(%rip), %rsi     # 0x649f8
movq 0x4a3c5(%rip), %rax     # 0x64ab0
movq (%rax), %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x83b2
addq $-0x8, 0xa2cb7(%rip)    # 0xbd3b8
cmpb $0x0, (%r14)
jne 0x1a71f
movl $0xe, %edi
callq 0x589e
movq 0x4a390(%rip), %rax     # 0x64aa8
movq %rax, 0x4a391(%rip)     # 0x64ab0
movq 0x4a38a(%rip), %rax     # 0x64ab0
movq %rax, (%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/besm6[P]pascal-re/pascompl.cc
// Function: standProc::callHelperWithArg()
void callHelperWithArg() {
        if (regsUsed.has(12) or l4bool12z) {
            curExpr = l4exp9z;
            (void) formOperator(ADDRTOR12);
        }
        l4bool12z= false;
        formAndAlign(getHelperProc(helperNo));
        disableNorm();
    }

// Assembly:
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
testb $0x8, 0x4a323(%rip)     # 0x64a64
jne 0x1a749
cmpb $0x1, 0x4a(%rbx)
jne 0x1a76b
movq 0x40(%rbx), %rax
movq %rax, 0x4a35c(%rip)     # 0x64ab0
leaq 0x8(%rsp), %rdi
movl $0x8, %esi
callq 0xc044
addq $-0x8, 0xa2c65(%rip)    # 0xbd3d0
movb $0x0, 0x4a(%rbx)
movq 0x70(%rbx), %rdi
callq 0x5cbc
movq %rax, %rdi
callq 0x5b45
cmpq $0x1, 0x4a160(%rip)     # 0x648e8
je 0x1a7a1
movq 0x9b07(%rip), %rdi      # 0x24298
callq 0x5941
movq $0x1, 0x4a147(%rip) # 0x648e8
addq $0x70, %rsp
popq %rbx
retq
nop