LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/generot[P]VM-0/src/lang/vc.cc
// Function: decl(lexer&)
void decl(lexer& lx) {
    string ident = lx.accept();

    if(ident != "var") {
        lx.unaccept();
        return;
    }

    while(ident != ";") {
        ident = lx.accept();
        symbol_table[ident] = { SYM_VARIABLE, ident, var_num };

        var_num++;
        if(EXPECT(",") || EXPECT(";"))
            ident = lx.accept();
        else
            ISSUE_ERROR("Expected separator or end of statement, got \"%s\" instead.", 
                lx.accept().c_str());
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4892
leaq 0x3727(%rip), %rsi      # 0x14fc1
movq %r14, %rdi
callq 0x4fdb
testb %al, %al
je 0x118ca
movq %rbx, %rdi
callq 0x47f8
leaq 0x38(%rsp), %rdi
callq 0x4130
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x38(%rsp), %r12
leaq 0x8(%rsp), %r13
leaq 0x78(%rsp), %rbp
leaq 0x58(%rsp), %r15
movq %r12, %rdi
leaq 0x371d(%rip), %rsi      # 0x15005
callq 0x4fdb
testb %al, %al
je 0x118ae
movq %r13, %rdi
movq %rbx, %rsi
callq 0x4892
movq %r12, %rdi
movq %r13, %rsi
callq 0x4370
movq %r13, %rdi
callq 0x4130
andl $0x0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x43f0
movq 0xedb0(%rip), %rax      # 0x206d8
movq %rax, 0x30(%rsp)
leaq 0xedf4(%rip), %rdi      # 0x20728
movq %r12, %rsi
callq 0x13052
movq %rax, %rdi
movq %r13, %rsi
callq 0x130b8
leaq 0x10(%rsp), %rdi
callq 0x4130
incq 0xed80(%rip)            # 0x206d8
movq %rbp, %rdi
leaq 0x36a5(%rip), %rsi      # 0x15007
movq %r13, %rdx
callq 0x4fa0
movq %rbx, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x477c
testb %al, %al
je 0x11985
movq %rbp, %rdi
callq 0x4130
jmp 0x119be
movq %r15, %rdi
leaq 0x3676(%rip), %rsi      # 0x15005
leaq 0x7(%rsp), %rdx
callq 0x4fa0
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x477c
movl %eax, %r14d
movq %r15, %rdi
callq 0x4130
movq %rbp, %rdi
callq 0x4130
testb %r14b, %r14b
je 0x119e1
movq %r13, %rdi
movq %rbx, %rsi
callq 0x4892
movq %r12, %rdi
movq %r13, %rsi
callq 0x4370
movq %r13, %rdi
callq 0x4130
jmp 0x118de
movq 0xe5d0(%rip), %rax      # 0x1ffb8
movq (%rax), %r14
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x4892
leaq 0x8(%rsp), %rbx
movq (%rbx), %rdx
leaq 0x3602(%rip), %rsi      # 0x15009
movq %r14, %rdi
xorl %eax, %eax
callq 0x4430
movq %rbx, %rdi
callq 0x4130
pushq $-0x1
popq %rdi
callq 0x4360
jmp 0x11a57
jmp 0x11a57
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x4130
jmp 0x11a39
jmp 0x11a36
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
jmp 0x11a4e
jmp 0x11a57
jmp 0x11a57
jmp 0x11a57
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4130
jmp 0x11a5a
jmp 0x11a57
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x4130
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4892
leaq 0x353c(%rip), %rsi      # 0x14fca
movq %r14, %rdi
callq 0x4fdb
testb %al, %al
je 0x11aa7
movq %rbx, %rdi
callq 0x47f8
jmp 0x11b4f
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x4892
movq %rsp, %rdi
leaq 0x20(%rsp), %r14
movq %r14, %rsi
callq 0x4370
movq %r14, %rdi
callq 0x4130
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x47fe
movq %rsp, %rsi
movq 0x8(%rsi), %rcx
addq $-0x2, %rcx
leaq 0x68(%rsp), %rdi
pushq $0x1
popq %rdx
callq 0x42f0
leaq 0x88(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0x12fd5
leaq 0x68(%rsp), %rdi
callq 0x4130
leaq 0x20(%rsp), %rdi
callq 0x4130
movq 0x88(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x4bc6
leaq 0x20(%rsp), %rdi
callq 0x116f8
leaq 0x20(%rsp), %rdi
callq 0x1303c
leaq 0x88(%rsp), %rdi
callq 0x4130
movq %rsp, %rdi
callq 0x4130
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1303c
jmp 0x11b74
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
jmp 0x11b95
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x4130
jmp 0x11b90
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4130
jmp 0x11ba3
jmp 0x11ba0
jmp 0x11ba0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4130
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4892
leaq 0x33ed(%rip), %rsi      # 0x14fc5
movq %r14, %rdi
callq 0x4fdb
testb %al, %al
je 0x11bf1
movq %rbx, %rdi
callq 0x47f8
jmp 0x11cd5
movq 0xeb68(%rip), %rax      # 0x20760
subq 0xeb59(%rip), %rax      # 0x20758
pushq $0x18
popq %rcx
cqto
idivq %rcx
movq %rax, %r14
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x4892
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x4370
movq %r12, %rdi
callq 0x4130
leaq 0xeaed(%rip), %rdi      # 0x20728
movq %r15, %rsi
callq 0x13052
cmpl $0x1, (%rax)
je 0x11ceb
leaq 0x30(%rsp), %r15
movl $0x1, -0x8(%r15)
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x43f0
movq %r14, 0x50(%rsp)
leaq 0xeab6(%rip), %rdi      # 0x20728
leaq 0x8(%rsp), %rsi
callq 0x13052
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x130b8
movq %r15, %rdi
callq 0x4130
movq %rbx, %rdi
callq 0x11d3a
leaq 0x33cb(%rip), %rsi      # 0x1506b
leaq 0x8(%rsp), %rdi
callq 0x4fdb
testb %al, %al
je 0x11cd5
movabsq $0x2400000002, %rax     # imm = 0x2400000002
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
andl $0x0, 0x8(%rsi)
andq $0x0, 0x10(%rsi)
leaq 0xea88(%rip), %rdi      # 0x20758
callq 0x13678
leaq 0x8(%rsp), %rdi
callq 0x4130
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xe2c6(%rip), %rax      # 0x1ffb8
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x3343(%rip), %rsi      # 0x15044
xorl %eax, %eax
callq 0x4430
pushq $-0x1
popq %rdi
callq 0x4360
jmp 0x11d25
movq %rax, %rbx
movq %r15, %rdi
callq 0x4130
jmp 0x11d28
jmp 0x11d25
jmp 0x11d25
jmp 0x11d25
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4130
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x331d(%rip), %rsi      # 0x15070
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4fa0
leaq 0x10(%rsp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x477c
leaq 0x10(%rsp), %rdi
callq 0x4130
leaq 0x70(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4892
movq %r14, %rdi
callq 0x4130
leaq 0x32d7(%rip), %r14      # 0x15072
leaq 0x30(%rsp), %r15
leaq 0xf(%rsp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4fa0
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x477c
movl %eax, %ebp
movq %r15, %rdi
callq 0x4130
testb %bpl, %bpl
jne 0x11e07
movq %rbx, %rdi
callq 0x11e55
movq %rbx, %rdi
callq 0x47dc
testb %al, %al
je 0x11da5
movq 0xe1ce(%rip), %rax      # 0x1ffb8
movq (%rax), %rcx
leaq 0x3280(%rip), %rdi      # 0x15074
pushq $0x20
popq %rsi
pushq $0x1
popq %rdx
callq 0x4540
pushq $-0x1
popq %rdi
callq 0x4360
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4892
movq %r14, %rdi
callq 0x4130
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x11e48
jmp 0x11e3b
movq %rax, %rbx
jmp 0x11e4d
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4130
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x11eea
movq %rbx, %rdi
callq 0x12032
movq %rbx, %rdi
callq 0x12110
movq %rbx, %rdi
callq 0x121db
movq %rbx, %rdi
callq 0x1233d
leaq 0x317a(%rip), %rsi      # 0x15005
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x4fa0
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x477c
leaq 0x8(%rsp), %rdi
callq 0x4130
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4892
movq %r14, %rdi
callq 0x4130
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4130
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x4892
leaq 0x318d(%rip), %rsi      # 0x15095
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x4fa0
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x477c
movl %eax, %ebp
leaq 0x50(%rsp), %rdi
callq 0x4130
testb %bpl, %bpl
je 0x11fc2
leaq 0xe7e6(%rip), %rdi      # 0x20728
movq %rsp, %rsi
callq 0x13052
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x130e6
cmpq $0x0, 0x48(%rsp)
je 0x11fdc
cmpl $0x0, 0x20(%rsp)
jne 0x11fdc
leaq 0x70(%rsp), %rdi
movq %rbx, %rsi
callq 0x4892
leaq 0x70(%rsp), %rdi
callq 0x4130
movq %rbx, %rdi
callq 0x125b6
movabsq $0x1300000001, %rax     # imm = 0x1300000001
leaq 0x90(%rsp), %rsi
movq %rax, (%rsi)
movl $0x3, 0x8(%rsi)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsi)
leaq 0xe7a7(%rip), %rdi      # 0x20758
callq 0x13678
leaq 0x28(%rsp), %rdi
callq 0x4130
jmp 0x11fca
movq %rbx, %rdi
callq 0x47f8
movq %rsp, %rdi
callq 0x4130
addq $0xa8, %rsp
popq %rbx
popq %rbp
retq
movq 0xdfd5(%rip), %rax      # 0x1ffb8
movq (%rax), %rdi
movq (%rsp), %rdx
leaq 0x30a7(%rip), %rsi      # 0x15098
xorl %eax, %eax
callq 0x4430
pushq $-0x1
popq %rdi
callq 0x4360
jmp 0x12004
jmp 0x1201f
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x12018
jmp 0x1201f
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x4130
jmp 0x12022
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4130
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x3081(%rip), %rsi      # 0x150c5
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %rdx
movq %r14, %rdi
callq 0x4fa0
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x477c
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x4130
testb %bpl, %bpl
je 0x120f2
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4892
movq %r14, %rdi
callq 0x4130
movq %rbx, %rdi
callq 0x125b6
movabsq $0x2200000001, %rax     # imm = 0x2200000001
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
movl $0x3, 0x8(%rsi)
andq $0x0, 0x10(%rsi)
leaq 0xe69f(%rip), %rdi      # 0x20758
callq 0x13678
movq 0xe69b(%rip), %r14      # 0x20760
subq 0xe68c(%rip), %r14      # 0x20758
movq %rbx, %rdi
callq 0x11d3a
movq 0xe685(%rip), %rax      # 0x20760
movq 0xe676(%rip), %rcx      # 0x20758
subq %rcx, %rax
pushq $0x18
popq %rsi
cqto
idivq %rsi
movq %rax, -0x8(%rcx,%r14)
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4130
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x2fa4(%rip), %rsi      # 0x150c8
movq %rsp, %r14
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
callq 0x4fa0
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x477c
movl %eax, %ebp
movq %rsp, %rdi
callq 0x4130
testb %bpl, %bpl
je 0x121bd
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4892
movq %r14, %rdi
callq 0x4130
leaq 0xe5e9(%rip), %r14      # 0x20758
movq 0xe5ea(%rip), %rax      # 0x20760
subq 0xe5db(%rip), %rax      # 0x20758
pushq $0x18
popq %rcx
cqto
idivq %rcx
movq %rax, %r15
movq %rbx, %rdi
callq 0x125b6
movq %rbx, %rdi
callq 0x11d3a
movabsq $0x2100000001, %rax     # imm = 0x2100000001
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movl $0x3, 0x8(%rsi)
movq %r15, 0x10(%rsi)
movq %r14, %rdi
callq 0x13678
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4130
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
leaq 0x2ede(%rip), %rsi      # 0x150ce
leaq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rdx
callq 0x4fa0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x477c
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
callq 0x4130
testb %bpl, %bpl
je 0x122de
leaq 0x90(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4892
movq %r14, %rdi
callq 0x4130
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4892
leaq 0xe4d5(%rip), %rdi      # 0x20728
movq %r14, %rsi
callq 0x13052
leaq 0x60(%rsp), %rdi
movq %rax, %rsi
callq 0x130e6
leaq 0x68(%rsp), %rbx
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x40(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4fe5
movl %eax, %ebp
movq %r14, %rdi
callq 0x4130
testb %bpl, %bpl
jne 0x122ea
movabsq $0x2300000001, %rax     # imm = 0x2300000001
leaq 0x40(%rsp), %rsi
movq %rax, (%rsi)
movl $0x3, 0x8(%rsi)
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rsi)
leaq 0xe48f(%rip), %rdi      # 0x20758
callq 0x13678
movq %rbx, %rdi
callq 0x4130
movq %rsp, %rdi
callq 0x4130
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0xdcc7(%rip), %rax      # 0x1ffb8
movq (%rax), %rdi
movq (%rsp), %rdx
leaq 0x2dd4(%rip), %rsi      # 0x150d3
xorl %eax, %eax
callq 0x4430
pushq $-0x1
popq %rdi
callq 0x4360
movq %rax, %r14
movq %rbx, %rdi
callq 0x4130
jmp 0x1231e
movq %rax, %r14
movq %rsp, %rdi
jmp 0x1232b
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x4130
jmp 0x12335
movq %rax, %r14
movq %r14, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
callq 0x126d3
leaq 0x2b52(%rip), %r14      # 0x15125
leaq 0x48(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x28(%rsp), %rbp
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4fa0
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x477c
testb %al, %al
je 0x1260b
movq %r15, %rdi
callq 0x4130
jmp 0x12644
movq %rbp, %rdi
leaq 0x2b13(%rip), %rsi      # 0x15128
leaq 0x7(%rsp), %rdx
callq 0x4fa0
movq %rbx, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x477c
movl %eax, %r13d
movq %rbp, %rdi
callq 0x4130
movq %r15, %rdi
callq 0x4130
testb %r13b, %r13b
je 0x1269e
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4892
movq %r12, %rdi
movq %r14, %rsi
callq 0x4f73
movzbl %al, %r13d
xorl $0x19, %r13d
movq %r12, %rdi
callq 0x4130
movq %rbx, %rdi
callq 0x126d3
movl $0x2, 0x8(%rsp)
movl %r13d, 0xc(%rsp)
andl $0x0, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
leaq 0xe0c7(%rip), %rdi      # 0x20758
movq %r12, %rsi
callq 0x13678
jmp 0x125e2
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x126be
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4130
jmp 0x126c1
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4130
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O2/generot[P]VM-0/src/lang/vc.cc
// Function: comp(lexer&)
void comp(lexer& lx) {
    term(lx);
    while(EXPECT(">")  || EXPECT("<")  || 
          EXPECT(">=") || EXPECT("<=") || 
          EXPECT("==") || EXPECT("!=")) 
    {
        opcode opc = match_comp(lx.accept());
        term(lx);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
callq 0x1295b
leaq 0xe8(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0xa8(%rsp), %r13
leaq 0xc8(%rsp), %r14
movq %r15, %rdi
leaq 0x1a12(%rip), %rsi      # 0x14125
movq %r12, %rdx
callq 0x4fa0
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x477c
testb %al, %al
jne 0x127fd
movq %r14, %rdi
leaq 0x19ed(%rip), %rsi      # 0x14127
leaq 0xf(%rsp), %rdx
callq 0x4fa0
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x477c
testb %al, %al
jne 0x127f5
leaq 0x28(%rsp), %rbp
movq %rbp, %rdi
leaq 0x19c1(%rip), %rsi      # 0x14129
leaq 0xe(%rsp), %rdx
callq 0x4fa0
movq %rbx, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x477c
testb %al, %al
jne 0x127eb
leaq 0x48(%rsp), %rbp
movq %rbp, %rdi
leaq 0x199a(%rip), %rsi      # 0x1412c
leaq 0xd(%rsp), %rdx
callq 0x4fa0
movq %rbx, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x477c
testb %al, %al
jne 0x127e1
leaq 0x68(%rsp), %rbp
movq %rbp, %rdi
leaq 0x1973(%rip), %rsi      # 0x1412f
leaq 0xc(%rsp), %rdx
callq 0x4fa0
movq %rbx, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x477c
testb %al, %al
je 0x12855
leaq 0x68(%rsp), %rdi
callq 0x4130
leaq 0x48(%rsp), %rdi
callq 0x4130
leaq 0x28(%rsp), %rdi
callq 0x4130
movq %r14, %rdi
callq 0x4130
movq %r15, %rdi
callq 0x4130
movq %r13, %rdi
movq %rbx, %rsi
callq 0x4892
movq %r13, %rdi
callq 0x49c3
movl %eax, %ebp
movq %r13, %rdi
callq 0x4130
movq %rbx, %rdi
callq 0x1295b
movl $0x2, 0x10(%rsp)
movl %ebp, 0x14(%rsp)
andl $0x0, 0x18(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0xdf10(%rip), %rdi      # 0x20758
movq %r12, %rsi
callq 0x13678
jmp 0x12709
leaq 0x88(%rsp), %rbp
movq %rbp, %rdi
leaq 0x18cb(%rip), %rsi      # 0x14132
leaq 0xb(%rsp), %rdx
callq 0x4fa0
movq %rbx, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x477c
movl %eax, %ebp
leaq 0x88(%rsp), %rdi
callq 0x4130
leaq 0x68(%rsp), %rdi
callq 0x4130
leaq 0x48(%rsp), %rdi
callq 0x4130
leaq 0x28(%rsp), %rdi
callq 0x4130
movq %r14, %rdi
callq 0x4130
movq %r15, %rdi
callq 0x4130
testb %bpl, %bpl
jne 0x12805
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x128ea
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x4130
jmp 0x128ed
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x4130
jmp 0x12900
jmp 0x128fd
jmp 0x1290e
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4130
jmp 0x12911
jmp 0x1291d
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4130
jmp 0x12920
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x4130
jmp 0x12941
jmp 0x1293e
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
jmp 0x12949
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0x4130
jmp 0x12953
movq %rax, %rbx
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
callq 0x12a78
leaq 0x27b3(%rip), %r14      # 0x1512b
leaq 0x48(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x28(%rsp), %rbp
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4fa0
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x477c
testb %al, %al
je 0x129b0
movq %r15, %rdi
callq 0x4130
jmp 0x129e9
movq %rbp, %rdi
leaq 0x2773(%rip), %rsi      # 0x1512d
leaq 0x7(%rsp), %rdx
callq 0x4fa0
movq %rbx, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x477c
movl %eax, %r13d
movq %rbp, %rdi
callq 0x4130
movq %r15, %rdi
callq 0x4130
testb %r13b, %r13b
je 0x12a43
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4892
movq %r12, %rdi
movq %r14, %rsi
callq 0x4f73
movzbl %al, %r13d
xorl $0x15, %r13d
movq %r12, %rdi
callq 0x4130
movq %rbx, %rdi
callq 0x12a78
movl $0x2, 0x8(%rsp)
movl %r13d, 0xc(%rsp)
andl $0x0, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
leaq 0xdd22(%rip), %rdi      # 0x20758
movq %r12, %rsi
callq 0x13678
jmp 0x12987
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12a63
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4130
jmp 0x12a66
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4130
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
callq 0x12b95
leaq 0x269a(%rip), %r14      # 0x1512f
leaq 0x48(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x28(%rsp), %rbp
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4fa0
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x477c
testb %al, %al
je 0x12acd
movq %r15, %rdi
callq 0x4130
jmp 0x12b06
movq %rbp, %rdi
leaq 0x1647(%rip), %rsi      # 0x1411e
leaq 0x7(%rsp), %rdx
callq 0x4fa0
movq %rbx, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x477c
movl %eax, %r13d
movq %rbp, %rdi
callq 0x4130
movq %r15, %rdi
callq 0x4130
testb %r13b, %r13b
je 0x12b60
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4892
movq %r12, %rdi
movq %r14, %rsi
callq 0x4f73
movzbl %al, %r13d
xorl $0x17, %r13d
movq %r12, %rdi
callq 0x4130
movq %rbx, %rdi
callq 0x12b95
movl $0x2, 0x8(%rsp)
movl %r13d, 0xc(%rsp)
andl $0x0, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
leaq 0xdc05(%rip), %rdi      # 0x20758
movq %r12, %rsi
callq 0x13678
jmp 0x12aa4
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12b80
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4130
jmp 0x12b83
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4130
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O2/generot[P]VM-0/src/lang/vc.cc
// Function: value(lexer&)
void value(lexer& lx) {
    string val = lx.accept();

    if(val == "(") {
        expr(lx);

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

        return;
    }

    if(is_numeric(val)) {
        double numval = atof(val.c_str());

        instr in = { INST_VAL, OPC_PUSH, SC_INVALID };
        in.val = numval;

        bytecode.push_back(in);
    } else {
        symbol var = symbol_table[val];
        bytecode.push_back({ INST_ADDR, OPC_PUSH, SC_INVALID, (size_s)var.addr });
        bytecode.push_back({ INST_NOARGS, OPC_DEREF, SC_INVALID });
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4892
leaq 0x257a(%rip), %rsi      # 0x15131
movq %r14, %rdi
callq 0x4f73
testb %al, %al
je 0x12c18
movq %rbx, %rdi
callq 0x125b6
leaq 0x1e95(%rip), %rsi      # 0x14a67
leaq 0x70(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x4fa0
leaq 0x70(%rsp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x477c
leaq 0x70(%rsp), %rdi
callq 0x4130
leaq 0xa8(%rsp), %rdi
movq %rbx, %rsi
callq 0x4892
leaq 0xa8(%rsp), %rdi
jmp 0x12cec
leaq 0x50(%rsp), %rdi
movq %rsp, %rsi
callq 0x43f0
leaq 0x50(%rsp), %rdi
callq 0x4aea
movl %eax, %ebx
leaq 0x50(%rsp), %rdi
callq 0x4130
testb %bl, %bl
je 0x12c6d
movq (%rsp), %rdi
callq 0x4380
movups 0x2541(%rip), %xmm1     # 0x15190
leaq 0x20(%rsp), %rsi
movaps %xmm1, (%rsi)
movsd %xmm0, 0x10(%rsi)
leaq 0xdaf5(%rip), %rdi      # 0x20758
callq 0x13112
jmp 0x12cf1
leaq 0xdab4(%rip), %rdi      # 0x20728
movq %rsp, %rsi
callq 0x13052
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x130e6
movabsq $0x1000000001, %rax     # imm = 0x1000000001
leaq 0x90(%rsp), %rsi
movq %rax, (%rsi)
movl $0x3, 0x8(%rsi)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsi)
leaq 0xdaa3(%rip), %rdi      # 0x20758
callq 0x13678
movabsq $0x1200000002, %rax     # imm = 0x1200000002
leaq 0x90(%rsp), %rsi
movq %rax, (%rsi)
movl $0x3, 0x8(%rsi)
andq $0x0, 0x10(%rsi)
leaq 0xda76(%rip), %rdi      # 0x20758
callq 0x13678
leaq 0x28(%rsp), %rdi
callq 0x4130
movq %rsp, %rdi
callq 0x4130
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
jmp 0x12d06
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x12d26
jmp 0x12d2f
jmp 0x12d2f
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x12d26
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x4130
jmp 0x12d32
jmp 0x12d2f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4130
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
leaq 0xe8f2(%rip), %rsi      # 0x10db1
movq %rdx, %rdi
callq 0x1180
pushq $0x4e
popq %rbx
testq %rax, %rax
je 0x257d
movq %rax, %rbp
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1150
testl %eax, %eax
je 0x24ed
pushq $-0x1
popq %r15
jmp 0x250a
movq %rbp, %rdi
callq 0x1110
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, %rax
pushq $-0x1
popq %r15
cmovneq %rax, %r15
movq %rbp, %rdi
callq 0x1090
testq %r15, %r15
js 0x257d
movq %r15, (%r13)
movq %r15, %rdi
callq 0x1130
movq %rax, %r13
movq %rax, (%r12)
testq %rax, %rax
sete %al
testq %r15, %r15
setne %cl
testb %al, %cl
je 0x253f
pushq $0x53
popq %rbx
jmp 0x257d
leaq 0xe86b(%rip), %rsi      # 0x10db1
movq %r14, %rdi
callq 0x1180
testq %rax, %rax
je 0x257d
movq %rax, %r14
pushq $0x1
popq %rsi
movq %r13, %rdi
movq %r15, %rdx
movq %rax, %rcx
callq 0x1080
movq %rax, %rbx
movq %r14, %rdi
callq 0x1090
xorl %eax, %eax
cmpq %r15, %rbx
pushq $0x4e
popq %rbx
cmovel %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xd5f5(%rip), %rsi      # 0xfb95
movq %rdx, %rdi
callq 0x1180
testq %rax, %rax
je 0x25cd
movq %rax, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x11c0
movq %r15, %rdi
callq 0x1090
xorl %eax, %eax
jmp 0x25d0
pushq $0x4f
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdi, (%rsp)
movq %rsi, 0x8(%rsp)
leaq (,%rsi,8), %rax
movq %rax, 0x10(%rsp)
shrq $0x3d, %rsi
setne %cl
cmpq $-0x40, %rax
setae %al
orb %cl, %al
jne 0x2688
movq %r8, %rbx
movq %rdx, %r15
movq %rsp, %r12
andq $0x0, 0x18(%r12)
andl $0x0, 0x20(%r12)
xorl %ebp, %ebp
cmpq %rbp, %r15
je 0x268c
movq (%r14,%rbp,8), %r13
movq %r12, %rdi
movq %r13, %rsi
cmpq $0x1a, %r13
jb 0x2642
callq 0x269e
jmp 0x2661
cmpq $0x12, %r13
jb 0x264f
callq 0x275f
jmp 0x2661
cmpq $0xa, %r13
jb 0x265c
callq 0x27e7
jmp 0x2661
callq 0x285e
testl %eax, %eax
je 0x2688
pushq $-0x1
popq %rax
movl %r13d, %ecx
shll %cl, %eax
movl 0x20(%rsp), %edx
notl %eax
andl %edx, %eax
shrl %cl, %edx
movl %edx, 0x20(%rsp)
addq %r13, 0x18(%rsp)
movl %eax, (%rbx,%rbp,4)
incq %rbp
jmp 0x2626
xorl %eax, %eax
jmp 0x268f
pushq $0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: ensureBits32
static LODEPNG_INLINE unsigned ensureBits32(LodePNGBitReader* reader, size_t nbits) {
  size_t start = reader->bp >> 3u;
  size_t size = reader->size;
  if(start + 4u < 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);
    reader->buffer |= (((unsigned)reader->data[start + 4] << 24u) << (8u - (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);
    if(start + 3u < size) reader->buffer |= ((unsigned)reader->data[start + 3] << 24u);
    reader->buffer >>= (reader->bp & 7u);
    return reader->bp + nbits <= reader->bitsize;
  }
}

// Assembly:
movq 0x8(%rdi), %rcx
movq 0x18(%rdi), %rax
movq %rax, %rdx
shrq $0x3, %rdx
leaq 0x4(%rdx), %r8
cmpq %rcx, %r8
jae 0x26e0
movq (%rdi), %rsi
movl (%rsi,%rdx), %r8d
andb $0x7, %al
movl %eax, %ecx
shrl %cl, %r8d
movl %r8d, 0x20(%rdi)
movzbl 0x4(%rsi,%rdx), %edx
shll $0x18, %edx
movb $0x8, %cl
subb %al, %cl
shll %cl, %edx
orl %r8d, %edx
movl %edx, 0x20(%rdi)
pushq $0x1
popq %rax
retq
andl $0x0, 0x20(%rdi)
xorl %r8d, %r8d
cmpq %rcx, %rdx
jae 0x26f8
movq (%rdi), %r8
movzbl (%r8,%rdx), %r8d
movl %r8d, 0x20(%rdi)
leaq 0x1(%rdx), %r9
cmpq %rcx, %r9
jae 0x2714
movq (%rdi), %r10
movzbl (%r10,%r9), %r9d
shll $0x8, %r9d
orl %r9d, %r8d
movl %r8d, 0x20(%rdi)
leaq 0x2(%rdx), %r9
cmpq %rcx, %r9
jae 0x2730
movq (%rdi), %r10
movzbl (%r10,%r9), %r9d
shll $0x10, %r9d
orl %r9d, %r8d
movl %r8d, 0x20(%rdi)
addq $0x3, %rdx
cmpq %rcx, %rdx
jae 0x2746
movq (%rdi), %rcx
movzbl (%rcx,%rdx), %ecx
shll $0x18, %ecx
orl %ecx, %r8d
movl %eax, %ecx
andb $0x7, %cl
shrl %cl, %r8d
movl %r8d, 0x20(%rdi)
addq %rax, %rsi
xorl %eax, %eax
cmpq 0x10(%rdi), %rsi
setbe %al
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x8(%rdi), %r8
movq 0x18(%rdi), %rax
movq %rax, %rcx
shrq $0x3, %rcx
leaq 0x3(%rcx), %rdx
cmpq %r8, %rdx
jae 0x278a
movq (%rdi), %rdx
movl (%rdx,%rcx), %edx
andb $0x7, %al
movl %eax, %ecx
shrl %cl, %edx
movl %edx, 0x20(%rdi)
pushq $0x1
popq %rax
retq
andl $0x0, 0x20(%rdi)
xorl %edx, %edx
cmpq %r8, %rcx
jae 0x279f
movq (%rdi), %rdx
movzbl (%rdx,%rcx), %edx
movl %edx, 0x20(%rdi)
leaq 0x1(%rcx), %r9
cmpq %r8, %r9
jae 0x27ba
movq (%rdi), %r10
movzbl (%r10,%r9), %r9d
shll $0x8, %r9d
orl %r9d, %edx
movl %edx, 0x20(%rdi)
addq $0x2, %rcx
cmpq %r8, %rcx
jae 0x27d0
movq (%rdi), %r8
movzbl (%r8,%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %edx
movl %eax, %ecx
andb $0x7, %cl
shrl %cl, %edx
movl %edx, 0x20(%rdi)
addq %rax, %rsi
xorl %eax, %eax
cmpq 0x10(%rdi), %rsi
setbe %al
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x8(%rdi), %r8
movq 0x18(%rdi), %rax
movq %rax, %rcx
shrq $0x3, %rcx
leaq 0x2(%rcx), %rdx
cmpq %r8, %rdx
jae 0x281d
movq (%rdi), %rdx
movzwl (%rdx,%rcx), %esi
movzbl 0x2(%rdx,%rcx), %edx
shll $0x10, %edx
orl %esi, %edx
andb $0x7, %al
movl %eax, %ecx
shrl %cl, %edx
movl %edx, 0x20(%rdi)
pushq $0x1
popq %rax
retq
andl $0x0, 0x20(%rdi)
xorl %edx, %edx
cmpq %r8, %rcx
jae 0x2832
movq (%rdi), %rdx
movzbl (%rdx,%rcx), %edx
movl %edx, 0x20(%rdi)
incq %rcx
cmpq %r8, %rcx
jae 0x2847
movq (%rdi), %r8
movzbl (%r8,%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %edx
movl %eax, %ecx
andb $0x7, %cl
shrl %cl, %edx
movl %edx, 0x20(%rdi)
addq %rax, %rsi
xorl %eax, %eax
cmpq 0x10(%rdi), %rsi
setbe %al
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x8(%rdi), %r8
movq 0x18(%rdi), %rax
movq %rax, %rcx
shrq $0x3, %rcx
leaq 0x1(%rcx), %rdx
cmpq %r8, %rdx
jae 0x288a
movq (%rdi), %rdx
movzwl (%rdx,%rcx), %edx
andb $0x7, %al
movl %eax, %ecx
shrl %cl, %edx
movl %edx, 0x20(%rdi)
pushq $0x1
popq %rax
retq
andl $0x0, 0x20(%rdi)
xorl %edx, %edx
cmpq %r8, %rcx
jae 0x289c
movq (%rdi), %rdx
movzbl (%rdx,%rcx), %edx
movl %eax, %ecx
andb $0x7, %cl
shrl %cl, %edx
movl %edx, 0x20(%rdi)
addq %rax, %rsi
xorl %eax, %eax
cmpq 0x10(%rdi), %rsi
setbe %al
retq
// File: /workspace/github_c_makefile_star2_O2/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_zlib_decompressv
static unsigned lodepng_zlib_decompressv(ucvector* out,
                                         const unsigned char* in, size_t insize,
                                         const LodePNGDecompressSettings* settings) {
  unsigned error = 0;
  unsigned CM, CINFO, FDICT;

  if(insize < 2) return 53; /*error, size of zlib data too small*/
  /*read information from zlib header*/
  if((in[0] * 256 + in[1]) % 31 != 0) {
    /*error: 256 * in[0] + in[1] must be a multiple of 31, the FCHECK value is supposed to be made that way*/
    return 24;
  }

  CM = in[0] & 15;
  CINFO = (in[0] >> 4) & 15;
  /*FCHECK = in[1] & 31;*/ /*FCHECK is already tested above*/
  FDICT = (in[1] >> 5) & 1;
  /*FLEVEL = (in[1] >> 6) & 3;*/ /*FLEVEL is not used here*/

  if(CM != 8 || CINFO > 7) {
    /*error: only compression method 8: inflate with sliding window of 32k is supported by the PNG spec*/
    return 25;
  }
  if(FDICT != 0) {
    /*error: the specification of PNG says about the zlib stream:
      "The additional flags shall not specify a preset dictionary."*/
    return 26;
  }

  error = inflatev(out, in + 2, insize - 2, settings);
  if(error) return error;

  if(!settings->ignore_adler32) {
    unsigned ADLER32 = lodepng_read32bitInt(&in[insize - 4]);
    unsigned checksum = adler32(out->data, (unsigned)(out->size));
    if(checksum != ADLER32) return 58; /*error, adler checksum not correct, data must be corrupted*/
  }

  return 0; /*no error*/
}

// Assembly:
cmpq $0x2, %rdx
jae 0x43c1
pushq $0x35
popq %rax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movzbl (%rsi), %esi
movl %esi, %eax
shll $0x8, %eax
movzbl 0x1(%r15), %ecx
orl %ecx, %eax
movw $0x1f, %di
xorl %edx, %edx
divw %di
testw %dx, %dx
je 0x43f6
pushq $0x18
jmp 0x443e
movl %esi, %eax
andl $0xf, %eax
cmpl $0x8, %eax
setne %al
testb %sil, %sil
sets %dl
orb %al, %dl
je 0x440f
pushq $0x19
jmp 0x443e
testb $0x20, %cl
jne 0x443c
leaq 0x2(%r15), %rdx
leaq -0x2(%r14), %rcx
movq 0x10(%r12), %rax
testq %rax, %rax
je 0x4448
leaq 0x8(%rbx), %rsi
movq %rbx, %rdi
movq %r12, %r8
callq *%rax
movq 0x8(%rbx), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x4459
pushq $0x1a
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r12, %rcx
callq 0x2ead
testl %eax, %eax
jne 0x443f
cmpl $0x0, (%r12)
jne 0x4482
leaq (%r15,%r14), %rdi
addq $-0x4, %rdi
callq 0x460b
movl %eax, %ebp
movq (%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0x4556
cmpl %ebp, %eax
jne 0x4486
xorl %eax, %eax
jmp 0x443f
pushq $0x3a
jmp 0x443e
// File: /workspace/github_c_makefile_star2_O2/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_zlib_compress
unsigned lodepng_zlib_compress(unsigned char** out, size_t* outsize, const unsigned char* in,
                               size_t insize, const LodePNGCompressSettings* settings) {
  size_t i;
  unsigned error;
  unsigned char* deflatedata = 0;
  size_t deflatesize = 0;

  error = deflate(&deflatedata, &deflatesize, in, insize, settings);

  *out = NULL;
  *outsize = 0;
  if(!error) {
    *outsize = deflatesize + 6;
    *out = (unsigned char*)lodepng_malloc(*outsize);
    if(!*out) error = 83; /*alloc fail*/
  }

  if(!error) {
    unsigned ADLER32 = adler32(in, (unsigned)insize);
    /*zlib data: 1 byte CMF (CM+CINFO), 1 byte FLG, deflate data, 4 byte ADLER32 checksum of the Decompressed data*/
    unsigned CMF = 120; /*0b01111000: CM 8, CINFO 7. With CINFO 7, any window size up to 32768 can be used.*/
    unsigned FLEVEL = 0;
    unsigned FDICT = 0;
    unsigned CMFFLG = 256 * CMF + FDICT * 32 + FLEVEL * 64;
    unsigned FCHECK = 31 - CMFFLG % 31;
    CMFFLG += FCHECK;

    (*out)[0] = (unsigned char)(CMFFLG >> 8);
    (*out)[1] = (unsigned char)(CMFFLG & 255);
    for(i = 0; i != deflatesize; ++i) (*out)[i + 2] = deflatedata[i];
    lodepng_set32bitInt(&(*out)[*outsize - 4], ADLER32);
  }

  lodepng_free(deflatedata);
  return error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
andq $0x0, 0x10(%rsp)
movq %rdx, %r12
andq $0x0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%r8), %rax
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
testq %rax, %rax
je 0x44c7
callq *%rax
jmp 0x44cc
callq 0x36ac
movl %eax, %ebp
andq $0x0, (%r14)
andq $0x0, (%rbx)
testl %eax, %eax
jne 0x453b
movq 0x8(%rsp), %rbp
leaq 0x6(%rbp), %rdi
movq %rdi, (%rbx)
callq 0x1130
movq %rax, (%r14)
testq %rax, %rax
je 0x4538
movq %rax, %r13
movq %r12, %rdi
movl %r15d, %esi
callq 0x4556
movw $0x178, (%r13)          # imm = 0x178
xorl %ecx, %ecx
cmpq %rbp, %rcx
je 0x4528
movq 0x10(%rsp), %rdx
movb (%rdx,%rcx), %dl
movq (%r14), %rsi
movb %dl, 0x2(%rsi,%rcx)
incq %rcx
movq 0x8(%rsp), %rbp
jmp 0x450a
movq (%r14), %rcx
movq (%rbx), %rdx
bswapl %eax
movl %eax, -0x4(%rcx,%rdx)
xorl %ebp, %ebp
jmp 0x453b
pushq $0x53
popq %rbp
movq 0x10(%rsp), %rdi
callq 0x1030
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_crc32
unsigned lodepng_crc32(const unsigned char* data, size_t length) {
  unsigned r = 0xffffffffu;
  size_t i;
  for(i = 0; i < length; ++i) {
    r = lodepng_crc32_table[(r ^ data[i]) & 0xffu] ^ (r >> 8u);
  }
  return r ^ 0xffffffffu;
}

// Assembly:
pushq $-0x1
popq %rax
xorl %ecx, %ecx
leaq 0xad06(%rip), %rdx      # 0xf2f0
cmpq %rcx, %rsi
je 0x4606
movb (%rdi,%rcx), %r8b
xorb %al, %r8b
movzbl %r8b, %r8d
shrl $0x8, %eax
xorl (%rdx,%r8,4), %eax
incq %rcx
jmp 0x45ea
notl %eax
retq
// File: /workspace/github_c_makefile_star2_O2/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_chunk_next
unsigned char* lodepng_chunk_next(unsigned char* chunk, unsigned char* end) {
  if(chunk >= end || end - chunk < 12) return end; /*too small to contain a chunk*/
  if(chunk[0] == 0x89 && chunk[1] == 0x50 && chunk[2] == 0x4e && chunk[3] == 0x47
    && chunk[4] == 0x0d && chunk[5] == 0x0a && chunk[6] == 0x1a && chunk[7] == 0x0a) {
    /* Is PNG magic header at start of PNG file. Jump to first actual chunk. */
    return chunk + 8;
  } else {
    size_t total_chunk_length;
    unsigned char* result;
    if(lodepng_addofl(lodepng_chunk_length(chunk), 12, &total_chunk_length)) return end;
    result = chunk + total_chunk_length;
    if(result < chunk) return end; /*pointer overflow*/
    return result;
  }
}

// Assembly:
movq %rsi, %rax
movq %rsi, %rcx
subq %rdi, %rcx
setbe %dl
cmpq $0xc, %rcx
setl %cl
orb %dl, %cl
jne 0x4785
pushq %rbx
movq %rdi, %rbx
cmpb $-0x77, (%rdi)
jne 0x4773
cmpb $0x50, 0x1(%rbx)
jne 0x4773
cmpb $0x4e, 0x2(%rbx)
jne 0x4773
cmpb $0x47, 0x3(%rbx)
jne 0x4773
cmpb $0xd, 0x4(%rbx)
jne 0x4773
cmpb $0xa, 0x5(%rbx)
jne 0x4773
cmpb $0x1a, 0x6(%rbx)
jne 0x4773
cmpb $0xa, 0x7(%rbx)
jne 0x4773
addq $0x8, %rbx
movq %rbx, %rax
jmp 0x4784
movq %rbx, %rdi
callq 0x460b
movl %eax, %eax
addq %rbx, %rax
addq $0xc, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_chunk_next_const
const unsigned char* lodepng_chunk_next_const(const unsigned char* chunk, const unsigned char* end) {
  if(chunk >= end || end - chunk < 12) return end; /*too small to contain a chunk*/
  if(chunk[0] == 0x89 && chunk[1] == 0x50 && chunk[2] == 0x4e && chunk[3] == 0x47
    && chunk[4] == 0x0d && chunk[5] == 0x0a && chunk[6] == 0x1a && chunk[7] == 0x0a) {
    /* Is PNG magic header at start of PNG file. Jump to first actual chunk. */
    return chunk + 8;
  } else {
    size_t total_chunk_length;
    const unsigned char* result;
    if(lodepng_addofl(lodepng_chunk_length(chunk), 12, &total_chunk_length)) return end;
    result = chunk + total_chunk_length;
    if(result < chunk) return end; /*pointer overflow*/
    return result;
  }
}

// Assembly:
movq %rsi, %rax
movq %rsi, %rcx
subq %rdi, %rcx
setbe %dl
cmpq $0xc, %rcx
setl %cl
orb %dl, %cl
jne 0x47eb
pushq %rbx
movq %rdi, %rbx
cmpb $-0x77, (%rdi)
jne 0x47d9
cmpb $0x50, 0x1(%rbx)
jne 0x47d9
cmpb $0x4e, 0x2(%rbx)
jne 0x47d9
cmpb $0x47, 0x3(%rbx)
jne 0x47d9
cmpb $0xd, 0x4(%rbx)
jne 0x47d9
cmpb $0xa, 0x5(%rbx)
jne 0x47d9
cmpb $0x1a, 0x6(%rbx)
jne 0x47d9
cmpb $0xa, 0x7(%rbx)
jne 0x47d9
addq $0x8, %rbx
movq %rbx, %rax
jmp 0x47ea
movq %rbx, %rdi
callq 0x460b
movl %eax, %eax
addq %rbx, %rax
addq $0xc, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_chunk_find
unsigned char* lodepng_chunk_find(unsigned char* chunk, unsigned char* end, const char type[5]) {
  for(;;) {
    if(chunk >= end || end - chunk < 12) return 0; /* past file end: chunk + 12 > end */
    if(lodepng_chunk_type_equals(chunk, type)) return chunk;
    chunk = lodepng_chunk_next(chunk, end);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ebx, %ebx
movq %r15, %rax
subq %r12, %rax
jbe 0x482f
cmpq $0xc, %rax
jl 0x482f
movq %r12, %rdi
movq %r14, %rsi
callq 0x4629
testb %al, %al
jne 0x482c
movq %r12, %rdi
movq %r15, %rsi
callq 0x4720
movq %rax, %r12
jmp 0x47ff
movq %r12, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_chunk_find_const
const unsigned char* lodepng_chunk_find_const(const unsigned char* chunk, const unsigned char* end, const char type[5]) {
  for(;;) {
    if(chunk >= end || end - chunk < 12) return 0; /* past file end: chunk + 12 > end */
    if(lodepng_chunk_type_equals(chunk, type)) return chunk;
    chunk = lodepng_chunk_next_const(chunk, end);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ebx, %ebx
movq %r15, %rax
subq %r12, %rax
jbe 0x4881
cmpq $0xc, %rax
jl 0x4881
movq %r12, %rdi
movq %r14, %rsi
callq 0x4629
testb %al, %al
jne 0x487e
movq %r12, %rdi
movq %r15, %rsi
callq 0x4786
movq %rax, %r12
jmp 0x4851
movq %r12, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_chunk_append
unsigned lodepng_chunk_append(unsigned char** out, size_t* outsize, const unsigned char* chunk) {
  unsigned i;
  size_t total_chunk_length, new_length;
  unsigned char *chunk_start, *new_buffer;

  if(lodepng_addofl(lodepng_chunk_length(chunk), 12, &total_chunk_length)) return 77;
  if(lodepng_addofl(*outsize, total_chunk_length, &new_length)) return 77;

  new_buffer = (unsigned char*)lodepng_realloc(*out, new_length);
  if(!new_buffer) return 83; /*alloc fail*/
  (*out) = new_buffer;
  (*outsize) = new_length;
  chunk_start = &(*out)[new_length - total_chunk_length];

  for(i = 0; i != total_chunk_length; ++i) chunk_start[i] = chunk[i];

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x460b
movl %eax, %r13d
addq $0xc, %r13
movq (%r14), %rbp
movq %r13, %r12
addq %rbp, %r12
jae 0x48c2
pushq $0x4d
jmp 0x48f3
movq (%r15), %rdi
movq %r12, %rsi
callq 0x1160
testq %rax, %rax
je 0x48f1
movq %rax, (%r15)
movq %r12, (%r14)
addq %rax, %rbp
xorl %eax, %eax
xorl %ecx, %ecx
movl %ecx, %ecx
cmpq %rcx, %r13
je 0x48f4
movb (%rbx,%rcx), %dl
movb %dl, (%rbp,%rcx)
incl %ecx
jmp 0x48df
pushq $0x53
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq