LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq 0x20(%rdi), %rax
movq 0x40(%rdi), %rcx
shlq $0x5, %rcx
leaq (%rax,%rcx), %r14
movq 0x8(%rax,%rcx), %rdx
cmpq 0x8(%rsi), %rdx
jne 0x4aef
testq %rdx, %rdx
je 0x4aff
movq (%rbx), %rsi
movq (%r14), %rdi
callq 0x42f0
testl %eax, %eax
sete %al
jmp 0x4af1
xorl %eax, %eax
xorb $0x1, %bpl
orb %al, %bpl
je 0x4b03
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, %al
jmp 0x4afa
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4580
// File: /workspace/github_c_makefile_star2_O3/generot[P]VM-0/src/lang/util.cc
// Function: match_comp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
opcode match_comp(string strrep) {
    string comps[] = { ">", "<", ">=", "<=", "==", "!=" };

    for(int i = 0; i < 6; i++) {
        if(strrep == comps[i])
            return opcode(OPC_GT + i);
    }

    return OPC_INVALID;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %r15
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x122fa(%rip), %rsi     # 0x17125
leaq 0x122f4(%rip), %rdx     # 0x17126
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x59aa
leaq 0x20(%rsp), %r14
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x122d5(%rip), %rsi     # 0x17127
leaq 0x122cf(%rip), %rdx     # 0x17128
movq %r14, %rdi
callq 0x59aa
leaq 0x40(%rsp), %r14
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x122b3(%rip), %rsi     # 0x17129
leaq 0x122ae(%rip), %rdx     # 0x1712b
movq %r14, %rdi
callq 0x59aa
leaq 0x60(%rsp), %r14
leaq 0x70(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x12292(%rip), %rsi     # 0x1712c
leaq 0x1228d(%rip), %rdx     # 0x1712e
movq %r14, %rdi
callq 0x59aa
leaq 0x80(%rsp), %r14
leaq 0x90(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x1226b(%rip), %rsi     # 0x1712f
leaq 0x12266(%rip), %rdx     # 0x17131
movq %r14, %rdi
callq 0x59aa
leaq 0xa0(%rsp), %r14
leaq 0xb0(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x12243(%rip), %rsi     # 0x17132
leaq 0x1223e(%rip), %rdx     # 0x17134
movq %r14, %rdi
callq 0x59aa
movq 0x8(%r15), %r14
movl $0x1a, %ebx
movl $0x8, %r13d
cmpq (%rsp,%r13), %r14
jne 0x4f2c
testq %r14, %r14
je 0x4f40
movq -0x8(%rsp,%r13), %rsi
movq (%r15), %rdi
movq %r14, %rdx
callq 0x42f0
testl %eax, %eax
je 0x4f40
incl %ebx
addq $0x20, %r13
cmpq $0xc8, %r13
jne 0x4f0d
movl $0x26, %ebx
movq $-0xc0, %r14
movq -0x10(%r12), %rdi
cmpq %rdi, %r12
je 0x4f5d
movq (%r12), %rsi
incq %rsi
callq 0x42d0
addq $-0x20, %r12
addq $0x20, %r14
jne 0x4f47
movl %ebx, %eax
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4f82
jmp 0x4f82
jmp 0x4f82
jmp 0x4f82
movq %rax, %r15
addq $-0x10, %r14
movq -0x10(%r14), %rdi
cmpq %rdi, %r14
je 0x4f9d
movq (%r14), %rsi
incq %rsi
callq 0x42d0
leaq -0x20(%r14), %rax
addq $-0x10, %r14
cmpq %rbx, %r14
movq %rax, %r14
jne 0x4f89
movq %r15, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
jle 0x4fef
movq (%rdi), %rdx
addq %rdx, %rcx
incq %rdx
movsbl -0x1(%rdx), %eax
cmpl $0x2e, %eax
sete %sil
addl $-0x30, %eax
cmpl $0xa, %eax
setb %al
orb %sil, %al
cmpb $0x1, %al
jne 0x4fee
leaq 0x1(%rdx), %rsi
cmpq %rcx, %rdx
movq %rsi, %rdx
jb 0x4fc7
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O3/generot[P]VM-0/src/lang/vc.cc
// Function: program(lexer&)
void program(lexer& lx) {
    while(!lx.eof()) {
        if(!(EXPECT("var") || EXPECT("proc") || EXPECT("include")))
            ISSUE_ERROR("Expected top-level declaration, got \"%s\" instead.",
                lx.accept().c_str());

        decl(lx);
        include(lx);
        procedure(lx);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
callq 0x4b0e
testb %al, %al
jne 0x139b3
leaq 0x58(%rsp), %r14
leaq 0x48(%rsp), %r12
leaq 0x28(%rsp), %r13
leaq 0x8(%rsp), %r15
movq %r14, 0x48(%rsp)
movq %r12, %rdi
leaq 0x4714(%rip), %rsi      # 0x17fc1
leaq 0x4710(%rip), %rdx      # 0x17fc4
callq 0x59aa
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4ab4
movb $0x1, %bpl
testb %al, %al
jne 0x1396f
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %r13, %rdi
leaq 0x46e0(%rip), %rsi      # 0x17fc5
leaq 0x46dd(%rip), %rdx      # 0x17fc9
callq 0x59aa
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x4ab4
movb $0x1, %bpl
testb %al, %al
jne 0x13953
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r15, %rbp
movq %r15, %rdi
leaq 0x46ae(%rip), %rsi      # 0x17fca
leaq 0x46ae(%rip), %rdx      # 0x17fd1
callq 0x59aa
movq %rbx, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x4ab4
movl %eax, %ebp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x13953
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42d0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1396f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42d0
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x13986
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x42d0
testb %bpl, %bpl
je 0x139c2
movq %rbx, %rdi
callq 0x13a32
movq %rbx, %rdi
callq 0x13d3c
movq %rbx, %rdi
callq 0x13fd0
movq %rbx, %rdi
callq 0x4b0e
testb %al, %al
je 0x1389e
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x4709
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x139f0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x139f0
jmp 0x139ed
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x13a13
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x13a13
jmp 0x13a10
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x13a2a
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O3/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 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c32
leaq 0x3fd0(%rip), %rsi      # 0x17fc5
movq %r14, %rdi
callq 0x40a0
testl %eax, %eax
je 0x14030
movq %rbx, %rdi
callq 0x4b32
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14024
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x42d0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xd729(%rip), %r15      # 0x21760
subq 0xd71a(%rip), %r15      # 0x21758
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x4c32
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x43a0
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x14077
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0xd6aa(%rip), %rdi      # 0x21728
leaq 0x38(%rsp), %rsi
callq 0x15f9a
cmpl $0x1, (%rax)
je 0x141a3
leaq 0x10(%rsp), %r14
movl $0x1, -0x8(%r14)
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x5834
sarq $0x3, %r15
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %r15, %rax
movq %rax, 0x30(%rsp)
leaq 0xd64d(%rip), %rdi      # 0x21728
leaq 0x38(%rsp), %rsi
callq 0x15f9a
movq %rax, %r15
movl 0x8(%rsp), %eax
movl %eax, (%r15)
movq %r15, %rdi
addq $0x8, %rdi
movq %r14, %rsi
callq 0x43a0
movq 0x30(%rsp), %rax
movq %rax, 0x28(%r15)
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1411e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x141f7
leaq 0x3f3e(%rip), %rsi      # 0x1806b
leaq 0x38(%rsp), %rdi
callq 0x40a0
testl %eax, %eax
je 0x14009
movabsq $0x2400000002, %rax     # imm = 0x2400000002
movq %rax, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0xd5fa(%rip), %rsi      # 0x21760
cmpq 0xd5fb(%rip), %rsi      # 0x21768
je 0x1418d
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x18, 0xd5d8(%rip)     # 0x21760
jmp 0x14009
leaq 0xd5c4(%rip), %rdi      # 0x21758
leaq 0x8(%rsp), %rdx
callq 0x16538
jmp 0x14009
leaq 0x38(%rsp), %rdi
callq 0x4779
jmp 0x141d1
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x141d4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x141d4
jmp 0x141d1
jmp 0x141d1
jmp 0x141d1
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x141ef
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x3e55(%rip), %rsi      # 0x18070
leaq 0x3e4f(%rip), %rdx      # 0x18071
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x59aa
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x4ab4
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x14256
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0x68(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c32
movq (%r14), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x14280
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0x18(%rsp), %r13
leaq 0x3de6(%rip), %r14      # 0x18072
leaq 0x3de0(%rip), %r15      # 0x18073
leaq 0x8(%rsp), %r12
movq %r13, 0x8(%rsp)
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x59aa
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4ab4
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x142d1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42d0
testb %bpl, %bpl
jne 0x142ef
movq %rbx, %rdi
callq 0x14356
movq %rbx, %rdi
callq 0x4b0e
testb %al, %al
je 0x14298
callq 0x47a0
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c32
movq (%r14), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x14319
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x42d0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
jmp 0x1433d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1434e
movq (%r13), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
callq 0x14424
movq %rbx, %rdi
callq 0x1462f
movq %rbx, %rdi
callq 0x1478e
movq %rbx, %rdi
callq 0x148c9
movq %rbx, %rdi
callq 0x14ab0
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3c6e(%rip), %rsi      # 0x18005
leaq 0x3c68(%rip), %rdx      # 0x18006
movq %rsp, %r14
movq %r14, %rdi
callq 0x59aa
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x4ab4
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x143cf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c32
movq (%r14), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x143f9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42d0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1441c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
callq 0x4c32
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3c44(%rip), %rsi      # 0x18095
leaq 0x3c3f(%rip), %rdx      # 0x18097
leaq 0x18(%rsp), %rdi
callq 0x59aa
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4ab4
movl %eax, %ebp
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x1448a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x42d0
testb %bpl, %bpl
je 0x14570
leaq 0xd28e(%rip), %rdi      # 0x21728
leaq 0x38(%rsp), %rsi
callq 0x15f9a
movq %rax, %r14
movl (%rax), %eax
leaq 0x60(%rsp), %rdi
movl %eax, -0x8(%rdi)
leaq 0x70(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
callq 0x5834
movq 0x28(%r14), %rax
movq %rax, 0x80(%rsp)
testq %rax, %rax
je 0x145c9
cmpl $0x0, 0x58(%rsp)
jne 0x145c9
leaq 0x88(%rsp), %rdi
movq %rbx, %rsi
callq 0x4c32
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1451b
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x14eb0
movabsq $0x1300000001, %rax     # imm = 0x1300000001
movq %rax, (%rsp)
movl $0x3, 0x8(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xd213(%rip), %rsi      # 0x21760
cmpq 0xd214(%rip), %rsi      # 0x21768
je 0x1457a
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rsi)
movups (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x18, 0xd1f2(%rip)     # 0x21760
jmp 0x14589
movq %rbx, %rdi
callq 0x4b32
jmp 0x145a0
leaq 0xd1d7(%rip), %rdi      # 0x21758
movq %rsp, %rdx
callq 0x16538
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x145a0
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x145bb
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x42d0
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x38(%rsp), %rdi
callq 0x47c5
jmp 0x145d7
jmp 0x14609
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x1460c
movq 0x70(%rsp), %rsi
jmp 0x145ff
jmp 0x14609
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x1460c
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x1460c
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14627
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3a79(%rip), %rsi      # 0x180c5
leaq 0x3a74(%rip), %rdx      # 0x180c7
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x59aa
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x4ab4
movl %eax, %ebp
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x14686
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x42d0
testb %bpl, %bpl
je 0x14761
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c32
movq (%r14), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x146b9
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x14eb0
movabsq $0x2200000001, %rax     # imm = 0x2200000001
movq %rax, (%rsp)
movl $0x3, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq 0xd079(%rip), %rsi      # 0x21760
cmpq 0xd07a(%rip), %rsi      # 0x21768
je 0x14714
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rsi)
movups (%rsp), %xmm0
movups %xmm0, (%rsi)
movq 0xd059(%rip), %r14      # 0x21760
addq $0x18, %r14
movq %r14, 0xd04e(%rip)      # 0x21760
jmp 0x1472a
leaq 0xd03d(%rip), %rdi      # 0x21758
movq %rsp, %rdx
callq 0x16538
movq 0xd036(%rip), %r14      # 0x21760
subq 0xd027(%rip), %r14      # 0x21758
movq %rbx, %rdi
callq 0x141f7
movq 0xd020(%rip), %rax      # 0x21760
movq 0xd011(%rip), %rcx      # 0x21758
subq %rcx, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
movq %rdx, -0x8(%rcx,%r14)
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x14786
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O3/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 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x391d(%rip), %rsi      # 0x180c8
leaq 0x391b(%rip), %rdx      # 0x180cd
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x59aa
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x4ab4
movl %eax, %ebp
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x147e5
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x42d0
testb %bpl, %bpl
je 0x1489c
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c32
movq (%r14), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x14818
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x42d0
movq 0xcf41(%rip), %rax      # 0x21760
subq 0xcf32(%rip), %rax      # 0x21758
sarq $0x3, %rax
movabsq $-0x5555555555555555, %r14 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r14
movq %rbx, %rdi
callq 0x14eb0
movq %rbx, %rdi
callq 0x141f7
movabsq $0x2100000001, %rax     # imm = 0x2100000001
movq %rax, (%rsp)
movl $0x3, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq 0xcef6(%rip), %rsi      # 0x21760
cmpq 0xcef7(%rip), %rsi      # 0x21768
je 0x1488d
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rsi)
movups (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x18, 0xced5(%rip)     # 0x21760
jmp 0x1489c
leaq 0xcec4(%rip), %rdi      # 0x21758
movq %rsp, %rdx
callq 0x16538
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x148c1
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x48(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x37e5(%rip), %rsi      # 0x180ce
leaq 0x37e2(%rip), %rdx      # 0x180d2
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x59aa
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x4ab4
movl %eax, %ebp
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x14923
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x42d0
testb %bpl, %bpl
je 0x14a42
leaq 0x88(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c32
movq (%r14), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x1495f
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c32
leaq 0xcdb2(%rip), %rdi      # 0x21728
movq %r14, %rsi
callq 0x15f9a
movq %rax, %rbx
movl (%rax), %eax
leaq 0x60(%rsp), %rdi
movl %eax, -0x8(%rdi)
leaq 0x70(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
callq 0x5834
movq 0x28(%rbx), %rax
movq %rax, 0x80(%rsp)
cmpq $0x0, 0x68(%rsp)
je 0x14a50
movabsq $0x2300000001, %rcx     # imm = 0x2300000001
movq %rcx, (%rsp)
movl $0x3, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq 0xcd82(%rip), %rsi      # 0x21760
cmpq 0xcd83(%rip), %rsi      # 0x21768
je 0x14a01
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rsi)
movups (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x18, 0xcd61(%rip)     # 0x21760
jmp 0x14a10
leaq 0xcd50(%rip), %rdi      # 0x21758
movq %rsp, %rdx
callq 0x16538
movq 0x60(%rsp), %rdi
cmpq %r14, %rdi
je 0x14a27
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14a42
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x42d0
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18(%rsp), %rdi
callq 0x47ec
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r14, %rdi
je 0x14a79
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x14a79
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14aa8
movq 0x28(%rsp), %rsi
jmp 0x14aa0
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x14aa8
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O3/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 0x15080
leaq 0x3258(%rip), %r14      # 0x18125
leaq 0x48(%rsp), %r12
leaq 0x8(%rsp), %r13
leaq 0x28(%rsp), %rbp
leaq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
movq %r12, %rdi
movq %r14, %rsi
leaq 0x3234(%rip), %rdx      # 0x18127
callq 0x59aa
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4ab4
movb $0x1, %r15b
testb %al, %al
jne 0x14f5b
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %rbp, %r15
movq %rbp, %rdi
leaq 0x3205(%rip), %rsi      # 0x18128
leaq 0x3200(%rip), %rdx      # 0x1812a
callq 0x59aa
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x4ab4
movl %eax, %r15d
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x14f5b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42d0
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x14f77
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x42d0
testb %r15b, %r15b
je 0x15027
movq %r13, %rdi
movq %rbx, %rsi
callq 0x4c32
movq %r13, %rdi
movq %r14, %rsi
callq 0x40a0
cmpl $0x1, %eax
movl $0x19, %r15d
sbbl $0x0, %r15d
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x14fbf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x15080
movl $0x2, 0x8(%rsp)
movl %r15d, 0xc(%rsp)
movl $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0xc774(%rip), %rsi      # 0x21760
cmpq 0xc775(%rip), %rsi      # 0x21768
je 0x15013
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x18, 0xc752(%rip)     # 0x21760
jmp 0x14edc
leaq 0xc73e(%rip), %rdi      # 0x21758
movq %r13, %rdx
callq 0x16538
jmp 0x14edc
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15059
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1505c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x1505c
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x15078
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O3/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 0x15663
leaq 0x2c7b(%rip), %r14      # 0x1812b
leaq 0x48(%rsp), %r12
leaq 0x8(%rsp), %r13
leaq 0x28(%rsp), %rbp
leaq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
movq %r12, %rdi
movq %r14, %rsi
leaq 0x2c56(%rip), %rdx      # 0x1812c
callq 0x59aa
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4ab4
movb $0x1, %r15b
testb %al, %al
jne 0x1553e
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %rbp, %r15
movq %rbp, %rdi
leaq 0x2c27(%rip), %rsi      # 0x1812d
leaq 0x2c21(%rip), %rdx      # 0x1812e
callq 0x59aa
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x4ab4
movl %eax, %r15d
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1553e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42d0
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x1555a
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x42d0
testb %r15b, %r15b
je 0x1560a
movq %r13, %rdi
movq %rbx, %rsi
callq 0x4c32
movq %r13, %rdi
movq %r14, %rsi
callq 0x40a0
cmpl $0x1, %eax
movl $0x15, %r15d
sbbl $0x0, %r15d
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x155a2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x15663
movl $0x2, 0x8(%rsp)
movl %r15d, 0xc(%rsp)
movl $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0xc191(%rip), %rsi      # 0x21760
cmpq 0xc192(%rip), %rsi      # 0x21768
je 0x155f6
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x18, 0xc16f(%rip)     # 0x21760
jmp 0x154bf
leaq 0xc15b(%rip), %rdi      # 0x21758
movq %r13, %rdx
callq 0x16538
jmp 0x154bf
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1563c
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1563f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x1563f
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x1565b
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O3/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 0x15833
leaq 0x2aaf(%rip), %r14      # 0x1812f
leaq 0x48(%rsp), %r12
leaq 0x8(%rsp), %r13
leaq 0x28(%rsp), %rbp
leaq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
movq %r12, %rdi
movq %r14, %rsi
leaq 0x2a8a(%rip), %rdx      # 0x18130
callq 0x59aa
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4ab4
movb $0x1, %r15b
testb %al, %al
jne 0x1570e
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %rbp, %r15
movq %rbp, %rdi
leaq 0x1a48(%rip), %rsi      # 0x1711e
leaq 0x1a42(%rip), %rdx      # 0x1711f
callq 0x59aa
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x4ab4
movl %eax, %r15d
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1570e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42d0
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x1572a
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x42d0
testb %r15b, %r15b
je 0x157da
movq %r13, %rdi
movq %rbx, %rsi
callq 0x4c32
movq %r13, %rdi
movq %r14, %rsi
callq 0x40a0
cmpl $0x1, %eax
movl $0x17, %r15d
sbbl $0x0, %r15d
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x15772
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x15833
movl $0x2, 0x8(%rsp)
movl %r15d, 0xc(%rsp)
movl $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0xbfc1(%rip), %rsi      # 0x21760
cmpq 0xbfc2(%rip), %rsi      # 0x21768
je 0x157c6
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x18, 0xbf9f(%rip)     # 0x21760
jmp 0x1568f
leaq 0xbf8b(%rip), %rdi      # 0x21758
movq %r13, %rdx
callq 0x16538
jmp 0x1568f
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1580c
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1580f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x1580f
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x1582b
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O3/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, %rbx
movq %rsi, %r12
movq %rdi, %r15
leaq 0x1168e(%rip), %rsi     # 0x13ea1
movq %rdx, %rdi
callq 0x1190
movl $0x4e, %ebp
testq %rax, %rax
je 0x2862
movq %rax, %r13
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x1160
testl %eax, %eax
jne 0x2855
movq %r13, %rdi
callq 0x1120
movq %rax, %r14
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, %r14
jne 0x2873
movq %r13, %rdi
callq 0x1090
movl $0x4e, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
callq 0x1090
testq %r14, %r14
js 0x2862
movq %r14, (%r12)
movq %r14, %rdi
callq 0x1140
movq %rax, %r12
movq %rax, (%r15)
testq %rax, %rax
sete %al
testq %r14, %r14
setne %cl
movl $0x53, %ebp
testb %al, %cl
jne 0x2862
leaq 0x115f3(%rip), %rsi     # 0x13ea1
movq %rbx, %rdi
callq 0x1190
movl $0x4e, %ebp
testq %rax, %rax
je 0x2862
movq %rax, %rbx
movl $0x1, %esi
movq %r12, %rdi
movq %r14, %rdx
movq %rax, %rcx
callq 0x1080
movq %rax, %r15
movq %rbx, %rdi
callq 0x1090
xorl %eax, %eax
cmpq %r14, %r15
movl $0x4e, %ebp
cmovel %eax, %ebp
jmp 0x2862
// File: /workspace/github_c_makefile_star2_O3/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 0x10380(%rip), %rsi     # 0x12c85
movq %rdx, %rdi
callq 0x1190
testq %rax, %rax
je 0x2934
movq %rax, %r15
movl $0x1, %esi
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x11d0
movq %r15, %rdi
callq 0x1090
xorl %eax, %eax
jmp 0x2939
movl $0x4f, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2b74
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)
movl $0x1, %eax
retq
movl $0x0, 0x20(%rdi)
xorl %edx, %edx
cmpq %r8, %rcx
jae 0x2b8c
movq (%rdi), %rdx
movzbl (%rdx,%rcx), %edx
movl %edx, 0x20(%rdi)
incq %rcx
cmpq %r8, %rcx
jae 0x2ba1
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_O3/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 0x2be6
movq (%rdi), %rdx
movzwl (%rdx,%rcx), %edx
andb $0x7, %al
movl %eax, %ecx
shrl %cl, %edx
movl %edx, 0x20(%rdi)
movl $0x1, %eax
retq
movl $0x0, 0x20(%rdi)
xorl %edx, %edx
cmpq %r8, %rcx
jae 0x2bfb
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_O3/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:
testq %rsi, %rsi
je 0x5593
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
leaq 0xce6a(%rip), %rdx      # 0x123e0
movb (%rdi,%rcx), %r8b
xorb %al, %r8b
movzbl %r8b, %r8d
shrl $0x8, %eax
xorl (%rdx,%r8,4), %eax
incq %rcx
cmpq %rcx, %rsi
jne 0x5576
notl %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x574c
movzbl (%rdi), %eax
movl %eax, %edx
xorb $-0x77, %dl
movb 0x1(%rdi), %cl
movl %ecx, %esi
xorb $0x50, %sil
orb %dl, %sil
jne 0x5729
movb $0x50, %cl
cmpb $0x4e, 0x2(%rdi)
jne 0x5729
cmpb $0x47, 0x3(%rdi)
jne 0x5729
cmpb $0xd, 0x4(%rdi)
jne 0x5729
cmpb $0xa, 0x5(%rdi)
jne 0x5729
cmpb $0x1a, 0x6(%rdi)
jne 0x5729
cmpb $0xa, 0x7(%rdi)
jne 0x5729
addq $0x8, %rdi
movq %rdi, %rax
retq
shll $0x18, %eax
movzbl %cl, %ecx
shll $0x10, %ecx
orl %eax, %ecx
movzbl 0x2(%rdi), %eax
shll $0x8, %eax
orl %ecx, %eax
movzbl 0x3(%rdi), %ecx
orq %rax, %rcx
leaq (%rdi,%rcx), %rax
addq $0xc, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x57cb
movzbl (%rdi), %eax
movl %eax, %edx
xorb $-0x77, %dl
movb 0x1(%rdi), %cl
movl %ecx, %esi
xorb $0x50, %sil
orb %dl, %sil
jne 0x57a8
movb $0x50, %cl
cmpb $0x4e, 0x2(%rdi)
jne 0x57a8
cmpb $0x47, 0x3(%rdi)
jne 0x57a8
cmpb $0xd, 0x4(%rdi)
jne 0x57a8
cmpb $0xa, 0x5(%rdi)
jne 0x57a8
cmpb $0x1a, 0x6(%rdi)
jne 0x57a8
cmpb $0xa, 0x7(%rdi)
jne 0x57a8
addq $0x8, %rdi
movq %rdi, %rax
retq
shll $0x18, %eax
movzbl %cl, %ecx
shll $0x10, %ecx
orl %eax, %ecx
movzbl 0x2(%rdi), %eax
shll $0x8, %eax
orl %ecx, %eax
movzbl 0x3(%rdi), %ecx
orq %rax, %rcx
leaq (%rdi,%rcx), %rax
addq $0xc, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rsi, %rax
subq %rdi, %rax
setbe %cl
cmpq $0xc, %rax
setl %al
orb %cl, %al
je 0x57ed
xorl %r14d, %r14d
jmp 0x5829
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, %r12
xorl %r14d, %r14d
movq %r15, %rdi
movq %r12, %rsi
callq 0x55b2
testb %al, %al
jne 0x5826
movq %r15, %rdi
movq %rbx, %rsi
callq 0x56ce
movq %rax, %r15
movq %rbx, %rax
subq %r15, %rax
jbe 0x5829
cmpq $0xb, %rax
jg 0x57f9
jmp 0x5829
movq %r15, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rsi, %rax
subq %rdi, %rax
setbe %cl
cmpq $0xc, %rax
setl %al
orb %cl, %al
je 0x5859
xorl %r14d, %r14d
jmp 0x5895
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, %r12
xorl %r14d, %r14d
movq %r15, %rdi
movq %r12, %rsi
callq 0x55b2
testb %al, %al
jne 0x5892
movq %r15, %rdi
movq %rbx, %rsi
callq 0x574d
movq %rax, %r15
movq %rbx, %rax
subq %r15, %rax
jbe 0x5895
cmpq $0xb, %rax
jg 0x5865
jmp 0x5895
movq %r15, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl (%rdx), %r13d
bswapl %r13d
addq $0xc, %r13
movq (%rsi), %rbp
movq %r13, %r12
movl $0x4d, %eax
addq %rbp, %r12
jb 0x5907
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
movq %r12, %rsi
callq 0x1170
testq %rax, %rax
je 0x5902
movq %rax, (%r15)
movq %r12, (%r14)
addq %rax, %rbp
xorl %eax, %eax
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
movb %dl, (%rbp,%rcx)
incq %rcx
movl %ecx, %edx
cmpq %rdx, %r13
jne 0x58ef
jmp 0x5907
movl $0x53, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_chunk_createv
static unsigned lodepng_chunk_createv(ucvector* out,
                                      unsigned length, const char* type, const unsigned char* data) {
  unsigned char* chunk;
  CERROR_TRY_RETURN(lodepng_chunk_init(&chunk, out, length, type));

  /*3: the data*/
  lodepng_memcpy(chunk + 8, data, length);

  /*4: CRC (of the chunkname characters and the data)*/
  lodepng_chunk_generate_crc(chunk);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %rcx
movl %esi, %r14d
movq %rdi, %rsi
movq %rsp, %rdi
movl %r14d, %edx
callq 0xd210
movl %eax, %ebp
testl %eax, %eax
jne 0x59a6
movq (%rsp), %r15
testl %r14d, %r14d
je 0x599e
movl %r14d, %edx
leaq 0x8(%r15), %rdi
movq %rbx, %rsi
callq 0x1130
movq %r15, %rdi
callq 0x568d
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_color_mode_copy
unsigned lodepng_color_mode_copy(LodePNGColorMode* dest, const LodePNGColorMode* source) {
  lodepng_color_mode_cleanup(dest);
  lodepng_memcpy(dest, source, sizeof(LodePNGColorMode));
  if(source->palette) {
    dest->palette = (unsigned char*)lodepng_malloc(1024);
    if(!dest->palette && source->palettesize) return 83; /*alloc fail*/
    lodepng_memcpy(dest->palette, source->palette, source->palettesize * 4);
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %r15
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x5a27
callq 0x1030
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq 0x20(%rbx), %rax
movq %rax, 0x20(%r14)
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x10(%r14)
movups %xmm0, (%r14)
xorl %ebp, %ebp
cmpq $0x0, 0x8(%rbx)
je 0x5a89
movl $0x400, %edi            # imm = 0x400
callq 0x1140
movq %rax, (%r15)
movq 0x10(%rbx), %rdx
testq %rax, %rax
je 0x5a7c
shlq $0x2, %rdx
testq %rdx, %rdx
je 0x5a89
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x1130
jmp 0x5a89
xorl %eax, %eax
testq %rdx, %rdx
movl $0x53, %ebp
cmovel %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_palette_add
unsigned lodepng_palette_add(LodePNGColorMode* info,
                             unsigned char r, unsigned char g, unsigned char b, unsigned char a) {
  if(!info->palette) /*allocate palette if empty*/ {
    lodepng_color_mode_alloc_palette(info);
    if(!info->palette) return 83; /*alloc fail*/
  }
  if(info->palettesize >= 256) {
    return 108; /*too many palette values*/
  }
  info->palette[4 * info->palettesize + 0] = r;
  info->palette[4 * info->palettesize + 1] = g;
  info->palette[4 * info->palettesize + 2] = b;
  info->palette[4 * info->palettesize + 3] = a;
  ++info->palettesize;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r14
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
jne 0x5ada
movq %r14, %rdi
callq 0x5b2c
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0x5b1e
movq 0x10(%r14), %rdx
movl $0x6c, %eax
cmpq $0xff, %rdx
ja 0x5b23
movb %r12b, (%rcx,%rdx,4)
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
movb %r15b, 0x1(%rax,%rcx,4)
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
movb %bpl, 0x2(%rax,%rcx,4)
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
movb %bl, 0x3(%rax,%rcx,4)
incq 0x10(%r14)
xorl %eax, %eax
jmp 0x5b23
movl $0x53, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_color_mode_alloc_palette
static void lodepng_color_mode_alloc_palette(LodePNGColorMode* info) {
  size_t i;
  /*if the palette is already allocated, it will have size 1024 so no reallocation needed in that case*/
  /*the palette must have room for up to 256 colors with 4 bytes each.*/
  if(!info->palette) info->palette = (unsigned char*)lodepng_malloc(1024);
  if(!info->palette) return; /*alloc fail*/
  for(i = 0; i != 256; ++i) {
    /*Initialize all unused colors with black, the value used for invalid palette indices.
    This is an error according to the PNG spec, but common PNG decoders make it black instead.
    That makes color conversion slightly faster due to no error handling needed.*/
    info->palette[i * 4 + 0] = 0;
    info->palette[i * 4 + 1] = 0;
    info->palette[i * 4 + 2] = 0;
    info->palette[i * 4 + 3] = 255;
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
jne 0x5b4a
movl $0x400, %edi            # imm = 0x400
callq 0x1140
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x5b7a
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x8(%rbx), %rdx
movb %al, (%rdx,%rcx,4)
movq 0x8(%rbx), %rdx
movb %al, 0x1(%rdx,%rcx,4)
movq 0x8(%rbx), %rdx
movb %al, 0x2(%rdx,%rcx,4)
movq 0x8(%rbx), %rdx
movb $-0x1, 0x3(%rdx,%rcx,4)
incq %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0x5b4e
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_has_palette_alpha
unsigned lodepng_has_palette_alpha(const LodePNGColorMode* info) {
  size_t i;
  for(i = 0; i != info->palettesize; ++i) {
    if(info->palette[i * 4 + 3] < 255) return 1;
  }
  return 0;
}

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x5c06
movq 0x8(%rdi), %rcx
xorl %edx, %edx
cmpb $-0x1, 0x3(%rcx,%rdx,4)
jne 0x5c09
incq %rdx
cmpq %rdx, %rax
jne 0x5bf7
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/tditlu[P]shadetabler/src/lodepng/lodepng.c
// Function: lodepng_add_text_sized
static unsigned lodepng_add_text_sized(LodePNGInfo* info, const char* key, const char* str, size_t size) {
  char** new_keys = (char**)(lodepng_realloc(info->text_keys, sizeof(char*) * (info->text_num + 1)));
  char** new_strings = (char**)(lodepng_realloc(info->text_strings, sizeof(char*) * (info->text_num + 1)));

  if(new_keys) info->text_keys = new_keys;
  if(new_strings) info->text_strings = new_strings;

  if(!new_keys || !new_strings) return 83; /*alloc fail*/

  ++info->text_num;
  info->text_keys[info->text_num - 1] = alloc_string(key);
  info->text_strings[info->text_num - 1] = alloc_string_sized(str, size);
  if(!info->text_keys[info->text_num - 1] || !info->text_strings[info->text_num - 1]) return 83; /*alloc fail*/

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x1170
movq %rax, %r13
movq 0x48(%rbx), %rax
movq 0x58(%rbx), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x1170
testq %r13, %r13
je 0x5d5e
movq %r13, 0x50(%rbx)
movl $0x53, %ebp
testq %rax, %rax
je 0x5d6c
movq %rax, 0x58(%rbx)
incq 0x48(%rbx)
movq %r12, %rdi
callq 0xd291
movq 0x48(%rbx), %r13
movq 0x50(%rbx), %rcx
movq %rax, -0x8(%rcx,%r13,8)
leaq 0x1(%r14), %rdi
callq 0x1140
movq %rax, %r12
testq %rax, %rax
je 0x5d33
testq %r14, %r14
je 0x5d2e
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1130
movb $0x0, (%r12,%r14)
movq 0x58(%rbx), %rax
movq %r12, -0x8(%rax,%r13,8)
movq 0x50(%rbx), %rax
cmpq $0x0, -0x8(%rax,%r13,8)
je 0x5d6c
movq 0x58(%rbx), %rax
xorl %ecx, %ecx
cmpq $0x0, -0x8(%rax,%r13,8)
movl $0x53, %ebp
cmovnel %ecx, %ebp
jmp 0x5d6c
movl $0x53, %ebp
testq %rax, %rax
je 0x5d6c
movq %rax, 0x58(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq