LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::insert_in_leaf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long)
Node *insert_in_leaf(E key, size_t i) {
			for (size_t j=elements; j > i; j--)
				keys[j] = keys[j-1]; // moves elements
			
			keys[i] = key; // add new element
			elements++;

			if (elements > order-1) // if node is full, split it
				return split(); // make new child

			return nullptr;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, -0x30(%rbp)
movq %rdi, %rbx
callq 0x2170
movq 0xb8(%rbx), %r14
leaq 0x38(%rbx), %r12
movq %r14, %rax
shlq $0x5, %rax
leaq (%rbx,%rax), %rdi
addq $0x38, %rdi
cmpq %r15, %r14
jbe 0x3854
decq %r14
leaq -0x20(%rdi), %r13
movq %r13, %rsi
callq 0x2120
movq %r13, %rdi
jmp 0x383b
shlq $0x5, %r15
addq %r15, %r12
movq %r12, %rdi
movq -0x30(%rbp), %rsi
callq 0x2120
movq 0xb8(%rbx), %rax
incq %rax
movq %rax, 0xb8(%rbx)
cmpq $0x3, %rax
jbe 0x3894
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a14
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::insert_in_node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long)
Node *insert_in_node(E key, size_t i) {

			Node *right_child = children[i]->insert(key); // if key smaller than value move it to child
			if (right_child == nullptr)	// nothing is split
				return nullptr;

			for (size_t j=elements; j > i; j--) {
				keys[j] = keys[j-1]; // moves elements
				children[j+1] = children[j]; // moves pointers
			}
			
			keys[i] = lift_key(children[i], right_child); // add new element
			elements++;

			children[i+1] = right_child;

			if (elements > order-1) // if node is full, split it
				return split(); // make new child

			return nullptr;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x2170
movq 0x8(%rbx,%r14,8), %r12
leaq -0x58(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x2240
movq %r12, %rdi
movq %r13, %rsi
callq 0x36c2
movq %rax, %r15
leaq -0x58(%rbp), %rdi
callq 0x20e0
testq %r15, %r15
je 0x39ad
movq %r15, -0x30(%rbp)
movq 0xb8(%rbx), %r15
leaq 0x38(%rbx), %rax
movq %rax, -0x38(%rbp)
movq %r15, %rax
shlq $0x5, %rax
leaq (%rbx,%rax), %rdi
addq $0x38, %rdi
cmpq %r14, %r15
jbe 0x3942
leaq -0x1(%r15), %r12
leaq -0x20(%rdi), %r13
movq %r13, %rsi
callq 0x2120
movq 0x8(%rbx,%r15,8), %rax
movq %rax, 0x10(%rbx,%r15,8)
movq %r13, %rdi
movq %r12, %r15
jmp 0x391b
movq 0x8(%rbx,%r14,8), %rax
cmpb $0x1, 0xc0(%rax)
jne 0x395d
movq -0x30(%rbp), %r15
movq %r15, %rsi
addq $0x38, %rsi
jmp 0x3974
movq 0xb8(%rax), %rcx
shlq $0x5, %rcx
leaq (%rax,%rcx), %rsi
addq $0x38, %rsi
movq -0x30(%rbp), %r15
movq %r14, %rax
shlq $0x5, %rax
movq -0x38(%rbp), %rdi
addq %rax, %rdi
callq 0x2120
movq 0xb8(%rbx), %rax
incq %rax
movq %rax, 0xb8(%rbx)
movq %r15, 0x10(%rbx,%r14,8)
cmpq $0x3, %rax
jbe 0x39ad
movq %rbx, %rdi
callq 0x3a14
jmp 0x39af
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::split()
Node *split() { // splits one Node in two

			size_t splitpoint = elements/2;

			Node * const left = this;
			Node *right = new Node(parent);

			right->leaf = left->leaf; // right is the same (inner or leaf) as left
			int z = leaf == false;

			for (size_t j = splitpoint+z; j < elements+1; j++)  {
				if (!leaf) {
					left->children[j]->parent = right; // copys children (one child more than value)
					right->children[right->elements] = left->children[j];
				}
				if (j<elements) {
					right->keys[right->elements] = left->keys[j]; // copies values
					right->elements++;
				}
			}

			left->elements = splitpoint; // sets new value for elements

			if (leaf) { // resets pointers to next and previous children
				right->next() = left->next();
				left->next() = right;
				right->previous() = left; 
				if (right->next() != nullptr)
					right->next()->previous() = right; 
			}
			return right;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x2170
movq 0xb8(%r14), %r15
movl $0xc8, %edi
callq 0x21d0
movq %rax, %rbx
movq (%r14), %rsi
movq %rax, %rdi
callq 0x31da
shrq %r15
movzbl 0xc0(%r14), %r13d
movb %r13b, 0xc0(%rbx)
xorq $0x1, %r13
movq %r15, -0x30(%rbp)
addq %r15, %r13
movq %rbx, %r12
addq $0x38, %r12
movq %r13, %rax
shlq $0x5, %rax
leaq (%rax,%r14), %r15
addq $0x38, %r15
movq 0xb8(%r14), %rax
leaq 0x1(%rax), %rcx
cmpq %rcx, %r13
jae 0x3ada
cmpb $0x0, 0xc0(%r14)
jne 0x3aaf
movq 0x8(%r14,%r13,8), %rcx
movq %rbx, (%rcx)
movq 0x8(%r14,%r13,8), %rcx
movq 0xb8(%rbx), %rdx
movq %rcx, 0x8(%rbx,%rdx,8)
cmpq %rax, %r13
jae 0x3ad1
movq 0xb8(%rbx), %rdi
shlq $0x5, %rdi
addq %r12, %rdi
movq %r15, %rsi
callq 0x2120
incq 0xb8(%rbx)
incq %r13
addq $0x20, %r15
jmp 0x3a7c
movq -0x30(%rbp), %rax
movq %rax, 0xb8(%r14)
cmpb $0x0, 0xc0(%r14)
je 0x3b08
movq 0x28(%r14), %rax
movq %rax, 0x28(%rbx)
movq %rbx, 0x28(%r14)
movq %r14, 0x8(%rbx)
testq %rax, %rax
je 0x3b08
movq %rbx, 0x8(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0xc8, %esi
movq %rbx, %rdi
callq 0x21f0
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::remove(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long)
void remove(E key, size_t pos_in_parent) {

			if (leaf) {
				for (size_t i=0; i < elements; i++) {
					if (key == keys[i]) {
						remove_from_leaf(i, pos_in_parent);
						break;
					} // else, loop ends without anything being removed
				}
			} 
			else {
				size_t i;
				for (i=0; i < elements; i++)
					if (keys[i] > key)
						break;

				children[i]->remove(key, i);
				// don't place ANYTHING here
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2170
leaq 0x38(%r14), %r15
cmpb $0x0, 0xc0(%r14)
je 0x3b83
xorl %r13d, %r13d
cmpq 0xb8(%r14), %r13
jae 0x3bd2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3797
testb %al, %al
jne 0x3be1
incq %r13
addq $0x20, %r15
jmp 0x3b62
xorl %r12d, %r12d
cmpq 0xb8(%r14), %r12
jae 0x3ba7
movq %r15, %rdi
movq %rbx, %rsi
callq 0x37d4
testb %al, %al
jne 0x3ba7
incq %r12
addq $0x20, %r15
jmp 0x3b86
movq 0x8(%r14,%r12,8), %r14
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2240
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3b32
leaq -0x48(%rbp), %rdi
callq 0x20e0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3c12
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/miniplane[P]mintree/./BpTree.h
// Function: void shift<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, unsigned long, unsigned long, int)
inline void shift(E* array, size_t begin, size_t end, int shift) {
	if (shift > 0)
		for (size_t i = end-1; i>=begin+shift; i--)
			array[i] = array[i-shift];

	else if (shift < 0)
		for (size_t i = begin; i<end+shift; i++)
			array[i] = array[i-shift];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r12d
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x2170
testl %r12d, %r12d
jle 0x3e5c
movl %r12d, %r12d
addq %r12, %rbx
leaq -0x1(%r14), %r13
shlq $0x5, %r14
addq %r15, %r14
addq $-0x20, %r14
shlq $0x5, %r12
negq %r12
cmpq %rbx, %r13
jb 0x3e5e
leaq (%r14,%r12), %rsi
movq %r14, %rdi
callq 0x2120
decq %r13
addq $-0x20, %r14
jmp 0x3e42
js 0x3e6d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq %r12d, %r12
addq %r12, %r14
shlq $0x5, %r12
negq %r12
movq %rbx, %rax
shlq $0x5, %rax
addq %rax, %r15
cmpq %r14, %rbx
jae 0x3e5e
leaq (%r15,%r12), %rsi
movq %r15, %rdi
callq 0x2120
incq %rbx
addq $0x20, %r15
jmp 0x3e84
// File: /workspace/github_cpp_makefile_star2_O2/miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::set_key_in_node(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void set_key_in_node(size_t index, E key) { // sets key in node to new min of right branch
			
			if (index > 0)
				keys[index-1] = key;
			else if (parent) {
				size_t pos_in_parent = 0;
				for (; pos_in_parent < parent->elements+1; pos_in_parent++)
					if (this == parent->children[pos_in_parent])
						break;
				parent->set_key_in_node(pos_in_parent, key);
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x2170
testq %r14, %r14
je 0x3ee0
shlq $0x5, %r14
leaq (%r14,%r15), %rdi
addq $0x18, %rdi
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2120
movq (%r15), %r14
testq %r14, %r14
je 0x3f2e
movq 0xb8(%r14), %r12
incq %r12
xorl %eax, %eax
cmpq %rax, %r12
je 0x3f08
cmpq %r15, 0x8(%r14,%rax,8)
je 0x3f05
incq %rax
jmp 0x3ef4
movq %rax, %r12
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2240
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3e9e
leaq -0x40(%rbp), %rdi
callq 0x20e0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::merge_leaf(unsigned long)
void merge_leaf(size_t pos_in_parent) { // if root empty, merged children form new root

			for (size_t i = 0; i < next()->elements; i++) 
				push_right(next()->keys[i]); // all values from next() are appended to this

			for (size_t i = pos_in_parent+1; i < parent->elements; i++) // moves children from parent node
				parent->children[i] = parent->children[i+1];

			for (size_t i = pos_in_parent; i < parent->elements-1; i++)
				parent->keys[i] = parent->keys[i+1]; // deletes value in parent pointing to child (min value of current node)

			parent->elements--;
			next()->unlink();

			parent->after_removal_from_inner();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2170
pushq $0x38
popq %r12
xorl %r13d, %r13d
leaq -0x48(%rbp), %r15
movq 0x28(%rbx), %rsi
cmpq 0xb8(%rsi), %r13
jae 0x40d7
addq %r12, %rsi
movq %r15, %rdi
callq 0x2240
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3fdc
movq %r15, %rdi
callq 0x20e0
incq %r13
addq $0x20, %r12
jmp 0x40a3
leaq 0x1(%r14), %rcx
movq (%rbx), %rsi
movq 0xb8(%rsi), %rax
cmpq %rax, %rcx
jae 0x40f9
movq 0x10(%rsi,%rcx,8), %rax
movq %rax, 0x8(%rsi,%rcx,8)
incq %rcx
jmp 0x40db
movq %r14, %r15
shlq $0x5, %r15
addq $0x58, %r15
decq %rax
cmpq %rax, %r14
jae 0x412f
incq %r14
leaq (%rsi,%r15), %rdi
addq $-0x20, %rdi
addq %r15, %rsi
callq 0x2120
movq (%rbx), %rsi
movq 0xb8(%rsi), %rax
addq $0x20, %r15
jmp 0x4104
movq %rax, 0xb8(%rsi)
movq 0x28(%rbx), %rdi
callq 0x416a
movq (%rbx), %rdi
callq 0x419e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::after_removal_from_inner()
void after_removal_from_inner() {
			if (elements >= k)
				return; // everything's fine

			if (!parent)
				return; // no siblings

			size_t pos_in_parent;
			for (pos_in_parent = 0; pos_in_parent <= parent->elements; pos_in_parent++) // finds position of this inner node
				if (this == parent->children[pos_in_parent])
					break;

			Node* prev_inner = pos_in_parent > 0                ? parent->children[pos_in_parent-1] : nullptr;
			Node* next_inner = pos_in_parent < parent->elements ? parent->children[pos_in_parent+1] : nullptr;

			// inner tries to borrow key from sibling

			if (can_borrow_from(prev_inner)) // borrow from previous
				return borrow_from_node(prev_inner, pos_in_parent, true);
			else if (can_borrow_from(next_inner)) // borrow from next
				return borrow_from_node(next_inner, pos_in_parent, false);
			
			// if borrowing not possible, -> merge

			if (prev_inner)
				prev_inner->merge_nodes(this, pos_in_parent-1); // call from previous, pass current
			else if (next_inner)
				merge_nodes(next_inner, pos_in_parent); // call from current, pass next
			else
				return;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2170
movq (%rbx), %rcx
cmpq $0x2, 0xb8(%rbx)
setae %al
testq %rcx, %rcx
sete %dl
orb %al, %dl
je 0x41cb
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0xb8(%rcx), %rsi
xorl %edx, %edx
cmpq %rsi, %rdx
ja 0x41ea
cmpq %rbx, 0x8(%rcx,%rdx,8)
je 0x41e5
incq %rdx
jmp 0x41d4
testq %rdx, %rdx
je 0x423f
movq (%rcx,%rdx,8), %rax
cmpq %rsi, %rdx
jae 0x41ff
movq 0x10(%rcx,%rdx,8), %rsi
testq %rax, %rax
jne 0x4206
jmp 0x4248
testq %rax, %rax
je 0x41c4
xorl %esi, %esi
cmpq %rcx, (%rax)
jne 0x4220
cmpq $0x3, 0xb8(%rax)
jb 0x4220
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x4265
testq %rsi, %rsi
je 0x4234
cmpq %rcx, (%rsi)
jne 0x4234
cmpq $0x2, 0xb8(%rsi)
ja 0x4260
decq %rdx
movq %rax, %rdi
movq %rbx, %rsi
jmp 0x4273
testq %rsi, %rsi
je 0x41c4
movq 0x10(%rcx), %rsi
testq %rsi, %rsi
je 0x41c4
cmpq %rcx, (%rsi)
jne 0x4270
cmpq $0x3, 0xb8(%rsi)
jb 0x4270
movq %rbx, %rdi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x427e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x43ba
// File: /workspace/github_cpp_makefile_star2_O2/miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::borrow_from_node(BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node*, unsigned long, bool)
void borrow_from_node(Node* other, size_t pos_in_parent, bool borrow_from_previous) {

			if (borrow_from_previous) {
				push_left(parent->keys[pos_in_parent-1]); // inserts val from parent at the beginning

				for (size_t i = elements; i > 0; i--) // inserts child at beginning
					children[i] = children[i-1];

				children[0] = other->children[other->elements]; // moves child from left to right
				children[0]->parent = this;
				parent->keys[pos_in_parent-1] = other->pop_right(); // puts key from left in parent
			}
			else { // borrow from next
				push_right(parent->keys[pos_in_parent]); // inserts val from parent at the end
				children[elements] = other->children[0]; // adds child from right node
				children[elements]->parent = this;

				for (size_t i = 0; i < other->elements; i++) // rearrange children from other node
					other->children[i] = other->children[i+1];
				
				parent->keys[pos_in_parent] = other->pop_left();
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %ecx, %r12d
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x2170
movq (%r14), %rsi
addq $0x38, %rsi
testl %r12d, %r12d
je 0x42f2
decq %rbx
shlq $0x5, %rbx
addq %rbx, %rsi
leaq -0x80(%rbp), %r12
movq %r12, %rdi
callq 0x2240
movq %r14, %rdi
movq %r12, %rsi
callq 0x3f50
leaq -0x80(%rbp), %rdi
callq 0x20e0
movq 0xb8(%r14), %rcx
movq %rcx, %rax
subq $0x1, %rax
jb 0x4349
movq (%r14,%rcx,8), %rcx
movq %rcx, 0x10(%r14,%rax,8)
movq %rax, %rcx
jmp 0x42de
shlq $0x5, %rbx
addq %rbx, %rsi
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0x2240
movq %r14, %rdi
movq %r12, %rsi
callq 0x3fdc
leaq -0x40(%rbp), %rdi
callq 0x20e0
movq 0x8(%r15), %rax
movq 0xb8(%r14), %rcx
movq %rax, 0x8(%r14,%rcx,8)
movq %r14, (%rax)
movq 0xb8(%r15), %rax
xorl %ecx, %ecx
cmpq %rax, %rcx
jae 0x436d
movq 0x10(%r15,%rcx,8), %rdx
movq %rdx, 0x8(%r15,%rcx,8)
incq %rcx
jmp 0x4335
movq 0xb8(%r15), %rax
movq 0x8(%r15,%rax,8), %rax
movq %rax, 0x8(%r14)
movq %r14, (%rax)
leaq -0x60(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3f9c
jmp 0x437c
leaq -0x60(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4018
movq (%r14), %rax
leaq (%rax,%rbx), %rdi
addq $0x38, %rdi
movq %r12, %rsi
callq 0x2220
movq %r12, %rdi
callq 0x20e0
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x43a6
movq %rax, %rbx
movq %r12, %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::merge_nodes(BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node*, unsigned long)
void merge_nodes(Node* other, size_t pos_in_parent) { // always called from previous

			push_right(parent->keys[pos_in_parent]);

			size_t i;
			for (i = 0; i < other->elements; i++) {
				children[elements] = other->children[i];
				children[elements]->parent = this;
				push_right(other->keys[i]); // all values from next() are appended to this
			}

			children[elements] = other->children[i];
			children[elements]->parent = this;

			// parent is in inconsistent state here

			for (size_t i = pos_in_parent; i < parent->elements-1; i++) {// moves children from parent node
				parent->keys[i] = parent->keys[i+1];
				parent->children[i+1] = parent->children[i+2];
			}

			parent->elements--;
			other->elements = -1;
			delete other;
			parent->after_removal_from_inner();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x2170
movq (%rbx), %rax
movq %r15, %rcx
shlq $0x5, %rcx
movq %rcx, -0x40(%rbp)
leaq (%rax,%rcx), %rsi
addq $0x38, %rsi
leaq -0x80(%rbp), %r13
movq %r13, %rdi
callq 0x2240
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3fdc
leaq -0x80(%rbp), %rdi
callq 0x20e0
movq %r12, -0x38(%rbp)
leaq 0x38(%r12), %r13
xorl %r12d, %r12d
leaq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdx
movq 0x8(%rdx,%r12,8), %rax
movq 0xb8(%rbx), %rcx
cmpq 0xb8(%rdx), %r12
movq %rax, 0x8(%rbx,%rcx,8)
movq %rbx, (%rax)
jae 0x446f
leaq -0x60(%rbp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x2240
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3fdc
movq %r14, %rdi
callq 0x20e0
incq %r12
addq $0x20, %r13
jmp 0x4423
movq -0x40(%rbp), %r14
addq $0x58, %r14
movq (%rbx), %rsi
movq 0xb8(%rsi), %rax
decq %rax
cmpq %rax, %r15
jae 0x44b3
leaq 0x1(%r15), %r12
leaq (%rsi,%r14), %rdi
addq $-0x20, %rdi
addq %r14, %rsi
callq 0x2120
movq (%rbx), %rax
movq 0x18(%rax,%r15,8), %rcx
movq %rcx, 0x10(%rax,%r15,8)
addq $0x20, %r14
movq %r12, %r15
jmp 0x4477
movq %rax, 0xb8(%rsi)
movq -0x38(%rbp), %r14
orq $-0x1, 0xb8(%r14)
movq %r14, %rdi
callq 0x364c
movl $0xc8, %esi
movq %r14, %rdi
callq 0x21f0
movq (%rbx), %rdi
callq 0x419e
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, -0x30(%rbp)
jmp 0x44f8
movq %rax, %rbx
movq -0x30(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::contains(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool contains(const E& key) const {
			// returns true if value(key) is in tree
			size_t i;

			for (i = 0; i < elements; i++) {
				if (keys[i] > key) // key isn't in this node
					break;
				else if (keys[i] == key) 
					return true;
			}

			if (leaf) // key isn't in tree
				return false;

			return children[i]->contains(key); // if node, check child for key
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2170
leaq 0x38(%r14), %r15
xorl %r12d, %r12d
cmpq 0xb8(%r14), %r12
jae 0x4559
movq %r15, %rdi
movq %rbx, %rsi
callq 0x37d4
testb %al, %al
jne 0x4559
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3797
testb %al, %al
jne 0x456a
incq %r12
addq $0x20, %r15
jmp 0x4529
cmpb $0x0, 0xc0(%r14)
jne 0x4575
movq 0x8(%r14,%r12,8), %r14
jmp 0x4522
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x456c
nop
// File: /workspace/github_cpp_makefile_star2_O2/miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::num_keys()
size_t num_keys() { // returns the num of keys in the leafs reachable from the current node (size of tree)
			if (leaf)
				return elements;
			
			size_t sum = 0;
			for (size_t i = 0; i < elements+1; i++)
				sum += children[i]->num_keys();

			return sum;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2170
cmpb $0x0, 0xc0(%rbx)
je 0x45aa
movq 0xb8(%rbx), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0xb8(%rbx), %rax
incq %rax
cmpq %rax, %r15
jae 0x459c
movq 0x8(%rbx,%r15,8), %rdi
callq 0x457a
addq %rax, %r14
incq %r15
jmp 0x45b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::apply_(Functor<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, Order, unsigned long&)
bool apply_(const Functor<E>& f, Order ord, size_t& n) { // I'm not sure yet why we need that, but ok

			size_t i;
			if (ord == descending) {
				i = elements-1;
				if (!leaf)
					if (!children[i+1]->apply_(f, ord, n))
						return false;
				do {
					if (i > elements) break;
					if (leaf) {
						n++; // counts values in leafs
						if (!f(keys[i]))
							return false;
						}
					else 
						if (!children[i]->apply_(f, ord, n)) // goes to next child until leaf
							return false;
				} while (i--);
			}

			else {
				i = 0;
				for (; i < elements; i++) {
					if (leaf) {
						n++; // counts values in leafs
						if (!f(keys[i]))
							return false;
						}
					else 
						if (!children[i]->apply_(f, ord, n)) // goes to next child until leaf
							return false;
				}
				if (!leaf)
					if (!children[i]->apply_(f, ord, n))
						return false;
			}
			return true;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %r15
callq 0x2170
movl %r12d, -0x30(%rbp)
cmpl $0x2, %r12d
jne 0x468e
movq 0xb8(%r15), %r13
cmpb $0x0, 0xc0(%r15)
jne 0x462b
movq 0x8(%r15,%r13,8), %rdi
pushq $0x2
popq %rdx
movq %r14, %rsi
movq %rbx, %rcx
callq 0x45d2
testb %al, %al
je 0x46f8
leaq -0x1(%r13), %r12
leaq 0x18(%r15), %rax
movq %rax, -0x30(%rbp)
shlq $0x5, %r13
cmpq 0xb8(%r15), %r12
ja 0x46f4
cmpb $0x1, 0xc0(%r15)
jne 0x4667
incq (%rbx)
movq -0x30(%rbp), %rax
leaq (%rax,%r13), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
jmp 0x467e
movq -0x30(%rbp), %rax
movq -0x10(%rax,%r12,8), %rdi
movq %r14, %rsi
pushq $0x2
popq %rdx
movq %rbx, %rcx
callq 0x45d2
testb %al, %al
je 0x46f8
addq $-0x20, %r13
addq $-0x1, %r12
jb 0x463b
jmp 0x46f4
leaq 0x38(%r15), %r13
xorl %r12d, %r12d
movb 0xc0(%r15), %al
cmpq 0xb8(%r15), %r12
jae 0x46d9
testb %al, %al
je 0x46b9
incq (%rbx)
movq (%r14), %rax
movq %r14, %rdi
movq %r13, %rsi
callq *(%rax)
jmp 0x46cc
movq 0x8(%r15,%r12,8), %rdi
movq %r14, %rsi
movl -0x30(%rbp), %edx
movq %rbx, %rcx
callq 0x45d2
testb %al, %al
je 0x46f8
incq %r12
addq $0x20, %r13
jmp 0x4695
testb %al, %al
jne 0x46f4
movq 0x8(%r15,%r12,8), %rdi
movq %r14, %rsi
movl -0x30(%rbp), %edx
movq %rbx, %rcx
callq 0x45d2
testb %al, %al
je 0x46f8
movb $0x1, %al
jmp 0x46fa
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::min()
E& min() {
			if (leaf)
				return keys[0];
			else
				return children[0]->min();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2170
cmpb $0x1, 0xc0(%rbx)
je 0x4727
movq 0x8(%rbx), %rbx
jmp 0x4718
addq $0x38, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::max()
E& max() {
			if (leaf)
				return keys[elements-1];
			else
				return children[elements]->max();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2170
movq 0xb8(%rbx), %rax
cmpb $0x1, 0xc0(%rbx)
je 0x4795
movq 0x8(%rbx,%rax,8), %rbx
jmp 0x477e
shlq $0x5, %rax
addq %rbx, %rax
addq $0x18, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::print(std::ostream&, int) const
std::ostream& print (std::ostream& o, int depth) const {
			for (int j = 0; j < depth; j++)
				o << "  ";

			if (leaf)
				o << "leaf : " << this << std::endl;
			else
				o << "inner: " << this << std::endl;
			for (size_t i = 0; i < elements; i++) {
				if (!leaf)
					children[i]->print(o, depth+1);
				for (int j = 0; j < depth; j++) {
					o << "  ";				// one space per depth
				}
				o << "  " << keys[i] << std::endl;
			}
			if (!leaf)
				children[elements]->print(o, depth+1); // calls print for children
			return o;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, %rbx
movq %rdi, %r15
callq 0x2170
leaq 0xe4b(%rip), %r12       # 0x5619
movl -0x2c(%rbp), %eax
testl %eax, %eax
movl $0x0, %r14d
cmovgl %eax, %r14d
leal 0x1(%r14), %eax
movl %eax, -0x30(%rbp)
subl $0x1, %r14d
jb 0x47f7
movq %rbx, %rdi
movq %r12, %rsi
callq 0x21c0
jmp 0x47e4
cmpb $0x0, 0xc0(%r15)
leaq 0xe1e(%rip), %rsi       # 0x5624
leaq 0xe0f(%rip), %rax       # 0x561c
cmovneq %rax, %rsi
movq %rbx, %rdi
callq 0x21c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x2100
incl -0x2c(%rbp)
leaq 0x38(%r15), %rax
movq %rax, -0x38(%rbp)
xorl %r13d, %r13d
movq 0xb8(%r15), %rax
movb 0xc0(%r15), %cl
cmpq %rax, %r13
jae 0x4895
testb %cl, %cl
jne 0x4861
movq 0x8(%r15,%r13,8), %rdi
movq %rbx, %rsi
movl -0x2c(%rbp), %edx
callq 0x47a8
movl -0x30(%rbp), %r14d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x21c0
decl %r14d
jne 0x4865
movq %r13, %rsi
shlq $0x5, %rsi
addq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x2100
incq %r13
jmp 0x483a
testb %cl, %cl
jne 0x48a3
movq 0x8(%r15,%rax,8), %r15
jmp 0x47ce
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kingufl[P]Rmapper/graph_traverse.cpp
// Function: DFS(int, int, int, int)
void DFS(int source, int thisnode, int thislvl, int toplvl){


    if(nodestatus[thisnode]==source){
        if(longestpath.size()<thispath.size()){
            longestcontig=thiscontig;
            longestpath=thispath;
        }
        return;
    }

    thispath.push_back(thisnode);
    thiscontig.push_back(nodefrag[thisnode][kmersize-1]);
    nodestatus[thisnode]=source;

    int iterationcontigsize=thiscontig.size();

    if(graphf[thisnode].size()==1){
        DFS(source,graphf[thisnode][0],thislvl+1,toplvl);
    }
    else{
            for(int ii=kmersize;ii<nodefrag[thisnode].size();ii++){
                thiscontig.push_back(nodefrag[thisnode][ii]);
            }

            longestcontig=thiscontig;
            longestpath=thispath;
    }

//    for(int nextnode: graphf[thisnode]){
//
//
//
//        thispath.resize(thislvl);
//        thiscontig.resize(iterationcontigsize);
//
//    }

//    if(longestpath.size()<thispath.size()){
//
//
//    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movl %esi, -0x24(%rbp)
movslq %esi, %rax
movq 0x6cce(%rip), %rcx      # 0x9268
cmpl %edi, (%rcx,%rax,4)
jne 0x25f6
movq 0x6cb2(%rip), %rax      # 0x9258
subq 0x6ca3(%rip), %rax      # 0x9250
movq 0x6c5c(%rip), %rcx      # 0x9210
subq 0x6c4d(%rip), %rcx      # 0x9208
cmpq %rcx, %rax
jae 0x26f6
leaq 0x6c6d(%rip), %rdi      # 0x9238
leaq 0x6c4e(%rip), %rsi      # 0x9220
callq 0x4116
leaq 0x6c72(%rip), %rdi      # 0x9250
leaq 0x6c23(%rip), %rsi      # 0x9208
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4116
movl %edx, %r14d
movl %edi, %r15d
leaq 0x6c05(%rip), %rdi      # 0x9208
leaq -0x24(%rbp), %r12
movq %r12, %rsi
callq 0x41e2
movslq (%r12), %rax
movq 0x6bbe(%rip), %rcx      # 0x91d8
imulq $0x18, %rax, %rax
movslq 0x6c5b(%rip), %rdx      # 0x9280
movq (%rcx,%rax), %rax
leaq (%rax,%rdx,4), %rsi
addq $-0x4, %rsi
leaq 0x6be8(%rip), %rdi      # 0x9220
callq 0x41e2
movslq (%r12), %rax
movq 0x6c20(%rip), %rcx      # 0x9268
movl %r15d, (%rcx,%rax,4)
movslq (%r12), %rax
movq 0x6b49(%rip), %rdx      # 0x91a0
imulq $0x18, %rax, %rsi
movq (%rdx,%rsi), %rcx
movq 0x8(%rdx,%rsi), %rdx
subq %rcx, %rdx
cmpq $0x4, %rdx
jne 0x2681
movl (%rcx), %esi
incl %r14d
movl %r15d, %edi
movl %r14d, %edx
movl %ebx, %ecx
callq 0x257c
jmp 0x26f6
movslq 0x6bf8(%rip), %r14      # 0x9280
leaq (,%r14,4), %r15
leaq 0x6b89(%rip), %rbx      # 0x9220
cltq
movq 0x6b38(%rip), %rcx      # 0x91d8
imulq $0x18, %rax, %rax
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rax
subq %rsi, %rax
sarq $0x2, %rax
cmpq %r14, %rax
jbe 0x26d0
addq %r15, %rsi
movq %rbx, %rdi
callq 0x41e2
incq %r14
movl -0x24(%rbp), %eax
addq $0x4, %r15
jmp 0x2697
leaq 0x6b61(%rip), %rdi      # 0x9238
leaq 0x6b42(%rip), %rsi      # 0x9220
callq 0x4116
leaq 0x6b66(%rip), %rdi      # 0x9250
leaq 0x6b17(%rip), %rsi      # 0x9208
callq 0x4116
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kingufl[P]Rmapper/graph_traverse.cpp
// Function: DFS_trim(int, int, int, int)
void DFS_trim(int source, int thisnode, int thislvl, int toplvl){


//    if(nodestatus[thisnode]==source){
//        if(longestpath.size()<thispath.size()){
//            longestcontig=thiscontig;
//            longestpath=thispath;
//        }
//        return;
//    }

    if(nodestatus[thisnode]==source){
        nothit++;
    }

    if(nodestatus[thisnode]==source || thislvl>=toplvl){
        if(thislvl>maxlvl)
            maxlvl=thislvl;
        return;
    }

    nodestatus[thisnode]=source;

    for(int nextnode: graphf[thisnode]){

        DFS_trim(source,nextnode,thislvl+1,toplvl);

    }

    if(thislvl>maxlvl)
            maxlvl=thislvl;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r14d
movl %edi, %r15d
movslq %esi, %rax
movq 0x6b47(%rip), %rcx      # 0x9268
movl (%rcx,%rax,4), %esi
cmpl %edi, %esi
jne 0x2731
incl 0x6b56(%rip)            # 0x9284
movl (%rcx,%rax,4), %esi
cmpl %r14d, %edx
jge 0x277c
cmpl %r15d, %esi
je 0x277c
movl %r15d, (%rcx,%rax,4)
movq 0x6a5a(%rip), %rcx      # 0x91a0
imulq $0x18, %rax, %rax
movq (%rcx,%rax), %r13
movq 0x8(%rcx,%rax), %rbx
movq %rdx, -0x30(%rbp)
leal 0x1(%rdx), %r12d
cmpq %rbx, %r13
je 0x2778
movl (%r13), %esi
movl %r15d, %edi
movl %r12d, %edx
movl %r14d, %ecx
callq 0x2703
addq $0x4, %r13
jmp 0x275b
movq -0x30(%rbp), %rdx
cmpl %edx, 0x6b06(%rip)      # 0x9288
jge 0x278a
movl %edx, 0x6afe(%rip)      # 0x9288
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kingufl[P]Rmapper/graph_traverse.cpp
// Function: parseArgs(int, char* const*, Args&)
void parseArgs(int argc, char *const argv[], Args &arg)
{
  int c;
  extern char *optarg;
  extern int optind;

  std::string usage("usage: " + std::string(argv[0]) + " indir\n\n" +
                    "Traverse the bi-labelled de Bruijn graph in the directory [indir].\n");

  // the only input parameter is the directory name
  if (argc == 2)
  {
    arg.dirname.assign(argv[1]);
  }
  else
  {
    cerr << "Invalid number of arguments\n" << usage;
    exit(1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
movq (%rsi), %rsi
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x20c0
leaq 0x3867(%rip), %rsi      # 0x6030
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x4230
leaq 0x385b(%rip), %rdx      # 0x6038
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4207
leaq 0x3850(%rip), %rdx      # 0x6041
leaq -0xa0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x4207
leaq -0x80(%rbp), %rdi
callq 0x20e0
leaq -0x60(%rbp), %rdi
callq 0x20e0
leaq -0x40(%rbp), %rdi
callq 0x20e0
cmpl $0x2, %r15d
jne 0x2848
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x22d0
leaq -0xa0(%rbp), %rdi
callq 0x20e0
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x67a1(%rip), %rdi      # 0x8ff0
leaq 0x382f(%rip), %rsi      # 0x6085
callq 0x21a0
leaq -0xa0(%rbp), %rsi
movq %rax, %rdi
callq 0x2180
pushq $0x1
popq %rdi
callq 0x21d0
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x20e0
jmp 0x2883
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x20e0
jmp 0x2891
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x28a6
movq %rax, %rbx
jmp 0x28ab
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/Emeraude[P]ECS/src/World.cpp
// Function: Ecs::World::~World()
Ecs::World::~World() {
  for (auto *it: _systems)
    delete it;
  for (auto *it: _entities)
    delete it;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq 0x18(%rdi), %r15
movq 0x20(%rdi), %r12
cmpq %r12, %r15
je 0x4b49
movq (%r15), %rdi
testq %rdi, %rdi
je 0x4b43
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r15
jmp 0x4b30
movq (%rbx), %r13
movq 0x8(%rbx), %rbp
pushq $0x18
popq %r15
cmpq %rbp, %r13
je 0x4b7b
movq (%r13), %r12
testq %r12, %r12
je 0x4b6a
movq %r12, %rdi
callq 0x4380
movq %r12, %rdi
movq %r15, %rsi
callq 0x4300
addq $0x8, %r13
jmp 0x4b54
leaq 0x30(%rbx), %rdi
callq 0x4330
movq %r14, %rdi
callq 0x42b0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x41a0
// File: /workspace/github_cpp_makefile_star2_O2/Emeraude[P]ECS/src/World.cpp
// Function: Ecs::World::update()
void Ecs::World::update() {
  std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();

  for (auto *it: _systems)
    it->update(*this);
  _time = std::chrono::steady_clock::now() - start;
  std::this_thread::sleep_for(_sleepDuration - _time);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4340
movq %rax, %r14
movq 0x18(%rbx), %r15
movq 0x20(%rbx), %r12
cmpq %r12, %r15
je 0x4bf8
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
addq $0x8, %r15
jmp 0x4be1
callq 0x4340
subq %r14, %rax
movq %rax, 0xb0(%rbx)
movq 0xb8(%rbx), %rcx
subq %rax, %rcx
movq %rsp, %rdi
movq %rcx, (%rdi)
callq 0x4260
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Emeraude[P]ECS/src/World.cpp
// Function: Ecs::World::add(Ecs::Entity*)
unsigned int Ecs::World::add(Ecs::Entity *e) {
  if (_garbage.empty()) {
    _entities.push_back(e);
    return _entities.size() - 1;
  }
  else {
    unsigned int const id = _garbage.front();
    delete _entities[id];
    _entities[id] = e;
    _garbage.pop();
    return id;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
movq 0x40(%rdi), %rax
cmpq %rax, 0x60(%rdi)
je 0x4cae
movq %rsi, %r15
leaq 0x30(%r14), %r12
movl (%rax), %ebx
movq (%r14), %rax
movq (%rax,%rbx,8), %r13
testq %r13, %r13
je 0x4c92
movq %r13, %rdi
callq 0x4380
pushq $0x18
popq %rsi
movq %r13, %rdi
callq 0x4300
movq (%r14), %rax
movq %r15, (%rax,%rbx,8)
movq %r12, %rdi
callq 0x4430
jmp 0x4cc8
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x4110
movq 0x8(%r14), %rbx
subq (%r14), %rbx
shrq $0x3, %rbx
decl %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/test.c
// Function: test_int
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	tommy_hashlin h;
	tommy_hashlin_init(&h);
	for (i = 0, x = x0; i < n; ++i) {
		uint32_t key;
		intcell_t *p;
		x = hash32(x);
		key = get_key(n, x);
		p = tommy_hashlin_search(&h, compare, &key, hash_fn(key));
		if (!p) {
			p = malloc(sizeof(intcell_t));
			p->key = key, p->cnt = 1;
			tommy_hashlin_insert(&h, &p->node, p, hash_fn(key));
			++z;
		} else z += ++p->cnt;
	}
	fprintf(stderr, "# unique keys: %d; checksum: %u\n", tommy_hashlin_count(&h), z);
	x = tommy_hashlin_count(&h);
	tommy_hashlin_done(&h);
	return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movl %esi, %r15d
movl %edi, %ebp
leaq 0x8(%rsp), %rdi
callq 0x2ada
xorl %r14d, %r14d
pushq $0x1
popq %r12
xorl %ebx, %ebx
cmpl %ebp, %r14d
je 0x1546
movl %r15d, %edi
callq 0x120c
movl %eax, %r15d
movl %ebp, %edi
movl %eax, %esi
callq 0x1237
movl %eax, %r13d
movl 0x118(%rsp), %ecx
andl %eax, %ecx
movl 0x110(%rsp), %eax
andl %r13d, %eax
cmpl 0x11c(%rsp), %ecx
cmovael %ecx, %eax
movl %eax, %ecx
orl $0x1, %ecx
bsrl %ecx, %ecx
shlq $0x3, %rax
addq 0x8(%rsp,%rcx,8), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x1513
cmpl %r13d, 0x18(%rax)
jne 0x14f2
movq 0x10(%rax), %rcx
cmpl (%rcx), %r13d
jne 0x14f2
movl 0x4(%rcx), %eax
incl %eax
movl %eax, 0x4(%rcx)
jmp 0x153c
pushq $0x28
popq %rdi
callq 0x1080
movl %r13d, (%rax)
movl $0x1, 0x4(%rax)
leaq 0x8(%rax), %rsi
leaq 0x8(%rsp), %rdi
movq %rax, %rdx
movl %r13d, %ecx
callq 0x2b75
movl %r12d, %eax
addl %eax, %ebx
incl %r14d
jmp 0x14a4
movq 0x5aab(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x8(%rsp), %r14
movl 0x118(%r14), %edx
leaq 0x2b12(%rip), %rsi      # 0x4075
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1070
movl 0x118(%r14), %ebx
movq %r14, %rdi
callq 0x2b31
movl %ebx, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xdsopl[P]FEC/tables_generator.cc
// Function: main
int main()
{
	std::cout << "/* generated by generator.cc */" << std::endl << std::endl;
	std::cout << "template <int M, int POLY, typename TYPE>" << std::endl;
	std::cout << "struct Tables {};" << std::endl << std::endl;

	// BBC WHP031 RS(15, 11) T=2
	GENERATOR(4, 0b10011, uint8_t);

	// DVB-T RS(255, 239) T=8
	GENERATOR(8, 0b100011101, uint8_t);

	// FUN RS(65535, 65471) T=32
	GENERATOR(16, 0b10001000000001011, uint16_t);

	// DVB-S2 FULL BCH(65535, 65343) T=12
	GENERATOR(16, 0b10000000000101101, uint16_t);
}

// Assembly:
pushq %rbx
movq 0x2e14(%rip), %rbx      # 0x3fd8
leaq 0xe39(%rip), %rsi       # 0x2004
movq %rbx, %rdi
callq 0x1060
movq %rax, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1030
leaq 0xe3a(%rip), %rsi       # 0x2024
movq %rbx, %rdi
callq 0x1060
movq %rax, %rdi
callq 0x1030
leaq 0xe4d(%rip), %rsi       # 0x204e
movq %rbx, %rdi
callq 0x1060
movq %rax, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1030
leaq 0xe40(%rip), %rbx       # 0x2060
movq %rbx, %rdi
callq 0x124c
movq %rbx, %rdi
callq 0x13fe
leaq 0xe31(%rip), %rbx       # 0x2068
movq %rbx, %rdi
callq 0x15fe
movq %rbx, %rdi
callq 0x1802
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/xdsopl[P]FEC/tables_generator.cc
// Function: TablesGenerator<4, 19, unsigned char>::print(unsigned char*, char const*, char const*, int)
static void print(TYPE *table, const char *name, const char *type, int size)
	{
		std::cout << "\tstatic " << type << " " << name << "(" << type << " a)\n\t{\n\t\t";
		std::cout << "static const " << type << " table[" << size << "] = {";
		for (int i = 0; i < size; ++i) {
			std::cout << " " << (int)table[i];
			if (i < size - 1)
				std::cout << ",";
		}
		std::cout << " };" << std::endl;
		std::cout << "\t\treturn table[a];\n\t}\n";
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movq 0x25b7(%rip), %r15      # 0x3fd8
leaq 0x738(%rip), %rsi       # 0x2160
movq %r15, %rdi
callq 0x1060
movq %rax, %rdi
movq %r13, %rsi
callq 0x1060
leaq 0x6f7(%rip), %rsi       # 0x2139
movq %rax, %rdi
callq 0x1060
movq %rax, %rdi
movq %rbp, %rsi
callq 0x1060
leaq 0x70d(%rip), %rsi       # 0x2169
movq %rax, %rdi
callq 0x1060
movq %rax, %rdi
movq %r13, %rsi
callq 0x1060
leaq 0x6f5(%rip), %rsi       # 0x216b
movq %rax, %rdi
callq 0x1060
leaq 0x6f0(%rip), %rsi       # 0x2175
movq %r15, %rdi
callq 0x1060
movq %rax, %rdi
movq %r13, %rsi
callq 0x1060
leaq 0x6e4(%rip), %rsi       # 0x2183
movq %rax, %rdi
callq 0x1060
movq %rax, %rdi
movl %ebx, %esi
callq 0x1080
leaq 0x6d3(%rip), %rsi       # 0x218b
movq %rax, %rdi
callq 0x1060
leal -0x1(%rbx), %eax
movslq %eax, %rbp
xorl %r12d, %r12d
testl %ebx, %ebx
cmovlel %r12d, %ebx
leaq 0x6bb(%rip), %r13       # 0x2191
cmpq %r12, %rbx
je 0x1b0c
movq %r15, %rdi
leaq 0x654(%rip), %rsi       # 0x2139
callq 0x1060
movzbl (%r14,%r12), %esi
movq %rax, %rdi
callq 0x1080
cmpq %rbp, %r12
jge 0x1b07
movq %r15, %rdi
movq %r13, %rsi
callq 0x1060
incq %r12
jmp 0x1ad6
movq 0x24c5(%rip), %rbx      # 0x3fd8
leaq 0x679(%rip), %rsi       # 0x2193
movq %rbx, %rdi
callq 0x1060
movq %rax, %rdi
callq 0x1030
leaq 0x666(%rip), %rsi       # 0x2197
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1060
nop
// File: /workspace/github_cpp_makefile_star2_O2/onai[P]npio/./npio.h
// Function: npio::Array::ValueRange<float> npio::Array::values<float>() const
ValueRange<T> values() const
      {
        if (isType<T>())
          return ValueRange<T>((T*) array.data, (T*) array.data + array.size);
        else
        {
          #ifdef NPIO_CXX_ENABLE_EXCEPTIONS
            throw std::bad_cast();
          #else
            return ValueRange<T>(0, 0);
          #endif
        }
      }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2d56
testb %al, %al
je 0x2c23
movq 0x28(%rbx), %rcx
movq 0x48(%rbx), %rax
leaq (%rax,%rcx,4), %rdx
popq %rbx
retq
pushq $0x8
popq %rdi
callq 0x2090
movq 0x2376(%rip), %rcx      # 0x4fa8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x2388(%rip), %rsi      # 0x4fc8
movq 0x2391(%rip), %rdx      # 0x4fd8
movq %rax, %rdi
callq 0x2190
nop
// File: /workspace/github_cpp_makefile_star2_O2/cpottamus[P]btree_lab/deletedisk.cc
// Function: main
int main(int argc, char *argv[])
{
  if (argc<2) { 
    usage();
    exit(-1);
  }

  remove((string(argv[1])+".data").c_str());
  remove((string(argv[1])+".bitmap").c_str());
  remove((string(argv[1])+".config").c_str());

  cerr << "Done.\n";

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
cmpl $0x1, %edi
jle 0x1347
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1396
leaq 0xdb4(%rip), %rdx       # 0x2020
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1376
leaq 0x28(%rsp), %r14
movq (%r14), %rdi
callq 0x10e0
movq %r14, %rdi
callq 0x1040
leaq 0x8(%rsp), %rdi
callq 0x1040
movq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1396
leaq 0xd72(%rip), %rdx       # 0x2026
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1376
leaq 0x28(%rsp), %r14
movq (%r14), %rdi
callq 0x10e0
movq %r14, %rdi
callq 0x1040
leaq 0x8(%rsp), %rdi
callq 0x1040
movq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1396
leaq 0xd32(%rip), %rdx       # 0x202e
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1376
leaq 0x28(%rsp), %rbx
movq (%rbx), %rdi
callq 0x10e0
movq %rbx, %rdi
callq 0x1040
leaq 0x8(%rsp), %rdi
callq 0x1040
movq 0x2cbf(%rip), %rdi      # 0x3ff0
leaq 0xcfe(%rip), %rsi       # 0x2036
callq 0x1080
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
callq 0x122c
pushq $-0x1
popq %rdi
callq 0x1090
jmp 0x135c
jmp 0x136b
jmp 0x135c
jmp 0x136b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1040
jmp 0x136e
movq %rax, %rbx
movq %rbx, %rdi
callq 0x10c0
// File: /workspace/github_cpp_makefile_star2_O2/cpearce[P]OggIndex/src/Decoder.cpp
// Function: SkeletonDecoder::SkeletonDecoder(unsigned int)
SkeletonDecoder::SkeletonDecoder(ogg_uint32_t serial) :
  Decoder(serial),
  mGotAllHeaders(0),
  mVersionMajor(0),
  mVersionMinor(0),
  mVersion(0)
{
  for (ogg_uint32_t i=0; i<mPackets.size(); i++) {
    delete[] mPackets[i]->packet;
    mPackets[i]->packet = 0;
    delete mPackets[i];
  }
  ClearKeyframeIndex(mIndex);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x495c
leaq 0x10122(%rip), %rax     # 0x14af8
movq %rax, (%rbx)
leaq 0x1f0(%rbx), %rax
andl $0x0, 0x1f0(%rbx)
andq $0x0, 0x1f8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1b8(%rbx)
movups %xmm0, 0x1c8(%rbx)
movups %xmm0, 0x1d8(%rbx)
movq %rax, 0x200(%rbx)
movq %rax, 0x208(%rbx)
andq $0x0, 0x210(%rbx)
movb $0x0, 0x218(%rbx)
andl $0x0, 0x21a(%rbx)
andl $0x0, 0x220(%rbx)
addq $0x1e8, %rbx            # imm = 0x1E8
movq %rbx, %rdi
popq %rbx
jmp 0x4a42
// File: /workspace/github_cpp_makefile_star2_O2/cpearce[P]OggIndex/src/Decoder.cpp
// Function: ClearKeyframeIndex(std::map<unsigned int, std::vector<KeyFrameInfo, std::allocator<KeyFrameInfo>>*, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, std::vector<KeyFrameInfo, std::allocator<KeyFrameInfo>>*>>>&)
void ClearKeyframeIndex(KeyFrameIndex& index) {
  KeyFrameIndex::iterator itr = index.begin();
  while (itr != index.end()) {
    vector<KeyFrameInfo>* v = itr->second;
    delete v;
    itr++;
  }
  index.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r15
leaq 0x8(%rdi), %r13
pushq $0x18
popq %r14
cmpq %r13, %r15
je 0x4a88
movq 0x28(%r15), %r12
testq %r12, %r12
je 0x4a70
movq %r12, %rdi
callq 0x6e48
movq %r12, %rdi
movq %r14, %rsi
callq 0x4370
movq %r15, %rdi
callq 0x4250
movq %rax, %r15
jmp 0x4a5a
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7384
nop