LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3ee6
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x3765
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21d0
movq 0x8(%rbx), %r14
cmpb $0x0, 0xc0(%r14)
jne 0x37b1
cmpq $0x0, 0xb8(%r14)
jne 0x37b1
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq $0x0, (%rax)
movq $-0x1, 0xb8(%r14)
testq %r14, %r14
je 0x37b1
movq %r14, %rdi
callq 0x39d4
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 0x37d6
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x38c2
leaq -0x20(%rbp), %r15
movq $0x0, (%r15)
movq %r14, %rsi
movl %ebx, %edx
movq %r15, %rcx
callq 0x4cd2
movq (%r15), %rax
jmp 0x38c4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3a2d
cmpq $-0x1, 0xb8(%rbx)
je 0x3a2d
xorl %r15d, %r15d
movq 0x8(%rbx,%r15,8), %r14
testq %r14, %r14
je 0x3a1b
movq %r14, %rdi
callq 0x39d4
movl $0xc8, %esi
movq %r14, %rdi
callq 0x21d0
incq %r15
movq 0xb8(%rbx), %rax
incq %rax
cmpq %rax, %r15
jb 0x39fc
movl $0xa8, %r14d
leaq (%rbx,%r14), %rax
movq -0x10(%rbx,%r14), %rdi
cmpq %rdi, %rax
je 0x3a4c
movq (%rax), %rsi
incq %rsi
callq 0x21d0
addq $-0x20, %r14
cmpq $0x28, %r14
jne 0x3a33
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3adc
leaq 0x38(%rbx), %r13
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x8(%r12), %rdx
cmpq 0x8(%r13), %rdx
jne 0x3abb
testq %rdx, %rdx
je 0x3b65
movq (%r13), %rsi
movq (%r12), %rdi
callq 0x21e0
testl %eax, %eax
je 0x3b65
movq %r13, %rdi
movq %r12, %rsi
callq 0x2040
testl %eax, %eax
jg 0x3adf
incq %r15
addq $0x20, %r13
cmpq 0xb8(%rbx), %r15
jb 0x3a92
jmp 0x3adf
xorl %r15d, %r15d
cmpb $0x1, 0xc0(%rbx)
jne 0x3b1f
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 0x3ba8
movq %rax, %r14
movq -0x68(%rbp), %rdi
jmp 0x3b54
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 0x3c48
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x3b65
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 0x3b87
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x3b98
movq (%r13), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22b0
movq %rax, %rdi
callq 0x33c2
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3bf6
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 0x3bdf
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 0x3c37
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3d98
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_O1/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 0x3a62
movq %rax, %r15
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x3cad
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21d0
testq %r15, %r15
je 0x3d66
movq %r15, -0x30(%rbp)
movq 0xb8(%rbx), %r13
cmpq %r14, %r13
jbe 0x3cfa
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 0x3cd5
movq 0x8(%rbx,%r14,8), %rax
cmpb $0x1, 0xc0(%rax)
jne 0x3d15
movq -0x30(%rbp), %r15
movq %r15, %rsi
addq $0x38, %rsi
jmp 0x3d2c
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 0x3d66
movq %rbx, %rdi
callq 0x3d98
jmp 0x3d68
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 0x3d8f
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %r12
movl $0xc8, %edi
callq 0x21b0
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 0x3dd0
shrq %r12
xorl %eax, %eax
movq %rax, 0xb8(%r14)
movb $0x1, 0xc0(%r14)
movq %rax, 0x8(%r14)
movq %rax, 0x28(%r14)
movzbl 0xc0(%rbx), %r13d
movb %r13b, 0xc0(%r14)
xorq $0x1, %r13
movq %r12, -0x30(%rbp)
addq %r12, %r13
movq 0xb8(%rbx), %rax
leaq 0x1(%rax), %rcx
cmpq %rcx, %r13
jae 0x3ea7
addq $0x38, %r15
movq %r13, %rcx
shlq $0x5, %rcx
leaq (%rcx,%rbx), %r12
addq $0x38, %r12
cmpb $0x0, 0xc0(%rbx)
jne 0x3e6e
movq 0x8(%rbx,%r13,8), %rcx
movq %r14, (%rcx)
movq 0x8(%rbx,%r13,8), %rcx
movq 0xb8(%r14), %rdx
movq %rcx, 0x8(%r14,%rdx,8)
cmpq %rax, %r13
jae 0x3e90
movq 0xb8(%r14), %rdi
shlq $0x5, %rdi
addq %r15, %rdi
movq %r12, %rsi
callq 0x20f0
incq 0xb8(%r14)
incq %r13
movq 0xb8(%rbx), %rax
leaq 0x1(%rax), %rcx
addq $0x20, %r12
cmpq %rcx, %r13
jb 0x3e4c
movq -0x30(%rbp), %rax
movq %rax, 0xb8(%rbx)
cmpb $0x0, 0xc0(%rbx)
je 0x3ed4
movq 0x28(%rbx), %rax
movq %rax, 0x28(%r14)
movq %r14, 0x28(%rbx)
movq %rbx, 0x8(%r14)
testq %rax, %rax
je 0x3ed4
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_O1/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 0x3f69
movq %r12, -0x38(%rbp)
movq %r14, -0x30(%rbp)
testq %r15, %r15
je 0x3fe0
movq 0x8(%rbx), %r13
movq -0x30(%rbp), %rax
leaq 0x40(%rax), %r14
xorl %r12d, %r12d
cmpq (%r14), %r13
jne 0x3f5b
testq %r13, %r13
je 0x3fef
movq -0x8(%r14), %rsi
movq (%rbx), %rdi
movq %r13, %rdx
callq 0x21e0
testl %eax, %eax
je 0x3fef
incq %r12
addq $0x20, %r14
cmpq %r12, %r15
jne 0x3f36
jmp 0x3fe0
testq %r15, %r15
je 0x3f96
leaq 0x38(%r14), %r12
xorl %r15d, %r15d
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2040
testl %eax, %eax
jg 0x3f99
incq %r15
addq $0x20, %r12
cmpq 0xb8(%r14), %r15
jb 0x3f75
jmp 0x3f99
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 0x3ee6
movq -0x58(%rbp), %rdi
cmpq %r12, %rdi
je 0x3fe0
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 0x4036
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r12, %rdi
je 0x4025
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22b0
movq %rax, %rdi
callq 0x33c2
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4412
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 0x447e
movq 0xb8(%r14), %rax
xorl %r15d, %r15d
incq %rax
je 0x443c
cmpq %r12, 0x8(%r14,%r15,8)
je 0x443c
incq %r15
cmpq %r15, %rax
jne 0x442a
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 0x43d0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x447e
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 0x44a3
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4551
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 0x453d
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21d0
incq %r13
movq 0x28(%rbx), %rax
addq $0x20, %r12
cmpq 0xb8(%rax), %r13
jb 0x44ec
movq -0x30(%rbp), %r14
leaq 0x1(%r14), %rcx
movq (%rbx), %rax
cmpq 0xb8(%rax), %rcx
jae 0x4582
movq 0x10(%rax,%rcx,8), %rdx
movq %rdx, 0x8(%rax,%rcx,8)
leaq 0x1(%rcx), %rdx
movq (%rbx), %rax
movq %rdx, %rcx
cmpq 0xb8(%rax), %rdx
jb 0x4565
movq (%rbx), %rdi
movq 0xb8(%rdi), %rax
decq %rax
cmpq %r14, %rax
jbe 0x45c8
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 0x459f
movq %rax, 0xb8(%rdi)
movq 0x28(%rbx), %rax
movq 0x28(%rax), %rcx
testq %rcx, %rcx
je 0x45e4
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rcx)
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x45f5
movq 0x28(%rax), %rax
movq %rax, 0x28(%rcx)
movq (%rbx), %rdi
callq 0x462c
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 0x4624
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4659
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0xb8(%rcx), %rsi
xorl %edx, %edx
cmpq %rbx, 0x8(%rcx,%rdx,8)
je 0x4671
incq %rdx
cmpq %rsi, %rdx
jbe 0x4662
testq %rdx, %rdx
je 0x467c
movq (%rcx,%rdx,8), %rax
jmp 0x467e
xorl %eax, %eax
cmpq %rsi, %rdx
jae 0x468a
movq 0x10(%rcx,%rdx,8), %rsi
jmp 0x468c
xorl %esi, %esi
testq %rax, %rax
je 0x46ad
cmpq %rcx, (%rax)
jne 0x46ad
cmpq $0x3, 0xb8(%rax)
jb 0x46ad
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %ecx
jmp 0x46c6
testq %rsi, %rsi
je 0x46d1
cmpq %rcx, (%rsi)
jne 0x46d1
cmpq $0x3, 0xb8(%rsi)
jb 0x46d1
movq %rbx, %rdi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x46f8
testq %rax, %rax
je 0x46e1
decq %rdx
movq %rax, %rdi
movq %rbx, %rsi
jmp 0x46ed
testq %rsi, %rsi
je 0x4652
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4994
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4c40
leaq 0x38(%r14), %r15
xorl %r13d, %r13d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2040
testl %eax, %eax
jg 0x4c43
movq 0x8(%r15), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x4c2e
movb $0x1, %r12b
testq %rdx, %rdx
je 0x4c57
movq (%rbx), %rsi
movq (%r15), %rdi
callq 0x21e0
testl %eax, %eax
je 0x4c57
incq %r13
addq $0x20, %r15
cmpq 0xb8(%r14), %r13
jb 0x4bfe
jmp 0x4c43
xorl %r13d, %r13d
cmpb $0x0, 0xc0(%r14)
jne 0x4c54
movq 0x8(%r14,%r13,8), %r14
jmp 0x4bed
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 0x33c2
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4cc4
cmpq $-0x1, %r14
je 0x4cc1
xorl %r15d, %r15d
xorl %r14d, %r14d
movq 0x8(%rbx,%r15,8), %rdi
callq 0x4c72
addq %rax, %r14
incq %r15
movq 0xb8(%rbx), %rax
incq %rax
cmpq %rax, %r15
jb 0x4ca0
jmp 0x4cc4
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4d96
cmpb $0x0, 0xc0(%r15)
jne 0x4d2d
movq 0x8(%r15,%r13,8), %rdi
movq %r14, %rsi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x4cd2
testb %al, %al
je 0x4e0d
leaq -0x1(%r13), %r12
leaq 0x18(%r15), %rax
movq %rax, -0x30(%rbp)
shlq $0x5, %r13
cmpq 0xb8(%r15), %r12
ja 0x4e09
cmpb $0x1, 0xc0(%r15)
jne 0x4d69
incq (%rbx)
movq -0x30(%rbp), %rax
leaq (%rax,%r13), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
jmp 0x4d82
movq -0x30(%rbp), %rax
movq -0x10(%rax,%r12,8), %rdi
movq %r14, %rsi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x4cd2
testb %al, %al
je 0x4e0d
addq $-0x20, %r13
addq $-0x1, %r12
jb 0x4d3d
jmp 0x4e09
testq %r13, %r13
je 0x4de5
leaq 0x38(%r15), %r13
xorl %r12d, %r12d
cmpb $0x1, 0xc0(%r15)
jne 0x4dbc
incq (%rbx)
movq (%r14), %rax
movq %r14, %rdi
movq %r13, %rsi
callq *(%rax)
jmp 0x4dcf
movq 0x8(%r15,%r12,8), %rdi
movq %r14, %rsi
movl -0x30(%rbp), %edx
movq %rbx, %rcx
callq 0x4cd2
testb %al, %al
je 0x4e0d
incq %r12
addq $0x20, %r13
cmpq 0xb8(%r15), %r12
jb 0x4da2
jmp 0x4de8
xorl %r12d, %r12d
cmpb $0x0, 0xc0(%r15)
jne 0x4e09
movq 0x8(%r15,%r12,8), %rdi
movq %r14, %rsi
movl -0x30(%rbp), %edx
movq %rbx, %rcx
callq 0x4cd2
testb %al, %al
je 0x4e0d
movb $0x1, %al
jmp 0x4e0f
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_O1/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 0x2150
cmpb $0x1, 0xc0(%rbx)
je 0x4e3b
movq 0x8(%rbx), %rbx
jmp 0x4e2c
addq $0x38, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2150
movq 0xb8(%rbx), %rax
cmpb $0x1, 0xc0(%rbx)
je 0x4eab
movq 0x8(%rbx,%rax,8), %rbx
jmp 0x4e94
shlq $0x5, %rax
addq %rbx, %rax
addq $0x18, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r13
callq 0x2150
movq $0x0, -0x30(%rbp)
leaq 0x172d(%rip), %r12      # 0x6619
movl %r15d, %r14d
movq %r15, -0x38(%rbp)
testl %r15d, %r15d
jle 0x4f0d
movl $0x2, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2200
decl %r14d
jne 0x4ef8
cmpb $0x0, 0xc0(%r13)
leaq 0x1708(%rip), %rsi      # 0x6624
leaq 0x16f9(%rip), %rax      # 0x661c
cmovneq %rax, %rsi
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2200
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2140
movq %r13, -0x48(%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 -0x48(%rbp), %r13
callq 0x2030
movq %rax, %rdi
callq 0x2120
movq 0xb8(%r13), %rax
testq %rax, %rax
je 0x5034
movq -0x38(%rbp), %rax
incl %eax
movl %eax, -0x3c(%rbp)
leaq 0x38(%r13), %r14
xorl %r15d, %r15d
cmpb $0x0, 0xc0(%r13)
jne 0x4fab
movq 0x8(%r13,%r15,8), %rdi
movq %rbx, %rsi
movl -0x3c(%rbp), %edx
callq 0x4ebe
movq -0x38(%rbp), %rax
movl %eax, %r13d
testl %eax, %eax
jle 0x4fcb
movl $0x2, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2200
decl %r13d
jne 0x4fb6
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 -0x48(%rbp), %r13
movq 0xb8(%r13), %rax
cmpq %rax, %r15
jb 0x4f91
cmpb $0x0, 0xc0(%r13)
movq -0x50(%rbp), %rcx
jne 0x5065
movq 0x8(%r13,%rax,8), %r13
movq -0x38(%rbp), %r15
incl %r15d
testb $0x1, -0x30(%rbp)
cmoveq %rbx, %rcx
movq %rcx, -0x50(%rbp)
movb $0x1, %al
movq %rax, -0x30(%rbp)
jmp 0x4eec
testb $0x1, -0x30(%rbp)
cmovneq %rcx, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7a2b(%rip), %rcx      # 0xa298
cmpl %edi, (%rcx,%rax,4)
jne 0x2878
incl 0x7a3c(%rip)            # 0xa2b4
cmpl %r14d, %edx
jge 0x28cb
cmpl %r15d, (%rcx,%rax,4)
je 0x28cb
movq %rdx, -0x30(%rbp)
movl %r15d, (%rcx,%rax,4)
movq 0x793e(%rip), %rcx      # 0xa1d0
leaq (%rax,%rax,2), %rax
movq (%rcx,%rax,8), %r13
movq 0x8(%rcx,%rax,8), %rbx
cmpq %rbx, %r13
je 0x28c7
movq -0x30(%rbp), %rax
leal 0x1(%rax), %r12d
movl (%r13), %esi
movl %r15d, %edi
movl %r12d, %edx
movl %r14d, %ecx
callq 0x284f
addq $0x4, %r13
cmpq %rbx, %r13
jne 0x28ac
movq -0x30(%rbp), %rdx
cmpl %edx, 0x79e7(%rip)      # 0xa2b8
jge 0x28d9
movl %edx, 0x79df(%rip)      # 0xa2b8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3bba
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3bb4
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x3ba1
movq (%rbx), %r15
movq 0x8(%rbx), %r12
cmpq %r12, %r15
je 0x3be9
movq (%r15), %r14
testq %r14, %r14
je 0x3be3
movq %r14, %rdi
callq 0x3220
movl $0x18, %esi
movq %r14, %rdi
callq 0x31b0
addq $0x8, %r15
jmp 0x3bc1
leaq 0x30(%rbx), %rdi
callq 0x31e0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3c07
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x31b0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3c26
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_O1/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 0x3c85
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
addq $0x8, %r15
jmp 0x3c6e
callq 0x31f0
subq %r14, %rax
movq %rax, 0xb0(%rbx)
movq 0xb8(%rbx), %rcx
subq %rax, %rcx
jle 0x3ce8
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 0x3ce8
callq 0x3050
cmpl $0x4, (%rax)
je 0x3cce
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rsp)
movq 0x40(%rdi), %rax
cmpq %rax, 0x60(%rdi)
je 0x3da2
leaq 0x30(%rbx), %r15
movl (%rax), %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %r12
testq %r12, %r12
je 0x3d8d
movq %r12, %rdi
callq 0x3220
movl $0x18, %esi
movq %r12, %rdi
callq 0x31b0
movq (%rsp), %rax
movq (%rbx), %rcx
movq %rax, (%rcx,%r14,8)
movq %r15, %rdi
callq 0x32b0
jmp 0x3dd2
movq 0x8(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0x3db6
movq %rsi, (%rax)
addq $0x8, 0x8(%rbx)
jmp 0x3dc4
movq %rsp, %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3030
movq 0x8(%rbx), %r14
subq (%rbx), %r14
shrq $0x3, %r14
decl %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gulshan216[P]Perceptron_Based_Reuse_Prediction/cache.cc
// Function: lg2(int)
int lg2 (int n) {
	int i, m = n, c = -1;
	for (i=0; m; i++) {
		m /= 2;
		c++;
	}
	assert (n == 1<<c);
	return c;
}

// Assembly:
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testl %edi, %edi
je 0x404a50
movl %edi, %edx
movl %edi, %eax
shrl $0x1f, %eax
addl %edx, %eax
sarl %eax
incl %ecx
incl %edx
cmpl $0x2, %edx
movl %eax, %edx
ja 0x404a3e
movl $0x1, %eax
shll %cl, %eax
cmpl %edi, %eax
jne 0x404a5e
movl %ecx, %eax
retq
pushq %rax
leaq 0x1845be(%rip), %rdi    # 0x589024
leaq 0x1845c1(%rip), %rsi    # 0x58902e
leaq 0x1845c3(%rip), %rcx    # 0x589037
movl $0x1f, %edx
callq 0x4cc560
// File: /workspace/github_cpp_makefile_star2_O1/gulshan216[P]Perceptron_Based_Reuse_Prediction/cache.cc
// Function: init_cache(cache*, int, int, int, int, int)
void init_cache (cache *c, int nsets, int assoc, int blocksize, int replacement_policy, int set_shift) {
	int i, j;
	c->sets = new set[nsets];
	c->replacement_policy = replacement_policy;
	c->repl = new CACHE_REPLACEMENT_STATE (nsets, assoc, replacement_policy);
	c->set_shift = set_shift;
	c->nsets = nsets;
	c->assoc = assoc;
	c->blocksize = blocksize;
	c->offset_bits = lg2 (blocksize);
	c->index_bits = lg2 (nsets);
	c->tagshiftbits = c->offset_bits + c->index_bits;
	c->index_mask = nsets - 1;
	c->misses = 0;
	c->accesses = 0;
	memset (c->counts, 0, sizeof (c->counts));
	for (i=0; i<nsets; i++) {
		for (j=0; j<assoc; j++) {
			block *b = &c->sets[i].blocks[j];
			b->tag = 0;
			b->valid = 0;
			b->dirty = 0;
		}
		c->sets[i].valid = 0;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movl %r8d, %r13d
movl %ecx, %ebp
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
movslq %esi, %r12
movl $0x288, %ecx            # imm = 0x288
movq %r12, %rax
mulq %rcx
movq $-0x1, %rdi
cmovnoq %rax, %rdi
callq 0x417c10
testl %r12d, %r12d
je 0x404b1e
imulq $0x288, %r12, %rdx      # imm = 0x288
movq %rax, %rcx
addq %rdx, %rcx
movq %rax, %rdx
movl $0x20, %esi
movl $0x0, (%rdx,%rsi)
movw $0x0, -0x10(%rdx,%rsi)
movq $0x0, -0x18(%rdx,%rsi)
addq $0x28, %rsi
cmpq $0x2a0, %rsi            # imm = 0x2A0
jne 0x404ad3
movb $0x0, 0x280(%rdx)
movq %rdx, %rsi
xorl %edi, %edi
movl %edi, (%rsi)
incq %rdi
addq $0x28, %rsi
cmpq $0x10, %rdi
jne 0x404b03
addq $0x288, %rdx            # imm = 0x288
cmpq %rcx, %rdx
jne 0x404ace
movq %rax, 0x38(%r14)
movl %r13d, 0x18(%r14)
movl $0x20, %edi
callq 0x417bd0
movq %rax, %r12
movq %rax, %rdi
movl %r15d, %esi
movl %ebx, %edx
movl %r13d, %ecx
callq 0x405d1c
movq %r12, 0x80(%r14)
movl 0x4(%rsp), %eax
movl %eax, 0xc(%r14)
movl %r15d, (%r14)
movl %ebx, 0x4(%r14)
movl %ebp, 0x8(%r14)
movl %ebp, %edi
callq 0x404a31
movl %eax, 0x10(%r14)
movl %r15d, %edi
callq 0x404a31
movl %eax, 0x14(%r14)
addl 0x10(%r14), %eax
movl %eax, 0x1c(%r14)
leal -0x1(%r15), %eax
movl %eax, 0x20(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%r14)
movups %xmm0, 0x50(%r14)
movups %xmm0, 0x60(%r14)
movups %xmm0, 0x70(%r14)
movups %xmm0, 0x28(%r14)
testl %r15d, %r15d
jle 0x404c06
movq 0x38(%r14), %rax
movl %r15d, %ecx
movl %ebx, %edx
shlq $0x3, %rdx
leaq (%rdx,%rdx,4), %rdx
movl $0x11, %esi
xorl %edi, %edi
movl $0x288, %r8d            # imm = 0x288
testl %ebx, %ebx
jle 0x404beb
movq 0x38(%r14), %r9
addq %rsi, %r9
xorl %r10d, %r10d
movq $0x0, -0x9(%r9,%r10)
movw $0x0, -0x1(%r9,%r10)
addq $0x28, %r10
cmpq %r10, %rdx
jne 0x404bd1
imulq $0x288, %rdi, %r9       # imm = 0x288
movb $0x0, 0x280(%rax,%r9)
incq %rdi
addq %r8, %rsi
cmpq %rcx, %rdi
jne 0x404bc3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x20, %esi
movq %r12, %rdi
callq 0x416d30
movq %rbx, %rdi
callq 0x4b7900
// File: /workspace/github_cpp_makefile_star2_O1/gulshan216[P]Perceptron_Based_Reuse_Prediction/cache.cc
// Function: memory_access(cache**, cache**, cache*, unsigned long long, unsigned long long, unsigned int, int, unsigned int)
unsigned int memory_access (cache **L1, cache **L2, cache *L3, unsigned long long int address, unsigned long long int pc, unsigned int size, int op, unsigned int core) {
	// access the memory hierarchy, returning latency of access
	unsigned int miss = 0;
	// unsigned long long int writeback_address;
	if (L3) {
		// L3 shared between everyone
		bool missL3 = cache_access (L3, address, pc, size, op, core, NULL);
		if (missL3) miss |= 4;
	}
	return miss;
}

// Assembly:
testq %rdx, %rdx
je 0x405293
pushq %rax
movl 0x18(%rsp), %r9d
movl 0x10(%rsp), %eax
movq $0x0, (%rsp)
movq %rdx, %rdi
movq %rcx, %rsi
movq %r8, %rdx
movl %eax, %r8d
callq 0x404c9d
movzbl %al, %eax
shll $0x2, %eax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gulshan216[P]Perceptron_Based_Reuse_Prediction/./trace.h
// Function: tracereader::tracereader(char const*, long long)
tracereader (const char *name, long long int _restart_cycles = 1000000000) {
		restart_cycles = _restart_cycles;
		current_cycle = 0;
		current_instr = 0;
		cycles_upto_restart = 0;
		insts_upto_restart = 0;
		icount = 0;
		cyclecount = 0;
		strcpy (filename, name);
		open (filename);
		printf ("opened \"%s\"\n", filename);
		fflush (stdout);
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdx, 0x448(%rdi)
leaq 0x60(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movq %r14, %rdi
callq 0x401078
movq %rbx, %rdi
movq %r14, %rsi
callq 0x405c8e
leaq 0x183de0(%rip), %rdi    # 0x5898e1
movq %r14, %rsi
xorl %eax, %eax
callq 0x4de520
movq $0x5fb510, %rax         # imm = 0x5FB510
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4ed080
nop
// File: /workspace/github_cpp_makefile_star2_O1/gulshan216[P]Perceptron_Based_Reuse_Prediction/./trace.h
// Function: tracereader::read()
trace *read (void) {
	startover:
		unsigned int a = gzfread (&t, sizeof (t), 1, tracefp);
		if (a == 0) {
			// printf ("restarting before %lld cycles!\n", restart_cycles);
			restart_cycles = current_cycle;
			restart ();
			goto startover;
		}
#if 0
		// this code was used to generate truncated traces
		{
			static FILE *f = NULL;
			if (!f) {
				f = fopen ("/tmp/foo", "w");
			}
			fwrite (&t, 1, sizeof (t), f);
			if (t.instr > 1000000000) {
				fprintf (stderr, "stopping at %lld\n", t.instr);
				fclose (f);
				exit (0);
			}
		}
#endif

		// heartbeat

		if (t.cycle >= (unsigned long long int) restart_cycles) {
			restart ();
			goto startover;
		}
		// this is stupid but we have to translate from CMP$im to DAN_* and back
		int cmd = t.cmd;
		switch (cmd) {
			case ACCESS_IFETCH: t.cmd = DAN_IREAD; break;
			case ACCESS_LOAD: t.cmd = DAN_DREAD; break;
			case ACCESS_STORE: t.cmd = DAN_WRITE; break;
			case ACCESS_PREFETCH: t.cmd = DAN_PREFETCH; break;
			case ACCESS_WRITEBACK: t.cmd = DAN_WRITEBACK; break;
			default: assert (0);
		}
#if 0
		printf ("cmd=%d; pc=%llx; address=%llx; instr=%llx; cycle=%llx\n",
			t.cmd, t.pc, t.address, t.instr, t.cycle);
#endif
		current_cycle = t.cycle;
		current_instr = t.instr;
		t.cycle += cycles_upto_restart;
		t.instr += insts_upto_restart;
		cyclecount = t.cycle;
		if (t.instr - icount >= 100000000) {
			icount = t.instr;
			printf ("icount = %lld, cycles = %lld\n", icount, cyclecount);
			fflush (stdout);
		}
		return & t;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movl $0x67, %ebp
leaq 0x183e24(%rip), %r12    # 0x589964
leaq 0x183dfe(%rip), %r15    # 0x589945
movq (%r14), %rdi
movq %rbx, %rsi
movl $0x28, %edx
callq 0x407e10
addl $0x27, %eax
cmpl $0x4e, %eax
ja 0x405b6c
movq 0x38(%r14), %rax
movq %rax, 0x448(%r14)
jmp 0x405be7
movq 0x28(%r14), %rdx
cmpq 0x448(%r14), %rdx
jae 0x405be7
movl (%rbx), %eax
cmpq $0x7, %rax
jae 0x405c14
btl %eax, %ebp
jae 0x405c14
movl (%r12,%rax,4), %eax
movl %eax, 0x8(%r14)
movq %rdx, 0x38(%r14)
movq 0x20(%r14), %rsi
movq %rsi, 0x40(%r14)
addq 0x58(%r14), %rdx
movq %rdx, 0x28(%r14)
addq 0x50(%r14), %rsi
movq %rsi, 0x20(%r14)
movq %rdx, 0x48(%r14)
movq %rsi, %rax
subq 0x30(%r14), %rax
cmpq $0x5f5e100, %rax        # imm = 0x5F5E100
jb 0x405bfd
movq %rsi, 0x30(%r14)
xorl %r13d, %r13d
movq %r15, %rdi
xorl %eax, %eax
callq 0x4de520
movq $0x5fb510, %rax         # imm = 0x5FB510
movq (%rax), %rdi
callq 0x4ed080
jmp 0x405bf2
movq %r14, %rdi
callq 0x405ce6
movb $0x1, %r13b
testb %r13b, %r13b
jne 0x405b47
jmp 0x405c02
xorl %r13d, %r13d
jmp 0x405bf2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x183bee(%rip), %rdi    # 0x589809
leaq 0x183cd9(%rip), %rsi    # 0x5898fb
leaq 0x183d01(%rip), %rcx    # 0x58992a
movl $0x64, %edx
callq 0x4cc560
// File: /workspace/github_cpp_makefile_star2_O1/gulshan216[P]Perceptron_Based_Reuse_Prediction/./trace.h
// Function: tracereader::open(char const*)
void open (const char *name) {
		tracefp = gzopen (name, "r");
		if (!tracefp) {
			char hostname[1000];
			gethostname (hostname, 1000);
			fprintf (stderr, "%s: ", hostname);
			perror (name);
			fflush (stderr);
		}
		assert (tracefp);
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18bed0(%rip), %rsi    # 0x591b6f
movq %r14, %rdi
callq 0x406d90
movq %rax, (%rbx)
testq %rax, %rax
je 0x405cbd
cmpq $0x0, (%rbx)
je 0x405cc7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x40144e
jmp 0x405caf
leaq 0x183c25(%rip), %rdi    # 0x5898f3
leaq 0x183c26(%rip), %rsi    # 0x5898fb
leaq 0x183c29(%rip), %rcx    # 0x589905
movl $0x29, %edx
callq 0x4cc560
// File: /workspace/github_cpp_makefile_star2_O1/gulshan216[P]Perceptron_Based_Reuse_Prediction/./trace.h
// Function: tracereader::restart()
void restart (void) {
		insts_upto_restart += current_instr;
		cycles_upto_restart += current_cycle;
		// printf ("restarting \"%s\" at cycle %lld\n", filename, cycles_upto_restart);
		// fflush (stdout);
		if (tracefp) gzclose (tracefp);
		open (filename);
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movdqu 0x38(%rdi), %xmm0
pshufd $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movdqu 0x50(%rdi), %xmm1
paddq %xmm0, %xmm1
movdqu %xmm1, 0x50(%rdi)
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x405d0f
callq 0x406a50
leaq 0x60(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x405c8e
// File: /workspace/github_cpp_makefile_star2_O1/gulshan216[P]Perceptron_Based_Reuse_Prediction/replacement_state.cpp
// Function: CACHE_REPLACEMENT_STATE::InitReplacementState()
void CACHE_REPLACEMENT_STATE::InitReplacementState()
{
    // Create the state for sets, then create the state for the ways

    repl  = new LINE_REPLACEMENT_STATE* [ numsets ];

    // ensure that we were able to create replacement state

    assert(repl);

    // Create the state for the sets
    for(UINT32 setIndex=0; setIndex<numsets; setIndex++) 
    {
        repl[ setIndex ]  = new LINE_REPLACEMENT_STATE[ assoc ];

        for(UINT32 way=0; way<assoc; way++) 
        {
            // initialize stack position (for true LRU)
            repl[ setIndex ][ way ].LRUstackposition = way;
        }
    }

    if (replPolicy != CRC_REPL_CONTESTANT) return;

    // Contestants:  ADD INITIALIZATION FOR YOUR HARDWARE HERE
    init_sampler_cache(&sampler, SAMPLER_SETS, SAMPLER_ASSOC, 64, CRC_REPL_LRU);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x8(%rdi), %r15d
leaq (,%r15,8), %rdi
callq 0x417c10
movq %rax, (%rbx)
testq %r15, %r15
je 0x405e38
movl 0xc(%rbx), %r12d
leaq (,%r12,8), %r14
leaq 0x1(%r12), %r13
andq $-0x2, %r13
movq %r12, %rax
decq %rax
movq %rax, %xmm0
pshufd $0x44, %xmm0, %xmm4     # xmm4 = xmm0[0,1,0,1]
xorl %ebp, %ebp
movdqa 0x183c01(%rip), %xmm0   # 0x589990
pxor %xmm0, %xmm4
movdqa %xmm4, (%rsp)
movq %r14, %rdi
callq 0x417c10
movdqa 0x183bf8(%rip), %xmm7   # 0x5899a0
pcmpeqd %xmm6, %xmm6
movdqa 0x183bdc(%rip), %xmm5   # 0x589990
movdqa (%rsp), %xmm4
movq (%rbx), %rcx
movq %rax, (%rcx,%rbp,8)
testl %r12d, %r12d
je 0x405e2c
movq (%rbx), %rax
movq (%rax,%rbp,8), %rax
xorl %ecx, %ecx
movdqa 0x183baa(%rip), %xmm0   # 0x589980
movdqa %xmm0, %xmm1
pxor %xmm5, %xmm1
movdqa %xmm1, %xmm2
pcmpgtd %xmm4, %xmm2
pcmpeqd %xmm4, %xmm1
pshufd $0xf5, %xmm1, %xmm3     # xmm3 = xmm1[1,1,3,3]
pand %xmm2, %xmm3
pshufd $0xf5, %xmm2, %xmm1     # xmm1 = xmm2[1,1,3,3]
por %xmm3, %xmm1
movd %xmm1, %edx
notl %edx
testb $0x1, %dl
je 0x405e0a
movl %ecx, (%rax,%rcx,8)
pxor %xmm6, %xmm1
pextrw $0x4, %xmm1, %edx
testb $0x1, %dl
je 0x405e1f
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rax,%rcx,8)
addq $0x2, %rcx
paddq %xmm7, %xmm0
cmpq %rcx, %r13
jne 0x405dd6
incq %rbp
cmpq %r15, %rbp
jne 0x405d98
cmpl $0x2, 0x10(%rbx)
jne 0x405e6a
leaq 0x1fa6e3(%rip), %rdi    # 0x600528
movl $0x100, %esi            # imm = 0x100
movl $0x10, %edx
movl $0x40, %ecx
xorl %r8d, %r8d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x405f89
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop