LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/pascompl.cc
// Function: defineRange(Types*&, long, long)
void defineRange(TypesPtr & res, int64_t l, int64_t r)
{
    RangeT * temp = new RangeT;
    temp->base = res;
    temp->checker = 0;
    temp->left = l;
    temp->right = r;
    if (temp->left >= 0)
        temp->bits = nrOfBits(r);
    res = temp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x38, %edi
callq 0x3d77
movq $0x1, (%rax)
movq $0x30, 0x8(%rax)
movl $0x2, 0x10(%rax)
movq (%rbx), %rcx
movq %rcx, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq %r15, 0x28(%rax)
movq %r14, 0x30(%rax)
testq %r15, %r15
js 0x6175
movq %r14, %rcx
shlq $0x10, %rcx
je 0x616c
movabsq $0x7fffffffffff, %rdx   # imm = 0x7FFFFFFFFFFF
leaq 0x1(%rdx), %rsi
movl $0x30, %ecx
testq %rsi, %r14
jne 0x6171
andq %rdx, %r14
bsrq %r14, %rcx
xorq $-0x40, %rcx
addq $0x41, %rcx
jmp 0x6171
movl $0x31, %ecx
movq %rcx, 0x8(%rax)
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/pascompl.cc
// Function: getValueOrAllocSymtab(long)
int64_t getValueOrAllocSymtab(int64_t value)
{
    curVal.i = value;
    curVal.i = curVal.i & 077777;
    if (040000 >= curVal.i)
        return curVal.i;
    else
        return
            allocSymtab((curVal.ii | 040000000) & halfWord);
}

// Assembly:
pushq %rbx
movq %rdi, %rsi
leaq 0x5e8a7(%rip), %rbx     # 0x64a30
movq %rbx, %rdi
callq 0x3c48
movq 0x5e898(%rip), %rsi     # 0x64a30
andl $0x7fff, %esi           # imm = 0x7FFF
movq %rbx, %rdi
callq 0x3c48
movq 0x5e883(%rip), %rdi     # 0x64a30
movq %rdi, %rax
shlq $0x17, %rax
sarq $0x17, %rax
cmpq $0x4001, %rax           # imm = 0x4001
jge 0x61c2
popq %rbx
retq
andl $0x7fffff, %edi         # imm = 0x7FFFFF
orq $0x800000, %rdi         # imm = 0x800000
popq %rbx
jmp 0x5ed0
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/pascompl.cc
// Function: OBPROG(long&, long&)
void OBPROG(int64_t & start, int64_t & fin)
{
    for (int64_t * p = &start; p <= &fin; ++p) {
        if (p != &start && (p - &start) % 4 == 0) putchar('\n');
        prInsn(*p >> 24); putchar(' '); prInsn(*p & 0xFFFFFF); printf("     ");
    }
    putchar('\n');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
cmpq %rsi, %rdi
ja 0x65d3
xorl %ebp, %ebp
movl $0x7f, %r13d
movl $0xfff, %r15d           # imm = 0xFFF
testq %rbp, %rbp
je 0x6500
testb $0x18, %bpl
jne 0x6500
movl $0xa, %edi
callq 0x3330
movq 0x8(%rsp), %rax
leaq (%rax,%rbp), %r12
addq $0x8, %r12
movl -0x5(%r12), %edx
movl %edx, %esi
sarl $0x14, %esi
xorl %ecx, %ecx
btl $0x13, %edx
movl $0x1f, %r8d
cmovael %r13d, %r8d
movl $0x7fff, %eax           # imm = 0x7FFF
cmovael %r15d, %eax
leaq 0x16ddc(%rip), %r14     # 0x1d313
movq %r14, %rdi
leaq 0x16de1(%rip), %rbx     # 0x1d322
cmovaeq %rbx, %rdi
setb %cl
leal (%rcx,%rcx,2), %ecx
addl $0xc, %ecx
andl %edx, %eax
shrl %cl, %edx
andl %r8d, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0x3030
movl $0x20, %edi
callq 0x3330
movl -0x8(%r12), %r8d
movl %r8d, %edx
andl $0xffffff, %edx         # imm = 0xFFFFFF
movl %edx, %esi
shrl $0x14, %esi
xorl %ecx, %ecx
btl $0x13, %r8d
movl $0x1f, %r9d
cmovael %r13d, %r9d
movl $0x7fff, %eax           # imm = 0x7FFF
cmovael %r15d, %eax
cmovaeq %rbx, %r14
setb %cl
leal (%rcx,%rcx,2), %ecx
addl $0xc, %ecx
shrl %cl, %edx
andl %r9d, %edx
andl %r8d, %eax
movq %r14, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0x3030
leaq 0x16d74(%rip), %rdi     # 0x1d331
xorl %eax, %eax
callq 0x3030
addq $0x8, %rbp
cmpq 0x10(%rsp), %r12
jbe 0x64eb
movl $0xa, %edi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3330
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/pascompl.cc
// Function: readToPos80()
void readToPos80()
{
    while (!feof(pasinput) && linePos < 81 && PASINPUT != '\n') {
        linePos = linePos + 1;
        lineBufBase[linePos] = PASINPUT;
        if (linePos != 81) PASINPUT = ugetc(pasinput);
    }
    endOfLine();
}

// Assembly:
pushq %rbx
movq 0x1dee4(%rip), %rdi     # 0x247b0
callq 0x3390
testl %eax, %eax
sete %dl
movq 0x5df93(%rip), %rax     # 0x64870
cmpq $0x51, %rax
setl %sil
movb 0x1decd(%rip), %cl      # 0x247b8
cmpb $0xa, %cl
setne %dil
andb %sil, %dil
andb %dl, %dil
cmpb $0x1, %dil
jne 0x6954
leaq 0x62beb(%rip), %rbx     # 0x694f0
leaq 0x1(%rax), %rdx
movq %rdx, 0x5df60(%rip)     # 0x64870
movb %cl, 0x1(%rax,%rbx)
cmpq $0x51, %rdx
je 0x692c
movq 0x1de8f(%rip), %rdi     # 0x247b0
callq 0x695a
movb %al, 0x1de8c(%rip)      # 0x247b8
movq 0x1de7d(%rip), %rdi     # 0x247b0
callq 0x3390
testl %eax, %eax
jne 0x6954
movq 0x5df2d(%rip), %rax     # 0x64870
cmpq $0x50, %rax
jg 0x6954
movb 0x1de69(%rip), %cl      # 0x247b8
cmpb $0xa, %cl
jne 0x6905
popq %rbx
jmp 0x65eb
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/pascompl.cc
// Function: nextCH()
void nextCH()
{
    do {
        atEOL = PASINPUT == '\n' || feof(pasinput);
        CH = PASINPUT;
        PASINPUT = ugetc(pasinput);
        linePos = linePos + 1;
        lineBufBase[linePos] = CH;
    } while (not ((maxLineLen >= linePos) or atEOL));
}

// Assembly:
pushq %rbx
movb 0x1dc3a(%rip), %al      # 0x247b8
leaq 0x6296b(%rip), %rbx     # 0x694f0
cmpb $0xa, %al
jne 0x6b8f
movb $0x1, %al
movb $0xa, %cl
jmp 0x6ba6
movq 0x1dc1a(%rip), %rdi     # 0x247b0
callq 0x3390
testl %eax, %eax
setne %al
movb 0x1dc12(%rip), %cl      # 0x247b8
movb %al, 0x5ddc5(%rip)      # 0x64971
movb %cl, 0x5dd67(%rip)      # 0x64919
movq 0x1dbf7(%rip), %rdi     # 0x247b0
callq 0x695a
movb %al, 0x1dbf4(%rip)      # 0x247b8
movq 0x5dca5(%rip), %rcx     # 0x64870
leaq 0x1(%rcx), %rdx
movq %rdx, 0x5dc9a(%rip)     # 0x64870
movb 0x5dd3d(%rip), %dl      # 0x64919
movb %dl, 0x1(%rcx,%rbx)
cmpq %rcx, 0x5dc81(%rip)     # 0x64868
jg 0x6bf2
testb $0x1, 0x5dd81(%rip)     # 0x64971
je 0x6b85
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/pascompl.cc
// Function: readOptVal(long)
int64_t readOptVal(int64_t limit)
{
    nextCH();
    int64_t res = 0;
    while (('9' >= CH) and (CH >= '0')) {
        res = 10 * res + CH - '0';
        nextCH();
        parseComment::super->badOpt = false;
    }
    if (limit < res) parseComment::super->badOpt = true;
    return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6b77
movb 0x5dd13(%rip), %al      # 0x64919
leal -0x30(%rax), %ecx
xorl %r14d, %r14d
cmpb $0x9, %cl
ja 0x6c3d
leaq (%r14,%r14,4), %rcx
movzbl %al, %eax
leaq (%rax,%rcx,2), %r14
addq $-0x30, %r14
callq 0x6b77
movq 0xb676c(%rip), %rax     # 0xbd398
movb $0x0, (%rax)
movb 0x5dce4(%rip), %al      # 0x64919
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0x6c11
cmpq %rbx, %r14
jle 0x6c4c
movq 0xb674f(%rip), %rax     # 0xbd398
movb $0x1, (%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/pascompl.cc
// Function: readOptFlag(bool&)
void readOptFlag(bool & res)
{
    nextCH();
    if ((CH == '-') or (CH == '+')) {
        res = CH == '+';
        parseComment::super->badOpt = false;
    }
    nextCH();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x6b77
movzbl 0x5dcb2(%rip), %eax     # 0x64919
cmpl $0x2d, %eax
je 0x6c71
cmpl $0x2b, %eax
jne 0x6c80
cmpb $0x2b, %al
sete (%rbx)
movq 0xb671b(%rip), %rax     # 0xbd398
movb $0x0, (%rax)
popq %rbx
jmp 0x6b77
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/pascompl.cc
// Function: koi8_to_koi7(unsigned char)
unsigned char koi8_to_koi7(unsigned char ch)
{
    if (ch >= 0300)
        return (ch & 0177) | 040;
    if (ch >= 0200)
        return ' ';
    if (ch >= 0140)
        ch ^= 040;
    return ch;
}

// Assembly:
movl %edi, %eax
cmpb $-0x40, %al
jb 0x6f28
andb $0x5f, %al
orb $0x20, %al
retq
testb %al, %al
js 0x6f3d
movl %eax, %ecx
xorb $0x20, %cl
cmpb $0x60, %al
movzbl %al, %edx
movzbl %cl, %eax
cmovbl %edx, %eax
retq
movb $0x20, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5c821(%rip), %ebp     # 0x6481c
leaq 0x178(%rsp), %rbx
movq %rbx, %rdi
callq 0x6f40
xorl $0x27, %ebp
movl 0x5c808(%rip), %eax     # 0x6481c
movl %eax, %ecx
xorl $0x10, %ecx
orl %ebp, %ecx
movl %eax, %ebp
jne 0x8003
movb 0x5c8f4(%rip), %al      # 0x64919
andb $-0x21, %al
cmpb $0x44, %al
jne 0x8041
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x6f40
cmpl $0x27, 0x5c7dd(%rip)    # 0x6481c
jne 0x8030
movl $0x4, %edi
callq 0x3110
movl $0x270f, (%rax)         # imm = 0x270F
movq 0x1bf28(%rip), %rsi     # 0x23f80
movq %rax, %rdi
xorl %edx, %edx
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x2e8, %rsp            # imm = 0x2E8
cmpl %edi, 0x5c76a(%rip)     # 0x6481c
jne 0x80c9
leaq 0x8(%rsp), %rdi
callq 0x6f40
addq $0x2e8, %rsp            # imm = 0x2E8
popq %rbx
popq %r14
retq
movq %rsi, %rbx
movq 0x5c79d(%rip), %rax     # 0x64870
cmpq 0x5c79e(%rip), %rax     # 0x64878
je 0x80e7
addl $0x58, %edi
movslq %edi, %rdi
callq 0x58ff
leaq 0x178(%rsp), %r14
movl 0x5c727(%rip), %eax     # 0x6481c
cmpq $0x2f, %rax
ja 0x8108
movb $0x2f, %cl
subb %al, %cl
movzbl %cl, %eax
btq %rax, %rbx
jb 0x80be
movq %r14, %rdi
callq 0x6f40
jmp 0x80ef
// File: /workspace/github_cpp_makefile_star2_O3/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), %rax
testq %rax, %rax
je 0x8329
cmpq %rsi, %rax
jne 0x8379
jmp 0x838e
movq (%rsi), %rcx
movabsq $-0x7fff7fff7fff7fff, %rdx # imm = 0x8000800080008001
movq %rcx, %rax
imulq %rdx
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0xf, %rdx
addl %eax, %edx
movl %edx, %eax
shll $0x10, %eax
subl %eax, %edx
leal (%rcx,%rdx), %eax
addl $0x7f, %eax
addl %edx, %ecx
cmovnsl %ecx, %eax
andl $-0x80, %eax
subl %eax, %ecx
movslq %ecx, %rcx
leaq 0x61e63(%rip), %rdx     # 0x6a1d0
movq (%rdx,%rcx,8), %rax
movq %rax, (%rdi)
cmpq %rsi, %rax
je 0x8393
testq %rax, %rax
je 0x839e
movq %rax, %rdi
movq 0x10(%rax), %rax
cmpq %rsi, %rax
jne 0x8379
addq $0x10, %rdi
movq %rsi, %rax
jmp 0x8397
leaq (%rdx,%rcx,8), %rdi
movq 0x10(%rax), %rax
movq %rax, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/pascompl.cc
// Function: checkSymAndRead(Symbol)
void checkSymAndRead(Symbol sym)
{
    if (SY != sym)
        requiredSymErr(sym);
    else
        inSymbol();
}

// Assembly:
cmpl %edi, 0x5c42f(%rip)     # 0x6481c
jne 0x8408
subq $0x178, %rsp            # imm = 0x178
leaq 0x8(%rsp), %rdi
callq 0x6f40
addq $0x178, %rsp            # imm = 0x178
retq
movq 0x5c461(%rip), %rax     # 0x64870
cmpq 0x5c462(%rip), %rax     # 0x64878
jne 0x8419
retq
addl $0x58, %edi
movslq %edi, %rdi
jmp 0x58ff
// File: /workspace/github_cpp_makefile_star2_O3/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 0x844b
cmpq %rbx, %r14
sete %al
jmp 0x848c
movq 0x18(%r14), %rsi
movq 0x18(%rbx), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x84c6
cmpb $0x1, (%r15)
jne 0x8482
cmpl $0x0, 0x20(%r14)
je 0x8496
cmpl $0x0, 0x20(%rbx)
je 0x8496
movq 0x28(%r14), %rdi
movq 0x28(%rbx), %rsi
callq 0x8424
jmp 0x8484
xorl %eax, %eax
addq $-0x8, 0xb4f1c(%rip)    # 0xbd3a8
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x151fd(%rip), %rdi     # 0x1d69a
leaq 0x151d0(%rip), %rsi     # 0x1d674
leaq 0x15302(%rip), %rcx     # 0x1d7ad
movl $0x2d5, %edx            # imm = 0x2D5
callq 0x3170
addq $-0x8, 0xb4eeb(%rip)    # 0xbd3a8
movq %rax, %rdi
callq 0x3400
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x881e
movq 0x38(%rdi), %rcx
testq %rcx, %rcx
sete %al
cmpq %rdi, %rcx
sete %dl
orb %al, %dl
je 0x87e9
xorl %eax, %eax
jmp 0x87fd
xorl %eax, %eax
cmpl $0x0, 0x20(%rcx)
je 0x87ff
incq %rax
movq 0x28(%rcx), %rcx
cmpq %rdi, %rcx
jne 0x87eb
popq %rcx
retq
leaq 0x14e94(%rip), %rdi     # 0x1d69a
leaq 0x14e67(%rip), %rsi     # 0x1d674
leaq 0x14f99(%rip), %rcx     # 0x1d7ad
movl $0x2d5, %edx            # imm = 0x2D5
callq 0x3170
leaq 0x14fa6(%rip), %rdi     # 0x1d7cb
leaq 0x14e48(%rip), %rsi     # 0x1d674
leaq 0x14fa8(%rip), %rcx     # 0x1d7db
movl $0x2f1, %edx            # imm = 0x2F1
callq 0x3170
// File: /workspace/github_cpp_makefile_star2_O3/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, %rcx   # imm = 0xFC0000000000
movq 0x5c27a(%rip), %r8      # 0x64ac8
testq %r8, %r8
sete %dl
movq 0x5c1d5(%rip), %rax     # 0x64a30
testq %rcx, %rax
je 0x8861
retq
notb %dil
andb %dl, %dil
movabsq $0xffffffffffc0, %rdx   # imm = 0xFFFFFFFFFFC0
movabsq $0xfc0000000, %rsi      # imm = 0xFC0000000
shlq $0x6, %rax
andq %rdx, %rax
leaq 0xa(%rax), %r9
cmpq $0x1, %r8
cmoveq %r9, %rax
testb %dil, %dil
movq %rax, %r8
cmovneq %r9, %r8
leaq 0x40000000(%rsi), %rax
cmpq %rax, %r8
jae 0x88c2
movabsq $0x3ffffffffc0, %r9     # imm = 0x3FFFFFFFFC0
movq %r8, %rax
shlq $0x6, %rax
andq %r9, %rax
testq %rsi, %r8
movq %rax, %r8
je 0x88b1
jmp 0x88c5
movq %r8, %rax
movq %rax, 0x5c164(%rip)     # 0x64a30
testq %rcx, %rax
jne 0x8860
movabsq $0x280000000000, %rcx   # imm = 0x280000000000
orq %rax, %rcx
shlq $0x6, %rax
andq %rdx, %rax
testb %dil, %dil
cmoveq %rax, %rcx
movq %rcx, 0x5c13d(%rip)     # 0x64a30
movq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3d77
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rbx, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq 0x5c18a(%rip), %rcx     # 0x64aa8
movq (%rcx), %rdx
testq %rdx, %rdx
je 0x8932
movq %rax, (%rdx)
movq 0x5c178(%rip), %rcx     # 0x64aa8
jmp 0x8936
movq %rax, 0x8(%rcx)
movq %rax, (%rcx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3d77
movq 0x5c13f(%rip), %rcx     # 0x64aa8
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
xorl %edx, %edx
movq %rdx, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rdx, 0x18(%rax)
movq 0x5c123(%rip), %rcx     # 0x64aa8
cmpq %rdx, 0x8(%rcx)
jne 0x8995
movq %rax, (%rcx)
movq 0x5c113(%rip), %rcx     # 0x64aa8
movq %rax, 0x8(%rcx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb4169(%rip), %rax     # 0xbd378
movq -0x8(%rax), %r14
movq 0x5b67e(%rip), %rdi     # 0x64898
movq 0x90(%r14), %r15
callq 0x88f7
movq 0x5b87b(%rip), %rax     # 0x64aa8
movq (%rax), %rax
movq %r15, 0x18(%rax)
movl $0x20, %edi
callq 0x3d77
movq %rax, 0x5b85b(%rip)     # 0x64aa0
movq 0x5b85c(%rip), %rcx     # 0x64aa8
movq 0x10(%rcx), %rcx
movq %rcx, (%rax)
movq %rsp, %rdi
callq 0x15d64
movq 0x5b83e(%rip), %rax     # 0x64aa0
movl %ebx, 0x8(%rax)
movq 0x90(%r14), %rcx
movq %rcx, 0x10(%rax)
leaq 0x1(%rcx), %rax
movq %rax, 0x90(%r14)
cmpq %rcx, 0x98(%r14)
jg 0x928b
movq %rax, 0x98(%r14)
addq $0x6b0, %rsp            # imm = 0x6B0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb2cc1(%rip), %rax     # 0xbd3d8
movq -0x8(%rax), %r14
movl $0x58, %edi
callq 0x3d77
movq %rax, 0x5a37c(%rip)     # 0x64aa8
xorl %ecx, %ecx
movq %rcx, (%rax)
movq 0x5a370(%rip), %rax     # 0x64aa8
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 0xa773
movl $0x0, 0x40(%rax)
movq $0x12, 0x38(%rax)
movl $0x30, %ecx
movl $0x10, %esi
leaq 0x5a127(%rip), %rdx     # 0x64898
jmp 0xa784
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_O3/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 0xe243
popq %rbx
retq
movq 0x565e6(%rip), %rax     # 0x64830
movq %rax, 0x28(%rdi)
movq 0x18(%rdi), %rbx
testq %rbx, %rbx
je 0xe241
movq (%rbx), %rax
movq %rax, 0x567cf(%rip)     # 0x64a30
cmpl $0x0, 0x20(%rbx)
je 0xe272
movq 0x28(%rbx), %rbx
callq 0x5d59
jmp 0xe252
leaq 0xf421(%rip), %rdi      # 0x1d69a
leaq 0xf3f4(%rip), %rsi      # 0x1d674
leaq 0xf526(%rip), %rcx      # 0x1d7ad
movl $0x2d5, %edx            # imm = 0x2D5
callq 0x3170
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3d77
movq 0x559d1(%rip), %rcx     # 0x649f0
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_O3/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 %r14
pushq %rbx
subq $0x48, %rsp
movq 0x559c5(%rip), %rdx     # 0x64a08
movq 0x559a6(%rip), %rax     # 0x649f0
cmpq %rax, %rdx
je 0xf081
cmpq %rax, 0x559ba(%rip)     # 0x64a10
jne 0xf0d4
movq 0x55989(%rip), %rsi     # 0x649e8
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x84c6
movb (%rbx), %al
addq $-0x8, 0xae334(%rip)    # 0xbd3a8
cmpb $0x1, %al
jne 0xf0d4
leaq 0x55a21(%rip), %rbx     # 0x64aa0
jmp 0xf0ab
movq %rdi, %rbx
movq 0x5595d(%rip), %rsi     # 0x649e8
movq 0x5597e(%rip), %rdx     # 0x64a10
movq %rsp, %r14
movq %r14, %rdi
callq 0x84c6
addq $-0x8, 0xae303(%rip)    # 0xbd3a8
cmpb $0x0, (%r14)
je 0xf0d4
movl $0x20, %edi
callq 0x3d77
movq 0x55934(%rip), %rcx     # 0x649f0
movq %rcx, (%rax)
movl $0x29, 0x8(%rax)
movq (%rbx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, (%rbx)
movb $0x1, %al
jmp 0xf0d6
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x108ce
addq $-0x8, 0xacc42(%rip)    # 0xbd428
cmpl $0xf, 0x5402f(%rip)     # 0x6481c
jne 0x10818
leaq 0x58(%rsp), %rbx
movq %rsp, %r14
movq %rbx, %rdi
callq 0x6f40
movq %r14, %rdi
callq 0x108ce
addq $-0x8, 0xacc19(%rip)    # 0xbd428
cmpl $0xf, 0x54006(%rip)     # 0x6481c
je 0x107f7
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xacbf2(%rip), %rax     # 0xbd428
movq -0x8(%rax), %r14
cmpq $0x1, 0x54096(%rip)     # 0x648d8
je 0x1085b
movq 0x13a3d(%rip), %rdi     # 0x24288
callq 0x59a2
movq $0x1, 0x5407d(%rip) # 0x648d8
callq 0xee5e
movq $0x0, 0x53f9d(%rip) # 0x64808
movq 0x5422e(%rip), %rax     # 0x64aa0
movq (%rax), %rax
cmpq 0x5415c(%rip), %rax     # 0x649d8
je 0x10887
xorl %edi, %edi
callq 0x58ff
jmp 0x1089e
leaq 0x60(%rsp), %rdi
movl $0xf, %esi
callq 0xc308
addq $-0x8, 0xacb22(%rip)    # 0xbd3c0
movq 0x53f63(%rip), %rax     # 0x64808
movq %rax, 0x40(%r14)
movl %ebx, %edi
callq 0x83e7
leaq 0x8(%rsp), %rdi
callq 0x108ce
addq $-0x8, 0xacb66(%rip)    # 0xbd428
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
cmpl $0x2, 0x20(%rsi)
jne 0x15b91
movl %edx, %ebp
movq (%r14), %rsi
leaq 0x48(%rsp), %rdi
callq 0x4ff9
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %r15
movq %r15, %rsi
callq 0x3300
movq (%r15), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x15aed
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3260
testb %bpl, %bpl
je 0x15b6b
movq 0x28(%r14), %r15
movq 0x30(%r14), %rbp
movq 0x38(%r14), %rdi
callq 0x3e11
movq %rax, %r13
movq 0x40(%r14), %rdi
callq 0x3e11
movups 0x48(%r14), %xmm0
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq 0x58(%r14), %rcx
movq %rcx, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x7ac2(%rip), %rsi      # 0x1d5f4
leaq 0x20(%rsp), %rdi
movq %r15, %rdx
movq %rbp, %rcx
movq %r13, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x30b0
testl %eax, %eax
js 0x15c35
movq 0x20(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x3470
movq 0x20(%rsp), %rdi
callq 0x32e0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x28(%rsp), %rcx
cmpq %r12, %rcx
je 0x15c12
movq %rcx, (%rbx)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x15c1a
movq (%r14), %rsi
leaq 0x48(%rsp), %rdi
callq 0x4ff9
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %r14
movq %r14, %rsi
callq 0x3300
movq (%r14), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x15bca
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3260
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movl $0x20, %esi
movq $-0x1, %rdx
callq 0x3490
leaq 0x1(%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x3270
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x15c23
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x15c23
movups (%r12), %xmm0
movups %xmm0, (%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7057(%rip), %rdi      # 0x1cc93
callq 0x31f0
jmp 0x15b6b
jmp 0x15c4a
jmp 0x15c4a
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x15c64
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3260
movq %rbx, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3440
movl $0x28, %edi
callq 0x3360
cvttsd2si %xmm0, %rax
movzwl 0x6(%rbx), %ecx
shlq $0x30, %rcx
movabsq $0x1ffffffffff, %rdx    # imm = 0x1FFFFFFFFFF
andq %rax, %rdx
orq %rcx, %rdx
movl (%r14), %eax
andl $0x7f, %eax
xorl $0x40, %eax
shlq $0x29, %rax
orq %rdx, %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x20(%rsi), %r14
testq %r14, %r14
jne 0x16d79
movq %rsi, %rbx
movq 0x28(%rsi), %rsi
leaq 0x4dd3a(%rip), %rdi     # 0x64a30
callq 0x3c48
movq 0x30(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3c48
movq 0x18(%rbx), %rax
movq (%r14), %r15
cmpq 0x4dcce(%rip), %rax     # 0x649e8
je 0x16d33
andl $0x1ff, 0x4dd0e(%rip)   # imm = 0x1FF
movabsq $0x1ffffffffff, %rax    # imm = 0x1FFFFFFFFFF
andq %rax, %r15
movq $0x0, 0x4dc1a(%rip) # 0x64958
movl $0xc0005, %edi          # imm = 0xC0005
addq 0x4db3e(%rip), %rdi     # 0x64888
callq 0x5bb2
movq 0x4db32(%rip), %r14     # 0x64888
movq %r14, 0x20(%rbx)
shlq $0x17, %r15
sarq $0x17, %r15
movl $0x1, %edi
movq %r15, %rsi
callq 0x61d5
movl $0xdc0000, %edi         # imm = 0xDC0000
callq 0x5bb2
callq 0x899b
movl $0xea0000, %edi         # imm = 0xEA0000
addq 0x4db26(%rip), %rdi     # 0x648b0
callq 0x88f7
addq $0xdc8000, %r14         # imm = 0xDC8000
movq %r14, %rdi
callq 0x88f7
movq 0x4dd03(%rip), %rax     # 0x64aa8
movq (%rax), %rax
movq $0x1, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16dba
btq $0x23, %r15
jae 0x17084
movl $0x2200c, %edi          # imm = 0x2200C
callq 0x88f7
movl $0x1000005, %edi        # imm = 0x1000005
callq 0x88f7
movq 0x4da1d(%rip), %r14     # 0x64aa8
movq 0x10(%rbx), %rax
movq %rax, 0x4da12(%rip)     # 0x64aa8
movq %rsp, %rdi
movl $0xe, %esi
callq 0x16dba
btq $0x23, %r15
jae 0x170be
movl $0x1000004, %edi        # imm = 0x1000004
callq 0x88f7
movl $0x2000c, %edi          # imm = 0x2000C
callq 0x88f7
movq 0x4d9e3(%rip), %rax     # 0x64aa8
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq 0x18(%rax), %rcx
orq %rcx, 0x18(%r14)
movq 0x8(%rax), %rax
movq (%r14), %rcx
movq %rax, (%rcx)
movq 0x4d9c0(%rip), %rax     # 0x64aa8
movq (%rax), %rax
movq %rax, (%r14)
movq %r14, 0x4d9b3(%rip)     # 0x64aa8
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/pascompl.cc
// Function: genFullExpr::genHelper()
void genHelper() {
        InsnList * &saved = formOperator::super.back()->saved;
        P4606();
        saved = insnList;
        insnList = otherIns;
        prepLoad();
        addToInsnList(getHelperProc(formOperator::super.back()->nextInsn));
        insnList->regsused = insnList->regsused + saved->regsused + BitRange(11,14);
        saved->next->next = insnList->next2;
        insnList->next2 = saved->next2;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xa62b1(%rip), %rax     # 0xbd3c0
movq -0x8(%rax), %r14
callq 0x899b
movl $0x1000005, %edi        # imm = 0x1000005
callq 0x88f7
movq 0x4d97f(%rip), %rax     # 0x64aa8
movq %rax, 0x58(%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x4d970(%rip)     # 0x64aa8
callq 0x899b
movq 0xa627c(%rip), %rax     # 0xbd3c0
movq -0x8(%rax), %rax
movq 0x18(%rax), %rbx
leaq 0x5387d(%rip), %r15     # 0x6a9d0
movq (%r15,%rbx,8), %rdi
testq %rdi, %rdi
jne 0x1717f
leaq 0xd21d(%rip), %rax      # 0x24380
movq (%rax,%rbx,8), %rax
movq %rax, 0x4d8c2(%rip)     # 0x64a30
movl $0x8c0000, %edi         # imm = 0x8C0000
callq 0x5c15
movq %rax, %rdi
movq %rax, (%r15,%rbx,8)
addq $0xdc8000, %rdi         # imm = 0xDC8000
callq 0x88f7
movq 0x4d916(%rip), %rax     # 0x64aa8
movq 0x58(%r14), %rcx
movq 0x8(%rax), %rdx
movq 0x18(%rax), %rsi
orq 0x18(%rcx), %rsi
movabsq $0xffe1ffffffff, %rcx   # imm = 0xFFE1FFFFFFFF
andq %rsi, %rcx
movabsq $0x1e00000000, %rsi     # imm = 0x1E00000000
orq %rcx, %rsi
movq %rsi, 0x18(%rax)
movq 0x58(%r14), %rax
movq (%rax), %rax
movq %rdx, (%rax)
movq 0x58(%r14), %rax
movq 0x8(%rax), %rax
movq 0x4d8cf(%rip), %rcx     # 0x64aa8
movq %rax, 0x8(%rcx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x4d385(%rip)     # 0x64a30
callq 0x5ff3
leaq 0x80f000(%rax), %rdi
popq %rax
jmp 0x88f7
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa59cc(%rip), %rax     # 0xbd378
movq -0x8(%rax), %r15
movl $0x20, %edi
callq 0x3d77
movq $0x1, (%rax)
movq $0xf, 0x8(%rax)
movl $0x3, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %rax, 0xf0(%r14)
movl $0x60, %edi
callq 0x3d77
movq 0x4d054(%rip), %rcx     # 0x64a40
movq 0x4cebd(%rip), %rdx     # 0x648b0
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_O3/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 0x3d77
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
shrq $0xf, %rdx
addl %eax, %edx
movl %edx, %eax
shll $0x10, %eax
subl %eax, %edx
leal (%rcx,%rdx), %eax
addl $0x7f, %eax
addl %edx, %ecx
cmovnsl %ecx, %eax
andl $-0x80, %eax
subl %eax, %ecx
movslq %ecx, %rax
leaq 0x511b6(%rip), %rcx     # 0x6a1d0
movq (%rcx,%rax,8), %rdx
movq %rdx, 0x10(%rsi)
movq %rsi, (%rcx,%rax,8)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3d77
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 0x190e5
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
shrq $0xf, %rdx
addl %eax, %edx
movl %edx, %eax
shll $0x10, %eax
subl %eax, %edx
leal (%rcx,%rdx), %eax
addl $0x7f, %eax
addl %edx, %ecx
cmovnsl %ecx, %eax
andl $-0x80, %eax
subl %eax, %ecx
movslq %ecx, %rax
leaq 0x510fd(%rip), %rcx     # 0x6a1d0
movq (%rcx,%rax,8), %rdx
movq %rdx, 0x10(%rsi)
movq %rsi, (%rcx,%rax,8)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x45ae(%rip), %rdi      # 0x1d69a
leaq 0x4581(%rip), %rsi      # 0x1d674
leaq 0x45ad(%rip), %rcx      # 0x1d6a7
movl $0x2d9, %edx            # imm = 0x2D9
callq 0x3170
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3d77
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 %rax
movq %rax, 0x40(%r14)
movq (%rsi), %rcx
movabsq $-0x7fff7fff7fff7fff, %rdx # imm = 0x8000800080008001
movq %rcx, %rax
imulq %rdx
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0xf, %rdx
addl %eax, %edx
movl %edx, %eax
shll $0x10, %eax
subl %eax, %edx
leal (%rcx,%rdx), %eax
addl $0x7f, %eax
addl %edx, %ecx
cmovnsl %ecx, %eax
andl $-0x80, %eax
subl %eax, %ecx
movslq %ecx, %rax
leaq 0x51033(%rip), %rcx     # 0x6a1d0
movq (%rcx,%rax,8), %rdx
movq %rdx, 0x10(%rsi)
movq %rsi, (%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/pascompl.cc
// Function: Real::operator=(long)
void operator=(int64_t i) {
        mantissa = i  & ((1L<<48)-1); exponent = 104;
        if (mantissa == 0)
            exponent = 0;
        else
            while ((mantissa >> 39) == 0 || (mantissa >> 39) == -1) { exponent--; mantissa <<= 1; }
    }

// Assembly:
movabsq $0x1fffffffffe, %rax    # imm = 0x1FFFFFFFFFE
movzwl 0x6(%rdi), %edx
shlq $0x30, %rdx
leaq 0x1(%rax), %r8
andq %rsi, %r8
orq %r8, %rdx
movabsq $0xd00000000000, %rcx   # imm = 0xD00000000000
orq %rdx, %rcx
movq %rcx, (%rdi)
testq %r8, %r8
je 0x19843
movabsq $-0x1000000000000, %rdx # imm = 0xFFFF000000000000
movabsq $0xfe0000000000, %rsi   # imm = 0xFE0000000000
movabsq $0x18000000000, %r8     # imm = 0x18000000000
movq %rcx, %r9
andq %r8, %r9
cmpq %r8, %r9
je 0x19825
testq %r9, %r9
jne 0x19846
leaq (%rcx,%rsi), %r9
andq %rsi, %r9
movq %rcx, %r10
andq %rdx, %r10
orq %r9, %r10
addq %rcx, %rcx
andq %rax, %rcx
orq %r10, %rcx
movq %rcx, (%rdi)
jmp 0x19815
movq %rdx, (%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x198c2
testb %al, %al
je 0x19861
movq 0x30(%rbx), %rdi
jmp 0x19897
movl $0x20, %edi
callq 0x3d77
movq %rax, %rdi
movq %rax, 0x30(%rbx)
movq 0x28(%rbx), %rax
movq %rax, (%rdi)
movq 0x690(%rbx), %rax
shlq $0x17, %rax
sarq $0x17, %rax
movq %rax, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq %rdi, 0x28(%rbx)
callq 0x3e11
leaq (%r14,%rax), %rsi
addq $0x1000000, %rsi        # imm = 0x1000000
movq (%rbx), %rax
leaq (%rbx,%rax,8), %rdi
addq $0x48, %rdi
callq 0x3c48
incq (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19912
cmpq %rax, 0x8(%r14)
jne 0x198dc
cmpq $0x1000000, 0x10(%r14)  # imm = 0x1000000
jne 0x19912
movq %r14, %rax
movq 0x18(%rax), %rdi
callq 0x3de2
movq %rax, 0x30(%rbx)
cmpq $0x1000000, 0x10(%rax)  # imm = 0x1000000
je 0x198fb
testq %r14, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/besm6[P]pascal-re/pascompl.cc
// Function: ParseData::P16432(long)
void P16432(int64_t l5arg1z) {
        DATAREC l5var1z;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
movq 0x18(%rdi), %rsi
shlq $0x17, %rsi
sarq $0x17, %rsi
callq 0x19ea2
movq %rax, %r15
andl $0xfff, %r15d           # imm = 0xFFF
shlq $0x24, %r15
movq 0x10(%rbx), %rax
movq %rax, %rcx
shlq $0x17, %rcx
sarq $0x17, %rcx
cmpq %rcx, 0x4aaeb(%rip)     # 0x64830
jne 0x19d72
movq 0x38(%rbx), %rax
movq %rax, 0x4acde(%rip)     # 0x64a30
leaq 0x4acd7(%rip), %r12     # 0x64a30
callq 0x5da0
movq %r12, %rdi
movq %rax, %rsi
callq 0x3c48
movq 0x4acc0(%rip), %rax     # 0x64a30
jmp 0x19d79
movq %rax, 0x4acb7(%rip)     # 0x64a30
andl $0xffffff, %eax         # imm = 0xFFFFFF
movabsq $0x801000000, %rdi      # imm = 0x801000000
orq %rax, %rdi
callq 0x5ed0
movq %rax, %r12
andl $0xfff, %r12d           # imm = 0xFFF
shlq $0x18, %r12
orq %r15, %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19ea2
movq %rax, %r15
shll $0xc, %r15d
andl $0xfff000, %r15d        # imm = 0xFFF000
orq %r12, %r15
leaq 0x40(%rbx), %r12
movq 0x30(%rbx), %rdi
movq 0x40(%rbx), %rsi
movq %rsi, %rax
shlq $0x17, %rax
je 0x19dfc
andl $0xffffff, %esi         # imm = 0xFFFFFF
orq %rsi, %rdi
callq 0x5ed0
leaq 0x4ac49(%rip), %rdi     # 0x64a30
movq %rax, %rsi
callq 0x3c48
movq 0x4ac3a(%rip), %rdi     # 0x64a30
movq (%r12), %rsi
jmp 0x19e0d
shrq $0x18, %rdi
andl $0xffffff, %edi         # imm = 0xFFFFFF
movq %rdi, 0x4ac23(%rip)     # 0x64a30
leaq 0x10(%rbx), %r13
andl $0xfff, %edi            # imm = 0xFFF
orq %rdi, %r15
movq %r15, 0x8(%rsp)
movq 0x18(%rbx), %rax
shlq $0x17, %rax
sarq $0x17, %rax
imulq %r14, %rax
shlq $0x17, %rsi
sarq $0x17, %rsi
addq %rax, %rsi
movq %r12, %rdi
callq 0x3c48
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x19e59
movq %r15, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x50(%rbx)
jmp 0x19e67
leaq 0x48(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0x19ed6
incq 0x8(%rbx)
movzwl 0x1e(%rbx), %eax
shlq $0x30, %rax
movabsq $0xd00000000000, %rcx   # imm = 0xD00000000000
orq %rax, %rcx
movq %rcx, 0x18(%rbx)
movq 0x4a9a5(%rip), %rsi     # 0x64830
movq %r13, %rdi
callq 0x3c48
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19ed2
pushq %rax
leaq 0x4ab7d(%rip), %rdi     # 0x64a30
callq 0x3c48
movq 0x4ab71(%rip), %rdi     # 0x64a30
andl $0x7fffff, %edi         # imm = 0x7FFFFF
orq $0x800000, %rdi         # imm = 0x800000
popq %rax
jmp 0x5ed0
movq %rsi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4a4d4(%rip), %rax     # 0x649a0
testq %rax, %rax
je 0x1a516
cmpl $0x3, 0x20(%rax)
jl 0x1a516
movq %rsi, %rbx
callq 0xeb22
testq %rbx, %rbx
je 0x1a52e
movq 0x4a5b5(%rip), %rax     # 0x64aa0
movq (%rax), %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x84c6
addq $-0x8, 0xa2ea4(%rip)    # 0xbd3a8
cmpb $0x0, (%r14)
jne 0x1a52e
movl $0x15, %edi
callq 0x58ff
jmp 0x1a52e
movl $0xb, %edi
callq 0x58ff
movq 0x4a571(%rip), %rax     # 0x64a98
movq %rax, 0x4a572(%rip)     # 0x64aa0
addq $0x48, %rsp
popq %rbx
popq %r14
retq