LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb2ae0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb2b10
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xb2b40
testb $0x1, %al
jne 0x12d9c3
jmp 0x12dab8
leaq -0x20(%rbp), %rdi
callq 0xb2b80
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x80(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xaaa70
movq -0x78(%rbp), %rdx
leaq 0x104e6(%rip), %rsi     # 0x13dedd
leaq -0x50(%rbp), %rdi
callq 0xaa7d0
jmp 0x12da02
movq -0x80(%rbp), %rdi
leaq -0x50(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xaabb0
movq %rax, -0x88(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xaabe8
leaq -0x51(%rbp), %rdi
callq 0xaa5f0
movq -0x88(%rbp), %rax
cmpq $-0x1, %rax
je 0x12daa8
movq -0x30(%rbp), %rax
movq %rax, -0x90(%rbp)
cmpq $0x0, %rax
je 0x12da88
movq -0x90(%rbp), %rdi
leaq 0x44b88(%rip), %rsi     # 0x1725e0
leaq 0x45981(%rip), %rdx     # 0x1733e0
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x98(%rbp)
jmp 0x12da93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x51(%rbp), %rdi
callq 0xaa5f0
jmp 0x12dacd
xorl %eax, %eax
movq %rax, -0x98(%rbp)
jmp 0x12da93
movq -0x98(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12dac0
jmp 0x12daaa
leaq -0x20(%rbp), %rdi
callq 0xb2ba0
jmp 0x12d9ad
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xaaa60
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x12fbe0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xb8280
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xb82b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x12f810
testb $0x1, %al
jne 0x12db3f
jmp 0x12dbe4
leaq -0x28(%rbp), %rdi
callq 0x12f850
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq 0xd242(%rip), %rsi      # 0x13ad9c
callq 0x12c730
movb %al, -0x61(%rbp)
jmp 0x12db64
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x12db6d
jmp 0x12dbd4
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0x12dbb3
movq -0x70(%rbp), %rdi
leaq 0x44a5a(%rip), %rsi     # 0x1725e0
leaq 0x451c3(%rip), %rdx     # 0x172d50
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x78(%rbp)
jmp 0x12dbbb
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x127d00
jmp 0x12dc04
xorl %eax, %eax
movq %rax, -0x78(%rbp)
jmp 0x12dbbb
movq -0x60(%rbp), %rdi
movq -0x78(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x12fc00
jmp 0x12dbd2
jmp 0x12dbd4
jmp 0x12dbd6
leaq -0x28(%rbp), %rdi
callq 0x12f870
jmp 0x12db29
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x12dbf7
movq -0x60(%rbp), %rdi
callq 0x127d00
movq -0x58(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xaaa60
nopl (%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xcb4d0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xb8280
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xb82b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x12f810
testb $0x1, %al
jne 0x12dc6f
jmp 0x12dd14
leaq -0x28(%rbp), %rdi
callq 0x12f850
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq 0x10a12(%rip), %rsi     # 0x13e69c
callq 0x12c730
movb %al, -0x61(%rbp)
jmp 0x12dc94
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x12dc9d
jmp 0x12dd04
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0x12dce3
movq -0x70(%rbp), %rdi
leaq 0x4492a(%rip), %rsi     # 0x1725e0
leaq 0x45753(%rip), %rdx     # 0x173410
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x78(%rbp)
jmp 0x12dceb
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0xccb90
jmp 0x12dd34
xorl %eax, %eax
movq %rax, -0x78(%rbp)
jmp 0x12dceb
movq -0x60(%rbp), %rdi
movq -0x78(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x12fc30
jmp 0x12dd02
jmp 0x12dd04
jmp 0x12dd06
leaq -0x28(%rbp), %rdi
callq 0x12f870
jmp 0x12dc59
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x12dd27
movq -0x60(%rbp), %rdi
callq 0xccb90
movq -0x58(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xaaa60
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb8280
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb82b0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x12f810
testb $0x1, %al
jne 0x12e5e8
jmp 0x12e672
leaq -0x20(%rbp), %rdi
callq 0x12f850
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0xf8d7(%rip), %rsi      # 0x13deda
callq 0x12c730
testb $0x1, %al
jne 0x12e60e
jmp 0x12e662
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x12e63d
movq -0x40(%rbp), %rdi
leaq 0x43fb9(%rip), %rsi     # 0x1725e0
leaq 0x44db2(%rip), %rdx     # 0x1733e0
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x48(%rbp)
jmp 0x12e645
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x12e645
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x12fe60
movq -0x30(%rbp), %rax
movb $0x1, 0x38(%rax)
jmp 0x12e664
leaq -0x20(%rbp), %rdi
callq 0x12f870
jmp 0x12e5d2
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12c8a0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12cb20
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x12e6bf
cmpq $0x0, -0x28(%rbp)
jne 0x12e708
movq -0x70(%rbp), %rdi
movq 0x458e6(%rip), %rax     # 0x173fb0
movq (%rax), %rax
movq %rax, -0x78(%rbp)
callq 0xaa270
movq -0x78(%rbp), %rdi
movq %rax, %r9
leaq 0x10117(%rip), %rsi     # 0x13e7fb
leaq 0xffee(%rip), %rdx      # 0x13e6d9
movl $0x13a, %ecx            # imm = 0x13A
leaq 0x10132(%rip), %r8      # 0x13e829
movb $0x0, %al
callq 0xaa850
movl $0x1, %edi
callq 0xaa6c0
movq -0x20(%rbp), %rax
movq 0x60(%rax), %rsi
movq (%rsi), %rax
leaq -0x48(%rbp), %rdi
callq *(%rax)
movq -0x70(%rbp), %rsi
leaq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0xaabb0
movq %rax, -0x80(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xaabe8
movq -0x80(%rbp), %rax
cmpq $-0x1, %rax
je 0x12e74a
movb $0x1, -0x1(%rbp)
jmp 0x12e7de
movq -0x28(%rbp), %rax
movq 0x60(%rax), %rsi
movq (%rsi), %rax
leaq -0x68(%rbp), %rdi
callq *(%rax)
movq -0x70(%rbp), %rsi
leaq -0x68(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0xaabb0
movq %rax, -0x88(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xaabe8
movq -0x88(%rbp), %rax
cmpq $-0x1, %rax
je 0x12e78f
movb $0x0, -0x1(%rbp)
jmp 0x12e7de
movq -0x70(%rbp), %rdi
movq 0x45816(%rip), %rax     # 0x173fb0
movq (%rax), %rax
movq %rax, -0x90(%rbp)
callq 0xaa270
movq -0x90(%rbp), %rdi
movq %rax, %r9
leaq 0x1007c(%rip), %rsi     # 0x13e836
leaq 0xff18(%rip), %rdx      # 0x13e6d9
movl $0x141, %ecx            # imm = 0x141
leaq 0x1005c(%rip), %r8      # 0x13e829
movb $0x0, %al
callq 0xaa850
movl $0x1, %edi
callq 0xaa6c0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x12dae0
leaq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x127bc0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x127bf0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x127c20
testb $0x1, %al
jne 0x12f694
jmp 0x12f781
leaq -0x38(%rbp), %rdi
callq 0x127c60
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x40(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x68(%rbp), %rdi
callq *%rax
jmp 0x12f6ba
movq -0x8(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x98(%rbp), %rdi
callq *%rax
jmp 0x12f6cf
leaq -0x68(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xaa060
movl %eax, -0xbc(%rbp)
jmp 0x12f6e7
leaq -0x98(%rbp), %rdi
callq 0xaabe8
leaq -0x68(%rbp), %rdi
callq 0xaabe8
movl -0xbc(%rbp), %eax
cmpl $0x0, %eax
jne 0x12f771
movq -0x48(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0xc0(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x127d00
movl -0xc0(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x12f7f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x12f763
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x98(%rbp), %rdi
callq 0xaabe8
leaq -0x68(%rbp), %rdi
callq 0xaabe8
jmp 0x12f7f4
jmp 0x12f773
leaq -0x38(%rbp), %rdi
callq 0x127c80
jmp 0x12f67e
movq 0x44828(%rip), %rax     # 0x173fb0
movq (%rax), %rax
movq %rax, -0xc8(%rbp)
movq -0x8(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0xb8(%rbp), %rdi
callq *%rax
jmp 0x12f7a7
leaq -0xb8(%rbp), %rdi
callq 0xaa270
movq -0xc8(%rbp), %rdi
movq %rax, %r9
leaq 0xf159(%rip), %rsi      # 0x13e91d
leaq 0xef0e(%rip), %rdx      # 0x13e6d9
movl $0x1a9, %ecx            # imm = 0x1A9
leaq 0xf170(%rip), %r8       # 0x13e947
movb $0x0, %al
callq 0xaa850
leaq -0xb8(%rbp), %rdi
callq 0xaabe8
movl $0x1, %edi
callq 0xaa6c0
leaq -0x28(%rbp), %rdi
callq 0x127d00
movq -0x70(%rbp), %rdi
callq 0xaaa60
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/khashl/./../common-block.c
// Function: traverse_rng
uint64_t traverse_rng(uint32_t n, uint32_t x0)
{
	uint64_t sum = 0;
	uint32_t i, x;
	uint8_t block[MAX_BLOCK_LEN];
	for (i = 0, x = x0; i < n; ++i) {
		x = hash32(x);
		sum += get_key_block(n, x, block);
	}
	return sum;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
jae 0x1265
movl 0x10(%rsp), %edi
callq 0x1270
movl %eax, 0x10(%rsp)
movl 0x24(%rsp), %edi
movl 0x10(%rsp), %esi
movq %rsp, %rdx
callq 0x12e0
cltq
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1225
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: attractivechaos[P]udb2/khashl/./../common-block.c
// Function: get_key_block
static inline int32_t get_key_block(const uint32_t n, const uint32_t x, uint8_t block[MAX_BLOCK_LEN])
{
	uint32_t y;
	int32_t i, len;
	y = hash32(x % (n>>2));
	len = MAX_BLOCK_LEN;
	for (i = 0; i < len; i += 4)
		memcpy(&block[i], &y, 4);
	return len;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl 0x20(%rsp), %eax
movl 0x24(%rsp), %ecx
shrl $0x2, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %edi
callq 0x1270
movl %eax, 0x14(%rsp)
movl $0x10, 0xc(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x1343
movq 0x18(%rsp), %rax
movslq 0x10(%rsp), %rcx
movl 0x14(%rsp), %edx
movl %edx, (%rax,%rcx)
movl 0x10(%rsp), %eax
addl $0x4, %eax
movl %eax, 0x10(%rsp)
jmp 0x131b
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rax
shrq $0x2, %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x13d8
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x20(%rsp)
movl 0xc(%rsp), %edi
callq 0x14a0
xorl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
shll $0xd, %eax
movl 0x10(%rsp), %ecx
shrl $0x13, %ecx
orl %ecx, %eax
movl %eax, 0x10(%rsp)
imull $0x5, 0x10(%rsp), %eax
addl $0xe6546b64, %eax       # imm = 0xE6546B64
movl %eax, 0x10(%rsp)
movq (%rsp), %rax
addq $-0x1, %rax
movq %rax, (%rsp)
jmp 0x1377
movl $0x0, 0xc(%rsp)
movq 0x18(%rsp), %rax
andq $0x3, %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x1426
movl 0xc(%rsp), %eax
shll $0x8, %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq (%rsp), %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %eax
orl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movq (%rsp), %rax
addq $-0x1, %rax
movq %rax, (%rsp)
jmp 0x13ed
movl 0xc(%rsp), %edi
callq 0x14a0
xorl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rcx
movl 0x10(%rsp), %eax
xorq %rcx, %rax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
shrl $0x10, %eax
xorl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
imull $0x85ebca6b, 0x10(%rsp), %eax # imm = 0x85EBCA6B
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
shrl $0xd, %eax
xorl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
imull $0xc2b2ae35, 0x10(%rsp), %eax # imm = 0xC2B2AE35
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
shrl $0x10, %eax
xorl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/khashl/./../common-block.c
// Function: murmur_32_scramble
static inline uint32_t murmur_32_scramble(uint32_t k)
{
    k *= 0xcc9e2d51;
    k = (k << 15) | (k >> 17);
    k *= 0x1b873593;
    return k;
}

// Assembly:
movl %edi, -0x4(%rsp)
imull $0xcc9e2d51, -0x4(%rsp), %eax # imm = 0xCC9E2D51
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shll $0xf, %eax
movl -0x4(%rsp), %ecx
shrl $0x11, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rsp)
imull $0x1b873593, -0x4(%rsp), %eax # imm = 0x1B873593
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x50, %rdi
callq 0xb7e0
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0xb800
movq -0x10(%rbp), %rax
movb $0x0, 0x48(%rax)
movb $0x0, 0x4b(%rax)
movb $0x0, 0x49(%rax)
movb $0x0, 0x4a(%rax)
movb $0x0, 0x4c(%rax)
movb $0x0, 0x4d(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
movl $0x1, 0x38(%rax)
movw $0x1, 0x3c(%rax)
movsd 0x2c0be(%rip), %xmm0    # 0x32008
movsd %xmm0, 0x28(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x42a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movl $0x1, 0x34(%rax)
movq $0x0, 0x90(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x43055(%rip), %rdi     # 0x48ff0
leaq 0x2cb97(%rip), %rsi     # 0x32b39
callq 0x42b0
jmp 0x5fa9
movq -0x40(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x5fd5
movq -0x48(%rbp), %rdi
callq 0xb820
movq -0x48(%rbp), %rdi
movl $0x18, %esi
callq 0x42d0
movq -0x40(%rbp), %rax
testb $0x1, 0x49(%rax)
je 0x6097
leaq -0x10(%rbp), %rdi
callq 0xb840
movq -0x40(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0xb860
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0xb8c0
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xb890
testb $0x1, %al
jne 0x602f
jmp 0x6069
leaq -0x10(%rbp), %rdi
callq 0xb8f0
movq (%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x605c
movq -0x50(%rbp), %rdi
callq 0x27340
movq -0x50(%rbp), %rdi
movl $0x20, %esi
callq 0x42d0
jmp 0x605e
leaq -0x10(%rbp), %rdi
callq 0xb920
jmp 0x6008
movq -0x40(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x6095
movq -0x58(%rbp), %rdi
callq 0xb950
movq -0x58(%rbp), %rdi
movl $0x30, %esi
callq 0x42d0
jmp 0x6097
movq -0x40(%rbp), %rax
testb $0x1, 0x4b(%rax)
je 0x6150
leaq -0x28(%rbp), %rdi
callq 0xb970
movq -0x40(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0xb990
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0xb9f0
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xb9c0
testb $0x1, %al
jne 0x60f1
jmp 0x6122
leaq -0x28(%rbp), %rdi
callq 0xba20
movq (%rax), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x6115
movq -0x60(%rbp), %rdi
movl $0x18, %esi
callq 0x42d0
jmp 0x6117
leaq -0x28(%rbp), %rdi
callq 0xba40
jmp 0x60ca
movq -0x40(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x614e
movq -0x68(%rbp), %rdi
callq 0xba60
movq -0x68(%rbp), %rdi
movl $0x18, %esi
callq 0x42d0
jmp 0x6150
movq -0x40(%rbp), %rdi
addq $0x68, %rdi
callq 0xba80
movq -0x40(%rbp), %rdi
addq $0x50, %rdi
callq 0xbae0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xb7d0
nopl (%rax,%rax)
// File: gchen98[P]macs/algorithm.cpp
// Function: GraphBuilder::mutateBelowEdge(boost::shared_ptr<Edge>&)
void GraphBuilder::mutateBelowEdge(EdgePtr & edge){
    NodePtr & bottomNode = edge->getBottomNodeRef();
    if (bottomNode->getType()==Node::SAMPLE  ){
        SampleNode* sample = static_cast<SampleNode*>(bottomNode.get());
        // mark this sampled node as affected.
        sample->bAffected = true;
    }else{
        for (unsigned int i=0;i<bottomNode->getBottomEdgeSize();++i){
            #ifdef DIAG
            if (bottomNode->getBottomEdgeByIndex(i)->bDeleted){
                throw "Mutate below edge: this edge should have been removed";
            }
            #endif
            EdgePtr edge = bottomNode->getBottomEdgeByIndex(i);
            if (edge->iGraphIteration==iGraphIteration){
                mutateBelowEdge(edge);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1de60
movq %rax, %rdi
callq 0x1deb0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ded0
movq %rax, %rdi
callq 0x1e200
cmpl $0x3, %eax
jne 0x1551d
movq -0x18(%rbp), %rdi
callq 0x1e220
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb $0x1, 0x7c(%rax)
jmp 0x155bc
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ded0
movq %rax, %rdi
callq 0x1e240
movw %ax, %cx
movl -0x54(%rbp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
jae 0x155ba
movq -0x18(%rbp), %rdi
callq 0x1ded0
movq %rax, %rsi
movl -0x24(%rbp), %eax
leaq -0x38(%rbp), %rdi
movzwl %ax, %edx
callq 0x1e260
leaq -0x38(%rbp), %rdi
callq 0x1de60
movq -0x50(%rbp), %rcx
movl 0x14(%rax), %eax
cmpl 0xd0(%rcx), %eax
jne 0x155a3
movq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x154c0
jmp 0x1558a
jmp 0x155a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1e090
jmp 0x155c2
leaq -0x38(%rbp), %rdi
callq 0x1e090
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x15524
jmp 0x155bc
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x44e0
nopl (%rax,%rax)
// File: gchen98[P]macs/algorithm.cpp
// Function: GraphBuilder::markEdgesBelow(boost::shared_ptr<Edge>&)
void GraphBuilder::markEdgesBelow(EdgePtr & selectedEdge){
    selectedEdge->iGraphIteration = iGraphIteration;
    NodePtr  & bottomNode = selectedEdge->getBottomNodeRef();
    if (bottomNode->getType()==Node::COAL||
    bottomNode->getType()==Node::SAMPLE) return;
    else{
        EdgePtr bottomEdge = bottomNode->getBottomEdgeByIndex(0);
        markEdgesBelow(bottomEdge);
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl 0xd0(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1de60
movl -0x38(%rbp), %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rdi
callq 0x1de60
movq %rax, %rdi
callq 0x1deb0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ded0
movq %rax, %rdi
callq 0x1e200
cmpl $0x0, %eax
je 0x15aa1
movq -0x18(%rbp), %rdi
callq 0x1ded0
movq %rax, %rdi
callq 0x1e200
cmpl $0x3, %eax
jne 0x15aa3
jmp 0x15aef
movq -0x18(%rbp), %rdi
callq 0x1ded0
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
xorl %edx, %edx
callq 0x1e260
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x15a30
jmp 0x15acd
leaq -0x28(%rbp), %rdi
callq 0x1e090
jmp 0x15aef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1e090
jmp 0x15af5
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x44e0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1de60
movq %rax, %rdi
callq 0x1deb0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ded0
movq %rax, %rdi
callq 0x1e200
cmpl $0x0, %eax
jne 0x15b6b
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x38, %rdi
callq 0x1e300
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
callq 0x1ded0
movq %rax, %rdi
callq 0x1e460
jmp 0x15bc8
movq -0x18(%rbp), %rdi
callq 0x1ded0
movq %rax, %rdi
callq 0x1e480
movq -0x18(%rbp), %rdi
callq 0x1ded0
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
xorl %edx, %edx
callq 0x1e260
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x15b00
jmp 0x15ba6
leaq -0x28(%rbp), %rdi
callq 0x1e090
jmp 0x15bc8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1e090
jmp 0x15bdb
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2a370
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x44e0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, 0x20(%rax)
movq 0x8(%rax), %rax
movl 0x30(%rax), %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x1c1f6
movq -0x48(%rbp), %rax
movq 0xc0(%rax), %rax
movl -0x10(%rbp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ded0
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
xorl %edx, %edx
callq 0x1e390
movq -0x48(%rbp), %rax
movq 0xb8(%rax), %rdi
movl -0x10(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdi
leaq -0x28(%rbp), %rsi
callq 0x1e630
leaq -0x28(%rbp), %rdi
callq 0x1e090
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1c18c
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movb $0x1, -0x31(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x1c26a
movq -0x48(%rbp), %rdi
movq 0xb8(%rdi), %rax
movl -0x2c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movb -0x31(%rbp), %al
movq -0x40(%rbp), %rcx
movl $0x1, %edx
leaq -0x2c(%rbp), %r8
andb $0x1, %al
movzbl %al, %esi
callq 0x155d0
testb $0x1, %al
jne 0x1c249
jmp 0x1c254
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1c25b
movl $0x0, -0x2c(%rbp)
movb $0x0, -0x31(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1c208
addq $0x50, %rsp
popq %rbp
retq
// File: gchen98[P]macs/./simulator.h
// Function: Node::getBottomEdgeByIndex(unsigned short)
inline EdgePtr Node::getBottomEdgeByIndex(short unsigned int index){
    #ifdef DIAG
    if (index>=this->bottomEdgeSize)
        throw "Index for bottom edge out of range";
    #endif
    return index?bottomEdge2.lock():bottomEdge1.lock();
//        return index?bottomEdge2:bottomEdge1;
//    return edge;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movw %dx, %ax
movq %rdi, %rcx
movq %rcx, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpw $0x0, -0x12(%rbp)
je 0x1e2a4
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x50, %rsi
callq 0x1fe60
jmp 0x1e2b5
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x40, %rsi
callq 0x1fe60
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: gchen98[P]macs/./simulator.h
// Function: Node::getTopEdgeByIndex(unsigned short)
inline EdgePtr Node::getTopEdgeByIndex(short unsigned int index){
    #ifdef DIAG
    if (index>=this->topEdgeSize)
        throw "Index for top edge out of range";
    #endif
    return index?topEdge2.lock():topEdge1.lock();
//        return index?topEdge2:topEdge1;
//    return edge;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movw %dx, %ax
movq %rdi, %rcx
movq %rcx, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpw $0x0, -0x12(%rbp)
je 0x1e3d4
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x30, %rsi
callq 0x1fe60
jmp 0x1e3e5
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x20, %rsi
callq 0x1fe60
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: gchen98[P]macs/datastructures.cpp
// Function: AlleleFreqBin::AlleleFreqBin(double, double, double)
AlleleFreqBin::AlleleFreqBin(double dStart,
double dEnd, double dFreq){
    this->dStart = dStart;
    this->dEnd = dEnd;
    this->dFreq = dFreq;
    this->iObservedCounts = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd -0x10(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
movl $0x0, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gchen98[P]macs/datastructures.cpp
// Function: Population::Population()
Population::Population(){
    setChrSampled(0);
    setPopSize(1);
    dGrowthAlpha=0;
    dLastTime=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
xorl %esi, %esi
callq 0x273a0
movq -0x10(%rbp), %rdi
movsd 0xac91(%rip), %xmm0     # 0x32008
callq 0x273c0
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gchen98[P]macs/datastructures.cpp
// Function: Edge::Edge(boost::intrusive_ptr<Node>&, boost::intrusive_ptr<Node>&)
Edge::Edge(NodePtr & topNode,NodePtr & bottomNode):
PtrRefCountable(){
    #ifdef DIAG

    if (topNode->getHeight()<bottomNode->getHeight()){
        cerr<<"Error in creating edge.  Top node must be higher or equal\n";
        throw "Error in creating edge";
    }
    if (topNode->getType()==Node::MIGRATION &&
    bottomNode->getPopulation()==topNode->getPopulation()){
        cerr<<"Error in creating edge.  Top node must be different from "<<
        "migration node's population\n";
        throw "Error in creating edge";
    }
    cerr<<"edge of constructed.\n";
    #endif
    this->dLength = topNode->getHeight() - bottomNode->getHeight();
    this->topNode = topNode;
    this->getBottomNodeRef() = bottomNode;
    this->bDeleted = false;
    this->bInQueue = false;
    this->bInCurrentTree = false;
    this->iGraphIteration = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x27140
movq -0x40(%rbp), %rdi
leaq 0x21654(%rip), %rax     # 0x48ae0
movq %rax, (%rdi)
addq $0x18, %rdi
movq %rdi, -0x48(%rbp)
callq 0x1e680
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x38(%rbp)
callq 0x1e680
movq -0x10(%rbp), %rdi
callq 0x1ded0
movq %rax, %rdi
callq 0x1df20
movsd %xmm0, -0x30(%rbp)
jmp 0x274c5
movq -0x18(%rbp), %rdi
callq 0x1ded0
movq %rax, %rdi
callq 0x1df20
movsd %xmm0, -0x50(%rbp)
jmp 0x274dd
movq -0x40(%rbp), %rdi
movsd -0x50(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rdi)
movq -0x10(%rbp), %rsi
addq $0x18, %rdi
callq 0x1e300
jmp 0x27503
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x1deb0
movq %rax, -0x58(%rbp)
jmp 0x2751a
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x1e300
jmp 0x27529
movq -0x40(%rbp), %rax
movb $0x0, 0x10(%rax)
movb $0x0, 0x11(%rax)
movb $0x0, 0x12(%rax)
movl $0x0, 0x14(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1e420
movq -0x48(%rbp), %rdi
callq 0x1e420
movq -0x40(%rbp), %rdi
callq 0x27170
movq -0x20(%rbp), %rdi
callq 0x44e0
nopw %cs:(%rax,%rax)
// File: gchen98[P]macs/datastructures.cpp
// Function: Node::getTypeStr()
const char* Node::getTypeStr(){
    switch(iType){
    case COAL:
        return "coal";
    case XOVER:
        return "xover";
    case MIGRATION:
        return "migr";
    case SAMPLE:
        return "sampl";
    case QUERY:
        return "query";
    }
    return "undef";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x64(%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0x276de
movq -0x18(%rbp), %rax
leaq 0xcff8(%rip), %rcx      # 0x3468c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xd032(%rip), %rax      # 0x346d6
movq %rax, -0x8(%rbp)
jmp 0x276e9
leaq 0xc5ef(%rip), %rax      # 0x33ca0
movq %rax, -0x8(%rbp)
jmp 0x276e9
leaq 0xd01d(%rip), %rax      # 0x346db
movq %rax, -0x8(%rbp)
jmp 0x276e9
leaq 0xd015(%rip), %rax      # 0x346e0
movq %rax, -0x8(%rbp)
jmp 0x276e9
leaq 0xd00e(%rip), %rax      # 0x346e6
movq %rax, -0x8(%rbp)
jmp 0x276e9
leaq 0xd007(%rip), %rax      # 0x346ec
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: gchen98[P]macs/datastructures.cpp
// Function: Node::addNewEdge(Node::EdgeLocation, boost::shared_ptr<Edge>&)
void Node::addNewEdge(EdgeLocation iLocation,
EdgePtr & newEdge){
    switch (iLocation){
        case Node::TOP_EDGE:
            if (topEdgeSize) this->topEdge2 = newEdge;
            else this->topEdge1 = newEdge;
            ++topEdgeSize;
            break;
        case Node::BOTTOM_EDGE:
            if (bottomEdgeSize) this->bottomEdge2 = newEdge;
            else this->bottomEdge1 = newEdge;
            ++bottomEdgeSize;
            break;
        break;
    }
    #ifdef DIAG
    switch(iType){
        case Node::COAL:
            if (bottomEdgeSize>2||
            topEdgeSize>1)
                throw "Coal node has too many edges\n";
            break;
        case Node::XOVER:
            if (topEdgeSize>2||
            bottomEdgeSize>1)
                throw "Xover node has too many edges\n";
            break;
        case Node::MIGRATION:
            if (bottomEdgeSize>1||
            topEdgeSize>1)
                throw "Migration node has too many edges\n";
            break;
        default:
            break;
    }
    #endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x27724
jmp 0x27717
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0x27765
jmp 0x277a4
movq -0x28(%rbp), %rax
cmpw $0x0, 0x68(%rax)
je 0x27742
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x30, %rdi
callq 0x2b7c0
jmp 0x27753
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rdi
callq 0x2b7c0
movq -0x28(%rbp), %rax
movw 0x68(%rax), %cx
addw $0x1, %cx
movw %cx, 0x68(%rax)
jmp 0x277a4
movq -0x28(%rbp), %rax
cmpw $0x0, 0x6a(%rax)
je 0x27783
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x50, %rdi
callq 0x2b7c0
jmp 0x27794
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x40, %rdi
callq 0x2b7c0
movq -0x28(%rbp), %rax
movw 0x6a(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6a(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movw %ax, -0xe(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x27140
movq -0x20(%rbp), %rdi
leaq 0x210cd(%rip), %rax     # 0x48af0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x18, %rdi
callq 0xbde0
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x2b8c0
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
callq 0x2b8c0
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
callq 0x2b8c0
movq -0x20(%rbp), %rdi
addq $0x50, %rdi
callq 0x2b8c0
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x64(%rax)
movw -0xe(%rbp), %cx
movw %cx, 0x62(%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x70(%rax)
movb $0x0, 0x60(%rax)
movw $0x0, 0x68(%rax)
movw $0x0, 0x6a(%rax)
movb $0x0, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: gchen98[P]macs/datastructures.cpp
// Function: Event::Event(Event::EventType, double)
Event::Event(EventType iType,double dTime):
PtrRefCountable(){
    #ifdef DIAG
    if (dTime<0) throw "Error in creating event. Time must be positive";
    cerr<<"At time "<<this->dTime<<" Graph event constructor\n";
    #endif
    this->iType = iType;
    this->dTime = dTime;
    this->bMarkedForDelete = false;
    if (dTime>Node::MAX_HEIGHT) throw "Stop here\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x27140
movq -0x30(%rbp), %rax
leaq 0x20ef4(%rip), %rcx     # 0x48b10
addq $0x10, %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x14(%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x18(%rax)
movb $0x0, 0x10(%rax)
movsd -0x18(%rbp), %xmm0
leaq 0xa545(%rip), %rax      # 0x32188
ucomisd (%rax), %xmm0
jbe 0x27c89
movl $0x8, %edi
callq 0x4130
movq %rax, %rdi
leaq 0xcabc(%rip), %rax      # 0x34719
movq %rax, (%rdi)
movq 0x21351(%rip), %rsi     # 0x48fb8
xorl %eax, %eax
movl %eax, %edx
callq 0x44c0
jmp 0x27c98
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x27170
jmp 0x27c8f
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x44e0
nopl (%rax,%rax)
// File: gchen98[P]macs/datastructures.cpp
// Function: GraphBuilder::mergeEdges(boost::shared_ptr<Edge>&, boost::shared_ptr<Edge>&)
void GraphBuilder::mergeEdges(EdgePtr & topEdge,EdgePtr & bottomEdge){
    #ifdef DIAG
    if (topEdge->getBottomNodeRef()->getHeight()!=bottomEdge->getTopNodeRef()->getHeight())
    throw "The top edge and bottom edge are mismatched for the join";
    #endif
    // mark expired node as deleted
    bottomEdge->getTopNodeRef()->bDeleted = true;
    NodePtr & bottomNode = bottomEdge->getBottomNodeRef();
    bottomNode->replaceOldWithNewEdge(Node::TOP_EDGE,bottomEdge,topEdge);
    topEdge->setBottomNode(bottomNode);
    deleteEdge(bottomEdge);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1de60
movq %rax, %rdi
callq 0x1e1e0
movq %rax, %rdi
callq 0x1ded0
movb $0x1, 0x10(%rax)
movq -0x18(%rbp), %rdi
callq 0x1de60
movq %rax, %rdi
callq 0x1deb0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1ded0
movq %rax, %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
xorl %esi, %esi
callq 0x277b0
movq -0x10(%rbp), %rdi
callq 0x1de60
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x27600
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a370
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gchen98[P]macs/datastructures.cpp
// Function: GraphBuilder::deleteEdge(boost::shared_ptr<Edge>&)
void GraphBuilder::deleteEdge(EdgePtr & edge){
    if (!edge->bDeleted){
        edge->bDeleted = true;
        if (pConfig->bDebug){
            cerr<<"Deleting edge with hts "<<edge->getBottomNodeRef()->getHeight()<<" and "<<
            edge->getTopNodeRef()->getHeight()<<endl;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1de60
testb $0x1, 0x10(%rax)
jne 0x2a44c
movq -0x10(%rbp), %rdi
callq 0x1de60
movq %rax, %rcx
movq -0x18(%rbp), %rax
movb $0x1, 0x10(%rcx)
movq 0x8(%rax), %rax
testb $0x1, 0x48(%rax)
je 0x2a44a
movq 0x1ec2c(%rip), %rdi     # 0x48ff0
leaq 0xa3cc(%rip), %rsi      # 0x34797
callq 0x42b0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1de60
movq %rax, %rdi
callq 0x1deb0
movq %rax, %rdi
callq 0x1ded0
movq %rax, %rdi
callq 0x1df20
movq -0x28(%rbp), %rdi
callq 0x4550
movq %rax, %rdi
leaq 0xa3a7(%rip), %rsi      # 0x347af
callq 0x42b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1de60
movq %rax, %rdi
callq 0x1e1e0
movq %rax, %rdi
callq 0x1ded0
movq %rax, %rdi
callq 0x1df20
movq -0x20(%rbp), %rdi
callq 0x4550
movq %rax, %rdi
movq 0x1eb6b(%rip), %rsi     # 0x48fb0
callq 0x4300
jmp 0x2a44c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1de60
movq %rax, %rdi
callq 0x1deb0
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x1e2c0
movq -0x18(%rbp), %rdi
callq 0x1de60
movl 0x14(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1de60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x27600
jmp 0x2a4bf
movq -0x10(%rbp), %rdi
callq 0x1ded0
movq %rax, %rdi
movq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x276f0
movl $0x30, %edi
callq 0x42c0
movq %rax, -0x58(%rbp)
jmp 0x2a4e6
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x27460
jmp 0x2a4f9
movq -0x58(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x1e5c0
jmp 0x2a508
movl -0x24(%rbp), %eax
movl %eax, -0x64(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x1de60
movl -0x64(%rbp), %ecx
movq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rsi
movl %ecx, 0x14(%rax)
callq 0x29f50
jmp 0x2a530
leaq -0x20(%rbp), %rdi
callq 0x1ded0
movq %rax, %rdi
movq -0x18(%rbp), %rdx
xorl %esi, %esi
leaq -0x48(%rbp), %rcx
callq 0x277b0
jmp 0x2a54d
movq -0x10(%rbp), %rdi
callq 0x1ded0
movq %rax, %rdi
movl $0x1, %esi
leaq -0x48(%rbp), %rdx
callq 0x276f0
leaq -0x48(%rbp), %rdi
callq 0x1e090
leaq -0x20(%rbp), %rdi
callq 0x1e420
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2a5be
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x30, %esi
callq 0x42d0
jmp 0x2a5be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1e090
leaq -0x20(%rbp), %rdi
callq 0x1e420
movq -0x30(%rbp), %rdi
callq 0x44e0
// File: gchen98[P]macs/datastructures.cpp
// Function: GraphBuilder::addEdgeToCurrentTree(boost::shared_ptr<Edge>&)
void GraphBuilder::addEdgeToCurrentTree(EdgePtr & edge){
    edge->bInCurrentTree = true;
    edge->iGraphIteration = this->iGraphIteration;
    if (iTotalTreeEdges<pEdgeVectorInTree->size()){
        pEdgeVectorInTree->at(iTotalTreeEdges) = edge;
    }else{
        pEdgeVectorInTree->push_back(edge);
    }
    ++iTotalTreeEdges;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1de60
movq %rax, %rcx
movq -0x20(%rbp), %rax
movb $0x1, 0x12(%rcx)
movl 0xd0(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1de60
movl -0x24(%rbp), %edx
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl %edx, 0x14(%rcx)
movl 0x20(%rax), %ecx
movq %rcx, -0x18(%rbp)
movq 0x18(%rax), %rdi
callq 0x1e150
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x2a65f
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq 0x18(%rax), %rdi
movl 0x20(%rax), %eax
movl %eax, %esi
callq 0x2be90
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x1e000
jmp 0x2a670
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2bde0
movq -0x20(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)