LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: besm6[P]pascal-re/pascompl.cc
// Function: BitRange(long, long)
Bitset BitRange(int64_t bit1, int64_t bit2)
{
    Bitset ret;
    ret.val = 0;
    for (; bit1 <= bit2; ++bit1)
        ret = ret + Bits(bit1);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movabsq $-0x1000000000000, %rax # imm = 0xFFFF000000000000
andq -0x8(%rbp), %rax
orq $0x0, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jg 0x4ac4
movq -0x10(%rbp), %rdi
callq 0x48e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x1db20
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4a86
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: besm6[P]pascal-re/pascompl.cc
// Function: Integer::operator=(long)
int64_t Integer::operator=(int64_t i)
{
    val = i;
    if (exp != 0 && exp != 127 && exp != 104)
        fprintf(stderr, "Data corruption!\n");
    exp = 104;
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq (%rax), %rcx
movabsq $0xffffffffffff, %rsi   # imm = 0xFFFFFFFFFFFF
andq %rsi, %rdx
movabsq $-0x1000000000000, %rsi # imm = 0xFFFF000000000000
andq %rsi, %rcx
orq %rdx, %rcx
movq %rcx, (%rax)
movq (%rax), %rax
shrq $0x29, %rax
andq $0x7f, %rax
cmpl $0x0, %eax
je 0x4b5f
movq -0x18(%rbp), %rax
movq (%rax), %rax
shrq $0x29, %rax
andq $0x7f, %rax
cmpl $0x7f, %eax
je 0x4b5f
movq -0x18(%rbp), %rax
movq (%rax), %rax
shrq $0x29, %rax
andq $0x7f, %rax
cmpl $0x68, %eax
je 0x4b5f
movq 0x3a48a(%rip), %rax     # 0x3efd8
movq (%rax), %rdi
leaq 0x2cf66(%rip), %rsi     # 0x31abe
movb $0x0, %al
callq 0x4430
movq -0x18(%rbp), %rax
movabsq $-0xfe0000000001, %rcx  # imm = 0xFFFF01FFFFFFFFFF
andq (%rax), %rcx
movabsq $0xd00000000000, %rdx   # imm = 0xD00000000000
orq %rdx, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: besm6_alloc(unsigned long)
void * besm6_alloc(size_t s)
{
    s = (s + 7) & ~7;
    s /= sizeof(int64_t);
    if (avail + s > 32768) {
        fprintf(stderr, "Out of memory: avail = %ld, wants %lu words\n", avail, s);
        throw std::bad_alloc();
    }
    avail += s;
    return heap + avail - s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x7, %rax
andq $-0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq 0x3a651(%rip), %rax     # 0x3f2e0
addq -0x8(%rbp), %rax
cmpq $0x8000, %rax           # imm = 0x8000
jbe 0x4ceb
movq 0x3a336(%rip), %rax     # 0x3efd8
movq (%rax), %rdi
movq 0x3a634(%rip), %rdx     # 0x3f2e0
movq -0x8(%rbp), %rcx
leaq 0x2ce19(%rip), %rsi     # 0x31ad0
movb $0x0, %al
callq 0x4430
movl $0x8, %edi
callq 0x4130
movq %rax, %rdi
movq %rdi, -0x10(%rbp)
callq 0x1dbd0
movq -0x10(%rbp), %rdi
movq 0x3a2f1(%rip), %rsi     # 0x3efd0
movq 0x3a2c2(%rip), %rdx     # 0x3efa8
callq 0x44b0
movq -0x8(%rbp), %rax
addq 0x3a5ea(%rip), %rax     # 0x3f2e0
movq %rax, 0x3a5e3(%rip)     # 0x3f2e0
movq 0x3a5dc(%rip), %rcx     # 0x3f2e0
leaq 0x3b175(%rip), %rax     # 0x3fe80
shlq $0x3, %rcx
addq %rcx, %rax
xorl %ecx, %ecx
subq -0x8(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: rollup(void*)
void rollup(void * p)
{
    if (p < heap || p > heap + avail) {
        fprintf(stderr, "Cannot rollup from %p to %p\n", (void*)(heap + avail), p);
        exit(1);
    }
    avail = reinterpret_cast<int64_t*>(p) - heap;
    if (heap + avail != p) {
        fprintf(stderr, "Cannot rollup to unaligned pointer %p\n", p);
        exit(1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x3b13d(%rip), %rax     # 0x3fe80
cmpq %rax, -0x8(%rbp)
jb 0x4d67
movq -0x8(%rbp), %rax
movq 0x3a58c(%rip), %rdx     # 0x3f2e0
leaq 0x3b125(%rip), %rcx     # 0x3fe80
shlq $0x3, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jbe 0x4da2
movq 0x3a26a(%rip), %rax     # 0x3efd8
movq (%rax), %rdi
movq 0x3a568(%rip), %rax     # 0x3f2e0
leaq 0x3b101(%rip), %rdx     # 0x3fe80
shlq $0x3, %rax
addq %rax, %rdx
movq -0x8(%rbp), %rcx
leaq 0x2cd6c(%rip), %rsi     # 0x31afd
movb $0x0, %al
callq 0x4430
movl $0x1, %edi
callq 0x43a0
movq -0x8(%rbp), %rax
leaq 0x3b0d3(%rip), %rcx     # 0x3fe80
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, 0x3a525(%rip)     # 0x3f2e0
movq 0x3a51e(%rip), %rcx     # 0x3f2e0
leaq 0x3b0b7(%rip), %rax     # 0x3fe80
shlq $0x3, %rcx
addq %rcx, %rax
cmpq -0x8(%rbp), %rax
je 0x4dfc
movq 0x3a1fb(%rip), %rax     # 0x3efd8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x2cd2f(%rip), %rsi     # 0x31b1a
movb $0x0, %al
callq 0x4430
movl $0x1, %edi
callq 0x43a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: ptr(long)
void * ptr(int64_t x)
{
    if (x == 074000) return NULL;
    if (x < 0 || x >= avail) {
        fprintf(stderr, "Cannot convert %ld to a pointer, avail = %ld\n", x, avail);
        exit(1);
    }
    return heap + x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x7800, -0x10(%rbp)    # imm = 0x7800
jne 0x4e30
movq $0x0, -0x8(%rbp)
jmp 0x4e87
cmpq $0x0, -0x10(%rbp)
jl 0x4e44
movq -0x10(%rbp), %rax
cmpq 0x3a49e(%rip), %rax     # 0x3f2e0
jl 0x4e71
movq 0x3a18d(%rip), %rax     # 0x3efd8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq 0x3a487(%rip), %rcx     # 0x3f2e0
leaq 0x2cce1(%rip), %rsi     # 0x31b41
movb $0x0, %al
callq 0x4430
movl $0x1, %edi
callq 0x43a0
movq -0x10(%rbp), %rcx
leaq 0x3b004(%rip), %rax     # 0x3fe80
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: ord(void*)
int64_t ord(void * p)
{
    int64_t ret = reinterpret_cast<int64_t>(p);
    if (p == NULL) return 074000;
    if (ret < avail || ret <= 100) return ret;
    if (p < heap || p >= heap + avail) {
        fprintf(stderr, "Invalid pointer to integer conversion, %p is outside of valid heap range %p-%p\n",
                p, (void*)heap, (void*)(heap + avail));
        exit(1);
    }
    if (heap + (reinterpret_cast<int64_t*>(p) - heap) != p) {
        fprintf(stderr, "Unaligned pointer to integer conversion: %p\n", p);
        exit(1);
    }
    return reinterpret_cast<int64_t*>(p) - heap;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4ec8
movq $0x7800, -0x8(%rbp)     # imm = 0x7800
jmp 0x4fb8
movq -0x18(%rbp), %rax
cmpq 0x3a40d(%rip), %rax     # 0x3f2e0
jl 0x4edc
cmpq $0x64, -0x18(%rbp)
jg 0x4ee9
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4fb8
leaq 0x3af90(%rip), %rax     # 0x3fe80
cmpq %rax, -0x10(%rbp)
jb 0x4f14
movq -0x10(%rbp), %rax
movq 0x3a3df(%rip), %rdx     # 0x3f2e0
leaq 0x3af78(%rip), %rcx     # 0x3fe80
shlq $0x3, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jb 0x4f56
movq 0x3a0bd(%rip), %rax     # 0x3efd8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq 0x3a3b7(%rip), %rax     # 0x3f2e0
leaq 0x3af50(%rip), %r8      # 0x3fe80
shlq $0x3, %rax
addq %rax, %r8
leaq 0x2cc31(%rip), %rsi     # 0x31b6f
leaq 0x3af3b(%rip), %rcx     # 0x3fe80
movb $0x0, %al
callq 0x4430
movl $0x1, %edi
callq 0x43a0
movq -0x10(%rbp), %rcx
leaq 0x3af1f(%rip), %rax     # 0x3fe80
subq %rax, %rcx
sarq $0x3, %rcx
leaq 0x3af11(%rip), %rax     # 0x3fe80
shlq $0x3, %rcx
addq %rcx, %rax
cmpq -0x10(%rbp), %rax
je 0x4fa2
movq 0x3a055(%rip), %rax     # 0x3efd8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x2cc2e(%rip), %rsi     # 0x31bbf
movb $0x0, %al
callq 0x4430
movl $0x1, %edi
callq 0x43a0
movq -0x10(%rbp), %rax
leaq 0x3aed3(%rip), %rcx     # 0x3fe80
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: Alfa::print[abi:cxx11]() const
std::string Alfa::print() const
{
    std::string ret;
    for (int i = 1; i <= 6; ++i)
        ret += (*this)[i];
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x4400
movl $0x1, -0x18(%rbp)
cmpl $0x6, -0x18(%rbp)
jg 0x5050
movq -0x30(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x1dc10
movb %al, -0x41(%rbp)
jmp 0x501b
movq -0x40(%rbp), %rdi
movb -0x41(%rbp), %al
movsbl %al, %esi
callq 0x4170
jmp 0x502c
jmp 0x502e
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5003
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4588
jmp 0x506d
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x5063
movq -0x40(%rbp), %rdi
callq 0x4588
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x44c0
nopw %cs:(%rax,%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: toAscii[abi:cxx11](long)
std::string toAscii(int64_t val)
{
    std::string ret;
    for (int i = 0; i < 8; ++i) {
        int c = (val >> (42-(i*6))) & 077;
        if (c == 0) ret += ' ';
        else if (020 <= c && c <= 031) ret += char(c-020+'0');
        else if (041 <= c && c <= 072) ret += char (c-041+'A');
        else if (c == 012) ret += '*';
        else if (c == 017) ret += '/';
        else ret += '?';
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x4400
movl $0x0, -0x18(%rbp)
cmpl $0x8, -0x18(%rbp)
jge 0x6e4b
movq -0x10(%rbp), %rax
imull $0x6, -0x18(%rbp), %edx
movl $0x2a, %ecx
subl %edx, %ecx
movl %ecx, %ecx
sarq %cl, %rax
andq $0x3f, %rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x6da5
movq -0x40(%rbp), %rdi
movl $0x20, %esi
callq 0x4170
jmp 0x6d86
jmp 0x6e3b
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x4588
jmp 0x6e68
movl $0x10, %eax
cmpl -0x1c(%rbp), %eax
jg 0x6dcb
cmpl $0x19, -0x1c(%rbp)
jg 0x6dcb
movq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x20, %eax
movsbl %al, %esi
callq 0x4170
jmp 0x6dc9
jmp 0x6e39
movl $0x21, %eax
cmpl -0x1c(%rbp), %eax
jg 0x6df1
cmpl $0x3a, -0x1c(%rbp)
jg 0x6df1
movq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x20, %eax
movsbl %al, %esi
callq 0x4170
jmp 0x6def
jmp 0x6e37
cmpl $0xa, -0x1c(%rbp)
jne 0x6e09
movq -0x40(%rbp), %rdi
movl $0x2a, %esi
callq 0x4170
jmp 0x6e07
jmp 0x6e35
cmpl $0xf, -0x1c(%rbp)
jne 0x6e21
movq -0x40(%rbp), %rdi
movl $0x2f, %esi
callq 0x4170
jmp 0x6e1f
jmp 0x6e33
movq -0x40(%rbp), %rdi
movl $0x3f, %esi
callq 0x4170
jmp 0x6e31
jmp 0x6e33
jmp 0x6e35
jmp 0x6e37
jmp 0x6e39
jmp 0x6e3b
jmp 0x6e3d
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6d4b
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x6e5e
movq -0x40(%rbp), %rdi
callq 0x4588
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x44c0
nopw %cs:(%rax,%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: escapeChar[abi:cxx11](int)
std::string escapeChar(int c) {
    std::string ret;
    if (c < 32 || c >= 127) {
        char * strp;
        if (0 <= asprintf(&strp, "_%03o", c)) {
            ret = strp;
            free(strp);
        } else perror("asprintf");
    } else
        ret = char(c);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
callq 0x4400
cmpl $0x20, -0xc(%rbp)
jl 0x6eaf
cmpl $0x7f, -0xc(%rbp)
jl 0x6f0f
movl -0xc(%rbp), %edx
leaq -0x18(%rbp), %rdi
leaq 0x2ad98(%rip), %rsi     # 0x31c55
movb $0x0, %al
callq 0x40c0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x6efd
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x43f0
jmp 0x6edb
movq -0x18(%rbp), %rdi
callq 0x4390
jmp 0x6f0d
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4588
jmp 0x6f3d
leaq 0x2ad57(%rip), %rdi     # 0x31c5b
callq 0x4240
jmp 0x6f0b
jmp 0x6f0d
jmp 0x6f20
movq -0x38(%rbp), %rdi
movsbl -0xc(%rbp), %esi
callq 0x44a0
jmp 0x6f1e
jmp 0x6f20
movb $0x1, -0xd(%rbp)
testb $0x1, -0xd(%rbp)
jne 0x6f33
movq -0x38(%rbp), %rdi
callq 0x4588
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x44c0
nopw %cs:(%rax,%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: printErrMsg(long)
void printErrMsg(int64_t errNo)
{
    putchar(' ');
    if (errNo >= 200)
        printf("Internal error %ld", errNo);
    else {
        if (errNo > 88)
            printErrMsg(86);
        else if (errNo == 20)
            errNo = (SY == IDENT)*2 + 1;
        else if (16 <= errNo && errNo <= 18)
            printf("%ld ", int64_t(curToken.i));
        printf("%s ", pasmitxt(errNo));
        if (errNo == 17)
            printf("%ld", int97z);
        else if (errNo == 22)
            printf("%6s", stmtName.c_str());
    }
    if (errNo != 86 && errNo != 78 && errNo != 79)
        putchar('\n');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x20, %edi
callq 0x4410
cmpq $0xc8, -0x8(%rbp)
jl 0x76d7
movq -0x8(%rbp), %rsi
leaq 0x2abee(%rip), %rdi     # 0x322b9
movb $0x0, %al
callq 0x4030
jmp 0x77a0
cmpq $0x58, -0x8(%rbp)
jle 0x76ea
movl $0x56, %edi
callq 0x76a0
jmp 0x7740
cmpq $0x14, -0x8(%rbp)
jne 0x770d
cmpl $0x0, 0x787e4(%rip)     # 0x7fedc
sete %al
andb $0x1, %al
movzbl %al, %eax
shll %eax
addl $0x1, %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x773e
movl $0x10, %eax
cmpq -0x8(%rbp), %rax
jg 0x773c
cmpq $0x12, -0x8(%rbp)
jg 0x773c
leaq 0x789c2(%rip), %rdi     # 0x800e8
callq 0x1dfb0
movq %rax, %rsi
leaq 0x2ab97(%rip), %rdi     # 0x322cc
movb $0x0, %al
callq 0x4030
jmp 0x773e
jmp 0x7740
movq -0x8(%rbp), %rdi
callq 0x7330
movq %rax, %rsi
leaq 0x2ab7e(%rip), %rdi     # 0x322d1
movb $0x0, %al
callq 0x4030
cmpq $0x11, -0x8(%rbp)
jne 0x7778
movq 0x788c0(%rip), %rsi     # 0x80028
leaq 0x2ab59(%rip), %rdi     # 0x322c8
movb $0x0, %al
callq 0x4030
jmp 0x779e
cmpq $0x16, -0x8(%rbp)
jne 0x779c
leaq 0x7881a(%rip), %rdi     # 0x7ffa0
callq 0x40f0
movq %rax, %rsi
leaq 0x2ab40(%rip), %rdi     # 0x322d5
movb $0x0, %al
callq 0x4030
jmp 0x779e
jmp 0x77a0
cmpq $0x56, -0x8(%rbp)
je 0x77bf
cmpq $0x4e, -0x8(%rbp)
je 0x77bf
cmpq $0x4f, -0x8(%rbp)
je 0x77bf
movl $0xa, %edi
callq 0x4410
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x6d20
leaq -0x28(%rbp), %rdi
callq 0x40f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x7810
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x77f6
movq -0x30(%rbp), %rdi
movq 0x3776d(%rip), %rax     # 0x3ef88
movq (%rax), %rsi
callq 0x4360
jmp 0x7825
leaq -0x28(%rbp), %rdi
callq 0x4588
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4588
movq -0x38(%rbp), %rdi
callq 0x44c0
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x78b2
movq -0x10(%rbp), %rax
shlq $0x6, %rax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
andl $0xff, %ecx
movslq %ecx, %rdx
leaq 0xd1058(%rip), %rcx     # 0xd88f0
movsbq (%rcx,%rdx), %rcx
orq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x7870
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x788b1(%rip), %rax     # 0x80180
cmpq 0x786aa(%rip), %rax     # 0x7ff80
jl 0x78f3
movq 0x786a1(%rip), %rcx     # 0x7ff80
leaq 0x788aa(%rip), %rax     # 0x80190
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x7a4f
movl $0x38, %edi
callq 0x1e2e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x1e300
jmp 0x790e
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x40, %edi
callq 0x1e2e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq 0x78787(%rip), %rcx     # 0x800b8
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x1e360
jmp 0x793f
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq $0x1, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0xc, 0x8(%rax)
movq 0x78737(%rip), %rcx     # 0x800a8
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x1, 0x28(%rax)
movq 0x785f4(%rip), %rcx     # 0x7ff80
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq 0x785e5(%rip), %rax     # 0x7ff80
addq $0x5, %rax
movl $0x6, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
cmpq $0x1, (%rax)
jne 0x7a00
movq 0x785bc(%rip), %rcx     # 0x7ff80
shlq $0x3, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x7a0c
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1e330
jmp 0x7a59
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1e330
jmp 0x7a59
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq 0x786a5(%rip), %rcx     # 0x800b8
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
movb $0x1, 0x28(%rax)
movq -0x28(%rbp), %rax
movq $0x6, 0x30(%rax)
movq -0x28(%rbp), %rax
movq $0x8, 0x38(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x44c0
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdx
movq 0x78511(%rip), %rcx     # 0x7fff8
leaq 0xc0df2(%rip), %rax     # 0xc88e0
movq %rdx, (%rax,%rcx,8)
movq 0x7844f(%rip), %rax     # 0x7ff48
addq $0x1, %rax
movq %rax, 0x78444(%rip)     # 0x7ff48
cmpq $0x2000, 0x784e9(%rip) # imm = 0x2000
jne 0x7b28
movl $0x31, %edi
callq 0x7b40
movq $0x1, 0x784d2(%rip) # 0x7fff8
jmp 0x7b3a
movq 0x784c9(%rip), %rax     # 0x7fff8
addq $0x1, %rax
movq %rax, 0x784be(%rip)     # 0x7fff8
addq $0x10, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb $0x1, 0x784e3(%rip)     # 0x80036
movb $0x1, 0x784e3(%rip)     # 0x8003d
movq 0x783cf(%rip), %rax     # 0x7ff30
cmpq 0x783d0(%rip), %rax     # 0x7ff38
je 0x7b78
movl $0x9, %eax
cmpq 0x783ca(%rip), %rax     # 0x7ff40
jge 0x7b83
cmpq $0x34, -0x8(%rbp)
jne 0x7c17
movq 0x783de(%rip), %rax     # 0x7ff68
addq $0x1, %rax
movq %rax, 0x783d3(%rip)     # 0x7ff68
movq 0x78394(%rip), %rdx     # 0x7ff30
movq 0x7839d(%rip), %rcx     # 0x7ff40
leaq 0x7d096(%rip), %rax     # 0x84c40
movq %rdx, (%rax,%rcx,8)
movq 0x7838b(%rip), %rax     # 0x7ff40
addq $0x1, %rax
movq %rax, 0x78380(%rip)     # 0x7ff40
movq 0x78369(%rip), %rax     # 0x7ff30
movq %rax, 0x7836a(%rip)     # 0x7ff38
movq -0x8(%rbp), %rsi
leaq 0x2a74a(%rip), %rdi     # 0x32323
movb $0x0, %al
callq 0x4030
movq -0x8(%rbp), %rdi
callq 0x76a0
movl $0x3c, %eax
cmpq 0x78373(%rip), %rax     # 0x7ff68
jge 0x7c15
movl $0xa, %edi
callq 0x4410
callq 0x8d10
movl $0x35, %edi
callq 0x76a0
callq 0xabb0
jmp 0x7c17
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x4ad0
leaq -0x10(%rbp), %rdi
callq 0x1dfb0
movq %rax, %rsi
andq $-0x8000, %rsi          # imm = 0x8000
leaq -0x18(%rbp), %rdi
callq 0x4ad0
leaq -0x18(%rbp), %rdi
callq 0x1dfb0
cmpq 0x7cf33(%rip), %rax     # 0x84b98
jne 0x7d47
movq 0x783a6(%rip), %rax     # 0x80018
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1dfb0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jne 0x7c90
jmp 0x7d98
testb $0x1, 0x7839d(%rip)     # 0x80034
je 0x7d45
cmpq $0x1, 0x78373(%rip)     # 0x80018
jne 0x7d45
movq 0x78346(%rip), %rax     # 0x7fff8
subq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
leaq 0xc0c1b(%rip), %rax     # 0xc88e0
movq (%rax,%rcx,8), %rax
sarq $0x18, %rax
andq $-0x8000, %rax          # imm = 0x8000
cmpq $0xdc8000, %rax         # imm = 0xDC8000
jne 0x7d43
leaq -0x18(%rbp), %rdi
callq 0x1dfb0
movq %rax, 0x7832d(%rip)     # 0x80018
movq -0x10(%rbp), %rax
andq $0x7fff, %rax           # imm = 0x7FFF
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
leaq 0xc0bdc(%rip), %rax     # 0xc88e0
movq (%rax,%rcx,8), %rax
sarq $0x18, %rax
andq $0x7fff, %rax           # imm = 0x7FFF
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdx
addq $0xda0000, %rdx         # imm = 0xDA0000
shlq $0x18, %rdx
movq -0x30(%rbp), %rax
addq $0xc0000, %rax          # imm = 0xC0000
orq %rax, %rdx
movq -0x20(%rbp), %rcx
leaq 0xc0ba3(%rip), %rax     # 0xc88e0
movq %rdx, (%rax,%rcx,8)
jmp 0x7d98
jmp 0x7d45
jmp 0x7d47
leaq -0x18(%rbp), %rdi
callq 0x1dfb0
movq %rax, 0x782c1(%rip)     # 0x80018
testb $0x1, 0x782d6(%rip)     # 0x80034
je 0x7d78
movq -0x10(%rbp), %rax
shlq $0x18, %rax
movq %rax, 0x78389(%rip)     # 0x800f8
movb $0x0, 0x782be(%rip)     # 0x80034
jmp 0x7d98
movb $0x1, 0x782b5(%rip)     # 0x80034
movq 0x78372(%rip), %rdi     # 0x800f8
movq -0x10(%rbp), %rax
andq $0xffffff, %rax         # imm = 0xFFFFFF
orq %rax, %rdi
callq 0x7ad0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x78195(%rip), %rax     # 0x80018
cmpq 0x7cd0e(%rip), %rax     # 0x84b98
je 0x7ee2
callq 0x7e30
movq %rax, -0x10(%rbp)
movb 0x78199(%rip), %al      # 0x80034
andb $0x1, %al
movb %al, -0x11(%rbp)
movq 0x78019(%rip), %rdi     # 0x7fec0
movq -0x8(%rbp), %rax
addq (%rax), %rdi
callq 0x7c20
movb 0x7817b(%rip), %al      # 0x80034
andb $0x1, %al
movzbl %al, %eax
movb -0x11(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x7ed7
movq -0x10(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdx
movq 0x77f91(%rip), %rcx     # 0x7fef8
leaq 0x7e442(%rip), %rax     # 0x863b0
movq %rdx, (%rax,%rcx,8)
cmpq $0x7fff, 0x77f7b(%rip) # imm = 0x7FFF
jne 0x7f96
movl $0x32, %edi
callq 0x7b40
movq $0x7800, 0x77f64(%rip) # imm = 0x7800
jmp 0x7fa8
movq 0x77f5b(%rip), %rax     # 0x7fef8
addq $0x1, %rax
movq %rax, 0x77f50(%rip)     # 0x7fef8
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x77f35(%rip), %rax     # 0x7fef8
movq %rax, -0x18(%rbp)
movq 0x78122(%rip), %rax     # 0x800f0
andq $0xffffff, %rax         # imm = 0xFFFFFF
cmpq $0x0, %rax
je 0x80a6
movq $0x1, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq 0xbe3bf(%rip), %rax     # 0xc63b0
jg 0x8033
movq 0x780f6(%rip), %rax     # 0x800f0
movq -0x20(%rbp), %rdx
leaq 0xbe69b(%rip), %rcx     # 0xc66a0
cmpq (%rcx,%rdx,8), %rax
jne 0x8023
movq -0x20(%rbp), %rcx
leaq 0xbe3aa(%rip), %rax     # 0xc63c0
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x80c6
jmp 0x8025
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x7fe6
movq 0xbe376(%rip), %rax     # 0xc63b0
addq $0x1, %rax
movq %rax, 0xbe36b(%rip)     # 0xc63b0
cmpq $0x5a, 0xbe363(%rip)    # 0xc63b0
jl 0x8064
movl $0x33, %edi
callq 0x7b40
movq $0x1, 0xbe34c(%rip) # 0xc63b0
movq 0x77e8d(%rip), %rdx     # 0x7fef8
movq 0xbe33e(%rip), %rcx     # 0xc63b0
leaq 0xbe347(%rip), %rax     # 0xc63c0
movq %rdx, (%rax,%rcx,8)
movq 0x7806c(%rip), %rdx     # 0x800f0
movq 0xbe325(%rip), %rcx     # 0xc63b0
leaq 0xbe60e(%rip), %rax     # 0xc66a0
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
orq $0x400000, %rax         # imm = 0x400000
movq %rax, -0x10(%rbp)
jmp 0x80b5
movq 0x78043(%rip), %rax     # 0x800f0
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7f50
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
leaq 0x7dfa9(%rip), %rax     # 0x86090
cmpq $0x0, (%rax,%rcx,8)
jne 0x8120
movq -0x8(%rbp), %rcx
leaq 0x37537(%rip), %rax     # 0x3f630
movq (%rax,%rcx,8), %rax
movq %rax, 0x77fec(%rip)     # 0x800f0
movl $0x8c0000, %edi         # imm = 0x8C0000
callq 0x7fb0
movq %rax, %rdx
movq -0x8(%rbp), %rcx
leaq 0x7df74(%rip), %rax     # 0x86090
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rcx
leaq 0x7df65(%rip), %rax     # 0x86090
movq (%rax,%rcx,8), %rax
addq $0xdc8000, %rax         # imm = 0xDC8000
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x8170
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x800, -0x10(%rbp)     # imm = 0x800
jge 0x85a5
jmp 0x85d7
cmpq $0x1000, -0x10(%rbp)    # imm = 0x1000
jl 0x85bb
movl $0xcc, %edi
callq 0x7b40
jmp 0x85d5
movq -0x10(%rbp), %rdi
addq $0x800000, %rdi         # imm = 0x800000
callq 0x8390
subq $0x7000, %rax           # imm = 0x7000
movq %rax, -0x8(%rbp)
jmp 0x85d7
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq -0x10(%rbp), %rax
cmpq $0x0, %rax
jne 0x8616
movq $-0x1, -0x8(%rbp)
jmp 0x8663
movq $0x0, -0x18(%rbp)
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
shrq $0x2f, %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x865b
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x20(%rbp)
jmp 0x8630
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x86b7
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
subq $0x1, %rax
andq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x8692
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x38, %edi
callq 0x1e2e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x1e300
jmp 0x87df
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jl 0x8852
movq -0x18(%rbp), %rdi
callq 0x8740
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x8852
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x1e330
jmp 0x8863
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x44c0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x77869(%rip), %rdi     # 0x800f0
callq 0x4ad0
leaq 0x7785d(%rip), %rdi     # 0x800f0
callq 0x1dfb0
movq %rax, %rsi
andq $0x7fff, %rsi           # imm = 0x7FFF
leaq 0x77847(%rip), %rdi     # 0x800f0
callq 0x4ad0
leaq 0x7783b(%rip), %rdi     # 0x800f0
callq 0x1dfb0
movq %rax, %rcx
movl $0x4000, %eax           # imm = 0x4000
cmpq %rcx, %rax
jl 0x88d9
leaq 0x77822(%rip), %rdi     # 0x800f0
callq 0x1dfb0
movq %rax, -0x8(%rbp)
jmp 0x88f7
movq 0x77810(%rip), %rdi     # 0x800f0
orq $0x800000, %rdi         # imm = 0x800000
andq $0xffffff, %rdi         # imm = 0xFFFFFF
callq 0x8390
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x8cf8
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x8ca9
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl $0x4, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x8ca9
movl $0xa, %edi
callq 0x4410
movq -0x18(%rbp), %rax
movq (%rax), %rax
sarq $0x18, %rax
movl %eax, %edi
callq 0x8be0
movl $0x20, %edi
callq 0x4410
movq -0x18(%rbp), %rax
movq (%rax), %rax
andq $0xffffff, %rax         # imm = 0xFFFFFF
movl %eax, %edi
callq 0x8be0
leaq 0x29619(%rip), %rdi     # 0x322f9
movb $0x0, %al
callq 0x4030
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x8c68
movl $0xa, %edi
callq 0x4410
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: besm6[P]pascal-re/pascompl.cc
// Function: kputc(unsigned char)
static void kputc(uint8_t c)
{
    if (c >= 0300) {
        fputs(koi2utf[c - 0300], stdout);
        return;
    }
    if (c < 040) {
        static const char *extra2utf[32] = {
            0,  0,  0,  0,  0,  0,  "×",0,  0,  0,  0,  0,  0,  0,  "≤","≥",
            0,  0,  0,  0,  0,  0,  0,  "≡","#",0,  "÷",0,  0,  0,  "∨","~",
        };
        const char *u = extra2utf[c];
        if (u) {
            fputs(u, stdout);
            return;
        }
    }
    putchar(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
cmpl $0xc0, %eax
jl 0x90a1
movzbl -0x1(%rbp), %eax
subl $0xc0, %eax
movslq %eax, %rcx
leaq 0x368c4(%rip), %rax     # 0x3f950
movq (%rax,%rcx,8), %rdi
movq 0x35ef1(%rip), %rax     # 0x3ef88
movq (%rax), %rsi
callq 0x4360
jmp 0x90e6
movzbl -0x1(%rbp), %eax
cmpl $0x20, %eax
jge 0x90dd
movzbl -0x1(%rbp), %eax
movl %eax, %ecx
leaq 0x36b89(%rip), %rax     # 0x3fc40
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x90db
movq -0x10(%rbp), %rdi
movq 0x35eb7(%rip), %rax     # 0x3ef88
movq (%rax), %rsi
callq 0x4360
jmp 0x90e6
jmp 0x90dd
movzbl -0x1(%rbp), %edi
callq 0x4410
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0x912a
movq 0x36d3f(%rip), %rdi     # 0x3fe70
callq 0x4460
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1(%rbp)
jne 0x9161
xorl %eax, %eax
cmpq $0x51, 0x76de4(%rip)    # 0x7ff30
movb %al, -0x1(%rbp)
jge 0x9161
movzbl 0x36d20(%rip), %eax     # 0x3fe78
cmpl $0xa, %eax
setne %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
testb $0x1, %al
jne 0x916a
jmp 0x91b4
movq 0x76dbf(%rip), %rax     # 0x7ff30
addq $0x1, %rax
movq %rax, 0x76db4(%rip)     # 0x7ff30
movb 0x36cf6(%rip), %dl      # 0x3fe78
movq 0x76da7(%rip), %rcx     # 0x7ff30
leaq 0x7ba20(%rip), %rax     # 0x84bb0
movb %dl, (%rax,%rcx)
cmpq $0x51, 0x76d95(%rip)    # 0x7ff30
je 0x91af
movq 0x36ccc(%rip), %rdi     # 0x3fe70
callq 0x91c0
movb %al, 0x36cc9(%rip)      # 0x3fe78
jmp 0x912a
callq 0x8d10
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0x91fa
movzbl 0x36c77(%rip), %ecx     # 0x3fe78
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x1(%rbp)
je 0x9220
movq 0x36c5e(%rip), %rdi     # 0x3fe70
callq 0x4460
cmpl $0x0, %eax
setne %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
movb %al, 0x76e06(%rip)      # 0x80031
movb 0x36c47(%rip), %al      # 0x3fe78
movb %al, 0x76da2(%rip)      # 0x7ffd9
movq 0x36c32(%rip), %rdi     # 0x3fe70
callq 0x91c0
movb %al, 0x36c2f(%rip)      # 0x3fe78
movq 0x76ce0(%rip), %rax     # 0x7ff30
addq $0x1, %rax
movq %rax, 0x76cd5(%rip)     # 0x7ff30
movb 0x76d78(%rip), %dl      # 0x7ffd9
movq 0x76cc8(%rip), %rcx     # 0x7ff30
leaq 0x7b941(%rip), %rax     # 0x84bb0
movb %dl, (%rax,%rcx)
movq 0x76caf(%rip), %rcx     # 0x7ff28
movb $0x1, %al
cmpq 0x76cae(%rip), %rcx     # 0x7ff30
movb %al, -0x2(%rbp)
jge 0x9290
movb 0x76da4(%rip), %al      # 0x80031
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x91fa
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x91f0
movq $0x0, -0x10(%rbp)
movzbl 0x76d09(%rip), %edx     # 0x7ffd9
xorl %eax, %eax
movl $0x39, %ecx
cmpl %edx, %ecx
movb %al, -0x11(%rbp)
jl 0x92ee
movzbl 0x76cf4(%rip), %eax     # 0x7ffd9
cmpl $0x30, %eax
setge %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x92f7
jmp 0x931f
imulq $0xa, -0x10(%rbp), %rax
movzbl 0x76cd6(%rip), %ecx     # 0x7ffd9
addq %rcx, %rax
subq $0x30, %rax
movq %rax, -0x10(%rbp)
callq 0x91f0
movq 0xcf73e(%rip), %rax     # 0xd8a58
movb $0x0, (%rax)
jmp 0x92c9
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x9333
movq 0xcf728(%rip), %rax     # 0xd8a58
movb $0x1, (%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x91f0
movzbl 0x76c81(%rip), %eax     # 0x7ffd9
cmpl $0x2d, %eax
je 0x9369
movzbl 0x76c75(%rip), %eax     # 0x7ffd9
cmpl $0x2b, %eax
jne 0x9389
movzbl 0x76c69(%rip), %eax     # 0x7ffd9
cmpl $0x2b, %eax
sete %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq 0xcf6d2(%rip), %rax     # 0xd8a58
movb $0x0, (%rax)
callq 0x91f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
cmpl $0xc0, %eax
jl 0x9754
movzbl -0x2(%rbp), %eax
andl $0x7f, %eax
orl $0x20, %eax
movb %al, -0x1(%rbp)
jmp 0x977e
movzbl -0x2(%rbp), %eax
cmpl $0x80, %eax
jl 0x9765
movb $0x20, -0x1(%rbp)
jmp 0x977e
movzbl -0x2(%rbp), %eax
cmpl $0x60, %eax
jl 0x9778
movzbl -0x2(%rbp), %eax
xorl $0x20, %eax
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x2f0, %rsp            # imm = 0x2F0
movl 0x7531b(%rip), %eax     # 0x7fedc
movl %eax, -0x4(%rbp)
movb $0x1, %al
cmpl $0x27, -0x4(%rbp)
movb %al, -0x2e9(%rbp)
jne 0xabe2
cmpl $0x10, 0x75303(%rip)    # 0x7fedc
setne %al
movb %al, -0x2e9(%rbp)
movb -0x2e9(%rbp), %al
testb $0x1, %al
jne 0xabee
jmp 0xac05
movl 0x752e8(%rip), %eax     # 0x7fedc
movl %eax, -0x4(%rbp)
leaq -0x178(%rbp), %rdi
callq 0x9790
jmp 0xabc4
movzbl 0x753cd(%rip), %eax     # 0x7ffd9
cmpl $0x44, %eax
je 0xac1d
movzbl 0x753c1(%rip), %eax     # 0x7ffd9
cmpl $0x64, %eax
jne 0xac38
jmp 0xac1f
cmpl $0x27, 0x752b6(%rip)    # 0x7fedc
je 0xac36
leaq -0x2e8(%rbp), %rdi
callq 0x9790
jmp 0xac1f
jmp 0xac38
movl $0x4, %edi
callq 0x4130
movq %rax, %rdi
movl $0x270f, (%rdi)         # imm = 0x270F
movq 0x3432e(%rip), %rsi     # 0x3ef80
xorl %eax, %eax
movl %eax, %edx
callq 0x44b0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rsi, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movl 0x75224(%rip), %eax     # 0x7fedc
cmpl -0xc(%rbp), %eax
je 0xacd8
movl -0xc(%rbp), %edi
callq 0x90f0
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xac60
jmp 0xace4
leaq -0x188(%rbp), %rdi
callq 0x9790
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xaf9c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl $0xffff, %ecx           # imm = 0xFFFF
cqto
idivq %rcx
movq %rdx, %rax
movl $0x80, %ecx
cqto
idivq %rcx
movq %rdx, -0x20(%rbp)
movb $0x1, -0x11(%rbp)
movq -0x20(%rbp), %rcx
leaq 0x7a901(%rip), %rax     # 0x85890
movq (%rax,%rcx,8), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xafa0
movb $0x0, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xafe8
testb $0x1, -0x11(%rbp)
je 0xafd7
movq -0x20(%rbp), %rcx
leaq 0x7a8d2(%rip), %rax     # 0x85890
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdx
movq -0x20(%rbp), %rcx
leaq 0x7a8bf(%rip), %rax     # 0x85890
movq %rdx, (%rax,%rcx,8)
jmp 0xafe6
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xb02e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0xb01e
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xb01a
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xb01c
jmp 0xb02e
jmp 0xaff3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
popq %rbp
retq
// File: besm6[P]pascal-re/pascompl.cc
// Function: knownInType(IdentRec*&)
bool knownInType(IdentRecPtr & rec)
{
    if (programme::super.back()->typelist != NULL) {
        rec = programme::super.back()->typelist;
        while (rec != NULL) {
            if (rec->id == curIdent) {
                return true;
            }
            rec = rec->next;
        }
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xcd99d(%rip), %rdi     # 0xd8a30
callq 0x1e890
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0xb0f5
leaq 0xcd987(%rip), %rdi     # 0xd8a30
callq 0x1e890
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xb0f3
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpq 0x75029(%rip), %rax     # 0x80100
jne 0xb0df
movb $0x1, -0x1(%rbp)
jmp 0xb0f9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0xb0bc
jmp 0xb0f5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)