LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::debruijn_graph::get_all_ends() const
unordered_set<debruijn_graph::node> debruijn_graph::get_all_ends(void) const {
		unordered_set<node> result;
		for (auto it = begins.begin(); it != begins.end(); ++it)
			result.insert(*it);
		for (auto it = ends.begin(); it != ends.end(); ++it)
			result.insert(*it);
		//for (const auto & p : left_ends)
		//result.insert(p.first);
		//for (const auto & p : right_ends)
		//result.insert(p.first);
		return result;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, -0x160(%rbp)
movq %rdi, %rax
movq %rax, -0x158(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x150(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xfa60
movq -0x150(%rbp), %rsi
addq $0x30, %rsi
leaq -0x50(%rbp), %rdi
callq 0xfa80
jmp 0x4d8e
jmp 0x4d90
movq -0x150(%rbp), %rsi
addq $0x30, %rsi
leaq -0x98(%rbp), %rdi
callq 0xfb60
jmp 0x4da9
leaq -0x50(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xfb10
movb %al, -0x161(%rbp)
jmp 0x4dc1
movb -0x161(%rbp), %al
testb $0x1, %al
jne 0x4dd0
jmp 0x4e6b
leaq -0x50(%rbp), %rdi
callq 0xfc30
movq %rdx, -0x170(%rbp)
movl %eax, -0x168(%rbp)
jmp 0x4de8
movq -0x160(%rbp), %rdi
movq -0x170(%rbp), %rax
movl -0x168(%rbp), %ecx
movl %ecx, -0xa8(%rbp)
movq %rax, -0xa0(%rbp)
leaq -0xa8(%rbp), %rsi
callq 0xfbf0
movb %dl, -0x179(%rbp)
movq %rax, -0x178(%rbp)
jmp 0x4e24
movb -0x179(%rbp), %al
movq -0x178(%rbp), %rcx
movq %rcx, -0xb8(%rbp)
movb %al, -0xb0(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xfce0
jmp 0x4e49
jmp 0x4d90
movq -0x160(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0xded0
jmp 0x4f73
movq -0x150(%rbp), %rsi
addq $0x58, %rsi
leaq -0xf0(%rbp), %rdi
callq 0xfa80
jmp 0x4e84
jmp 0x4e86
movq -0x150(%rbp), %rsi
addq $0x58, %rsi
leaq -0x128(%rbp), %rdi
callq 0xfb60
jmp 0x4e9f
leaq -0xf0(%rbp), %rdi
leaq -0x128(%rbp), %rsi
callq 0xfb10
movb %al, -0x17a(%rbp)
jmp 0x4eba
movb -0x17a(%rbp), %al
testb $0x1, %al
jne 0x4ec9
jmp 0x4f4d
leaq -0xf0(%rbp), %rdi
callq 0xfc30
movq %rdx, -0x188(%rbp)
movl %eax, -0x180(%rbp)
jmp 0x4ee4
movq -0x160(%rbp), %rdi
movq -0x188(%rbp), %rax
movl -0x180(%rbp), %ecx
movl %ecx, -0x138(%rbp)
movq %rax, -0x130(%rbp)
leaq -0x138(%rbp), %rsi
callq 0xfbf0
movb %dl, -0x191(%rbp)
movq %rax, -0x190(%rbp)
jmp 0x4f20
movb -0x191(%rbp), %al
movq -0x190(%rbp), %rcx
movq %rcx, -0x148(%rbp)
movb %al, -0x140(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0xfce0
jmp 0x4f48
jmp 0x4e86
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x4f63
movq -0x160(%rbp), %rdi
callq 0xded0
movq -0x158(%rbp), %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3480
nopl (%rax)
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::debruijn_graph::left_edges(dna::canonical_kmer) const
set<debruijn_graph::edge> debruijn_graph::left_edges(node n) const {
		set<edge> result;
		for (const auto b : bases) {
			edge e = b + n;
			if (abundance(e) && !is_duplex_edge(n, e))
				result.insert(e);
		}
		return result;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xe8(%rbp)
movb $0x0, -0x21(%rbp)
callq 0xe080
leaq 0x24b3a(%rip), %rax     # 0x2a010
movq %rax, -0x30(%rbp)
leaq 0x24b2f(%rip), %rax     # 0x2a010
movq %rax, -0x38(%rbp)
leaq 0x24b24(%rip), %rax     # 0x2a010
addq $0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x5664
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %esi
leaq -0x78(%rbp), %rdi
callq 0x3820
jmp 0x5519
movups -0x18(%rbp), %xmm0
movaps %xmm0, -0xa0(%rbp)
movl -0x78(%rbp), %edi
movq -0x70(%rbp), %rsi
movl -0xa0(%rbp), %edx
movq -0x98(%rbp), %rcx
callq 0x3f10
movq %rdx, -0x108(%rbp)
movl %eax, -0xfc(%rbp)
jmp 0x554c
movq -0x108(%rbp), %rax
movl -0xfc(%rbp), %ecx
movl %ecx, -0x68(%rbp)
movq %rax, -0x60(%rbp)
movl -0x68(%rbp), %esi
movq -0x60(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x4300
jmp 0x5572
movq -0xe8(%rbp), %rdi
movups -0x58(%rbp), %xmm0
movaps %xmm0, -0xb0(%rbp)
movl -0xb0(%rbp), %esi
movq -0xa8(%rbp), %rdx
callq 0x4450
movq %rax, -0x110(%rbp)
jmp 0x559f
movq -0x110(%rbp), %rax
cmpq $0x0, %rax
je 0x5651
movups -0x18(%rbp), %xmm0
movaps %xmm0, -0xc0(%rbp)
movups -0x58(%rbp), %xmm0
movaps %xmm0, -0xd0(%rbp)
movl -0xc0(%rbp), %edi
movq -0xb8(%rbp), %rsi
movl -0xd0(%rbp), %edx
movq -0xc8(%rbp), %rcx
callq 0x56a0
movb %al, -0x111(%rbp)
jmp 0x55ed
movb -0x111(%rbp), %al
testb $0x1, %al
jne 0x5651
jmp 0x55f9
movq -0xf8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xe0a0
movb %dl, -0x121(%rbp)
movq %rax, -0x120(%rbp)
jmp 0x5618
movb -0x121(%rbp), %al
movq -0x120(%rbp), %rcx
movq %rcx, -0xe0(%rbp)
movb %al, -0xd8(%rbp)
jmp 0x5651
movq -0xf8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
callq 0xe0f0
jmp 0x568a
jmp 0x5653
movq -0x38(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
jmp 0x54f4
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x567a
movq -0xf8(%rbp), %rdi
callq 0xe0f0
movq -0xf0(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x3480
nopw %cs:(%rax,%rax)
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::is_duplex_edge(dna::canonical_kmer, dna::canonical_kmer)
bool is_duplex_edge(debruijn_graph::node n, debruijn_graph::edge e) {
		bool lefty = false, righty = false;
		for (const auto b : bases) {
			righty |= (e == canonicalize(n + b));
			lefty |= (e == canonicalize(b + n));
		}
		return righty && lefty;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0x20(%rbp)
movq %rcx, -0x18(%rbp)
movb $0x0, -0x21(%rbp)
movb $0x0, -0x22(%rbp)
leaq 0x24948(%rip), %rax     # 0x2a010
movq %rax, -0x30(%rbp)
leaq 0x2493d(%rip), %rax     # 0x2a010
movq %rax, -0x38(%rbp)
leaq 0x24932(%rip), %rax     # 0x2a010
addq $0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x5862
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x44(%rbp), %esi
leaq -0x98(%rbp), %rdi
callq 0x3820
movl -0x88(%rbp), %edi
movq -0x80(%rbp), %rsi
movl -0x98(%rbp), %edx
movq -0x90(%rbp), %rcx
callq 0x3f10
movl %eax, -0x78(%rbp)
movq %rdx, -0x70(%rbp)
movl -0x78(%rbp), %edi
movq -0x70(%rbp), %rsi
callq 0x3d40
movl %eax, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movl -0x58(%rbp), %edi
movq -0x50(%rbp), %rsi
movl -0x68(%rbp), %edx
movq -0x60(%rbp), %rcx
callq 0x3b80
andb $0x1, %al
movzbl %al, %ecx
movb -0x22(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x22(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movl -0x44(%rbp), %esi
leaq -0xd8(%rbp), %rdi
callq 0x3820
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe0(%rbp)
movl -0xd8(%rbp), %edi
movq -0xd0(%rbp), %rsi
movl -0xe8(%rbp), %edx
movq -0xe0(%rbp), %rcx
callq 0x3f10
movl %eax, -0xc8(%rbp)
movq %rdx, -0xc0(%rbp)
movl -0xc8(%rbp), %edi
movq -0xc0(%rbp), %rsi
callq 0x3d40
movl %eax, -0xb8(%rbp)
movq %rdx, -0xb0(%rbp)
movl -0xa8(%rbp), %edi
movq -0xa0(%rbp), %rsi
movl -0xb8(%rbp), %edx
movq -0xb0(%rbp), %rcx
callq 0x3b80
andb $0x1, %al
movzbl %al, %ecx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x38(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
jmp 0x56e6
xorl %eax, %eax
testb $0x1, -0x22(%rbp)
movb %al, -0xe9(%rbp)
je 0x5879
movb -0x21(%rbp), %al
movb %al, -0xe9(%rbp)
movb -0xe9(%rbp), %al
andb $0x1, %al
addq $0xf0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::debruijn_graph::right_edges(dna::canonical_kmer) const
set<debruijn_graph::edge> debruijn_graph::right_edges(node n) const {
		set<edge> result;
		for (const auto b : bases) {
			edge e = n + b;
			if (abundance(e) && !is_duplex_edge(n, e))
				result.insert(e);
		}
		return result;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xe8(%rbp)
movb $0x0, -0x21(%rbp)
callq 0xe080
leaq 0x2473a(%rip), %rax     # 0x2a010
movq %rax, -0x30(%rbp)
leaq 0x2472f(%rip), %rax     # 0x2a010
movq %rax, -0x38(%rbp)
leaq 0x24724(%rip), %rax     # 0x2a010
addq $0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x5a67
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movups -0x18(%rbp), %xmm0
movaps %xmm0, -0x80(%rbp)
movl -0x44(%rbp), %esi
leaq -0x90(%rbp), %rdi
callq 0x3820
jmp 0x5924
movl -0x80(%rbp), %edi
movq -0x78(%rbp), %rsi
movl -0x90(%rbp), %edx
movq -0x88(%rbp), %rcx
callq 0x3f10
movq %rdx, -0x108(%rbp)
movl %eax, -0xfc(%rbp)
jmp 0x594c
movq -0x108(%rbp), %rax
movl -0xfc(%rbp), %ecx
movl %ecx, -0x68(%rbp)
movq %rax, -0x60(%rbp)
movl -0x68(%rbp), %esi
movq -0x60(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x4300
jmp 0x5972
movq -0xe8(%rbp), %rdi
movups -0x58(%rbp), %xmm0
movaps %xmm0, -0xb0(%rbp)
movl -0xb0(%rbp), %esi
movq -0xa8(%rbp), %rdx
callq 0x4450
movq %rax, -0x110(%rbp)
jmp 0x599f
movq -0x110(%rbp), %rax
cmpq $0x0, %rax
je 0x5a54
movups -0x18(%rbp), %xmm0
movaps %xmm0, -0xc0(%rbp)
movups -0x58(%rbp), %xmm0
movaps %xmm0, -0xd0(%rbp)
movl -0xc0(%rbp), %edi
movq -0xb8(%rbp), %rsi
movl -0xd0(%rbp), %edx
movq -0xc8(%rbp), %rcx
callq 0x56a0
movb %al, -0x111(%rbp)
jmp 0x59ed
movb -0x111(%rbp), %al
testb $0x1, %al
jne 0x5a54
jmp 0x59f9
movq -0xf8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xe0a0
movb %dl, -0x121(%rbp)
movq %rax, -0x120(%rbp)
jmp 0x5a18
movb -0x121(%rbp), %al
movq -0x120(%rbp), %rcx
movq %rcx, -0xe0(%rbp)
movb %al, -0xd8(%rbp)
jmp 0x5a54
movq -0xf8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
callq 0xe0f0
jmp 0x5a8d
jmp 0x5a56
movq -0x38(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
jmp 0x58f4
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x5a7d
movq -0xf8(%rbp), %rdi
callq 0xe0f0
movq -0xf0(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x3480
nopl (%rax)
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::debruijn_graph::left_abundance(dna::canonical_kmer) const
uint64_t debruijn_graph::left_abundance(node n) const {
		uint64_t sum = 0;
		for (const auto &e : left_edges(n))
			sum += abundance(e);
		return sum;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %esi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movq %rsi, -0xa8(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x68(%rbp), %edx
movq -0x60(%rbp), %rcx
leaq -0x58(%rbp), %rdi
callq 0x5490
leaq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xe180
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rdi
callq 0xe1b0
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xe1e0
testb $0x1, %al
jne 0x72b7
leaq -0x58(%rbp), %rdi
callq 0xe0f0
jmp 0x732b
leaq -0x70(%rbp), %rdi
callq 0xe210
movq -0xa8(%rbp), %rdi
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x90(%rbp)
movl -0x90(%rbp), %esi
movq -0x88(%rbp), %rdx
callq 0x4450
movq %rax, -0xb0(%rbp)
jmp 0x72f4
movq -0xb0(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xe230
jmp 0x729b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xe0f0
jmp 0x7338
movq -0x20(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x3480
nopw %cs:(%rax,%rax)
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::debruijn_graph::right_abundance(dna::canonical_kmer) const
uint64_t debruijn_graph::right_abundance(node n) const {
		uint64_t sum = 0;
		for (const auto &e : right_edges(n))
			sum += abundance(e);
		return sum;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %esi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movq %rsi, -0xa8(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x68(%rbp), %edx
movq -0x60(%rbp), %rcx
leaq -0x58(%rbp), %rdi
callq 0x5890
leaq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xe180
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rdi
callq 0xe1b0
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xe1e0
testb $0x1, %al
jne 0x73d7
leaq -0x58(%rbp), %rdi
callq 0xe0f0
jmp 0x744b
leaq -0x70(%rbp), %rdi
callq 0xe210
movq -0xa8(%rbp), %rdi
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x90(%rbp)
movl -0x90(%rbp), %esi
movq -0x88(%rbp), %rdx
callq 0x4450
movq %rax, -0xb0(%rbp)
jmp 0x7414
movq -0xb0(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xe230
jmp 0x73bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xe0f0
jmp 0x7458
movq -0x20(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x3480
nopw %cs:(%rax,%rax)
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::debruijn_graph::duplex_abundance(dna::canonical_kmer) const
uint64_t debruijn_graph::duplex_abundance(node n) const {
		uint64_t sum = 0;
		for (const auto &e : duplex_edges(n))
			sum += abundance(e);
		return sum;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %esi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movq %rsi, -0xa8(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x68(%rbp), %edx
movq -0x60(%rbp), %rcx
leaq -0x58(%rbp), %rdi
callq 0x5aa0
leaq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xe180
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rdi
callq 0xe1b0
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xe1e0
testb $0x1, %al
jne 0x74f7
leaq -0x58(%rbp), %rdi
callq 0xe0f0
jmp 0x756b
leaq -0x70(%rbp), %rdi
callq 0xe210
movq -0xa8(%rbp), %rdi
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x90(%rbp)
movl -0x90(%rbp), %esi
movq -0x88(%rbp), %rdx
callq 0x4450
movq %rax, -0xb0(%rbp)
jmp 0x7534
movq -0xb0(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xe230
jmp 0x74db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xe0f0
jmp 0x7578
movq -0x20(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x3480
nopw %cs:(%rax,%rax)
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::is_left_edge(dna::canonical_kmer, dna::canonical_kmer)
bool is_left_edge(debruijn_graph::node n, debruijn_graph::edge e) {
		for (const auto b : bases)
			if (e == canonicalize(b + n))
				return !is_duplex_edge(n, e);
		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x28(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x22560(%rip), %rax     # 0x2a010
movq %rax, -0x30(%rbp)
leaq 0x22555(%rip), %rax     # 0x2a010
movq %rax, -0x38(%rbp)
leaq 0x2254a(%rip), %rax     # 0x2a010
addq $0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x7bd0
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x44(%rbp), %esi
leaq -0x88(%rbp), %rdi
callq 0x3820
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movl -0x88(%rbp), %edi
movq -0x80(%rbp), %rsi
movl -0x98(%rbp), %edx
movq -0x90(%rbp), %rcx
callq 0x3f10
movl %eax, -0x78(%rbp)
movq %rdx, -0x70(%rbp)
movl -0x78(%rbp), %edi
movq -0x70(%rbp), %rsi
callq 0x3d40
movl %eax, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movl -0x58(%rbp), %edi
movq -0x50(%rbp), %rsi
movl -0x68(%rbp), %edx
movq -0x60(%rbp), %rcx
callq 0x3b80
testb $0x1, %al
jne 0x7b69
jmp 0x7bbd
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl -0xa8(%rbp), %edi
movq -0xa0(%rbp), %rsi
movl -0xb8(%rbp), %edx
movq -0xb0(%rbp), %rcx
callq 0x56a0
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x7bd4
jmp 0x7bbf
movq -0x38(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
jmp 0x7ace
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::is_right_edge(dna::canonical_kmer, dna::canonical_kmer)
bool is_right_edge(debruijn_graph::node n, debruijn_graph::edge e) {
		for (const auto b : bases)
			if (e == canonicalize(n + b))
				return !is_duplex_edge(n, e);
		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x28(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x22400(%rip), %rax     # 0x2a010
movq %rax, -0x30(%rbp)
leaq 0x223f5(%rip), %rax     # 0x2a010
movq %rax, -0x38(%rbp)
leaq 0x223ea(%rip), %rax     # 0x2a010
addq $0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x7d2d
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x44(%rbp), %esi
leaq -0x98(%rbp), %rdi
callq 0x3820
movl -0x88(%rbp), %edi
movq -0x80(%rbp), %rsi
movl -0x98(%rbp), %edx
movq -0x90(%rbp), %rcx
callq 0x3f10
movl %eax, -0x78(%rbp)
movq %rdx, -0x70(%rbp)
movl -0x78(%rbp), %edi
movq -0x70(%rbp), %rsi
callq 0x3d40
movl %eax, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movl -0x58(%rbp), %edi
movq -0x50(%rbp), %rsi
movl -0x68(%rbp), %edx
movq -0x60(%rbp), %rcx
callq 0x3b80
testb $0x1, %al
jne 0x7cc6
jmp 0x7d1a
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl -0xa8(%rbp), %edi
movq -0xa0(%rbp), %rsi
movl -0xb8(%rbp), %edx
movq -0xb0(%rbp), %rcx
callq 0x56a0
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x7d31
jmp 0x7d1c
movq -0x38(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
jmp 0x7c2e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
nop
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::debruijn_graph::left_invariant_value(dna::canonical_kmer) const
int64_t debruijn_graph::left_invariant_value(node n) const
	{
		uint64_t sum = 0;
		for (const auto &e : left_edges(n))
			sum += (is_loop(e) ? 2 : 1) * abundance(e);
		return sum - get_left_ends(n);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movl %esi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movq %rsi, -0xc8(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x68(%rbp), %edx
movq -0x60(%rbp), %rcx
leaq -0x58(%rbp), %rdi
callq 0x5490
leaq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xe180
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rdi
callq 0xe1b0
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xe1e0
testb $0x1, %al
jne 0x7dca
leaq -0x58(%rbp), %rdi
callq 0xe0f0
jmp 0x7e8a
leaq -0x70(%rbp), %rdi
callq 0xe210
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x90(%rbp)
movl -0x90(%rbp), %edi
movq -0x88(%rbp), %rsi
callq 0x7ef0
movb %al, -0xc9(%rbp)
jmp 0x7dff
movq -0xc8(%rbp), %rdi
movb -0xc9(%rbp), %al
movzbl %al, %eax
andl $0x1, %eax
incq %rax
movq %rax, -0xe0(%rbp)
movq -0x80(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0xb0(%rbp)
movl -0xb0(%rbp), %esi
movq -0xa8(%rbp), %rdx
callq 0x4450
movq %rax, -0xd8(%rbp)
jmp 0x7e45
movq -0xd8(%rbp), %rcx
movq -0xe0(%rbp), %rax
imulq %rcx, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xe230
jmp 0x7dab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xe0f0
jmp 0x7eda
movq -0xc8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movl -0xc0(%rbp), %esi
movq -0xb8(%rbp), %rdx
callq 0x79c0
movq %rax, %rcx
movq -0xe8(%rbp), %rax
subq %rcx, %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x3480
nopw %cs:(%rax,%rax)
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::debruijn_graph::right_invariant_value(dna::canonical_kmer) const
int64_t debruijn_graph::right_invariant_value(node n) const
	{
		uint64_t sum = 0;
		for (const auto &e : right_edges(n))
			sum += (is_loop(e) ? 2 : 1) * abundance(e);
		return sum - get_right_ends(n);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movl %esi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movq %rsi, -0xc8(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x68(%rbp), %edx
movq -0x60(%rbp), %rcx
leaq -0x58(%rbp), %rdi
callq 0x5890
leaq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xe180
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rdi
callq 0xe1b0
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xe1e0
testb $0x1, %al
jne 0x7fda
leaq -0x58(%rbp), %rdi
callq 0xe0f0
jmp 0x809a
leaq -0x70(%rbp), %rdi
callq 0xe210
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x90(%rbp)
movl -0x90(%rbp), %edi
movq -0x88(%rbp), %rsi
callq 0x7ef0
movb %al, -0xc9(%rbp)
jmp 0x800f
movq -0xc8(%rbp), %rdi
movb -0xc9(%rbp), %al
movzbl %al, %eax
andl $0x1, %eax
incq %rax
movq %rax, -0xe0(%rbp)
movq -0x80(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0xb0(%rbp)
movl -0xb0(%rbp), %esi
movq -0xa8(%rbp), %rdx
callq 0x4450
movq %rax, -0xd8(%rbp)
jmp 0x8055
movq -0xd8(%rbp), %rcx
movq -0xe0(%rbp), %rax
imulq %rcx, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xe230
jmp 0x7fbb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xe0f0
jmp 0x80ea
movq -0xc8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movl -0xc0(%rbp), %esi
movq -0xb8(%rbp), %rdx
callq 0x7a50
movq %rax, %rcx
movq -0xe8(%rbp), %rax
subq %rcx, %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x3480
nopw %cs:(%rax,%rax)
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::debruijn_graph::invariant_implied_abundance_correction(dna::canonical_kmer, dna::canonical_kmer) const
int64_t debruijn_graph::invariant_implied_abundance_correction(node n,
																																 edge e) const {
		if (is_left_edge(n, e))
			return invariant_discrepancy(n);
		else if (is_right_edge(n, e))
			return -invariant_discrepancy(n);
		else // duplex edge
			return 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %esi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x28(%rbp)
movq %r8, -0x20(%rbp)
movq %rdi, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x40(%rbp), %edi
movq -0x38(%rbp), %rsi
movl -0x50(%rbp), %edx
movq -0x48(%rbp), %rcx
callq 0x7a90
testb $0x1, %al
jne 0x81d1
jmp 0x81fa
movq -0x98(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x60(%rbp), %esi
movq -0x58(%rbp), %rdx
callq 0x8100
movq %rax, -0x8(%rbp)
jmp 0x8278
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x70(%rbp), %edi
movq -0x68(%rbp), %rsi
movl -0x80(%rbp), %edx
movq -0x78(%rbp), %rcx
callq 0x7bf0
testb $0x1, %al
jne 0x8233
jmp 0x8270
movq -0x98(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movl -0x90(%rbp), %esi
movq -0x88(%rbp), %rdx
callq 0x8100
movq %rax, %rcx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x8278
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::debruijn_graph::abundance_is_correct_whp(dna::canonical_kmer) const
bool debruijn_graph::abundance_is_correct_whp(edge e) const {
		// FIXME: need to check for small cycles, and adjust 3
		for (const auto & n : nearby_nodes(left_node(e), 3))
			if (invariant_discrepancy(n) != 0)
				return false;
		return period(e) > 6;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movl %esi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x210(%rbp)
movups -0x18(%rbp), %xmm0
movaps %xmm0, -0x90(%rbp)
movl -0x90(%rbp), %edi
movq -0x88(%rbp), %rsi
callq 0x7680
movq -0x210(%rbp), %rsi
movl %eax, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
movl -0x80(%rbp), %edx
movq -0x78(%rbp), %rcx
leaq -0x70(%rbp), %rdi
movq %rdi, -0x208(%rbp)
movl $0x3, %r8d
callq 0x50a0
movq -0x208(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x120(%rbp), %rdi
callq 0xfd00
jmp 0x8316
movq -0x28(%rbp), %rsi
leaq -0x1c0(%rbp), %rdi
callq 0xfd90
jmp 0x8328
jmp 0x832a
leaq -0x120(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0xfe40
movb %al, -0x211(%rbp)
jmp 0x8345
movb -0x211(%rbp), %al
testb $0x1, %al
jne 0x83b1
jmp 0x8351
movl $0x2, -0x1c4(%rbp)
jmp 0x8459
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x128(%rbp)
movl %eax, -0x12c(%rbp)
jmp 0x8495
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x128(%rbp)
movl %eax, -0x12c(%rbp)
jmp 0x8489
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x128(%rbp)
movl %eax, -0x12c(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x10220
jmp 0x8489
leaq -0x120(%rbp), %rdi
callq 0xfe90
movq %rdx, -0x220(%rbp)
movl %eax, -0x218(%rbp)
jmp 0x83cc
movq -0x210(%rbp), %rdi
movq -0x220(%rbp), %rax
movl -0x218(%rbp), %ecx
movl %ecx, -0x1e0(%rbp)
movq %rax, -0x1d8(%rbp)
leaq -0x1e0(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq -0x1d0(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x1f0(%rbp)
movl -0x1f0(%rbp), %esi
movq -0x1e8(%rbp), %rdx
callq 0x8100
movq %rax, -0x228(%rbp)
jmp 0x8427
movq -0x228(%rbp), %rax
cmpq $0x0, %rax
je 0x8444
movb $0x0, -0x1(%rbp)
movl $0x1, -0x1c4(%rbp)
jmp 0x8459
jmp 0x8446
leaq -0x120(%rbp), %rdi
callq 0xfed0
jmp 0x8454
jmp 0x832a
leaq -0x1c0(%rbp), %rdi
callq 0x10220
leaq -0x120(%rbp), %rdi
callq 0x10220
leaq -0x70(%rbp), %rdi
callq 0xf8a0
movl -0x1c4(%rbp), %eax
subl $0x1, %eax
je 0x84d4
jmp 0x8487
jmp 0x84a0
leaq -0x120(%rbp), %rdi
callq 0x10220
leaq -0x70(%rbp), %rdi
callq 0xf8a0
jmp 0x84e2
movq -0x18(%rbp), %rax
movq %rax, -0x200(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1f8(%rbp)
movl -0x200(%rbp), %edi
movq -0x1f8(%rbp), %rsi
callq 0x4120
cmpq $0x6, %rax
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq -0x128(%rbp), %rdi
callq 0x3480
nop
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::debruijn_graph::abundance_is_definitely_correct(dna::canonical_kmer, std::unordered_map<unsigned long, dna::debruijn_graph::unresolved_edge_set, std::hash<unsigned long>, std::equal_to<unsigned long>, std::allocator<std::pair<unsigned long const, dna::debruijn_graph::unresolved_edge_set>>>&) const
bool debruijn_graph::abundance_is_definitely_correct(edge e,
																											 unresolved_edges_map &mbi) const {
		if (abundance(e) == 0)
			return true;
		
		uint64_t hash = occurences.get_hash(e);
		return mbi.count(hash) == 0 || mbi[hash].count(e) == 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %esi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x38(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0x4450
cmpq $0x0, %rax
jne 0x8567
movb $0x1, -0x1(%rbp)
jmp 0x85d5
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x50(%rbp), %esi
movq -0x48(%rbp), %rdx
callq 0x10250
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x102a0
movq %rax, %rcx
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x59(%rbp)
je 0x85cd
movq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x102d0
movq %rax, %rdi
leaq -0x18(%rbp), %rsi
callq 0x10300
cmpq $0x0, %rax
sete %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::debruijn_graph::left_side_is_definitely_correct(dna::canonical_kmer, std::unordered_map<unsigned long, dna::debruijn_graph::unresolved_edge_set, std::hash<unsigned long>, std::equal_to<unsigned long>, std::allocator<std::pair<unsigned long const, dna::debruijn_graph::unresolved_edge_set>>>&) const
bool
	debruijn_graph::left_side_is_definitely_correct(node n,
																									unresolved_edges_map &mbi) const {
		for (const auto & e : left_edges(n)) {
			if (!abundance_is_definitely_correct(e, mbi))
				return false;
		}
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %esi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rsi
movq %rsi, -0xb8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0x70(%rbp), %edx
movq -0x68(%rbp), %rcx
leaq -0x60(%rbp), %rdi
callq 0x5490
leaq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xe180
movq %rax, -0x78(%rbp)
movq -0x30(%rbp), %rdi
callq 0xe1b0
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xe1e0
testb $0x1, %al
jne 0x8667
movl $0x2, -0x84(%rbp)
jmp 0x86f6
leaq -0x78(%rbp), %rdi
callq 0xe210
movq -0xb8(%rbp), %rdi
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0xa0(%rbp)
movq -0x28(%rbp), %rcx
movl -0xa0(%rbp), %esi
movq -0x98(%rbp), %rdx
callq 0x8520
movb %al, -0xb9(%rbp)
jmp 0x86ad
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x86e6
jmp 0x86b9
movb $0x0, -0x1(%rbp)
movl $0x1, -0x84(%rbp)
jmp 0x86f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xe0f0
jmp 0x871e
jmp 0x86e8
leaq -0x78(%rbp), %rdi
callq 0xe230
jmp 0x8647
leaq -0x60(%rbp), %rdi
callq 0xe0f0
movl -0x84(%rbp), %eax
subl $0x1, %eax
je 0x8710
jmp 0x870c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x3480
nopw (%rax,%rax)
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::debruijn_graph::right_side_is_definitely_correct(dna::canonical_kmer, std::unordered_map<unsigned long, dna::debruijn_graph::unresolved_edge_set, std::hash<unsigned long>, std::equal_to<unsigned long>, std::allocator<std::pair<unsigned long const, dna::debruijn_graph::unresolved_edge_set>>>&) const
bool
	debruijn_graph::right_side_is_definitely_correct(node n,
																									 unresolved_edges_map &mbi) const {
		for (const auto & e : right_edges(n)) {
			if (!abundance_is_definitely_correct(e, mbi))
				return false;
		}
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %esi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rsi
movq %rsi, -0xb8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0x70(%rbp), %edx
movq -0x68(%rbp), %rcx
leaq -0x60(%rbp), %rdi
callq 0x5890
leaq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xe180
movq %rax, -0x78(%rbp)
movq -0x30(%rbp), %rdi
callq 0xe1b0
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xe1e0
testb $0x1, %al
jne 0x87b7
movl $0x2, -0x84(%rbp)
jmp 0x8846
leaq -0x78(%rbp), %rdi
callq 0xe210
movq -0xb8(%rbp), %rdi
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0xa0(%rbp)
movq -0x28(%rbp), %rcx
movl -0xa0(%rbp), %esi
movq -0x98(%rbp), %rdx
callq 0x8520
movb %al, -0xb9(%rbp)
jmp 0x87fd
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x8836
jmp 0x8809
movb $0x0, -0x1(%rbp)
movl $0x1, -0x84(%rbp)
jmp 0x8846
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xe0f0
jmp 0x886e
jmp 0x8838
leaq -0x78(%rbp), %rdi
callq 0xe230
jmp 0x8797
leaq -0x60(%rbp), %rdi
callq 0xe0f0
movl -0x84(%rbp), %eax
subl $0x1, %eax
je 0x8860
jmp 0x885c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x3480
nopw (%rax,%rax)
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::debruijn_graph::find_single_error_edge(dna::canonical_kmer, std::unordered_map<unsigned long, dna::debruijn_graph::unresolved_edge_set, std::hash<unsigned long>, std::equal_to<unsigned long>, std::allocator<std::pair<unsigned long const, dna::debruijn_graph::unresolved_edge_set>>>&) const
debruijn_graph::edge
	debruijn_graph::find_single_error_edge(node n,
																				 unresolved_edges_map &mbi) const {
		vector<edge> error_edges;
		for (const auto & e : edges(n))
			if (!abundance_is_definitely_correct(e, mbi))
				error_edges.push_back(e);
		if (error_edges.size() == 1)
			return error_edges.front();
		return edge();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movl %esi, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x10330
movq -0xe0(%rbp), %rsi
movups -0x20(%rbp), %xmm0
movaps %xmm0, -0x90(%rbp)
movl -0x90(%rbp), %edx
movq -0x88(%rbp), %rcx
leaq -0x80(%rbp), %rdi
callq 0x5df0
jmp 0x88d8
leaq -0x80(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0xe180
movq %rax, -0xa8(%rbp)
movq -0x50(%rbp), %rdi
callq 0xe1b0
movq %rax, -0xb0(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0xe1e0
testb $0x1, %al
jne 0x893c
leaq -0x80(%rbp), %rdi
callq 0xe0f0
jmp 0x89d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x8a36
leaq -0xa8(%rbp), %rdi
callq 0xe210
movq -0xe0(%rbp), %rdi
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0xd0(%rbp)
movq -0x30(%rbp), %rcx
movl -0xd0(%rbp), %esi
movq -0xc8(%rbp), %rdx
callq 0x8520
movb %al, -0xe1(%rbp)
jmp 0x8985
movb -0xe1(%rbp), %al
testb $0x1, %al
jne 0x89c2
jmp 0x8991
movq -0xb8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x10350
jmp 0x89a3
jmp 0x89c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xe0f0
jmp 0x8a36
jmp 0x89c4
leaq -0xa8(%rbp), %rdi
callq 0xe230
jmp 0x8900
leaq -0x48(%rbp), %rdi
callq 0x103c0
cmpq $0x1, %rax
jne 0x8a08
leaq -0x48(%rbp), %rdi
callq 0x103e0
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0xd4(%rbp)
jmp 0x8a1d
leaq -0x10(%rbp), %rdi
callq 0x4180
jmp 0x8a13
movl $0x1, -0xd4(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x10410
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x10410
movq -0x98(%rbp), %rdi
callq 0x3480
nopl (%rax,%rax)
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::is_constant(dna::canonical_kmer)
bool is_constant(debruijn_graph::node n) {
		uint64_t b = n.val & 3ULL;
		uint64_t val = b * 0x5555555555555555;
		debruijn_graph::node n2(n.len, val & BITMASK(2*n.len));
		return n == n2;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
andq $0x3, %rax
movq %rax, -0x18(%rbp)
movabsq $0x5555555555555555, %rax # imm = 0x5555555555555555
imulq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x10(%rbp), %eax
shll %eax
cmpl $0x40, %eax
jne 0x9e93
movq $-0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0x9eac
movl -0x10(%rbp), %eax
shll %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x68(%rbp)
movl -0x5c(%rbp), %esi
movq -0x58(%rbp), %rdx
movq -0x68(%rbp), %rax
andq %rax, %rdx
leaq -0x30(%rbp), %rdi
callq 0x4200
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x40(%rbp), %edi
movq -0x38(%rbp), %rsi
movl -0x50(%rbp), %edx
movq -0x48(%rbp), %rcx
callq 0x3b80
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nop
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: print_time_elapsed(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, timeval*, timeval*)
void print_time_elapsed(string desc, struct timeval* start, struct timeval* end)
{
	struct timeval elapsed;
	if (start->tv_usec > end->tv_usec) {
		end->tv_usec += 1000000;
		end->tv_sec--;
	}
	elapsed.tv_usec = end->tv_usec - start->tv_usec;
	elapsed.tv_sec = end->tv_sec - start->tv_sec;
	float time_elapsed = (elapsed.tv_sec * 1000000 + elapsed.tv_usec)/1000000.f;
	cout << desc << "Total Time Elapsed: " << to_string(time_elapsed) << 
		"seconds" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jle 0xd75e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0xf4240, %rcx          # imm = 0xF4240
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
movq -0x68(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
imulq $0xf4240, %rax, %rax    # imm = 0xF4240
addq %rcx, %rax
cvtsi2ss %rax, %xmm0
movss 0x1c857(%rip), %xmm1    # 0x2a004
divss %xmm1, %xmm0
movss %xmm0, -0x2c(%rbp)
movq 0x2c813(%rip), %rdi     # 0x39fd0
callq 0x3270
movq %rax, %rdi
leaq 0x1cfef(%rip), %rsi     # 0x2a7bb
callq 0x3290
movq %rax, -0x80(%rbp)
movss -0x2c(%rbp), %xmm0
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x15f20
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x3270
movq %rax, -0x70(%rbp)
jmp 0xd7fa
movq -0x70(%rbp), %rdi
leaq 0x1cfcb(%rip), %rsi     # 0x2a7d0
callq 0x3290
movq %rax, -0x88(%rbp)
jmp 0xd813
movq -0x88(%rbp), %rdi
movq 0x2c797(%rip), %rsi     # 0x39fb8
callq 0x32e0
jmp 0xd828
leaq -0x50(%rbp), %rdi
callq 0x3150
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3150
movq -0x58(%rbp), %rdi
callq 0x3480
nopl (%rax,%rax)
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: unsigned long dna::kmer_hash<dna::canonical_kmer>(dna::canonical_kmer, unsigned int, unsigned __int128)
static uint64_t kmer_hash(kmer_type k, uint32_t seed, __uint128_t range) {
		return
			kmercounting::HashUtil::MurmurHash64A(&k.val,
																						sizeof(k.val),
																						seed)
			% range;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
movq %rsi, -0x8(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl %edx, -0x24(%rbp)
movq %rcx, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %edx
movl $0x8, %esi
callq 0x24050
movq %rax, %rdi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x3430
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::debruijn_graph::node_iterator<std::queue>::node_iterator(dna::debruijn_graph const&, std::unordered_set<dna::canonical_kmer, std::hash<dna::canonical_kmer>, std::equal_to<dna::canonical_kmer>, std::allocator<dna::canonical_kmer>>, unsigned long)
debruijn_graph::node_iterator<Q>::node_iterator(const debruijn_graph &g,
																									const std::unordered_set<node> starts,
																									uint64_t depth)
		: dbg(g) {
		for (const auto &n : starts) {
			work_item w;
			w.curr = n;
			w.depth = depth;
			work.push(w);
			visited.insert(n);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdx, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0xb0(%rbp)
callq 0x1b8a0
movq -0xa8(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0xa0(%rbp)
callq 0xfa60
movq -0x98(%rbp), %rdx
movq %rdx, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1b8d0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1b900
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x10720
testb $0x1, %al
jne 0x1b7a6
jmp 0x1b858
leaq -0x30(%rbp), %rdi
callq 0x1b930
movq %rax, -0x40(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1b960
jmp 0x1b7be
movq -0xa8(%rbp), %rdi
movq -0x40(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x70(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x8, %rdi
leaq -0x70(%rbp), %rsi
callq 0x1b990
jmp 0x1b7e7
movq -0xa8(%rbp), %rdi
addq $0x58, %rdi
movq -0x40(%rbp), %rsi
callq 0x10680
movb %dl, -0xb9(%rbp)
movq %rax, -0xb8(%rbp)
jmp 0x1b80a
movb -0xb9(%rbp), %al
movq -0xb8(%rbp), %rcx
movq %rcx, -0x90(%rbp)
movb %al, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1b9c0
jmp 0x1b790
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0xded0
movq -0xb0(%rbp), %rdi
callq 0x15740
jmp 0x1b861
addq $0xc0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x3480
nopw (%rax,%rax)
// File: splatlab[P]debgr/hashutil.cc
// Function: kmercounting::HashUtil::hash_64(unsigned long, unsigned long)
uint64_t HashUtil::hash_64(uint64_t key, uint64_t mask)
	{
		key = (~key + (key << 21)) & mask; // key = (key << 21) - key - 1;
		key = key ^ key >> 24;
		key = ((key + (key << 3)) + (key << 8)) & mask; // key * 265
		key = key ^ key >> 14;
		key = ((key + (key << 2)) + (key << 4)) & mask; // key * 21
		key = key ^ key >> 28;
		key = (key + (key << 31)) & mask;
		return key;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
xorq $-0x1, %rax
movq -0x8(%rbp), %rcx
shlq $0x15, %rcx
addq %rcx, %rax
andq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq $0x18, %rcx
xorq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
andq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq $0xe, %rcx
xorq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
andq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq $0x1c, %rcx
xorq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shlq $0x1f, %rcx
addq %rcx, %rax
andq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: splatlab[P]debgr/hashutil.cc
// Function: kmercounting::HashUtil::hash_64i(unsigned long, unsigned long)
uint64_t HashUtil::hash_64i(uint64_t key, uint64_t mask)
	{
		uint64_t tmp;

		// Invert key = key + (key << 31)
		tmp = (key - (key << 31));
		key = (key - (tmp << 31)) & mask;

		// Invert key = key ^ (key >> 28)
		tmp = key ^ key >> 28;
		key = key ^ tmp >> 28;

		// Invert key *= 21
		key = (key * 14933078535860113213ull) & mask;

		// Invert key = key ^ (key >> 14)
		tmp = key ^ key >> 14;
		tmp = key ^ tmp >> 14;
		tmp = key ^ tmp >> 14;
		key = key ^ tmp >> 14;

		// Invert key *= 265
		key = (key * 15244667743933553977ull) & mask;

		// Invert key = key ^ (key >> 24)
		tmp = key ^ key >> 24;
		key = key ^ tmp >> 24;

		// Invert key = (~key) + (key << 21)
		tmp = ~key;
		tmp = ~(key - (tmp << 21));
		tmp = ~(key - (tmp << 21));
		key = ~(key - (tmp << 21)) & mask;

		return key;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shlq $0x1f, %rcx
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shlq $0x1f, %rcx
subq %rcx, %rax
andq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq $0x1c, %rcx
xorq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq $0x1c, %rcx
xorq %rcx, %rax
movq %rax, -0x8(%rbp)
movabsq $-0x30c30c30c30c30c3, %rax # imm = 0xCF3CF3CF3CF3CF3D
imulq -0x8(%rbp), %rax
andq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq $0xe, %rcx
xorq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq $0xe, %rcx
xorq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq $0xe, %rcx
xorq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq $0xe, %rcx
xorq %rcx, %rax
movq %rax, -0x8(%rbp)
movabsq $-0x2c700f74e3fc22c7, %rax # imm = 0xD38FF08B1C03DD39
imulq -0x8(%rbp), %rax
andq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq $0x18, %rcx
xorq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq $0x18, %rcx
xorq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
xorq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shlq $0x15, %rcx
subq %rcx, %rax
xorq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shlq $0x15, %rcx
subq %rcx, %rax
xorq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shlq $0x15, %rcx
subq %rcx, %rax
xorq $-0x1, %rax
andq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: splatlab[P]debgr/threadsafe-gqf/gqf.c
// Function: qf_dump
void qf_dump(const QF *qf)
{
	uint64_t i;

	printf("%lu %lu %lu\n",
				 qf->metadata->nblocks,
				 qf->metadata->ndistinct_elts,
				 qf->metadata->nelts);

	for (i = 0; i < qf->metadata->nblocks; i++) {
		qf_dump_block(qf, i);
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x60(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x58(%rax), %rcx
leaq 0x63b9(%rip), %rdi      # 0x2aa70
movb $0x0, %al
callq 0x3030
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x50(%rcx), %rax
jae 0x246f3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x24700
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x246c6
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)