LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x12a7b(%rip)           # 0x2fb30
movq %rsi, (%rsp)
movq %rdi, %r14
leaq 0x12745(%rip), %r13     # 0x2f808
movq (%r13), %rcx
leaq 0x4516(%rip), %rdi      # 0x215e4
movl $0xb, %esi
movl $0x1, %edx
callq 0x64b0
leaq 0x12718(%rip), %rbp     # 0x2f7fc
movl (%rbp), %r15d
incl %r15d
movl %r15d, (%rbp)
movq 0x8(%r14), %r12
movq 0x10(%r14), %r14
cmpq %r14, %r12
je 0x1d1c2
movq (%r12), %rbx
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
movq (%rsp), %rsi
callq *0x18(%rax)
cmpl (%rbp), %r15d
je 0x1d143
incl 0x12a12(%rip)           # 0x2fb30
movq (%r13), %rcx
movl $0xb, %esi
movl $0x1, %edx
leaq 0x4499(%rip), %rdi      # 0x215cc
callq 0x64b0
movl (%rbp), %r15d
incl %r15d
movl %r15d, (%rbp)
leaq 0x8(%rbx), %rdi
callq 0x1cee6
incl 0x129de(%rip)           # 0x2fb30
movq (%r13), %rdi
movq 0x8(%rbx), %rcx
movq 0x18(%rcx), %rdx
testb %al, %al
leaq 0x4451(%rip), %rsi      # 0x215b8
leaq 0x4482(%rip), %rax      # 0x215f0
cmovneq %rax, %rsi
xorl %eax, %eax
callq 0x6390
incl 0x129b1(%rip)           # 0x2fb30
movq (%r13), %rcx
movl $0xb, %esi
movl $0x1, %edx
leaq 0x4467(%rip), %rdi      # 0x215fb
callq 0x64b0
incl 0x12991(%rip)           # 0x2fb30
movq (%r13), %rcx
movl $0x4, %esi
movl $0x1, %edx
leaq 0x4453(%rip), %rdi      # 0x21607
callq 0x64b0
addq $0x8, %r12
jmp 0x1d0f7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rax
movq %rax, %rcx
cmpq %rdx, %rax
je 0x1d205
movq (%rdx), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
cmpq $0x9, %rcx
jb 0x1d263
movl $0x1, %r12d
leaq 0x125ed(%rip), %r13     # 0x2f808
leaq 0x43e5(%rip), %r15      # 0x21607
incl 0x12908(%rip)           # 0x2fb30
movq (%r13), %rcx
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
callq 0x64b0
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
incq %r12
movq 0x10(%r14), %rax
subq 0x8(%r14), %rax
sarq $0x3, %rax
cmpq %r12, %rax
ja 0x1d222
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x128af(%rip), %ebp     # 0x2fb34
movl 0x128a4(%rip), %r15d    # 0x2fb30
leal 0x1(%r15), %eax
movl %eax, 0x1289a(%rip)     # 0x2fb30
leaq 0x1256b(%rip), %r13     # 0x2f808
movq (%r13), %rcx
leaq 0x4364(%rip), %rdi      # 0x2160c
movl $0x9, %esi
movl $0x1, %edx
callq 0x64b0
incl 0x12873(%rip)           # 0x2fb30
movq (%r13), %rcx
leaq 0x434e(%rip), %rdi      # 0x21616
movl $0x4, %esi
movl $0x1, %edx
callq 0x64b0
incl 0x12853(%rip)           # 0x2fb30
movq (%r13), %rcx
leaq 0x4333(%rip), %rdi      # 0x2161b
movl $0x7, %esi
movl $0x1, %edx
callq 0x64b0
incl 0x12833(%rip)           # 0x2fb30
movq (%r13), %rcx
cmpl %r15d, %ebp
jne 0x1d314
leaq 0x4325(%rip), %rdi      # 0x21632
movl $0x9, %esi
jmp 0x1d320
leaq 0x4308(%rip), %rdi      # 0x21623
movl $0xe, %esi
movl $0x1, %edx
callq 0x64b0
movq 0x10(%rbx), %rdx
subq 0x8(%rbx), %rdx
movq %rdx, %r15
shrq $0x3, %r15
testl %r15d, %r15d
je 0x1d381
decl %r15d
leaq 0x42f4(%rip), %r12      # 0x2163c
incl 0x127e2(%rip)           # 0x2fb30
movq (%r13), %rdi
movq %r12, %rsi
movl %r15d, %edx
xorl %eax, %eax
callq 0x6390
movslq %r15d, %r15
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
addl $-0x1, %r15d
jb 0x1d348
movq 0x10(%rbx), %rdx
subq 0x8(%rbx), %rdx
incl 0x127a9(%rip)           # 0x2fb30
movq (%r13), %rdi
sarq $0x3, %rdx
addq $0x2, %rdx
leaq 0x42b1(%rip), %rsi      # 0x2164b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6390
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
incl 0x125f0(%rip)           # 0x2fb30
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x122bb(%rip), %r15     # 0x2f808
movq (%r15), %rcx
leaq 0x40bf(%rip), %rdi      # 0x21616
movl $0x4, %esi
movl $0x1, %edx
callq 0x64b0
incl 0x125c4(%rip)           # 0x2fb30
movq (%r15), %rcx
leaq 0x4058(%rip), %rdi      # 0x215ce
movl $0x9, %esi
movl $0x1, %edx
callq 0x64b0
leaq 0x12270(%rip), %r12     # 0x2f7fc
movl (%r12), %ebp
incl %ebp
movl %ebp, (%r12)
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
incl 0x12587(%rip)           # 0x2fb30
movq (%r15), %rcx
leaq 0x40a2(%rip), %rdi      # 0x21655
movl $0x5, %esi
movl $0x1, %edx
callq 0x64b0
incl 0x12568(%rip)           # 0x2fb30
movq (%r15), %rcx
cmpl (%r12), %ebp
jne 0x1d5e9
leaq 0x402f(%rip), %rdi      # 0x21607
movl $0x4, %esi
movl $0x1, %edx
callq 0x64b0
jmp 0x1d603
leaq 0x3fde(%rip), %rdi      # 0x215ce
movl $0x9, %esi
movl $0x1, %edx
callq 0x64b0
incl (%r12)
incl 0x12527(%rip)           # 0x2fb30
movq (%r15), %rcx
leaq 0x4048(%rip), %rdi      # 0x2165b
movl $0xb, %esi
movl $0x1, %edx
callq 0x64b0
movl 0x12508(%rip), %eax     # 0x2fb30
movl %eax, 0x12506(%rip)     # 0x2fb34
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
incl 0x124ee(%rip)           # 0x2fb30
movq %rdi, %rbx
leaq 0x121bc(%rip), %r14     # 0x2f808
movq (%r14), %rcx
leaq 0x3f78(%rip), %rdi      # 0x215ce
movl $0x9, %esi
movl $0x1, %edx
callq 0x64b0
leaq 0x12190(%rip), %rax     # 0x2f7fc
incl (%rax)
incl 0x124bc(%rip)           # 0x2fb30
movq (%r14), %rdi
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdx
leaq 0x3f6a(%rip), %rsi      # 0x215f0
xorl %eax, %eax
callq 0x6390
incl 0x1249d(%rip)           # 0x2fb30
movq (%r14), %rcx
leaq 0x3fbe(%rip), %rdi      # 0x2165b
movl $0xb, %esi
movl $0x1, %edx
callq 0x64b0
movl 0x1247e(%rip), %eax     # 0x2fb30
movl %eax, 0x1247c(%rip)     # 0x2fb34
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x1cee6
movl %eax, %ebp
movq 0x8(%r15), %rsi
testb %al, %al
je 0x1d76b
addq $0x18, %rsi
leaq 0x40cf(%rip), %rdx      # 0x21830
movq %rbx, %rdi
callq 0x1cdd8
jmp 0x1d777
movq (%rsi), %rax
movq %rsi, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
incl 0x123b3(%rip)           # 0x2fb30
leaq 0x12084(%rip), %r12     # 0x2f808
movq (%r12), %rcx
leaq 0x3e87(%rip), %rdi      # 0x21616
movl $0x4, %esi
movl $0x1, %edx
callq 0x64b0
movq 0x10(%r15), %rax
movl 0x8(%rax), %eax
incl 0x12385(%rip)           # 0x2fb30
cmpl $0x2, %eax
movq (%r12), %rcx
leaq 0x3eae(%rip), %rax      # 0x21667
leaq 0x3eac(%rip), %rdi      # 0x2166c
cmoveq %rax, %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x64b0
testb %bpl, %bpl
je 0x1d7f0
movq (%r14), %rsi
addq $0x18, %rsi
leaq 0x407a(%rip), %rdx      # 0x21860
movq %rbx, %rdi
callq 0x1cdd8
jmp 0x1d810
incl 0x1233a(%rip)           # 0x2fb30
movq (%r12), %rcx
leaq 0x3e70(%rip), %rdi      # 0x21671
movl $0xd, %esi
movl $0x1, %edx
callq 0x64b0
incl 0x1231a(%rip)           # 0x2fb30
movq (%r12), %rcx
leaq 0x3de6(%rip), %rdi      # 0x21607
movl $0x4, %esi
movl $0x1, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x64b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1cee6
movl %eax, %ebp
movq 0x8(%r15), %rsi
testb %al, %al
je 0x1d870
addq $0x18, %rsi
leaq 0x3fca(%rip), %rdx      # 0x21830
movq %rbx, %rdi
callq 0x1cdd8
jmp 0x1d87c
movq (%rsi), %rax
movq %rsi, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
movq 0x10(%r15), %rax
movl 0x8(%rax), %eax
incl 0x122a7(%rip)           # 0x2fb30
leaq 0x11f78(%rip), %r15     # 0x2f808
movq (%r15), %rcx
leal -0x2(%rax), %edx
cmpl $0x5, %edx
ja 0x1d8b4
leaq 0x3c1a(%rip), %rax      # 0x214bc
movslq (%rax,%rdx,4), %rdx
addq %rax, %rdx
jmpq *%rdx
leaq 0x3db5(%rip), %rdi      # 0x21667
jmp 0x1d8f7
cmpl $0x1a, %eax
je 0x1d942
cmpl $0x1e, %eax
jne 0x1d8cb
leaq 0x3dc6(%rip), %rdi      # 0x2168f
jmp 0x1d949
leaq 0x3dc3(%rip), %rdi      # 0x21695
movl $0x7, %esi
jmp 0x1d94e
leaq 0x3da4(%rip), %rdi      # 0x21684
jmp 0x1d8e9
leaq 0x3d96(%rip), %rdi      # 0x2167f
movl $0x4, %esi
jmp 0x1d94e
leaq 0x3d75(%rip), %rdi      # 0x2166c
movl $0x4, %esi
movl $0x1, %edx
callq 0x64b0
testb %bpl, %bpl
je 0x1d92b
movq (%r14), %rsi
addq $0x18, %rsi
leaq 0x3f47(%rip), %rdx      # 0x21860
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1cdd8
incl 0x121ff(%rip)           # 0x2fb30
movq (%r15), %rcx
leaq 0x3d36(%rip), %rdi      # 0x21671
movl $0xd, %esi
jmp 0x1d94e
leaq 0x3d40(%rip), %rdi      # 0x21689
movl $0x5, %esi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x64b0
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_ConditionalExpression::codeGen(Symbol*)
DEF_AST_METHOD(ConditionalExpression,AST_CODEGEN)
{
    PRINTF("; conditional expression\n");
    CODEGEN(expr);
    PRINTF("istrue\n");
    int falseLabel=nextLabel();
    int jmpLabel=nextLabel();
    PRINTF("jmp label_%d\n",falseLabel);
    PRINTF("; true branch\n");
    CODEGEN(trueExpr);
    PRINTF("jmp label_%d\n",jmpLabel);
    PRINTF("label_%d:\n",falseLabel);
    PRINTF("; false branch\n");
    CODEGEN(falseExpr);
    PRINTF("label_%d:\n",jmpLabel);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
incl 0x11e49(%rip)           # 0x2fb30
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x11b14(%rip), %r13     # 0x2f808
movq (%r13), %rcx
leaq 0x3a12(%rip), %rdi      # 0x21711
movl $0x19, %esi
movl $0x1, %edx
callq 0x64b0
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
incl 0x11e0f(%rip)           # 0x2fb30
movq (%r13), %rcx
leaq 0x3971(%rip), %rdi      # 0x2169d
movl $0x7, %esi
movl $0x1, %edx
callq 0x64b0
callq 0xdb7b
movl %eax, %r15d
callq 0xdb7b
movl %eax, %ebp
incl 0x11de0(%rip)           # 0x2fb30
movq (%r13), %rdi
leaq 0x394a(%rip), %r12      # 0x216a5
movq %r12, %rsi
movl %r15d, %edx
xorl %eax, %eax
callq 0x6390
incl 0x11dc2(%rip)           # 0x2fb30
movq (%r13), %rcx
leaq 0x39b2(%rip), %rdi      # 0x2172b
movl $0xe, %esi
movl $0x1, %edx
callq 0x64b0
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
incl 0x11d95(%rip)           # 0x2fb30
movq (%r13), %rdi
movq %r12, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x6390
incl 0x11d7f(%rip)           # 0x2fb30
movq (%r13), %rdi
leaq 0x394a(%rip), %r12      # 0x21706
movq %r12, %rsi
movl %r15d, %edx
xorl %eax, %eax
callq 0x6390
incl 0x11d61(%rip)           # 0x2fb30
movq (%r13), %rcx
leaq 0x3960(%rip), %rdi      # 0x2173a
movl $0xf, %esi
movl $0x1, %edx
callq 0x64b0
movq 0x18(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
incl 0x11d34(%rip)           # 0x2fb30
movq (%r13), %rdi
movq %r12, %rsi
movl %ebp, %edx
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_O3/Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_IfStatement::codeGen(Symbol*)
DEF_AST_METHOD(IfStatement,AST_CODEGEN)
{
    PRINTF("; if statement\n");
    CODEGEN(expr);
    PRINTF("istrue\n");
    int jmpLabel=nextLabel();
    int elseLabel;
    if(elseStatement)elseLabel=nextLabel();
    else elseLabel=jmpLabel;
    PRINTF("jmp label_%d\n",elseLabel);
    PRINTF("; true branch\n");
    CODEGEN(statement);
    if(elseStatement)
    {
        PRINTF("jmp label_%d\n",jmpLabel);
        PRINTF("label_%d:\n",elseLabel);
        PRINTF("; else branch\n");
        CODEGEN(elseStatement);
    }
    PRINTF("label_%d:\n",jmpLabel);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
incl 0x11a8e(%rip)           # 0x2fb30
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x11759(%rip), %r12     # 0x2f808
movq (%r12), %rcx
leaq 0x3690(%rip), %rdi      # 0x2174a
movl $0xf, %esi
movl $0x1, %edx
callq 0x64b0
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
incl 0x11a54(%rip)           # 0x2fb30
movq (%r12), %rcx
leaq 0x35b6(%rip), %rdi      # 0x2169d
movl $0x7, %esi
movl $0x1, %edx
callq 0x64b0
callq 0xdb7b
movl %eax, %ebp
cmpq $0x0, 0x18(%r14)
movl %eax, %r15d
je 0x1e10f
callq 0xdb7b
movl %eax, %r15d
incl 0x11a1b(%rip)           # 0x2fb30
movq (%r12), %rdi
leaq 0x3585(%rip), %rsi      # 0x216a5
movl %r15d, %edx
xorl %eax, %eax
callq 0x6390
incl 0x11a00(%rip)           # 0x2fb30
movq (%r12), %rcx
leaq 0x35f0(%rip), %rdi      # 0x2172b
movl $0xe, %esi
movl $0x1, %edx
callq 0x64b0
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
cmpq $0x0, 0x18(%r14)
je 0x1e1c0
incl 0x119cc(%rip)           # 0x2fb30
movq (%r12), %rdi
leaq 0x3536(%rip), %rsi      # 0x216a5
movl %ebp, %edx
xorl %eax, %eax
callq 0x6390
incl 0x119b2(%rip)           # 0x2fb30
movq (%r12), %rdi
leaq 0x357d(%rip), %rsi      # 0x21706
movl %r15d, %edx
xorl %eax, %eax
callq 0x6390
incl 0x11997(%rip)           # 0x2fb30
movq (%r12), %rcx
leaq 0x35b6(%rip), %rdi      # 0x2175a
movl $0xe, %esi
movl $0x1, %edx
callq 0x64b0
movq 0x18(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
incl 0x1196a(%rip)           # 0x2fb30
movq (%r12), %rdi
leaq 0x3535(%rip), %rsi      # 0x21706
movl %ebp, %edx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6390
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_VariableDeclaration::codeGen(Symbol*)
DEF_AST_METHOD(VariableDeclaration,AST_CODEGEN)
{
    if(!assignExpr)return;
    CODEGEN(assignExpr);
    storeVariant(symbol,identifier);
    PRINTF("pop\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x1e23f
movq %rsi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%r14), %rsi
addq $0x18, %rsi
leaq 0x3656(%rip), %rdx      # 0x21860
movq %rbx, %rdi
callq 0x1cdd8
incl 0x11918(%rip)           # 0x2fb30
leaq 0x115e9(%rip), %rax     # 0x2f808
movq (%rax), %rcx
leaq 0x33de(%rip), %rdi      # 0x21607
movl $0x4, %esi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x64b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_DoStatement::codeGen(Symbol*)
DEF_AST_METHOD(DoStatement,AST_CODEGEN)
{
    int beginLabel=nextLabel();
    int endLabel=nextLabel();
    int continueLabel=nextLabel();
    continueStack.push(continueLabel);
    breakStack.push(endLabel);
    GET_SCOPE();
    PRINTF("; do statement\n");
    PRINTF("label_%d:\n",beginLabel);
    PRINTF("; statement\n");
    CODEGEN(statement);
    PRINTF("label_%d:\n",continueLabel);
    PRINTF("; check expression\n");
    CODEGEN(expr);
    PRINTF("isfalse\n");
    PRINTF("jmp label_%d\n",beginLabel);
    PRINTF("label_%d:\n",endLabel);
    continueStack.pop();
    breakStack.pop();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
callq 0xdb7b
movl %eax, %ebx
callq 0xdb7b
movl %eax, %ebp
movl %eax, 0xc(%rsp)
callq 0xdb7b
movl %eax, 0x8(%rsp)
leaq 0x111cb(%rip), %rcx     # 0x2f6b8
movq 0x30(%rcx), %rdx
movq 0x40(%rcx), %rsi
addq $-0x4, %rsi
cmpq %rsi, %rdx
je 0x1e50a
movl %eax, (%rdx)
addq $0x4, %rdx
movq %rdx, 0x30(%rcx)
jmp 0x1e51b
leaq 0x111a7(%rip), %rdi     # 0x2f6b8
leaq 0x8(%rsp), %rsi
callq 0x1f024
leaq 0x111e6(%rip), %rax     # 0x2f708
movq 0x30(%rax), %rcx
movq 0x40(%rax), %rdx
addq $-0x4, %rdx
cmpq %rdx, %rcx
je 0x1e53f
movl %ebp, (%rcx)
addq $0x4, %rcx
movq %rcx, 0x30(%rax)
jmp 0x1e550
leaq 0x111c2(%rip), %rdi     # 0x2f708
leaq 0xc(%rsp), %rsi
callq 0x1f024
leaq 0x10(%rsp), %rsi
movq %r14, (%rsi)
leaq 0x11129(%rip), %rdi     # 0x2f688
callq 0x10a90
movq (%rax), %r12
incl 0x115c3(%rip)           # 0x2fb30
leaq 0x11294(%rip), %r13     # 0x2f808
movq (%r13), %rcx
leaq 0x3237(%rip), %rdi      # 0x217b6
movl $0xf, %esi
movl $0x1, %edx
callq 0x64b0
incl 0x1159c(%rip)           # 0x2fb30
movq (%r13), %rdi
leaq 0x3167(%rip), %r15      # 0x21706
movq %r15, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x6390
incl 0x1157f(%rip)           # 0x2fb30
movq (%r13), %rcx
leaq 0x31da(%rip), %rdi      # 0x21796
movl $0xc, %esi
movl $0x1, %edx
callq 0x64b0
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x18(%rax)
incl 0x11552(%rip)           # 0x2fb30
movq (%r13), %rdi
movl 0x8(%rsp), %edx
movq %r15, %rsi
xorl %eax, %eax
callq 0x6390
incl 0x1153a(%rip)           # 0x2fb30
movq (%r13), %rcx
leaq 0x3181(%rip), %rdi      # 0x21782
movl $0x13, %esi
movl $0x1, %edx
callq 0x64b0
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x18(%rax)
incl 0x1150d(%rip)           # 0x2fb30
movq (%r13), %rcx
leaq 0x3085(%rip), %rdi      # 0x216b3
movl $0x8, %esi
movl $0x1, %edx
callq 0x64b0
incl 0x114ed(%rip)           # 0x2fb30
movq (%r13), %rdi
leaq 0x3057(%rip), %rsi      # 0x216a5
movl %ebx, %edx
xorl %eax, %eax
callq 0x6390
incl 0x114d3(%rip)           # 0x2fb30
movq (%r13), %rdi
movl 0xc(%rsp), %edx
movq %r15, %rsi
xorl %eax, %eax
callq 0x6390
leaq 0x11042(%rip), %rdi     # 0x2f6b8
callq 0x1f238
leaq 0x11086(%rip), %rdi     # 0x2f708
callq 0x1f238
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_WhileStatement::codeGen(Symbol*)
DEF_AST_METHOD(WhileStatement,AST_CODEGEN)
{
    int beginLabel=nextLabel();
    int endLabel=nextLabel();
    continueStack.push(beginLabel);
    breakStack.push(endLabel);
    GET_SCOPE();
    PRINTF("; while statement\n");
    PRINTF("label_%d:\n",beginLabel);
    PRINTF("; check expression\n");
    CODEGEN(expr);
    PRINTF("istrue\n");
    PRINTF("jmp label_%d\n",endLabel);
    PRINTF("; statement\n");
    CODEGEN(statement);
    PRINTF("jmp label_%d\n",beginLabel);
    PRINTF("label_%d:\n",endLabel);

    continueStack.pop();
    breakStack.pop();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0xdb7b
movl %eax, %r14d
movl %eax, 0xc(%rsp)
callq 0xdb7b
movl %eax, %ebp
movl %eax, 0x8(%rsp)
leaq 0x10ff3(%rip), %rax     # 0x2f6b8
movq 0x30(%rax), %rcx
movq 0x40(%rax), %rdx
addq $-0x4, %rdx
cmpq %rdx, %rcx
je 0x1e6e3
movl %r14d, (%rcx)
addq $0x4, %rcx
movq %rcx, 0x30(%rax)
jmp 0x1e6f4
leaq 0x10fce(%rip), %rdi     # 0x2f6b8
leaq 0xc(%rsp), %rsi
callq 0x1f024
leaq 0x1100d(%rip), %rax     # 0x2f708
movq 0x30(%rax), %rcx
movq 0x40(%rax), %rdx
addq $-0x4, %rdx
cmpq %rdx, %rcx
je 0x1e718
movl %ebp, (%rcx)
addq $0x4, %rcx
movq %rcx, 0x30(%rax)
jmp 0x1e729
leaq 0x10fe9(%rip), %rdi     # 0x2f708
leaq 0x8(%rsp), %rsi
callq 0x1f024
leaq 0x10(%rsp), %rsi
movq %rbx, (%rsi)
leaq 0x10f50(%rip), %rdi     # 0x2f688
callq 0x10a90
movq (%rax), %r14
incl 0x113ea(%rip)           # 0x2fb30
leaq 0x110bb(%rip), %r13     # 0x2f808
movq (%r13), %rcx
leaq 0x306e(%rip), %rdi      # 0x217c6
movl $0x12, %esi
movl $0x1, %edx
callq 0x64b0
incl 0x113c3(%rip)           # 0x2fb30
movq (%r13), %rdi
movl 0xc(%rsp), %edx
leaq 0x2f8a(%rip), %r15      # 0x21706
movq %r15, %rsi
xorl %eax, %eax
callq 0x6390
incl 0x113a4(%rip)           # 0x2fb30
movq (%r13), %rcx
leaq 0x2feb(%rip), %rdi      # 0x21782
movl $0x13, %esi
movl $0x1, %edx
callq 0x64b0
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
incl 0x11377(%rip)           # 0x2fb30
movq (%r13), %rcx
leaq 0x2ed9(%rip), %rdi      # 0x2169d
movl $0x7, %esi
movl $0x1, %edx
callq 0x64b0
incl 0x11357(%rip)           # 0x2fb30
movq (%r13), %rdi
movl 0x8(%rsp), %edx
leaq 0x2ebd(%rip), %r12      # 0x216a5
movq %r12, %rsi
xorl %eax, %eax
callq 0x6390
incl 0x11338(%rip)           # 0x2fb30
movq (%r13), %rcx
leaq 0x2f93(%rip), %rdi      # 0x21796
movl $0xc, %esi
movl $0x1, %edx
callq 0x64b0
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
incl 0x1130b(%rip)           # 0x2fb30
movq (%r13), %rdi
movl 0xc(%rsp), %edx
movq %r12, %rsi
xorl %eax, %eax
callq 0x6390
incl 0x112f3(%rip)           # 0x2fb30
movq (%r13), %rdi
movl 0x8(%rsp), %edx
movq %r15, %rsi
xorl %eax, %eax
callq 0x6390
leaq 0x10e62(%rip), %rdi     # 0x2f6b8
callq 0x1f238
leaq 0x10ea6(%rip), %rdi     # 0x2f708
callq 0x1f238
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_CaseBlock::codeGen(Symbol*)
DEF_AST_METHOD(CaseBlock,AST_CODEGEN)
{
    int endLabel=nextLabel();
    breakStack.push(endLabel);
    defaultClauseStack.push(-1);
    CODEGEN(caseClausesList);
    int defaultLabel=defaultClauseStack.top();
    if(defaultLabel!=-1)PRINTF("jmp label_%d\n",defaultLabel);
    PRINTF("label_%d:\n",endLabel);
    breakStack.pop();
    defaultClauseStack.pop();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xdb7b
movl %eax, 0x8(%rsp)
leaq 0x10ca3(%rip), %rcx     # 0x2f708
movq 0x30(%rcx), %rdx
movq 0x40(%rcx), %rsi
addq $-0x4, %rsi
cmpq %rsi, %rdx
je 0x1ea82
movl %eax, (%rdx)
addq $0x4, %rdx
movq %rdx, 0x30(%rcx)
jmp 0x1ea93
leaq 0x10c7f(%rip), %rdi     # 0x2f708
leaq 0x8(%rsp), %rsi
callq 0x1f024
leaq 0xc(%rsp), %rsi
movl $0xffffffff, (%rsi)     # imm = 0xFFFFFFFF
leaq 0x10cb3(%rip), %r15     # 0x2f758
movq %r15, %rdi
callq 0x1f284
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
movq 0x30(%r15), %rax
cmpq 0x38(%r15), %rax
jne 0x1ead1
movq 0x48(%r15), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movl -0x4(%rax), %edx
cmpl $-0x1, %edx
je 0x1eaf7
incl 0x11051(%rip)           # 0x2fb30
leaq 0x10d22(%rip), %rax     # 0x2f808
movq (%rax), %rdi
leaq 0x2bb5(%rip), %rsi      # 0x216a5
xorl %eax, %eax
callq 0x6390
incl 0x11033(%rip)           # 0x2fb30
leaq 0x10d04(%rip), %rax     # 0x2f808
movq (%rax), %rdi
movl 0x8(%rsp), %edx
leaq 0x2bf4(%rip), %rsi      # 0x21706
xorl %eax, %eax
callq 0x6390
leaq 0x10be8(%rip), %rdi     # 0x2f708
callq 0x1f238
leaq 0x10c2c(%rip), %rdi     # 0x2f758
callq 0x1f238
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_SwitchStatement::codeGen(Symbol*)
DEF_AST_METHOD(SwitchStatement,AST_CODEGEN)
{
    GET_SCOPE();
    PRINTF("; switch statement\n");
    CODEGEN(expr);
    CODEGEN(caseBlock);
    PRINTF("pop\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %rdi, (%rsi)
leaq 0x10b31(%rip), %rdi     # 0x2f688
callq 0x10a90
movq (%rax), %r14
incl 0x10fcb(%rip)           # 0x2fb30
leaq 0x10c9c(%rip), %r15     # 0x2f808
movq (%r15), %rcx
leaq 0x2c75(%rip), %rdi      # 0x217eb
movl $0x13, %esi
movl $0x1, %edx
callq 0x64b0
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
incl 0x10f8b(%rip)           # 0x2fb30
movq (%r15), %rcx
leaq 0x2a58(%rip), %rdi      # 0x21607
movl $0x4, %esi
movl $0x1, %edx
callq 0x64b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_Program::codeGen(Symbol*)
DEF_AST_METHOD(Program,AST_CODEGEN)
{
    GET_SCOPE();
    auto localCount=symbol->localCount;
    if(localCount)PRINTF("addsp %d\n",symbol->localCount);
    CODEGEN(stmtList);
    if(localCount)PRINTF("subsp %d\n",symbol->localCount);
    PRINTF("halt\n\n");
    for(FILE *x:func_tmpfile)copy_stream(AST::fp,x);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
movq %rdi, (%rsi)
leaq 0x10733(%rip), %rdi     # 0x2f688
callq 0x10a90
movq (%rax), %rbx
movl 0x3c(%rbx), %edx
testl %edx, %edx
je 0x1efab
incl 0x10bc6(%rip)           # 0x2fb30
leaq 0x10897(%rip), %r15     # 0x2f808
movq (%r15), %rdi
leaq 0x289b(%rip), %rsi      # 0x21816
xorl %eax, %eax
callq 0x6390
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
incl 0x10b9b(%rip)           # 0x2fb30
movq (%r15), %rdi
movl 0x3c(%rbx), %edx
leaq 0x28ad(%rip), %rsi      # 0x2184f
xorl %eax, %eax
callq 0x6390
jmp 0x1efb8
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
incl 0x10b72(%rip)           # 0x2fb30
leaq 0x10843(%rip), %rbx     # 0x2f808
movq (%rbx), %rcx
leaq 0x288a(%rip), %rdi      # 0x21859
movl $0x6, %esi
movl $0x1, %edx
callq 0x64b0
movq 0x10b53(%rip), %r14     # 0x2fb38
movq 0x10b54(%rip), %r15     # 0x2fb40
cmpq %r15, %r14
je 0x1f002
movq (%r14), %rsi
movq (%rbx), %rdi
callq 0x1eefb
addq $0x8, %r14
jmp 0x1efec
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/examples/echo/client.cpp
// Function: main
int main(){
	socket sock;

	if(!sock.connect("localhost", 1234)){
		std::cout << "connect failed!" << std::endl;
		return -1;
	}
	std::cout << "connect successfully" << std::endl;

	std::string msg;
	while(true){
		std::cout << "[send]: ";
		std::cin >> msg;

		sock.sync_write(msg.c_str(), msg.size());

		char buff[2049] = {0};
		sock.sync_read(buff, 2048);

		std::cout << "[recv]: " << buff << std::endl;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa58, %rsp            # imm = 0xA58
leaq -0x270(%rbp), %rdi
callq 0x3814
leaq -0xa70(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x4a76(%rip), %rsi      # 0x8004
leaq 0x4a78(%rip), %rdx      # 0x800d
leaq -0xa80(%rbp), %rdi
callq 0x3774
leaq -0x270(%rbp), %rdi
leaq -0xa80(%rbp), %rsi
movl $0x4d2, %edx            # imm = 0x4D2
callq 0x3ff4
movl %eax, %ebx
movq -0xa80(%rbp), %rdi
cmpq %r14, %rdi
je 0x35cc
callq 0x31f0
testb %bl, %bl
jne 0x3639
movq 0x99f9(%rip), %rbx      # 0xcfd0
leaq 0x4a30(%rip), %rsi      # 0x800e
movl $0xf, %edx
movq %rbx, %rdi
callq 0x3230
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x3200
movsbl %al, %esi
movq 0x99c7(%rip), %rdi      # 0xcfd0
callq 0x3030
movq %rax, %rdi
callq 0x3160
leaq -0x270(%rbp), %rdi
callq 0x3e8e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0xa58, %rsp            # imm = 0xA58
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x9990(%rip), %rdi      # 0xcfd0
leaq 0x49d7(%rip), %rsi      # 0x801e
movl $0x14, %edx
callq 0x3230
movq 0x9978(%rip), %rbx      # 0xcfd0
movq %rbx, %rdi
callq 0x3110
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x48(%rbp), %r12
leaq -0x270(%rbp), %r13
leaq -0xa80(%rbp), %r14
leaq 0x49b0(%rip), %r15      # 0x803c
movl $0x8, %edx
movq %rbx, %rdi
leaq 0x4998(%rip), %rsi      # 0x8033
callq 0x3230
movq 0x9939(%rip), %rdi      # 0xcfe0
movq %r12, %rsi
callq 0x3240
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r13, %rdi
callq 0x46d2
movl $0x801, %edx            # imm = 0x801
movq %r14, %rdi
xorl %esi, %esi
callq 0x3130
movl $0x800, %edx            # imm = 0x800
movq %r13, %rdi
movq %r14, %rsi
callq 0x4920
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3230
movq %r14, %rdi
callq 0x30e0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3230
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3200
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
jmp 0x368c
jmp 0x3732
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
jne 0x3753
jmp 0x375f
movq %rax, %rbx
movq -0xa80(%rbp), %rdi
cmpq %r14, %rdi
je 0x375f
callq 0x31f0
jmp 0x375f
jmp 0x375c
movq %rax, %rbx
leaq -0x270(%rbp), %rdi
callq 0x3e8e
movq %rbx, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O3/scattana[P]Crossword-Anagram-CPP/crossword.cpp
// Function: sortHighLow(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void sortHighLow(vector<string>& list){
	string temp;
	// run bubble sort algorithm
	for(int i=0; i<list.size()-1; i++){
		for(int j=0; j<list.size()-i-1; j++){
			if(list[j].size() < list[j+1].size()){
				temp = list[j];
				list[j] = list[j+1];
				list[j+1] = temp;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x20, %rdx
je 0x3ae9
movq %rdi, %rbx
xorl %r13d, %r13d
leaq -0x50(%rbp), %r14
leaq 0x1(%r13), %rsi
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %rsi, %rdx
je 0x3ac8
movq %rsi, -0x30(%rbp)
notq %r13
movl $0x20, %r15d
xorl %r12d, %r12d
movq -0x18(%rax,%r15), %rdx
cmpq 0x8(%rax,%r15), %rdx
jae 0x3aa1
leaq (%rax,%r15), %rsi
addq $-0x20, %rsi
movq %r14, %rdi
callq 0x20f0
movq (%rbx), %rsi
leaq (%rsi,%r15), %rdi
addq $-0x20, %rdi
addq %r15, %rsi
callq 0x20f0
movq (%rbx), %rdi
addq %r15, %rdi
movq %r14, %rsi
callq 0x20f0
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
incq %r12
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x5, %rdx
addq %r13, %rdx
addq $0x20, %r15
cmpq %r12, %rdx
ja 0x3a5d
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x5, %rdx
movq -0x30(%rbp), %rsi
decq %rdx
movq %rsi, %r13
cmpq %rsi, %rdx
ja 0x3a3a
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x3ae9
callq 0x2180
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x3b0d
callq 0x2180
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/scattana[P]Crossword-Anagram-CPP/board.cpp
// Function: Board::Board()
Board::Board(){
	// make a 15x15 blank board, with blanks shown as underscores
	for(int i=0; i<15; i++){
		for(int j=0; j<15; j++){
			data[i][j] = '_';
		}
	}
	// make all locations (0,0) to begin with
	for(int row=0; row<20; row++){
		for(int col=0; col<2; col++){
			locations[row][col] = 0;
		}
	}
	// "place" keeps track of which word in list goes to which location
	// start at 1 because first (longest) word will be placed before the
	// method is called that places the next word on the board
	place = 1;

	// direction keeps track of the orientation of the words placed
	for(int i=0; i<20; i++){
		direction[i] = " ";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x198, %eax            # imm = 0x198
leaq (%rbx,%rax), %rcx
movq %rcx, -0x10(%rbx,%rax)
movq $0x0, -0x8(%rbx,%rax)
movb $0x0, (%rbx,%rax)
addq $0x20, %rax
cmpq $0x418, %rax            # imm = 0x418
jne 0x3f07
movl $0xe1, %edx
movq %rbx, %rdi
movl $0x5f, %esi
callq 0x2100
leaq 0xe4(%rbx), %rdi
xorl %r15d, %r15d
movl $0xa0, %edx
xorl %esi, %esi
callq 0x2100
leaq 0x188(%rbx), %r12
movl $0x1, 0x408(%rbx)
leaq 0x147a(%rip), %r14      # 0x53e3
leaq (%r12,%r15), %rdi
movq 0x190(%rbx,%r15), %rdx
movl $0x1, %r8d
xorl %esi, %esi
movq %r14, %rcx
callq 0x2220
addq $0x20, %r15
cmpq $0x280, %r15            # imm = 0x280
jne 0x3f69
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x22c4
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/scattana[P]Crossword-Anagram-CPP/board.cpp
// Function: Board::printBoard()
void Board::printBoard(){
	for(int i=0; i<15; i++){
		for(int j=0; j<15; j++){
			cout << data[i][j];
			// add a space in between for visual purposes
			cout << " ";
		}
		cout << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq 0x2fc9(%rip), %r14      # 0x6fd0
leaq -0x29(%rbp), %r15
leaq 0x13d1(%rip), %r12      # 0x53e3
movq %rax, -0x38(%rbp)
movq $-0xf, %r13
movb 0xf(%rbx,%r13), %al
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x21d0
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x21d0
incq %r13
jne 0x401d
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq -0x38(%rbp), %rax
incq %rax
addq $0xf, %rbx
cmpq $0xf, %rax
jne 0x4012
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/scattana[P]Crossword-Anagram-CPP/board.cpp
// Function: Board::printHidden()
void Board::printHidden(){
	for(int i=0; i<15; i++){
		for(int j=0; j<15; j++){
			if(data[i][j]=='_') cout << '#';
			else cout << '_';
			// add a space in between for visual purposes
			cout << " ";
		}
		cout << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq 0x2f21(%rip), %r14      # 0x6fd0
leaq 0x132d(%rip), %r12      # 0x53e3
leaq -0x2a(%rbp), %r13
movq %rax, -0x38(%rbp)
movq $-0xf, %r15
cmpb $0x5f, 0xf(%rbx,%r15)
jne 0x40df
movb $0x23, -0x29(%rbp)
movl $0x1, %edx
movq %r14, %rdi
leaq -0x29(%rbp), %rsi
jmp 0x40ee
movb $0x5f, -0x2a(%rbp)
movl $0x1, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x21d0
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x21d0
incq %r15
jne 0x40c5
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq -0x38(%rbp), %rax
incq %rax
addq $0xf, %rbx
cmpq $0xf, %rax
jne 0x40ba
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/scattana[P]Crossword-Anagram-CPP/board.cpp
// Function: Board::findMatch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Board::findMatch(string word){
	for(int i=0; i<15; i++){
		for(int j=0; j<15; j++){
			for(int k=0; k<word.size(); k++){
				if(word[k] == getSpot(i,j)) return 1 ;
			}
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq 0x8(%rsi), %rax
movb $0x1, %cl
xorl %edx, %edx
leaq (%rdx,%rdx,4), %r8
leaq (%r8,%r8,2), %r8
addq %rdi, %r8
xorl %r9d, %r9d
testq %rax, %rax
je 0x49ab
movq (%rsi), %r10
movb (%r9,%r8), %r11b
xorl %ebx, %ebx
cmpb %r11b, (%r10,%rbx)
je 0x49cc
incq %rbx
cmpq %rbx, %rax
jne 0x499d
incq %r9
cmpq $0xf, %r9
jne 0x498f
cmpq $0xe, %rdx
leaq 0x1(%rdx), %r8
setb %cl
movq %r8, %rdx
cmpq $0xf, %r8
jne 0x4981
xorl %eax, %eax
jmp 0x49d2
movzbl %cl, %eax
andl $0x1, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/7shi[P]8086run/v2/bios.cpp
// Function: moveCursorToBottom()
void moveCursorToBottom() {
    if (cleared) {
        AH = 2, DL = 79, DH = 24;
        bios(0x10);
        AX = 0x0e0d;
        bios(0x10);
    }
}

// Assembly:
leaq 0x129751(%rip), %rax    # 0x12b4f2
cmpb $0x1, (%rax)
jne 0x1de4
pushq %rax
leaq 0x1295f2(%rip), %rax    # 0x12b3a0
movq 0x20(%rax), %rcx
movb $0x2, (%rcx)
movq 0x10(%rax), %rcx
movb $0x4f, (%rcx)
movq 0x30(%rax), %rax
movb $0x18, (%rax)
movl $0x10, %edi
callq 0x148c
leaq 0x1295bc(%rip), %rax    # 0x12b390
movw $0xe0d, (%rax)          # imm = 0xE0D
movl $0x10, %edi
popq %rax
jmp 0x148c
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/7shi[P]8086run/v2/utils.cpp
// Function: mclock()
int mclock() {
#ifdef _WIN32
    clock_t clk = clock();
    static clock_t clk0 = clk;
    clk -= clk0;
    return clk * 1000 / CLOCKS_PER_SEC;
#else
    struct timeval tv;
    gettimeofday(&tv, NULL);
    static time_t sec0 = tv.tv_sec;
    return (tv.tv_sec - sec0) * 1000 + tv.tv_usec / 1000;
#endif
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsp, %rdi
xorl %esi, %esi
callq 0x11f0
movb 0x1242d5(%rip), %al     # 0x12b5b8
testb %al, %al
je 0x731b
movq (%rsp), %rbx
subl 0x1242bf(%rip), %ebx    # 0x12b5b0
movabsq $0x20c49ba5e353f7cf, %rax # imm = 0x20C49BA5E353F7CF
imulq 0x8(%rsp)
imull $0x3e8, %ebx, %ecx      # imm = 0x3E8
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x7, %rdx
addl %edx, %eax
addl %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x124296(%rip), %rdi    # 0x12b5b8
callq 0x1210
movq (%rsp), %rbx
testl %eax, %eax
je 0x72eb
movq %rbx, 0x12427a(%rip)    # 0x12b5b0
leaq 0x12427b(%rip), %rdi    # 0x12b5b8
callq 0x1090
jmp 0x72eb
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O3/Rekran[P]HahTable-Chaining-/LinkedList.cpp
// Function: LinkedList::print()
void LinkedList::print(){
	Node *n = this->header.head;
	for(int i = 0;i < this->header.size; i++){
		std::cout<<"["<<i<<"]"<<n->word<<" ";
		n = n->Next;
		
		if(i%10 == 0 && i != 0)
			std::cout<<std::endl;	
 	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, -0x30(%rbp)
cmpl $0x0, 0x10(%rdi)
jle 0x2525
movq -0x30(%rbp), %rax
movq (%rax), %rbx
xorl %r14d, %r14d
movq 0x3b93(%rip), %r15      # 0x5fd8
movl $0x1, %edx
movq %r15, %rdi
leaq 0x1bb0(%rip), %rsi      # 0x4004
callq 0x2160
movq %r15, %rdi
movl %r14d, %esi
callq 0x21d0
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
leaq 0x1b90(%rip), %rsi      # 0x4006
callq 0x2160
movq 0x8(%rbx), %r12
testq %r12, %r12
je 0x249c
movq %r12, %rdi
callq 0x20b0
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2160
jmp 0x24b7
movq (%r13), %rax
movq -0x18(%rax), %rax
movq %r13, %rdi
addq %rax, %rdi
movl 0x20(%r13,%rax), %esi
orl $0x1, %esi
callq 0x21c0
movl $0x1, %edx
movq %r13, %rdi
leaq 0x1b47(%rip), %rsi      # 0x400d
callq 0x2160
movq (%rbx), %rbx
testl %r14d, %r14d
je 0x2514
movl %r14d, %eax
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
imulq %rcx, %rax
shrq $0x23, %rax
addl %eax, %eax
leal (%rax,%rax,4), %eax
cmpl %r14d, %eax
jne 0x2514
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
incl %r14d
movq -0x30(%rbp), %rax
cmpl 0x10(%rax), %r14d
jl 0x2445
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Rekran[P]HahTable-Chaining-/LinkedList.cpp
// Function: LinkedList::prepend(char*)
void LinkedList::prepend(char *word){
	if(header.head == NULL){
		Node *N1 = new Node();
		N1->word = word;
		
		this->header.head = N1;
		this->header.tail = N1;
		
		this->header.size += 1;	
			
	}else{
		
		Node *N1 = new Node();
		N1->word = word;
		
		N1->Next = header.head;
		this->header.head = N1;
		
		this->header.size += 1;	
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %r12
movl $0x18, %edi
callq 0x2140
movq %rax, %rbx
testq %r12, %r12
je 0x2571
movq %rbx, %rdi
callq 0x23bc
movq %r15, 0x8(%rbx)
movq (%r14), %rax
movq %rax, (%rbx)
movq %r14, %rax
jmp 0x2584
movq %rbx, %rdi
callq 0x23bc
movq %r15, 0x8(%rbx)
movq %rbx, (%r14)
leaq 0x8(%r14), %rax
movq %rbx, (%rax)
incl 0x10(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2596
movq %rax, %r14
movl $0x18, %esi
movq %rbx, %rdi
callq 0x2150
movq %r14, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/Rekran[P]HahTable-Chaining-/LinkedList.cpp
// Function: LinkedList::prepend(int)
void LinkedList::prepend(int value){
	if(header.head == NULL){
		Node *N1 = new Node();
		N1->Value = value;
		
		this->header.head = N1;
		this->header.tail = N1;
		
		this->header.size += 1;	
			
	}else{
		
		Node *N1 = new Node();
		N1->Value = value;
		
		N1->Next = header.head;
		this->header.head = N1;
		
		this->header.size += 1;	
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r15d
movq %rdi, %r14
movq (%rdi), %r12
movl $0x18, %edi
callq 0x2140
movq %rax, %rbx
testq %r12, %r12
je 0x25eb
movq %rbx, %rdi
callq 0x23bc
movl %r15d, 0x10(%rbx)
movq (%r14), %rax
movq %rax, (%rbx)
movq %r14, %rax
jmp 0x25fe
movq %rbx, %rdi
callq 0x23bc
movl %r15d, 0x10(%rbx)
movq %rbx, (%r14)
leaq 0x8(%r14), %rax
movq %rbx, (%rax)
incl 0x10(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2610
movq %rax, %r14
movl $0x18, %esi
movq %rbx, %rdi
callq 0x2150
movq %r14, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/Rekran[P]HahTable-Chaining-/LinkedList.cpp
// Function: LinkedList::append(int)
void LinkedList::append(int value){
	
	if(this->header.head == NULL){
		
		Node *N1 = new Node();
		N1->Value = value;
		
		this->header.head = N1;
		this->header.tail = N1;
		
		this->header.size += 1;	
			
	}else{
		
		Node *N1 = new Node();
		N1->Value = value;
		
		this->header.tail->Next = N1;
		this->header.tail = N1;		
		this->header.size += 1;	
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r15d
movq %rdi, %r14
movq (%rdi), %r12
movl $0x18, %edi
callq 0x2140
movq %rax, %rbx
testq %r12, %r12
je 0x2663
movq %rbx, %rdi
callq 0x23bc
movl %r15d, 0x10(%rbx)
movq 0x8(%r14), %rax
movq %rbx, (%rax)
jmp 0x2672
movq %rbx, %rdi
callq 0x23bc
movl %r15d, 0x10(%rbx)
movq %rbx, (%r14)
movq %rbx, 0x8(%r14)
incl 0x10(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2685
movq %rax, %r14
movl $0x18, %esi
movq %rbx, %rdi
callq 0x2150
movq %r14, %rdi
callq 0x21e0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/Rekran[P]HahTable-Chaining-/HashTable.cpp
// Function: HashTable::search(char*)
bool HashTable::search(char *word){
	
	LinkedList &L = this->table[this->hash(word)];
	
	Node *aux = L.getHead();
	
while(aux != NULL){
	
	if(strcmp(aux->word,word) == 0){
		return true;
	}
	aux = aux->Next;
	
}
	
	
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x20b0
testl %eax, %eax
jle 0x275b
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl $0x1505, %ecx           # imm = 0x1505
xorl %edx, %edx
movsbl (%rbx,%rdx), %esi
movl %ecx, %edi
shll $0x5, %edi
addl %edi, %ecx
addl %esi, %ecx
incq %rdx
cmpq %rdx, %rax
jne 0x272d
movl %ecx, %eax
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
imulq %rax, %rdx
shrq $0x24, %rdx
shll $0x2, %edx
leal (%rdx,%rdx,4), %eax
subl %eax, %ecx
jmp 0x2760
movl $0x1, %ecx
leaq (%rcx,%rcx,2), %rax
leaq (%r14,%rax,8), %rdi
callq 0x240e
testq %rax, %rax
je 0x2792
movq %rax, %r14
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x2180
testl %eax, %eax
sete %al
je 0x2794
movq (%r14), %r14
testq %r14, %r14
jne 0x2775
jmp 0x2794
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Rekran[P]HahTable-Chaining-/HashTable.cpp
// Function: HashTable::hash(char*)
unsigned int HashTable::hash(char *word){
	int size = strlen(word);
	int i;
	unsigned int value = 5381;
	
	for(i = 0;i< size;i++ ){
	
	value += (value << 5)  + word[i];
	
	}
	return value%MAX;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x20b0
movq %rax, %rcx
testl %ecx, %ecx
jle 0x27ed
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl $0x1505, %eax           # imm = 0x1505
xorl %edx, %edx
movsbl (%rbx,%rdx), %esi
movl %eax, %edi
shll $0x5, %edi
addl %edi, %eax
addl %esi, %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x27bf
movl %eax, %ecx
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
imulq %rcx, %rdx
shrq $0x24, %rdx
shll $0x2, %edx
leal (%rdx,%rdx,4), %ecx
subl %ecx, %eax
jmp 0x27f2
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop