LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: printTextWord(long)
void printTextWord(int64_t val)
{
    std::string str = toAscii(val);
    const char *s = str.c_str();
    while (*s == ' ')
        s++;
    fputs(s, stdout);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x47ad
movq (%rbx), %rdi
decq %rdi
cmpb $0x20, 0x1(%rdi)
leaq 0x1(%rdi), %rdi
je 0x4d95
movq 0x1e1e2(%rip), %rax     # 0x22f88
movq (%rax), %rsi
callq 0x32a0
movq %rsp, %rdi
callq 0x3498
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: toText(char const*)
int64_t toText(const char * str) {
    int64_t ret;
    ret = 0;
    for (; *str; ++str)
        ret = ret << 6 | koi2text[*str & 0xFF];
    return ret;
}

// Assembly:
xorl %eax, %eax
leaq 0xb746b(%rip), %rcx     # 0xbc230
movzbl (%rdi), %edx
testq %rdx, %rdx
je 0x4dde
shlq $0x6, %rax
movsbq (%rdx,%rcx), %rdx
orq %rdx, %rax
incq %rdi
jmp 0x4dc5
retq
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: makeStringType()
TypesPtr makeStringType()
{
    if (maxSmallString >= strLen)
        return smallStringType[strLen];
    else {
        RangeT * span = new RangeT;
        ArrayT * res = new ArrayT(0, 0, CharType);

        span->size = 1;
        span->checker = 0;
        span->bits = 12;
        span->base = IntegerType;
        span->left = 1;
        span->right = strLen;

        res->size = (strLen + 5) / 6;
        if (res->size == 1)
            res->bits = strLen * 8;
        else
            res->bits = 0;
        res->base = CharType;
        res->range = span;
        res->pck = true;
        res->perWord = 6;
        res->pcksize = 8;
        return res;
    }
}

// Assembly:
movq 0x5eada(%rip), %rax     # 0x638c0
cmpq %rax, 0x5ecd3(%rip)     # 0x63ac0
jge 0x4eb0
pushq %r14
pushq %rbx
pushq %rax
pushq $0x38
popq %rdi
callq 0x390b
movq %rax, %rbx
pushq $0x1
popq %r14
movq %r14, (%rax)
movq $0x30, 0x8(%rax)
movl $0x2, 0x10(%rax)
pushq $0x40
popq %rdi
callq 0x390b
movq %rax, %rcx
movq 0x5ebce(%rip), %rsi     # 0x639f8
andq $0x0, (%rax)
movl $0x5, 0x10(%rax)
movq %r14, (%rbx)
andq $0x0, 0x20(%rbx)
movq $0xc, 0x8(%rbx)
movq 0x5eb9c(%rip), %rax     # 0x639e8
movq %rax, 0x18(%rbx)
movq %r14, 0x28(%rbx)
movq 0x5ea65(%rip), %rdi     # 0x638c0
movq %rdi, 0x30(%rbx)
leaq 0x5(%rdi), %rax
pushq $0x6
popq %r8
cqto
idivq %r8
movq %rax, (%rcx)
decq %rdi
movq 0x5ea47(%rip), %rax     # 0x638c0
shlq $0x3, %rax
xorl %edx, %edx
cmpq $0x6, %rdi
cmovbq %rax, %rdx
movq %rdx, 0x8(%rcx)
movq %rsi, 0x18(%rcx)
movq %rbx, 0x20(%rcx)
movb $0x1, 0x28(%rcx)
movq $0x6, 0x30(%rcx)
movq $0x8, 0x38(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4ebb
leaq 0x5ec19(%rip), %rcx     # 0x63ad0
movq (%rcx,%rax,8), %rcx
movq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: storeObjWord(long)
void storeObjWord(int64_t insn)
{
    objBuffer[objBufIdx] = insn;
    moduleOffset = moduleOffset + 1;
    if (objBufIdx == OBJBUF_SIZE) {
        error(49); /* errTooManyInsnsInBlock */
        objBufIdx = 1;
    } else
        objBufIdx = objBufIdx + 1;
}

// Assembly:
movq 0x5ea43(%rip), %rax     # 0x63938
leaq 0xa7324(%rip), %rcx     # 0xac220
movq %rdi, (%rcx,%rax,8)
incq 0x5e981(%rip)           # 0x63888
cmpq $0x2000, %rax           # imm = 0x2000
jne 0x4f21
pushq %rax
pushq $0x31
popq %rdi
callq 0x4f2c
pushq $0x1
popq %rax
addq $0x8, %rsp
jmp 0x4f24
incq %rax
movq %rax, 0x5ea0d(%rip)     # 0x63938
retq
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: error(long)
void error(int64_t errNo)
{
    errors = true;
    bool110z = true;
    if (((linePos != prevErrPos) and (9 >= errsInLine))
        or (errNo == 52)) {
        totalErrors = totalErrors + 1;
        errMapBase[errsInLine] = linePos;
        errsInLine = errsInLine + 1;
        prevErrPos = linePos;
        printf("Error %ld:", errNo);
        printErrMsg(errNo);
        if (60 < totalErrors) {
            putchar('\n');
            endOfLine();
            printErrMsg(53);
            skipToEnd();
        }
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb $0x1, %al
movb %al, 0x5ea3e(%rip)      # 0x63976
movb %al, 0x5ea3f(%rip)      # 0x6397d
movq 0x5e92b(%rip), %rax     # 0x63870
cmpq 0x5e92c(%rip), %rax     # 0x63878
setne %dl
movq 0x5e92a(%rip), %rcx     # 0x63880
cmpq $0xa, %rcx
setl %sil
cmpq $0x34, %rdi
je 0x4f69
andb %sil, %dl
je 0x4faf
incq 0x5e938(%rip)           # 0x638a8
leaq 0x63609(%rip), %rdx     # 0x68580
movq %rax, (%rdx,%rcx,8)
incq %rcx
movq %rcx, 0x5e8fb(%rip)     # 0x63880
movq %rax, 0x5e8ec(%rip)     # 0x63878
leaq 0x15338(%rip), %rdi     # 0x1a2cb
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3030
movq %rbx, %rdi
callq 0x4c75
cmpq $0x3d, 0x5e8fb(%rip)    # 0x638a8
jge 0x4fb1
popq %rbx
retq
pushq $0xa
popq %rdi
callq 0x3320
callq 0x59c4
pushq $0x35
popq %rdi
callq 0x4c75
callq 0x70ed
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: form1Insn(long)
void form1Insn(int64_t arg)
{
    Word Insn, opcode;
    int64_t pos;
    Insn.i = arg;
    opcode.i = Insn.i & ~077777;
    if (opcode.i == InsnTemp[UJ]) {
        if (prevOpcode == opcode.i)
            // No need for a jump after jump.
            return;
        if (putLeft and (prevOpcode == 1)) {
            pos = objBufIdx - 1;
            if (((objBuffer[pos] >> 24) & ~077777) == I13+KVJM) {
                // Chaining the call and the jump.
                int64_t addr1, addr2;
                prevOpcode = opcode.i;
                addr1 = Insn.ii & 077777;
                addr2 = (objBuffer[pos] >> 24) & 077777;
                objBuffer[pos] = (I13+KVTM+addr1) << 24 | (KUJ+addr2);
                return;
            }
        }
    };
    prevOpcode = opcode.i;
    if (putLeft) {
        leftInsn = Insn.ii << 24;
        putLeft = false;
    } else {
        putLeft = true;
        storeObjWord(leftInsn | (Insn.ii & halfWord));
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x381c
movq (%rbx), %rbx
movq %rbx, %rsi
shlq $0x17, %rsi
sarq $0x17, %rsi
andq $-0x8000, %rsi          # imm = 0x8000
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x381c
movq (%r14), %rax
shlq $0x17, %rax
sarq $0x17, %rax
cmpq 0x634c2(%rip), %rax     # 0x684d8
jne 0x5094
movq 0x5e939(%rip), %rdx     # 0x63958
cmpq %rax, %rdx
je 0x50b8
movb 0x5e946(%rip), %cl      # 0x63974
movl %ecx, %esi
xorb $0x1, %sil
cmpq $0x1, %rdx
setne %dl
orb %sil, %dl
jne 0x509a
movq 0x5e8f1(%rip), %rdx     # 0x63938
leaq 0xa71d2(%rip), %rsi     # 0xac220
movq -0x8(%rsi,%rdx,8), %rdi
movq %rdi, %r8
shrq $0x27, %r8
cmpl $0x1b9, %r8d            # imm = 0x1B9
jne 0x509a
movq %rax, 0x5e8ee(%rip)     # 0x63958
shrq $0x18, %rdi
movl $0x7fff, %eax           # imm = 0x7FFF
andq %rax, %rdi
andq %rax, %rbx
shlq $0x18, %rbx
orq %rdi, %rbx
movabsq $0xda00000c0000, %rax   # imm = 0xDA00000C0000
orq %rbx, %rax
movq %rax, -0x8(%rsi,%rdx,8)
jmp 0x50b8
movb 0x5e8da(%rip), %cl      # 0x63974
movq %rax, 0x5e8b7(%rip)     # 0x63958
testb $0x1, %cl
je 0x50c0
shlq $0x18, %rbx
movq %rbx, 0x5e987(%rip)     # 0x63a38
movb $0x0, 0x5e8bc(%rip)     # 0x63974
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movb $0x1, 0x5e8ad(%rip)     # 0x63974
andl $0xffffff, %ebx         # imm = 0xFFFFFF
orq 0x5e964(%rip), %rbx     # 0x63a38
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x4eee
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: formJump(long&)
void formJump(int64_t & arg)
{
    int64_t pos;
    bool isLeft;
    if (prevOpcode != InsnTemp[UJ]) {
        pos = getObjBufIdxPlus();
        isLeft = putLeft;
        form1Insn(jumpType + arg);
        if (putLeft == isLeft)
            pos = pos - 1;
        arg = pos;
    }
}

// Assembly:
movq 0x5e809(%rip), %rax     # 0x63958
cmpq 0x63382(%rip), %rax     # 0x684d8
je 0x51a0
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb 0x5e80e(%rip), %bpl     # 0x63974
movq 0x5e7cb(%rip), %rax     # 0x63938
leaq 0x1000(%rax), %r14
testb %bpl, %bpl
cmoveq %rax, %r14
movq (%rdi), %rdi
addq 0x5e67b(%rip), %rdi     # 0x63800
callq 0x4fcb
xorl %eax, %eax
cmpb %bpl, 0x5e7e1(%rip)     # 0x63974
sete %al
subq %rax, %r14
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: putToSymTab(long)
void putToSymTab(int64_t arg)
{
    symTab[symTabPos] = arg;
    if (symTabPos == SYMTAB_LIMIT) {
        error(50); /* errSymbolTableOverflow */
        symTabPos = 074000;
    } else
        symTabPos = symTabPos + 1;
}

// Assembly:
movq 0x5e655(%rip), %rax     # 0x63838
leaq 0x64b06(%rip), %rcx     # 0x69cf0
movq %rdi, (%rcx,%rax,8)
cmpq $0x7fff, %rax           # imm = 0x7FFF
jne 0x520a
pushq %rax
pushq $0x32
popq %rdi
callq 0x4f2c
movl $0x7800, %eax           # imm = 0x7800
addq $0x8, %rsp
jmp 0x520d
incq %rax
movq %rax, 0x5e624(%rip)     # 0x63838
retq
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: allocExtSymbol(long)
int64_t allocExtSymbol(int64_t newSym)
{
    int64_t ret = symTabPos;

    if (curVal.ii & halfWord) {
        int64_t i;
        for (i = 1; i <= longSymCnt; ++i) {
            if (curVal.ii == longSyms[i]) {
                return longSymTabBase[i];
            }
        }
        longSymCnt++;
        if (longSymCnt >= 90) {
            error(51); /* errLongSymbolOverflow */
            longSymCnt = 1;
        };
        longSymTabBase[longSymCnt] = symTabPos;
        longSyms[longSymCnt] = curVal.ii;
        newSym |= 020000000;
    } else {
        newSym |= curVal.ii;
    }
    putToSymTab(newSym);
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x5e614(%rip), %rbx     # 0x63838
movq 0x5e805(%rip), %rax     # 0x63a30
testl $0xffffff, %eax         # imm = 0xFFFFFF
je 0x525f
movq 0xa4ab7(%rip), %rcx     # 0xa9cf0
xorl %edx, %edx
testq %rcx, %rcx
movl $0x0, %esi
cmovgq %rcx, %rsi
leaq 0xa4d92(%rip), %r15     # 0xa9fe0
cmpq %rdx, %rsi
je 0x5264
cmpq 0x8(%r15,%rdx,8), %rax
je 0x52bc
incq %rdx
jmp 0x524e
orq %rax, %r14
jmp 0x52b2
leaq 0x1(%rcx), %rdx
movq %rdx, 0xa4a81(%rip)     # 0xa9cf0
movq %rbx, %rsi
cmpq $0x59, %rcx
jl 0x529c
pushq $0x33
popq %rdi
callq 0x4f2c
movq $0x1, 0xa4a65(%rip) # 0xa9cf0
movq 0x5e5a6(%rip), %rsi     # 0x63838
pushq $0x1
popq %rdx
movq 0x5e794(%rip), %rax     # 0x63a30
leaq 0xa4a5d(%rip), %rcx     # 0xa9d00
movq %rsi, (%rcx,%rdx,8)
movq %rax, (%r15,%rdx,8)
orq $0x400000, %r14         # imm = 0x400000
movq %r14, %rdi
callq 0x51dc
jmp 0x52c8
leaq 0xa4a3d(%rip), %rax     # 0xa9d00
movq 0x8(%rax,%rdx,8), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: getHelperProc(long)
int64_t getHelperProc(int64_t l3arg1z)
{
    if (helperMap[l3arg1z] == 0)  {
        curVal.ii = helperNames[l3arg1z];
        helperMap[l3arg1z] = allocExtSymbol(extSymMask);
    };
    return helperMap[l3arg1z] + (KVJM+I13);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x646f4(%rip), %r14     # 0x699d0
movq (%r14,%rdi,8), %rax
testq %rax, %rax
jne 0x5308
movq %rdi, %rbx
leaq 0x1e091(%rip), %rax     # 0x23380
movq (%rax,%rdi,8), %rax
movq %rax, 0x5e736(%rip)     # 0x63a30
movl $0x8c0000, %edi         # imm = 0x8C0000
callq 0x5215
movq %rax, (%r14,%rbx,8)
addq $0xdc8000, %rax         # imm = 0xDC8000
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: addCurValToFCST()
int64_t addCurValToFCST()
{
    int64_t ret;
    int64_t low, high, mid;
    low = 1;
    if (FcstTotal == 0) {
        ret = FcstCnt;
        FcstTotal = 1;
        constVals[1] = curVal;
        constNums[1] = FcstCnt;
        toFCST();
    } else {
        high = FcstTotal;
        do {
            mid = (low + high) / 2;
            if (curVal.m == constVals[mid].m) {
              return constNums[mid];
            }
            if (curVal.a < constVals[mid].a)
                high = mid - 1;
            else
                low = mid + 1;
        } while (low <= high);
        ret = FcstCnt;
        if (FcstTotal != MAXLIT) {
            if (curVal.a < constVals[mid].a)
                high = mid;
            else
                high = mid + 1;
            for (mid = FcstTotal; mid >= high; --mid) {
                low = mid + 1;
                constVals[low] = constVals[mid];
                constNums[low] = constNums[mid];
            }
            FcstTotal = FcstTotal + 1;
            constVals[high] = curVal;
            constNums[high] = FcstCnt;
        };
        toFCST();
    }
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x5e5eb(%rip), %rbp     # 0x63930
testq %rbp, %rbp
je 0x5400
pushq $0x1
popq %rbx
leaq 0xa4f68(%rip), %r12     # 0xaa2c0
leaq (%rbx,%rbp), %rax
cqto
pushq $0x2
popq %rcx
idivq %rcx
movq %rax, %r14
movq 0x5e6c2(%rip), %rax     # 0x63a30
xorq (%r12,%r14,8), %rax
shlq $0x10, %rax
je 0x5429
leaq (%r12,%r14,8), %r15
leaq 0x5e6a9(%rip), %rdi     # 0x63a30
movq %r15, %rsi
callq 0x12c52
leaq 0x1(%r14), %r13
testb %al, %al
cmoveq %r13, %rbx
leaq -0x1(%r14), %rax
cmovneq %rax, %rbp
cmpq %rbp, %rbx
jle 0x5358
movq 0x5e483(%rip), %rbx     # 0x63830
cmpq $0x1f4, 0x5e578(%rip) # imm = 0x1F4
je 0x5456
leaq 0x5e66b(%rip), %rdi     # 0x63a30
movq %r15, %rsi
callq 0x12c52
testb %al, %al
cmovneq %r14, %r13
movq 0x5e556(%rip), %rcx     # 0x63930
leaq 0xa5e8f(%rip), %rax     # 0xab270
movq %rcx, %rdx
cmpq %r13, %rdx
jl 0x5436
movq (%r12,%rdx,8), %rsi
movq %rsi, 0x8(%r12,%rdx,8)
movq (%rax,%rdx,8), %rsi
movq %rsi, 0x8(%rax,%rdx,8)
decq %rdx
jmp 0x53e4
movq 0x5e429(%rip), %rbx     # 0x63830
movq $0x1, 0x5e51e(%rip) # 0x63930
movq 0x5e617(%rip), %rax     # 0x63a30
movq %rax, 0xa4ea8(%rip)     # 0xaa2c8
movq %rbx, 0xa5e51(%rip)     # 0xab278
jmp 0x5456
leaq 0xa5e40(%rip), %rax     # 0xab270
movq (%rax,%r14,8), %rbx
jmp 0x545b
incq %rcx
movq %rcx, 0x5e4f0(%rip)     # 0x63930
movq 0x5e5e9(%rip), %rcx     # 0x63a30
movq %rcx, (%r12,%r13,8)
movq 0x5e3de(%rip), %rcx     # 0x63830
movq %rcx, (%rax,%r13,8)
callq 0x5316
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: allocSymtab(long)
int64_t allocSymtab(int64_t newSym)
{
    int64_t ret = symTabPos;

    if (symTabCnt == 0) {
        symTabCnt = 1;
        symTabArray[1] = newSym;
        symTabIndex[1] = symTabPos;
    } else {
        int64_t low = 1;
        int64_t high = symTabCnt;
        int64_t mid;

        do {
            mid = (low + high) / 2;
            if (newSym == symTabArray[mid]) {
                return symTabIndex[mid];
            }
            if (newSym < symTabArray[mid])
                high = mid - 1;
            else
                low = mid + 1;
        } while (high >= low);

        if (symTabCnt >= SYMTAB_MAX) {
            error(50); /* errSymbolTableOverflow */
        } else {
            if (newSym < symTabArray[mid])
                high = mid;
            else
                high = mid + 1;
            for (mid = symTabCnt; mid >= high; --mid) {
                low = mid + 1;
                symTabArray[low] = symTabArray[mid];
                symTabIndex[low] = symTabIndex[mid];
            }
            symTabCnt = symTabCnt + 1;
            symTabArray[high] = newSym;
            symTabIndex[high] = symTabPos;
        }
    }
    putToSymTab(newSym);
    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x5e3bd(%rip), %rbx     # 0x63838
movq 0x5e686(%rip), %rcx     # 0x63b08
testq %rcx, %rcx
je 0x54d5
pushq $0x1
popq %rdi
pushq $0x2
popq %r8
leaq 0x5e67b(%rip), %rsi     # 0x63b10
movq %rcx, %r9
leaq (%r9,%rdi), %rax
cqto
idivq %r8
movq (%rsi,%rax,8), %r10
cmpq %r14, %r10
je 0x54f0
leaq 0x1(%rax), %rdx
cmpq %r14, %r10
cmovleq %rdx, %rdi
leaq -0x1(%rax), %r11
cmovgq %r11, %r9
cmpq %rdi, %r9
jge 0x5498
cmpq $0x3e8, %rcx            # imm = 0x3E8
jl 0x54fd
pushq $0x32
popq %rdi
callq 0x4f2c
jmp 0x553c
movq $0x1, 0x5e628(%rip) # 0x63b08
movq %r14, 0x5e631(%rip)     # 0x63b18
movq %rbx, 0x6057a(%rip)     # 0x65a68
jmp 0x553c
leaq 0x60569(%rip), %rcx     # 0x65a60
movq (%rcx,%rax,8), %rbx
jmp 0x5544
cmpq %r14, %r10
cmovgq %rax, %rdx
leaq 0x60555(%rip), %rax     # 0x65a60
movq %rcx, %rdi
cmpq %rdx, %rdi
jl 0x552a
movq (%rsi,%rdi,8), %r8
movq %r8, 0x8(%rsi,%rdi,8)
movq (%rax,%rdi,8), %r8
movq %r8, 0x8(%rax,%rdi,8)
decq %rdi
jmp 0x550e
incq %rcx
movq %rcx, 0x5e5d4(%rip)     # 0x63b08
movq %r14, (%rsi,%rdx,8)
movq %rbx, (%rax,%rdx,8)
movq %r14, %rdi
callq 0x51dc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: getFCSToffset()
int64_t getFCSToffset()
{
    int64_t ret;
    int64_t offset;
    ret = addCurValToFCST();
    offset = ret;
    if (offset < 2048) {
        /* empty */
    } else if (offset >= 4096)
        error(204);
    else {
        ret = allocSymtab(offset + 040000000) - 070000;
    }
    return ret;
}

// Assembly:
pushq %rbx
callq 0x5333
movq %rax, %rbx
cmpq $0x800, %rax            # imm = 0x800
jl 0x558e
cmpq $0x1000, %rbx           # imm = 0x1000
jb 0x5575
movl $0xcc, %edi
callq 0x4f2c
jmp 0x558e
orq $0x800000, %rbx         # imm = 0x800000
movq %rbx, %rdi
callq 0x546d
movq %rax, %rbx
addq $-0x7000, %rbx          # imm = 0x9000
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: minel(Bitset)
int64_t minel(Bitset b)
{
    if (!b.val) return -1;
    int64_t ret = 0;
    uint64_t t = b.val;
    while (((t >> 47) & 1) == 0) {
        ret++;
        t <<= 1;
    }
    return ret;
}

// Assembly:
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq %rdi, %rcx
je 0x55b3
xorl %eax, %eax
btq $0x2f, %rcx
jb 0x55b6
incq %rax
addq %rcx, %rcx
jmp 0x55a4
pushq $-0x1
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: card(Bitset)
int64_t card(Bitset b)
{
    int64_t val = b.val, ret = 0;
    while (val) {
        ++ret;
        val &= val-1;
    }
    return ret;
}

// Assembly:
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq %rdi, %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x55d7
incq %rax
leaq -0x1(%rcx), %rdx
andq %rdx, %rcx
jmp 0x55c6
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
pushq $0x38
popq %rdi
callq 0x390b
movq %rax, %r15
movq $0x1, (%rax)
movq $0x30, 0x8(%rax)
movl $0x2, 0x10(%rax)
movq (%rbx), %rax
movq %rax, 0x18(%r15)
andq $0x0, 0x20(%r15)
movq %r12, 0x28(%r15)
movq %r14, 0x30(%r15)
testq %r12, %r12
js 0x568b
movq %r14, %rdi
callq 0x5616
movq %rax, 0x8(%r15)
movq %r15, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e38b(%rip), %rbx     # 0x63a30
movq %rbx, %rdi
callq 0x381c
movq 0x5e37c(%rip), %rsi     # 0x63a30
andl $0x7fff, %esi           # imm = 0x7FFF
movq %rbx, %rdi
callq 0x381c
movq 0x5e367(%rip), %rdi     # 0x63a30
movq %rdi, %rax
shlq $0x17, %rax
sarq $0x17, %rax
cmpq $0x4001, %rax           # imm = 0x4001
jge 0x56de
popq %rbx
retq
andl $0x7fffff, %edi         # imm = 0x7FFFFF
orq $0x800000, %rdi         # imm = 0x800000
popq %rbx
jmp 0x546d
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0xffffff, %r13d        # imm = 0xFFFFFF
leaq 0x1493d(%rip), %r15     # 0x1a2a1
xorl %r12d, %r12d
leaq (%r14,%r12), %rbp
cmpq %rbx, %rbp
ja 0x59ae
testq %r12, %r12
je 0x5983
testb $0x18, %r12b
jne 0x5983
pushq $0xa
popq %rdi
callq 0x3320
movl 0x3(%rbp), %edi
callq 0x58f6
pushq $0x20
popq %rdi
callq 0x3320
movl (%rbp), %edi
andl %r13d, %edi
callq 0x58f6
movq %r15, %rdi
xorl %eax, %eax
callq 0x3030
addq $0x8, %r12
jmp 0x5967
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3320
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x6285a(%rip), %rbx     # 0x684f0
movq 0x1db13(%rip), %rdi     # 0x237b0
callq 0x3370
testl %eax, %eax
jne 0x5ce7
movq 0x5dbc3(%rip), %rax     # 0x63870
cmpq $0x50, %rax
jg 0x5ce7
movb 0x1daff(%rip), %cl      # 0x237b8
cmpb $0xa, %cl
je 0x5ce7
leaq 0x1(%rax), %rdx
movq %rdx, 0x5dba7(%rip)     # 0x63870
movb %cl, 0x1(%rax,%rbx)
cmpq $0x51, %rdx
je 0x5c96
movq 0x1dad6(%rip), %rdi     # 0x237b0
callq 0x5ced
movb %al, 0x1dad3(%rip)      # 0x237b8
jmp 0x5c96
popq %rbx
jmp 0x59c4
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1d871(%rip), %al      # 0x237b8
leaq 0x625a2(%rip), %rbx     # 0x684f0
cmpb $0xa, %al
jne 0x5f58
movb $0x1, %al
movb $0xa, %cl
jmp 0x5f6f
movq 0x1d851(%rip), %rdi     # 0x237b0
callq 0x3370
testl %eax, %eax
setne %al
movb 0x1d849(%rip), %cl      # 0x237b8
movb %al, 0x5d9fc(%rip)      # 0x63971
movb %cl, 0x5d99e(%rip)      # 0x63919
movq 0x1d82e(%rip), %rdi     # 0x237b0
callq 0x5ced
movb %al, 0x1d82b(%rip)      # 0x237b8
movq 0x5d8dc(%rip), %rcx     # 0x63870
leaq 0x1(%rcx), %rdx
movq %rdx, 0x5d8d1(%rip)     # 0x63870
movb 0x5d974(%rip), %dl      # 0x63919
movb %dl, 0x1(%rcx,%rbx)
cmpq %rcx, 0x5d8b8(%rip)     # 0x63868
jg 0x5fbb
testb $0x1, 0x5d9b8(%rip)     # 0x63971
je 0x5f4e
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
callq 0x5f40
xorl %ebx, %ebx
movzbl 0x5d947(%rip), %eax     # 0x63919
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x5ff7
imulq $0xa, %rbx, %rcx
leaq (%rcx,%rax), %rbx
addq $-0x30, %rbx
callq 0x5f40
movq 0xb63a6(%rip), %rax     # 0xbc398
movb $0x0, (%rax)
jmp 0x5fcb
cmpq %r14, %rbx
jle 0x6006
movq 0xb6395(%rip), %rax     # 0xbc398
movb $0x1, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5f40
movzbl 0x5d8f8(%rip), %eax     # 0x63919
cmpl $0x2d, %eax
je 0x602b
cmpl $0x2b, %eax
jne 0x603a
cmpb $0x2b, %al
sete (%rbx)
movq 0xb6361(%rip), %rax     # 0xbc398
movb $0x0, (%rax)
popq %rbx
jmp 0x5f40
// File: /workspace/github_cpp_makefile_star2_O2/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 0x62fd
andb $0x5f, %al
orb $0x20, %al
retq
testb %al, %al
js 0x6312
movl %eax, %ecx
xorb $0x20, %cl
cmpb $0x60, %al
movzbl %al, %edx
movzbl %cl, %eax
cmovbl %edx, %eax
retq
movb $0x20, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5c720(%rip), %eax     # 0x6381c
leaq 0x178(%rsp), %rbx
movl %eax, %ebp
movl %ebp, %ecx
movl %eax, %ebp
xorl $0x27, %ecx
xorl $0x10, %eax
orl %ecx, %eax
je 0x7124
movq %rbx, %rdi
callq 0x6316
movl 0x5c6fa(%rip), %eax     # 0x6381c
jmp 0x7106
movb 0x5c7ef(%rip), %al      # 0x63919
andb $-0x21, %al
cmpb $0x44, %al
jne 0x7146
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x6316
cmpl $0x27, 0x5c6d8(%rip)    # 0x6381c
jne 0x7135
pushq $0x4
popq %rdi
callq 0x3110
movl $0x270f, (%rax)         # imm = 0x270F
movq 0x1be25(%rip), %rsi     # 0x22f80
movq %rax, %rdi
xorl %edx, %edx
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x5c669(%rip)     # 0x6381c
jne 0x71c6
movq %rsp, %rdi
callq 0x6316
addq $0x170, %rsp            # imm = 0x170
popq %rbx
retq
movq %rsi, %rbx
callq 0x5c72
movq %rbx, %rdi
addq $0x170, %rsp            # imm = 0x170
popq %rbx
jmp 0x7165
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7381
cmpq %rsi, %rax
jne 0x73af
movq 0x10(%rsi), %rax
movq %rax, (%rdi)
retq
movq (%rsi), %rax
movl $0xffff, %ecx           # imm = 0xFFFF
cqto
idivq %rcx
movq %rdx, %rax
movl $0x80, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x61e2d(%rip), %rdx     # 0x691d0
movq (%rdx,%rcx,8), %rax
movq %rax, (%rdi)
cmpq %rsi, %rax
je 0x73ce
cmpq %rsi, %rax
je 0x73c5
movq %rax, %rdx
testq %rax, %rax
je 0x73cd
movq 0x10(%rdx), %rax
movq %rdx, %rcx
jmp 0x73af
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rcx)
retq
movq 0x10(%rax), %rax
movq %rax, (%rdx,%rcx,8)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7475
cmpq %rbx, %r14
sete %al
jmp 0x74ba
movq 0x18(%r14), %rsi
movq 0x18(%rbx), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x74d4
cmpb $0x1, (%r15)
jne 0x74b0
movq %r14, %rdi
callq 0x12d6e
movq (%rax), %r14
movq %rbx, %rdi
callq 0x12d6e
movq (%rax), %rsi
movq %r14, %rdi
callq 0x744e
jmp 0x74b2
xorl %eax, %eax
addq $-0x8, 0xb4eee(%rip)    # 0xbc3a8
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
addq $-0x8, 0xb4edc(%rip)    # 0xbc3a8
movq %rax, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x12e9c
movq (%rax), %rdi
xorl %r14d, %r14d
testq %rdi, %rdi
je 0x787f
cmpq %rbx, %rdi
je 0x787f
incq %r14
callq 0x12d6e
movq (%rax), %rdi
jmp 0x786d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: makeNameWithStars(bool)
int64_t makeNameWithStars(bool isProc)
{
    bool wantBoth = not isProc and (extSymAdornment == 0);
    if (curVal.m * BitRange(0, 5) == Bits()) {
        curVal.m = curVal.m << 6;
        if (wantBoth or (extSymAdornment == 1))
            curVal.m = curVal.m + Bits(44, 46);
        while (curVal.m * BitRange(0, 11) == Bits()) {
            curVal.m = curVal.m << 6;
        }
        if (curVal.m * BitRange(0, 5) == Bits()) {
            if (wantBoth)
                curVal.m = Bits(2, 4) + curVal.m;
            else {
                curVal.m = curVal.m << 6;
            }
        }
    }
    return curVal.ii;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movabsq $0xffffffffffc0, %r15   # imm = 0xFFFFFFFFFFC0
movq 0x5c220(%rip), %r13     # 0x63ac8
testq %r13, %r13
sete %bpl
pushq $0x5
popq %rsi
xorl %edi, %edi
callq 0x37ec
movq 0x5c170(%rip), %r14     # 0x63a30
leaq 0x3f(%r15), %r12
andq %rax, %r12
testq %r14, %r12
jne 0x793c
notb %bl
andb %bpl, %bl
shlq $0x6, %r14
andq %r15, %r14
leaq 0xa(%r14), %rax
cmpq $0x1, %r13
cmoveq %rax, %r14
testb %bl, %bl
cmovneq %rax, %r14
pushq $0xb
popq %rsi
xorl %edi, %edi
callq 0x37ec
leaq 0x3f(%r15), %rcx
movq %r14, %rdx
andq %rcx, %rdx
testq %rax, %rdx
jne 0x790c
shlq $0x6, %r14
andq %r15, %r14
jmp 0x78f8
movq %r14, 0x5c11d(%rip)     # 0x63a30
testq %r14, %r12
jne 0x793c
movabsq $0x280000000000, %rax   # imm = 0x280000000000
orq %r14, %rax
shlq $0x6, %r14
andq %r15, %r14
testb %bl, %bl
cmoveq %r14, %rax
movq %rax, 0x5c0f7(%rip)     # 0x63a30
movq %rax, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x20
popq %rdi
callq 0x390b
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rbx, 0x10(%rax)
andq $0x0, 0x18(%rax)
movq 0x5c138(%rip), %rcx     # 0x63aa8
movq (%rcx), %rdx
testq %rdx, %rdx
je 0x7984
movq %rax, (%rdx)
movq 0x5c126(%rip), %rcx     # 0x63aa8
jmp 0x7988
movq %rax, 0x8(%rcx)
movq %rax, (%rcx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x20
popq %rdi
callq 0x390b
movq 0x5c0ef(%rip), %rcx     # 0x63aa8
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
andq $0x0, 0x8(%rax)
movq %rbx, 0x10(%rax)
andq $0x0, 0x18(%rax)
movq 0x5c0d3(%rip), %rcx     # 0x63aa8
xorl %edx, %edx
cmpq %rdx, 0x8(%rcx)
jne 0x79e7
movq %rax, (%rcx)
movq 0x5c0c1(%rip), %rcx     # 0x63aa8
movq %rax, 0x8(%rcx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x6b8, %rsp            # imm = 0x6B8
movl %edi, %ebx
movq 0xb4437(%rip), %rax     # 0xbc378
movq -0x8(%rax), %r14
movq 0x5b94c(%rip), %rdi     # 0x63898
movq 0x90(%r14), %rsi
callq 0x798d
pushq $0x20
popq %rdi
callq 0x390b
movq %rax, 0x5bb39(%rip)     # 0x63aa0
movq 0x5bb3a(%rip), %rcx     # 0x63aa8
movq 0x10(%rcx), %rcx
movq %rcx, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x12ed0
movq 0x5bb1a(%rip), %rax     # 0x63aa0
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 0x7faf
movq %rax, 0x98(%r14)
addq $0x6b8, %rsp            # imm = 0x6B8
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: allocGlobalObject(IdentRec*)
int64_t allocGlobalObject(IdentRecPtr l6arg1z)
{
    if (l6arg1z->pos() == 0) {
        if (l6arg1z->flags() * Bits(20, 21) != Bits()) {
            curVal.ii = l6arg1z->id;
            curVal.ii = makeNameWithStars(true);
            l6arg1z->pos() = allocExtSymbol(extSymMask);
        } else {
            l6arg1z->pos() = symTabPos;
            putToSymTab(0);
        }
    }
    return l6arg1z->pos();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x13eb6
cmpq $0x0, (%rax)
jne 0x883a
movq %rbx, %rdi
callq 0x13ee4
testb $0xc, 0x3(%rax)
je 0x8821
movq (%rbx), %rax
movq %rax, 0x5b238(%rip)     # 0x63a30
pushq $0x1
popq %rdi
callq 0x788a
movq %rax, 0x5b229(%rip)     # 0x63a30
movl $0x8c0000, %edi         # imm = 0x8C0000
callq 0x5215
movq %rax, %r14
movq %rbx, %rdi
callq 0x13eb6
movq %r14, (%rax)
jmp 0x883a
movq 0x5b010(%rip), %r14     # 0x63838
movq %rbx, %rdi
callq 0x13eb6
movq %r14, (%rax)
xorl %edi, %edi
callq 0x51dc
movq %rbx, %rdi
callq 0x13eb6
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb3175(%rip), %rax     # 0xbc3d8
movq -0x8(%rax), %r14
pushq $0x58
popq %rdi
callq 0x390b
movq %rax, 0x5a832(%rip)     # 0x63aa8
andq $0x0, (%rax)
movq 0x5a827(%rip), %rax     # 0x63aa8
andq $0x0, 0x8(%rax)
movq (%r14), %rcx
movq (%rcx), %rcx
movq %rcx, 0x10(%rax)
andq $0x0, 0x18(%rax)
movl %ebx, 0x20(%rax)
testl %ebx, %ebx
je 0x92b7
andl $0x0, 0x40(%rax)
movq $0x12, 0x38(%rax)
pushq $0x30
popq %rcx
pushq $0x10
popq %rsi
leaq 0x5a5e3(%rip), %rdx     # 0x63898
jmp 0x92c4
movq (%r14), %rdx
addq $0x10, %rdx
pushq $0x38
popq %rcx
pushq $0x18
popq %rsi
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_O2/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:
cmpq $0x0, 0x28(%rdi)
je 0xc612
retq
pushq %rbx
movq 0x57216(%rip), %rax     # 0x63830
movq %rax, 0x28(%rdi)
movq 0x18(%rdi), %rbx
testq %rbx, %rbx
je 0xc643
movq (%rbx), %rax
movq %rax, 0x573ff(%rip)     # 0x63a30
movq %rbx, %rdi
callq 0x12d6e
movq (%rax), %rbx
callq 0x5316
jmp 0xc622
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x20
popq %rdi
callq 0x390b
movq 0x567fd(%rip), %rcx     # 0x639f0
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_O2/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 0x567f1(%rip), %rdx     # 0x63a08
movq 0x567d2(%rip), %rax     # 0x639f0
cmpq %rax, %rdx
je 0xd255
cmpq %rax, 0x567e6(%rip)     # 0x63a10
jne 0xd28b
movq 0x567b5(%rip), %rsi     # 0x639e8
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x74d4
movb (%rbx), %al
addq $-0x8, 0xaf160(%rip)    # 0xbc3a8
cmpb $0x1, %al
jne 0xd28b
leaq 0x5684d(%rip), %rbx     # 0x63aa0
jmp 0xd27f
movq %rdi, %rbx
movq 0x56789(%rip), %rsi     # 0x639e8
movq 0x567aa(%rip), %rdx     # 0x63a10
movq %rsp, %r14
movq %r14, %rdi
callq 0x74d4
addq $-0x8, 0xaf12f(%rip)    # 0xbc3a8
cmpb $0x0, (%r14)
je 0xd28b
movq %rbx, %rdi
callq 0xd1e0
movb $0x1, %al
jmp 0xd28d
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
leaq 0x58(%rsp), %r14
movq %rbx, %rdi
callq 0xe7dc
addq $-0x8, 0xadcf4(%rip)    # 0xbc428
cmpl $0xf, 0x550e1(%rip)     # 0x6381c
jne 0xe747
movq %r14, %rdi
callq 0x6316
jmp 0xe724
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xadcc3(%rip), %rax     # 0xbc428
movq -0x8(%rax), %r14
callq 0x5107
callq 0xd048
andq $0x0, 0x5508d(%rip)     # 0x63808
movq 0x5531e(%rip), %rax     # 0x63aa0
movq (%rax), %rax
cmpq 0x5524c(%rip), %rax     # 0x639d8
je 0xe797
xorl %edi, %edi
callq 0x4f2c
jmp 0xe7ac
leaq 0x60(%rsp), %rdi
pushq $0xf
popq %rsi
callq 0xaa9a
addq $-0x8, 0xadc14(%rip)    # 0xbc3c0
movq 0x55055(%rip), %rax     # 0x63808
movq %rax, 0x40(%r14)
movl %ebx, %edi
callq 0x7429
leaq 0x8(%rsp), %rdi
callq 0xe7dc
addq $-0x8, 0xadc58(%rip)    # 0xbc428
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/besm6[P]pascal-re/pascompl.cc
// Function: outputObjFile()
void outputObjFile()
{
    int64_t idx;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x51a1
movq 0x54853(%rip), %rax     # 0x63938
decq %rax
movq %rax, 0x54849(%rip)     # 0x63938
pushq $0x1
popq %r15
leaq 0x9d12e(%rip), %rbx     # 0xac228
leaq 0xad247(%rip), %r14     # 0xbc348
cmpq %rax, %r15
jg 0xf121
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12c32
incq %r15
movq 0x5481d(%rip), %rax     # 0x63938
addq $0x8, %rbx
jmp 0xf101
movq 0x54760(%rip), %rax     # 0x63888
movq %rax, 0x54761(%rip)     # 0x63890
andq $0x0, 0x54821(%rip)     # 0x63958
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
andq $0x0, -0x8(%r12)
movq %rdi, %rbx
movb $0x0, (%r12)
cmpl $0x2, 0x20(%rsi)
jne 0x12b4b
movl %edx, %ebp
movq (%r14), %rsi
leaq 0x48(%rsp), %rdi
callq 0x47ad
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %r15
movq %r15, %rsi
callq 0x32f0
movq %r15, %rdi
callq 0x3498
testb %bpl, %bpl
je 0x12b2c
movq 0x28(%r14), %r15
movq 0x30(%r14), %rbp
movq 0x38(%r14), %rdi
callq 0x3a1d
movq %rax, %r13
movq 0x40(%r14), %rdi
callq 0x3a1d
movups 0x48(%r14), %xmm0
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq 0x58(%r14), %rcx
movq %rcx, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x7a71(%rip), %rsi      # 0x1a564
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 0x12bd8
movq 0x20(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x3450
movq 0x20(%rsp), %rdi
callq 0x32d0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x28(%rsp), %rcx
cmpq %r12, %rcx
je 0x12b9b
movq %rcx, (%rbx)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x12ba3
movq (%r14), %rsi
leaq 0x48(%rsp), %rdi
callq 0x47ad
leaq 0x28(%rsp), %r14
leaq 0x48(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x32f0
movq %r15, %rdi
callq 0x3498
pushq $0x20
popq %rsi
pushq $-0x1
popq %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x3480
leaq 0x1(%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x3260
jmp 0x12bbc
movups (%r12), %xmm0
movups %xmm0, (%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r12, 0x28(%rsp)
andq $0x0, 0x30(%rsp)
movb $0x0, 0x38(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x3498
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7024(%rip), %rdi      # 0x19c03
callq 0x31d0
jmp 0x12b2c
jmp 0x12bed
jmp 0x12bed
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3498
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3430
pushq $0x28
popq %rdi
callq 0x3350
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_O2/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), %r15
testq %r15, %r15
jne 0x13c07
movq %rsi, %rbx
movq 0x28(%rsi), %rsi
leaq 0x4febc(%rip), %rdi     # 0x63a30
callq 0x381c
movq 0x30(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x381c
movq 0x18(%rbx), %rax
movq (%r14), %r14
cmpq 0x4fe50(%rip), %rax     # 0x639e8
je 0x13bc6
pushq $0x7
popq %rdi
pushq $0x2f
popq %rsi
callq 0x37ec
movabsq $-0x1000000000000, %rcx # imm = 0xFFFF000000000000
orq %rcx, %r14
orq 0x4fe77(%rip), %rcx     # 0x63a30
andq %rax, %rcx
movq %rcx, 0x4fe6d(%rip)     # 0x63a30
andq %rax, %r14
andq $0x0, 0x4fd8a(%rip)     # 0x63958
movl $0xc0005, %edi          # imm = 0xC0005
addq 0x4fcae(%rip), %rdi     # 0x63888
callq 0x51c4
movq 0x4fca2(%rip), %r15     # 0x63888
movq %r15, 0x20(%rbx)
shlq $0x17, %r14
sarq $0x17, %r14
pushq $0x1
popq %rdi
movq %r14, %rsi
callq 0x56f1
movl $0xdc0000, %edi         # imm = 0xDC0000
callq 0x51c4
callq 0x79ed
movl $0xea0000, %edi         # imm = 0xEA0000
addq 0x4fc98(%rip), %rdi     # 0x638b0
callq 0x794e
addq $0xdc8000, %r15         # imm = 0xDC8000
movq %r15, %rdi
callq 0x794e
movq 0x4fe75(%rip), %rax     # 0x63aa8
movq (%rax), %rax
movq $0x1, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq