LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x14d07(%rip)           # 0x2fb40
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x149d2(%rip), %r15     # 0x2f818
movq (%r15), %rcx
leaq 0x3871(%rip), %rdi      # 0x1e6c1
pushq $0x19
popq %rsi
pushq $0x1
popq %r12
movq %r12, %rdx
callq 0x64c0
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
incl 0x14cce(%rip)           # 0x2fb40
movq (%r15), %rcx
leaq 0x37d1(%rip), %rdi      # 0x1e64d
pushq $0x7
popq %rsi
movq %r12, %rdx
callq 0x64c0
callq 0xc83c
movl %eax, %r12d
callq 0xc83c
movl %eax, %ebp
incl 0x14ca4(%rip)           # 0x2fb40
movq (%r15), %rdi
leaq 0x37af(%rip), %r13      # 0x1e655
movq %r13, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x6390
incl 0x14c87(%rip)           # 0x2fb40
movq (%r15), %rcx
leaq 0x3818(%rip), %rdi      # 0x1e6db
pushq $0xe
popq %rsi
pushq $0x1
popq %rdx
callq 0x64c0
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
incl 0x14c5f(%rip)           # 0x2fb40
movq (%r15), %rdi
movq %r13, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x6390
incl 0x14c4a(%rip)           # 0x2fb40
movq (%r15), %rdi
leaq 0x37b6(%rip), %r13      # 0x1e6b6
movq %r13, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x6390
incl 0x14c2d(%rip)           # 0x2fb40
movq (%r15), %rcx
leaq 0x37cd(%rip), %rdi      # 0x1e6ea
pushq $0xf
popq %rsi
pushq $0x1
popq %rdx
callq 0x64c0
movq 0x18(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
incl 0x14c05(%rip)           # 0x2fb40
movq (%r15), %rdi
movq %r13, %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_O2/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 0x1498c(%rip)           # 0x2fb40
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x14657(%rip), %r12     # 0x2f818
movq (%r12), %rcx
leaq 0x352e(%rip), %rdi      # 0x1e6fa
pushq $0xf
popq %rsi
pushq $0x1
popq %r15
movq %r15, %rdx
callq 0x64c0
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
incl 0x14952(%rip)           # 0x2fb40
movq (%r12), %rcx
leaq 0x3454(%rip), %rdi      # 0x1e64d
pushq $0x7
popq %rsi
movq %r15, %rdx
callq 0x64c0
callq 0xc83c
movl %eax, %ebp
cmpq $0x0, 0x18(%r14)
movl %eax, %r15d
je 0x1b21d
callq 0xc83c
movl %eax, %r15d
incl 0x1491d(%rip)           # 0x2fb40
movq (%r12), %rdi
leaq 0x3427(%rip), %rsi      # 0x1e655
movl %r15d, %edx
xorl %eax, %eax
callq 0x6390
incl 0x14902(%rip)           # 0x2fb40
movq (%r12), %rcx
leaq 0x3492(%rip), %rdi      # 0x1e6db
pushq $0xe
popq %rsi
pushq $0x1
popq %rdx
callq 0x64c0
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
cmpq $0x0, 0x18(%r14)
je 0x1b2c6
incl 0x148d2(%rip)           # 0x2fb40
movq (%r12), %rdi
leaq 0x33dc(%rip), %rsi      # 0x1e655
movl %ebp, %edx
xorl %eax, %eax
callq 0x6390
incl 0x148b8(%rip)           # 0x2fb40
movq (%r12), %rdi
leaq 0x3423(%rip), %rsi      # 0x1e6b6
movl %r15d, %edx
xorl %eax, %eax
callq 0x6390
incl 0x1489d(%rip)           # 0x2fb40
movq (%r12), %rcx
leaq 0x345c(%rip), %rdi      # 0x1e70a
pushq $0xe
popq %rsi
pushq $0x1
popq %rdx
callq 0x64c0
movq 0x18(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
incl 0x14874(%rip)           # 0x2fb40
movq (%r12), %rdi
leaq 0x33df(%rip), %rsi      # 0x1e6b6
movl %ebp, %edx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6390
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1b339
movq %rsi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x8, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1bf9d
incl 0x1482a(%rip)           # 0x2fb40
leaq 0x144fb(%rip), %rax     # 0x2f818
movq (%rax), %rcx
leaq 0x3290(%rip), %rdi      # 0x1e5b7
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x64c0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r12
callq 0xc83c
movl %eax, %ebp
callq 0xc83c
leaq 0xc(%rsp), %rbx
movl %eax, (%rbx)
callq 0xc83c
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x14137(%rip), %rdi     # 0x2f6c8
callq 0x1bfea
leaq 0x1417b(%rip), %rdi     # 0x2f718
movq %rbx, %rsi
callq 0x1bfea
leaq 0x10(%rsp), %rsi
movq %r12, (%rsi)
leaq 0x140e4(%rip), %rdi     # 0x2f698
callq 0xed1e
movq (%rax), %r14
incl 0x1457e(%rip)           # 0x2fb40
leaq 0x1424f(%rip), %r13     # 0x2f818
movq (%r13), %rcx
leaq 0x3192(%rip), %rdi      # 0x1e766
pushq $0xf
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x64c0
incl 0x14558(%rip)           # 0x2fb40
movq (%r13), %rdi
leaq 0x30c3(%rip), %r15      # 0x1e6b6
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x6390
incl 0x1453b(%rip)           # 0x2fb40
movq (%r13), %rcx
leaq 0x3136(%rip), %rdi      # 0x1e746
pushq $0xc
popq %rsi
movq %rbx, %rdx
callq 0x64c0
movq 0x8(%r12), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
incl 0x14511(%rip)           # 0x2fb40
movq (%r13), %rdi
leaq 0x8(%rsp), %rax
movl (%rax), %edx
movq %r15, %rsi
xorl %eax, %eax
callq 0x6390
incl 0x144f6(%rip)           # 0x2fb40
movq (%r13), %rcx
leaq 0x30dd(%rip), %rdi      # 0x1e732
pushq $0x13
popq %rsi
movq %rbx, %rdx
callq 0x64c0
movq 0x10(%r12), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
incl 0x144cc(%rip)           # 0x2fb40
movq (%r13), %rcx
leaq 0x2fe4(%rip), %rdi      # 0x1e663
pushq $0x8
popq %rsi
movq %rbx, %rdx
callq 0x64c0
incl 0x144b0(%rip)           # 0x2fb40
movq (%r13), %rdi
leaq 0x2fba(%rip), %rsi      # 0x1e655
movl %ebp, %edx
xorl %eax, %eax
callq 0x6390
incl 0x14496(%rip)           # 0x2fb40
movq (%r13), %rdi
leaq 0xc(%rsp), %rax
movl (%rax), %edx
movq %r15, %rsi
xorl %eax, %eax
callq 0x6390
leaq 0x14002(%rip), %rdi     # 0x2f6c8
callq 0x1c21e
leaq 0x14046(%rip), %rdi     # 0x2f718
callq 0x1c21e
addq $0x18, %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_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, %r13
callq 0xc83c
leaq 0xc(%rsp), %r12
movl %eax, (%r12)
callq 0xc83c
leaq 0x8(%rsp), %rbx
movl %eax, (%rbx)
leaq 0x13fb0(%rip), %rdi     # 0x2f6c8
movq %r12, %rsi
callq 0x1bfea
leaq 0x13ff1(%rip), %rdi     # 0x2f718
movq %rbx, %rsi
callq 0x1bfea
leaq 0x10(%rsp), %rsi
movq %r13, (%rsi)
leaq 0x13f5a(%rip), %rdi     # 0x2f698
callq 0xed1e
movq (%rax), %rbp
incl 0x143f4(%rip)           # 0x2fb40
leaq 0x140c5(%rip), %r15     # 0x2f818
movq (%r15), %rcx
leaq 0x3019(%rip), %rdi      # 0x1e776
pushq $0x12
popq %rsi
pushq $0x1
popq %r14
movq %r14, %rdx
callq 0x64c0
incl 0x143ce(%rip)           # 0x2fb40
movq (%r15), %rdi
movl (%r12), %edx
leaq 0x2f36(%rip), %rsi      # 0x1e6b6
xorl %eax, %eax
callq 0x6390
incl 0x143b3(%rip)           # 0x2fb40
movq (%r15), %rcx
leaq 0x2f9b(%rip), %rdi      # 0x1e732
pushq $0x13
popq %rsi
movq %r14, %rdx
callq 0x64c0
movq 0x8(%r13), %rdi
movq (%rdi), %rax
movq %rbp, %rsi
callq *0x18(%rax)
incl 0x1438b(%rip)           # 0x2fb40
movq (%r15), %rcx
leaq 0x2e8e(%rip), %rdi      # 0x1e64d
pushq $0x7
popq %rsi
movq %r14, %rdx
callq 0x64c0
incl 0x14370(%rip)           # 0x2fb40
movq (%r15), %rdi
movl (%rbx), %edx
leaq 0x2e79(%rip), %rbx      # 0x1e655
movq %rbx, %rsi
xorl %eax, %eax
callq 0x6390
incl 0x14354(%rip)           # 0x2fb40
movq (%r15), %rcx
leaq 0x2f50(%rip), %rdi      # 0x1e746
pushq $0xc
popq %rsi
movq %r14, %rdx
callq 0x64c0
movq 0x10(%r13), %rdi
movq (%rdi), %rax
movq %rbp, %rsi
callq *0x18(%rax)
incl 0x1432c(%rip)           # 0x2fb40
movq (%r15), %rdi
movl (%r12), %edx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x6390
incl 0x14315(%rip)           # 0x2fb40
movq (%r15), %rdi
leaq 0x8(%rsp), %rax
movl (%rax), %edx
leaq 0x2e7a(%rip), %rsi      # 0x1e6b6
xorl %eax, %eax
callq 0x6390
leaq 0x13e7e(%rip), %rdi     # 0x2f6c8
callq 0x1c21e
leaq 0x13ec2(%rip), %rdi     # 0x2f718
callq 0x1c21e
addq $0x18, %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_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, %r14
movq %rdi, %r15
callq 0xc83c
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x13cc0(%rip), %rdi     # 0x2f718
callq 0x1bfea
leaq 0xc(%rsp), %rsi
orl $-0x1, (%rsi)
leaq 0x13cfc(%rip), %rbx     # 0x2f768
movq %rbx, %rdi
callq 0x1c274
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
movq 0x30(%rbx), %rax
cmpq 0x38(%rbx), %rax
jne 0x1ba98
movq 0x48(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movl -0x4(%rax), %edx
cmpl $-0x1, %edx
je 0x1babe
incl 0x1409a(%rip)           # 0x2fb40
leaq 0x13d6b(%rip), %rax     # 0x2f818
movq (%rax), %rdi
leaq 0x2b9e(%rip), %rsi      # 0x1e655
xorl %eax, %eax
callq 0x6390
incl 0x1407c(%rip)           # 0x2fb40
leaq 0x13d4d(%rip), %rax     # 0x2f818
movq (%rax), %rdi
movl 0x8(%rsp), %edx
leaq 0x2bdd(%rip), %rsi      # 0x1e6b6
xorl %eax, %eax
callq 0x6390
leaq 0x13c31(%rip), %rdi     # 0x2f718
callq 0x1c21e
leaq 0x13c75(%rip), %rdi     # 0x2f768
callq 0x1c21e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rsi
movq %rdi, (%rsi)
leaq 0x13b7e(%rip), %rdi     # 0x2f698
callq 0xed1e
movq (%rax), %r14
incl 0x14018(%rip)           # 0x2fb40
leaq 0x13ce9(%rip), %r12     # 0x2f818
movq (%r12), %rcx
leaq 0x2c61(%rip), %rdi      # 0x1e79b
pushq $0x13
popq %rsi
pushq $0x1
popq %r15
movq %r15, %rdx
callq 0x64c0
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 0x13fd7(%rip)           # 0x2fb40
movq (%r12), %rcx
leaq 0x2a43(%rip), %rdi      # 0x1e5b7
pushq $0x4
popq %rsi
movq %r15, %rdx
callq 0x64c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x137c1(%rip), %rdi     # 0x2f698
callq 0xed1e
movq (%rax), %rbx
movl 0x3c(%rbx), %edx
testl %edx, %edx
je 0x1bf2d
incl 0x13c54(%rip)           # 0x2fb40
leaq 0x13925(%rip), %r15     # 0x2f818
movq (%r15), %rdi
leaq 0x28c9(%rip), %rsi      # 0x1e7c6
xorl %eax, %eax
callq 0x6390
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
incl 0x13c29(%rip)           # 0x2fb40
movq (%r15), %rdi
movl 0x3c(%rbx), %edx
leaq 0x28db(%rip), %rsi      # 0x1e7ff
xorl %eax, %eax
callq 0x6390
jmp 0x1bf3a
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
incl 0x13c00(%rip)           # 0x2fb40
leaq 0x138d1(%rip), %rbx     # 0x2f818
movq (%rbx), %rcx
leaq 0x28b8(%rip), %rdi      # 0x1e809
pushq $0x6
popq %rsi
pushq $0x1
popq %rdx
callq 0x64c0
movq 0x13be5(%rip), %r14     # 0x2fb48
movq 0x13be6(%rip), %r15     # 0x2fb50
cmpq %r15, %r14
je 0x1bf80
movq (%r14), %rsi
movq (%rbx), %rdi
callq 0x1be7d
addq $0x8, %r14
jmp 0x1bf6a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/rppl.cpp
// Function: RPPL()
void RPPL()
{
	const std::string PROMPT = ">> ";

	Lexer lexer;
	Parser parser;
	
	std::string line;

	while (true)
	{
		std::cout << PROMPT;

		std::getline(std::cin, line);

		lexer.New(line);
		parser.New(lexer);

		Program *program = parser.ParseProgram();

		if (parser.Errors().size())
			for (std::string error : parser.Errors())
				std::cout << error << std::endl;
		else
			std::cout << program->getStringRepr() << std::endl;

		parser.resetErrors();
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
leaq 0x9820(%rip), %rsi      # 0x100a4
leaq 0x88(%rsp), %rdi
leaq 0xa8(%rsp), %rdx
callq 0x6a64
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0xa8(%rsp), %rdi
callq 0xaab0
leaq 0x78(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x126f9(%rip), %rbx     # 0x18fc8
leaq 0x68(%rsp), %r13
leaq 0x38(%rsp), %rbp
leaq 0x18(%rsp), %r14
movq %rbx, %rdi
leaq 0x88(%rsp), %rsi
callq 0x4190
movq 0x126eb(%rip), %rdi     # 0x18fe0
movq %r13, %rsi
callq 0x4060
movq %rbp, %rdi
movq %r13, %rsi
callq 0x7826
leaq 0xa8(%rsp), %rdi
movq %rbp, %rsi
callq 0xae4c
leaq 0xa8(%rsp), %r12
movq %r12, %rdi
callq 0xc66e
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0xcdce
movq %r13, %rbp
movq 0x20(%rsp), %r12
movq 0x18(%rsp), %r13
movq %r14, %rdi
callq 0x6aa0
cmpq %r13, %r12
je 0x69ac
movq %rsp, %rdi
leaq 0xa8(%rsp), %rsi
callq 0xcdce
movq (%rsp), %r15
movq 0x8(%rsp), %r12
movq %rbp, %r13
leaq 0x38(%rsp), %rbp
cmpq %r12, %r15
je 0x69a2
movq %r14, %rdi
movq %r15, %rsi
callq 0x4230
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4190
movq %rax, %rdi
callq 0x40e0
movq %r14, %rdi
callq 0x4338
addq $0x20, %r15
jmp 0x6971
movq %rsp, %rdi
callq 0x6aa0
jmp 0x69db
movq (%r15), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x8(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4190
movq %rax, %rdi
callq 0x40e0
movq %r14, %rdi
callq 0x4338
movq %rbp, %r13
leaq 0x38(%rsp), %rbp
leaq 0xa8(%rsp), %rdi
callq 0xcde4
jmp 0x68de
jmp 0x6a04
jmp 0x6a04
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4338
jmp 0x6a23
jmp 0x6a04
jmp 0x6a04
movq %rax, %rbx
jmp 0x6a23
movq %rax, %rbx
jmp 0x6a1b
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4338
movq %rsp, %rdi
callq 0x6aa0
leaq 0x68(%rsp), %rdi
callq 0x4338
leaq 0xa8(%rsp), %rdi
callq 0x6ac2
jmp 0x6a3f
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x4338
leaq 0x88(%rsp), %rdi
callq 0x4338
movq %rbx, %rdi
callq 0x42f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3688
leaq 0x4ae1(%rip), %rsi      # 0x8004
leaq -0xa80(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x30c0
leaq -0x270(%rbp), %rdi
leaq -0xa80(%rbp), %rsi
movl $0x4d2, %edx            # imm = 0x4D2
callq 0x3c98
movl %eax, %ebx
leaq -0xa80(%rbp), %rdi
callq 0x30e0
testb %bl, %bl
jne 0x3599
movq 0xaa6c(%rip), %rdi      # 0xdfd0
leaq 0x4aa3(%rip), %rsi      # 0x800e
callq 0x31d0
movq %rax, %rdi
callq 0x3110
leaq -0x270(%rbp), %rdi
callq 0x3b68
pushq $-0x1
popq %rax
addq $0xa58, %rsp            # imm = 0xA58
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xaa30(%rip), %rdi      # 0xdfd0
leaq 0x4a77(%rip), %rsi      # 0x801e
callq 0x31d0
movq %rax, %rdi
callq 0x3110
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0xaa05(%rip), %rbx      # 0xdfd0
leaq -0x48(%rbp), %r12
leaq -0x270(%rbp), %r13
leaq -0xa80(%rbp), %r14
leaq 0x4a58(%rip), %r15      # 0x803c
movq %rbx, %rdi
leaq 0x4a45(%rip), %rsi      # 0x8033
callq 0x31d0
movq 0xa9e6(%rip), %rdi      # 0xdfe0
movq %r12, %rsi
callq 0x3200
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r13, %rdi
callq 0x4190
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 0x4322
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x31d0
movq %rax, %rdi
callq 0x3110
jmp 0x35e4
jmp 0x3653
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
jmp 0x3666
movq %rax, %rbx
leaq -0xa80(%rbp), %rdi
callq 0x30e0
jmp 0x3672
jmp 0x366f
movq %rax, %rbx
leaq -0x270(%rbp), %rdi
callq 0x3b68
movq %rbx, %rdi
callq 0x32e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %rbx
movb $0x0, (%rax)
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
xorl %r12d, %r12d
movq %rax, %rdx
movq %rcx, %rsi
subq %rdx, %rsi
sarq $0x5, %rsi
decq %rsi
cmpq %r12, %rsi
jbe 0x3097
movq %r12, %r13
notq %r13
xorl %r14d, %r14d
movq %r14, %rsi
shlq $0x5, %rsi
movq %rdx, %rdi
movq %rcx, %rdx
subq %rdi, %rdx
sarq $0x5, %rdx
addq %r13, %rdx
cmpq %r14, %rdx
jbe 0x308c
leaq 0x20(%rsi), %r15
incq %r14
movq 0x8(%rdi,%rsi), %r8
movq %rax, %rdx
cmpq 0x28(%rdi,%rsi), %r8
movq %r15, %rsi
jae 0x301f
leaq (%rdi,%r15), %rsi
addq $-0x20, %rsi
leaq -0x48(%rbp), %rdi
callq 0x2100
movq (%rbx), %rsi
leaq (%rsi,%r15), %rdi
addq $-0x20, %rdi
addq %r15, %rsi
callq 0x2100
addq (%rbx), %r15
movq %r15, %rdi
leaq -0x48(%rbp), %rsi
callq 0x2100
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rax, %rdx
jmp 0x3018
incq %r12
movq %rdi, %rdx
jmp 0x2ff9
leaq -0x48(%rbp), %rdi
callq 0x20c0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x198(%rdi), %rax
xorl %ecx, %ecx
leaq (%rax,%rcx), %rdx
movq %rdx, -0x10(%rax,%rcx)
andq $0x0, -0x8(%rax,%rcx)
movb $0x0, (%rax,%rcx)
addq $0x20, %rcx
cmpq $0x280, %rcx            # imm = 0x280
jne 0x343f
xorl %eax, %eax
movq %rbx, %rcx
cmpq $0xf, %rax
je 0x3484
xorl %edx, %edx
cmpq $0xf, %rdx
je 0x347b
movb $0x5f, (%rcx,%rdx)
incq %rdx
jmp 0x346c
incq %rax
addq $0xf, %rcx
jmp 0x3464
leaq 0x188(%rbx), %r15
xorl %eax, %eax
cmpq $0x14, %rax
je 0x34a1
andq $0x0, 0xe4(%rbx,%rax,8)
incq %rax
jmp 0x348d
movl $0x1, 0x408(%rbx)
xorl %r12d, %r12d
leaq 0xf2e(%rip), %r14       # 0x43e3
cmpq $0x280, %r12            # imm = 0x280
je 0x34d0
leaq (%r15,%r12), %rdi
movq %r14, %rsi
callq 0x2260
addq $0x20, %r12
jmp 0x34b5
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x3e8, %r15d           # imm = 0x3E8
leaq (%rbx,%r15), %rdi
callq 0x20c0
addq $-0x20, %r15
cmpq $0x168, %r15            # imm = 0x168
jne 0x34e2
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
movq 0x2a89(%rip), %r14      # 0x5fd0
leaq 0xe95(%rip), %r15       # 0x43e3
cmpq $0xf, %r12
je 0x358b
xorl %r13d, %r13d
cmpq $0xf, %r13
je 0x357a
movsbl (%rbx,%r13), %esi
movq %r14, %rdi
callq 0x2190
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
incq %r13
jmp 0x3557
movq %r14, %rdi
callq 0x20e0
incq %r12
addq $0xf, %rbx
jmp 0x354e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
movq 0x2a1c(%rip), %r14      # 0x5fd0
pushq $0x23
popq %r13
leaq 0xe24(%rip), %r15       # 0x43e3
cmpq $0xf, %rax
je 0x360c
movq %rax, -0x30(%rbp)
xorl %r12d, %r12d
cmpq $0xf, %r12
je 0x35f7
cmpb $0x5f, (%rbx,%r12)
movl %r13d, %esi
je 0x35df
pushq $0x5f
popq %rsi
movq %r14, %rdi
callq 0x2190
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
incq %r12
jmp 0x35cc
movq %r14, %rdi
callq 0x20e0
movq -0x30(%rbp), %rax
incq %rax
addq $0xf, %rbx
jmp 0x35bf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x8(%rsi), %rax
xorl %ecx, %ecx
cmpq $0xf, %rcx
je 0x3c1d
imulq $0xf, %rcx, %rdx
xorl %r8d, %r8d
cmpq $0xf, %r8
je 0x3c18
leaq (%rdi,%r8), %r9
addq %rdx, %r9
xorl %r10d, %r10d
cmpq %r10, %rax
je 0x3c13
movq (%rsi), %r11
movb (%r11,%r10), %r11b
incq %r10
cmpb (%r9), %r11b
jne 0x3bfd
jmp 0x3c1d
incq %r8
jmp 0x3bed
incq %rcx
jmp 0x3be0
xorl %eax, %eax
cmpq $0xf, %rcx
setb %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x127932(%rip), %rax    # 0x1294f2
cmpb $0x1, (%rax)
jne 0x1c00
pushq %rbx
leaq 0x1277d3(%rip), %rax    # 0x1293a0
movq 0x20(%rax), %rcx
movb $0x2, (%rcx)
movq 0x10(%rax), %rcx
movb $0x4f, (%rcx)
movq 0x30(%rax), %rax
movb $0x18, (%rax)
pushq $0x10
popq %rbx
movl %ebx, %edi
callq 0x13ce
leaq 0x12779d(%rip), %rax    # 0x129390
movw $0xe0d, (%rax)          # imm = 0xE0D
movl %ebx, %edi
popq %rbx
jmp 0x13ce
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 0x11e0
movb 0x12419a(%rip), %al     # 0x1295b8
testb %al, %al
je 0x5449
movq (%rsp), %rbx
subl 0x124184(%rip), %ebx    # 0x1295b0
imull $0x3e8, %ebx, %ecx      # imm = 0x3E8
movq 0x8(%rsp), %rax
movl $0x3e8, %esi            # imm = 0x3E8
cqto
idivq %rsi
addl %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x124168(%rip), %rdi    # 0x1295b8
callq 0x1200
movq (%rsp), %rbx
testl %eax, %eax
je 0x5426
movq %rbx, 0x12414c(%rip)    # 0x1295b0
leaq 0x12414d(%rip), %rdi    # 0x1295b8
callq 0x1090
jmp 0x5426
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq (%rdi), %r13
xorl %r14d, %r14d
xorl %r15d, %r15d
movl %r15d, %eax
xorl %edx, %edx
pushq $0xa
popq %rcx
divl %ecx
cmpl 0x10(%rbx), %r15d
jge 0x2482
movl %eax, %r12d
movq 0x2bc0(%rip), %rdi      # 0x4fd8
leaq 0xbe5(%rip), %rsi       # 0x3004
callq 0x2120
movq %rax, %rdi
movl %r15d, %esi
callq 0x21c0
movq %rax, %rdi
leaq 0xbcd(%rip), %rsi       # 0x3006
callq 0x2120
movq 0x8(%r13), %rsi
movq %rax, %rdi
callq 0x2120
movq %rax, %rdi
leaq 0xbb9(%rip), %rsi       # 0x300d
callq 0x2120
movq (%r13), %r13
testl %r15d, %r15d
je 0x2477
imull $0xa, %r12d, %eax
addl %r14d, %eax
jne 0x2477
movq 0x2b66(%rip), %rdi      # 0x4fd8
callq 0x20c0
incl %r15d
decl %r14d
jmp 0x23fe
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x2130
movq %rax, %rbx
testq %r12, %r12
je 0x24cd
movq %rbx, %rdi
callq 0x238c
movq %r15, 0x8(%rbx)
movq (%r14), %rax
movq %rax, (%rbx)
movq %r14, %rax
jmp 0x24e0
movq %rbx, %rdi
callq 0x238c
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 0x24f2
movq %rax, %r14
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x2130
movq %rax, %rbx
testq %r12, %r12
je 0x2543
movq %rbx, %rdi
callq 0x238c
movl %r15d, 0x10(%rbx)
movq (%r14), %rax
movq %rax, (%rbx)
movq %r14, %rax
jmp 0x2556
movq %rbx, %rdi
callq 0x238c
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 0x2568
movq %rax, %r14
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x2130
movq %rax, %rbx
testq %r12, %r12
je 0x25b7
movq %rbx, %rdi
callq 0x238c
movl %r15d, 0x10(%rbx)
movq 0x8(%r14), %rax
movq %rbx, (%rax)
jmp 0x25c6
movq %rbx, %rdi
callq 0x238c
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 0x25d9
movq %rax, %r14
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x26a0
movl %eax, %eax
imulq $0x18, %rax, %rax
addq %rax, %r14
movq %r14, %rdi
callq 0x23da
movq %rax, %r14
testq %r14, %r14
je 0x2694
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x2180
testl %eax, %eax
je 0x2694
movq (%r14), %r14
jmp 0x267a
testq %r14, %r14
setne %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x20a0
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
movl $0x1505, %ecx           # imm = 0x1505
cmpq %rdx, %rax
je 0x26d0
movsbl (%rbx,%rdx), %esi
imull $0x21, %ecx, %ecx
addl %esi, %ecx
incq %rdx
jmp 0x26bd
pushq $0x14
popq %rsi
movl %ecx, %eax
xorl %edx, %edx
divl %esi
movl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Rekran[P]HahTable-Chaining-/HashTable.cpp
// Function: HashTable::loadDictionary(char*)
void HashTable::loadDictionary(char *path){
string line;
  
  ifstream myfile(path);
  if (myfile.is_open())
  {
    while ( myfile>>line )
    {
    
    	int n = line.length() + 1;
		char *char_array = new char[n];	
    	strcpy(char_array, line.c_str()); 
    	this->guarda(char_array);
    }
    myfile.close();
  }
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rdi, %rbx
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x248(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x21e0
leaq -0x1d0(%rbp), %rdi
callq 0x2050
testb %al, %al
je 0x277f
leaq -0x248(%rbp), %r14
leaq -0x40(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2150
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2773
movl -0x38(%rbp), %eax
incl %eax
movslq %eax, %rdi
callq 0x2030
movq %rax, %r12
movq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x2110
movq %rbx, %rdi
movq %r12, %rsi
callq 0x27ce
jmp 0x2731
leaq -0x248(%rbp), %rdi
callq 0x2040
leaq -0x248(%rbp), %rdi
callq 0x2060
leaq -0x40(%rbp), %rdi
callq 0x20b0
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27ad
movq %rax, %rbx
jmp 0x27bc
jmp 0x27ad
movq %rax, %rbx
leaq -0x248(%rbp), %rdi
callq 0x2060
leaq -0x40(%rbp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Rekran[P]HahTable-Chaining-/HashTable.cpp
// Function: HashTable::print()
void HashTable::print(){
	
	for(int i = 0; i < MAX ; i++){
		LinkedList &l = this->table[i];
		std::cout << "Index "<< i << std::endl; 
		l.print();
		std::cout << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x2770(%rip), %r15      # 0x4fd8
leaq 0x799(%rip), %r12       # 0x3008
cmpq $0x14, %r14
je 0x28ac
movq %r15, %rdi
movq %r12, %rsi
callq 0x2120
movq %rax, %rdi
movl %r14d, %esi
callq 0x21c0
movq %rax, %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x23e4
movq %r15, %rdi
callq 0x20c0
incq %r14
addq $0x18, %rbx
jmp 0x286f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/Rekran[P]HahTable-Chaining-/main.cpp
// Function: main
int main(int argc, char** argv) {
vector<string>erros;
HashTable ht = HashTable();

ht.loadDictionary("dictionary.txt");

string word;
  ifstream myfile("text.txt");
  if (myfile.is_open())
  {
    while ( myfile>>word )
    {
    	if(!ht.search(&word[0]))
			erros.push_back(word);
    }
    myfile.close();
  }
for(int i = 0; i< erros.size();i++)
	cout<<erros[i]<<endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x430, %rsp            # imm = 0x430
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
andq $0x0, -0x30(%rbp)
leaq -0x448(%rbp), %rdi
callq 0x2600
leaq 0x726(%rip), %rsi       # 0x300f
leaq -0x448(%rbp), %rdi
callq 0x26e2
leaq -0x50(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x712(%rip), %rsi       # 0x301e
leaq -0x268(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x21e0
leaq -0x1f0(%rbp), %rdi
callq 0x2050
testb %al, %al
je 0x2983
leaq -0x268(%rbp), %rbx
leaq -0x60(%rbp), %r14
leaq -0x448(%rbp), %r15
leaq -0x40(%rbp), %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2150
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2977
movq -0x60(%rbp), %rsi
movq %r15, %rdi
callq 0x2654
testb %al, %al
jne 0x2941
movq %r12, %rdi
movq %r14, %rsi
callq 0x2a44
jmp 0x2941
leaq -0x268(%rbp), %rdi
callq 0x2040
xorl %r14d, %r14d
movq 0x264b(%rip), %rbx      # 0x4fd8
xorl %r15d, %r15d
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r15, %rax
jbe 0x29c0
addq %r14, %rsi
movq %rbx, %rdi
callq 0x2100
movq %rax, %rdi
callq 0x20c0
incq %r15
addq $0x20, %r14
jmp 0x2990
leaq -0x268(%rbp), %rdi
callq 0x2060
leaq -0x60(%rbp), %rdi
callq 0x20b0
leaq -0x448(%rbp), %rdi
callq 0x27f8
leaq -0x40(%rbp), %rdi
callq 0x2a80
xorl %eax, %eax
addq $0x430, %rsp            # imm = 0x430
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a0f
movq %rax, %rbx
jmp 0x2a1e
movq %rax, %rbx
jmp 0x2a27
movq %rax, %rbx
jmp 0x2a33
jmp 0x2a0f
movq %rax, %rbx
leaq -0x268(%rbp), %rdi
callq 0x2060
leaq -0x60(%rbp), %rdi
callq 0x20b0
leaq -0x448(%rbp), %rdi
callq 0x27f8
leaq -0x40(%rbp), %rdi
callq 0x2a80
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/linear_sorting/bench.cpp
// Function: fill_random(std::vector<unsigned long, std::allocator<unsigned long>>&, unsigned long)
void fill_random(std::vector<std::size_t>& vec, std::size_t size){
    std::mt19937 generator;
    std::uniform_int_distribution<std::size_t> distribution(0, MAX);

    for(std::size_t i = 0; i < size; ++i){
        vec.push_back(distribution(generator));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x13a0, %rsp           # imm = 0x13A0
leaq 0x18(%rsp), %r15
movq %rdi, %r14
movq %rsi, %rbx
movq %r15, %rdi
callq 0x1752
leaq 0x8(%rsp), %r12
movq %rsp, %r13
andq $0x0, (%r12)
movq $0x2faf080, 0x8(%r12)   # imm = 0x2FAF080
subq $0x1, %rbx
jb 0x12c7
movq %r12, %rdi
movq %r15, %rsi
callq 0x175c
movq %rax, (%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x1b92
jmp 0x12a5
addq $0x13a0, %rsp           # imm = 0x13A0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/linear_sorting/bench.cpp
// Function: in_place_counting_sort(std::vector<unsigned long, std::allocator<unsigned long>>&)
void in_place_counting_sort(std::vector<std::size_t>& A){
    std::vector<std::size_t> C(MAX + 1);

    for (std::size_t i = 0; i < SIZE; ++i){
        ++C[A[i]];
    }

    int current = 0;
    for (std::size_t i = 0; i < MAX; ++i){
        for(std::size_t j =0; j < C[i]; ++j){
            A[current++] = i;
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movl $0x2faf081, %esi        # imm = 0x2FAF081
movq %rdi, %rbx
movq %r14, %rdi
callq 0x1764
movq (%rbx), %rcx
movq (%r14), %rax
xorl %edx, %edx
cmpq $0x4c4b40, %rdx         # imm = 0x4C4B40
je 0x13af
movq (%rcx,%rdx,8), %rsi
incq %rdx
incq (%rax,%rsi,8)
jmp 0x1399
xorl %ecx, %ecx
xorl %edx, %edx
cmpq $0x2faf080, %rdx        # imm = 0x2FAF080
je 0x13e3
movslq %ecx, %rcx
xorl %esi, %esi
leaq (,%rcx,8), %rdi
addq (%rbx), %rdi
cmpq (%rax,%rdx,8), %rsi
jae 0x13db
movq %rdx, (%rdi,%rsi,8)
incq %rsi
jmp 0x13cc
incq %rdx
addq %rsi, %rcx
jmp 0x13b3
leaq 0x10(%rsp), %rdi
callq 0x2140
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/linear_sorting/bench.cpp
// Function: counting_sort(std::vector<unsigned long, std::allocator<unsigned long>>&)
void counting_sort(std::vector<std::size_t>& A){
    std::vector<std::size_t> B(SIZE);
    std::vector<std::size_t> C(MAX);

    for (std::size_t i = 0; i < SIZE; ++i){
        ++C[A[i]];
    }

    for (std::size_t i = 1; i <= MAX; ++i){
        C[i] += C[i - 1];
    }

    for (long i = SIZE - 1; i >= 0; --i) {
        B[C[A[i]] - 1] = A[i];
        --C[A[i]];
    }

    for (std::size_t i = 0; i < SIZE; ++i){
        A[i] = B[i];
    }
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movl $0x4c4b40, %esi         # imm = 0x4C4B40
callq 0x1764
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movl $0x2faf080, %esi        # imm = 0x2FAF080
callq 0x1764
movq (%rbx), %rax
movq 0x10(%rsp), %rcx
xorl %edx, %edx
cmpq $0x4c4b40, %rdx         # imm = 0x4C4B40
je 0x1445
movq (%rax,%rdx,8), %rsi
incq %rdx
incq (%rcx,%rsi,8)
jmp 0x142f
pushq $0x1
popq %rdx
cmpq $0x2faf081, %rdx        # imm = 0x2FAF081
je 0x145f
movq -0x8(%rcx,%rdx,8), %rsi
addq %rsi, (%rcx,%rdx,8)
incq %rdx
jmp 0x1448
movq 0x28(%rsp), %rdx
movl $0x4c4b3f, %esi         # imm = 0x4C4B3F
testq %rsi, %rsi
js 0x1484
movq (%rax,%rsi,8), %rdi
decq %rsi
movq (%rcx,%rdi,8), %r8
movq %rdi, -0x8(%rdx,%r8,8)
decq (%rcx,%rdi,8)
jmp 0x1469
xorl %ecx, %ecx
cmpq $0x4c4b40, %rcx         # imm = 0x4C4B40
je 0x149c
movq (%rdx,%rcx,8), %rsi
movq %rsi, (%rax,%rcx,8)
incq %rcx
jmp 0x1486
leaq 0x10(%rsp), %rdi
callq 0x2140
leaq 0x28(%rsp), %rdi
callq 0x2140
addq $0x40, %rsp
popq %rbx
retq
leaq 0x28(%rsp), %rdi
movq %rax, %rbx
callq 0x2140
movq %rbx, %rdi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/linear_sorting/bench.cpp
// Function: binsort(std::vector<unsigned long, std::allocator<unsigned long>>&)
void binsort(std::vector<std::size_t>& A){
    std::vector<std::vector<std::size_t>> B(MAX + 1);

    for(std::size_t i = 0; i < SIZE; ++i){
        B[A[i]].push_back(A[i]);
    }

    std::size_t current = 0;
    for(std::size_t i = 0; i < MAX; ++i){
        for(auto item : B[i]){
            A[current++] = item;
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movl $0x2faf081, %esi        # imm = 0x2FAF081
callq 0x17b8
xorl %r14d, %r14d
cmpq $0x2625a00, %r14        # imm = 0x2625A00
je 0x1510
movq (%rbx), %rsi
imulq $0x18, (%rsi,%r14), %rdi
addq %r14, %rsi
addq 0x10(%rsp), %rdi
callq 0x180c
addq $0x8, %r14
jmp 0x14ec
movq 0x10(%rsp), %rax
xorl %ecx, %ecx
xorl %edx, %edx
cmpq $0x2faf080, %rdx        # imm = 0x2FAF080
je 0x154c
imulq $0x18, %rdx, %rdi
movq (%rbx), %r8
movq (%rax,%rdi), %rsi
movq 0x8(%rax,%rdi), %rdi
cmpq %rdi, %rsi
je 0x1547
movq (%rsi), %r9
addq $0x8, %rsi
movq %r9, (%r8,%rcx,8)
incq %rcx
jmp 0x1532
incq %rdx
jmp 0x1519
leaq 0x10(%rsp), %rdi
callq 0x182c
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0x182c
movq %rbx, %rdi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/linear_sorting/bench.cpp
// Function: radix_sort(std::vector<unsigned long, std::allocator<unsigned long>>&)
void radix_sort(std::vector<std::size_t>& A){
    std::vector<std::size_t> B(SIZE);
    std::vector<std::size_t> cnt(radix);

    for(std::size_t i = 0, shift = 0; i < digits; i++, shift += r){
        for(std::size_t j = 0; j < radix; ++j){
            cnt[j] = 0;
        }

        for(std::size_t j = 0; j < SIZE; ++j){
            ++cnt[(A[j] >> shift) & mask];
        }

        for(std::size_t j = 1; j < radix; ++j){
            cnt[j] += cnt[j - 1];
        }

        for(long j = SIZE - 1; j >= 0; --j){
            B[--cnt[(A[j] >> shift) & mask]] = A[j];
        }

        for(std::size_t j = 0; j < SIZE; ++j){
           A[j] = B[j];
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x4c4b40, %esi         # imm = 0x4C4B40
callq 0x1764
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movl $0x10000, %esi          # imm = 0x10000
callq 0x1764
movq 0x8(%rsp), %rax
movq (%rbx), %rcx
movq 0x20(%rsp), %rdx
xorl %esi, %esi
pushq $0x1
popq %rdi
xorl %r8d, %r8d
cmpq $0x2, %rsi
je 0x1666
xorl %r9d, %r9d
cmpq $0x10000, %r9           # imm = 0x10000
je 0x15da
andq $0x0, (%rax,%r9,8)
incq %r9
jmp 0x15c7
xorl %r9d, %r9d
cmpq $0x4c4b40, %r9          # imm = 0x4C4B40
je 0x15f9
shrxq %r8, (%rcx,%r9,8), %r10
incq %r9
movzwl %r10w, %r10d
incq (%rax,%r10,8)
jmp 0x15dd
movq %rdi, %r9
cmpq $0x10000, %r9           # imm = 0x10000
je 0x1613
movq -0x8(%rax,%r9,8), %r10
addq %r10, (%rax,%r9,8)
incq %r9
jmp 0x15fc
movl $0x4c4b3f, %r9d         # imm = 0x4C4B3F
testq %r9, %r9
js 0x1641
movq (%rcx,%r9,8), %r10
decq %r9
shrxq %r8, %r10, %r11
movzwl %r11w, %r11d
movq (%rax,%r11,8), %rbx
leaq -0x1(%rbx), %r14
movq %r14, (%rax,%r11,8)
movq %r10, -0x8(%rdx,%rbx,8)
jmp 0x1619
xorl %r9d, %r9d
cmpq $0x4c4b40, %r9          # imm = 0x4C4B40
je 0x165a
movq (%rdx,%r9,8), %r10
movq %r10, (%rcx,%r9,8)
incq %r9
jmp 0x1644
incq %rsi
addq $0x10, %r8
jmp 0x15ba
leaq 0x8(%rsp), %rdi
callq 0x2140
leaq 0x20(%rsp), %rdi
callq 0x2140
addq $0x38, %rsp
popq %rbx
popq %r14
retq
leaq 0x20(%rsp), %rdi
movq %rax, %rbx
callq 0x2140
movq %rbx, %rdi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/linear_sorting/bench.cpp
// Function: main
int main(){
    std::cout << "std::sort" << std::endl;
    bench(&std_sort);

    std::cout << "counting_sort" << std::endl;
    bench(&counting_sort);

    std::cout << "in_place_counting_sort" << std::endl;
    bench(&in_place_counting_sort);

    std::cout << "binsort" << std::endl;
    bench(&::binsort);

    std::cout << "radix_sort" << std::endl;
    bench(&radix_sort);

    return 0;
}

// Assembly:
pushq %rbx
movq 0x3939(%rip), %rbx      # 0x4fd8
leaq 0x1967(%rip), %rsi      # 0x300d
movq %rbx, %rdi
callq 0x10f0
movq %rax, %rdi
callq 0x1070
leaq -0x35c(%rip), %rdi      # 0x1361
callq 0x184d
leaq 0x1957(%rip), %rsi      # 0x3020
movq %rbx, %rdi
callq 0x10f0
movq %rax, %rdi
callq 0x1070
leaq -0x2eb(%rip), %rdi      # 0x13f5
callq 0x184d
leaq 0x192b(%rip), %rsi      # 0x3017
movq %rbx, %rdi
callq 0x10f0
movq %rax, %rdi
callq 0x1070
leaq -0x393(%rip), %rdi      # 0x1370
callq 0x184d
leaq 0x191f(%rip), %rsi      # 0x302e
movq %rbx, %rdi
callq 0x10f0
movq %rax, %rdi
callq 0x1070
leaq -0x25b(%rip), %rdi      # 0x14cb
callq 0x184d
leaq 0x1904(%rip), %rsi      # 0x3036
movq %rbx, %rdi
callq 0x10f0
movq %rax, %rdi
callq 0x1070
leaq -0x1d6(%rip), %rdi      # 0x1573
callq 0x184d
xorl %eax, %eax
popq %rbx
retq