LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8d30(%rip), %rsi      # 0x1db25
movq %r15, %rdi
callq 0x15b5a
testb %al, %al
je 0x14e90
pushq $0x18
popq %rdi
callq 0x6230
movq %rax, %rbx
leaq 0x19c71(%rip), %rax     # 0x2ea88
addq $0x10, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x123dc
movq %rbx, %rax
addq $0x8, %rax
leaq 0x8(%rsp), %rsi
movq (%rsi), %rcx
movq %rcx, (%rax)
movl $0x2c, (%rsi)
movq %r15, %rdi
callq 0x15a2a
testb %al, %al
je 0x14eeb
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x13318
movq 0x8(%rsp), %rax
movq 0x10(%rbx), %rdi
movq %rax, 0x10(%rbx)
testq %rdi, %rdi
je 0x14e7f
movq (%rdi), %rax
callq *0x28(%rax)
movq %rbx, (%r14)
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x70
popq %rdi
callq 0x6150
movq %rax, %rbx
movq %r15, %rdi
xorl %esi, %esi
callq 0x109e0
movq %rax, %r14
leaq 0x8c7b(%rip), %rsi      # 0x1db2a
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x9c4a
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79f8
xorl %ebp, %ebp
leaq 0x18d66(%rip), %rsi     # 0x2dc40
leaq -0x61d9(%rip), %rdx     # 0xed08
movq %rbx, %rdi
callq 0x6450
jmp 0x14f44
pushq $0x70
popq %rdi
callq 0x6150
movq %rax, %r14
movq %r15, %rdi
xorl %esi, %esi
callq 0x109e0
movq %rax, %r15
leaq 0x8c32(%rip), %rsi      # 0x1db3c
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x9c4a
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x79f8
xorl %ebp, %ebp
leaq 0x18d0b(%rip), %rsi     # 0x2dc40
leaq -0x6234(%rip), %rdx     # 0xed08
movq %r14, %rdi
callq 0x6450
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x6130
testb %bpl, %bpl
jne 0x14f73
jmp 0x14f91
jmp 0x14f70
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x6130
testb %bpl, %bpl
jne 0x14f80
jmp 0x14f9a
jmp 0x14f7d
movq %rax, %r15
movq %r14, %rdi
callq 0x61d0
jmp 0x14f91
movq %rax, %r15
movq %rbx, %rdi
callq 0x61d0
jmp 0x14f9a
jmp 0x14f8e
jmp 0x14f8e
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movq %r15, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
movl $0x12, (%rsi)
movq %r15, %rdi
callq 0x15a2a
testb %al, %al
je 0x1529f
pushq $0x10
popq %rdi
callq 0x6230
movq %rax, %rbx
leaq 0x19889(%rip), %rax     # 0x2eae0
addq $0x10, %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x14fa2
leaq 0x8(%rsp), %rsi
movq (%rsi), %rax
movq %rax, 0x8(%rbx)
movl $0x13, (%rsi)
movq %r15, %rdi
callq 0x15a2a
testb %al, %al
je 0x152fa
movq %rbx, (%r14)
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x70
popq %rdi
callq 0x6150
movq %rax, %rbx
movq %r15, %rdi
xorl %esi, %esi
callq 0x109e0
movq %rax, %r14
leaq 0x8750(%rip), %rsi      # 0x1da0e
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x9c4a
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79f8
xorl %ebp, %ebp
leaq 0x18957(%rip), %rsi     # 0x2dc40
leaq -0x65e8(%rip), %rdx     # 0xed08
movq %rbx, %rdi
callq 0x6450
jmp 0x15353
pushq $0x70
popq %rdi
callq 0x6150
movq %rax, %r14
movq %r15, %rdi
xorl %esi, %esi
callq 0x109e0
movq %rax, %r15
leaq 0x8859(%rip), %rsi      # 0x1db72
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x9c4a
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x79f8
xorl %ebp, %ebp
leaq 0x188fc(%rip), %rsi     # 0x2dc40
leaq -0x6643(%rip), %rdx     # 0xed08
movq %r14, %rdi
callq 0x6450
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x6130
testb %bpl, %bpl
jne 0x15382
jmp 0x1539e
jmp 0x1537f
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x6130
testb %bpl, %bpl
jne 0x1538f
jmp 0x153a7
jmp 0x1538c
movq %rax, %r15
movq %r14, %rdi
callq 0x61d0
jmp 0x1539e
movq %rax, %r15
movq %rbx, %rdi
callq 0x61d0
jmp 0x153a7
jmp 0x1539b
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movq %r15, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O2/Eronana[P]strawberry/src/parser.cpp
// Function: Parser::SwitchStatement()
AST_PTR Parser::SwitchStatement()
{
    if(!acceptEat("switch"))PARSER_ERROR("excepted a 'switch'");
    if(!acceptEat(TOKEN_LEFT_PAREN))PARSER_ERROR("excepted a '('");
    DEF_AST_RET(SwitchStatement);
    ret->expr=Expression();
    if(!acceptEat(TOKEN_RIGHT_PAREN))PARSER_ERROR("excepted a ')'");
    ret->caseBlock=CaseBlock();
    RETURN_PTR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x87ba(%rip), %rsi      # 0x1db81
movq %r14, %rdi
callq 0x15c74
testb %al, %al
je 0x1547d
leaq 0x8(%rsp), %rsi
movl $0xe, (%rsi)
movq %r14, %rdi
callq 0x15a2a
testb %al, %al
je 0x154db
pushq $0x18
popq %rdi
callq 0x6230
movq %rax, %rbx
leaq 0x19734(%rip), %rax     # 0x2eb38
addq $0x10, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x123dc
movq %rbx, %rax
addq $0x8, %rax
leaq 0x8(%rsp), %rsi
movq (%rsi), %rcx
movq %rcx, (%rax)
movl $0xf, (%rsi)
movq %r14, %rdi
callq 0x15a2a
testb %al, %al
je 0x15536
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1521e
movq 0x8(%rsp), %rax
movq 0x10(%rbx), %rdi
movq %rax, 0x10(%rbx)
testq %rdi, %rdi
je 0x1546c
movq (%rdi), %rax
callq *0x28(%rax)
movq %rbx, (%r15)
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x70
popq %rdi
callq 0x6150
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x109e0
movq %rax, %r14
leaq 0x86ec(%rip), %rsi      # 0x1db88
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x9c4a
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79f8
xorl %ebp, %ebp
leaq 0x18779(%rip), %rsi     # 0x2dc40
leaq -0x67c6(%rip), %rdx     # 0xed08
movq %rbx, %rdi
callq 0x6450
jmp 0x1558f
pushq $0x70
popq %rdi
callq 0x6150
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x109e0
movq %rax, %r14
leaq 0x85df(%rip), %rsi      # 0x1dad9
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x9c4a
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79f8
xorl %ebp, %ebp
leaq 0x1871b(%rip), %rsi     # 0x2dc40
leaq -0x6824(%rip), %rdx     # 0xed08
movq %rbx, %rdi
callq 0x6450
jmp 0x1558f
pushq $0x70
popq %rdi
callq 0x6150
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
callq 0x109e0
movq %rax, %r14
leaq 0x83f5(%rip), %rsi      # 0x1d94a
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x9c4a
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x79f8
xorl %ebp, %ebp
leaq 0x186c0(%rip), %rsi     # 0x2dc40
leaq -0x687f(%rip), %rdx     # 0xed08
movq %r15, %rdi
callq 0x6450
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x6130
testb %bpl, %bpl
jne 0x155c2
jmp 0x155e2
jmp 0x155bf
jmp 0x155a9
jmp 0x155ce
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x6130
testb %bpl, %bpl
jne 0x155d1
jmp 0x155eb
jmp 0x155ce
movq %rax, %r14
movq %r15, %rdi
callq 0x61d0
jmp 0x155e2
jmp 0x155ce
movq %rax, %r14
movq %rbx, %rdi
callq 0x61d0
jmp 0x155eb
jmp 0x155df
jmp 0x155df
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x10
popq %rdi
callq 0x6230
movq %rax, %rbx
leaq 0x19465(%rip), %rax     # 0x2ed48
addq $0x10, %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x13318
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
pushq $0x1
popq %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x10aae
testb %al, %al
je 0x1591b
movq %rbx, (%r14)
jmp 0x15955
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10aae
testb %al, %al
jne 0x15964
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x13426
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x15948
movq (%rdi), %rax
callq *0x28(%rax)
andq $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
pushq $0x70
popq %rdi
callq 0x6150
movq %rax, %r14
movq %r15, %rdi
xorl %esi, %esi
callq 0x109e0
movq %rax, %r12
movq %r15, %rdi
xorl %esi, %esi
callq 0x109e0
addq $0x30, %rax
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x79f8
leaq 0x182a1(%rip), %rsi     # 0x2dc40
leaq -0x6c9e(%rip), %rdx     # 0xed08
movq %r14, %rdi
callq 0x6450
movq %rax, %r15
movq %r14, %rdi
callq 0x61d0
jmp 0x159c0
jmp 0x159bd
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movq %r15, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %rsi
pushq $0xa
popq %rdx
callq 0x64a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl $0x80000000, %ebp       # imm = 0x80000000
testb $0x5, 0x20(%rax,%rcx)
jne 0x161e9
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
pushq $0x8
popq %rdx
callq 0x6440
leaq 0x20(%rsp), %rdi
pushq $0x3b
popq %rdx
movq %rbx, %rsi
callq 0x64a0
cmpq $0x0, 0x8(%rbx)
je 0x161d0
pushq $0x1
popq %rbp
jmp 0x161df
movq %r14, %rdi
movq %rbx, %rsi
callq 0x16164
movl %eax, %ebp
incl %ebp
leaq 0x20(%rsp), %rdi
callq 0x6140
movq %rsp, %rdi
callq 0x6130
movl %ebp, %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x16210
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6140
jmp 0x16213
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6130
movq %rbx, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x4
popq %rbx
cmpb $0x22, %cl
jne 0x16243
cmpb $0x22, %al
je 0x1628d
cmpb $0x27, %cl
jne 0x1624c
cmpb $0x27, %al
je 0x1628d
leaq 0x7cfe(%rip), %rsi      # 0x1df51
movq %r14, %rdi
callq 0x9d30
testb %al, %al
je 0x16264
pushq $0x1
popq %rbx
jmp 0x1628d
leaq 0x7cbb(%rip), %rsi      # 0x1df26
movq %r14, %rdi
callq 0x9d30
pushq $0x2
popq %rbx
testb %al, %al
jne 0x1628d
leaq 0x7cac(%rip), %rsi      # 0x1df2d
movq %r14, %rdi
callq 0x9d30
testb %al, %al
je 0x16297
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rax
movq 0x8(%r14), %rcx
leaq -0x1(%rcx), %rdx
xorl %esi, %esi
pushq $0x3
popq %r8
pushq $0x5
popq %rdi
xorl %ebx, %ebx
cmpq %rsi, %rcx
je 0x1628d
testq %rsi, %rsi
je 0x162ea
movsbl (%rax,%rsi), %r9d
leal -0x3a(%r9), %r10d
cmpl $-0xb, %r10d
ja 0x162ea
cmpb $0x2d, (%rax)
je 0x162ea
movzbl %r9b, %r9d
movl %r8d, %ebx
cmpl $0x2e, %r9d
je 0x162ea
cmpq %rsi, %rdx
jne 0x162ef
orl $0x20, %r9d
movl %r8d, %ebx
cmpl $0x66, %r9d
jne 0x162ef
incq %rsi
jmp 0x162ad
movl %edi, %ebx
jmp 0x1628d
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x19597(%rip)     # 0x2f891
je 0x162fd
retq
xorl %eax, %eax
leaq 0x1958a(%rip), %rcx     # 0x2f890
cmpq $0x80, %rax
je 0x16316
movb %al, (%rax,%rcx)
incq %rax
jmp 0x16306
movb $0x0, 0x195a3(%rip)     # 0x2f8c0
movw $0xc1b, 0x195cf(%rip)   # imm = 0xC1B
movw $0x807, 0x195c2(%rip)   # imm = 0x807
movb $0x9, 0x195ce(%rip)     # 0x2f904
movb $0xa, 0x195c1(%rip)     # 0x2f8fe
movb $0xb, 0x195c2(%rip)     # 0x2f906
movb $0xd, 0x195b7(%rip)     # 0x2f902
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
pushq $0x1
popq %rbp
leaq 0x1951d(%rip), %r15     # 0x2f890
movslq %ebp, %rax
movq 0x8(%r14), %rcx
decq %rcx
cmpq %rax, %rcx
jbe 0x163ab
movq (%r14), %rdx
movb (%rdx,%rax), %cl
cmpb $0x5c, %cl
jne 0x1639c
movsbq 0x1(%rdx,%rax), %rcx
incq %rax
movb (%rcx,%r15), %cl
movl %eax, %ebp
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x6200
incl %ebp
jmp 0x16373
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6130
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/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 0x56a2(%rip), %rsi      # 0x1dfe4
callq 0x62c0
testq %rax, %rax
je 0x18980
movq %rax, %rbx
leaq 0x4878(%rip), %rsi      # 0x1d1ce
movq %r14, %rdi
callq 0x62c0
testq %rax, %rax
je 0x18984
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x18995
movl %eax, %ebp
movq %rbx, %rdi
callq 0x6220
movq %r14, %rbx
jmp 0x18986
xorl %ebp, %ebp
jmp 0x1898e
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x6220
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eronana[P]strawberry/src/disassembler.cpp
// Function: disassemble(_IO_FILE*, _IO_FILE*)
bool disassemble(FILE *in,FILE *out)
{
    CodeData code_data;
    if(!code_data.load(in))return false;
    fprintf(out,"; ======[   int table  ]======\n");
    for(int i=0;i<code_data.config.int_table_size;i++)fprintf(out,"; %3d | %d\n",i,code_data.int_table[i]);
    fprintf(out,"; ======[  float table ]======\n");
    for(int i=0;i<code_data.config.float_table_size;i++)fprintf(out,"; %3d | %f\n",i,code_data.float_table[i]);
    fprintf(out,"; ======[ string table ]======\n");
    for(int i=0;i<code_data.config.string_table_size;i++)fprintf(out,"; %3d | %s\n",i,code_data.string_table[i]);
    fprintf(out,"; ======[     code     ]======\n");
    for(int i=0;i<code_data.config.code_raw_size;i+=op_length[code_data.code_raw[i]])
    {
        discode(code_data.code_raw[i],code_data,out);
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
xorps %xmm0, %xmm0
leaq 0x8(%rsp), %rdi
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
andq $0x0, 0x60(%rdi)
callq 0x19c3c
movl %eax, %ebp
testb %al, %al
je 0x18aea
leaq 0x5661(%rip), %rdi      # 0x1e033
pushq $0x1f
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x64c0
leaq 0x566c(%rip), %r14      # 0x1e053
xorl %r15d, %r15d
cmpq %r15, 0x10(%rsp)
jbe 0x18a0f
movq 0x48(%rsp), %rax
movl (%rax,%r15,4), %ecx
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
xorl %eax, %eax
callq 0x6390
incq %r15
jmp 0x189ea
leaq 0x5649(%rip), %rdi      # 0x1e05f
pushq $0x1f
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x64c0
xorl %r14d, %r14d
leaq 0x5651(%rip), %r15      # 0x1e07f
cmpq %r14, 0x18(%rsp)
jbe 0x18a55
movq 0x50(%rsp), %rax
movsd (%rax,%r14,8), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
movb $0x1, %al
callq 0x6390
incq %r14
jmp 0x18a2e
leaq 0x562f(%rip), %rdi      # 0x1e08b
pushq $0x1f
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x64c0
leaq 0x563a(%rip), %r14      # 0x1e0ab
xorl %r15d, %r15d
cmpq %r15, 0x20(%rsp)
jbe 0x18a99
movq 0x58(%rsp), %rax
movq (%rax,%r15,8), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
xorl %eax, %eax
callq 0x6390
incq %r15
jmp 0x18a74
leaq 0x5617(%rip), %rdi      # 0x1e0b7
pushq $0x1f
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x64c0
xorl %r15d, %r15d
leaq 0x8(%rsp), %r14
leaq 0x5143(%rip), %r12      # 0x1dc00
movslq %r15d, %r15
cmpq 0x30(%rsp), %r15
jae 0x18aea
movq 0x68(%rsp), %rdi
addq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x18bc1
movq 0x68(%rsp), %rax
movzbl (%rax,%r15), %eax
addq (%r12,%rax,8), %r15
jmp 0x18abd
leaq 0x8(%rsp), %rdi
callq 0x780a
movl %ebp, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x780a
movq %rbx, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x18b18
pushq $0x22
popq %rdi
movq %rbx, %rsi
callq 0x6300
leaq 0x16f51(%rip), %r15     # 0x2fac0
pushq $0x5c
popq %rbp
movsbq (%r14), %rax
testq %rax, %rax
je 0x18ba4
cmpb $0x0, (%rax,%r15)
je 0x18b94
movl %ebp, %edi
movq %rbx, %rsi
callq 0x6300
movsbq (%r14), %rax
movb (%rax,%r15), %al
movsbl %al, %edi
movq %rbx, %rsi
callq 0x6300
incq %r14
jmp 0x18b72
pushq $0x22
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6300
// File: /workspace/github_cpp_makefile_star2_O2/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 0x18c01
movq %rsi, %r15
leaq 0x53ca(%rip), %rax      # 0x1dfa8
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x53f9(%rip), %rdi      # 0x1dfe7
pushq $0xa
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x64c0
leal -0x33(%rdx), %eax
cmpl $0x4, %eax
jae 0x18c30
movl %edx, %eax
leaq 0x166ee(%rip), %rcx     # 0x2f300
movq (%rcx,%rax,8), %rdx
movl 0x1(%r14), %ecx
leaq 0x53f2(%rip), %rsi      # 0x1e013
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x6390
cmpb $0x39, %dl
jb 0x18ce2
leaq 0x53da(%rip), %rsi      # 0x1e01a
movq %rbx, %rdi
jmp 0x18cb3
leaq 0x53c1(%rip), %rdi      # 0x1e00d
pushq $0x5
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x64c0
movslq 0x1(%r14), %rax
movq 0x50(%r15), %rcx
movq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
callq 0x18b4b
pushq $0xa
popq %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x6300
cmpb $0x0, 0x1(%r14)
leaq 0x52a3(%rip), %rax      # 0x1df2d
leaq 0x5295(%rip), %rdx      # 0x1df26
cmoveq %rax, %rdx
leaq 0x5356(%rip), %rsi      # 0x1dff2
jmp 0x18cf4
movslq 0x1(%r14), %rax
movq 0x40(%r15), %rcx
movl (%rcx,%rax,4), %edx
leaq 0x534b(%rip), %rsi      # 0x1dffb
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 0x5331(%rip), %rsi      # 0x1e004
movq %rbx, %rdi
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
jmp 0x6390
leaq 0x16617(%rip), %rax     # 0x2f300
movq (%rax,%rdx,8), %rdx
leaq 0x440a(%rip), %rsi      # 0x1d0fe
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x6390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdi, %rbx
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
xorl %eax, %eax
movb %al, 0x20(%rdi)
leaq 0x40(%rdi), %rcx
movq %rcx, 0x30(%rdi)
andq $0x0, 0x38(%rdi)
movq %rsi, %r14
movb %al, 0x40(%rdi)
movl %edx, (%rdi)
movq 0x28(%rsi), %rax
movq %rax, 0x4(%rdi)
movslq 0x20(%rsi), %rsi
addq 0x8(%r14), %rsi
movslq %ebp, %rdx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xa0fe
movq %rbx, %rdi
addq $0x10, %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x62d0
movq %r15, %rdi
callq 0x6130
movq %r14, %rdi
movl %ebp, %esi
callq 0x18dc4
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x77da
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/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 0x403f(%rip), %rsi      # 0x1d1ad
movq %rax, %rdi
callq 0x62c0
movq %rax, (%rbx)
testq %rax, %rax
je 0x1918c
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x28(%rbx)
testq %rax, %rax
setne %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x442d(%rip), %rsi      # 0x1dfe4
callq 0x62c0
testq %rax, %rax
je 0x19bee
movq %rax, %rbx
leaq 0x4(%rsp), %r14
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rax, %rcx
callq 0x63b0
movq %rbx, %rdi
callq 0x6220
cmpl $0x414e5245, (%r14)     # imm = 0x414E5245
sete %al
jmp 0x19bf0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x43db(%rip), %rsi      # 0x1dfe4
movq %rax, %rdi
callq 0x62c0
testq %rax, %rax
je 0x19c32
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x19c3c
movl %eax, %ebx
movq %r14, %rdi
callq 0x6220
movl %ebx, %eax
jmp 0x19c34
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
pushq $0x40
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
movq %r15, %rcx
callq 0x63b0
movl (%r14), %ebp
cmpl $0x414e5245, %ebp       # imm = 0x414E5245
jne 0x19de8
movq 0x8(%r14), %rax
movq %rax, %rcx
shrq $0x3e, %rcx
shlq $0x2, %rax
xorl %r12d, %r12d
negq %rcx
movl $0x0, %edi
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x6030
leaq 0x40(%r14), %rdi
movq %rsp, %r13
andq $0x0, (%r13)
movq %rax, %rsi
callq 0x19f5c
movq %r13, %rdi
callq 0x7998
movq 0x10(%r14), %rax
movq %rax, %rcx
shrq $0x3d, %rcx
shlq $0x3, %rax
negq %rcx
movl $0x0, %edi
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x6030
leaq 0x48(%r14), %rdi
andq $0x0, (%r13)
movq %rax, %rsi
callq 0x19f70
movq %rsp, %r13
movq %r13, %rdi
callq 0x797e
movq 0x18(%r14), %rax
movq %rax, %rcx
shrq $0x3d, %rcx
shlq $0x3, %rax
negq %rcx
sbbq %r12, %r12
orq %rax, %r12
movq %r12, %rdi
callq 0x6030
leaq 0x50(%r14), %r12
andq $0x0, (%r13)
movq %r12, %rdi
movq %rax, %rsi
callq 0x19f84
movq %rsp, %r13
movq %r13, %rdi
callq 0x7964
movq 0x20(%r14), %rdi
callq 0x6030
leaq 0x58(%r14), %rdi
andq $0x0, (%r13)
movq %rax, %rsi
callq 0x19f98
movq %rsp, %r13
movq %r13, %rdi
callq 0x794a
movq 0x28(%r14), %rdi
callq 0x6030
leaq 0x60(%r14), %rdi
andq $0x0, (%r13)
movq %rax, %rsi
callq 0x19fac
movq %rsp, %rdi
callq 0x7930
movq 0x8(%r14), %rdx
movq 0x40(%r14), %rdi
pushq $0x4
popq %rsi
movq %r15, %rcx
callq 0x63b0
movq 0x10(%r14), %rdx
movq 0x48(%r14), %rdi
pushq $0x8
popq %rsi
movq %r15, %rcx
callq 0x63b0
movq 0x20(%r14), %rdx
movq 0x58(%r14), %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x63b0
movq 0x28(%r14), %rdx
movq 0x60(%r14), %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x63b0
movq 0x50(%r14), %rax
movq 0x58(%r14), %rcx
movq %rcx, (%rax)
movq 0x18(%r14), %rax
cmpq %rbx, %rax
jbe 0x19de8
cmpb $0x0, (%rcx)
leaq 0x1(%rcx), %rcx
jne 0x19dd2
movq (%r12), %rdx
movq %rcx, (%rdx,%rbx,8)
incq %rbx
jmp 0x19dcd
cmpl $0x414e5245, %ebp       # imm = 0x414E5245
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc13c
cmpl $0x2, %eax
je 0x1a097
cmpl $0x1, %eax
je 0x1a013
testl %eax, %eax
jne 0x1a0bc
incl 0x15b47(%rip)           # 0x2fb40
leaq 0x15818(%rip), %rax     # 0x2f818
movq (%rax), %rdi
movl 0xc(%rsp), %ecx
leaq 0x4532(%rip), %rsi      # 0x1e540
jmp 0x1a0b2
leaq 0x1579e(%rip), %rcx     # 0x2f7b8
movq 0x30(%rcx), %rax
cmpq 0x38(%rcx), %rax
jne 0x1a031
movq 0x48(%rcx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xc1f0
testq %rax, %rax
jne 0x1a06e
leaq 0x30(%r15), %r12
movq 0x38(%r15), %r13
subq 0x30(%r15), %r13
shrq $0x5, %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0xc20a
movl %r13d, (%rax)
movq %r12, %rdi
movq %r14, %rsi
callq 0x1703a
incl 0x15acc(%rip)           # 0x2fb40
leaq 0x1579d(%rip), %rax     # 0x2f818
movq (%rax), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0xc20a
movl (%rax), %ecx
leaq 0x44bc(%rip), %rsi      # 0x1e54e
movq %r12, %rdi
jmp 0x1a0b2
incl 0x15aa3(%rip)           # 0x2fb40
leaq 0x15774(%rip), %rax     # 0x2f818
movq (%rax), %rdi
movl 0xc(%rsp), %ecx
leaq 0x3f61(%rip), %rsi      # 0x1e013
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_O2/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 %rbx
subq $0x10, %rsp
movl 0x8(%rdi), %eax
leal -0x31(%rax), %ecx
cmpl $0x3, %ecx
jae 0x1a128
incl 0x15a2c(%rip)           # 0x2fb40
leaq 0x156fd(%rip), %rax     # 0x2f818
movq (%rax), %rbx
movq 0x18(%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
jmp 0x1a164
cmpl $0x30, %eax
je 0x1a14b
cmpl $0x2e, %eax
jne 0x1a182
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
movq %rsi, %rdi
movq %rax, %rsi
callq 0x1bf8a
addq $0x10, %rsp
popq %rbx
retq
incl 0x159ef(%rip)           # 0x2fb40
leaq 0x156c0(%rip), %rax     # 0x2f818
movq (%rax), %rbx
movq 0x18(%rdi), %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x6380
leaq 0x43ee(%rip), %rsi      # 0x1e55e
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
jmp 0x6390
incl 0x159b8(%rip)           # 0x2fb40
leaq 0x15689(%rip), %rax     # 0x2f818
movq (%rax), %rax
movq 0x18(%rdi), %rdx
leaq 0x43cb(%rip), %rsi      # 0x1e568
movq %rax, %rdi
jmp 0x1a176
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a1b5
movq (%rdi), %rax
callq *0x28(%rax)
movq %rbx, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x15971(%rip)           # 0x2fb40
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x1563c(%rip), %rax     # 0x2f818
movq (%rax), %rcx
leaq 0x438b(%rip), %rdi      # 0x1e571
pushq $0xa
popq %rsi
pushq $0x1
popq %rdx
callq 0x64c0
leaq 0x15614(%rip), %r13     # 0x2f80c
movl (%r13), %r14d
incl %r14d
movl %r14d, (%r13)
movq 0x8(%r12), %r15
movq 0x10(%r12), %rbp
pushq $0xb
popq %r12
cmpq %rbp, %r15
je 0x1a27d
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
cmpl (%r13), %r14d
je 0x1a255
incl 0x15912(%rip)           # 0x2fb40
leaq 0x155e3(%rip), %rax     # 0x2f818
movq (%rax), %rcx
leaq 0x433d(%rip), %rdi      # 0x1e57c
movq %r12, %rsi
pushq $0x1
popq %rdx
callq 0x64c0
movl (%r13), %r14d
incl %r14d
movl %r14d, (%r13)
incl 0x158e5(%rip)           # 0x2fb40
leaq 0x155b6(%rip), %rax     # 0x2f818
movq (%rax), %rcx
leaq 0x431c(%rip), %rdi      # 0x1e588
movq %r12, %rsi
pushq $0x1
popq %rdx
callq 0x64c0
addq $0x8, %r15
jmp 0x1a211
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_ObjectLiteral::codeGen(Symbol*)
DEF_AST_METHOD(ObjectLiteral,AST_CODEGEN)
{
    PRINTF("new_object\n");
    int this_bak=++this_count;
    for(auto &x:nodes)
    {
        auto property=(AST_NAME(PropertyNameAndValue)*)x.get();
        CODEGEN(property->assignExpr);
        if(this_bak!=this_count)
        {
            PRINTF("reset_this\n");
            this_bak=++this_count;
        }
        if(is_identifier(property->identifier))PRINTF("push \"%s\"\n",GET_LITERAL(property->identifier).raw.c_str());
        else PRINTF("push %s\n",GET_LITERAL(property->identifier).raw.c_str());
        PRINTF("object_set\n");
        PRINTF("pop\n");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
incl 0x158a3(%rip)           # 0x2fb40
movq %rsi, (%rsp)
movq %rdi, %r14
leaq 0x1556d(%rip), %r12     # 0x2f818
movq (%r12), %rcx
leaq 0x42de(%rip), %rdi      # 0x1e594
pushq $0xb
popq %rsi
pushq $0x1
popq %r15
movq %r15, %rdx
callq 0x64c0
leaq 0x15540(%rip), %rax     # 0x2f80c
movl (%rax), %ebx
incl %ebx
movl %ebx, (%rax)
movq 0x8(%r14), %rbp
movq 0x10(%r14), %r14
cmpq %r14, %rbp
je 0x1a3a0
movq (%rbp), %r13
movq 0x10(%r13), %rdi
movq (%rdi), %rax
movq (%rsp), %rsi
callq *0x18(%rax)
leaq 0x15510(%rip), %rax     # 0x2f80c
cmpl (%rax), %ebx
je 0x1a329
incl 0x1583a(%rip)           # 0x2fb40
movq (%r12), %rcx
leaq 0x426b(%rip), %rdi      # 0x1e57c
pushq $0xb
popq %rsi
movq %r15, %rdx
callq 0x64c0
leaq 0x154e9(%rip), %rax     # 0x2f80c
movl (%rax), %ebx
incl %ebx
movl %ebx, (%rax)
leaq 0x8(%r13), %rdi
callq 0x1a0ca
incl 0x15808(%rip)           # 0x2fb40
movq (%r12), %rdi
movq 0x8(%r13), %rcx
movq 0x18(%rcx), %rdx
testb %al, %al
leaq 0x421b(%rip), %rsi      # 0x1e568
leaq 0x424c(%rip), %rax      # 0x1e5a0
cmovneq %rax, %rsi
xorl %eax, %eax
callq 0x6390
incl 0x157db(%rip)           # 0x2fb40
movq (%r12), %rcx
leaq 0x423b(%rip), %rdi      # 0x1e5ab
pushq $0xb
popq %rsi
movq %r15, %rdx
callq 0x64c0
incl 0x157bf(%rip)           # 0x2fb40
movq (%r12), %rcx
leaq 0x422b(%rip), %rdi      # 0x1e5b7
pushq $0x4
popq %rsi
movq %r15, %rdx
callq 0x64c0
addq $0x8, %rbp
jmp 0x1a2da
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_Expression::codeGen(Symbol*)
DEF_AST_METHOD(Expression,AST_CODEGEN)
{
    if(nodes.size())CODEGEN(nodes[0]);
    FOR2ND(nodes)
    {
        PRINTF("pop\n");
        CODEGEN(nodes[i]);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
cmpq %rax, 0x10(%rdi)
je 0x1a3d7
movq (%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
pushq $0x1
popq %rbp
leaq 0x41d6(%rip), %r12      # 0x1e5b7
pushq $0x4
popq %r13
movq %rbp, %r15
movq 0x10(%r14), %rax
subq 0x8(%r14), %rax
sarq $0x3, %rax
cmpq %r15, %rax
jbe 0x1a42d
incl 0x15741(%rip)           # 0x2fb40
leaq 0x15412(%rip), %rax     # 0x2f818
movq (%rax), %rcx
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x64c0
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
incq %r15
jmp 0x1a3e8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_ArgumentList::codeGen(Symbol*)
DEF_AST_METHOD(ArgumentList,AST_CODEGEN)
{
    bool isGlobalThis=last_object_get!=print_count;
    PRINTF("; callee\n");
    PRINTF("dup\n"); 
    PRINTF("; this\n");
    if(isGlobalThis)PRINTF("load_global 0\n");
    else PRINTF("get_this\n");
    for(int i=nodes.size()-1;~i;i--)
    {
        PRINTF("; arugment %d\n",i);
        CODEGEN(nodes[i]);
    }
    PRINTF("call %lu\n",nodes.size()+2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x156f1(%rip), %ebp     # 0x2fb44
movl 0x156e6(%rip), %r12d    # 0x2fb40
leal 0x1(%r12), %eax
movl %eax, 0x156db(%rip)     # 0x2fb40
leaq 0x153ac(%rip), %r13     # 0x2f818
movq (%r13), %rcx
leaq 0x4145(%rip), %rdi      # 0x1e5bc
pushq $0x9
popq %rsi
pushq $0x1
popq %r15
movq %r15, %rdx
callq 0x64c0
incl 0x156b4(%rip)           # 0x2fb40
movq (%r13), %rcx
leaq 0x412f(%rip), %rdi      # 0x1e5c6
pushq $0x4
popq %rsi
movq %r15, %rdx
callq 0x64c0
incl 0x15698(%rip)           # 0x2fb40
movq (%r13), %rcx
leaq 0x4118(%rip), %rdi      # 0x1e5cb
pushq $0x7
popq %rsi
movq %r15, %rdx
callq 0x64c0
incl 0x1567c(%rip)           # 0x2fb40
movq (%r13), %rcx
cmpl %r12d, %ebp
jne 0x1a4d8
leaq 0x410e(%rip), %rdi      # 0x1e5e2
pushq $0x9
jmp 0x1a4e1
leaq 0x40f4(%rip), %rdi      # 0x1e5d3
pushq $0xe
popq %rsi
pushq $0x1
popq %rdx
callq 0x64c0
movq 0x10(%rbx), %r15
subq 0x8(%rbx), %r15
shrq $0x3, %r15
decl %r15d
leaq 0x40ec(%rip), %r12      # 0x1e5ec
cmpl $-0x1, %r15d
je 0x1a536
incl 0x15634(%rip)           # 0x2fb40
movq (%r13), %rdi
movq %r12, %rsi
movl %r15d, %edx
xorl %eax, %eax
callq 0x6390
movslq %r15d, %rax
movq 0x8(%rbx), %rcx
movq (%rcx,%rax,8), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
decl %r15d
jmp 0x1a500
incl 0x15604(%rip)           # 0x2fb40
movq 0x10(%rbx), %rdx
subq 0x8(%rbx), %rdx
movq (%r13), %rdi
sarq $0x3, %rdx
addq $0x2, %rdx
leaq 0x40a4(%rip), %rsi      # 0x1e5fb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6390
// File: /workspace/github_cpp_makefile_star2_O2/Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_MemberPartExpression::codeGen(Symbol*)
DEF_AST_METHOD(MemberPartExpression,AST_CODEGEN)
{
    PRINTF("dup\n");
    PRINTF("set_this\n");
    int this_bak=++this_count;
    CODEGEN(expr);
    PRINTF("swap\n");
    if(this_bak!=this_count)
    {
        PRINTF("set_this\n");
        this_count++;
    
    }else PRINTF("pop\n");
    PRINTF("object_get\n");
    last_object_get=print_count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
incl 0x15451(%rip)           # 0x2fb40
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1511c(%rip), %r12     # 0x2f818
movq (%r12), %rcx
leaq 0x3ebf(%rip), %rdi      # 0x1e5c6
pushq $0x4
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x64c0
incl 0x15425(%rip)           # 0x2fb40
movq (%r12), %rcx
leaq 0x3e58(%rip), %rdi      # 0x1e57e
pushq $0x9
popq %rsi
movq %rbx, %rdx
callq 0x64c0
leaq 0x150d4(%rip), %r13     # 0x2f80c
movl (%r13), %ebp
incl %ebp
movl %ebp, (%r13)
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
incl 0x153eb(%rip)           # 0x2fb40
movq (%r12), %rcx
leaq 0x3ea5(%rip), %rdi      # 0x1e605
pushq $0x5
popq %rsi
movq %rbx, %rdx
callq 0x64c0
incl 0x153cf(%rip)           # 0x2fb40
movq (%r12), %rcx
cmpl (%r13), %ebp
jne 0x1a78f
leaq 0x3e35(%rip), %rdi      # 0x1e5b7
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
callq 0x64c0
jmp 0x1a7a5
leaq 0x3de8(%rip), %rdi      # 0x1e57e
pushq $0x9
popq %rsi
pushq $0x1
popq %rdx
callq 0x64c0
incl (%r13)
incl 0x15395(%rip)           # 0x2fb40
movq (%r12), %rcx
leaq 0x3e55(%rip), %rdi      # 0x1e60b
pushq $0xb
popq %rsi
pushq $0x1
popq %rdx
callq 0x64c0
movl 0x15379(%rip), %eax     # 0x2fb40
movl %eax, 0x15377(%rip)     # 0x2fb44
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_MemberPartIdentifer::codeGen(Symbol*)
DEF_AST_METHOD(MemberPartIdentifer,AST_CODEGEN)
{
    PRINTF("set_this\n");
    this_count++;
    PRINTF("push \"%s\"\n",GET_LITERAL(identifer).raw.c_str());
    PRINTF("object_get\n");
    last_object_get=print_count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
incl 0x15359(%rip)           # 0x2fb40
movq %rdi, %rbx
leaq 0x15027(%rip), %r15     # 0x2f818
movq (%r15), %rcx
leaq 0x3d83(%rip), %rdi      # 0x1e57e
pushq $0x9
popq %rsi
pushq $0x1
popq %r14
movq %r14, %rdx
callq 0x64c0
leaq 0x14ffb(%rip), %rax     # 0x2f80c
incl (%rax)
incl 0x15327(%rip)           # 0x2fb40
movq (%r15), %rdi
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdx
leaq 0x3d75(%rip), %rsi      # 0x1e5a0
xorl %eax, %eax
callq 0x6390
incl 0x15308(%rip)           # 0x2fb40
movq (%r15), %rcx
leaq 0x3dc9(%rip), %rdi      # 0x1e60b
pushq $0xb
popq %rsi
movq %r14, %rdx
callq 0x64c0
movl 0x152ed(%rip), %eax     # 0x2fb40
movl %eax, 0x152eb(%rip)     # 0x2fb44
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_PostfixExpression::codeGen(Symbol*)
DEF_AST_METHOD(PostfixExpression,AST_CODEGEN)
{
    bool isIdentifier=is_identifier(expr);
    if(isIdentifier)loadVariant(symbol,expr);
    else CODEGEN(expr);
    PRINTF("dup\n");
    if(GET_LITERAL(optr).type==TOKEN_INCREMENT)PRINTF("inc\n");
    else PRINTF("dec\n");
    if(isIdentifier)storeVariant(symbol,expr);
    else PRINTF("object_reset\n");
    PRINTF("pop\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x1a0ca
movl %eax, %ebp
testb %al, %al
movq %rbx, (%rsp)
je 0x1a906
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1bf8a
jmp 0x1a912
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
incl 0x15228(%rip)           # 0x2fb40
leaq 0x14ef9(%rip), %rbx     # 0x2f818
movq (%rbx), %rcx
leaq 0x3c9d(%rip), %rdi      # 0x1e5c6
pushq $0x4
popq %r12
pushq $0x1
popq %r13
movq %r12, %rsi
movq %r13, %rdx
callq 0x64c0
movq 0x10(%r15), %rax
movl 0x8(%rax), %eax
incl 0x151f7(%rip)           # 0x2fb40
cmpl $0x2, %eax
movq (%rbx), %rcx
leaq 0x3cc1(%rip), %rax      # 0x1e617
leaq 0x3cbf(%rip), %rdi      # 0x1e61c
cmoveq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x64c0
testb %bpl, %bpl
je 0x1a97f
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x1bf9d
jmp 0x1a99a
incl 0x151bb(%rip)           # 0x2fb40
movq (%rbx), %rcx
leaq 0x3c92(%rip), %rdi      # 0x1e621
pushq $0xd
popq %rsi
pushq $0x1
popq %rdx
callq 0x64c0
incl 0x151a0(%rip)           # 0x2fb40
movq (%rbx), %rcx
leaq 0x3c0d(%rip), %rdi      # 0x1e5b7
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x64c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_PrefixExpression::codeGen(Symbol*)
DEF_AST_METHOD(PrefixExpression,AST_CODEGEN)
{
    bool isIdentifier=is_identifier(expr);
    if(isIdentifier)loadVariant(symbol,expr);
    else CODEGEN(expr);

    if(GET_LITERAL(optr).type==TOKEN_INCREMENT||GET_LITERAL(optr).type==TOKEN_DECREMENT)
    {
        if(GET_LITERAL(optr).type==TOKEN_INCREMENT)PRINTF("inc\n");
        else PRINTF("dec\n");
        if(isIdentifier)storeVariant(symbol,expr);
        else PRINTF("object_reset\n");
        return;
    }

    switch(GET_LITERAL(optr).type)
    {
        case TOKEN_ADD:
            PRINTF("pos\n");
            break;
        case TOKEN_SUB:
            PRINTF("neg\n");
            break;
        case TOKEN_BITWISE_NOT:
            PRINTF("bnot\n");
            break;
        case TOKEN_NEGATION:
            PRINTF("lnot\n");
            break;
        default:
            PRINTF("typeof\n");
            break;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x1a0ca
movl %eax, %ebp
testb %al, %al
je 0x1a9f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1bf8a
jmp 0x1a9fc
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
movq 0x10(%r15), %rax
movl 0x8(%rax), %eax
incl 0x15137(%rip)           # 0x2fb40
leaq 0x14e08(%rip), %r15     # 0x2f818
movq (%r15), %rcx
leal -0x2(%rax), %edx
cmpl $0x5, %edx
ja 0x1aa34
leaq 0x3a4a(%rip), %rax      # 0x1e46c
movslq (%rax,%rdx,4), %rdx
addq %rax, %rdx
jmpq *%rdx
leaq 0x3be5(%rip), %rdi      # 0x1e617
jmp 0x1aa6d
cmpl $0x1a, %eax
je 0x1aaa6
cmpl $0x1e, %eax
jne 0x1aa47
leaq 0x3bfa(%rip), %rdi      # 0x1e63f
jmp 0x1aaad
leaq 0x3bf7(%rip), %rdi      # 0x1e645
pushq $0x7
jmp 0x1aaaf
leaq 0x3bdb(%rip), %rdi      # 0x1e634
jmp 0x1aa62
leaq 0x3bcd(%rip), %rdi      # 0x1e62f
pushq $0x4
jmp 0x1aaaf
leaq 0x3baf(%rip), %rdi      # 0x1e61c
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
callq 0x64c0
testb %bpl, %bpl
je 0x1aa92
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1bf9d
incl 0x150a8(%rip)           # 0x2fb40
movq (%r15), %rcx
leaq 0x3b7f(%rip), %rdi      # 0x1e621
pushq $0xd
jmp 0x1aaaf
leaq 0x3b8c(%rip), %rdi      # 0x1e639
pushq $0x5
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x64c0