LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/KJTang[P]SimpleCompiler/VirtualMachine.cpp
// Function: VirtualMachine::printData()
void VirtualMachine::printData() {
    for (int i = 0; i != eipStack.size()+1; ++i) {
        std::cout<<"data stack "<<i<<": ";
        for (int j = 0; j != 10; ++j) {
            std::cout<<data[i][j]<<" ";
        }
        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
xorl %r14d, %r14d
movq 0x6cef(%rip), %r15      # 0x13fd0
leaq 0x1f73(%rip), %r12      # 0xf25b
movq 0xe8(%rbx), %rax
movq %rax, %rcx
subq 0xc8(%rbx), %rcx
shrq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
shlq $0x7, %rcx
movq 0xd0(%rbx), %rax
subq 0xd8(%rbx), %rax
movq 0xc0(%rbx), %rdx
sarq $0x2, %rax
subq 0xb0(%rbx), %rdx
sarq $0x2, %rdx
addq %rcx, %rax
addq %rdx, %rax
incq %rax
cmpq %r14, %rax
je 0xd3d1
movl $0xb, %edx
movq %r15, %rdi
leaq 0x20f2(%rip), %rsi      # 0xf440
callq 0x3230
movq %r15, %rdi
movl %r14d, %esi
callq 0x3320
movl $0x2, %edx
movq %rax, %rdi
leaq 0x1ed2(%rip), %rsi      # 0xf23f
callq 0x3230
xorl %r13d, %r13d
movq 0x68(%rbx), %rax
movq (%rax,%r14,8), %rax
movl (%rax,%r13,4), %esi
movq %r15, %rdi
callq 0x3320
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x3230
incq %r13
cmpq $0xa, %r13
jne 0xd375
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3150
incq %r14
jmp 0xd2e8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/thunlp[P]KB2E/CTransR/Train_CTransR.cpp
// Function: Train::add(int, int, int)
void add(int x,int y,int z)
    {
        fb_h.push_back(x);
        fb_r.push_back(z);
        fb_l.push_back(y);
        ok[make_pair(x,z)][y]=1;
        ok_fb[make_pair(x,cluster2fb[z])][y]=1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %r14d
movl %edx, %ebp
movl %esi, %eax
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movq 0x98(%rdi), %rsi
cmpq 0xa0(%rdi), %rsi
je 0x3d85
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x98(%rbx)
jmp 0x3d96
leaq 0x90(%rbx), %rdi
leaq 0xc(%rsp), %rdx
callq 0x4798
movq 0xc8(%rbx), %rsi
cmpq 0xd0(%rbx), %rsi
je 0x3db6
movl %r14d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xc8(%rbx)
jmp 0x3dc7
leaq 0xc0(%rbx), %rdi
leaq 0x10(%rsp), %rdx
callq 0x4798
movq 0xb0(%rbx), %rsi
cmpq 0xb8(%rbx), %rsi
je 0x3de6
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xb0(%rbx)
jmp 0x3df7
leaq 0xa8(%rbx), %rdi
leaq 0x14(%rsp), %rdx
callq 0x4798
movl 0xc(%rsp), %eax
leaq 0x10(%rsp), %r12
movl (%r12), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
leaq 0x18(%rsp), %r15
movq %rcx, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x470e
leaq 0x14(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x3c96
movl $0x1, %ebp
movl %ebp, (%rax)
addq $0x30, %rbx
leaq 0x39110(%rip), %rdi     # 0x3cf50
movq %r12, %rsi
callq 0x3c96
movl 0xc(%rsp), %ecx
movl (%rax), %eax
shlq $0x20, %rax
orq %rcx, %rax
movq %rax, (%r15)
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x470e
movq %rax, %rdi
movq %r14, %rsi
callq 0x3c96
movl %ebp, (%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/SunriseFox[P]very-simple-c-compiler/./src/asm.cpp
// Function: getTmpReg[abi:cxx11](int)
string getTmpReg(int size) {
    for (int i = 0; i < 14; i++) {
        if (!regUsed[i])
            return size == 2 ? get2RegName(i) : (size == 4 ? get4RegName(i) : get8RegName(i));
    }
    cerr << "no enough regs" << endl;
    throw 0;
}

// Assembly:
pushq %rbx
movl %esi, %eax
movq %rdi, %rbx
xorl %esi, %esi
leaq 0xf98c(%rip), %rcx      # 0x13470
cmpb $0x0, (%rsi,%rcx)
je 0x3b2f
incq %rsi
cmpq $0xe, %rsi
jne 0x3ae4
movq 0xf4f6(%rip), %rdi      # 0x12ff0
leaq 0x9793(%rip), %rsi      # 0xd294
callq 0x31e0
movq %rax, %rdi
callq 0x3100
movl $0x4, %edi
callq 0x3110
movl $0x0, (%rax)
movq 0xf473(%rip), %rsi      # 0x12f98
movq %rax, %rdi
xorl %edx, %edx
callq 0x3390
movq %rbx, %rdi
cmpl $0x4, %eax
je 0x3b43
cmpl $0x2, %eax
jne 0x3b4a
callq 0x373c
jmp 0x3b4f
callq 0x386f
jmp 0x3b4f
callq 0x39a2
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/SunriseFox[P]very-simple-c-compiler/./src/asm.cpp
// Function: getSymbolMemory[abi:cxx11](Symbol*)
string getSymbolMemory(Symbol* sym) {
    if (varDeclare[sym].size() == 0) {
        cerr << "++++++++ trying getting empty symbol " << sym << endl;
        throw 0;
    }
    return varDeclare[sym] + string("(%rip)");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsp, %rax
movq %rsi, (%rax)
leaq 0xf358(%rip), %rdi      # 0x13240
movq %rax, %rsi
callq 0x76f8
cmpq $0x0, 0x8(%rax)
je 0x3faa
leaq 0xf33e(%rip), %rdi      # 0x13240
movq %rsp, %rsi
callq 0x76f8
movq %rax, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x93b7(%rip), %rsi      # 0xd2d5
leaq 0x93b6(%rip), %rdx      # 0xd2db
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x7944
movq (%r14), %rcx
movq 0x8(%r14), %r8
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3250
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x3f67
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x3f6d
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3f9b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3200
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xf03f(%rip), %rdi      # 0x12ff0
leaq 0x92f7(%rip), %rsi      # 0xd2af
callq 0x31e0
movq (%rsp), %rsi
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x3100
movl $0x4, %edi
callq 0x3110
movl $0x0, (%rax)
movq 0xefb0(%rip), %rsi      # 0x12f98
movq %rax, %rdi
xorl %edx, %edx
callq 0x3390
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x400c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3200
movq %rbx, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O3/SunriseFox[P]very-simple-c-compiler/./src/asm.cpp
// Function: handleCodeBlock(TreeNode*)
void handleCodeBlock(TreeNode* node) {
    if (node->nodeType == TreeNode::NODE_STATMENT
            && static_cast<StatementNode*>(node)->type == StatementNode::ST_SCOPE) {
        node = node->child;
    }
    while (node) {
        generateCode(node);
        node = node -> sibling;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, 0x10(%rdi)
jne 0x47bf
cmpl $0x2, 0x30(%rbx)
jne 0x47bf
movq 0x18(%rbx), %rbx
jmp 0x47cb
movq %rbx, %rdi
callq 0x47d2
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
jne 0x47bf
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/SunriseFox[P]very-simple-c-compiler/./src/asm.cpp
// Function: handleFunctionNode(TreeNode*)
void handleFunctionNode(TreeNode* node) {
    Symbol* ownSymbol = static_cast<TreeNode*>(node)->symbol;
    of << "\t.globl\t" << ownSymbol->value << "\n";
    of << "\t.type\t" << ownSymbol->value << ", @function\n";
    of << ownSymbol->value << ":\n";
    of << "\tpushq\t%rbp\n";
    of << "\tmovq\t%rsp, %rbp\n";

    auto children = node -> child;

    handleCodeBlock(children);

    while (true) {
        if (children->sibling != nullptr)
            children = children->sibling;
        else break;
    }

    if (children->nodeType == TreeNode::NODE_STATMENT
            && static_cast<StatementNode*>(children)->type == StatementNode::ST_RET) {

    } else {
        if (ownSymbol->value == "main") {
            of << "\tmovl $0, %eax\n";
        }
        of << "\tleave\n";
        of << "\tret\n";
    }
    of << "\t.size\t"<< ownSymbol->value <<", .-"<< ownSymbol->value <<"\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x28(%rdi), %r12
leaq 0xca30(%rip), %r15      # 0x13270
leaq 0x6bd4(%rip), %rsi      # 0xd41b
movl $0x8, %edx
movq %r15, %rdi
callq 0x3260
leaq 0x8(%r12), %rbx
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %r15, %rdi
callq 0x3260
leaq 0x6cae(%rip), %rsi      # 0xd520
movl $0x1, %edx
movq %rax, %rdi
callq 0x3260
leaq 0x6b9e(%rip), %rsi      # 0xd424
movl $0x7, %edx
movq %r15, %rdi
callq 0x3260
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %r15, %rdi
callq 0x3260
leaq 0x6b80(%rip), %rsi      # 0xd42c
movl $0xc, %edx
movq %rax, %rdi
callq 0x3260
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %r15, %rdi
callq 0x3260
leaq 0x6af6(%rip), %rsi      # 0xd3c8
movl $0x2, %edx
movq %rax, %rdi
callq 0x3260
leaq 0x6b53(%rip), %rsi      # 0xd439
movl $0xc, %edx
movq %r15, %rdi
callq 0x3260
leaq 0x6b4c(%rip), %rsi      # 0xd446
movl $0x11, %edx
movq %r15, %rdi
callq 0x3260
movq 0x18(%r14), %r14
movq %r14, %rdi
callq 0x47a9
movq %r14, %rax
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x6913
cmpl $0x1, 0x10(%rax)
jne 0x692b
cmpl $0x3, 0x30(%rax)
je 0x6985
leaq 0x6b26(%rip), %rsi      # 0xd458
movq %rbx, %rdi
callq 0x30a0
testl %eax, %eax
jne 0x6956
leaq 0xc92b(%rip), %rdi      # 0x13270
leaq 0x6b11(%rip), %rsi      # 0xd45d
movl $0xf, %edx
callq 0x3260
leaq 0xc913(%rip), %rbx      # 0x13270
leaq 0x6b09(%rip), %rsi      # 0xd46d
movl $0x7, %edx
movq %rbx, %rdi
callq 0x3260
leaq 0x6afd(%rip), %rsi      # 0xd475
movl $0x5, %edx
movq %rbx, %rdi
callq 0x3260
leaq 0xc8e4(%rip), %rbx      # 0x13270
leaq 0x6ae8(%rip), %rsi      # 0xd47b
movl $0x7, %edx
movq %rbx, %rdi
callq 0x3260
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %rbx, %rdi
callq 0x3260
movq %rax, %rbx
leaq 0x6ac7(%rip), %rsi      # 0xd483
movl $0x4, %edx
movq %rax, %rdi
callq 0x3260
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %rbx, %rdi
callq 0x3260
leaq 0x6b3e(%rip), %rsi      # 0xd520
movl $0x1, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3260
// File: /workspace/github_cpp_makefile_star2_O3/SunriseFox[P]very-simple-c-compiler/./src/asm.cpp
// Function: handleWhile(StatementNode*)
void handleWhile(StatementNode* node) {
    string LCondition = getNextLabel();

    of << "\tjmp\t" << LCondition << "\n";

    string LBlock = getNextLabel();

    of << LBlock << ":\n";

    handleCodeBlock(node->child->sibling);

    of << LCondition << ":\n";
    string reg = handleExprNode(node->child);
    of << "\ttestl\t" << reg << ", " << reg << "\n";
    of << "\tje\t" << LBlock << "\n";
}

// Assembly:
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
callq 0x4014
leaq 0xc85d(%rip), %rdi      # 0x13270
leaq 0x69a8(%rip), %rsi      # 0xd3c2
movl $0x5, %edx
callq 0x3260
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0xc83b(%rip), %rdi      # 0x13270
callq 0x3260
leaq 0x6adf(%rip), %rsi      # 0xd520
movl $0x1, %edx
movq %rax, %rdi
callq 0x3260
leaq 0x20(%rsp), %rdi
callq 0x4014
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0xc807(%rip), %rdi      # 0x13270
callq 0x3260
leaq 0x6953(%rip), %rsi      # 0xd3c8
movl $0x2, %edx
movq %rax, %rdi
callq 0x3260
movq 0x18(%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x47a9
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0xc7d0(%rip), %rdi      # 0x13270
callq 0x3260
leaq 0x691c(%rip), %rsi      # 0xd3c8
movl $0x2, %edx
movq %rax, %rdi
callq 0x3260
movq 0x18(%rbx), %rsi
movq %rsp, %rdi
callq 0x5235
leaq 0xc7a4(%rip), %rdi      # 0x13270
leaq 0x68c0(%rip), %rsi      # 0xd393
movl $0x7, %edx
callq 0x3260
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0xc783(%rip), %rdi      # 0x13270
callq 0x3260
movq %rax, %rbx
leaq 0x68d7(%rip), %rsi      # 0xd3d3
movl $0x2, %edx
movq %rax, %rdi
callq 0x3260
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x3260
leaq 0x69ff(%rip), %rsi      # 0xd520
movl $0x1, %edx
movq %rax, %rdi
callq 0x3260
leaq 0xc73b(%rip), %rdi      # 0x13270
leaq 0x6876(%rip), %rsi      # 0xd3b2
movl $0x4, %edx
callq 0x3260
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0xc719(%rip), %rdi      # 0x13270
callq 0x3260
leaq 0x69bd(%rip), %rsi      # 0xd520
movl $0x1, %edx
movq %rax, %rdi
callq 0x3260
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b8b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3200
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6ba6
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3200
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6bc1
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3200
addq $0x60, %rsp
popq %rbx
retq
jmp 0x6bd0
jmp 0x6bcb
movq %rax, %rbx
jmp 0x6c0e
movq %rax, %rbx
jmp 0x6bf3
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6bf3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3200
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6c0e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3200
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6c29
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3200
movq %rbx, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O3/SunriseFox[P]very-simple-c-compiler/./src/main.cpp
// Function: main
int main(int argc, char *argv[])
{
    if (argc == 2) {
        FILE* fin = fopen(argv[1], "r");
        if (fin != nullptr) {
            yyin = fin;
        } else {
            cerr << "failed to open file: " << argv[1] << endl;
        }
    } else {
#if YYDEBUG != 0
        extern int yydebug;
        yydebug = 1;
#endif
    }

    scope = new Scope();

    yyparse();

    TreeNode* temp = root;

    while (temp) {
        showTree(temp);
        temp = temp -> sibling;
    }

    extern void generateASM();
    generateASM();

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jne 0x861f
movq %rsi, %r14
movq 0x8(%rsi), %rdi
leaq 0x6ea0(%rip), %rsi      # 0xf42b
callq 0x3280
testq %rax, %rax
je 0x85a1
leaq 0xaefc(%rip), %rcx      # 0x13498
movq %rax, (%rcx)
jmp 0x861f
movq 0xaa48(%rip), %rbx      # 0x12ff0
leaq 0x51b1(%rip), %rsi      # 0xd760
movl $0x15, %edx
movq %rbx, %rdi
callq 0x3260
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x85e1
movq %r14, %rdi
callq 0x30f0
movq 0xaa1c(%rip), %rdi      # 0x12ff0
movq %r14, %rsi
movq %rax, %rdx
callq 0x3260
jmp 0x85f8
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x3370
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3150
movl $0x18, %edi
callq 0x31f0
movq %rax, %rbx
movq %rax, %rdi
callq 0xb658
leaq 0xaef5(%rip), %rax      # 0x13530
movq %rbx, (%rax)
callq 0xa090
leaq 0xaede(%rip), %rax      # 0x13528
movq (%rax), %rbx
testq %rbx, %rbx
je 0x8660
movq %rbx, %rdi
callq 0x8008
movq 0x20(%rbx), %rbx
jmp 0x864d
callq 0x724c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x18, %esi
movq %rbx, %rdi
callq 0x3200
movq %r14, %rdi
callq 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/SunriseFox[P]very-simple-c-compiler/./src/scope.cpp
// Function: Scope::findSymbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Symbol *Scope::findSymbol(const string &name)
{
    for (const auto& l: scopeStack) {
        for (const auto& n: l) {
            if(n.name == name)
                return n.symbol;
        }
    }
    return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r13
cmpq %rdi, %r13
je 0xb79f
movq %rdi, %r14
movq (%rsi), %r15
movq 0x8(%rsi), %r12
leaq 0x10(%r13), %rbx
movq 0x10(%r13), %rbp
cmpq %rbx, %rbp
je 0xb796
cmpq %r12, 0x20(%rbp)
jne 0xb790
testq %r12, %r12
je 0xb7a3
movq 0x18(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3210
testl %eax, %eax
je 0xb7a3
movq (%rbp), %rbp
jmp 0xb76d
movq (%r13), %r13
cmpq %r14, %r13
jne 0xb765
xorl %eax, %eax
jmp 0xb7a7
movq 0x38(%rbp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/SunriseFox[P]very-simple-c-compiler/./src/scope.cpp
// Function: Scope::insertSymbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, Symbol*)
bool Scope::insertSymbol(const string &name, int lineno, Symbol *symbol)
{
    auto& current = scopeStack.front();
    for (const auto& n: current) {
        if(n.name == name)
            return false;
    }
    current.push_back(ScopeNode(lineno, name, symbol));
    if (currFunc) {
        funcTable[currFunc].push_back(symbol);
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, 0x30(%rsp)
movl %edx, %ebp
movq (%rdi), %r13
leaq 0x10(%r13), %r14
movq 0x10(%r13), %rbx
movq (%rsi), %r15
movq 0x8(%rsi), %r12
cmpq %r14, %rbx
je 0xb805
cmpq %r12, 0x20(%rbx)
jne 0xb800
testq %r12, %r12
je 0xb861
movq 0x18(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3210
testl %eax, %eax
je 0xb861
movq (%rbx), %rbx
jmp 0xb7dd
leaq 0x8(%rsp), %rdi
movl %ebp, -0x8(%rdi)
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
addq %r15, %r12
movq %r15, %rsi
movq %r12, %rdx
callq 0x78ae
movq 0x30(%rsp), %rbx
movq %rbx, 0x10(%rbp)
movl $0x40, %edi
callq 0x31f0
movl (%rsp), %ecx
movl %ecx, 0x10(%rax)
movq %rax, %rcx
addq $0x28, %rcx
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rdx
cmpq %rbp, %rdx
je 0xb868
movq %rdx, 0x18(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x28(%rax)
jmp 0xb86f
xorl %ebp, %ebp
jmp 0xb8fd
movups (%rbp), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x20(%rax)
movq %rbp, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, 0x38(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x3060
incq 0x20(%r13)
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xb8ba
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3200
leaq 0x7c77(%rip), %rax      # 0x13538
movb $0x1, %bpl
cmpq $0x0, (%rax)
je 0xb8fd
leaq 0x7c77(%rip), %rdi      # 0x13548
leaq 0x7c60(%rip), %rsi      # 0x13538
callq 0xb954
movq %rax, %r14
movl $0x18, %edi
callq 0x31f0
movq %rbx, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x3060
incq 0x10(%r14)
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xb928
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3200
movq %rbx, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O3/SunriseFox[P]very-simple-c-compiler/./src/symbol.cpp
// Function: Symbol::getSymbolName[abi:cxx11](Symbol*)
string Symbol::getSymbolName(Symbol *s)
{
    switch (s->type) {
    case Symbol::VALUE_CHAR:
        return "char";
    case Symbol::VALUE_DOUBLE:
        return "double";
    case Symbol::VALUE_INT:
        return "int";
    case Symbol::VALUE_NONE:
        return "none";
    case Symbol::VALUE_ERROR:
        return "error";
    case Symbol::VALUE_STRING:
        return "string";
    case Symbol::VALUE_VOID:
        return "void";
    }
    return "--";
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rsi), %eax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
cmpq $0x6, %rax
ja 0xbd1b
leaq 0x373a(%rip), %rcx      # 0xf40c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3756(%rip), %rsi      # 0xf438
leaq 0x3753(%rip), %rdx      # 0xf43c
jmp 0xbd59
leaq 0x374b(%rip), %rsi      # 0xf43d
leaq 0x374a(%rip), %rdx      # 0xf443
jmp 0xbd59
leaq 0x3732(%rip), %rsi      # 0xf434
leaq 0x372e(%rip), %rdx      # 0xf437
jmp 0xbd59
leaq 0x371b(%rip), %rsi      # 0xf42d
leaq 0x371a(%rip), %rdx      # 0xf433
jmp 0xbd59
leaq 0x3727(%rip), %rsi      # 0xf449
leaq 0x3722(%rip), %rdx      # 0xf44b
jmp 0xbd59
leaq 0x3712(%rip), %rsi      # 0xf444
leaq 0x370f(%rip), %rdx      # 0xf448
jmp 0xbd59
leaq 0x36e6(%rip), %rsi      # 0xf428
leaq 0x36e3(%rip), %rdx      # 0xf42c
jmp 0xbd59
leaq 0x3659(%rip), %rsi      # 0xf3ab
leaq 0x3657(%rip), %rdx      # 0xf3b0
movq %rbx, %rdi
callq 0x7944
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/SunriseFox[P]very-simple-c-compiler/./src/tree.cpp
// Function: TreeNode::addChild(TreeNode*)
void TreeNode::addChild(TreeNode *node)
{
    if (node == nullptr
            || (node->nodeType == NODE_STATMENT
                && static_cast<StatementNode*>(node)->type == StatementNode::StatementNode::ST_EMPTY)) return;
    if (child == nullptr) {
        child = node;
        return;
    }
    if (child->sibling == nullptr) {
        child->sibling = node;
        return;
    }
    auto cur = child->sibling;
    while (cur->sibling != nullptr) {
        cur = cur->sibling;
    }
    cur->sibling = node;
}

// Assembly:
testq %rsi, %rsi
je 0xc067
cmpl $0x1, 0x10(%rsi)
jne 0xc033
cmpl $0x1, 0x30(%rsi)
je 0xc067
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0xc057
movq 0x20(%rcx), %rax
testq %rax, %rax
je 0xc05d
movq %rax, %rdi
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0xc045
addq $0x20, %rdi
jmp 0xc064
addq $0x18, %rdi
jmp 0xc064
addq $0x20, %rcx
movq %rcx, %rdi
movq %rsi, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/SunriseFox[P]very-simple-c-compiler/./src/tree.cpp
// Function: ExprNode::ExprNode(int, Symbol::ValueType, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
ExprNode::ExprNode(int lineno, Symbol::ValueType type, string value, bool isConstant)
    : TreeNode(lineno, NODE_EXPRESSION)
{
    if (isConstant)
        this->symbol = new Constant(type, value);
    else
        this->symbol = new Variable(type, value);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %r8d, %r12d
movq %rcx, %r15
movl %edx, %ebp
movq %rdi, %r14
movl %esi, 0xc(%rdi)
movl $0x3, 0x10(%rdi)
movl 0x707f(%rip), %eax      # 0x13224
leal 0x1(%rax), %ecx
movl %ecx, 0x7076(%rip)      # 0x13224
movl %eax, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
leaq 0x6aa1(%rip), %rax      # 0x12c60
movq %rax, (%rdi)
movl $0x30, %edi
callq 0x31f0
movq %rax, %rbx
testl %r12d, %r12d
je 0xc20c
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x78ae
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0xbd98
movq %rbx, 0x28(%r14)
movq 0x20(%rsp), %rdi
jmp 0xc23d
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x78ae
movq %rsp, %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0xbe30
movq %rbx, 0x28(%r14)
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xc24e
movq (%r12), %rsi
incq %rsi
callq 0x3200
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xc28f
movq 0x10(%rsp), %rsi
jmp 0xc280
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xc28f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3200
jmp 0xc28f
jmp 0xc28c
movq %rax, %r14
movl $0x30, %esi
movq %rbx, %rdi
callq 0x3200
movq %r14, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O3/Altius[P]hotspot2/src/hotspot2_part1.cpp
// Function: intern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string* intern(string s)
{
  map<string, string*>::iterator it = interned.find(s);
  if (it == interned.end())
    {
      interned[s] = new string(s);
      chromAsInt[interned[s]] = static_cast<int>(interned.size());
      return interned[s];
    }
  return it->second;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xaa1b(%rip), %rdi      # 0xd228
movq %rbx, %rsi
callq 0x7642
leaq 0xaa14(%rip), %rcx      # 0xd230
cmpq %rcx, %rax
je 0x2827
addq $0x40, %rax
jmp 0x288f
movl $0x20, %edi
callq 0x2220
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x75ac
leaq 0xa9d4(%rip), %r15      # 0xd228
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6df0
movq %r14, (%rax)
movl 0xa9e8(%rip), %ebp      # 0xd250
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6df0
leaq 0xa9de(%rip), %rdi      # 0xd258
movq %rax, %rsi
callq 0x6e6c
movl %ebp, (%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6df0
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x2230
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O3/Altius[P]hotspot2/src/hotspot2_part1.cpp
// Function: idxFromChrom(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
int idxFromChrom(string* ptr)
{
  map<string*, int>::const_iterator it = chromAsInt.find(ptr);
  if (chromAsInt.end() == it)
    {
      cerr << "Coding error:  Line " << __LINE__ << ", failed to find \""
	   << *ptr << "\" in the lookup table." << endl << endl;
      exit(2);
    }
  return it->second;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xa9a8(%rip), %rcx      # 0xd268
testq %rcx, %rcx
je 0x28fa
leaq 0xa994(%rip), %rax      # 0xd260
xorl %edx, %edx
cmpq %rbx, 0x20(%rcx)
setb %dl
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x28cc
leaq 0xa976(%rip), %rcx      # 0xd260
cmpq %rcx, %rax
je 0x28fa
cmpq %rbx, 0x20(%rax)
ja 0x28fa
movl 0x28(%rax), %eax
popq %rbx
retq
movq 0xa6ef(%rip), %rdi      # 0xcff0
leaq 0x67bc(%rip), %rsi      # 0x90c4
callq 0x2210
movq %rax, %rdi
movl $0x34, %esi
callq 0x2390
leaq 0x67b8(%rip), %rsi      # 0x90d9
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21e0
leaq 0x67b1(%rip), %rsi      # 0x90ec
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
callq 0x20e0
movl $0x2, %edi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/Altius[P]hotspot2/src/hotspot2_part1.cpp
// Function: nextProbBinomial(int const&, long double const&, std::vector<long double, std::allocator<long double>> const&)
long double nextProbBinomial(const int& k, const long double& prevVal, const vector<long double>& params)
{
  if (params.size() < 3)
    {
      cerr << "Error:  nextProbBinomial() received an incorrect parameter vector; expected m, v, n."
           << endl
           << endl;
      exit(1);
    }
  if (0 == k)
    {
      cerr << "Error:  nextProbBinomial() received k = 0, which is invalid (require k > 0)."
           << endl
           << endl;
      exit(1);
    }
  const long double &m(params[0]), &v(params[1]), &nn(params[2]), kk(static_cast<long double>(k));
  if (kk > nn + 0.5) // really "if kk > nn," but we could have "kk == nn" with nn=15.99999 and kk=16.000001, hence the 0.5
    return 0.;
  if (v < 1.0e-8)
    {
      cerr << "Error:  nextProbBinomial() received v = 0, which is invalid (require variance > 0)."
           << endl
           << endl;
      exit(1);
    }
  return prevVal * (m - v) * (nn + 1. - kk) / (v * kk);
}

// Assembly:
pushq %rax
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
subq %rax, %rcx
cmpq $0x20, %rcx
jbe 0x2aa0
movl (%rdi), %ecx
testl %ecx, %ecx
je 0x2ab0
movl %ecx, 0x4(%rsp)
fildl 0x4(%rsp)
fldt 0x20(%rax)
fld %st(0)
fadds 0x659f(%rip)            # 0x9004
fldz
fxch %st(3)
fucomi %st(1), %st
fstp %st(1)
ja 0x2a9a
fstp %st(2)
fldt 0x10(%rax)
fldl 0x6596(%rip)            # 0x9010
fucompi %st(1), %st
ja 0x2ac0
fldt (%rsi)
fldt (%rax)
fsub %st(2), %st
fmulp %st, %st(1)
fld1
faddp %st, %st(3)
fxch %st(2)
fsub %st(3), %st
fmulp %st, %st(2)
fmulp %st, %st(2)
fdivp %st, %st(1)
fldz
fldz
fxch %st(1)
fstp %st(0)
fstp %st(0)
popq %rax
retq
movq 0xa549(%rip), %rdi      # 0xcff0
leaq 0x6765(%rip), %rsi      # 0x9213
jmp 0x2ad4
movq 0xa539(%rip), %rdi      # 0xcff0
leaq 0x67aa(%rip), %rsi      # 0x9268
jmp 0x2ad4
fstp %st(2)
fstp %st(0)
fstp %st(0)
movq 0xa523(%rip), %rdi      # 0xcff0
leaq 0x67e1(%rip), %rsi      # 0x92b5
callq 0x2210
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
callq 0x20e0
movl $0x1, %edi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/Altius[P]hotspot2/src/hotspot2_part1.cpp
// Function: nextProbPoisson(int const&, long double const&, std::vector<long double, std::allocator<long double>> const&)
long double nextProbPoisson(const int& k, const long double& prevVal, const vector<long double>& params)
{
  if (params.empty())
    {
      cerr << "Error:  nextProbPoisson() received an incorrect parameter vector; expected m."
           << endl
           << endl;
      exit(1);
    }
  if (0 == k)
    {
      cerr << "Error:  nextProbPoisson() received k = 0, which is invalid (require k > 0)."
           << endl
           << endl;
      exit(1);
    }
  const long double &m(params[0]), kk(static_cast<long double>(k));
  return prevVal * m / kk;
}

// Assembly:
pushq %rax
movq (%rdx), %rax
cmpq 0x8(%rdx), %rax
je 0x2b13
movl (%rdi), %ecx
testl %ecx, %ecx
je 0x2b23
movl %ecx, 0x4(%rsp)
fldt (%rsi)
fldt (%rax)
fmulp %st, %st(1)
fidivl 0x4(%rsp)
popq %rax
retq
movq 0xa4d6(%rip), %rdi      # 0xcff0
leaq 0x67e8(%rip), %rsi      # 0x9309
jmp 0x2b31
movq 0xa4c6(%rip), %rdi      # 0xcff0
leaq 0x6826(%rip), %rsi      # 0x9357
callq 0x2210
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
callq 0x20e0
movl $0x1, %edi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/Altius[P]hotspot2/src/hotspot2_part1.cpp
// Function: BackgroundRegionManager::setBounds(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, int, int)
void BackgroundRegionManager::setBounds(const string* pChrom, const int posL, const int posR)
{
  if (posR <= posL)
    {
      cerr << "Error:  BackgroundRegionManager::setBounds() received posL = "
           << posL << " and posR = " << posR << "; must have posL <= posR."
           << endl
           << endl;
      exit(1);
    }
  m_pCurChrom = pChrom; // used solely for warning and error messages and debugging
  m_posL = posL;
  m_posR = posR;
  m_posC = m_posL + (m_posR - m_posL) / 2; // integer division
  m_nextPosToSample = m_posL;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %ecx, %eax
subl %edx, %eax
jle 0x2ec4
movq %rsi, 0x188(%rdi)
movl %ebp, (%rdi)
movl %ebx, 0x4(%rdi)
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %ebp, %ecx
movl %ecx, 0x8(%rdi)
movl %ebp, 0x15c(%rdi)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0xa125(%rip), %rdi      # 0xcff0
leaq 0x6512(%rip), %rsi      # 0x93e4
callq 0x2210
movq %rax, %rdi
movl %ebp, %esi
callq 0x2390
leaq 0x653a(%rip), %rsi      # 0x9422
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
movl %ebx, %esi
callq 0x2390
leaq 0x652e(%rip), %rsi      # 0x942f
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
callq 0x20e0
movl $0x1, %edi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/TheiaRT[P]libiris/tcp_client.cpp
// Function: TCPClient::connect(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
bool TCPClient::connect(std::string address, int port)
{
    /* New client; sock does not exist */
    if (sock == -1) {
        sock = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
        if (sock < 0) {
            perror("Could not create socket.");
            return false;
        }

#if defined(__APPLE__) && defined(__MACH__)
        int set = 1;
        setsockopt(sock, SOL_SOCKET, SO_NOSIGPIPE, (void *)&set, sizeof(set));
#endif
    }
    else {
        /* Do nothing; sock exists */
    }

    /* Set up address structure */
    if (inet_addr(address.c_str()) == -1) {
        struct hostent *he;
        struct in_addr **addr_list;

        /* Valgrind may incorrectly report this as leaking. */
        he = gethostbyname(address.c_str());
        if (he == NULL) {
            herror("Could not resolve hostname.");
            return false;
        }

        addr_list = (struct in_addr **) he->h_addr_list;
        for (int i = 0; addr_list[i] != NULL; i++) {
            server.sin_addr = *addr_list[i];
            break;
        }
    }
    else {
        server.sin_addr.s_addr = inet_addr(address.c_str());
    }

    server.sin_family = AF_INET;
    server.sin_port = htons(port);

    if (::connect(sock, (struct sockaddr *)&server, sizeof(server)) < 0) {
        perror("Connect failed.");
        return false;
    }

    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
cmpl $-0x1, (%rdi)
jne 0x238e
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2050
movl %eax, (%r14)
testl %eax, %eax
js 0x2401
movq (%r15), %rdi
callq 0x2100
movq (%r15), %rdi
cmpl $-0x1, %eax
je 0x23d9
callq 0x2100
movl %eax, 0x8(%r14)
leaq 0x4(%r14), %rsi
movw $0x2, 0x4(%r14)
rolw $0x8, %bx
movw %bx, 0x6(%r14)
movl (%r14), %edi
movl $0x10, %edx
callq 0x20c0
movl %eax, %ecx
movb $0x1, %al
testl %ecx, %ecx
jns 0x240f
leaq 0xc62(%rip), %rdi       # 0x3039
jmp 0x2408
callq 0x2120
testq %rax, %rax
je 0x23f3
movq 0x18(%rax), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x23a7
movl (%rax), %eax
jmp 0x23a3
leaq 0xc23(%rip), %rdi       # 0x301d
callq 0x2140
jmp 0x240d
leaq 0xbfc(%rip), %rdi       # 0x3004
callq 0x20d0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/TheiaRT[P]libiris/tcp_client.cpp
// Function: TCPClient::send_data(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
bool TCPClient::send_data(std::string data, int size)
{
    if (send(sock, data.c_str(), data.length(), 0) < 0) {
        perror("Send failed.");
        return false;
    }

    return true;
}

// Assembly:
pushq %rbx
movl (%rdi), %edi
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x2070
movq %rax, %rbx
testq %rax, %rax
js 0x243a
testq %rbx, %rbx
setns %al
popq %rbx
retq
leaq 0xc08(%rip), %rdi       # 0x3049
callq 0x20d0
jmp 0x2432
// File: /workspace/github_cpp_makefile_star2_O3/TheiaRT[P]libiris/tcp_client.cpp
// Function: TCPClient::receive[abi:cxx11](int)
std::string TCPClient::receive(int size)
{
    std::string buffer = "";
    char *cbuffer = new char[size];
    bzero(cbuffer, size);
    int recvd = 0;
    while ((recvd = recv(sock, cbuffer, size - 1, 0)) > 0) {
        buffer += cbuffer;
        bzero(cbuffer, size);
    }

    if (recvd < 0) {
        perror("Receive failed.");
        return std::string();
    }

    delete [] cbuffer;
    close(sock);
    sock = -1;
    return buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0xc57(%rip), %rdx       # 0x30c5
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x256e
movslq %ebx, %r12
movq %r12, %rdi
callq 0x2030
movq %rax, %r13
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2080
leal -0x1(%r12), %eax
movslq %eax, %rbp
leaq 0x8(%rsp), %rbx
movl (%r15), %edi
movq %r13, %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
callq 0x2060
testl %eax, %eax
jle 0x24d1
movq %rbx, %rdi
movq %r13, %rsi
callq 0x21a0
movq %r13, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2080
jmp 0x24a3
js 0x252f
movq %r13, %rdi
callq 0x2150
movl (%r15), %edi
callq 0x21b0
movl $0xffffffff, (%r15)     # imm = 0xFFFFFFFF
leaq 0x10(%r14), %rax
movq %rax, (%r14)
movq 0x8(%rsp), %rcx
leaq 0x18(%rsp), %rdx
cmpq %rdx, %rcx
je 0x250e
movq %rcx, (%r14)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%r14)
jmp 0x2514
movups (%rdx), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%r14)
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
leaq 0x18(%rsp), %rdx
callq 0x21d0
jmp 0x251d
jmp 0x2547
jmp 0x2547
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2566
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2110
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/frame/testClient/testEcho.cpp
// Function: test003_mt_sync_req_rsp()
static void test003_mt_sync_req_rsp()
{
	static const char *tag = "test003: mt-sync-req-rsp";
	fprintf(stdout, "%s start...\n", tag);


	pthread_t tids[tcnt];
	for (int i = 0; i < tcnt; ++i) {
		errno = pthread_create(&tids[i], NULL, __test003_worker, (void *)(long)i);
		if (errno) {
			fprintf(stdout, "%s create the %dth thread failed: %m\n", tag, i);
			exit(1);
		}
	}

	for (int i = 0; i < tcnt; ++i) {
		pthread_join(tids[i], NULL);
	}

	fprintf(stdout, "%s done\n", tag);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x38f0(%rip), %r14      # 0x4fc8
movq (%r14), %rdi
leaq 0x198e(%rip), %rsi      # 0x3070
leaq 0x1b36(%rip), %rdx      # 0x321f
xorl %eax, %eax
callq 0x11f0
movl 0x3a62(%rip), %eax      # 0x5158
movq %rsp, %r13
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
subq %rcx, %r13
movq %r13, %rsp
testl %eax, %eax
jle 0x1776
xorl %ebx, %ebx
leaq 0x37c(%rip), %r14       # 0x1a94
movq %r13, %r15
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1260
movl %eax, %r12d
callq 0x1040
movl %r12d, (%rax)
testl %r12d, %r12d
jne 0x179d
incq %rbx
movslq 0x3a13(%rip), %rax      # 0x5158
addq $0x8, %r15
cmpq %rax, %rbx
jl 0x171b
testl %eax, %eax
movq 0x3871(%rip), %r14      # 0x4fc8
jle 0x1776
xorl %ebx, %ebx
movq (%r13,%rbx,8), %rdi
xorl %esi, %esi
callq 0x1140
incq %rbx
movslq 0x39e7(%rip), %rax      # 0x5158
cmpq %rax, %rbx
jl 0x175b
movq (%r14), %rdi
leaq 0x1914(%rip), %rsi      # 0x3094
leaq 0x1a98(%rip), %rdx      # 0x321f
xorl %eax, %eax
callq 0x11f0
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3824(%rip), %rax      # 0x4fc8
movq (%rax), %rdi
leaq 0x1a8a(%rip), %rsi      # 0x3238
leaq 0x1a6a(%rip), %rdx      # 0x321f
movl %ebx, %ecx
xorl %eax, %eax
callq 0x11f0
movl $0x1, %edi
callq 0x11a0
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/frame/testClient/testEcho.cpp
// Function: _send_req(int, int, int, char const*)
static void __send_req(int fd, int cmd, int size, const char *tag)
{
	struct proto_h16_head *h; 
	int msize = size + sizeof(*h);

	char *reqbuf = new char[msize];	
	h = (struct proto_h16_head *)reqbuf;

	h->len = msize;
	h->cmd = cmd;
	h->ver = 1;
	h->syn = 2;
	h->ack = 3;

	if (size >= (int)sizeof(int)) {
		*(int *)(reqbuf + sizeof *h) = random() % 3000;
	}	

	ssize_t wlen = beyondy::XbsWriteN(fd, reqbuf, msize, timeout);
	if (wlen != msize) {
		fprintf(stdout, "FAIL: %s pkg-size=%d, write req failed: %m\n", tag, size);
		exit(1);
	}

	delete[] reqbuf;	
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r14d
movl %esi, %r13d
movl %edi, %ebp
leal 0x10(%r14), %eax
movslq %eax, %r15
movq %r15, %rdi
callq 0x1030
movq %rax, %r12
movl %r15d, (%rax)
movw %r13w, 0x4(%rax)
movw $0x1, 0x6(%rax)
movabsq $0x300000002, %rax      # imm = 0x300000002
movq %rax, 0x8(%r12)
cmpl $0x4, %r14d
jl 0x1845
callq 0x10c0
movq %rax, %rcx
movabsq $-0x513cc1e098ead65b, %rdx # imm = 0xAEC33E1F671529A5
imulq %rdx
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0xb, %rdx
addl %eax, %edx
imull $0xbb8, %edx, %eax      # imm = 0xBB8
subl %eax, %ecx
movl %ecx, 0x10(%r12)
movl $0x7530, %ecx           # imm = 0x7530
movl %ebp, %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1caf
cmpq %r15, %rax
jne 0x1872
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11c0
movq 0x374f(%rip), %rax      # 0x4fc8
movq (%rax), %rdi
leaq 0x184f(%rip), %rsi      # 0x30d2
movq %rbx, %rdx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x11f0
movl $0x1, %edi
callq 0x11a0
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/frame/testClient/testEcho.cpp
// Function: _read_rsp(int, int, char const*)
static void __read_rsp(int fd, int size, const char *tag)
{
	int msize = size + sizeof(struct proto_h16_head);
	char *rspbuf = new char[msize];

	ssize_t rlen = beyondy::XbsReadN(fd, rspbuf, msize, timeout);
	if (rlen != msize) {
		fprintf(stdout, "FAIL: %s pkg-size=%d, read rsp failed: %m\n", tag, msize);
		exit(1);
	}

	// TODO: cksum rspbuf
	delete[] rspbuf;
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebx
movl %edi, %ebp
addl $0x10, %ebx
movslq %ebx, %r12
movq %r12, %rdi
callq 0x1030
movq %rax, %r15
movl $0x7530, %ecx           # imm = 0x7530
movl %ebp, %edi
movq %rax, %rsi
movq %r12, %rdx
callq 0x1ea9
cmpq %r12, %rax
jne 0x18e1
movq %r15, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x11c0
movq 0x36e0(%rip), %rax      # 0x4fc8
movq (%rax), %rdi
leaq 0x180c(%rip), %rsi      # 0x30fe
movq %r14, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x11f0
movl $0x1, %edi
callq 0x11a0
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/frame/testClient/testEcho.cpp
// Function: _test002_sender_entry(void*)
static void *__test002_sender_entry(void *p)
{
	static const char *tag = "test002: async-req-rsp sender";

	int fd = (int)(long)p;	
	for (int i = 0; i < scnt; ++i) {
		struct timeval t1, t2;

		gettimeofday(&t1, NULL);
		__send_req(fd, cmd, sizes[i], tag);

		gettimeofday(&t2, NULL);
		fprintf(stdout, "%s send req with pkg-size=%ld took %ldms\n", \
			tag, (long)sizes[i], DIFF_TV(&t1, &t2));
	}

	return NULL;	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x1870(%rip), %r15      # 0x3190
movabsq $0x20c49ba5e353f7cf, %r12 # imm = 0x20C49BA5E353F7CF
leaq 0x187d(%rip), %r13      # 0x31ae
xorl %r14d, %r14d
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x1240
movl 0x381a(%rip), %esi      # 0x5160
leaq 0x1983(%rip), %rax      # 0x32d0
movl (%r14,%rax), %ebp
movl %ebx, %edi
movl %ebp, %edx
movq %r15, %rcx
callq 0x17c8
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1240
movq 0x3658(%rip), %rax      # 0x4fc8
movq (%rax), %rdi
movslq %ebp, %rcx
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
subq 0x18(%rsp), %rdx
imulq $0x3e8, %rdx, %rsi      # imm = 0x3E8
subq 0x20(%rsp), %rax
imulq %r12
movq %rdx, %r8
shrq $0x3f, %r8
sarq $0x7, %rdx
addq %rdx, %r8
addq %rsi, %r8
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x11f0
addq $0x4, %r14
cmpq $0x38, %r14
jne 0x1934
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/frame/testClient/testEcho.cpp
// Function: _test002_reader_entry(void*)
static void *__test002_reader_entry(void *p)
{
	static const char *tag = "test002: async-req-rsp reader";

	int fd = (int)(long)p;
	for (int i = 0; i < scnt; ++i) {
		struct timeval t1, t2;

		gettimeofday(&t1, NULL);
		__read_rsp(fd, sizes[i], tag);

		gettimeofday(&t2, NULL);
		fprintf(stdout, "%s read rsp for pkg-size=%ld took %ldms\n", 
			tag, (long)sizes[i], DIFF_TV(&t1, &t2));
	}

	return NULL;	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x17ef(%rip), %r15      # 0x31d8
movabsq $0x20c49ba5e353f7cf, %r12 # imm = 0x20C49BA5E353F7CF
leaq 0x17fc(%rip), %r13      # 0x31f6
xorl %r14d, %r14d
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x1240
leaq 0x18c0(%rip), %rax      # 0x32d0
movl (%r14,%rax), %ebp
movl %ebx, %edi
movl %ebp, %esi
movq %r15, %rdx
callq 0x189a
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1240
movq 0x3595(%rip), %rax      # 0x4fc8
movq (%rax), %rdi
movslq %ebp, %rcx
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
subq 0x18(%rsp), %rdx
imulq $0x3e8, %rdx, %rsi      # imm = 0x3E8
subq 0x20(%rsp), %rax
imulq %r12
movq %rdx, %r8
shrq $0x3f, %r8
sarq $0x7, %rdx
addq %rdx, %r8
addq %rsi, %r8
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x11f0
addq $0x4, %r14
cmpq $0x38, %r14
jne 0x19fd
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/frame/testClient/testEcho.cpp
// Function: _test003_worker(void*)
static void *__test003_worker(void *p)
{
	static const char *tag = "test003: mt-sync-req-rsp-worker";

	int fd = beyondy::XbsClient(host, O_NONBLOCK, 30000);
	if (fd < 0) {
		fprintf(stdout, "%s connect failed: %m\n", tag);
		exit(1);
	}

	for (int i = 0; i < scnt; ++i) {
		struct timeval t1, t2, t3;

		gettimeofday(&t1, NULL);	
		__send_req(fd, cmd, sizes[i], tag);

		gettimeofday(&t2, NULL);
		__read_rsp(fd, sizes[i], tag);

		gettimeofday(&t3, NULL);
		fprintf(stdout, "%s pkg-size=%ld send took %ldms, read took %ld ms\n", \
			tag, (long)sizes[i], DIFF_TV(&t1, &t2), DIFF_TV(&t2, &t3));
	}

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x36a7(%rip), %rdi      # 0x5150
movl $0x7530, %edx           # imm = 0x7530
movl $0x800, %esi            # imm = 0x800
callq 0x2543
testl %eax, %eax
js 0x1bc9
movl %eax, %ebx
leaq 0x1795(%rip), %r15      # 0x325e
movabsq $0x20c49ba5e353f7cf, %r12 # imm = 0x20C49BA5E353F7CF
leaq 0x17a4(%rip), %rbp      # 0x327e
xorl %r13d, %r13d
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x1240
movl 0x3671(%rip), %esi      # 0x5160
leaq 0x17da(%rip), %rax      # 0x32d0
movl (%r13,%rax), %r14d
movl %ebx, %edi
movl %r14d, %edx
movq %r15, %rcx
callq 0x17c8
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x1240
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0x189a
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1240
movq 0x3494(%rip), %rax      # 0x4fc8
movq (%rax), %rdi
movslq %r14d, %rcx
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdx
movq 0x8(%rsp), %r9
subq %rax, %r9
movq %rax, %r8
subq 0x28(%rsp), %r8
movq 0x10(%rsp), %rsi
subq %rdx, %rsi
movq %rdx, %rax
subq 0x30(%rsp), %rax
imulq $0x3e8, %r8, %r10       # imm = 0x3E8
imulq %r12
movq %rdx, %r8
shrq $0x3f, %r8
sarq $0x7, %rdx
addq %rdx, %r8
addq %r10, %r8
imulq $0x3e8, %r9, %r10       # imm = 0x3E8
movq %rsi, %rax
imulq %r12
movq %rdx, %r9
shrq $0x3f, %r9
sarq $0x7, %rdx
addq %rdx, %r9
addq %r10, %r9
movq %rbp, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x11f0
addq $0x4, %r13
cmpq $0x38, %r13
jne 0x1add
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x33f8(%rip), %rax      # 0x4fc8
movq (%rax), %rdi
leaq 0x14a3(%rip), %rsi      # 0x307d
leaq 0x167d(%rip), %rdx      # 0x325e
xorl %eax, %eax
callq 0x11f0
movl $0x1, %edi
callq 0x11a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/daltonbr[P]RayTracing/./src/vec3.h
// Function: random_in_unit_sphere()
vec3 random_in_unit_sphere()
{
    vec3 p;
    do
    {
        p = 2.0 * vec3(drand48(), drand48(), drand48()) - vec3(1, 1, 1);
    } while (p.squared_length() >= 1.0);
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x20a0
cvtsd2ss %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
callq 0x20a0
cvtsd2ss %xmm0, %xmm0
movaps %xmm0, -0x10(%rbp)
callq 0x20a0
movaps -0x10(%rbp), %xmm4
movaps -0x20(%rbp), %xmm3
xorps %xmm1, %xmm1
cvtsd2ss %xmm0, %xmm1
addss %xmm3, %xmm3
addss %xmm4, %xmm4
addss %xmm1, %xmm1
movss 0x14c7e(%rip), %xmm0    # 0x17004
addss %xmm0, %xmm3
addss %xmm0, %xmm4
addss %xmm0, %xmm1
movaps %xmm4, %xmm0
mulss %xmm4, %xmm0
movaps %xmm3, %xmm2
mulss %xmm3, %xmm2
addss %xmm0, %xmm2
movaps %xmm1, %xmm0
mulss %xmm1, %xmm0
addss %xmm2, %xmm0
ucomiss 0x14c52(%rip), %xmm0    # 0x17008
jae 0x2344
unpcklps %xmm4, %xmm3            # xmm3 = xmm3[0],xmm4[0],xmm3[1],xmm4[1]
movaps %xmm3, %xmm0
addq $0x20, %rsp
popq %rbp
retq