LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::remove(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
virtual void remove(const E& e ) {
		root->remove(e, 0);
		if (!root->leaf && root->elements == 0) {
			Node *oldroot = root;
			root = root->children[0];
			root->parent = nullptr;
			oldroot->elements = -1;
			delete oldroot;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2150
movq 0x8(%rbx), %r15
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x346e
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3f10
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x3755
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21d0
movq 0x8(%rbx), %r14
cmpb $0x0, 0xc0(%r14)
jne 0x379c
cmpq $0x0, 0xb8(%r14)
jne 0x379c
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq $0x0, (%rax)
movq $-0x1, 0xb8(%r14)
movq %r14, %rdi
callq 0x39fc
movl $0xc8, %esi
movq %r14, %rdi
callq 0x21d0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x37c1
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::apply(Functor<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, Order) const
virtual size_t apply (const Functor<E>& f, Order order_=dontcare) const {
		if (root->elements == 0)
			return 0;
		size_t n = 0;
		root->apply_(f, order_, n);
		return n;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x2150
movq 0x8(%r15), %rdi
cmpq $0x0, 0xb8(%rdi)
je 0x38ae
leaq -0x20(%rbp), %r15
movq $0x0, (%r15)
movq %r14, %rsi
movl %ebx, %edx
movq %r15, %rcx
callq 0x4d12
movq (%r15), %rax
jmp 0x38b0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::~Node()
~Node () {
			if (leaf)
				return;
			for (size_t i = 0; i < elements+1; i++)
				delete children[i];
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2150
cmpb $0x0, 0xc0(%rbx)
jne 0x3a55
cmpq $-0x1, 0xb8(%rbx)
je 0x3a55
xorl %r15d, %r15d
movq 0x8(%rbx,%r15,8), %r14
testq %r14, %r14
je 0x3a36
movq %r14, %rdi
callq 0x39fc
movl $0xc8, %esi
movq %r14, %rdi
callq 0x21d0
incq %r15
movq 0xb8(%rbx), %rax
incq %rax
cmpq %rax, %r15
jb 0x3a24
movl $0xa8, %r14d
leaq (%rbx,%r14), %rax
movq -0x10(%rbx,%r14), %rdi
cmpq %rdi, %rax
je 0x3a74
movq (%rax), %rsi
incq %rsi
callq 0x21d0
addq $-0x20, %r14
cmpq $0x28, %r14
jne 0x3a5b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::insert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Node *insert(E key) { // insertions into inner nodes and leafs

			size_t i = 0;

			for (i = 0; i < elements; i++) {
				if (key == keys[i])
					return nullptr; // return to avoid inserting the same value twice

				if (keys[i] > key) // if key smaller than value, stop
					break;
			}

			Node *retval = nullptr;

			if (leaf)
				retval = insert_in_leaf(key, i);
			else
				retval = insert_in_node(key, i);
			return retval;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r12
movq %rdi, %rbx
callq 0x2150
cmpq $0x0, 0xb8(%rbx)
je 0x3b04
leaq 0x38(%rbx), %r13
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x8(%r12), %rdx
cmpq 0x8(%r13), %rdx
jne 0x3ae3
testq %rdx, %rdx
je 0x3b8d
movq (%r13), %rsi
movq (%r12), %rdi
callq 0x21e0
testl %eax, %eax
je 0x3b8d
movq %r13, %rdi
movq %r12, %rsi
callq 0x2040
testl %eax, %eax
jg 0x3b07
incq %r15
addq $0x20, %r13
cmpq 0xb8(%rbx), %r15
jb 0x3aba
jmp 0x3b07
xorl %r15d, %r15d
cmpb $0x1, 0xc0(%rbx)
jne 0x3b47
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %r14
movq %r14, %rdi
callq 0x346e
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3bd0
movq %rax, %r14
movq -0x68(%rbp), %rdi
jmp 0x3b7c
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r14
movq %r14, %rdi
callq 0x346e
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3c70
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x3b8d
movq (%r13), %rsi
incq %rsi
callq 0x21d0
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x3baf
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x3bc0
movq (%r13), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22b0
movq %rax, %rdi
callq 0x33bc
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq %rdi, %rbx
callq 0x2150
movq 0xb8(%rbx), %r13
cmpq %r15, %r13
jbe 0x3c1e
movq %r13, %rax
shlq $0x5, %rax
leaq (%rax,%rbx), %rdi
addq $0x38, %rdi
decq %r13
leaq -0x20(%rdi), %r12
movq %r12, %rsi
callq 0x20f0
movq %r12, %rdi
cmpq %r15, %r13
ja 0x3c07
shlq $0x5, %r15
leaq (%rbx,%r15), %rdi
addq $0x38, %rdi
movq %r14, %rsi
callq 0x20f0
movq 0xb8(%rbx), %rax
incq %rax
movq %rax, 0xb8(%rbx)
cmpq $0x3, %rax
jbe 0x3c5f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3dc0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x2150
movq 0x8(%rbx,%r14,8), %r12
leaq -0x40(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x346e
movq %r12, %rdi
movq %r15, %rsi
callq 0x3a8a
movq %rax, %r15
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x3cd5
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21d0
testq %r15, %r15
je 0x3d8e
movq %r15, -0x30(%rbp)
movq 0xb8(%rbx), %r13
cmpq %r14, %r13
jbe 0x3d22
movq %r13, %rax
shlq $0x5, %rax
leaq (%rax,%rbx), %rdi
addq $0x38, %rdi
leaq -0x1(%r13), %r15
leaq -0x20(%rdi), %r12
movq %r12, %rsi
callq 0x20f0
movq 0x8(%rbx,%r13,8), %rax
movq %rax, 0x10(%rbx,%r13,8)
movq %r12, %rdi
movq %r15, %r13
cmpq %r14, %r15
ja 0x3cfd
movq 0x8(%rbx,%r14,8), %rax
cmpb $0x1, 0xc0(%rax)
jne 0x3d3d
movq -0x30(%rbp), %r15
movq %r15, %rsi
addq $0x38, %rsi
jmp 0x3d54
movq 0xb8(%rax), %rcx
shlq $0x5, %rcx
leaq (%rax,%rcx), %rsi
addq $0x38, %rsi
movq -0x30(%rbp), %r15
movq %r14, %rax
shlq $0x5, %rax
leaq (%rbx,%rax), %rdi
addq $0x38, %rdi
callq 0x20f0
movq 0xb8(%rbx), %rax
incq %rax
movq %rax, 0xb8(%rbx)
movq %r15, 0x10(%rbx,%r14,8)
cmpq $0x3, %rax
jbe 0x3d8e
movq %rbx, %rdi
callq 0x3dc0
jmp 0x3d90
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x3db7
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
callq 0x2150
movq 0xb8(%rbx), %r13
movl $0xc8, %edi
callq 0x21b0
movq %rbx, %rdx
movq %rax, %r15
movq %rax, %r14
movq (%rbx), %rax
movq %rax, (%r15)
movl $0x48, %eax
leaq (%r15,%rax), %rcx
movq %rcx, -0x10(%r14,%rax)
movq $0x0, -0x8(%r14,%rax)
movb $0x0, (%r14,%rax)
addq $0x20, %rax
cmpq $0xc8, %rax
jne 0x3dfb
movq %r13, %rsi
shrq %rsi
xorl %eax, %eax
movq %rax, 0xb8(%r14)
movq %rax, 0x8(%r14)
movq %rax, 0x28(%r14)
movzbl 0xc0(%rdx), %eax
movb %al, 0xc0(%r14)
movq %rax, %rbx
xorq $0x1, %rbx
addq %rsi, %rbx
leaq 0x1(%r13), %rcx
cmpq %rcx, %rbx
jae 0x3eda
movq %rsi, -0x30(%rbp)
addq $0x38, %r15
movq %rbx, %rax
shlq $0x5, %rax
leaq (%rax,%rdx), %r12
addq $0x38, %r12
xorl %edi, %edi
cmpb $0x0, 0xc0(%rdx)
jne 0x3e8e
movq 0x8(%rdx,%rbx,8), %rax
movq %r14, (%rax)
movq 0x8(%rdx,%rbx,8), %rax
movq %rax, 0x8(%r14,%rdi,8)
cmpq %r13, %rbx
jae 0x3ec0
shlq $0x5, %rdi
addq %r15, %rdi
movq %r12, %rsi
movq %rdx, %r13
callq 0x20f0
movq %r13, %rdx
movq 0xb8(%r14), %rdi
incq %rdi
movq %rdi, 0xb8(%r14)
movq 0xb8(%r13), %r13
incq %rbx
leaq 0x1(%r13), %rax
addq $0x20, %r12
cmpq %rax, %rbx
jb 0x3e73
movb 0xc0(%rdx), %al
movq -0x30(%rbp), %rsi
movq %rsi, 0xb8(%rdx)
testb $0x1, %al
je 0x3efe
movq 0x28(%rdx), %rax
movq %rax, 0x28(%r14)
movq %r14, 0x28(%rdx)
movq %rdx, 0x8(%r14)
testq %rax, %rax
je 0x3efe
movq %r14, 0x8(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x38, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2150
movq 0xb8(%r14), %r15
cmpb $0x0, 0xc0(%r14)
je 0x3f93
movq %r12, -0x38(%rbp)
movq %r14, -0x30(%rbp)
testq %r15, %r15
je 0x400a
movq 0x8(%rbx), %r13
movq -0x30(%rbp), %rax
leaq 0x40(%rax), %r14
xorl %r12d, %r12d
cmpq (%r14), %r13
jne 0x3f85
testq %r13, %r13
je 0x4019
movq -0x8(%r14), %rsi
movq (%rbx), %rdi
movq %r13, %rdx
callq 0x21e0
testl %eax, %eax
je 0x4019
incq %r12
addq $0x20, %r14
cmpq %r12, %r15
jne 0x3f60
jmp 0x400a
testq %r15, %r15
je 0x3fc0
leaq 0x38(%r14), %r12
xorl %r15d, %r15d
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2040
testl %eax, %eax
jg 0x3fc3
incq %r15
addq $0x20, %r12
cmpq 0xb8(%r14), %r15
jb 0x3f9f
jmp 0x3fc3
xorl %r15d, %r15d
movq 0x8(%r14,%r15,8), %r14
leaq -0x48(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rbx
movq %rbx, %rdi
callq 0x346e
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3f10
movq -0x58(%rbp), %rdi
cmpq %r12, %rdi
je 0x400a
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %r12, %rsi
movq -0x38(%rbp), %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4060
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r12, %rdi
je 0x404f
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22b0
movq %rax, %rdi
callq 0x33bc
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r12
callq 0x2150
testq %r14, %r14
je 0x4442
shlq $0x5, %r14
leaq (%r14,%r12), %rdi
addq $0x18, %rdi
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
movq (%r12), %r14
testq %r14, %r14
je 0x44ae
movq 0xb8(%r14), %rax
xorl %r15d, %r15d
incq %rax
je 0x446c
cmpq %r12, 0x8(%r14,%r15,8)
je 0x446c
incq %r15
cmpq %r15, %rax
jne 0x445a
movq %rax, %r15
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rbx
movq %rbx, %rdi
callq 0x346e
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x4400
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x44ae
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21d0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x44d3
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x38, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rbx
callq 0x2150
movq 0x28(%rbx), %rax
cmpq $0x0, 0xb8(%rax)
je 0x4581
leaq -0x48(%rbp), %r15
leaq 0x38(%rbx), %rdx
movq %rdx, -0x38(%rbp)
movl $0x40, %r12d
xorl %r13d, %r13d
movq %r15, -0x58(%rbp)
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x346e
movq 0xb8(%rbx), %rdi
leaq 0x1(%rdi), %rax
movq %rax, 0xb8(%rbx)
shlq $0x5, %rdi
addq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x20f0
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x456d
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21d0
incq %r13
movq 0x28(%rbx), %rax
addq $0x20, %r12
cmpq 0xb8(%rax), %r13
jb 0x451c
movq -0x30(%rbp), %r14
leaq 0x1(%r14), %rcx
movq (%rbx), %rdi
movq 0xb8(%rdi), %rax
cmpq %rax, %rcx
jae 0x45b8
movq 0x10(%rdi,%rcx,8), %rax
movq %rax, 0x8(%rdi,%rcx,8)
leaq 0x1(%rcx), %rdx
movq (%rbx), %rdi
movq 0xb8(%rdi), %rax
movq %rdx, %rcx
cmpq %rax, %rdx
jb 0x4598
decq %rax
cmpq %r14, %rax
jbe 0x45f4
movq %r14, %r15
shlq $0x5, %r15
addq $0x38, %r15
incq %r14
leaq (%rdi,%r15), %rsi
addq $0x20, %rsi
addq %r15, %rdi
callq 0x20f0
movq (%rbx), %rdi
movq 0xb8(%rdi), %rax
decq %rax
addq $0x20, %r15
cmpq %rax, %r14
jb 0x45cb
movq %rax, 0xb8(%rdi)
movq 0x28(%rbx), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rax), %rdx
testq %rdx, %rdx
je 0x4610
movq %rcx, 0x8(%rdx)
testq %rcx, %rcx
je 0x461d
movq 0x28(%rax), %rax
movq %rax, 0x28(%rcx)
movq (%rbx), %rdi
callq 0x4654
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x464c
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2150
movq (%rbx), %rcx
cmpq $0x2, 0xb8(%rbx)
setae %al
testq %rcx, %rcx
sete %dl
orb %al, %dl
je 0x4681
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0xb8(%rcx), %rsi
xorl %edx, %edx
cmpq %rbx, 0x8(%rcx,%rdx,8)
je 0x469b
incq %rdx
cmpq %rsi, %rdx
jbe 0x468a
jmp 0x46a0
testq %rdx, %rdx
je 0x46f7
movq (%rcx,%rdx,8), %rax
cmpq %rsi, %rdx
jae 0x46b5
movq 0x10(%rcx,%rdx,8), %rsi
testq %rax, %rax
jne 0x46bc
jmp 0x4706
testq %rax, %rax
je 0x467a
xorl %esi, %esi
cmpq %rcx, (%rax)
jne 0x46d8
cmpq $0x3, 0xb8(%rax)
jb 0x46d8
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %ecx
jmp 0x4723
testq %rsi, %rsi
je 0x46ec
cmpq %rcx, (%rsi)
jne 0x46ec
cmpq $0x2, 0xb8(%rsi)
ja 0x471e
decq %rdx
movq %rax, %rdi
movq %rbx, %rsi
jmp 0x4731
testq %rsi, %rsi
je 0x467a
movq 0x10(%rcx), %rsi
xorl %edx, %edx
testq %rsi, %rsi
je 0x467a
cmpq %rcx, (%rsi)
jne 0x472e
cmpq $0x3, 0xb8(%rsi)
jb 0x472e
movq %rbx, %rdi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x473c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x49d8
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2150
cmpq $0x0, 0xb8(%r14)
je 0x4c80
leaq 0x38(%r14), %r15
xorl %r13d, %r13d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2040
testl %eax, %eax
jg 0x4c83
movq 0x8(%r15), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x4c6e
movb $0x1, %r12b
testq %rdx, %rdx
je 0x4c97
movq (%rbx), %rsi
movq (%r15), %rdi
callq 0x21e0
testl %eax, %eax
je 0x4c97
incq %r13
addq $0x20, %r15
cmpq 0xb8(%r14), %r13
jb 0x4c3e
jmp 0x4c83
xorl %r13d, %r13d
cmpb $0x0, 0xc0(%r14)
jne 0x4c94
movq 0x8(%r14,%r13,8), %r14
jmp 0x4c2d
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x33bc
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2150
movq 0xb8(%rbx), %r14
cmpb $0x0, 0xc0(%rbx)
jne 0x4d04
cmpq $-0x1, %r14
je 0x4d01
xorl %r15d, %r15d
xorl %r14d, %r14d
movq 0x8(%rbx,%r15,8), %rdi
callq 0x4cb2
addq %rax, %r14
incq %r15
movq 0xb8(%rbx), %rax
incq %rax
cmpq %rax, %r15
jb 0x4ce0
jmp 0x4d04
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2150
movq 0xb8(%r15), %r13
movl %r12d, -0x30(%rbp)
cmpl $0x2, %r12d
jne 0x4dd6
cmpb $0x0, 0xc0(%r15)
jne 0x4d6d
movq 0x8(%r15,%r13,8), %rdi
movq %r14, %rsi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x4d12
testb %al, %al
je 0x4e4d
leaq -0x1(%r13), %r12
leaq 0x18(%r15), %rax
movq %rax, -0x30(%rbp)
shlq $0x5, %r13
cmpq 0xb8(%r15), %r12
ja 0x4e49
cmpb $0x1, 0xc0(%r15)
jne 0x4da9
incq (%rbx)
movq -0x30(%rbp), %rax
leaq (%rax,%r13), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
jmp 0x4dc2
movq -0x30(%rbp), %rax
movq -0x10(%rax,%r12,8), %rdi
movq %r14, %rsi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x4d12
testb %al, %al
je 0x4e4d
addq $-0x20, %r13
addq $-0x1, %r12
jb 0x4d7d
jmp 0x4e49
testq %r13, %r13
je 0x4e25
leaq 0x38(%r15), %r13
xorl %r12d, %r12d
cmpb $0x1, 0xc0(%r15)
jne 0x4dfc
incq (%rbx)
movq (%r14), %rax
movq %r14, %rdi
movq %r13, %rsi
callq *(%rax)
jmp 0x4e0f
movq 0x8(%r15,%r12,8), %rdi
movq %r14, %rsi
movl -0x30(%rbp), %edx
movq %rbx, %rcx
callq 0x4d12
testb %al, %al
je 0x4e4d
incq %r12
addq $0x20, %r13
cmpq 0xb8(%r15), %r12
jb 0x4de2
jmp 0x4e28
xorl %r12d, %r12d
cmpb $0x0, 0xc0(%r15)
jne 0x4e49
movq 0x8(%r15,%r12,8), %rdi
movq %r14, %rsi
movl -0x30(%rbp), %edx
movq %rbx, %rcx
callq 0x4d12
testb %al, %al
je 0x4e4d
movb $0x1, %al
jmp 0x4e4f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15d
movq %rsi, %rbx
movq %rdi, %r13
callq 0x2150
leaq 0x1759(%rip), %r12      # 0x6619
movl %r15d, %r14d
testl %r15d, %r15d
jle 0x4edd
movl $0x2, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2200
decl %r14d
jne 0x4ec8
cmpb $0x0, 0xc0(%r13)
leaq 0x1738(%rip), %rsi      # 0x6624
leaq 0x1729(%rip), %rax      # 0x661c
cmovneq %rax, %rsi
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2200
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2140
movq %r13, -0x40(%rbp)
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %r13, %rdi
movq -0x40(%rbp), %r13
callq 0x2030
movq %rax, %rdi
callq 0x2120
cmpq $0x0, 0xb8(%r13)
movq %r15, -0x38(%rbp)
je 0x5006
leal 0x1(%r15), %eax
movl %eax, -0x2c(%rbp)
leaq 0x38(%r13), %r14
xorl %r15d, %r15d
cmpb $0x0, 0xc0(%r13)
jne 0x4f7b
movq 0x8(%r13,%r15,8), %rdi
movq %rbx, %rsi
movl -0x2c(%rbp), %edx
callq 0x4e9a
movq -0x38(%rbp), %rax
movl %eax, %r13d
testl %eax, %eax
jle 0x4f9b
movl $0x2, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2200
decl %r13d
jne 0x4f86
movl $0x2, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2200
movq %r15, %rax
shlq $0x5, %rax
movq (%r14,%rax), %rsi
movq 0x8(%r14,%rax), %rdx
movq %rbx, %rdi
callq 0x2200
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
incq %r15
movq -0x40(%rbp), %r13
movq 0xb8(%r13), %rax
cmpq %rax, %r15
jb 0x4f61
jmp 0x5008
xorl %eax, %eax
cmpb $0x0, 0xc0(%r13)
jne 0x5023
movq 0x8(%r13,%rax,8), %r13
movq -0x38(%rbp), %r15
incl %r15d
jmp 0x4ec0
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_O3/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 0x7a16(%rip), %rcx      # 0xa298
movl (%rcx,%rax,4), %esi
cmpl %edi, %esi
jne 0x2892
incl 0x7a25(%rip)            # 0xa2b4
movl (%rcx,%rax,4), %esi
cmpl %r14d, %edx
jge 0x28e4
cmpl %r15d, %esi
je 0x28e4
movq %rdx, -0x30(%rbp)
movl %r15d, (%rcx,%rax,4)
movq 0x7925(%rip), %rcx      # 0xa1d0
leaq (%rax,%rax,2), %rax
movq (%rcx,%rax,8), %r13
movq 0x8(%rcx,%rax,8), %rbx
cmpq %rbx, %r13
je 0x28e0
movq -0x30(%rbp), %rax
leal 0x1(%rax), %r12d
movl (%r13), %esi
movl %r15d, %edi
movl %r12d, %edx
movl %r14d, %ecx
callq 0x2864
addq $0x4, %r13
cmpq %rbx, %r13
jne 0x28c5
movq -0x30(%rbp), %rdx
cmpl %edx, 0x79ce(%rip)      # 0xa2b8
jge 0x28f2
movl %edx, 0x79c6(%rip)      # 0xa2b8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movq 0x20(%rdi), %r15
cmpq %r15, %r14
je 0x3bc6
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3bc0
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x3bad
movq (%rbx), %r15
movq 0x8(%rbx), %r12
cmpq %r12, %r15
je 0x3bf5
movq (%r15), %r14
testq %r14, %r14
je 0x3be2
movq %r14, %rdi
callq 0x3220
movl $0x18, %esi
movq %r14, %rdi
callq 0x31b0
addq $0x8, %r15
jmp 0x3bcd
leaq 0x30(%rbx), %rdi
callq 0x31e0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3c13
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x31b0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3c32
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x31b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x31f0
movq %rax, %r14
movq 0x18(%rbx), %r15
movq 0x20(%rbx), %r12
cmpq %r12, %r15
je 0x3c91
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
addq $0x8, %r15
jmp 0x3c7a
callq 0x31f0
subq %r14, %rax
movq %rax, 0xb0(%rbx)
movq 0xb8(%rbx), %rcx
subq %rax, %rcx
jle 0x3cf4
movq %rcx, %rax
shrq $0x9, %rax
movabsq $0x44b82fa09b5a53, %rdx # imm = 0x44B82FA09B5A53
mulq %rdx
shrq $0xb, %rdx
imulq $-0x3b9aca00, %rdx, %rax # imm = 0xC4653600
addq %rcx, %rax
leaq 0x8(%rsp), %rbx
movq %rdx, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x3090
cmpl $-0x1, %eax
jne 0x3cf4
callq 0x3050
cmpl $0x4, (%rax)
je 0x3cda
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rsi, %r15
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq 0x40(%rdi), %rax
cmpq %rax, 0x60(%rdi)
je 0x3db3
leaq 0x30(%rbx), %r12
movl (%rax), %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %r13
testq %r13, %r13
je 0x3d95
movq %r13, %rdi
callq 0x3220
movl $0x18, %esi
movq %r13, %rdi
callq 0x31b0
movq (%rbx), %rax
movq %r15, (%rax,%r14,8)
movq %r12, %rdi
callq 0x32b0
jmp 0x3de9
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3dce
movq %r15, (%rsi)
movq 0x8(%rbx), %r14
addq $0x8, %r14
movq %r14, 0x8(%rbx)
jmp 0x3ddf
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x3030
movq 0x8(%rbx), %r14
subq (%rbx), %r14
shrq $0x3, %r14
decl %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %r12d
movl %edi, %r14d
leaq 0x8(%rsp), %rdi
callq 0x3252
xorl %ebx, %ebx
testl %r14d, %r14d
je 0x14fe
movl %r14d, %ebp
shrl $0x2, %ebp
xorl %ebx, %ebx
xorl %r15d, %r15d
movl %r12d, %eax
shll $0xf, %eax
notl %eax
addl %r12d, %eax
movl %eax, %ecx
shrl $0xa, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
movl %eax, %ecx
shrl $0x6, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0xb, %eax
notl %eax
addl %ecx, %eax
movl %eax, %r12d
shrl $0x10, %r12d
xorl %eax, %r12d
movl %r12d, %eax
xorl %edx, %edx
divl %ebp
movl %edx, %eax
shll $0xf, %eax
notl %eax
addl %edx, %eax
movl %eax, %ecx
shrl $0xa, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
movl %eax, %ecx
shrl $0x6, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0xb, %eax
notl %eax
addl %ecx, %eax
movl %eax, %r13d
shrl $0x10, %r13d
xorl %eax, %r13d
movl 0x118(%rsp), %eax
andl %r13d, %eax
movl 0x110(%rsp), %ecx
andl %r13d, %ecx
cmpl 0x11c(%rsp), %eax
cmovael %eax, %ecx
movl %ecx, %eax
orl $0x1, %eax
bsrl %eax, %eax
movq 0x8(%rsp,%rax,8), %rax
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0x14bd
cmpl %r13d, 0x18(%rax)
jne 0x14b8
movq 0x10(%rax), %rcx
cmpl %r13d, (%rcx)
je 0x14e8
movq (%rax), %rax
jmp 0x14a4
pushq $0x28
popq %rdi
callq 0x1090
movl %r13d, (%rax)
movl $0x1, 0x4(%rax)
leaq 0x8(%rax), %rsi
leaq 0x8(%rsp), %rdi
movq %rax, %rdx
movl %r13d, %ecx
callq 0x3357
pushq $0x1
popq %rax
jmp 0x14f0
movl 0x4(%rcx), %eax
incl %eax
movl %eax, 0x4(%rcx)
addl %eax, %ebx
incl %r15d
cmpl %r14d, %r15d
jne 0x1412
movq 0x5af3(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x8(%rsp), %r14
movl 0x118(%r14), %edx
leaq 0x2b5a(%rip), %rsi      # 0x4075
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1080
movl 0x118(%r14), %ebx
movq %r14, %rdi
callq 0x330b
movl %ebx, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq 0x3dc1(%rip), %rbx      # 0x4fd8
leaq 0x1de6(%rip), %rsi      # 0x3004
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x10a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
leaq 0x1da1(%rip), %rsi      # 0x3024
movl $0x29, %edx
movq %rbx, %rdi
callq 0x10a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
leaq 0x1d90(%rip), %rsi      # 0x304e
movl $0x11, %edx
movq %rbx, %rdi
callq 0x10a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
leaq 0x1d3d(%rip), %rbx      # 0x3060
movq %rbx, %rdi
callq 0x1354
movq %rbx, %rdi
callq 0x15a6
leaq 0x1d2e(%rip), %rbx      # 0x3068
movq %rbx, %rdi
callq 0x184c
movq %rbx, %rdi
callq 0x1b00
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
cmpl $0x1, %edi
jle 0x144e
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x149e
leaq 0xdbd(%rip), %rsi       # 0x2020
leaq 0x30(%rsp), %rdi
callq 0x10e0
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1294
movq %rdx, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x129b
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x10(%rsp), %rdi
callq 0x10d0
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x12d4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1070
leaq 0x40(%rsp), %r14
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x12ef
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1070
movq 0x8(%rbx), %rsi
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x149e
leaq 0xd1d(%rip), %rsi       # 0x2026
leaq 0x30(%rsp), %rdi
callq 0x10e0
movq %r15, 0x10(%rsp)
movq (%rax), %rdi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdi
je 0x1336
movq %rdi, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x1340
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq %r15, %rdi
movq 0x8(%rax), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x10d0
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x1374
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1070
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x138b
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1070
movq 0x8(%rbx), %rsi
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x149e
leaq 0xc89(%rip), %rsi       # 0x202e
leaq 0x30(%rsp), %rdi
callq 0x10e0
leaq 0x20(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rax), %rdi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdi
je 0x13d6
movq %rdi, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x13df
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rdi
movq 0x8(%rax), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x10d0
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0x1413
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1070
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x142a
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1070
movq 0x2bbf(%rip), %rdi      # 0x3ff0
leaq 0xbfe(%rip), %rsi       # 0x2036
movl $0x6, %edx
callq 0x1080
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x121c
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1090
jmp 0x1461
jmp 0x1492
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
jne 0x1483
jmp 0x1495
jmp 0x1492
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1495
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1070
jmp 0x1495
movq %rax, %rbx
movq %rbx, %rdi
callq 0x10b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4aec
leaq 0x11f88(%rip), %rax     # 0x16af0
movq %rax, (%rbx)
leaq 0x1f0(%rbx), %rax
xorl %ecx, %ecx
movl %ecx, 0x1f0(%rbx)
movq %rcx, 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)
movq %rcx, 0x210(%rbx)
movb $0x0, 0x218(%rbx)
movl %ecx, 0x21a(%rbx)
movl %ecx, 0x220(%rbx)
addq $0x1e8, %rbx            # imm = 0x1E8
movq %rbx, %rdi
popq %rbx
jmp 0x4bd1
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
leaq 0x8(%rdi), %r12
cmpq %r12, %r14
je 0x4c23
movq 0x28(%r14), %r15
testq %r15, %r15
je 0x4c06
movq (%r15), %rdi
testq %rdi, %rdi
je 0x4c06
movq 0x10(%r15), %rsi
subq %rdi, %rsi
callq 0x43a0
movl $0x18, %esi
movq %r15, %rdi
callq 0x43a0
movq %r14, %rdi
callq 0x4260
movq %rax, %r14
cmpq %r12, %rax
jne 0x4be9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x795a
// File: /workspace/github_cpp_makefile_star2_O3/cpearce[P]OggIndex/src/Decoder.cpp
// Function: Decoder::Create(ogg_page*)
Decoder* Decoder::Create(ogg_page* page)
{
  assert(ogg_page_bos(page));
  ogg_uint32_t serialno = ogg_page_serialno(page);
  if (page->body_len > 8 &&
      strncmp("theora", (const char*)page->body+1, 6) == 0)
  {
    return new TheoraDecoder(serialno);
  } else if (page->body_len > 8 &&
             strncmp("vorbis", (const char*)page->body+1, 6) == 0)
  {
    return new VorbisDecoder(serialno);
#ifdef HAVE_KATE
  } else if (page->body_len > 8 &&
             memcmp("kate\0\0\0", (const char*)page->body+1, 7) == 0)
  {
    return new KateDecoder(serialno);
#endif
  } else if (page->body_len > 8 &&
             strncmp("fishead", (const char*)page->body, 8) == 0)
  {
    return new SkeletonDecoder(serialno);
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x46e0
testl %eax, %eax
je 0x5363
movq %r14, %rdi
callq 0x42d0
cmpq $0x9, 0x18(%r14)
jl 0x530c
movl %eax, %ebx
movq 0x10(%r14), %r14
leaq 0x1(%r14), %r15
leaq 0xb40c(%rip), %rdi      # 0x106d7
movl $0x6, %edx
movq %r15, %rsi
callq 0x41a0
testl %eax, %eax
je 0x5311
leaq 0xb538(%rip), %rdi      # 0x1081b
movl $0x6, %edx
movq %r15, %rsi
callq 0x41a0
testl %eax, %eax
je 0x532a
leaq 0xaed1(%rip), %rdi      # 0x101cc
movl $0x8, %edx
movq %r14, %rsi
callq 0x41a0
testl %eax, %eax
je 0x5343
xorl %r14d, %r14d
jmp 0x535a
movl $0x290, %edi            # imm = 0x290
callq 0x4380
movq %rax, %r14
movq %rax, %rdi
movl %ebx, %esi
callq 0x53ba
jmp 0x535a
movl $0x388, %edi            # imm = 0x388
callq 0x4380
movq %rax, %r14
movq %rax, %rdi
movl %ebx, %esi
callq 0x5498
jmp 0x535a
movl $0x228, %edi            # imm = 0x228
callq 0x4380
movq %rax, %r14
movq %rax, %rdi
movl %ebx, %esi
callq 0x4b58
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xae23(%rip), %rdi      # 0x1018d
leaq 0xac9c(%rip), %rsi      # 0x1000d
leaq 0xae28(%rip), %rcx      # 0x101a0
movl $0x3ed, %edx            # imm = 0x3ED
callq 0x4210
movq %rax, %rbx
movl $0x228, %esi            # imm = 0x228
jmp 0x539e
movq %rax, %rbx
movl $0x388, %esi            # imm = 0x388
jmp 0x539e
movq %rax, %rbx
movl $0x290, %esi            # imm = 0x290
movq %r14, %rdi
callq 0x43a0
movq %rbx, %rdi
callq 0x46d0
// File: /workspace/github_cpp_makefile_star2_O3/cpearce[P]OggIndex/src/Decoder.cpp
// Function: TheoraDecoder::GetFisboneInfo()
virtual FisboneInfo GetFisboneInfo() {
    FisboneInfo f;
    f.mGranNumer = mInfo.fps_numerator;
    f.mGranDenom = mInfo.fps_denominator;
    f.mPreroll = 0;
    f.mGranuleShift = mInfo.keyframe_granule_shift;
    f.mRadix = 0;
    f.mContentType = "video/theora";
    f.mRole = "video/main";
    f.mName = "video_1";
    return f;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x20, %rdi
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
xorl %eax, %eax
movq %rax, 0x28(%rbx)
movb %al, 0x30(%rbx)
leaq 0x50(%rbx), %rcx
movq %rcx, 0x40(%rbx)
movq %rax, 0x48(%rbx)
movb %al, 0x50(%rbx)
leaq 0x70(%rbx), %rcx
movq %rcx, 0x60(%rbx)
movq %rax, 0x68(%rbx)
movb %al, 0x70(%rbx)
movsd 0x1d4(%rsi), %xmm0
xorps %xmm1, %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movups %xmm0, (%rbx)
movl %eax, 0x10(%rbx)
movl 0x1f4(%rsi), %ecx
movl %ecx, 0x14(%rbx)
movl %eax, 0x18(%rbx)
leaq 0xa1ee(%rip), %rcx      # 0x106d1
movl $0xc, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x45b0
leaq 0x40(%rbx), %rdi
movq 0x48(%rbx), %rdx
leaq 0xa1dd(%rip), %rcx      # 0x106de
movl $0xa, %r8d
xorl %esi, %esi
callq 0x45b0
leaq 0x60(%rbx), %rdi
movq 0x68(%rbx), %rdx
leaq 0xa1cc(%rip), %rcx      # 0x106e9
movl $0x7, %r8d
xorl %esi, %esi
callq 0x45b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6c34
movq %r14, %rdi
callq 0x46d0