LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/parser.cpp
// Function: Parser::Operation(std::unique_ptr<AST, std::default_delete<AST>> (Parser::*)())
AST_PTR Parser::Operation(PARSER_AST_FUNC ast_func)
{
    DEF_AST_RET(BinaryOperationExpression);
    ret->optr=Literal();
    ret->expr=(this->*ast_func)();
    RETURN_PTR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl $0x18, %edi
callq 0x6220
movq %rax, %rbx
leaq 0x19523(%rip), %rbp     # 0x2e710
addq $0x10, %rbp
movq %rbp, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rsp, %rdi
movq %r12, %rsi
callq 0x136fc
movq (%rsp), %rax
movq %rax, 0x10(%rbx)
addq %r13, %r12
testb $0x1, %r15b
je 0x15220
movq (%r12), %rax
movq -0x1(%rax,%r15), %r15
movq %rsp, %rdi
movq %r12, %rsi
callq *%r15
movq %rbx, %rax
addq $0x8, %rax
movq (%rsp), %rcx
movq $0x0, (%rsp)
movq (%rax), %rdi
movq %rcx, (%rax)
testq %rdi, %rdi
je 0x1525c
movq (%rdi), %rax
callq *0x28(%rax)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1525c
movq (%rdi), %rax
callq *0x28(%rax)
movq %rbx, (%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rbp
jmp 0x1527c
movq %rax, %r14
movq %rbx, %rdi
callq *0x28(%rbp)
movq %r14, %rdi
callq 0x6450
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/parser.cpp
// Function: Parser::Block()
AST_PTR Parser::Block()
{
    if(!acceptEat(TOKEN_LEFT_BARCKET))PARSER_ERROR("expected a '{'");
    auto stmtlist=StatementList();
    DEF_AST_RET(Block);
    ret->nodes.swap(((AST_NAME(StatementList)*)stmtlist.get())->nodes);
    if(!acceptEat(TOKEN_RIGHT_BARCKET))Statement();
    RETURN_PTR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
xorl %esi, %esi
callq 0x12884
cmpl $0x12, (%rax)
jne 0x15358
incl 0x20(%r12)
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x15420
movl $0x20, %edi
callq 0x6220
movq %rax, %r15
leaq 0x19121(%rip), %r13     # 0x2e3f8
addq $0x10, %r13
movq %r13, (%rax)
movq 0x8(%rsp), %rbx
movups 0x8(%rbx), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
movq %r12, %rdi
xorl %esi, %esi
callq 0x12884
cmpl $0x13, (%rax)
jne 0x15318
incl 0x20(%r12)
jmp 0x1533a
movq %rsp, %rdi
movq %r12, %rsi
callq 0x1552e
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x15332
movq (%rdi), %rax
callq *0x28(%rax)
movq $0x0, (%rsp)
movq %r15, (%r14)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x70, %edi
callq 0x6140
movq %rax, %rbx
movq %r12, %rdi
xorl %esi, %esi
callq 0x12884
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xb6bc(%rip), %rsi      # 0x20a3e
leaq 0xb6c3(%rip), %rdx      # 0x20a4c
leaq 0x8(%rsp), %rdi
callq 0xb1b4
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7bdc
xorl %ebp, %ebp
leaq 0x18889(%rip), %rsi     # 0x2dc38
leaq -0x4976(%rip), %rdx     # 0x10a40
movq %rbx, %rdi
callq 0x6440
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x153d8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
testb %bpl, %bpl
jne 0x153ec
jmp 0x15418
jmp 0x153e9
movq %rax, %r14
movq (%r15), %r13
jmp 0x153f9
movq %rax, %r14
movq %rbx, %rdi
callq 0x61c0
jmp 0x15418
movq %rax, %r14
movq %r15, %rdi
callq *0x28(%r13)
jmp 0x1540f
movq %rax, %r14
movq 0x8(%rsp), %rbx
testq %rbx, %rbx
je 0x15418
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movq %r14, %rdi
callq 0x6450
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/parser.cpp
// Function: Parser::StatementList()
AST_PTR Parser::StatementList()
{
    DEF_AST_RET(StatementList);
    int status;
    while(!accept(TOKEN_EOF))
    {
        status=tokenStatus();
        try
        {
            ret->nodes.push_back(Statement());
        }
        catch(Exception)
        {
            tokenStatus(status);
            break;
        }
    }
    RETURN_PTR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x20, %edi
callq 0x6220
movq %rax, %rbx
leaq 0x18f00(%rip), %rax     # 0x2e348
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
leaq 0x8(%rsp), %r13
movq %r15, %rdi
xorl %esi, %esi
callq 0x12884
cmpl $0x1, (%rax)
je 0x154fa
movl 0x20(%r15), %ebp
movq %r13, %rdi
movq %r15, %rsi
callq 0x1552e
movq %r12, %rdi
movq %r13, %rsi
callq 0x18748
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x15467
movq (%rdi), %rax
callq *0x28(%rax)
jmp 0x15467
movq %rdx, %r13
movq %rax, %r12
jmp 0x154c4
movq %rdx, %r13
movq %rax, %r12
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x154c4
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x1, %r13d
jne 0x1551c
movq %r12, %rdi
callq 0x6300
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x17f4c
movq %r12, %rdi
callq 0x6120
movl %ebp, 0x20(%r15)
leaq 0x8(%rsp), %rdi
callq 0x10a40
callq 0x6420
movq %rbx, (%r14)
movq %r14, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15519
movq %rax, %rdi
callq 0x79b7
movq %rax, %r12
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movq %r12, %rdi
callq 0x6450
nop
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/parser.cpp
// Function: Parser::VariableDeclaration()
AST_PTR Parser::VariableDeclaration()
{
    
    if(!accept(TOKEN_IDENTIFIER))PARSER_ERROR("expected a identifier");
    DEF_AST_RET(VariableDeclaration);
    ret->identifier=Literal();
    if(acceptEat(TOKEN_ASSIGN))ret->assignExpr=AssignmentExpression();
    RETURN_PTR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
xorl %esi, %esi
callq 0x12884
cmpl $0x2e, (%rax)
jne 0x159c5
movl $0x18, %edi
callq 0x6220
movq %rax, %rbx
leaq 0x18fe7(%rip), %rax     # 0x2e920
addq $0x10, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x136fc
movq %rbx, %rax
addq $0x8, %rax
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq %r15, %rdi
xorl %esi, %esi
callq 0x12884
cmpl $0x20, (%rax)
jne 0x159b4
incl 0x20(%r15)
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x137a8
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rsp)
movq 0x10(%rbx), %rdi
movq %rax, 0x10(%rbx)
testq %rdi, %rdi
je 0x159b4
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x159b4
movq (%rdi), %rax
callq *0x28(%rax)
movq %rbx, (%r14)
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x70, %edi
callq 0x6140
movq %rax, %rbx
movq %r15, %rdi
xorl %esi, %esi
callq 0x12884
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xb05e(%rip), %rsi      # 0x20a4d
leaq 0xb06c(%rip), %rdx      # 0x20a62
leaq 0x8(%rsp), %rdi
callq 0xb1b4
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7bdc
xorl %ebp, %ebp
leaq 0x1821c(%rip), %rsi     # 0x2dc38
leaq -0x4fe3(%rip), %rdx     # 0x10a40
movq %rbx, %rdi
callq 0x6440
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x15a45
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
testb %bpl, %bpl
jne 0x15a53
jmp 0x15a6b
jmp 0x15a50
jmp 0x15a5f
movq %rax, %r14
movq %rbx, %rdi
callq 0x61c0
jmp 0x15a6b
jmp 0x15a5f
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movq %r14, %rdi
callq 0x6450
nop
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/parser.cpp
// Function: Parser::VariableStatement()
AST_PTR Parser::VariableStatement()
{
    if(!acceptEat("var"))PARSER_ERROR("expected a 'var'");
    DEF_AST_RET(VariableDeclarationList);
    do ret->nodes.push_back(VariableDeclaration());while(acceptEat(TOKEN_COMMA));
    if(!acceptEat(TOKEN_SEMICOLON))PARSER_ERROR("expected a ';'");
    RETURN_PTR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0xafd4(%rip), %rsi      # 0x20a63
movq %r14, %rdi
callq 0x1808a
testb %al, %al
je 0x15b39
movl $0x20, %edi
callq 0x6220
movq %rax, %rbx
leaq 0x188ed(%rip), %rax     # 0x2e3a0
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x15902
movq %r12, %rdi
movq %r13, %rsi
callq 0x18748
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x15af8
movq (%rdi), %rax
callq *0x28(%rax)
movq %r14, %rdi
xorl %esi, %esi
callq 0x12884
cmpl $0x2a, (%rax)
jne 0x15b0d
incl 0x20(%r14)
jmp 0x15ad2
movq %r14, %rdi
xorl %esi, %esi
callq 0x12884
cmpl $0x29, (%rax)
jne 0x15ba1
incl 0x20(%r14)
movq %rbx, (%r15)
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x70, %edi
callq 0x6140
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x12884
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xaf04(%rip), %rsi      # 0x20a67
leaq 0xaf0d(%rip), %rdx      # 0x20a77
leaq 0x8(%rsp), %rdi
callq 0xb1b4
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7bdc
xorl %ebp, %ebp
leaq 0x180a8(%rip), %rsi     # 0x2dc38
leaq -0x5157(%rip), %rdx     # 0x10a40
movq %rbx, %rdi
callq 0x6440
jmp 0x15c08
movl $0x70, %edi
callq 0x6140
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
callq 0x12884
movq %rax, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xaeac(%rip), %rsi      # 0x20a78
leaq 0xaeb3(%rip), %rdx      # 0x20a86
leaq 0x8(%rsp), %rdi
callq 0xb1b4
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x7bdc
xorl %ebp, %ebp
leaq 0x1803f(%rip), %rsi     # 0x2dc38
leaq -0x51c0(%rip), %rdx     # 0x10a40
movq %r15, %rdi
callq 0x6440
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x15c22
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
testb %bpl, %bpl
jne 0x15c51
jmp 0x15c84
jmp 0x15c4e
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x15c45
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
testb %bpl, %bpl
jne 0x15c5e
jmp 0x15c8d
jmp 0x15c5b
movq %rax, %r14
movq %r15, %rdi
callq 0x61c0
jmp 0x15c84
movq %rax, %r14
movq %rbx, %rdi
callq 0x61c0
jmp 0x15c8d
jmp 0x15c81
jmp 0x15c81
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x15c84
movq (%rdi), %rax
callq *0x28(%rax)
jmp 0x15c84
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movq %r14, %rdi
callq 0x6450
nop
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/parser.cpp
// Function: Parser::ExpressionStatement()
AST_PTR Parser::ExpressionStatement()
{
    DEF_AST_RET(ExpressionStatement);
    ret->expr=Expression();
    if(!acceptEat(TOKEN_SEMICOLON))PARSER_ERROR("excepted a ';'");
    RETURN_PTR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x10, %edi
callq 0x6220
movq %rax, %rbx
leaq 0x18bb4(%rip), %rax     # 0x2e870
addq $0x10, %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rsp, %rdi
movq %r15, %rsi
callq 0x14434
movq (%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r15, %rdi
xorl %esi, %esi
callq 0x12884
cmpl $0x29, (%rax)
jne 0x15d04
incl 0x20(%r15)
movq %rbx, (%r14)
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x70, %edi
callq 0x6140
movq %rax, %r14
movq %r15, %rdi
xorl %esi, %esi
callq 0x12884
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xad58(%rip), %rsi      # 0x20a87
leaq 0xad5f(%rip), %rdx      # 0x20a95
movq %rsp, %rdi
callq 0xb1b4
movb $0x1, %bpl
movq %rsp, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x7bdc
xorl %ebp, %ebp
leaq 0x17ee0(%rip), %rsi     # 0x2dc38
leaq -0x531f(%rip), %rdx     # 0x10a40
movq %r14, %rdi
callq 0x6440
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x15d80
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6230
testb %bpl, %bpl
jne 0x15d8c
jmp 0x15d9b
jmp 0x15d89
movq %rax, %r15
movq %r14, %rdi
callq 0x61c0
jmp 0x15d9b
jmp 0x15d98
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movq %r15, %rdi
callq 0x6450
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/parser.cpp
// Function: Parser::ContinueStatement()
AST_PTR Parser::ContinueStatement()
{
    if(!accept("continue"))PARSER_ERROR("excepted a 'continue'");
    DEF_AST_RET(ContinueStatement);
    ret->literal=Literal();
    if(!acceptEat(TOKEN_SEMICOLON))PARSER_ERROR("excepted a ';'");
    RETURN_PTR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x9aae(%rip), %rsi      # 0x2085b
leaq 0x9aaf(%rip), %rdx      # 0x20863
movq %rsp, %rdi
callq 0xb1b4
movq %rsp, %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x129a2
movl %eax, %ebx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x16de1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6230
testb %bl, %bl
je 0x16e41
movl $0x10, %edi
callq 0x6220
movq %rax, %rbx
leaq 0x17e3f(%rip), %rax     # 0x2ec38
addq $0x10, %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rsp, %rdi
movq %r14, %rsi
callq 0x136fc
movq (%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x12884
cmpl $0x29, (%rax)
jne 0x16e9f
incl 0x20(%r14)
movq %rbx, (%r15)
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x70, %edi
callq 0x6140
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x12884
movq %rax, %r14
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x9cc4(%rip), %rsi      # 0x20b2c
leaq 0x9cd2(%rip), %rdx      # 0x20b41
callq 0xb1b4
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7bdc
xorl %ebp, %ebp
leaq 0x16daa(%rip), %rsi     # 0x2dc38
leaq -0x6455(%rip), %rdx     # 0x10a40
movq %rbx, %rdi
callq 0x6440
jmp 0x16efb
movl $0x70, %edi
callq 0x6140
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
callq 0x12884
movq %rax, %r14
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x9bc1(%rip), %rsi      # 0x20a87
leaq 0x9bc8(%rip), %rdx      # 0x20a95
callq 0xb1b4
movb $0x1, %bpl
movq %rsp, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x7bdc
xorl %ebp, %ebp
leaq 0x16d4c(%rip), %rsi     # 0x2dc38
leaq -0x64b3(%rip), %rdx     # 0x10a40
movq %r15, %rdi
callq 0x6440
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x16f14
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6230
testb %bpl, %bpl
jne 0x16f42
jmp 0x16f5e
jmp 0x16f3f
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x16f36
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6230
testb %bpl, %bpl
jne 0x16f4f
jmp 0x16f87
jmp 0x16f4c
movq %rax, %r14
movq %r15, %rdi
callq 0x61c0
jmp 0x16f5e
movq %rax, %r14
movq %rbx, %rdi
callq 0x61c0
jmp 0x16f87
jmp 0x16f5b
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
jmp 0x16f87
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x16f87
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6230
jmp 0x16f87
movq %rax, %r14
movq %r14, %rdi
callq 0x6450
nop
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/parser.cpp
// Function: Parser::BreakStatement()
AST_PTR Parser::BreakStatement()
{
    if(!accept("break"))PARSER_ERROR("excepted a 'break'");
    DEF_AST_RET(BreakStatement);
    ret->literal=Literal();
    if(!acceptEat(TOKEN_SEMICOLON))PARSER_ERROR("excepted a ';'");
    RETURN_PTR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x98bd(%rip), %rsi      # 0x20870
leaq 0x98bb(%rip), %rdx      # 0x20875
movq %rsp, %rdi
callq 0xb1b4
movq %rsp, %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x129a2
movl %eax, %ebx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x16fe7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6230
testb %bl, %bl
je 0x17047
movl $0x10, %edi
callq 0x6220
movq %rax, %rbx
leaq 0x17c91(%rip), %rax     # 0x2ec90
addq $0x10, %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rsp, %rdi
movq %r14, %rsi
callq 0x136fc
movq (%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x12884
cmpl $0x29, (%rax)
jne 0x170a5
incl 0x20(%r14)
movq %rbx, (%r15)
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x70, %edi
callq 0x6140
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x12884
movq %rax, %r14
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x9ad4(%rip), %rsi      # 0x20b42
leaq 0x9adf(%rip), %rdx      # 0x20b54
callq 0xb1b4
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7bdc
xorl %ebp, %ebp
leaq 0x16ba4(%rip), %rsi     # 0x2dc38
leaq -0x665b(%rip), %rdx     # 0x10a40
movq %rbx, %rdi
callq 0x6440
jmp 0x17101
movl $0x70, %edi
callq 0x6140
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
callq 0x12884
movq %rax, %r14
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x99bb(%rip), %rsi      # 0x20a87
leaq 0x99c2(%rip), %rdx      # 0x20a95
callq 0xb1b4
movb $0x1, %bpl
movq %rsp, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x7bdc
xorl %ebp, %ebp
leaq 0x16b46(%rip), %rsi     # 0x2dc38
leaq -0x66b9(%rip), %rdx     # 0x10a40
movq %r15, %rdi
callq 0x6440
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1711a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6230
testb %bpl, %bpl
jne 0x17148
jmp 0x17164
jmp 0x17145
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1713c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6230
testb %bpl, %bpl
jne 0x17155
jmp 0x1718d
jmp 0x17152
movq %rax, %r14
movq %r15, %rdi
callq 0x61c0
jmp 0x17164
movq %rax, %r14
movq %rbx, %rdi
callq 0x61c0
jmp 0x1718d
jmp 0x17161
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
jmp 0x1718d
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1718d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6230
jmp 0x1718d
movq %rax, %r14
movq %r14, %rdi
callq 0x6450
nop
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/parser.cpp
// Function: Parser::CaseClause()
AST_PTR Parser::CaseClause()
{
    if(!acceptEat("case"))PARSER_ERROR("expected a 'case'");
    DEF_AST_RET(CaseClause);
    ret->expr=Expression();
    if(!acceptEat(TOKEN_COLON))PARSER_ERROR("expected a ':'");
    ret->stmtList=StatementList();
    RETURN_PTR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r12
movq %rdi, %r14
leaq 0x99a6(%rip), %rsi      # 0x20b55
movq %r12, %rdi
callq 0x181b2
testb %al, %al
je 0x17247
movl $0x18, %edi
callq 0x6220
movq %rax, %rbx
leaq 0x178ad(%rip), %rax     # 0x2ea80
addq $0x10, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq %rsp, %rdi
movq %r12, %rsi
callq 0x14434
movq %rbx, %rax
addq $0x8, %rax
movq (%rsp), %rcx
movq %rcx, (%rax)
movq %r12, %rdi
xorl %esi, %esi
callq 0x12884
cmpl $0x2c, (%rax)
jne 0x172ab
incl 0x20(%r12)
movq %rsp, %rdi
movq %r12, %rsi
callq 0x15420
movq (%rsp), %rax
movq 0x10(%rbx), %rdi
movq %rax, 0x10(%rbx)
testq %rdi, %rdi
je 0x17234
movq (%rdi), %rax
callq *0x28(%rax)
movq %rbx, (%r14)
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x70, %edi
callq 0x6140
movq %rax, %rbx
movq %r12, %rdi
xorl %esi, %esi
callq 0x12884
movq %rax, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x98e9(%rip), %rsi      # 0x20b5a
leaq 0x98f3(%rip), %rdx      # 0x20b6b
movq %rsp, %rdi
callq 0xb1b4
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7bdc
xorl %ebp, %ebp
leaq 0x1699e(%rip), %rsi     # 0x2dc38
leaq -0x6861(%rip), %rdx     # 0x10a40
movq %rbx, %rdi
callq 0x6440
jmp 0x1730e
movl $0x70, %edi
callq 0x6140
movq %rax, %r15
movq %r12, %rdi
xorl %esi, %esi
callq 0x12884
movq %rax, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x9896(%rip), %rsi      # 0x20b6c
leaq 0x989d(%rip), %rdx      # 0x20b7a
movq %rsp, %rdi
callq 0xb1b4
movb $0x1, %bpl
movq %rsp, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x7bdc
xorl %ebp, %ebp
leaq 0x16939(%rip), %rsi     # 0x2dc38
leaq -0x68c6(%rip), %rdx     # 0x10a40
movq %r15, %rdi
callq 0x6440
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x17327
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6230
testb %bpl, %bpl
jne 0x17355
jmp 0x17373
jmp 0x17352
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x17349
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6230
testb %bpl, %bpl
jne 0x17362
jmp 0x1737c
jmp 0x1735f
movq %rax, %r14
movq %r15, %rdi
callq 0x61c0
jmp 0x17373
movq %rax, %r14
movq %rbx, %rdi
callq 0x61c0
jmp 0x1737c
jmp 0x17370
jmp 0x17370
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movq %r14, %rdi
callq 0x6450
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/parser.cpp
// Function: Parser::CaseBlock()
AST_PTR Parser::CaseBlock()
{
    if(!acceptEat(TOKEN_LEFT_BARCKET))PARSER_ERROR("expected a '{'");
    DEF_AST_RET(CaseBlock);
    ret->caseClausesList=CaseClauseList();
    if(!acceptEat(TOKEN_RIGHT_BARCKET))PARSER_ERROR("expected a '}'");
    RETURN_PTR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
xorl %esi, %esi
callq 0x12884
cmpl $0x12, (%rax)
jne 0x17705
incl 0x20(%r14)
movl $0x10, %edi
callq 0x6220
movq %rax, %rbx
leaq 0x1741b(%rip), %rax     # 0x2ead8
addq $0x10, %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rsp, %rdi
movq %r14, %rsi
callq 0x17384
movq (%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x12884
cmpl $0x13, (%rax)
jne 0x17769
incl 0x20(%r14)
movq %rbx, (%r15)
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x70, %edi
callq 0x6140
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x12884
movq %rax, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x930f(%rip), %rsi      # 0x20a3e
leaq 0x9316(%rip), %rdx      # 0x20a4c
movq %rsp, %rdi
callq 0xb1b4
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7bdc
xorl %ebp, %ebp
leaq 0x164e0(%rip), %rsi     # 0x2dc38
leaq -0x6d1f(%rip), %rdx     # 0x10a40
movq %rbx, %rdi
callq 0x6440
jmp 0x177cc
movl $0x70, %edi
callq 0x6140
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
callq 0x12884
movq %rax, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x940e(%rip), %rsi      # 0x20ba2
leaq 0x9415(%rip), %rdx      # 0x20bb0
movq %rsp, %rdi
callq 0xb1b4
movb $0x1, %bpl
movq %rsp, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x7bdc
xorl %ebp, %ebp
leaq 0x1647b(%rip), %rsi     # 0x2dc38
leaq -0x6d84(%rip), %rdx     # 0x10a40
movq %r15, %rdi
callq 0x6440
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x177e5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6230
testb %bpl, %bpl
jne 0x17813
jmp 0x1782f
jmp 0x17810
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x17807
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6230
testb %bpl, %bpl
jne 0x17820
jmp 0x17838
jmp 0x1781d
movq %rax, %r14
movq %r15, %rdi
callq 0x61c0
jmp 0x1782f
movq %rax, %r14
movq %rbx, %rdi
callq 0x61c0
jmp 0x17838
jmp 0x1782c
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movq %r14, %rdi
callq 0x6450
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/parser.cpp
// Function: Parser::Program()
AST_PTR Parser::Program()
{
    DEF_AST_RET(Program);
    ret->stmtList=StatementList();
    if(accept(TOKEN_EOF))RETURN_PTR;
    if(accept(TOKEN_ERROR))PARSER_ERROR(lookHead().msg);
    Statement();
    return nullptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x10, %edi
callq 0x6220
movq %rax, %rbx
leaq 0x16f05(%rip), %rax     # 0x2ed40
addq $0x10, %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x15420
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r15, %rdi
xorl %esi, %esi
callq 0x12884
cmpl $0x1, (%rax)
jne 0x17e74
movq %rbx, (%r14)
jmp 0x17eb0
movq %r15, %rdi
xorl %esi, %esi
callq 0x12884
cmpl $0x0, (%rax)
je 0x17ebf
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1552e
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x17ea0
movq (%rdi), %rax
callq *0x28(%rax)
movq $0x0, (%r14)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x70, %edi
callq 0x6140
movq %rax, %r14
movq %r15, %rdi
xorl %esi, %esi
callq 0x12884
movq %rax, %r12
movq %r15, %rdi
xorl %esi, %esi
callq 0x12884
addq $0x30, %rax
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x7bdc
leaq 0x15d3c(%rip), %rsi     # 0x2dc38
leaq -0x74c3(%rip), %rdx     # 0x10a40
movq %r14, %rdi
callq 0x6440
movq %rax, %r15
movq %r14, %rdi
callq 0x61c0
jmp 0x17f1d
jmp 0x17f1a
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movq %r15, %rdi
callq 0x6450
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/assembler.cpp
// Function: get_asm_line(std::basic_ifstream<char, std::char_traits<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int get_asm_line(ifstream &stream,string &s)
{
    string str;
    if(!getline(stream,str,'\n'))return -0x80000000;
    istringstream ss(str);
    getline(ss,s,';');
    if(s.empty())return 1+get_asm_line(stream,s);
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x8(%rsp), %rsi
movl $0xa, %edx
callq 0x6490
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl $0x80000000, %ebp       # imm = 0x80000000
testb $0x5, 0x20(%rax,%rcx)
jne 0x1898d
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x6430
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
movl $0x3b, %edx
callq 0x6490
movl $0x1, %ebp
cmpq $0x0, 0x8(%rbx)
jne 0x1896f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x188e4
movl %eax, %ebp
incl %ebp
movq 0x1665a(%rip), %rsi     # 0x2efd0
leaq 0x28(%rsp), %rdi
callq 0x6380
leaq 0xa0(%rsp), %rdi
callq 0x6100
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x189a4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
movl %ebp, %eax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x189d9
movq %rax, %rbx
movq 0x16610(%rip), %rsi     # 0x2efd0
leaq 0x28(%rsp), %rdi
callq 0x6380
leaq 0xa0(%rsp), %rdi
callq 0x6100
jmp 0x189dc
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x189f3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
movq %rbx, %rdi
callq 0x6450
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/assembler.cpp
// Function: get_opnd_type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
OPND_TYPE get_opnd_type(const string &s)
{
    char b=s[0],e=*s.rbegin();
    if((b=='"'&&e=='"')||(b=='\''&e=='\''))return OT_STRING;
    if(s=="NULL")return OT_NULL;
    if(s=="TRUE")return OT_BOOL;
    if(s=="FALSE")return OT_BOOL;

    OPND_TYPE t=OT_INT;
    for(int i=0;i<s.length();i++)if(!isdigit(s[i])&&(i&&s[0]!='-'))
    {
        if(s[i]=='.'||(i==s.length()-1&&(s[i]=='f'||s[i]=='F')))
        {
            t=OT_FLOAT;
        }
        else
        {
            t=OT_LABEL;
            break;
        }
    }
    return t;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
movb (%rax), %cl
movb -0x1(%rax,%rdx), %al
movl $0x4, %ebx
cmpb $0x22, %cl
jne 0x18a21
cmpb $0x22, %al
je 0x18ad1
cmpb $0x27, %cl
jne 0x18a2e
cmpb $0x27, %al
je 0x18ad1
leaq 0x8529(%rip), %rsi      # 0x20f5e
movq %r14, %rdi
callq 0x60d0
testl %eax, %eax
je 0x18acc
leaq 0x84f1(%rip), %rsi      # 0x20f3d
movq %r14, %rdi
callq 0x60d0
movl $0x2, %ebx
testl %eax, %eax
je 0x18ad1
leaq 0x84e0(%rip), %rsi      # 0x20f44
movq %r14, %rdi
callq 0x60d0
testl %eax, %eax
je 0x18ad1
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x18adb
movq (%r14), %rcx
leaq -0x1(%rax), %rdx
xorl %esi, %esi
xorl %edi, %edi
testq %rsi, %rsi
je 0x18ac0
movsbl (%rcx,%rsi), %r8d
leal -0x3a(%r8), %r9d
cmpl $-0xb, %r9d
ja 0x18ac0
cmpb $0x2d, (%rcx)
je 0x18ac0
movzbl %r8b, %r8d
movl $0x3, %edi
cmpl $0x2e, %r8d
je 0x18ac0
movl $0x5, %ebx
cmpq %rsi, %rdx
jne 0x18ad1
orl $0x20, %r8d
cmpl $0x66, %r8d
jne 0x18ad1
incq %rsi
movl %edi, %ebx
cmpq %rsi, %rax
jne 0x18a84
jmp 0x18ad1
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %ebx, %ebx
jmp 0x18ad1
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/assembler.cpp
// Function: init_escape_table()
void init_escape_table()
{
    if(escape_table[1])return;
    for(int i=0;i<sizeof(escape_table);i++)escape_table[i]=i;
    escape_table['0']='\0';
    escape_table['e']='\e';
    escape_table['a']='\a';
    escape_table['b']='\b';
    escape_table['t']='\t';
    escape_table['n']='\n';
    escape_table['v']='\v';
    escape_table['f']='\f';
    escape_table['r']='\r';
}

// Assembly:
cmpb $0x0, 0x16d9b(%rip)     # 0x2f881
je 0x18ae9
retq
movdqa 0x811f(%rip), %xmm0     # 0x20c10
xorl %eax, %eax
leaq 0x16d86(%rip), %rcx     # 0x2f880
movdqa 0x811e(%rip), %xmm1     # 0x20c20
movdqa %xmm0, (%rax,%rcx)
addq $0x10, %rax
paddb %xmm1, %xmm0
cmpq $0x80, %rax
jne 0x18b02
movb $0x0, 0x16d92(%rip)     # 0x2f8b0
movw $0xc1b, 0x16dbe(%rip)   # imm = 0xC1B
movw $0x807, 0x16db1(%rip)   # imm = 0x807
movb $0x9, 0x16dbd(%rip)     # 0x2f8f4
movb $0xa, 0x16db0(%rip)     # 0x2f8ee
movb $0xb, 0x16db1(%rip)     # 0x2f8f6
movb $0xd, 0x16da6(%rip)     # 0x2f8f2
retq
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/assembler.cpp
// Function: process_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string process_string(const string &s)
{
    string x;
    for(int i=1;i<s.length()-1;i++)
        x.push_back(s[i]=='\\'?escape_table[s[++i]]:s[i]);
    return x;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
addq $-0x3, %rax
cmpq $-0x3, %rax
ja 0x18bc6
movq %rsi, %r14
movl $0x1, %r12d
movl $0x1, %eax
leaq 0x16cf1(%rip), %r13     # 0x2f880
movq (%r14), %rcx
movb (%rcx,%rax), %al
cmpb $0x5c, %al
jne 0x18ba9
movslq %r12d, %r12
movsbq 0x1(%rcx,%r12), %rax
incq %r12
movb (%rax,%r13), %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x61f0
incl %r12d
movslq %r12d, %rax
movq 0x8(%r14), %rcx
decq %rcx
cmpq %rax, %rcx
ja 0x18b8f
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x18be9
movq (%r15), %rsi
incq %rsi
callq 0x6230
movq %r14, %rdi
callq 0x6450
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/disassembler.cpp
// Function: disassemble(char const*, char const*)
bool disassemble(const char *binfile,const char *outfile)
{
    FILE *in=fopen(binfile,"rb");
    if(!in)return false;
    FILE *out=fopen(outfile,"w");
    if(!out)
    {
        fclose(in);
        return false;
    }
    bool ret=disassemble(in,out);
    fclose(in);
    fclose(out);
    return ret;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
leaq 0x5df9(%rip), %rsi      # 0x21033
callq 0x62d0
testq %rax, %rax
je 0x1b278
movq %rax, %rbx
leaq 0x4fa8(%rip), %rsi      # 0x201f6
movq %r14, %rdi
callq 0x62d0
testq %rax, %rax
je 0x1b27c
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1b28d
movl %eax, %ebp
movq %rbx, %rdi
callq 0x6210
movq %r14, %rbx
jmp 0x1b27e
xorl %ebp, %ebp
jmp 0x1b286
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x6210
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/disassembler.cpp
// Function: print_string(_IO_FILE*, char const*)
void print_string(FILE *fp,const char *s)
{
    init_r_escape_table();
    fputc('"',fp);
    for(int i=0;s[i];i++)
    {
        if(r_escape_table[s[i]])fputc('\\',fp),fputc(r_escape_table[s[i]],fp);
        else fputc(s[i],fp);
    }
    fputc('"',fp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0x145c9(%rip)     # 0x2fab0
jne 0x1b511
movb $0x30, 0x145c0(%rip)    # 0x2fab0
movb $0x65, 0x145d4(%rip)    # 0x2facb
movl $0x6e746261, 0x145b6(%rip) # imm = 0x6E746261
movw $0x6676, 0x145b1(%rip)  # imm = 0x6676
movb $0x72, 0x145ac(%rip)    # 0x2fabd
movl $0x22, %edi
movq %rbx, %rsi
callq 0x6310
movb (%r14), %al
testb %al, %al
je 0x1b565
incq %r14
leaq 0x14581(%rip), %r15     # 0x2fab0
movsbq %al, %rcx
cmpb $0x0, (%rcx,%r15)
je 0x1b550
movl $0x5c, %edi
movq %rbx, %rsi
callq 0x6310
movsbq -0x1(%r14), %rax
movb (%rax,%r15), %al
movsbl %al, %edi
movq %rbx, %rsi
callq 0x6310
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x1b52f
movl $0x22, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x6310
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/disassembler.cpp
// Function: discode(unsigned char&, CodeData&, _IO_FILE*)
void discode(CODE &op,CodeData &code_data,FILE *out)
{
    switch(op)
    {
        case OP_NPUSH:
            fprintf(out,"PUSH NULL\n");
            break;
        case OP_BPUSH:
            fprintf(out,"PUSH %s\n",get_int8(&op)?"TRUE":"FALSE");
            break;
        case OP_IPUSH:
            fprintf(out,"PUSH %d\n",code_data.int_table[get_int32(&op)]);
            break;
        case OP_FPUSH:
            fprintf(out,"PUSH %f\n",code_data.float_table[get_int32(&op)]);
            break;
        case OP_SPUSH:
            fprintf(out,"PUSH ");
            print_string(out,code_data.string_table[get_int32(&op)]);
            fputc('\n',out);
            break;
        case OP_LOAD_GLOBAL:
        case OP_STORE_GLOBAL:
        case OP_LOAD:
        case OP_STORE:
        case OP_LOAD_EXTERNAL:
        case OP_STORE_EXTERNAL:
        case OP_CREATE_FUNCTION:
        case OP_ADDSP:
        case OP_SUBSP:
        case OP_CALL:
        case OP_JMP:

            fprintf(out,"%s %d\n",op_name[op],get_int32(&op));
            break;
        default:
            if(op>=SIZEOF(op_name))
            {
                fprintf(out,"; unknow instructor: %x\n",op);
                break;
            }
            fprintf(out,"%s\n",op_name[op]);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movzbl (%rdi), %edx
cmpl $0xe, %edx
ja 0x1b5c3
movq %rsi, %r15
leaq 0x5a1c(%rip), %rax      # 0x20fb8
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x5a8a(%rip), %rdi      # 0x21036
movl $0xa, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x64b0
leal -0x33(%rdx), %eax
cmpl $0x4, %eax
jae 0x1b5f2
movl %edx, %eax
leaq 0x13d1c(%rip), %rcx     # 0x2f2f0
movq (%rcx,%rax,8), %rdx
movl 0x1(%r14), %ecx
leaq 0x5a7f(%rip), %rsi      # 0x21062
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x6390
cmpb $0x39, %dl
jb 0x1b6aa
leaq 0x5a67(%rip), %rsi      # 0x21069
movq %rbx, %rdi
jmp 0x1b67b
leaq 0x5a4e(%rip), %rdi      # 0x2105c
movl $0x5, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x64b0
movslq 0x1(%r14), %rax
movq 0x50(%r15), %rcx
movq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
callq 0x1b4d5
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x6310
cmpb $0x0, 0x1(%r14)
leaq 0x58f2(%rip), %rax      # 0x20f44
leaq 0x58e4(%rip), %rdx      # 0x20f3d
cmoveq %rax, %rdx
leaq 0x59dd(%rip), %rsi      # 0x21041
jmp 0x1b6bc
movslq 0x1(%r14), %rax
movq 0x40(%r15), %rcx
movl (%rcx,%rax,4), %edx
leaq 0x59d2(%rip), %rsi      # 0x2104a
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x6390
movslq 0x1(%r14), %rax
movq 0x48(%r15), %rcx
movsd (%rcx,%rax,8), %xmm0
leaq 0x59b8(%rip), %rsi      # 0x21053
movq %rbx, %rdi
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
jmp 0x6390
leaq 0x13c3f(%rip), %rax     # 0x2f2f0
movq (%rax,%rdx,8), %rdx
leaq 0x4a42(%rip), %rsi      # 0x200fe
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x6390
nop
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/lexer.cpp
// Function: Lexer::createToken(TOKEN_TYPE, int)
Token Lexer::createToken(TOKEN_TYPE type, int len = 1)
{
    Token t;
    t.type = type;
    t.line = line_number;
    t.col = col_number;
    t.raw = std::string(lookhead_buffer.begin(), len);
    clearChar(len);
    return t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movb %al, 0x20(%rdi)
leaq 0x40(%rdi), %rsi
movq %rsi, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movb %al, 0x40(%rdi)
movl %edx, (%rdi)
movq 0x28(%r14), %rax
movq %rax, 0x4(%rdi)
movslq 0x20(%r14), %rsi
addq 0x8(%r14), %rsi
movslq %ecx, %r12
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq (%rsi,%r12), %rdx
movq %rsp, %rdi
callq 0xb1b4
leaq 0x10(%rbx), %rdi
movq %rsp, %r15
movq %r15, %rsi
callq 0x62e0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x1b919
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6230
addl %r12d, 0x2c(%r14)
movslq 0x20(%r14), %rdx
addq %r12, %rdx
movl %edx, 0x20(%r14)
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
movq %rcx, %rsi
subq %rax, %rsi
cmpq %rdx, %rsi
jne 0x1b94c
cmpq %rax, %rcx
je 0x1b944
movq %rax, 0x10(%r14)
movl $0x0, 0x20(%r14)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7cac
movq %r14, %rdi
callq 0x6450
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/lexer.cpp
// Function: Lexer::load(char const*)
bool Lexer::load(const char *file)
{
    fp = fopen(file, "r");
    if (!fp) return false;
    line_number = 1;
    col_number = 1;
    return true;
}

// Assembly:
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x443f(%rip), %rsi      # 0x201d5
movq %rax, %rdi
callq 0x62d0
movq %rax, (%rbx)
testq %rax, %rax
je 0x1bdb4
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x28(%rbx)
testq %rax, %rax
setne %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/codedata.cpp
// Function: CodeData::check(char const*)
bool CodeData::check(const char *filename)
{
    FILE *fp=fopen(filename,"rb");
    if(!fp)return false;
    uint32_t magic;
    fread(&magic,sizeof(magic),1,fp);
    fclose(fp);
    return magic==HEADER_MAGIC;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x4600(%rip), %rsi      # 0x21033
callq 0x62d0
testq %rax, %rax
je 0x1ca6e
movq %rax, %rbx
leaq 0x4(%rsp), %r14
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rcx
callq 0x63b0
movq %rbx, %rdi
callq 0x6210
cmpl $0x414e5245, (%r14)     # imm = 0x414E5245
sete %al
jmp 0x1ca70
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/codedata.cpp
// Function: CodeData::load(char const*)
bool CodeData::load(const char *filename)
{
    FILE *fp=fopen(filename,"rb");
    if(!fp)return false;
    bool ret=load(fp);
    fclose(fp);
    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x45aa(%rip), %rsi      # 0x21033
movq %rax, %rdi
callq 0x62d0
testq %rax, %rax
je 0x1cab2
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1cabc
movl %eax, %ebx
movq %r14, %rdi
callq 0x6210
movl %ebx, %eax
jmp 0x1cab4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/codedata.cpp
// Function: CodeData::load(_IO_FILE*)
bool CodeData::load(FILE *fp)
{
    fread(&config,sizeof(config),1,fp);
    if(config.magic!=HEADER_MAGIC)return false;
    int_table=unique_ptr<int[]>(new int[config.int_table_size]);
    float_table=unique_ptr<double[]>(new double[config.float_table_size]);
    string_table=unique_ptr<char*[]>(new char*[config.string_table_size]);
    string_raw=unique_ptr<char[]>(new char[config.string_raw_size]);
    code_raw=unique_ptr<CODE[]>(new CODE[config.code_raw_size]);
    

    fread(int_table.get(),sizeof(int),config.int_table_size,fp);
    fread(float_table.get(),sizeof(double),config.float_table_size,fp);
    fread(string_raw.get(),1,config.string_raw_size,fp);
    fread(code_raw.get(),sizeof(CODE),config.code_raw_size,fp);
    
    char *buffer=string_raw.get();
    string_table[0]=buffer;
    for(int i=1;i<config.string_table_size;i++)
    {
        while(*buffer++);
        string_table[i]=buffer;
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x40, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x63b0
movl (%rbx), %ebp
cmpl $0x414e5245, %ebp       # imm = 0x414E5245
jne 0x1cc44
movq 0x8(%rbx), %rax
movq %rax, %rcx
shrq $0x3e, %rcx
shlq $0x2, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x6030
movq 0x40(%rbx), %rdi
movq %rax, 0x40(%rbx)
testq %rdi, %rdi
je 0x1cb1a
callq 0x6320
movabsq $0x1fffffffffffffff, %r15 # imm = 0x1FFFFFFFFFFFFFFF
movq 0x10(%rbx), %rax
movq %rax, %rcx
shrq $0x3d, %rcx
shlq $0x3, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x6030
movq 0x48(%rbx), %rdi
movq %rax, 0x48(%rbx)
testq %rdi, %rdi
je 0x1cb55
callq 0x6320
movq 0x18(%rbx), %rax
leaq (,%rax,8), %rcx
cmpq %r15, %rax
movq $-0x1, %rdi
cmovbeq %rcx, %rdi
callq 0x6030
movq 0x50(%rbx), %rdi
movq %rax, 0x50(%rbx)
testq %rdi, %rdi
je 0x1cb86
callq 0x6320
movq 0x20(%rbx), %rdi
callq 0x6030
movq 0x58(%rbx), %rdi
movq %rax, 0x58(%rbx)
testq %rdi, %rdi
je 0x1cba1
callq 0x6320
movq 0x28(%rbx), %rdi
callq 0x6030
movq 0x60(%rbx), %rdi
movq %rax, 0x60(%rbx)
testq %rdi, %rdi
je 0x1cbbc
callq 0x6320
movq 0x8(%rbx), %rdx
movq 0x40(%rbx), %rdi
movl $0x4, %esi
movq %r14, %rcx
callq 0x63b0
movq 0x10(%rbx), %rdx
movq 0x48(%rbx), %rdi
movl $0x8, %esi
movq %r14, %rcx
callq 0x63b0
movq 0x20(%rbx), %rdx
movq 0x58(%rbx), %rdi
movl $0x1, %r15d
movl $0x1, %esi
movq %r14, %rcx
callq 0x63b0
movq 0x28(%rbx), %rdx
movq 0x60(%rbx), %rdi
movl $0x1, %esi
movq %r14, %rcx
callq 0x63b0
movq 0x50(%rbx), %rax
movq 0x58(%rbx), %rcx
movq %rcx, (%rax)
movq 0x18(%rbx), %rax
cmpq $0x2, %rax
jb 0x1cc44
cmpb $0x0, (%rcx)
leaq 0x1(%rcx), %rcx
jne 0x1cc2b
movq 0x50(%rbx), %rdx
movq %rcx, (%rdx,%r15,8)
incq %r15
cmpq %rax, %r15
jne 0x1cc2b
cmpl $0x414e5245, %ebp       # imm = 0x414E5245
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/ast_codegen.cpp
// Function: variantMethod(Symbol*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*)
void variantMethod(Symbol *symbol,const string &id,const char *method)
{
    int allowIndex;
    switch(symbol->lookup(id,allowIndex))
    {
        case ST_GLOBAL:
            PRINTF("%s_global %d\n",method,allowIndex);
            break;
        case ST_LOCAL:
            PRINTF("%s %d\n",method,allowIndex);
            break;
        case ST_EXTERNAL:
        {
            auto &func=*functionStack.top();
            if(!func.ext_map.count(id))
            {
                func.ext_map[id]=func.ext_list.size();
                func.ext_list.push_back(id);
            }
            PRINTF("%s_external %d\n",method,func.ext_map[id]);
            break;
        }
        default:
            break;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0xc(%rsp), %rdx
callq 0xd436
cmpl $0x2, %eax
je 0x1ceb3
cmpl $0x1, %eax
je 0x1ce2b
testl %eax, %eax
jne 0x1ced8
incl 0x12d1f(%rip)           # 0x2fb30
leaq 0x129f0(%rip), %rax     # 0x2f808
movq (%rax), %rdi
movl 0xc(%rsp), %ecx
leaq 0x476a(%rip), %rsi      # 0x21590
jmp 0x1cece
leaq 0x12976(%rip), %rcx     # 0x2f7a8
movq 0x30(%rcx), %rax
cmpq 0x38(%rcx), %rax
jne 0x1ce49
movq 0x48(%rcx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xd774
leaq 0x8(%r15), %rcx
cmpq %rcx, %rax
jne 0x1ce8a
leaq 0x30(%r15), %r12
movq 0x38(%r15), %r13
subq 0x30(%r15), %r13
shrq $0x5, %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0xd504
movl %r13d, (%rax)
movq %r12, %rdi
movq %r14, %rsi
callq 0x19abe
incl 0x12ca0(%rip)           # 0x2fb30
leaq 0x12971(%rip), %rax     # 0x2f808
movq (%rax), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0xd504
movl (%rax), %ecx
leaq 0x46f0(%rip), %rsi      # 0x2159e
movq %r12, %rdi
jmp 0x1cece
incl 0x12c77(%rip)           # 0x2fb30
leaq 0x12948(%rip), %rax     # 0x2f808
movq (%rax), %rdi
movl 0xc(%rsp), %ecx
leaq 0x4194(%rip), %rsi      # 0x21062
movq %rbx, %rdx
xorl %eax, %eax
callq 0x6390
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_Literal::codeGen(Symbol*)
DEF_AST_METHOD(Literal,AST_CODEGEN)
{
    switch(token.type)
    {
        case TOKEN_IDENTIFIER:
        {
            AST_PTR tmp(this);
            loadVariant(symbol,tmp);
            tmp.release();
        }
        break;
        case TOKEN_BIN_INTEGER_LITERAL:
            PRINTF("push %ld\n",strtol(token.raw.c_str(),NULL,2));
            break;
        case TOKEN_OCT_INTEGER_LITERAL:
        case TOKEN_DEC_INTEGER_LITERAL:
        case TOKEN_HEX_INTEGER_LITERAL:
            PRINTF("push %ld\n",strtol(token.raw.c_str(),NULL,0));
            break;
        default:
            PRINTF("push %s\n",token.raw.c_str());
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
leal -0x31(%rax), %ecx
cmpl $0x3, %ecx
jae 0x1cf46
incl 0x12bfe(%rip)           # 0x2fb30
leaq 0x128cf(%rip), %rax     # 0x2f808
movq (%rax), %r14
movq 0x18(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
jmp 0x1cf89
cmpl $0x30, %eax
je 0x1cf6e
cmpl $0x2e, %eax
jne 0x1cfa9
leaq 0x18(%rbx), %rax
leaq 0x48d5(%rip), %rdx      # 0x21830
movq %rsi, %rdi
movq %rax, %rsi
callq 0x1cdd8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incl 0x12bbc(%rip)           # 0x2fb30
leaq 0x1288d(%rip), %rax     # 0x2f808
movq (%rax), %r14
movq 0x18(%rbx), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x6370
leaq 0x4619(%rip), %rsi      # 0x215ae
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6390
incl 0x12b81(%rip)           # 0x2fb30
leaq 0x12852(%rip), %rax     # 0x2f808
movq (%rax), %rdi
movq 0x18(%rbx), %rdx
leaq 0x45f4(%rip), %rsi      # 0x215b8
jmp 0x1cf9b
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movq %r14, %rdi
callq 0x6450
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_ArrayLiteral::codeGen(Symbol*)
DEF_AST_METHOD(ArrayLiteral,AST_CODEGEN)
{
    PRINTF("new_array\n");
    int this_bak=++this_count;
    FOREACH(nodes)
    {
        CODEGEN(x);
        if(this_bak!=this_count)
        {
            PRINTF("reset_this\n");
            this_bak=++this_count;
        }
        PRINTF("array_push\n");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
incl 0x12b45(%rip)           # 0x2fb30
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x12810(%rip), %r12     # 0x2f808
movq (%r12), %rcx
leaq 0x45be(%rip), %rdi      # 0x215c1
movl $0xa, %esi
movl $0x1, %edx
callq 0x64b0
leaq 0x127e3(%rip), %r13     # 0x2f7fc
movl (%r13), %r14d
incl %r14d
movl %r14d, (%r13)
movq 0x8(%r15), %rbp
movq 0x10(%r15), %r15
cmpq %r15, %rbp
je 0x1d095
movq (%rbp), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
cmpl (%r13), %r14d
je 0x1d06f
incl 0x12ae6(%rip)           # 0x2fb30
movq (%r12), %rcx
movl $0xb, %esi
movl $0x1, %edx
leaq 0x456d(%rip), %rdi      # 0x215cc
callq 0x64b0
movl (%r13), %r14d
incl %r14d
movl %r14d, (%r13)
incl 0x12abb(%rip)           # 0x2fb30
movq (%r12), %rcx
movl $0xb, %esi
movl $0x1, %edx
leaq 0x454e(%rip), %rdi      # 0x215d8
callq 0x64b0
addq $0x8, %rbp
jmp 0x1d02c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq