LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/eniac[P]Mantis/src/compile/find_nodes.cpp
// Function: findIngress(std::vector<AstNode*, std::allocator<AstNode*>> const&)
P4ExprNode* findIngress(const std::vector<AstNode*>& astNodes) {
    for (auto node : astNodes) {
        if (typeContains(node, "P4ExprNode")) {
            P4ExprNode* exprNode = dynamic_cast<P4ExprNode*>(node);
            // Might be called after ing transformation
            if (exprNode->name1_->toString().find("ingress") != string::npos || exprNode->name1_->toString().find(string(kOrigIngControlName)) != string::npos) {
                return exprNode;
            }
        }
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq (%rdi), %rbx
movq 0x8(%rdi), %r12
cmpq %r12, %rbx
je 0x6f594
leaq 0xae1d(%rip), %r15      # 0x7a299
movq (%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x6f390
movb $0x1, %r13b
testb %al, %al
je 0x6f582
movq %r14, %rdi
leaq 0x1d191(%rip), %rsi     # 0x8c630
leaq 0x1d912(%rip), %rdx     # 0x8cdb8
xorl %ecx, %ecx
callq 0x2e430
movq %rax, %r15
movq 0x48(%rax), %rsi
movq (%rsi), %rax
leaq -0x90(%rbp), %r14
movq %r14, %rdi
callq *(%rax)
movl $0x7, %ecx
movq %r14, %rdi
leaq 0xadd2(%rip), %rsi      # 0x7a2a4
xorl %edx, %edx
callq 0x2e710
movq %rax, %r14
cmpq $-0x1, %rax
jne 0x6f529
movq 0x48(%r15), %rsi
movq (%rsi), %rax
leaq -0x70(%rbp), %rdi
callq *(%rax)
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0xa4b7(%rip), %rsi      # 0x799b9
leaq 0xa4bf(%rip), %rdx      # 0x799c8
callq 0x33112
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rcx
leaq -0x70(%rbp), %rdi
xorl %edx, %edx
callq 0x2e710
cmpq $-0x1, %rax
setne %r13b
cmpq $-0x1, %r14
jne 0x6f553
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x6f541
callq 0x2e360
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x6f553
callq 0x2e360
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x6f568
callq 0x2e360
testb %r13b, %r13b
movq -0x30(%rbp), %rax
cmovneq %r15, %rax
movq %rax, -0x30(%rbp)
xorb $0x1, %r13b
leaq 0xad17(%rip), %r15      # 0x7a299
testb %r13b, %r13b
je 0x6f598
addq $0x8, %rbx
cmpq %r12, %rbx
jne 0x6f47c
xorl %eax, %eax
jmp 0x6f59c
movq -0x30(%rbp), %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x6f5c5
movq %rax, %rbx
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x6f5c5
callq 0x2e360
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x6f5da
callq 0x2e360
movq %rbx, %rdi
callq 0x2e730
// File: /workspace/github_cpp_makefile_star2_O1/eniac[P]Mantis/src/compile/find_nodes.cpp
// Function: findEgress(std::vector<AstNode*, std::allocator<AstNode*>> const&)
P4ExprNode* findEgress(const std::vector<AstNode*>& astNodes) {
    for (auto node : astNodes) {
        if (typeContains(node, "P4ExprNode")) {
            P4ExprNode* exprNode = dynamic_cast<P4ExprNode*>(node);
            if (exprNode->name1_->toString().find("egress") != string::npos || exprNode->name1_->toString().find(string(kOrigEgrControlName)) != string::npos) {
                return exprNode;
            }
        }
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq (%rdi), %rbx
movq 0x8(%rdi), %r12
cmpq %r12, %rbx
je 0x6f722
leaq 0xac8f(%rip), %r15      # 0x7a299
movq (%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x6f390
movb $0x1, %r13b
testb %al, %al
je 0x6f710
movq %r14, %rdi
leaq 0x1d003(%rip), %rsi     # 0x8c630
leaq 0x1d784(%rip), %rdx     # 0x8cdb8
xorl %ecx, %ecx
callq 0x2e430
movq %rax, %r15
movq 0x48(%rax), %rsi
movq (%rsi), %rax
leaq -0x90(%rbp), %r14
movq %r14, %rdi
callq *(%rax)
movl $0x6, %ecx
movq %r14, %rdi
leaq 0xac4c(%rip), %rsi      # 0x7a2ac
xorl %edx, %edx
callq 0x2e710
movq %rax, %r14
cmpq $-0x1, %rax
jne 0x6f6b7
movq 0x48(%r15), %rsi
movq (%rsi), %rax
leaq -0x70(%rbp), %rdi
callq *(%rax)
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0xa3ed(%rip), %rsi      # 0x79a7d
leaq 0xa3f4(%rip), %rdx      # 0x79a8b
callq 0x33112
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rcx
leaq -0x70(%rbp), %rdi
xorl %edx, %edx
callq 0x2e710
cmpq $-0x1, %rax
setne %r13b
cmpq $-0x1, %r14
jne 0x6f6e1
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x6f6cf
callq 0x2e360
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x6f6e1
callq 0x2e360
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x6f6f6
callq 0x2e360
testb %r13b, %r13b
movq -0x30(%rbp), %rax
cmovneq %r15, %rax
movq %rax, -0x30(%rbp)
xorb $0x1, %r13b
leaq 0xab89(%rip), %r15      # 0x7a299
testb %r13b, %r13b
je 0x6f726
addq $0x8, %rbx
cmpq %r12, %rbx
jne 0x6f60a
xorl %eax, %eax
jmp 0x6f72a
movq -0x30(%rbp), %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x6f753
movq %rax, %rbx
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x6f753
callq 0x2e360
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x6f768
callq 0x2e360
movq %rbx, %rdi
callq 0x2e730
// File: /workspace/github_cpp_makefile_star2_O1/eniac[P]Mantis/src/compile/find_nodes.cpp
// Function: findBlackbox(std::vector<AstNode*, std::allocator<AstNode*>> const&)
vector<P4ExprNode*> findBlackbox(const std::vector<AstNode*>& astNodes) {
    vector<P4ExprNode*> ret;
    for (auto node : astNodes) {
        if (typeContains(node, "P4ExprNode")) {
            P4ExprNode* exprNode = dynamic_cast<P4ExprNode*>(node);
            if (exprNode->keyword_->toString().find("blackbox") != string::npos) {
                ret.push_back(exprNode);
            }
        }
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r15
movq 0x8(%rsi), %r14
cmpq %r14, %r15
je 0x6f846
leaq -0x50(%rbp), %r13
movq (%r15), %r12
movq %r12, %rdi
leaq 0xaae6(%rip), %rsi      # 0x7a299
callq 0x6f390
testb %al, %al
je 0x6f839
movq %r12, %rdi
leaq 0x1ce6a(%rip), %rsi     # 0x8c630
leaq 0x1d5eb(%rip), %rdx     # 0x8cdb8
xorl %ecx, %ecx
callq 0x2e430
movq %rax, -0x30(%rbp)
movq 0x40(%rax), %rsi
movq (%rsi), %rax
movq %r13, %rdi
callq *(%rax)
movl $0x8, %ecx
movq %r13, %rdi
leaq 0xa4c7(%rip), %rsi      # 0x79cba
xorl %edx, %edx
callq 0x2e710
movq %rax, %r12
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x6f80f
callq 0x2e360
cmpq $-0x1, %r12
je 0x6f839
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6f82d
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x6f839
movq %rbx, %rdi
leaq -0x30(%rbp), %rdx
callq 0x714e8
addq $0x8, %r15
cmpq %r14, %r15
jne 0x6f7a6
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6f85c
jmp 0x6f85c
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6f86c
callq 0x2e360
movq %r14, %rdi
callq 0x2e730
// File: /workspace/github_cpp_makefile_star2_O1/eniac[P]Mantis/src/compile/find_nodes.cpp
// Function: findMalleableRefs(std::vector<MblRefNode*, std::allocator<MblRefNode*>>*, std::vector<AstNode*, std::allocator<AstNode*>> const&)
void findMalleableRefs(vector<MblRefNode*>* varRefs,
                      const vector<AstNode*>& astNodes) {
    for (AstNode* node : astNodes) {
        if (typeContains(node, "MblRefNode")) {
            MblRefNode* varRef = dynamic_cast<MblRefNode*>(node);
            varRefs->push_back(varRef);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %r12
movq 0x8(%rsi), %r13
cmpq %r13, %r12
je 0x6fa42
movq %rdi, %rbx
leaq 0x642f(%rip), %r14      # 0x75e10
movq (%r12), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6f390
testb %al, %al
je 0x6fa39
testq %r15, %r15
je 0x6fa13
movq %r15, %rdi
leaq 0x1cc2d(%rip), %rsi     # 0x8c630
leaq 0x1da6e(%rip), %rdx     # 0x8d478
xorl %ecx, %ecx
callq 0x2e430
jmp 0x6fa15
xorl %eax, %eax
movq %rax, -0x30(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6fa2d
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x6fa39
movq %rbx, %rdi
leaq -0x30(%rbp), %rdx
callq 0x720ec
addq $0x8, %r12
cmpq %r13, %r12
jne 0x6f9e1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/eniac[P]Mantis/src/compile/find_nodes.cpp
// Function: findTableActionStmts(std::vector<AstNode*, std::allocator<AstNode*>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
unordered_map<TableActionStmtNode*, TableNode*> findTableActionStmts(
            const vector<AstNode*>& astNodes, const string& actionName) {
    auto ret = unordered_map<TableActionStmtNode*, TableNode*>();

    for (auto node : astNodes) {
        if (typeContains(node, "TableNode") && !typeContains(node, "P4R")) {
            TableNode* table = dynamic_cast<TableNode*>(node);
            TableActionStmtsNode* actions = table->actions_;
            for (TableActionStmtNode* tas : *actions->list_) {
                if (*tas->name_->word_ == actionName) {
                    ret.emplace(tas, table);
                    break;
                }
            }
        }
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x30(%rdi)
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
movq %rdi, -0x30(%rbp)
movups %xmm0, 0x28(%rdi)
movq (%rsi), %r13
movq 0x8(%rsi), %rbx
cmpq %rbx, %r13
je 0x6fb8b
movq %rdx, %r14
leaq 0x8141(%rip), %r12      # 0x77bf1
movq %rbx, -0x38(%rbp)
movq (%r13), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x6f390
testb %al, %al
je 0x6fb7e
movq %r15, %rdi
leaq 0x7df5(%rip), %rsi      # 0x778ca
callq 0x6f390
testb %al, %al
jne 0x6fb7e
movq %r15, %rdi
leaq 0x1cb44(%rip), %rsi     # 0x8c630
leaq 0x1d355(%rip), %rdx     # 0x8ce48
xorl %ecx, %ecx
callq 0x2e430
movq %rax, -0x48(%rbp)
movq 0x50(%rax), %rax
movq 0x40(%rax), %rax
movq (%rax), %r15
movq 0x8(%rax), %r12
cmpq %r12, %r15
je 0x6fb73
movq (%r15), %rax
movq %rax, -0x40(%rbp)
movq 0x40(%rax), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdx
cmpq 0x8(%r14), %rdx
jne 0x6fb42
testq %rdx, %rdx
je 0x6fb46
movq (%r14), %rsi
movq (%rax), %rdi
callq 0x2e3c0
testl %eax, %eax
sete %bl
jmp 0x6fb48
xorl %ebx, %ebx
jmp 0x6fb48
movb $0x1, %bl
testb %bl, %bl
je 0x6fb6d
movq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x721c2
addq $0x8, %r15
cmpq %r12, %r15
sete %al
orb %al, %bl
je 0x6fb12
jmp 0x6fb73
addq $0x8, %r15
jmp 0x6fb0d
movq -0x38(%rbp), %rbx
leaq 0x8073(%rip), %r12      # 0x77bf1
addq $0x8, %r13
cmpq %rbx, %r13
jne 0x6fab4
movq -0x30(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6fba0
movq %rax, %r14
movq -0x30(%rbp), %rdi
callq 0x6e8ee
movq %r14, %rdi
callq 0x2e730
// File: /workspace/github_cpp_makefile_star2_O1/eniac[P]Mantis/src/compile/find_nodes.cpp
// Function: findTableReadStmt(TableNode const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool findTableReadStmt(const TableNode& table, const string& fieldName) {
    TableReadStmtsNode* reads = table.reads_;
    for (TableReadStmtNode* trs : *reads->list_) {
        if (typeContains(trs->field_, "StrNode")) {
            StrNode* sn = dynamic_cast<StrNode*>(trs->field_);
            if (*sn->word_ == fieldName) {
                return true;
            }
        }
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x48(%rdi), %rax
movq 0x40(%rax), %rax
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
setne %r14b
je 0x6fc3d
movq %rsi, %rbx
movq (%r12), %r15
movq 0x40(%r15), %rdi
leaq 0xa6d8(%rip), %rsi      # 0x7a2c4
callq 0x6f390
testb %al, %al
je 0x6fc30
movq 0x40(%r15), %rdi
leaq 0x1ca30(%rip), %rsi     # 0x8c630
leaq 0x1ce39(%rip), %rdx     # 0x8ca40
xorl %ecx, %ecx
callq 0x2e430
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x6fc30
testq %rdx, %rdx
je 0x6fc3d
movq (%rbx), %rsi
movq (%rax), %rdi
callq 0x2e3c0
testl %eax, %eax
je 0x6fc3d
addq $0x8, %r12
cmpq %r13, %r12
setne %r14b
jne 0x6fbdd
andb $0x1, %r14b
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/eniac[P]Mantis/src/compile/find_nodes.cpp
// Function: findAndTransformMblRefsInAction(ActionNode*, std::vector<MblRefNode*, std::allocator<MblRefNode*>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void findAndTransformMblRefsInAction(ActionNode* action,
                                     vector<MblRefNode*>* varRefs,
                                     const string& varName,
                                     const string& altHeader,
                                     const string& altField) {

    for (ActionStmtNode* as : *action->stmts_->list_) {
        for (BodyWordNode* bw : *as->args_->list_) {
            if (bw->wordType_ != BodyWordNode::VARREF) {
                continue;
            }

            auto varRef = dynamic_cast<MblRefNode*>(bw->contents_);
            if (*varRef->name_->word_ == varName) {
                varRef->transform(altHeader, altField);
            } else if (varRefs && !varRef->transformed_) {
                varRefs->push_back(dynamic_cast<MblRefNode*>(bw->contents_));
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, -0x50(%rbp)
movq %rcx, -0x48(%rbp)
movq %rdx, -0x30(%rbp)
movq 0x50(%rdi), %rax
movq 0x40(%rax), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq %rax, %rcx
je 0x6fd9a
movq %rsi, %r12
movq %rcx, -0x40(%rbp)
movq (%rcx), %rax
movq 0x58(%rax), %rax
movq 0x40(%rax), %rax
movq (%rax), %rbx
movq 0x8(%rax), %r15
cmpq %r15, %rbx
je 0x6fd88
movq (%rbx), %rax
cmpl $0x0, 0x3c(%rax)
je 0x6fcbd
addq $0x8, %rbx
jmp 0x6fca5
movq 0x40(%rax), %r14
testq %r14, %r14
je 0x6fce3
movq %r14, %rdi
leaq 0x1c960(%rip), %rsi     # 0x8c630
leaq 0x1d7a1(%rip), %rdx     # 0x8d478
xorl %ecx, %ecx
callq 0x2e430
movq %rax, %r13
jmp 0x6fce6
xorl %r13d, %r13d
movq 0x80(%r13), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdx
movq -0x30(%rbp), %rcx
cmpq 0x8(%rcx), %rdx
jne 0x6fd17
testq %rdx, %rdx
je 0x6fd42
movq -0x30(%rbp), %rcx
movq (%rcx), %rsi
movq (%rax), %rdi
callq 0x2e3c0
testl %eax, %eax
je 0x6fd42
testq %r12, %r12
je 0x6fcb7
cmpb $0x0, 0x39(%r13)
jne 0x6fcb7
testq %r14, %r14
je 0x6fd57
movq %r14, %rdi
leaq 0x1c8fe(%rip), %rsi     # 0x8c630
leaq 0x1d73f(%rip), %rdx     # 0x8d478
xorl %ecx, %ecx
callq 0x2e430
jmp 0x6fd59
movq %r13, %rdi
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x3e2fe
jmp 0x6fcb7
xorl %eax, %eax
movq %rax, -0x58(%rbp)
movq 0x8(%r12), %rsi
cmpq 0x10(%r12), %rsi
je 0x6fd77
movq %rax, (%rsi)
addq $0x8, 0x8(%r12)
jmp 0x6fcb7
movq %r12, %rdi
leaq -0x58(%rbp), %rdx
callq 0x6ec86
jmp 0x6fcb7
movq -0x40(%rbp), %rcx
addq $0x8, %rcx
cmpq -0x38(%rbp), %rcx
jne 0x6fc8f
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/eniac[P]Mantis/src/compile/find_nodes.cpp
// Function: findInitBlock(std::vector<AstNode*, std::allocator<AstNode*>>)
P4RInitBlockNode* findInitBlock(std::vector<AstNode*> astNodes){
    // Currently get a single node, easily generalize to multiple distributed init/reaction block
	for (auto node : astNodes) {
		if (node->nodeType_.find(string("InitBlockNode")) != string::npos) {
			P4RInitBlockNode * iNode = dynamic_cast<P4RInitBlockNode *>(node);
			return iNode;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %r14
movq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0x6fe78
leaq -0x40(%rbp), %r12
movq (%r14), %r13
movq %r12, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0xa4b2(%rip), %rsi      # 0x7a2b6
leaq 0xa4b8(%rip), %rdx      # 0x7a2c3
callq 0x33112
leaq 0x10(%r13), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rcx
xorl %edx, %edx
callq 0x2e710
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x6fe34
callq 0x2e360
cmpq $-0x1, %rbx
je 0x6fe65
testq %r13, %r13
je 0x6fe5d
movq %r13, %rdi
leaq 0x1c7e7(%rip), %rsi     # 0x8c630
leaq 0x1d5c8(%rip), %rdx     # 0x8d418
xorl %ecx, %ecx
callq 0x2e430
movq %rax, -0x30(%rbp)
jmp 0x6fe65
movq $0x0, -0x30(%rbp)
cmpq $-0x1, %rbx
jne 0x6fe7c
addq $0x8, %r14
cmpq %r15, %r14
jne 0x6fdf2
xorl %eax, %eax
jmp 0x6fe80
movq -0x30(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/eniac[P]Mantis/src/compile/find_nodes.cpp
// Function: findReaction(std::vector<AstNode*, std::allocator<AstNode*>>)
P4RReactionNode* findReaction(std::vector<AstNode*> astNodes){
	for (auto node : astNodes) {
		if (node->nodeType_.find(string("ReactionNode")) != string::npos) {
			P4RReactionNode * reactionNode = dynamic_cast<P4RReactionNode *>(node);
			return reactionNode;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %r14
movq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0x6ff3a
leaq -0x40(%rbp), %r12
movq (%r14), %r13
movq %r12, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x9c4f(%rip), %rsi      # 0x79b15
leaq 0x9c54(%rip), %rdx      # 0x79b21
callq 0x33112
leaq 0x10(%r13), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rcx
xorl %edx, %edx
callq 0x2e710
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x6fef6
callq 0x2e360
cmpq $-0x1, %rbx
je 0x6ff27
testq %r13, %r13
je 0x6ff1f
movq %r13, %rdi
leaq 0x1c725(%rip), %rsi     # 0x8c630
leaq 0x1d51e(%rip), %rdx     # 0x8d430
xorl %ecx, %ecx
callq 0x2e430
movq %rax, -0x30(%rbp)
jmp 0x6ff27
movq $0x0, -0x30(%rbp)
cmpq $-0x1, %rbx
jne 0x6ff3e
addq $0x8, %r14
cmpq %r15, %r14
jne 0x6feb4
xorl %eax, %eax
jmp 0x6ff42
movq -0x30(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/eniac[P]Mantis/src/compile/find_nodes.cpp
// Function: findP4RegisterNode(std::vector<AstNode*, std::allocator<AstNode*>> const&)
vector<P4RegisterNode*> findP4RegisterNode(const vector<AstNode*>& astNodes) {
    vector<P4RegisterNode*> ret;
    for (auto node : astNodes) {
        if (typeContains(node, "P4RegisterNode")) {
            ret.push_back(dynamic_cast<P4RegisterNode*>(node));
        }
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r12
movq 0x8(%rsi), %r13
cmpq %r13, %r12
je 0x6ffe4
leaq 0x6b51(%rip), %r14      # 0x76ad4
movq (%r12), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6f390
testb %al, %al
je 0x6ffdb
testq %r15, %r15
je 0x6ffb5
movq %r15, %rdi
leaq 0x1c68b(%rip), %rsi     # 0x8c630
leaq 0x1cdf4(%rip), %rdx     # 0x8cda0
xorl %ecx, %ecx
callq 0x2e430
jmp 0x6ffb7
xorl %eax, %eax
movq %rax, -0x30(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6ffcf
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x6ffdb
movq %rbx, %rdi
leaq -0x30(%rbp), %rdx
callq 0x724ba
addq $0x8, %r12
cmpq %r13, %r12
jne 0x6ff83
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6fff8
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x70008
callq 0x2e360
movq %r14, %rdi
callq 0x2e730
// File: /workspace/github_cpp_makefile_star2_O1/eniac[P]Mantis/src/compile/find_nodes.cpp
// Function: findReactionArgs(std::vector<AstNode*, std::allocator<AstNode*>> const&)
vector<ReactionArgNode*> findReactionArgs(const vector<AstNode*>& astNodes) {
    vector<ReactionArgNode*> ret;
    // Find all the argument nodes
    for (auto node : astNodes) {
        if (typeContains(node, "ReactionArgNode")) {
            ret.push_back(dynamic_cast<ReactionArgNode*>(node));
        }
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r12
movq 0x8(%rsi), %r13
cmpq %r13, %r12
je 0x700a3
leaq 0xa28a(%rip), %r14      # 0x7a2cc
movq (%r12), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6f390
testb %al, %al
je 0x7009a
testq %r15, %r15
je 0x70074
movq %r15, %rdi
leaq 0x1c5cc(%rip), %rsi     # 0x8c630
leaq 0x1d3f5(%rip), %rdx     # 0x8d460
xorl %ecx, %ecx
callq 0x2e430
jmp 0x70076
xorl %eax, %eax
movq %rax, -0x30(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x7008e
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x7009a
movq %rbx, %rdi
leaq -0x30(%rbp), %rdx
callq 0x725f4
addq $0x8, %r12
cmpq %r13, %r12
jne 0x70042
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x700b7
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x700c7
callq 0x2e360
movq %r14, %rdi
callq 0x2e730
// File: /workspace/github_cpp_makefile_star2_O1/eniac[P]Mantis/src/compile/find_nodes.cpp
// Function: findAndRemoveReactions(std::vector<P4RReactionNode*, std::allocator<P4RReactionNode*>>*, std::vector<AstNode*, std::allocator<AstNode*>> const&)
void findAndRemoveReactions(vector<P4RReactionNode*>* reactions,
                            const vector<AstNode*>& astNodes) {
    // Find all the malleables
    for (auto n : astNodes) {
        if (typeContains(n, "P4RReactionNode")) {
            auto r = dynamic_cast<P4RReactionNode*>(n);
            reactions->push_back(r);
            n->removed_ = true;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %r12
movq 0x8(%rsi), %r13
cmpq %r13, %r12
je 0x707bc
movq %rdi, %rbx
leaq 0x93bc(%rip), %r14      # 0x79b12
movq (%r12), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6f390
testb %al, %al
je 0x707b3
testq %r15, %r15
je 0x70788
movq %r15, %rdi
leaq 0x1beb8(%rip), %rsi     # 0x8c630
leaq 0x1ccb1(%rip), %rdx     # 0x8d430
xorl %ecx, %ecx
callq 0x2e430
jmp 0x7078a
xorl %eax, %eax
movq %rax, -0x30(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x707a2
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x707ae
movq %rbx, %rdi
leaq -0x30(%rbp), %rdx
callq 0x72d86
movb $0x1, 0x38(%r15)
addq $0x8, %r12
cmpq %r13, %r12
jne 0x70756
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/eniac[P]Mantis/src/compile/find_nodes.cpp
// Function: findTblInIng(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<AstNode*, std::allocator<AstNode*>> const&)
bool findTblInIng(string tableName, const vector<AstNode*>& nodeArray) {
    P4ExprNode* ing_node = findIngress(nodeArray);
    P4ExprNode* egr_node = findEgress(nodeArray);
    // Currently assume that control ing/egr doesn't wrap other control blocks (otherwise requires recursive search)
    if(ing_node==NULL || egr_node==NULL) {
        PANIC("Missing ing/egr node for %s\n", tableName.c_str());
    }
    if(ing_node->body_->toString().find(tableName) != string::npos) {
        return true;
    } else if (egr_node->body_->toString().find(tableName) != string::npos) {
        return false;
    } else {
        PANIC("Failed to locate %s in ing/egr control block\n", tableName.c_str());
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x6f454
movq %rax, %r14
movq %r15, %rdi
callq 0x6f5e2
testq %r14, %r14
je 0x70890
movq %rax, %r15
testq %rax, %rax
je 0x70890
movq 0x60(%r14), %rsi
movq (%rsi), %rax
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq *(%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movq %r12, %rdi
xorl %edx, %edx
callq 0x2e710
movq %rax, %r14
movq (%r12), %rdi
leaq -0x38(%rbp), %r13
cmpq %r13, %rdi
je 0x70840
callq 0x2e360
cmpq $-0x1, %r14
jne 0x7087a
movq 0x60(%r15), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *(%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movq %r12, %rdi
xorl %edx, %edx
callq 0x2e710
movq %rax, %r15
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x70874
callq 0x2e360
cmpq $-0x1, %r15
je 0x70898
cmpq $-0x1, %r14
setne %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x2f23e
movq %rbx, %rdi
callq 0x2f201
// File: /workspace/github_cpp_makefile_star2_O1/eniac[P]Mantis/src/compile/find_nodes.cpp
// Function: findRegargWidth(ReactionArgNode*, std::vector<AstNode*, std::allocator<AstNode*>>)
int findRegargWidth(ReactionArgNode* regarg, std::vector<AstNode*> nodeArray) {
    vector<P4RegisterNode*> regNodes = findP4RegisterNode(nodeArray);
    for(auto reg : regNodes) {
        if(reg->name_->toString().compare(regarg->toString())==0) {
            return reg->width_;
        }
    }
    PANIC("Non existing reg arg %s\n", regarg->toString().c_str());
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, -0x38(%rbp)
leaq -0x98(%rbp), %r14
movq %r14, %rdi
callq 0x6ff51
movq (%r14), %r15
movq 0x8(%r14), %rax
movq %rax, -0x60(%rbp)
cmpq %rax, %r15
sete %bl
je 0x713b5
movq (%r15), %r12
movq 0x40(%r12), %rsi
movq (%rsi), %rax
leaq -0x58(%rbp), %rdi
callq *(%rax)
movq -0x38(%rbp), %rsi
movq (%rsi), %rax
leaq -0x80(%rbp), %rdi
callq *(%rax)
movb %bl, -0x29(%rbp)
movq -0x50(%rbp), %rbx
movq -0x78(%rbp), %r13
cmpq %rbx, %r13
movq %rbx, %rdx
cmovbq %r13, %rdx
testq %rdx, %rdx
je 0x71360
movq -0x80(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x2e3c0
testl %eax, %eax
sete %r14b
jmp 0x71363
movb $0x1, %r14b
cmpq %r13, %rbx
sete %bl
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rax
cmpq %rax, %rdi
je 0x7137b
callq 0x2e360
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x7138d
callq 0x2e360
andb %bl, %r14b
je 0x7139a
movl 0x50(%r12), %eax
movl %eax, -0x30(%rbp)
testb %r14b, %r14b
jne 0x713b2
addq $0x8, %r15
cmpq -0x60(%rbp), %r15
sete %bl
jne 0x71313
jmp 0x713b5
movb -0x29(%rbp), %bl
testb $0x1, %bl
movl -0x30(%rbp), %ebx
jne 0x713df
movq -0x98(%rbp), %rdi
testq %rdi, %rdi
je 0x713ce
callq 0x2e360
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1cbda(%rip), %rax     # 0x8dfc0
movq (%rax), %r14
movq -0x38(%rbp), %rsi
movq (%rsi), %rax
leaq -0x58(%rbp), %rdi
callq *(%rax)
leaq -0x58(%rbp), %rdi
movq %r14, %rsi
callq 0x2f38e
jmp 0x71404
movq %rax, %rbx
jmp 0x7141e
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x7141e
callq 0x2e360
movq -0x98(%rbp), %rdi
testq %rdi, %rdi
je 0x7142f
callq 0x2e360
movq %rbx, %rdi
callq 0x2e730
nop
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/khashl/./../common-block.c
// Function: murmur3_32
uint32_t murmur3_32(const uint8_t* key, size_t len, uint32_t seed) // from wiki
{
	uint32_t h = seed;
    uint32_t k;
	size_t i;
    for (i = len >> 2; i; i--) {
        memcpy(&k, key, sizeof(uint32_t));
        key += sizeof(uint32_t);
        h ^= murmur_32_scramble(k);
        h = (h << 13) | (h >> 19);
        h = h * 5 + 0xe6546b64;
    }
    k = 0;
    for (i = len & 3; i; i--) {
        k <<= 8;
        k |= key[i - 1];
    }
    h ^= murmur_32_scramble(k);
	h ^= len;
	h ^= h >> 16;
	h *= 0x85ebca6b;
	h ^= h >> 13;
	h *= 0xc2b2ae35;
	h ^= h >> 16;
	return h;
}

// Assembly:
cmpq $0x4, %rsi
jb 0x16e4
movq %rsi, %rcx
shrq $0x2, %rcx
movq %rsi, %rax
andq $-0x4, %rax
xorl %r8d, %r8d
movl (%rdi,%r8,4), %r9d
imull $0xcc9e2d51, %r9d, %r10d # imm = 0xCC9E2D51
imull $0x16a88000, %r9d, %r9d # imm = 0x16A88000
shrl $0x11, %r10d
orl %r9d, %r10d
imull $0x1b873593, %r10d, %r9d # imm = 0x1B873593
xorl %edx, %r9d
roll $0xd, %r9d
leal (%r9,%r9,4), %edx
addl $0xe6546b64, %edx       # imm = 0xE6546B64
incq %r8
cmpq %r8, %rcx
jne 0x16a8
addq %rax, %rdi
movq %rsi, %rcx
xorl %eax, %eax
andq $0x3, %rcx
je 0x1700
shll $0x8, %eax
movzbl -0x1(%rdi,%rcx), %r8d
orl %r8d, %eax
decq %rcx
jne 0x16ef
imull $0xcc9e2d51, %eax, %ecx # imm = 0xCC9E2D51
imull $0x16a88000, %eax, %eax # imm = 0x16A88000
shrl $0x11, %ecx
orl %eax, %ecx
imull $0x1b873593, %ecx, %eax # imm = 0x1B873593
xorl %esi, %edx
xorl %eax, %edx
movl %edx, %eax
shrl $0x10, %eax
xorl %edx, %eax
imull $0x85ebca6b, %eax, %eax # imm = 0x85EBCA6B
movl %eax, %ecx
shrl $0xd, %ecx
xorl %eax, %ecx
imull $0xc2b2ae35, %ecx, %ecx # imm = 0xC2B2AE35
movl %ecx, %eax
shrl $0x10, %eax
xorl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/gchen98[P]macs/simulator.cpp
// Function: Configuration::Configuration()
Configuration::Configuration(){
    bDebug = false;
    bVariableRecomb = false;
    bSNPAscertainment = false;
    bFlipAlleles = false;
    bNewickFormat = false;
    bMigrationChangeEventDefined = false;
    dTheta = 0; // mutation rate parameter theta
    dRecombRateRAcrossSites = 0.0; // recombination rate parameter r
    dSeqLength = 0.;
    dGeneConvRatio = 0.;
    iGeneConvTract = 1;
    iTotalPops = 1; // total populations declared
    dBasesToTrack = 1;
    iRandomSeed = time(NULL);
    iIterations = 1;
    pAlleleFreqBinPtrSet = NULL;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq %r14, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq %r14, 0x20(%rdi)
movl $0x0, 0x48(%rdi)
movw $0x0, 0x4c(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x70(%rdi)
movl $0x1, %ebp
movl %ebp, 0x38(%rdi)
movw $0x1, 0x3c(%rdi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x28(%rdi)
xorl %edi, %edi
callq 0x3220
movq %rax, 0x40(%rbx)
movl %ebp, 0x34(%rbx)
movq %r14, 0x90(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gchen98[P]macs/simulator.cpp
// Function: Configuration::~Configuration()
Configuration::~Configuration(){
    cerr<<"Configuration destructor\n";
    delete pEventList;
    if (bSNPAscertainment){
        AlleleFreqBinPtrSet::iterator it;
        for (it=pAlleleFreqBinPtrSet->begin();it!=pAlleleFreqBinPtrSet->end();++it){
            delete(*it);
        }
        delete pAlleleFreqBinPtrSet;
    }
    if (bVariableRecomb){
        HotSpotBinPtrList::iterator it;
        for(it=pHotSpotBinPtrList->begin();it!=pHotSpotBinPtrList->end();++it){
            delete(*it);
        }
        delete pHotSpotBinPtrList;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x1b8df(%rip), %rdi     # 0x1fff0
leaq 0x13348(%rip), %rsi     # 0x17a60
movl $0x19, %edx
callq 0x32a0
movq 0x80(%rbx), %r14
testq %r14, %r14
je 0x4743
movq %r14, %rdi
callq 0x86de
movl $0x18, %esi
movq %r14, %rdi
callq 0x3270
cmpb $0x1, 0x49(%rbx)
jne 0x47a9
movq 0x90(%rbx), %r15
movq 0x18(%r15), %r14
leaq 0x8(%r15), %rax
cmpq %rax, %r14
je 0x478f
movq 0x20(%r14), %r15
testq %r15, %r15
je 0x477b
movq %r15, %rdi
callq 0x11ee8
movl $0x20, %esi
movq %r15, %rdi
callq 0x3270
movq %r14, %rdi
callq 0x32b0
movq %rax, %r14
movq 0x90(%rbx), %r15
jmp 0x4754
testq %r15, %r15
je 0x47a9
movq %r15, %rdi
callq 0x8722
movl $0x30, %esi
movq %r15, %rdi
callq 0x3270
cmpb $0x1, 0x4b(%rbx)
jne 0x480c
movq 0x88(%rbx), %r14
movq (%r14), %r15
cmpq %r14, %r15
je 0x47dd
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x47d1
movl $0x18, %esi
callq 0x3270
movq (%r15), %r15
movq 0x88(%rbx), %r14
jmp 0x47b9
testq %r14, %r14
je 0x480c
movq (%r14), %rdi
cmpq %r14, %rdi
je 0x47ff
movq (%rdi), %r15
movl $0x18, %esi
callq 0x3270
movq %r15, %rdi
cmpq %r14, %r15
jne 0x47ea
movl $0x18, %esi
movq %r14, %rdi
callq 0x3270
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x4821
movq 0x78(%rbx), %rsi
subq %rdi, %rsi
callq 0x3270
addq $0x50, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x81fe
movq %rax, %rdi
callq 0x81f3
// File: /workspace/github_cpp_makefile_star2_O1/gchen98[P]macs/algorithm.cpp
// Function: GraphBuilder::pruneEdgesBelow(boost::shared_ptr<Edge>&)
void GraphBuilder::pruneEdgesBelow(EdgePtr & selectedEdge){
    NodePtr & bottomNode = selectedEdge->getBottomNodeRef();
    if (bottomNode->getType()==Node::COAL){
        // this is the terminating condition and should be the new
        // lower MRCA
        grandMRCA = bottomNode;
        grandMRCA->clearTopEdges();
    }else{
        // we didn't find a coalescent node (MRCA) so keep searching down
        bottomNode->removeEvent();
        EdgePtr bottomEdge = bottomNode->getBottomEdgeByIndex(0);
        pruneEdgesBelow(bottomEdge);
    }
    deleteEdge(selectedEdge);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq (%rsi), %rsi
testq %rsi, %rsi
je 0xa76d
movq 0x20(%rsi), %rcx
testq %rcx, %rcx
je 0xa74e
movq %rdi, %r14
cmpl $0x0, 0x64(%rcx)
je 0xa6e4
cmpb $0x1, 0x60(%rcx)
jne 0xa6bb
movq 0x18(%rcx), %rax
testq %rax, %rax
je 0xa78c
movb $0x1, 0x10(%rax)
movq $0x0, (%rsp)
movq 0x48(%rcx), %rdx
movq %rdx, 0x8(%rsp)
testq %rdx, %rdx
je 0xa711
movl 0x8(%rdx), %eax
testl %eax, %eax
je 0xa702
leal 0x1(%rax), %esi
lock
cmpxchgl %esi, 0x8(%rdx)
jne 0xa6d4
jmp 0xa704
addq $0x20, %rsi
leaq 0x38(%r14), %rdi
callq 0x1080e
movq 0x38(%r14), %rax
testq %rax, %rax
je 0xa74e
movw $0x0, 0x68(%rax)
jmp 0xa739
xorl %eax, %eax
testl %eax, %eax
jne 0xa711
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xa721
movq 0x40(%rcx), %rax
movq %rax, (%rsp)
leaq 0x8(%rsp), %r15
movq %rsp, %rsi
movq %r14, %rdi
callq 0xa676
movq %r15, %rdi
callq 0x10dec
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13ea2
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xe3a3(%rip), %rdi      # 0x18af8
leaq 0xe3a4(%rip), %rsi      # 0x18b00
leaq 0xed38(%rip), %rcx      # 0x1949b
movl $0xc7, %edx
callq 0x3170
leaq 0xe384(%rip), %rdi      # 0x18af8
leaq 0xec8b(%rip), %rsi      # 0x19406
leaq 0xecb0(%rip), %rcx      # 0x19432
movl $0x2d8, %edx            # imm = 0x2D8
callq 0x3170
leaq 0xe365(%rip), %rdi      # 0x18af8
leaq 0xe366(%rip), %rsi      # 0x18b00
leaq 0xe38e(%rip), %rcx      # 0x18b2f
jmp 0xa763
movq %rax, %rbx
movq %r15, %rdi
callq 0x10dec
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/gchen98[P]macs/algorithm.cpp
// Function: GraphBuilder::markCurrentTree()
void GraphBuilder::markCurrentTree(){
    iTotalTreeEdges = 0;
    unsigned int iTotalSamples=pConfig->iSampleSize;
    for(unsigned int i=0;i<iTotalSamples;++i){
        NodePtr & node = pSampleNodeArray[i];
        pTreeEdgesToCoalesceArray[i]=node->getTopEdgeByIndex(0);
    }
    unsigned int iIndex = 0;
    int iIterations = 0;
    bool bFirstSample = true;
    while(iIndex<iTotalSamples){
        EdgePtr & curEdge = pTreeEdgesToCoalesceArray[iIndex];
        if (markEdgesAbove(bFirstSample,true,curEdge,iIndex)){
            ++iIndex;
        }else{
            // start over
            iIndex = 0;
        }
        bFirstSample = false;
        ++iIterations;
    }
    #ifdef DIAG
    if (localMRCA->getBottomEdgeByIndex(0)->iGraphIteration!=
    localMRCA->getBottomEdgeByIndex(1)->iGraphIteration){
        printDataStructures();
        cerr<<"Proposed grandMRCA at :"<<localMRCA->getHeight()<<endl;
        throw "Proposed grandMRCA's edges' histories don't match";
    }
    #endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl $0x0, 0x20(%rdi)
movq 0x8(%rdi), %rax
movl 0x30(%rax), %ebp
testl %ebp, %ebp
je 0xeeea
leaq 0x10(%rsp), %r14
xorl %r12d, %r12d
leaq 0x20(%rsp), %r15
xorl %eax, %eax
movq 0xc0(%rbx), %rcx
movl %eax, %r13d
movq (%rcx,%r13,8), %rcx
testq %rcx, %rcx
je 0xef4c
movq $0x0, 0x8(%rsp)
movq 0x28(%rcx), %rdx
movq %rdx, 0x10(%rsp)
testq %rdx, %rdx
je 0xee78
movl 0x8(%rdx), %eax
testl %eax, %eax
je 0xee69
leal 0x1(%rax), %esi
lock
cmpxchgl %esi, 0x8(%rdx)
jne 0xee59
jmp 0xee6b
xorl %eax, %eax
testl %eax, %eax
jne 0xee78
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xee8b
movq 0x20(%rcx), %rcx
movq %rcx, 0x8(%rsp)
movq 0xb8(%rbx), %rcx
movq %r13, %rdx
shlq $0x4, %rdx
movq 0x8(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movq %r12, 0x10(%rsp)
movq %rax, 0x20(%rsp)
movq %r12, 0x8(%rsp)
movq (%rcx,%rdx), %rdi
movq %rdi, 0x18(%rsp)
movq %rsi, (%rcx,%rdx)
movq 0x8(%rcx,%rdx), %rsi
movq %rax, 0x8(%rcx,%rdx)
movq %rsi, 0x20(%rsp)
movq %r15, %rdi
callq 0x10dec
movq %r14, %rdi
callq 0x10dec
leal 0x1(%r13), %eax
cmpl %ebp, %eax
jne 0xee28
movl $0x0, 0x18(%rsp)
testl %ebp, %ebp
je 0xef3d
xorl %eax, %eax
movb $0x1, %dl
leaq 0x18(%rsp), %r14
movl %eax, %ecx
shlq $0x4, %rcx
addq 0xb8(%rbx), %rcx
movzbl %dl, %esi
andl $0x1, %esi
movq %rbx, %rdi
movl $0x1, %edx
movq %r14, %r8
callq 0xa202
testb %al, %al
jne 0xef2a
xorl %eax, %eax
jmp 0xef30
movl 0x18(%rsp), %eax
incl %eax
movl %eax, 0x18(%rsp)
movl $0x0, %edx
cmpl %ebp, %eax
jb 0xeeff
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9ba5(%rip), %rdi      # 0x18af8
leaq 0x9ba6(%rip), %rsi      # 0x18b00
leaq 0xa53a(%rip), %rcx      # 0x1949b
movl $0xc7, %edx
callq 0x3170
nop
// File: /workspace/github_cpp_makefile_star2_O1/gchen98[P]macs/datastructures.cpp
// Function: Edge::setBottomNode(boost::intrusive_ptr<Node>&)
void Edge::setBottomNode(NodePtr & bottomNode){
    #ifdef DIAG
    if (topNode->getHeight()<bottomNode->getHeight())
    throw "Error in modifying edge.  Top node must be higher or equal";
    #endif
    this->dLength = topNode->getHeight() - bottomNode->getHeight();
    this->bottomNode = bottomNode;
}

// Assembly:
pushq %rax
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x12065
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x12065
movsd 0x70(%rax), %xmm0
subsd 0x70(%rcx), %xmm0
movsd %xmm0, 0x28(%rdi)
addq $0x20, %rdi
popq %rax
jmp 0x1080e
leaq 0x6a8c(%rip), %rdi      # 0x18af8
leaq 0x6a8d(%rip), %rsi      # 0x18b00
leaq 0x7421(%rip), %rcx      # 0x1949b
movl $0xc7, %edx
callq 0x3170
// File: /workspace/github_cpp_makefile_star2_O1/gchen98[P]macs/datastructures.cpp
// Function: Node::Node(Node::NodeType, short, double)
Node::Node(NodeType iType,short int iPopulation,double dHeight):
PtrRefCountable(){
    this->iType = iType;
    this->iPopulation = iPopulation;
    this->dHeight = dHeight;
    this->bEventDefined = false;
    this->topEdgeSize=0;
    this->bottomEdgeSize=0;
    this->bDeleted = false;
    #ifdef DIAG
    cerr<<"Graph node at "<<dHeight<<" constructed."<<endl;
    #endif
}

// Assembly:
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0xd73f(%rip), %rcx      # 0x1fad0
movq %rcx, (%rdi)
xorps %xmm1, %xmm1
movups %xmm1, 0x18(%rdi)
movups %xmm1, 0x28(%rdi)
movups %xmm1, 0x38(%rdi)
movups %xmm1, 0x48(%rdi)
movq %rax, 0x58(%rdi)
movl %esi, 0x64(%rdi)
movw %dx, 0x62(%rdi)
movsd %xmm0, 0x70(%rdi)
movb %al, 0x60(%rdi)
movl $0x0, 0x68(%rdi)
movb %al, 0x10(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gchen98[P]macs/datastructures.cpp
// Function: GraphBuilder::insertNodeInEdge(boost::intrusive_ptr<Node>&, boost::shared_ptr<Edge>&)
void GraphBuilder::insertNodeInEdge(NodePtr & newNode,
EdgePtr & selectedEdge){

    NodePtr bottomNodeCopy = selectedEdge->getBottomNodeRef();
    #ifdef DIAG
    NodePtr & topNode = selectedEdge->getTopNodeRef();
    if (newNode->getHeight()<bottomNodeCopy->getHeight() ||
    newNode->getHeight() > topNode->getHeight()){
        cerr<<"Edge has heights "<<bottomNodeCopy->getHeight()<<
        " and "<<topNode->getHeight()<<endl;
        cerr<<"New node has height "<<newNode->getHeight()<<endl;
        throw "Node to insert does not fit within edge";
    }
    #endif
    int iGraphIteration = selectedEdge->iGraphIteration;
    selectedEdge->setBottomNode(newNode);
    newNode->addNewEdge(Node::TOP_EDGE,selectedEdge);
    EdgePtr newBottomEdge = EdgePtr(new Edge(newNode,bottomNodeCopy));
    newBottomEdge->iGraphIteration = iGraphIteration;
    addEdge(newBottomEdge);
    bottomNodeCopy->replaceOldWithNewEdge(Node::TOP_EDGE,selectedEdge,
    newBottomEdge);
    newNode->addNewEdge(Node::BOTTOM_EDGE,newBottomEdge);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r15
movq (%rdx), %rdi
testq %rdi, %rdi
je 0x140d8
movq %rdx, %r14
movq %rsi, %rbx
movq 0x20(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x13ff3
incq 0x8(%rax)
movl 0x14(%rdi), %ebp
movq %rbx, %rsi
callq 0x1203a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x140b9
xorl %esi, %esi
movq %r14, %rdx
callq 0x120a2
movl $0x30, %edi
callq 0x3260
movq %rax, %r12
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x11f28
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x1083a
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x140d8
movl %ebp, 0x14(%rax)
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x13b78
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x140b9
leaq 0x10(%rsp), %rcx
xorl %esi, %esi
movq %r14, %rdx
callq 0x1210c
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x140b9
leaq 0x10(%rsp), %rdx
movl $0x1, %esi
callq 0x120a2
leaq 0x18(%rsp), %rdi
callq 0x10dec
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x140ac
decq 0x8(%rdi)
jne 0x140ac
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4a38(%rip), %rdi      # 0x18af8
leaq 0x4a39(%rip), %rsi      # 0x18b00
leaq 0x53cd(%rip), %rcx      # 0x1949b
movl $0xc7, %edx
callq 0x3170
leaq 0x4a19(%rip), %rdi      # 0x18af8
leaq 0x5320(%rip), %rsi      # 0x19406
leaq 0x5345(%rip), %rcx      # 0x19432
movl $0x2d8, %edx            # imm = 0x2D8
callq 0x3170
movq %rax, %rbx
movl $0x30, %esi
movq %r12, %rdi
callq 0x3270
jmp 0x1411d
jmp 0x1411a
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x10dec
jmp 0x1411d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x14133
decq 0x8(%rdi)
jne 0x14133
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/gchen98[P]macs/datastructures.cpp
// Function: GraphBuilder::initializeCurrentTree()
void GraphBuilder::initializeCurrentTree(){
    // this method does two things, traverses the edges
    // to compute the total length, and clears out the status for
    // in current tree
    dLastTreeLength = 0.0;
    dArgLength = 0.;
    if (iGraphIteration==0){
        EdgePtrList::iterator it;
        for (it=pEdgeListInARG->begin();it!=pEdgeListInARG->end();++it){
            EdgePtr curEdge=*it;
            dLastTreeLength+=curEdge->getLength();
            this->addEdgeToCurrentTree(curEdge);
            curEdge->bInCurrentTree = false;
        }
        dArgLength = dLastTreeLength;
    }else{
        EdgePtrList::iterator it1=pEdgeListInARG->begin();
        while(it1!=pEdgeListInARG->end()){
            EdgePtr curEdge = *it1;
            if (!curEdge->bDeleted){
              dArgLength+=curEdge->getLength();
              if (curEdge->bInCurrentTree){
                dLastTreeLength+=curEdge->getLength();
                curEdge->bInCurrentTree = false;
              }
              ++it1;
            }else{
              it1 = pEdgeListInARG->erase(it1);
            }
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, 0x28(%rdi)
cmpl $0x0, 0xd0(%rdi)
movq 0x10(%rdi), %rax
movq (%rax), %r14
je 0x14262
cmpq %rax, %r14
je 0x142d0
leaq 0x28(%rbx), %r12
leaq 0x8(%rsp), %r15
movq 0x10(%r14), %rax
movq %rax, (%rsp)
movq 0x18(%r14), %rcx
movq %rcx, 0x8(%rsp)
testq %rcx, %rcx
je 0x14203
lock
incl 0x8(%rcx)
testq %rax, %rax
je 0x142de
cmpb $0x0, 0x10(%rax)
je 0x14226
movq 0x10(%rbx), %rdi
movq (%r14), %r13
movq %r14, %rsi
callq 0x16616
movq %r13, %r14
jmp 0x14252
movsd 0x28(%rax), %xmm0
movsd (%r12), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%r12)
cmpb $0x1, 0x12(%rax)
jne 0x1424f
addsd 0x30(%rbx), %xmm0
movsd %xmm0, 0x30(%rbx)
movb $0x0, 0x12(%rax)
movq (%r14), %r14
movq %r15, %rdi
callq 0x10dec
cmpq 0x10(%rbx), %r14
jne 0x141e9
jmp 0x142d0
cmpq %rax, %r14
je 0x142c6
leaq 0x8(%rsp), %r15
movq %rsp, %r12
movq 0x10(%r14), %rax
movq %rax, (%rsp)
movq 0x18(%r14), %rcx
movq %rcx, 0x8(%rsp)
testq %rcx, %rcx
je 0x14289
lock
incl 0x8(%rcx)
testq %rax, %rax
je 0x142de
movsd 0x28(%rax), %xmm0
addsd 0x30(%rbx), %xmm0
movsd %xmm0, 0x30(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1413c
movq (%rsp), %rax
testq %rax, %rax
je 0x142de
movb $0x0, 0x12(%rax)
movq %r15, %rdi
callq 0x10dec
movq (%r14), %r14
cmpq 0x10(%rbx), %r14
jne 0x1426f
movsd 0x30(%rbx), %xmm0
movsd %xmm0, 0x28(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x4813(%rip), %rdi      # 0x18af8
leaq 0x511a(%rip), %rsi      # 0x19406
leaq 0x513f(%rip), %rcx      # 0x19432
movl $0x2d8, %edx            # imm = 0x2D8
callq 0x3170
movq %rax, %rbx
movq %r15, %rdi
callq 0x10dec
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/hoehermann[P]TypedJNI/typedjni.cpp
// Function: TypedJNI::GetStaticMethodID(JNIEnv_*, _jclass*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
jmethodID TypedJNI::GetStaticMethodID(JNIEnv *env, const jclass cls, const std::string name, const std::string & signature) {
    jmethodID mid = env->GetStaticMethodID(cls, name.c_str(), signature.c_str());
    if (mid == NULL) {
        throw TypedJNIError("Failed to find static method '"+name+"' "+signature+".");
    }
    return mid;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq (%rdx), %rdx
movq (%rcx), %rcx
movq (%rdi), %rax
callq *0x388(%rax)
testq %rax, %rax
je 0x6994
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x30e0
movq %rax, %rbx
leaq 0x2b76(%rip), %rsi      # 0x951e
leaq 0x40(%rsp), %rdi
movq %r15, %rdx
callq 0x782c
leaq 0x2b81(%rip), %rsi      # 0x953d
leaq 0x40(%rsp), %rdi
callq 0x32a0
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x69e7
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x69f3
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x60(%rsp), %rdi
movq %r14, %rdx
callq 0x77d2
leaq 0x2b87(%rip), %rsi      # 0x95a8
leaq 0x60(%rsp), %rdi
callq 0x32a0
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x6a4e
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x6a5b
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x31f0
leaq 0x613f(%rip), %rax      # 0xcbc8
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x614b(%rip), %rsi      # 0xcbe0
movq 0x652c(%rip), %rdx      # 0xcfc8
movq %rbx, %rdi
callq 0x3260
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x6ac6
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31b0
jmp 0x6ac6
movq %rax, %r14
movb $0x1, %bpl
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6ae9
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x31b0
jmp 0x6ae9
movq %rax, %r14
movb $0x1, %bpl
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6b07
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31b0
jmp 0x6b07
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b2a
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x31b0
jmp 0x6b2a
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x6b37
movq %rbx, %rdi
callq 0x3120
movq %r14, %rdi
callq 0x3280