LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/SunriseFox[P]very-simple-c-compiler/./src/asm.cpp
// Function: get2RegName[abi:cxx11](int)
string get2RegName(int i) {
    switch (i) {
    case 0: return "%al";
    case 1: return "%bl";
    case 2: return "%cl";
    case 3: return "%dl";
    case 4: return "%sil";
    case 5: return "%dil";
    case 6: return "%r8b";
    case 7: return "%r9b";
    case 8: return "%r10b";
    case 9: return "%r11b";
    case 10: return "%r12b";
    case 11: return "%r13b";
    case 12: return "%r14b";
    case 13: return "%r15b";
    }
    return "unknown4reg";
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0xd, %esi
ja 0x37f2
movl %esi, %eax
leaq 0x78fa(%rip), %rcx      # 0xb010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x7a6e(%rip), %rsi      # 0xb194
leaq 0xf(%rsp), %rdx
jmp 0x37fe
leaq 0x7a93(%rip), %rsi      # 0xb1ca
leaq 0x4(%rsp), %rdx
jmp 0x37fe
leaq 0x7a5c(%rip), %rsi      # 0xb1a4
leaq 0xb(%rsp), %rdx
jmp 0x37fe
leaq 0x7a77(%rip), %rsi      # 0xb1d0
leaq 0x3(%rsp), %rdx
jmp 0x37fe
leaq 0x7a54(%rip), %rsi      # 0xb1be
leaq 0x6(%rsp), %rdx
jmp 0x37fe
leaq 0x7a21(%rip), %rsi      # 0xb19c
leaq 0xd(%rsp), %rdx
jmp 0x37fe
leaq 0x7a17(%rip), %rsi      # 0xb1a0
leaq 0xc(%rsp), %rdx
jmp 0x37fe
leaq 0x7a1c(%rip), %rsi      # 0xb1b3
leaq 0x8(%rsp), %rdx
jmp 0x37fe
leaq 0x79f3(%rip), %rsi      # 0xb198
leaq 0xe(%rsp), %rdx
jmp 0x37fe
leaq 0x79f6(%rip), %rsi      # 0xb1a9
leaq 0xa(%rsp), %rdx
jmp 0x37fe
leaq 0x7a15(%rip), %rsi      # 0xb1d6
leaq 0x2(%rsp), %rdx
jmp 0x37fe
leaq 0x79df(%rip), %rsi      # 0xb1ae
leaq 0x9(%rsp), %rdx
jmp 0x37fe
leaq 0x79e7(%rip), %rsi      # 0xb1c4
leaq 0x5(%rsp), %rdx
jmp 0x37fe
leaq 0x79cd(%rip), %rsi      # 0xb1b8
leaq 0x7(%rsp), %rdx
jmp 0x37fe
leaq 0x79e3(%rip), %rsi      # 0xb1dc
leaq 0x1(%rsp), %rdx
movq %rbx, %rdi
callq 0x615c
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/SunriseFox[P]very-simple-c-compiler/./src/asm.cpp
// Function: get4RegName[abi:cxx11](int)
string get4RegName(int i) {
    switch (i) {
    case 0: return "%eax";
    case 1: return "%ebx";
    case 2: return "%ecx";
    case 3: return "%edx";
    case 4: return "%esi";
    case 5: return "%edi";
    case 6: return "%r8d";
    case 7: return "%r9d";
    case 8: return "%r10d";
    case 9: return "%r11d";
    case 10: return "%r12d";
    case 11: return "%r13d";
    case 12: return "%r14d";
    case 13: return "%r15d";
    }
    return "unknown4reg";
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0xd, %esi
ja 0x3905
movl %esi, %eax
leaq 0x781f(%rip), %rcx      # 0xb048
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x79af(%rip), %rsi      # 0xb1e8
leaq 0xf(%rsp), %rdx
jmp 0x3911
leaq 0x79d8(%rip), %rsi      # 0xb222
leaq 0x4(%rsp), %rdx
jmp 0x3911
leaq 0x79a1(%rip), %rsi      # 0xb1fc
leaq 0xb(%rsp), %rdx
jmp 0x3911
leaq 0x79bc(%rip), %rsi      # 0xb228
leaq 0x3(%rsp), %rdx
jmp 0x3911
leaq 0x7999(%rip), %rsi      # 0xb216
leaq 0x6(%rsp), %rdx
jmp 0x3911
leaq 0x7964(%rip), %rsi      # 0xb1f2
leaq 0xd(%rsp), %rdx
jmp 0x3911
leaq 0x795b(%rip), %rsi      # 0xb1f7
leaq 0xc(%rsp), %rdx
jmp 0x3911
leaq 0x7961(%rip), %rsi      # 0xb20b
leaq 0x8(%rsp), %rdx
jmp 0x3911
leaq 0x7935(%rip), %rsi      # 0xb1ed
leaq 0xe(%rsp), %rdx
jmp 0x3911
leaq 0x793b(%rip), %rsi      # 0xb201
leaq 0xa(%rsp), %rdx
jmp 0x3911
leaq 0x795a(%rip), %rsi      # 0xb22e
leaq 0x2(%rsp), %rdx
jmp 0x3911
leaq 0x7924(%rip), %rsi      # 0xb206
leaq 0x9(%rsp), %rdx
jmp 0x3911
leaq 0x792c(%rip), %rsi      # 0xb21c
leaq 0x5(%rsp), %rdx
jmp 0x3911
leaq 0x7912(%rip), %rsi      # 0xb210
leaq 0x7(%rsp), %rdx
jmp 0x3911
leaq 0x78d0(%rip), %rsi      # 0xb1dc
leaq 0x1(%rsp), %rdx
movq %rbx, %rdi
callq 0x615c
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/SunriseFox[P]very-simple-c-compiler/./src/asm.cpp
// Function: get8RegName[abi:cxx11](int)
string get8RegName(int i) {
    switch (i) {
    case 0: return "%rax";
    case 1: return "%rbx";
    case 2: return "%rcx";
    case 3: return "%rdx";
    case 4: return "%rsi";
    case 5: return "%rdi";
    case 6: return "%r8";
    case 7: return "%r9";
    case 8: return "%r10";
    case 9: return "%r11";
    case 10: return "%r12";
    case 11: return "%r13";
    case 12: return "%r14";
    case 13: return "%r15";
    }
    return "unknown8reg";
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0xd, %esi
ja 0x3a18
movl %esi, %eax
leaq 0x7744(%rip), %rcx      # 0xb080
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x78e8(%rip), %rsi      # 0xb234
leaq 0xf(%rsp), %rdx
jmp 0x3a24
leaq 0x790c(%rip), %rsi      # 0xb269
leaq 0x4(%rsp), %rdx
jmp 0x3a24
leaq 0x78da(%rip), %rsi      # 0xb248
leaq 0xb(%rsp), %rdx
jmp 0x3a24
leaq 0x78ef(%rip), %rsi      # 0xb26e
leaq 0x3(%rsp), %rdx
jmp 0x3a24
leaq 0x78cf(%rip), %rsi      # 0xb25f
leaq 0x6(%rsp), %rdx
jmp 0x3a24
leaq 0x789d(%rip), %rsi      # 0xb23e
leaq 0xd(%rsp), %rdx
jmp 0x3a24
leaq 0x7894(%rip), %rsi      # 0xb243
leaq 0xc(%rsp), %rdx
jmp 0x3a24
leaq 0x7899(%rip), %rsi      # 0xb256
leaq 0x8(%rsp), %rdx
jmp 0x3a24
leaq 0x786e(%rip), %rsi      # 0xb239
leaq 0xe(%rsp), %rdx
jmp 0x3a24
leaq 0x7874(%rip), %rsi      # 0xb24d
leaq 0xa(%rsp), %rdx
jmp 0x3a24
leaq 0x788c(%rip), %rsi      # 0xb273
leaq 0x2(%rsp), %rdx
jmp 0x3a24
leaq 0x785d(%rip), %rsi      # 0xb252
leaq 0x9(%rsp), %rdx
jmp 0x3a24
leaq 0x7861(%rip), %rsi      # 0xb264
leaq 0x5(%rsp), %rdx
jmp 0x3a24
leaq 0x7849(%rip), %rsi      # 0xb25a
leaq 0x7(%rsp), %rdx
jmp 0x3a24
leaq 0x7859(%rip), %rsi      # 0xb278
leaq 0x1(%rsp), %rdx
movq %rbx, %rdi
callq 0x615c
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xea24(%rip), %rcx      # 0x12468
cmpq $0xe, %rsi
je 0x3a7a
cmpb $0x0, (%rsi,%rcx)
je 0x3a55
incq %rsi
jmp 0x3a44
movq %rbx, %rdi
cmpl $0x4, %eax
je 0x3a69
cmpl $0x2, %eax
jne 0x3a70
callq 0x36fc
jmp 0x3a75
callq 0x380f
jmp 0x3a75
callq 0x3922
movq %rbx, %rax
popq %rbx
retq
movq 0xe56f(%rip), %rdi      # 0x11ff0
leaq 0x77fc(%rip), %rsi      # 0xb284
callq 0x31d0
movq %rax, %rdi
callq 0x3100
pushq $0x4
popq %rdi
callq 0x3110
andl $0x0, (%rax)
movq 0xe4f1(%rip), %rsi      # 0x11f98
movq %rax, %rdi
xorl %edx, %edx
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
leaq 0xe494(%rip), %rdi      # 0x12238
movq %rax, %rsi
callq 0x6198
cmpq $0x0, 0x8(%rax)
je 0x3e05
leaq 0xe47e(%rip), %rdi      # 0x12238
leaq 0x8(%rsp), %rsi
callq 0x6198
movq %rax, %r14
leaq 0x74f7(%rip), %rsi      # 0xb2c5
leaq 0x10(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x615c
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x61e7
leaq 0x10(%rsp), %rdi
callq 0x30f0
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0xe1e4(%rip), %rdi      # 0x11ff0
leaq 0x748c(%rip), %rsi      # 0xb29f
callq 0x31d0
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x3190
movq %rax, %rdi
callq 0x3100
pushq $0x4
popq %rdi
callq 0x3110
andl $0x0, (%rax)
movq 0xe159(%rip), %rsi      # 0x11f98
movq %rax, %rdi
xorl %edx, %edx
callq 0x3360
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/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 0x415b
cmpl $0x2, 0x30(%rbx)
jne 0x415b
addq $0x18, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x416e
movq %rbx, %rdi
callq 0x4170
addq $0x20, %rbx
jmp 0x4158
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rbx
leaq 0xcb1e(%rip), %r15      # 0x12268
leaq 0x5cba(%rip), %rsi      # 0xb40b
movq %r15, %rdi
callq 0x31d0
addq $0x8, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x31c0
leaq 0x5da1(%rip), %rsi      # 0xb510
movq %rax, %rdi
callq 0x31d0
leaq 0x5c96(%rip), %rsi      # 0xb414
movq %r15, %rdi
callq 0x31d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x31c0
leaq 0x5c84(%rip), %rsi      # 0xb41c
movq %rax, %rdi
callq 0x31d0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x31c0
leaq 0x5c06(%rip), %rsi      # 0xb3b8
movq %rax, %rdi
callq 0x31d0
leaq 0x5c68(%rip), %rsi      # 0xb429
movq %r15, %rdi
callq 0x31d0
leaq 0x5c66(%rip), %rsi      # 0xb436
movq %r15, %rdi
callq 0x31d0
movq 0x18(%r14), %r14
movq %r14, %rdi
callq 0x4144
movq %r14, %rax
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x57e4
cmpl $0x1, 0x10(%rax)
jne 0x57fc
cmpl $0x3, 0x30(%rax)
je 0x5847
leaq 0x5c45(%rip), %rsi      # 0xb448
movq %rbx, %rdi
callq 0x62e9
testb %al, %al
je 0x5822
leaq 0xca52(%rip), %rdi      # 0x12268
leaq 0x5c30(%rip), %rsi      # 0xb44d
callq 0x31d0
leaq 0xca3f(%rip), %r14      # 0x12268
leaq 0x5c2d(%rip), %rsi      # 0xb45d
movq %r14, %rdi
callq 0x31d0
leaq 0x5c26(%rip), %rsi      # 0xb465
movq %r14, %rdi
callq 0x31d0
leaq 0xca1a(%rip), %rdi      # 0x12268
leaq 0x5c16(%rip), %rsi      # 0xb46b
callq 0x31d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x31c0
leaq 0x5c07(%rip), %rsi      # 0xb473
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x31c0
leaq 0x5c8a(%rip), %rsi      # 0xb510
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x31d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3e5e
leaq 0xc9bc(%rip), %rdi      # 0x12268
leaq 0x5aff(%rip), %rsi      # 0xb3b2
callq 0x31d0
leaq 0x40(%rsp), %rsi
movq %rax, %rdi
callq 0x31c0
leaq 0x5c44(%rip), %rsi      # 0xb510
movq %rax, %rdi
callq 0x31d0
leaq 0x20(%rsp), %rdi
callq 0x3e5e
leaq 0xc983(%rip), %rdi      # 0x12268
leaq 0x20(%rsp), %rsi
callq 0x31c0
leaq 0x5ac2(%rip), %rsi      # 0xb3b8
movq %rax, %rdi
callq 0x31d0
movq 0x18(%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x4144
leaq 0xc956(%rip), %rdi      # 0x12268
leaq 0x40(%rsp), %rsi
callq 0x31c0
leaq 0x5a95(%rip), %rsi      # 0xb3b8
movq %rax, %rdi
callq 0x31d0
movq 0x18(%rbx), %rsi
movq %rsp, %rdi
callq 0x488e
leaq 0xc92a(%rip), %rdi      # 0x12268
leaq 0x5a3e(%rip), %rsi      # 0xb383
callq 0x31d0
movq %rsp, %rsi
movq %rax, %rdi
callq 0x31c0
leaq 0x5a67(%rip), %rsi      # 0xb3c3
movq %rax, %rdi
callq 0x31d0
movq %rsp, %rsi
movq %rax, %rdi
callq 0x31c0
leaq 0x5b9a(%rip), %rsi      # 0xb510
movq %rax, %rdi
callq 0x31d0
leaq 0xc8e3(%rip), %rdi      # 0x12268
leaq 0x5a16(%rip), %rsi      # 0xb3a2
callq 0x31d0
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x31c0
leaq 0x5b6b(%rip), %rsi      # 0xb510
movq %rax, %rdi
callq 0x31d0
movq %rsp, %rdi
callq 0x30f0
leaq 0x20(%rsp), %rdi
callq 0x30f0
leaq 0x40(%rsp), %rdi
callq 0x30f0
addq $0x60, %rsp
popq %rbx
retq
jmp 0x59d8
jmp 0x59d3
movq %rax, %rbx
jmp 0x59f2
movq %rax, %rbx
jmp 0x59e8
movq %rax, %rbx
movq %rsp, %rdi
callq 0x30f0
leaq 0x20(%rsp), %rdi
callq 0x30f0
leaq 0x40(%rsp), %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/SunriseFox[P]very-simple-c-compiler/./src/asm.cpp
// Function: handleFor(StatementNode*)
void handleFor(StatementNode* node) {
    TreeNode* st1 = node->child;
    TreeNode* st2 = st1->sibling;
    TreeNode* st3 = st2->sibling;
    TreeNode* st4 = st3->sibling;

    handleExprNode(st1);
    string LFor = getNextLabel();
    string LCondition = getNextLabel();
    of << "\tjmp\t" << LCondition << "\n";

    of << LFor << ":\n";
    handleCodeBlock(st4);
    handleExprNode(st3);

    of << LCondition << ":\n";
    string reg = handleExprNode(st2);
    of << "\ttestl\t" << reg << ", " << reg << "\n";
    of << "\tje\t" << LFor << "\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq 0x18(%rdi), %rsi
movq 0x20(%rsi), %rbx
movq 0x20(%rbx), %r14
movq 0x20(%r14), %r15
leaq 0x88(%rsp), %r12
movq %r12, %rdi
callq 0x488e
movq %r12, %rdi
callq 0x30f0
leaq 0x48(%rsp), %rdi
callq 0x3e5e
leaq 0x28(%rsp), %rdi
callq 0x3e5e
leaq 0xc813(%rip), %rdi      # 0x12268
leaq 0x5956(%rip), %rsi      # 0xb3b2
callq 0x31d0
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x31c0
leaq 0x5a9b(%rip), %rsi      # 0xb510
movq %rax, %rdi
callq 0x31d0
leaq 0xc7e4(%rip), %rdi      # 0x12268
leaq 0x48(%rsp), %rsi
callq 0x31c0
leaq 0x5923(%rip), %rsi      # 0xb3b8
movq %rax, %rdi
callq 0x31d0
movq %r15, %rdi
callq 0x4144
leaq 0x68(%rsp), %rdi
movq %r14, %rsi
callq 0x488e
leaq 0x68(%rsp), %rdi
callq 0x30f0
leaq 0xc7a5(%rip), %rdi      # 0x12268
leaq 0x28(%rsp), %rsi
callq 0x31c0
leaq 0x58e4(%rip), %rsi      # 0xb3b8
movq %rax, %rdi
callq 0x31d0
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x488e
leaq 0xc778(%rip), %rdi      # 0x12268
leaq 0x588c(%rip), %rsi      # 0xb383
callq 0x31d0
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x31c0
leaq 0x58b3(%rip), %rsi      # 0xb3c3
movq %rax, %rdi
callq 0x31d0
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x31c0
leaq 0x59e4(%rip), %rsi      # 0xb510
movq %rax, %rdi
callq 0x31d0
leaq 0xc72d(%rip), %rdi      # 0x12268
leaq 0x5860(%rip), %rsi      # 0xb3a2
callq 0x31d0
leaq 0x48(%rsp), %rsi
movq %rax, %rdi
callq 0x31c0
leaq 0x59b5(%rip), %rsi      # 0xb510
movq %rax, %rdi
callq 0x31d0
leaq 0x8(%rsp), %rdi
callq 0x30f0
leaq 0x28(%rsp), %rdi
callq 0x30f0
leaq 0x48(%rsp), %rdi
callq 0x30f0
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x5ba6
movq %rax, %rbx
jmp 0x5bb3
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x30f0
jmp 0x5ba9
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x30f0
leaq 0x48(%rsp), %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6fb6
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
leaq 0x64a2(%rip), %rsi      # 0xd41b
callq 0x3240
testq %rax, %rax
je 0x6f8f
leaq 0xb506(%rip), %rcx      # 0x12490
movq %rax, (%rcx)
jmp 0x6fb6
movq 0xb05a(%rip), %rdi      # 0x11ff0
leaq 0x47b3(%rip), %rsi      # 0xb750
callq 0x31d0
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x3100
pushq $0x18
popq %rdi
callq 0x31e0
movq %rax, %rbx
movq %rax, %rdi
callq 0x98e0
leaq 0xb558(%rip), %rax      # 0x12528
movq %rbx, (%rax)
callq 0x8688
leaq 0xb541(%rip), %rbx      # 0x12520
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x6ff5
movq %rbx, %rdi
callq 0x6b50
addq $0x20, %rbx
jmp 0x6fdf
callq 0x5e1f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x31f0
movq %r14, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
movq %rdi, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x99a2
leaq 0x10(%r12), %rbp
movq %rbp, %r13
movq (%r13), %r13
cmpq %rbp, %r13
je 0x9974
leaq 0x18(%r13), %rdi
movq %r14, %rsi
callq 0x9a94
testb %al, %al
je 0x9985
movq 0x38(%r13), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rcx, (%rsp)
movq (%rdi), %rbx
addq $0x10, %rbx
movq %rbx, %r13
movq (%r13), %r13
cmpq %rbx, %r13
je 0x99f3
leaq 0x18(%r13), %rdi
movq %r15, %rsi
callq 0x9a94
testb %al, %al
je 0x99d8
jmp 0x9a4d
leaq 0x10(%rsp), %r12
movl %ebp, -0x8(%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x32b0
movq %r14, 0x20(%r12)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x9abe
movq %r12, %rdi
callq 0x30f0
leaq 0x8b07(%rip), %rax      # 0x12530
cmpq $0x0, (%rax)
je 0x9a4d
leaq 0x8b0a(%rip), %rdi      # 0x12540
leaq 0x8af3(%rip), %rsi      # 0x12530
callq 0x9aca
movq %rsp, %rsi
movq %rax, %rdi
callq 0x9b1a
cmpq %rbx, %r13
sete %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x10, %rsp
movq %rdi, %rbx
movl (%rsi), %eax
cmpq $0x6, %rax
ja 0xa1b8
leaq 0x3285(%rip), %rcx      # 0xd3fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x32a1(%rip), %rsi      # 0xd428
leaq 0xc(%rsp), %rdx
jmp 0xa1ee
leaq 0x3298(%rip), %rsi      # 0xd42d
leaq 0xa(%rsp), %rdx
jmp 0xa1ee
leaq 0x3281(%rip), %rsi      # 0xd424
leaq 0xd(%rsp), %rdx
jmp 0xa1ee
leaq 0x326c(%rip), %rsi      # 0xd41d
leaq 0xe(%rsp), %rdx
jmp 0xa1ee
leaq 0x327a(%rip), %rsi      # 0xd439
leaq 0x8(%rsp), %rdx
jmp 0xa1ee
leaq 0x3267(%rip), %rsi      # 0xd434
leaq 0x9(%rsp), %rdx
jmp 0xa1ee
leaq 0x323d(%rip), %rsi      # 0xd418
leaq 0xf(%rsp), %rdx
jmp 0xa1ee
leaq 0x31b2(%rip), %rsi      # 0xd39b
leaq 0xb(%rsp), %rdx
movq %rbx, %rdi
callq 0x615c
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa3e3
cmpl $0x1, 0x10(%rsi)
jne 0xa3af
cmpl $0x1, 0x30(%rsi)
je 0xa3e3
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0xa3d3
movq 0x20(%rcx), %rax
testq %rax, %rax
je 0xa3d9
movq %rax, %rdi
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0xa3c1
addq $0x20, %rdi
jmp 0xa3e0
addq $0x18, %rdi
jmp 0xa3e0
addq $0x20, %rcx
movq %rcx, %rdi
movq %rsi, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15d
movq %rcx, %r12
movl %edx, %ebp
movq %rdi, %r14
movl %esi, 0xc(%rdi)
movl $0x3, 0x10(%rdi)
movl 0x7cff(%rip), %eax      # 0x1221c
leal 0x1(%rax), %ecx
movl %ecx, 0x7cf6(%rip)      # 0x1221c
movl %eax, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
leaq 0x7729(%rip), %rax      # 0x11c60
movq %rax, (%rdi)
pushq $0x30
popq %rdi
callq 0x31e0
movq %rax, %rbx
testl %r15d, %r15d
je 0xa569
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x32b0
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0xa224
jmp 0xa584
movq %rsp, %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x32b0
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0xa276
movq %rbx, 0x28(%r14)
movq %r15, %rdi
callq 0x30f0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rsp, %rdi
jmp 0xa5ad
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x30f0
jmp 0xa5b9
jmp 0xa5b6
movq %rax, %r14
pushq $0x30
popq %rsi
movq %rbx, %rdi
callq 0x31f0
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/sykeben[P]overos/cmd/hello.cpp
// Function: main
int main(int argc, char** argv) {
	cout << "Hello, World! I'm gonna test arguments now!" << _TERM;
	cout << "Arguments used with \"" << argv[0] << "\":" << _TERM;
  for (int n = 1; n < argc; n++)
    cout << setw(2) << n << ": " << argv[n] << _TERM;
  return 0;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r12d
movq 0x2e01(%rip), %r14      # 0x3fd8
leaq 0xe26(%rip), %rsi       # 0x2004
movq %r14, %rdi
callq 0x1040
pushq $0xa
popq %r15
movq %rax, %rdi
movl %r15d, %esi
callq 0x1050
leaq 0xe34(%rip), %rsi       # 0x2030
movq %r14, %rdi
callq 0x1040
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x1040
leaq 0xe30(%rip), %rsi       # 0x2046
movq %rax, %rdi
callq 0x1040
movq %rax, %rdi
movl %r15d, %esi
callq 0x1050
movslq %r12d, %r15
pushq $0x1
popq %r12
leaq 0xe12(%rip), %r13       # 0x2049
cmpq %r15, %r12
jge 0x127e
movq (%r14), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x10(%r14,%rax)
movq %r14, %rdi
movl %r12d, %esi
callq 0x1070
movq %rax, %rdi
movq %r13, %rsi
callq 0x1040
movq (%rbx,%r12,8), %rsi
movq %rax, %rdi
callq 0x1040
movq %rax, %rdi
pushq $0xa
popq %rsi
callq 0x1050
incq %r12
jmp 0x1237
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9c9b(%rip), %rdi      # 0xc208
movq %rbx, %rsi
callq 0x64aa
leaq 0x9c94(%rip), %rcx      # 0xc210
cmpq %rcx, %rax
je 0x2587
addq $0x40, %rax
jmp 0x25df
pushq $0x20
popq %rdi
callq 0x21f0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x22a0
leaq 0x9c64(%rip), %r15      # 0xc208
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5b9e
movq %r14, (%rax)
movl 0x9c78(%rip), %ebp      # 0xc230
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5b9e
leaq 0x9c6e(%rip), %rdi      # 0xc238
movq %rax, %rsi
callq 0x5c04
movl %ebp, (%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5b9e
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x2200
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movq %rsp, %rsi
movq %rdi, (%rsi)
leaq 0x9c27(%rip), %rdi      # 0xc238
callq 0x6b24
leaq 0x9c23(%rip), %rcx      # 0xc240
cmpq %rcx, %rax
je 0x2627
movl 0x28(%rax), %eax
popq %rcx
retq
movq 0x99c2(%rip), %rdi      # 0xbff0
leaq 0x5a6f(%rip), %rsi      # 0x80a4
callq 0x21e0
pushq $0x34
popq %rsi
movq %rax, %rdi
callq 0x2340
leaq 0x5a6d(%rip), %rsi      # 0x80b9
movq %rax, %rdi
callq 0x21e0
movq (%rsp), %rsi
movq %rax, %rdi
callq 0x21c0
leaq 0x5a65(%rip), %rsi      # 0x80cc
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
callq 0x20e0
pushq $0x2
popq %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/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 0x27c8
movl (%rdi), %ecx
testl %ecx, %ecx
je 0x27d8
movl %ecx, 0x4(%rsp)
fildl 0x4(%rsp)
fldt 0x20(%rax)
fld %st(0)
fadds 0x5877(%rip)            # 0x8004
fldz
fxch %st(3)
fucomi %st(1), %st
fstp %st(1)
ja 0x27c2
fstp %st(2)
fldt 0x10(%rax)
fldl 0x586e(%rip)            # 0x8010
fucompi %st(1), %st
ja 0x27e8
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 0x9821(%rip), %rdi      # 0xbff0
leaq 0x5a1d(%rip), %rsi      # 0x81f3
jmp 0x27fc
movq 0x9811(%rip), %rdi      # 0xbff0
leaq 0x5a62(%rip), %rsi      # 0x8248
jmp 0x27fc
fstp %st(2)
fstp %st(0)
fstp %st(0)
movq 0x97fb(%rip), %rdi      # 0xbff0
leaq 0x5a99(%rip), %rsi      # 0x8295
callq 0x21e0
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
callq 0x20e0
pushq $0x1
popq %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2839
movl (%rdi), %ecx
testl %ecx, %ecx
je 0x2849
movl %ecx, 0x4(%rsp)
fldt (%rsi)
fldt (%rax)
fmulp %st, %st(1)
fidivl 0x4(%rsp)
popq %rax
retq
movq 0x97b0(%rip), %rdi      # 0xbff0
leaq 0x5aa2(%rip), %rsi      # 0x82e9
jmp 0x2857
movq 0x97a0(%rip), %rdi      # 0xbff0
leaq 0x5ae0(%rip), %rsi      # 0x8337
callq 0x21e0
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
callq 0x20e0
pushq $0x1
popq %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/Altius[P]hotspot2/src/hotspot2_part1.cpp
// Function: BackgroundRegionManager::BackgroundRegionManager(int const&, int const&)
BackgroundRegionManager::BackgroundRegionManager(const int& samplingInterval, const int& MAlength)
{
  m_posL = m_posC = m_posR = -1;
  m_runningSum_count = m_runningSum_countSquared
    = m_runningSum_count_duringPrevComputation = m_runningSum_countSquared_duringPrevComputation = 0;
  m_numPtsInNullRegion = m_numPtsInNullRegion_duringPrevComputation = 0;
  m_kcutoff = m_modeYval = m_modeXval = -1;
  m_MAlength = MAlength; // see explanation in findCutoff(); 5 is good when samplingInterval = 1, 15 is good when windowSize/samplingInterval ~= 250
  m_thresholdRatio = 1.33; // see explanation in findCutoff(); could instead try 1.4. 1.5 seems to be too high, 1.2 seems to be too low.
  m_sliding = false;
  m_needToUpdate_kcutoff = true;

  m_samplingInterval = samplingInterval;
  m_nextPosToSample = -1;
  m_sampledDataDistnSize = 0;

  m_minMAxN = m_kTrendReversal = -1;
  m_prev_k = -1;
  m_pmf = NULL;
  m_pCurChrom = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rdi)
andq $0x0, 0x60(%rdi)
leaq 0x68(%rdi), %r12
movq %r12, %rdi
callq 0x5fca
leaq 0xb8(%rbx), %rdi
callq 0x5fca
leaq 0x128(%rbx), %rax
andl $0x0, 0x128(%rbx)
andq $0x0, 0x130(%rbx)
movq %rax, 0x138(%rbx)
movq %rax, 0x140(%rbx)
andq $0x0, 0x148(%rbx)
xorps %xmm0, %xmm0
andq $0x0, 0x180(%rbx)
movaps %xmm0, 0x170(%rbx)
orl $-0x1, 0x8(%rbx)
orq $-0x1, (%rbx)
andl $0x0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
andl $0x0, 0x38(%rbx)
movups %xmm0, 0x28(%rbx)
orq $-0x1, 0x108(%rbx)
orl $-0x1, 0x110(%rbx)
movl (%r15), %eax
movl %eax, 0x3c(%rbx)
fldl 0x54da(%rip)            # 0x8018
fstpt 0x40(%rbx)
movw $0x100, 0x118(%rbx)     # imm = 0x100
movl (%r14), %eax
movl %eax, 0x158(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x15c(%rbx)
orl $-0x1, 0x114(%rbx)
orq $-0x1, 0x150(%rbx)
andq $0x0, 0x168(%rbx)
andq $0x0, 0x188(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r12, %rdi
callq 0x6e60
jmp 0x2b9a
movq %rax, %r14
addq $0x50, %rbx
movq %rbx, %rdi
callq 0x6e2c
movq %r14, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2bdf
movq %rsi, 0x188(%rdi)
movl %ebp, (%rdi)
movl %ebx, 0x4(%rdi)
pushq $0x2
popq %rcx
cltd
idivl %ecx
addl %ebp, %eax
movl %eax, 0x8(%rdi)
movl %ebp, 0x15c(%rdi)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x940a(%rip), %rdi      # 0xbff0
leaq 0x57d7(%rip), %rsi      # 0x83c4
callq 0x21e0
movq %rax, %rdi
movl %ebp, %esi
callq 0x2340
leaq 0x57ff(%rip), %rsi      # 0x8402
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
movl %ebx, %esi
callq 0x2340
leaq 0x57f3(%rip), %rsi      # 0x840f
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
callq 0x20e0
pushq $0x1
popq %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2346
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x2050
movl %eax, (%r14)
testl %eax, %eax
js 0x23b7
movq (%r15), %rdi
callq 0x2130
movq (%r15), %rdi
cmpl $-0x1, %eax
je 0x238f
callq 0x2130
movl %eax, 0x8(%r14)
leaq 0x4(%r14), %rsi
movw $0x2, 0x4(%r14)
rolw $0x8, %bx
movw %bx, 0x6(%r14)
movl (%r14), %edi
pushq $0x10
popq %rdx
callq 0x20e0
movl %eax, %ecx
movb $0x1, %al
testl %ecx, %ecx
jns 0x23c5
leaq 0xcac(%rip), %rdi       # 0x3039
jmp 0x23be
callq 0x2140
testq %rax, %rax
je 0x23a9
movq 0x18(%rax), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x235f
movl (%rax), %eax
jmp 0x235b
leaq 0xc6d(%rip), %rdi       # 0x301d
callq 0x2150
jmp 0x23c3
leaq 0xc46(%rip), %rdi       # 0x3004
callq 0x20f0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x20a0
movq %rax, %rbx
testq %rax, %rax
js 0x23f0
testq %rbx, %rbx
setns %al
popq %rbx
retq
leaq 0xc52(%rip), %rdi       # 0x3049
callq 0x20f0
jmp 0x23e8
// File: /workspace/github_cpp_makefile_star2_O2/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, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xcaa(%rip), %rsi       # 0x30c5
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2526
movslq %ebp, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x20b0
leal -0x1(%r15), %eax
movslq %eax, %r13
leaq 0x8(%rsp), %rbp
movl (%r14), %edi
movq %r12, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x2060
testl %eax, %eax
jle 0x247f
movq %rbp, %rdi
movq %r12, %rsi
callq 0x21b0
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x20b0
jmp 0x2451
js 0x24f1
movq %r12, %rdi
callq 0x2160
movl (%r14), %edi
callq 0x21c0
orl $-0x1, (%r14)
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0x24b8
movq %rdx, (%rbx)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x24be
movups (%rax), %xmm0
movups %xmm0, (%rcx)
leaq 0x10(%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x8(%rbx)
movq %rax, -0x8(%rcx)
andq $0x0, (%rcx)
movb $0x0, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x2080
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb5e(%rip), %rdi       # 0x3056
callq 0x20f0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rcx
addq $0x8, %rcx
jmp 0x24ce
jmp 0x2511
jmp 0x2511
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O2/TheiaRT[P]libiris/sampleclient.cpp
// Function: main
int main() {
    std::string input;
    TCPClient client;
    while (getline(std::cin, input)) {
        if (client.connect("localhost", 8000) == false) {
            std::cerr << "Could not connect :(" << std::endl;
            return 1;
        }
        if (client.send_data(input) == false) {
            std::cerr << "Could not send data :(" << std::endl;
            return 2;
        }
        std::cout << client.receive() << std::endl;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x24(%rsp), %rdi
callq 0x231c
movq %rsp, %r14
leaq 0x78(%rsp), %r12
leaq 0x38(%rsp), %r13
leaq 0x24(%rsp), %rbp
leaq 0x58(%rsp), %r15
movq 0x2996(%rip), %rdi      # 0x4fd8
movq %r14, %rsi
callq 0x2040
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x26e9
movq %r12, %rdi
leaq 0xa2a(%rip), %rsi       # 0x3090
movq %r13, %rdx
callq 0x2526
movq %rbp, %rdi
movq %r12, %rsi
movl $0x1f40, %edx           # imm = 0x1F40
callq 0x2320
movl %eax, %ebx
movq %r12, %rdi
callq 0x2080
testb %bl, %bl
je 0x26ed
movq %r15, %rdi
movq %r14, %rsi
callq 0x2170
movq %rbp, %rdi
movq %r15, %rsi
movl $0x200, %edx            # imm = 0x200
callq 0x23cc
movl %eax, %ebx
movq %r15, %rdi
callq 0x2080
testb %bl, %bl
je 0x270c
movq %r13, %rdi
movq %rbp, %rsi
movl $0x200, %edx            # imm = 0x200
callq 0x23fe
movq 0x28fc(%rip), %rdi      # 0x4fc8
movq %r13, %rsi
callq 0x2110
movq %rax, %rdi
callq 0x2090
movq %r13, %rdi
callq 0x2080
jmp 0x263b
xorl %ebx, %ebx
jmp 0x272a
movq 0x28fc(%rip), %rdi      # 0x4ff0
leaq 0x99f(%rip), %rsi       # 0x309a
callq 0x2120
movq %rax, %rdi
callq 0x2090
pushq $0x1
jmp 0x2729
movq 0x28dd(%rip), %rdi      # 0x4ff0
leaq 0x995(%rip), %rsi       # 0x30af
callq 0x2120
movq %rax, %rdi
callq 0x2090
pushq $0x2
popq %rbx
movq %rsp, %rdi
callq 0x2080
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x276f
jmp 0x276f
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
jmp 0x2768
jmp 0x276f
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
jmp 0x2768
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x2080
jmp 0x2772
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O2/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 0x48f7(%rip), %rax      # 0x5fc8
movq (%rax), %rdi
leaq 0x1995(%rip), %rsi      # 0x3070
leaq 0x1b3d(%rip), %rdx      # 0x321f
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x11f0
movl 0x4a67(%rip), %eax      # 0x6158
movq %rsp, %r13
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
subq %rcx, %r13
movq %r13, %rsp
leaq 0x337(%rip), %r14       # 0x1a44
movq %r13, %r15
movslq %eax, %rcx
cmpq %rcx, %rbx
jge 0x1747
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 0x1795
incq %rbx
movl 0x4a17(%rip), %eax      # 0x6158
addq $0x8, %r15
jmp 0x1710
xorl %ebx, %ebx
cltq
cmpq %rax, %rbx
jge 0x1767
movq (%r13,%rbx,8), %rdi
xorl %esi, %esi
callq 0x1140
incq %rbx
movl 0x49f3(%rip), %eax      # 0x6158
jmp 0x1749
movq 0x485a(%rip), %rax      # 0x5fc8
movq (%rax), %rdi
leaq 0x191c(%rip), %rsi      # 0x3094
leaq 0x1aa0(%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 0x482c(%rip), %rax      # 0x5fc8
movq (%rax), %rdi
leaq 0x1a92(%rip), %rsi      # 0x3238
leaq 0x1a72(%rip), %rdx      # 0x321f
movl %ebx, %ecx
xorl %eax, %eax
callq 0x11f0
pushq $0x1
popq %rdi
callq 0x11a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x181d
callq 0x10c0
movl $0xbb8, %ecx            # imm = 0xBB8
cqto
idivq %rcx
movl %edx, 0x10(%r12)
movl $0x7530, %ecx           # imm = 0x7530
movl %ebp, %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1c30
cmpq %r15, %rax
jne 0x184a
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11c0
movq 0x4777(%rip), %rax      # 0x5fc8
movq (%rax), %rdi
leaq 0x1877(%rip), %rsi      # 0x30d2
movq %rbx, %rdx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x11f0
pushq $0x1
popq %rdi
callq 0x11a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1e04
cmpq %r12, %rax
jne 0x18b7
movq %r15, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x11c0
movq 0x470a(%rip), %rax      # 0x5fc8
movq (%rax), %rdi
leaq 0x1836(%rip), %rsi      # 0x30fe
movq %r14, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x11f0
pushq $0x1
popq %rdi
callq 0x11a0