LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/generot[P]VM-0/src/lang/util.cc
// Function: lexer::expect(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
bool lexer::expect(string tok, bool kill_prog) {
    if(tokens[ix] != tok) {
        if(kill_prog)
            ISSUE_ERROR("Expected \"%s\", got \"%s\" instead.", tok.c_str(), tokens[ix].c_str());

        return false;
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x28(%rbp)
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rax, %rdi
addq $0x20, %rdi
movq 0x40(%rax), %rsi
callq 0x6ab0
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x6a80
testb $0x1, %al
jne 0x5a45
jmp 0x5aae
testb $0x1, -0x19(%rbp)
je 0x5aa8
movq -0x28(%rbp), %rdi
movq 0x4e56a(%rip), %rax     # 0x53fc0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
callq 0x5170
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq %rax, %rdi
addq $0x20, %rdi
movq 0x40(%rax), %rsi
callq 0x6ab0
movq %rax, %rdi
callq 0x5170
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq %rax, %rcx
leaq 0x336dd(%rip), %rsi     # 0x39174
movb $0x0, %al
callq 0x55e0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x54f0
movb $0x0, -0x1(%rbp)
jmp 0x5ab2
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/generot[P]VM-0/src/lang/util.cc
// Function: lexer::file_path[abi:cxx11]()
string lexer::file_path(void) { 
    int i;

    for(i = (int)filepath.length() - 1; i > 0 && 
        (filepath[i] != '/' && filepath[i] != '\\'); i--);

    return string(filepath.substr(0, i)) + (i != 0 ? "/" : "");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x5610
subl $0x1, %eax
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x61(%rbp)
jle 0x5b92
movq -0x50(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x5760
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2f, %ecx
movb %al, -0x62(%rbp)
je 0x5b8c
movq -0x50(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x5760
movsbl (%rax), %eax
cmpl $0x5c, %eax
setne %al
movb %al, -0x62(%rbp)
movb -0x62(%rbp), %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x5b9b
jmp 0x5ba8
jmp 0x5b9d
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5b4e
movq -0x50(%rbp), %rsi
movslq -0x14(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x5410
movq -0x60(%rbp), %rdi
movq -0x70(%rbp), %rsi
movl -0x14(%rbp), %eax
testl %eax, %eax
leaq 0x335c5(%rip), %rax     # 0x3919a
leaq 0x3369d(%rip), %rdx     # 0x39279
cmovneq %rax, %rdx
callq 0x6b00
jmp 0x5be7
leaq -0x38(%rbp), %rdi
callq 0x5260
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5260
movq -0x40(%rbp), %rdi
callq 0x56d0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/generot[P]VM-0/src/lang/util.cc
// Function: is_numeric(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool is_numeric(string str) {
    for(auto i = str.begin(); i < str.end(); i++) {
        if(!isdigit(*i) && *i != '.')
            return false;
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x5370
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rdi
callq 0x5230
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6da0
testb $0x1, %al
jne 0x62a9
jmp 0x62e9
leaq -0x18(%rbp), %rdi
callq 0x6de0
movsbl (%rax), %edi
callq 0x53a0
cmpl $0x0, %eax
jne 0x62d6
leaq -0x18(%rbp), %rdi
callq 0x6de0
movsbl (%rax), %eax
cmpl $0x2e, %eax
je 0x62d6
movb $0x0, -0x1(%rbp)
jmp 0x62ed
jmp 0x62d8
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x6e00
movq %rax, -0x28(%rbp)
jmp 0x6289
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/generot[P]VM-0/src/lang/util.cc
// Function: dump_program(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<_Instruction, std::allocator<_Instruction>>, long long)
void dump_program(string filename, vector<instr> prog, size_s entry_addr) {
    ofstream outf = ofstream(filename.c_str(), ios::out | ios::binary);

    bcode_header header;

    header.program_size = prog.size();
    header.stack_size_spec = bcode_header::STACK_SIZE_DEFAULT;
    header.entry_point_addr = (size_t)entry_addr;

    header.code_seg_sz = header.data_seg_sz = 0;

    outf.write((const char*)&header, sizeof(bcode_header));
    outf.write((const char*)prog.data(), prog.size() * sizeof(instr));

    outf.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rsi, -0x260(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x5170
movq %rax, -0x268(%rbp)
movl $0x10, %edi
movl $0x4, %esi
callq 0x6e40
movq -0x268(%rbp), %rsi
movl %eax, %edx
leaq -0x218(%rbp), %rdi
movq %rdi, -0x258(%rbp)
callq 0x5470
movq -0x260(%rbp), %rdi
callq 0x6e60
movq -0x258(%rbp), %rdi
movq %rax, -0x240(%rbp)
movl $0x1, -0x230(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x238(%rbp)
movq $0x0, -0x220(%rbp)
movq $0x0, -0x228(%rbp)
leaq -0x240(%rbp), %rsi
movl $0x28, %edx
callq 0x5570
jmp 0x63ad
movq -0x260(%rbp), %rdi
callq 0x6e90
movq -0x260(%rbp), %rdi
movq %rax, -0x270(%rbp)
callq 0x6e60
movq -0x270(%rbp), %rsi
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdx
leaq -0x218(%rbp), %rdi
callq 0x5570
jmp 0x63e9
leaq -0x218(%rbp), %rdi
callq 0x55c0
jmp 0x63f7
leaq -0x218(%rbp), %rdi
callq 0x5600
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x5600
movq -0x248(%rbp), %rdi
callq 0x56d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/generot[P]VM-0/src/lang/vc.cc
// Function: include(lexer&)
void include(lexer& lx) {
    string path = lx.accept();

    if(path != "include") {
        lx.unaccept();
        return;
    }
    
    path = lx.accept();

    string filepath = lx.file_path() + path.substr(1, path.length() - 2);
    lexer _module = lex_file((char*)filepath.c_str());

    program(_module);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x5c20
movq -0x110(%rbp), %rdi
leaq 0x7089(%rip), %rsi      # 0x3a04a
callq 0x6c00
movb %al, -0x101(%rbp)
jmp 0x32fce
movb -0x101(%rbp), %al
testb $0x1, %al
jne 0x32fda
jmp 0x33002
movq -0x8(%rbp), %rdi
callq 0x5b00
jmp 0x32fe5
movl $0x1, -0x38(%rbp)
jmp 0x330e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x3315e
movq -0x8(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x5c20
jmp 0x33011
leaq -0x28(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movq %rsi, -0x118(%rbp)
callq 0x5500
movq -0x118(%rbp), %rdi
callq 0x5260
movq -0x8(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x5b20
jmp 0x33043
leaq -0x28(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x5610
movq -0x120(%rbp), %rsi
movq %rax, %rcx
addq $-0x2, %rcx
leaq -0xb8(%rbp), %rdi
movl $0x1, %edx
callq 0x5410
jmp 0x33074
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x35810
jmp 0x3308d
leaq -0xb8(%rbp), %rdi
callq 0x5260
leaq -0x98(%rbp), %rdi
callq 0x5260
leaq -0x78(%rbp), %rdi
callq 0x5170
movq %rax, %rsi
leaq -0x100(%rbp), %rdi
callq 0x6440
jmp 0x330bf
leaq -0x100(%rbp), %rdi
callq 0x32840
jmp 0x330cd
leaq -0x100(%rbp), %rdi
callq 0x358e0
leaq -0x78(%rbp), %rdi
callq 0x5260
movl $0x0, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5260
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x33121
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x5260
leaq -0x98(%rbp), %rdi
callq 0x5260
jmp 0x3315e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x33155
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x358e0
leaq -0x78(%rbp), %rdi
callq 0x5260
leaq -0x28(%rbp), %rdi
callq 0x5260
movq -0x30(%rbp), %rdi
callq 0x56d0
// File: /workspace/github_c_makefile_star2_O0/generot[P]VM-0/src/lang/vc.cc
// Function: procedure(lexer&)
void procedure(lexer& lx) {
    string ident = lx.accept();
    
    if(ident != "proc") {
        lx.unaccept();
        return;
    }

    size_s starting_addr = bytecode.size();

    ident = lx.accept();

    if(symbol_table[ident].stype == SYM_FUNCTION)
        ISSUE_ERROR("Error: Redefinition of function \"%s\".", ident.c_str());

    symbol_table[ident] = { SYM_FUNCTION, ident, starting_addr };

    block(lx);

    if(ident != ENTRY_POINT) 
        bytecode.push_back({ INST_NOARGS, OPC_RET });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x5c20
movq -0xb8(%rbp), %rdi
leaq 0x6ea4(%rip), %rsi      # 0x3a045
callq 0x6c00
movb %al, -0xa9(%rbp)
jmp 0x331ae
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x331ba
jmp 0x331e2
movq -0x8(%rbp), %rdi
callq 0x5b00
jmp 0x331c5
movl $0x1, -0x38(%rbp)
jmp 0x3337f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x33391
leaq 0x2166f(%rip), %rdi     # 0x54858
callq 0x6e60
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x5c20
jmp 0x33201
leaq -0x28(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
leaq -0x60(%rbp), %rsi
movq %rsi, -0xd0(%rbp)
callq 0x5500
movq -0xd0(%rbp), %rdi
callq 0x5260
movq -0xc8(%rbp), %rsi
leaq 0x215f2(%rip), %rdi     # 0x54828
callq 0x35910
movq %rax, -0xc0(%rbp)
jmp 0x33244
movq -0xc0(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x3328c
movq 0x20d69(%rip), %rax     # 0x53fc0
movq (%rax), %rax
movq %rax, -0xd8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5170
movq -0xd8(%rbp), %rdi
movq %rax, %rdx
leaq 0x6e49(%rip), %rsi      # 0x3a0c4
movb $0x0, %al
callq 0x55e0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x54f0
movl $0x1, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5190
jmp 0x332a8
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq 0x21571(%rip), %rdi     # 0x54828
leaq -0x28(%rbp), %rsi
callq 0x35910
movq %rax, -0xe0(%rbp)
jmp 0x332c9
movq -0xe0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
movq %rsi, -0xe8(%rbp)
callq 0x359f0
movq -0xe8(%rbp), %rdi
callq 0x35a40
movq -0x8(%rbp), %rdi
callq 0x333b0
jmp 0x332fa
leaq 0x6dea(%rip), %rsi      # 0x3a0eb
leaq -0x28(%rbp), %rdi
callq 0x6c00
movb %al, -0xe9(%rbp)
jmp 0x33312
movb -0xe9(%rbp), %al
testb $0x1, %al
jne 0x3331e
jmp 0x33378
movl $0x2, -0xa8(%rbp)
movl $0x24, -0xa4(%rbp)
movl $0x0, -0xa0(%rbp)
movq $0x0, -0x98(%rbp)
leaq 0x2150a(%rip), %rdi     # 0x54858
leaq -0xa8(%rbp), %rsi
callq 0x35a60
jmp 0x3335c
jmp 0x33378
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x35a40
jmp 0x33391
movl $0x0, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5260
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x5260
movq -0x30(%rbp), %rdi
callq 0x56d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/generot[P]VM-0/src/lang/vc.cc
// Function: block(lexer&)
void block(lexer& lx) {
    lx.expect("{");
    lx.accept();

    while(!EXPECT("}")) {
        statement(lx);

        if(lx.eof())
            ISSUE_ERROR("Expected '}', got 'eof' instead");
    }

    lx.accept();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x56e0
movq -0xb0(%rbp), %rdx
leaq 0x6d08(%rip), %rsi      # 0x3a0f0
leaq -0x28(%rbp), %rdi
callq 0x6b50
jmp 0x333f3
movq -0xb8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x5a00
jmp 0x3340a
leaq -0x28(%rbp), %rdi
callq 0x5260
leaq -0x29(%rbp), %rdi
callq 0x5460
movq -0x8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x5c20
leaq -0x60(%rbp), %rdi
callq 0x5260
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x56e0
movq -0xc0(%rbp), %rdx
leaq 0x6c94(%rip), %rsi      # 0x3a0f2
leaq -0x80(%rbp), %rdi
callq 0x6b50
jmp 0x33469
movq -0xc8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
xorl %edx, %edx
callq 0x5a00
movb %al, -0xc9(%rbp)
jmp 0x33483
movb -0xc9(%rbp), %al
xorb $-0x1, %al
movb %al, -0xca(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x5260
leaq -0x81(%rbp), %rdi
callq 0x5460
movb -0xca(%rbp), %al
testb $0x1, %al
jne 0x334b5
jmp 0x33556
movq -0x8(%rbp), %rdi
callq 0x33590
movq -0x8(%rbp), %rdi
callq 0x5ac0
testb $0x1, %al
jne 0x334d0
jmp 0x33551
movq 0x20ae9(%rip), %rax     # 0x53fc0
movq (%rax), %rdi
leaq 0x6c13(%rip), %rsi      # 0x3a0f4
movb $0x0, %al
callq 0x55e0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x54f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x33515
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5260
leaq -0x29(%rbp), %rdi
callq 0x5460
jmp 0x3357b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x33543
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x5260
leaq -0x81(%rbp), %rdi
callq 0x5460
jmp 0x3357b
jmp 0x33432
movq -0x8(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x5c20
leaq -0xa8(%rbp), %rdi
callq 0x5260
addq $0xd0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x56d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/generot[P]VM-0/src/lang/vc.cc
// Function: statement(lexer&)
void statement(lexer& lx) {
    assign(lx);
    cond_if(lx);
    cond_while(lx);
    call(lx);
    inpout(lx);

    lx.expect(";");
    lx.accept();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x33670
movq -0x8(%rbp), %rdi
callq 0x33890
movq -0x8(%rbp), %rdi
callq 0x33a00
movq -0x8(%rbp), %rdi
callq 0x33b40
movq -0x8(%rbp), %rdi
callq 0x33d90
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x56e0
movq -0x68(%rbp), %rdx
leaq 0x6a9c(%rip), %rsi      # 0x3a085
leaq -0x28(%rbp), %rdi
callq 0x6b50
jmp 0x335f4
movq -0x70(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x5a00
jmp 0x33608
leaq -0x28(%rbp), %rdi
callq 0x5260
leaq -0x29(%rbp), %rdi
callq 0x5460
movq -0x8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x5c20
leaq -0x60(%rbp), %rdi
callq 0x5260
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x33659
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5260
leaq -0x29(%rbp), %rdi
callq 0x5460
movq -0x38(%rbp), %rdi
callq 0x56d0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/generot[P]VM-0/src/lang/vc.cc
// Function: assign(lexer&)
void assign(lexer& lx) {
    string ident = lx.accept();

    if(!EXPECT(":=")) {
        lx.unaccept();
        return;
    }

    symbol sym = symbol_table[ident];

    if(!sym.addr || sym.stype != SYM_VARIABLE)
        ISSUE_ERROR("Symbol \"%s\" is unreachable or unassignable.", ident.c_str());

    lx.accept();
    expr(lx);

    bytecode.push_back({ INST_ADDR, OPC_STORE, SC_INVALID, sym.addr });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x5c20
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x56e0
movq -0xd0(%rbp), %rdx
leaq 0x6a60(%rip), %rsi      # 0x3a115
leaq -0x48(%rbp), %rdi
callq 0x6b50
jmp 0x336c0
movq -0xd8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
xorl %edx, %edx
callq 0x5a00
movb %al, -0xd9(%rbp)
jmp 0x336da
movb -0xd9(%rbp), %al
xorb $-0x1, %al
movb %al, -0xda(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5260
leaq -0x49(%rbp), %rdi
callq 0x5460
movb -0xda(%rbp), %al
testb $0x1, %al
jne 0x33706
jmp 0x3375f
movq -0x8(%rbp), %rdi
callq 0x5b00
jmp 0x33711
movl $0x1, -0x60(%rbp)
jmp 0x33853
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x33740
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5260
leaq -0x49(%rbp), %rdi
callq 0x5460
jmp 0x3387d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3387d
leaq 0x210c2(%rip), %rdi     # 0x54828
leaq -0x28(%rbp), %rsi
callq 0x35910
movq %rax, -0xe8(%rbp)
jmp 0x33778
movq -0xe8(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x35a90
jmp 0x3378d
cmpq $0x0, -0x68(%rbp)
je 0x3379d
cmpl $0x0, -0x90(%rbp)
je 0x337d9
movq 0x2081c(%rip), %rax     # 0x53fc0
movq (%rax), %rax
movq %rax, -0xf0(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5170
movq -0xf0(%rbp), %rdi
movq %rax, %rdx
leaq 0x6950(%rip), %rsi      # 0x3a118
movb $0x0, %al
callq 0x55e0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x54f0
movq -0x8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x5c20
jmp 0x337eb
leaq -0xb0(%rbp), %rdi
callq 0x5260
movq -0x8(%rbp), %rdi
callq 0x34200
jmp 0x33802
movl $0x1, -0xc8(%rbp)
movl $0x13, -0xc4(%rbp)
movl $0x3, -0xc0(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq 0x21026(%rip), %rdi     # 0x54858
leaq -0xc8(%rbp), %rsi
callq 0x35a60
jmp 0x33840
leaq -0x90(%rbp), %rdi
callq 0x35a40
movl $0x0, -0x60(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5260
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x35a40
leaq -0x28(%rbp), %rdi
callq 0x5260
movq -0x58(%rbp), %rdi
callq 0x56d0
nop
// File: /workspace/github_c_makefile_star2_O0/generot[P]VM-0/src/lang/vc.cc
// Function: cond_if(lexer&)
void cond_if(lexer& lx) {
    if(!(EXPECT("if")))
        return;

    lx.accept();
    expr(lx);

    bytecode.push_back({ INST_ADDR, OPC_JEZ, SC_INVALID, 0x0 });
    size_t curr_sz = bytecode.size() - 1;

    block(lx);
    bytecode[curr_sz].addr = (size_s)bytecode.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x56e0
movq -0x88(%rbp), %rdx
leaq 0x687d(%rip), %rsi      # 0x3a145
leaq -0x28(%rbp), %rdi
callq 0x6b50
jmp 0x338d3
movq -0x90(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x5a00
movb %al, -0x91(%rbp)
jmp 0x338ed
movb -0x91(%rbp), %al
xorb $-0x1, %al
movb %al, -0x92(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5260
leaq -0x29(%rbp), %rdi
callq 0x5460
movb -0x92(%rbp), %al
testb $0x1, %al
jne 0x33919
jmp 0x3394f
jmp 0x339e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x33941
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5260
leaq -0x29(%rbp), %rdi
callq 0x5460
jmp 0x339ef
movq -0x8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x5c20
leaq -0x60(%rbp), %rdi
callq 0x5260
movq -0x8(%rbp), %rdi
callq 0x34200
movl $0x1, -0x78(%rbp)
movl $0x22, -0x74(%rbp)
movl $0x3, -0x70(%rbp)
movq $0x0, -0x68(%rbp)
leaq 0x20ec6(%rip), %rdi     # 0x54858
leaq -0x78(%rbp), %rsi
callq 0x35a60
leaq 0x20eb6(%rip), %rdi     # 0x54858
callq 0x6e60
subq $0x1, %rax
movq %rax, -0x80(%rbp)
movq -0x8(%rbp), %rdi
callq 0x333b0
leaq 0x20e99(%rip), %rdi     # 0x54858
callq 0x6e60
movq %rax, -0xa0(%rbp)
movq -0x80(%rbp), %rsi
leaq 0x20e82(%rip), %rdi     # 0x54858
callq 0x35ae0
movq -0xa0(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0xa0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x56d0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/generot[P]VM-0/src/lang/vc.cc
// Function: cond_while(lexer&)
void cond_while(lexer& lx) {
    if(!EXPECT("while"))
        return;

    lx.accept();
    size_t curr_addr = bytecode.size();

    expr(lx);
    block(lx);

    bytecode.push_back({ INST_ADDR, OPC_JNZ, SC_INVALID, (size_s)curr_addr });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x56e0
movq -0x88(%rbp), %rdx
leaq 0x6710(%rip), %rsi      # 0x3a148
leaq -0x28(%rbp), %rdi
callq 0x6b50
jmp 0x33a43
movq -0x90(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x5a00
movb %al, -0x91(%rbp)
jmp 0x33a5d
movb -0x91(%rbp), %al
xorb $-0x1, %al
movb %al, -0x92(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5260
leaq -0x29(%rbp), %rdi
callq 0x5460
movb -0x92(%rbp), %al
testb $0x1, %al
jne 0x33a89
jmp 0x33abc
jmp 0x33b21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x33ab1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5260
leaq -0x29(%rbp), %rdi
callq 0x5460
jmp 0x33b2a
movq -0x8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x5c20
leaq -0x60(%rbp), %rdi
callq 0x5260
leaq 0x20d7f(%rip), %rdi     # 0x54858
callq 0x6e60
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
callq 0x34200
movq -0x8(%rbp), %rdi
callq 0x333b0
movl $0x1, -0x80(%rbp)
movl $0x21, -0x7c(%rbp)
movl $0x3, -0x78(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq 0x20d40(%rip), %rdi     # 0x54858
leaq -0x80(%rbp), %rsi
callq 0x35a60
addq $0xa0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x56d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/generot[P]VM-0/src/lang/vc.cc
// Function: call(lexer&)
void call(lexer& lx) {
    if(!EXPECT("call"))
        return;
    
    lx.accept();
    string ident = lx.accept();
    symbol func = symbol_table[ident];

    if(func.ident == string())
        ISSUE_ERROR("Undefined reference to function \"%s\".", ident.c_str());

    bytecode.push_back({ INST_ADDR, OPC_CALL, SC_INVALID, func.addr });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf8(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x56e0
movq -0xf0(%rbp), %rdx
leaq 0x65d6(%rip), %rsi      # 0x3a14e
leaq -0x28(%rbp), %rdi
callq 0x6b50
jmp 0x33b83
movq -0xf8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x5a00
movb %al, -0xf9(%rbp)
jmp 0x33b9d
movb -0xf9(%rbp), %al
xorb $-0x1, %al
movb %al, -0xfa(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5260
leaq -0x29(%rbp), %rdi
callq 0x5460
movb -0xfa(%rbp), %al
testb $0x1, %al
jne 0x33bc9
jmp 0x33bff
jmp 0x33d53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x33bf1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5260
leaq -0x29(%rbp), %rdi
callq 0x5460
jmp 0x33d7d
movq -0x8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x5c20
movq -0x118(%rbp), %rdi
callq 0x5260
movq -0x8(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x5c20
movq -0x110(%rbp), %rsi
leaq 0x20be7(%rip), %rdi     # 0x54828
callq 0x35910
movq %rax, -0x108(%rbp)
jmp 0x33c4f
movq -0x108(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x35a90
jmp 0x33c64
leaq -0xb0(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x128(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x5590
movq -0x128(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x6d10
movb %al, -0x119(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x5260
movb -0x119(%rbp), %al
testb $0x1, %al
jne 0x33cb3
jmp 0x33cfd
movq 0x20306(%rip), %rax     # 0x53fc0
movq (%rax), %rax
movq %rax, -0x130(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x5170
movq -0x130(%rbp), %rdi
movq %rax, %rdx
leaq 0x6475(%rip), %rsi      # 0x3a153
movb $0x0, %al
callq 0x55e0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x54f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x33d74
movl $0x1, -0xe8(%rbp)
movl $0x23, -0xe4(%rbp)
movl $0x3, -0xe0(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq 0x20b28(%rip), %rdi     # 0x54858
leaq -0xe8(%rbp), %rsi
callq 0x35a60
jmp 0x33d3e
leaq -0xb0(%rbp), %rdi
callq 0x35a40
leaq -0x80(%rbp), %rdi
callq 0x5260
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x35a40
leaq -0x80(%rbp), %rdi
callq 0x5260
movq -0x38(%rbp), %rdi
callq 0x56d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/generot[P]VM-0/src/lang/vc.cc
// Function: expr(lexer&)
void expr(lexer& lx) {
    comp(lx);
    while(EXPECT("&&") || EXPECT("||")) {
        opcode opc = lx.accept() == "&&" ? OPC_AND : OPC_OR;
        comp(lx);

        bytecode.push_back({ INST_NOARGS, opc });
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x34480
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x56e0
movq -0xa8(%rbp), %rdx
movb $0x0, -0x62(%rbp)
movb $0x0, -0x63(%rbp)
leaq 0x5f5c(%rip), %rsi      # 0x3a1a5
leaq -0x28(%rbp), %rdi
callq 0x6b50
jmp 0x34254
movq -0xb0(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x5a00
movb %al, -0xb1(%rbp)
jmp 0x3426e
movb -0xb1(%rbp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0xb2(%rbp)
jne 0x342e7
jmp 0x34283
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x56e0
movq -0xc0(%rbp), %rdx
movb $0x1, -0x62(%rbp)
leaq 0x5ef8(%rip), %rsi      # 0x3a1a8
leaq -0x60(%rbp), %rdi
callq 0x6b50
jmp 0x342bb
movq -0xc8(%rbp), %rdi
movb $0x1, -0x63(%rbp)
leaq -0x60(%rbp), %rsi
xorl %edx, %edx
callq 0x5a00
movb %al, -0xc9(%rbp)
jmp 0x342d9
movb -0xc9(%rbp), %al
movb %al, -0xb2(%rbp)
jmp 0x342e7
movb -0xb2(%rbp), %al
movb %al, -0xca(%rbp)
testb $0x1, -0x63(%rbp)
jne 0x342fb
jmp 0x34304
leaq -0x60(%rbp), %rdi
callq 0x5260
testb $0x1, -0x62(%rbp)
jne 0x3430c
jmp 0x34315
leaq -0x61(%rbp), %rdi
callq 0x5460
leaq -0x28(%rbp), %rdi
callq 0x5260
leaq -0x29(%rbp), %rdi
callq 0x5460
movb -0xca(%rbp), %al
testb $0x1, %al
jne 0x34336
jmp 0x3446c
movq -0x8(%rbp), %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x5c20
movq -0xd8(%rbp), %rdi
leaq 0x5e4a(%rip), %rsi      # 0x3a1a5
callq 0x6ad0
movb %al, -0xcb(%rbp)
jmp 0x34368
movb -0xcb(%rbp), %dl
movl $0x19, %eax
movl $0x18, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0xdc(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x5260
movl -0xdc(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
callq 0x34480
movl $0x2, -0xa0(%rbp)
movl -0x68(%rbp), %eax
movl %eax, -0x9c(%rbp)
movl $0x0, -0x98(%rbp)
movq $0x0, -0x90(%rbp)
leaq 0x20487(%rip), %rdi     # 0x54858
leaq -0xa0(%rbp), %rsi
callq 0x35a60
jmp 0x34218
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x34447
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3443e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3442b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
testb $0x1, -0x63(%rbp)
jne 0x34420
jmp 0x34429
leaq -0x60(%rbp), %rdi
callq 0x5260
jmp 0x3442b
testb $0x1, -0x62(%rbp)
jne 0x34433
jmp 0x3443c
leaq -0x61(%rbp), %rdi
callq 0x5460
jmp 0x3443e
leaq -0x28(%rbp), %rdi
callq 0x5260
leaq -0x29(%rbp), %rdi
callq 0x5460
jmp 0x34475
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x5260
jmp 0x34475
addq $0xe0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x56d0
nop
// File: /workspace/github_c_makefile_star2_O0/generot[P]VM-0/src/lang/vc.cc
// Function: term(lexer&)
void term(lexer& lx) {
    factor(lx);
    while(EXPECT("+") || EXPECT("-")) {
        opcode opc = lx.accept() == "+" ? OPC_ADDF : OPC_SUBF;
        factor(lx);

        bytecode.push_back({ INST_NOARGS, opc });
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x34da0
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x56e0
movq -0xa8(%rbp), %rdx
movb $0x0, -0x62(%rbp)
movb $0x0, -0x63(%rbp)
leaq 0x5642(%rip), %rsi      # 0x3a1ab
leaq -0x28(%rbp), %rdi
callq 0x6b50
jmp 0x34b74
movq -0xb0(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x5a00
movb %al, -0xb1(%rbp)
jmp 0x34b8e
movb -0xb1(%rbp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0xb2(%rbp)
jne 0x34c07
jmp 0x34ba3
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x56e0
movq -0xc0(%rbp), %rdx
movb $0x1, -0x62(%rbp)
leaq 0x55dd(%rip), %rsi      # 0x3a1ad
leaq -0x60(%rbp), %rdi
callq 0x6b50
jmp 0x34bdb
movq -0xc8(%rbp), %rdi
movb $0x1, -0x63(%rbp)
leaq -0x60(%rbp), %rsi
xorl %edx, %edx
callq 0x5a00
movb %al, -0xc9(%rbp)
jmp 0x34bf9
movb -0xc9(%rbp), %al
movb %al, -0xb2(%rbp)
jmp 0x34c07
movb -0xb2(%rbp), %al
movb %al, -0xca(%rbp)
testb $0x1, -0x63(%rbp)
jne 0x34c1b
jmp 0x34c24
leaq -0x60(%rbp), %rdi
callq 0x5260
testb $0x1, -0x62(%rbp)
jne 0x34c2c
jmp 0x34c35
leaq -0x61(%rbp), %rdi
callq 0x5460
leaq -0x28(%rbp), %rdi
callq 0x5260
leaq -0x29(%rbp), %rdi
callq 0x5460
movb -0xca(%rbp), %al
testb $0x1, %al
jne 0x34c56
jmp 0x34d8c
movq -0x8(%rbp), %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x5c20
movq -0xd8(%rbp), %rdi
leaq 0x5530(%rip), %rsi      # 0x3a1ab
callq 0x6ad0
movb %al, -0xcb(%rbp)
jmp 0x34c88
movb -0xcb(%rbp), %dl
movl $0x15, %eax
movl $0x14, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0xdc(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x5260
movl -0xdc(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
callq 0x34da0
movl $0x2, -0xa0(%rbp)
movl -0x68(%rbp), %eax
movl %eax, -0x9c(%rbp)
movl $0x0, -0x98(%rbp)
movq $0x0, -0x90(%rbp)
leaq 0x1fb67(%rip), %rdi     # 0x54858
leaq -0xa0(%rbp), %rsi
callq 0x35a60
jmp 0x34b38
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x34d67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x34d5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x34d4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
testb $0x1, -0x63(%rbp)
jne 0x34d40
jmp 0x34d49
leaq -0x60(%rbp), %rdi
callq 0x5260
jmp 0x34d4b
testb $0x1, -0x62(%rbp)
jne 0x34d53
jmp 0x34d5c
leaq -0x61(%rbp), %rdi
callq 0x5460
jmp 0x34d5e
leaq -0x28(%rbp), %rdi
callq 0x5260
leaq -0x29(%rbp), %rdi
callq 0x5460
jmp 0x34d95
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x5260
jmp 0x34d95
addq $0xe0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x56d0
nop
// File: /workspace/github_c_makefile_star2_O0/generot[P]VM-0/src/lang/vc.cc
// Function: factor(lexer&)
void factor(lexer& lx) {
    value(lx);
    while(EXPECT("*") || EXPECT("/")) {
        opcode opc = lx.accept() == "*" ? OPC_MULTF : OPC_DIVF;
        value(lx);

        bytecode.push_back({ INST_NOARGS, opc });
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x35020
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x56e0
movq -0xa8(%rbp), %rdx
movb $0x0, -0x62(%rbp)
movb $0x0, -0x63(%rbp)
leaq 0x53c6(%rip), %rsi      # 0x3a1af
leaq -0x28(%rbp), %rdi
callq 0x6b50
jmp 0x34df4
movq -0xb0(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x5a00
movb %al, -0xb1(%rbp)
jmp 0x34e0e
movb -0xb1(%rbp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0xb2(%rbp)
jne 0x34e87
jmp 0x34e23
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x56e0
movq -0xc0(%rbp), %rdx
movb $0x1, -0x62(%rbp)
leaq 0x434a(%rip), %rsi      # 0x3919a
leaq -0x60(%rbp), %rdi
callq 0x6b50
jmp 0x34e5b
movq -0xc8(%rbp), %rdi
movb $0x1, -0x63(%rbp)
leaq -0x60(%rbp), %rsi
xorl %edx, %edx
callq 0x5a00
movb %al, -0xc9(%rbp)
jmp 0x34e79
movb -0xc9(%rbp), %al
movb %al, -0xb2(%rbp)
jmp 0x34e87
movb -0xb2(%rbp), %al
movb %al, -0xca(%rbp)
testb $0x1, -0x63(%rbp)
jne 0x34e9b
jmp 0x34ea4
leaq -0x60(%rbp), %rdi
callq 0x5260
testb $0x1, -0x62(%rbp)
jne 0x34eac
jmp 0x34eb5
leaq -0x61(%rbp), %rdi
callq 0x5460
leaq -0x28(%rbp), %rdi
callq 0x5260
leaq -0x29(%rbp), %rdi
callq 0x5460
movb -0xca(%rbp), %al
testb $0x1, %al
jne 0x34ed6
jmp 0x3500c
movq -0x8(%rbp), %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x5c20
movq -0xd8(%rbp), %rdi
leaq 0x52b4(%rip), %rsi      # 0x3a1af
callq 0x6ad0
movb %al, -0xcb(%rbp)
jmp 0x34f08
movb -0xcb(%rbp), %dl
movl $0x17, %eax
movl $0x16, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0xdc(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x5260
movl -0xdc(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
callq 0x35020
movl $0x2, -0xa0(%rbp)
movl -0x68(%rbp), %eax
movl %eax, -0x9c(%rbp)
movl $0x0, -0x98(%rbp)
movq $0x0, -0x90(%rbp)
leaq 0x1f8e7(%rip), %rdi     # 0x54858
leaq -0xa0(%rbp), %rsi
callq 0x35a60
jmp 0x34db8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x34fe7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x34fde
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x34fcb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
testb $0x1, -0x63(%rbp)
jne 0x34fc0
jmp 0x34fc9
leaq -0x60(%rbp), %rdi
callq 0x5260
jmp 0x34fcb
testb $0x1, -0x62(%rbp)
jne 0x34fd3
jmp 0x34fdc
leaq -0x61(%rbp), %rdi
callq 0x5460
jmp 0x34fde
leaq -0x28(%rbp), %rdi
callq 0x5260
leaq -0x29(%rbp), %rdi
callq 0x5460
jmp 0x35015
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x5260
jmp 0x35015
addq $0xe0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x56d0
nop
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_load_file
unsigned lodepng_load_file(unsigned char** out, size_t* outsize, const char* filename) {
  long size = lodepng_filesize(filename);
  if(size < 0) return 78;
  *outsize = (size_t)size;

  *out = (unsigned char*)lodepng_malloc((size_t)size);
  if(!(*out) && size > 0) return 83; /*the above malloc failed*/

  return lodepng_buffer_file(*out, (size_t)size, filename);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3d40
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x3ce1
movl $0x4e, -0x4(%rbp)
jmp 0x3d30
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x3de0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3d19
cmpq $0x0, -0x28(%rbp)
jle 0x3d19
movl $0x53, -0x4(%rbp)
jmp 0x3d30
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3e00
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_buffer_file
static unsigned lodepng_buffer_file(unsigned char* out, size_t size, const char* filename) {
  FILE* file;
  size_t readsize;
  file = fopen(filename, "rb");
  if(!file) return 78;

  readsize = fread(out, 1, size, file);
  fclose(file);

  if(readsize != size) return 78;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x18982(%rip), %rsi     # 0x1c7a1
callq 0x1170
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x3e38
movl $0x4e, -0x4(%rbp)
jmp 0x3e75
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x1060
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1070
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x3e6e
movl $0x4e, -0x4(%rbp)
jmp 0x3e75
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_save_file
unsigned lodepng_save_file(const unsigned char* buffer, size_t buffersize, const char* filename) {
  FILE* file;
  file = fopen(filename, "wb" );
  if(!file) return 79;
  fwrite(buffer, 1, buffersize, file);
  fclose(file);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x176e6(%rip), %rsi     # 0x1b585
callq 0x1170
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x3eb8
movl $0x4f, -0x4(%rbp)
jmp 0x3ede
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x11b0
movq -0x28(%rbp), %rdi
callq 0x1070
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lode_png_test_bitreader
unsigned lode_png_test_bitreader(const unsigned char* data, size_t size,
                                 size_t numsteps, const size_t* steps, unsigned* result) {
  size_t i;
  LodePNGBitReader reader;
  unsigned error = LodePNGBitReader_init(&reader, data, size);
  if(error) return 0;
  for(i = 0; i < numsteps; i++) {
    size_t step = steps[i];
    unsigned ok;
    if(step > 25) ok = ensureBits32(&reader, step);
    else if(step > 17) ok = ensureBits25(&reader, step);
    else if(step > 9) ok = ensureBits17(&reader, step);
    else ok = ensureBits9(&reader, step);
    if(!ok) return 0;
    result[i] = readBits(&reader, step);
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x4010
movl %eax, -0x64(%rbp)
cmpl $0x0, -0x64(%rbp)
je 0x3f35
movl $0x0, -0x4(%rbp)
jmp 0x3ffb
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x3ff4
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x70(%rbp)
cmpq $0x19, -0x70(%rbp)
jbe 0x3f74
movq -0x70(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x40b0
movl %eax, -0x74(%rbp)
jmp 0x3fba
cmpq $0x11, -0x70(%rbp)
jbe 0x3f8d
movq -0x70(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x4290
movl %eax, -0x74(%rbp)
jmp 0x3fb8
cmpq $0x9, -0x70(%rbp)
jbe 0x3fa6
movq -0x70(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x4410
movl %eax, -0x74(%rbp)
jmp 0x3fb6
movq -0x70(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x4550
movl %eax, -0x74(%rbp)
jmp 0x3fb8
jmp 0x3fba
cmpl $0x0, -0x74(%rbp)
jne 0x3fc9
movl $0x0, -0x4(%rbp)
jmp 0x3ffb
movq -0x70(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x4650
movl %eax, %edx
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x3f3d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: LodePNGBitReader_init
static unsigned LodePNGBitReader_init(LodePNGBitReader* reader, const unsigned char* data, size_t size) {
  size_t temp;
  reader->data = data;
  reader->size = size;
  /* size in bits, return error if overflow (if size_t is 32 bit this supports up to 500MB)  */
  if(lodepng_mulofl(size, 8u, &reader->bitsize)) return 105;
  /*ensure incremented bp can be compared to bitsize without overflow even when it would be incremented 32 too much and
  trying to ensure 32 more bits*/
  if(lodepng_addofl(reader->bitsize, 64u, &temp)) return 105;
  reader->bp = 0;
  reader->buffer = 0;
  return 0; /*ok*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x10, %rdx
movl $0x8, %esi
callq 0x10520
cmpl $0x0, %eax
je 0x405f
movl $0x69, -0x4(%rbp)
jmp 0x40a1
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x40, %esi
leaq -0x28(%rbp), %rdx
callq 0x5e60
cmpl $0x0, %eax
je 0x4083
movl $0x69, -0x4(%rbp)
jmp 0x40a1
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: ensureBits25
static LODEPNG_INLINE unsigned ensureBits25(LodePNGBitReader* reader, size_t nbits) {
  size_t start = reader->bp >> 3u;
  size_t size = reader->size;
  if(start + 3u < size) {
    reader->buffer = (unsigned)reader->data[start + 0] | ((unsigned)reader->data[start + 1] << 8u) |
                     ((unsigned)reader->data[start + 2] << 16u) | ((unsigned)reader->data[start + 3] << 24u);
    reader->buffer >>= (reader->bp & 7u);
    return 1;
  } else {
    reader->buffer = 0;
    if(start + 0u < size) reader->buffer |= reader->data[start + 0];
    if(start + 1u < size) reader->buffer |= ((unsigned)reader->data[start + 1] << 8u);
    if(start + 2u < size) reader->buffer |= ((unsigned)reader->data[start + 2] << 16u);
    reader->buffer >>= (reader->bp & 7u);
    return reader->bp + nbits <= reader->bitsize;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x3, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x3, %rax
cmpq -0x28(%rbp), %rax
jae 0x4341
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rdx
movzbl 0x1(%rax,%rdx), %eax
shll $0x8, %eax
orl %eax, %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rdx
movzbl 0x2(%rax,%rdx), %eax
shll $0x10, %eax
orl %eax, %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rdx
movzbl 0x3(%rax,%rdx), %eax
shll $0x18, %eax
orl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
andq $0x7, %rcx
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x20(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x4402
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
addq $0x0, %rax
cmpq -0x28(%rbp), %rax
jae 0x4373
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movq -0x10(%rbp), %rax
orl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
cmpq -0x28(%rbp), %rax
jae 0x439e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movzbl 0x1(%rax,%rcx), %ecx
shll $0x8, %ecx
movq -0x10(%rbp), %rax
orl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jae 0x43c9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movzbl 0x2(%rax,%rcx), %ecx
shll $0x10, %ecx
movq -0x10(%rbp), %rax
orl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
andq $0x7, %rcx
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
setbe %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: ensureBits17
static unsigned ensureBits17(LodePNGBitReader* reader, size_t nbits) {
  size_t start = reader->bp >> 3u;
  size_t size = reader->size;
  if(start + 2u < size) {
    reader->buffer = (unsigned)reader->data[start + 0] | ((unsigned)reader->data[start + 1] << 8u) |
                     ((unsigned)reader->data[start + 2] << 16u);
    reader->buffer >>= (reader->bp & 7u);
    return 1;
  } else {
    reader->buffer = 0;
    if(start + 0u < size) reader->buffer |= reader->data[start + 0];
    if(start + 1u < size) reader->buffer |= ((unsigned)reader->data[start + 1] << 8u);
    reader->buffer >>= (reader->bp & 7u);
    return reader->bp + nbits <= reader->bitsize;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x3, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jae 0x44ac
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rdx
movzbl 0x1(%rax,%rdx), %eax
shll $0x8, %eax
orl %eax, %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rdx
movzbl 0x2(%rax,%rdx), %eax
shll $0x10, %eax
orl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
andq $0x7, %rcx
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x20(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x4542
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
addq $0x0, %rax
cmpq -0x28(%rbp), %rax
jae 0x44de
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movq -0x10(%rbp), %rax
orl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
cmpq -0x28(%rbp), %rax
jae 0x4509
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movzbl 0x1(%rax,%rcx), %ecx
shll $0x8, %ecx
movq -0x10(%rbp), %rax
orl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
andq $0x7, %rcx
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
setbe %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: ensureBits9
static unsigned ensureBits9(LodePNGBitReader* reader, size_t nbits) {
  size_t start = reader->bp >> 3u;
  size_t size = reader->size;
  if(start + 1u < size) {
    reader->buffer = (unsigned)reader->data[start + 0] | ((unsigned)reader->data[start + 1] << 8u);
    reader->buffer >>= (reader->bp & 7u);
    return 1;
  } else {
    reader->buffer = 0;
    if(start + 0u < size) reader->buffer |= reader->data[start + 0];
    reader->buffer >>= (reader->bp & 7u);
    return reader->bp + nbits <= reader->bitsize;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x3, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
cmpq -0x28(%rbp), %rax
jae 0x45d4
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rdx
movzbl 0x1(%rax,%rdx), %eax
shll $0x8, %eax
orl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
andq $0x7, %rcx
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x20(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x463f
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
addq $0x0, %rax
cmpq -0x28(%rbp), %rax
jae 0x4606
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movq -0x10(%rbp), %rax
orl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
andq $0x7, %rcx
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
setbe %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)