LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/roornelas[P]small-world/./graph.hpp
// Function: Graph::set_p(int)
void set_p(int p) {
		for (int i = 0; i < side_length; i++) {
			for (int j = 0; j < side_length; j++) {
				for (int k = -p; k <= p; k++) {
					for (int l = -p; l <= p; l++) {
						if (abs(k) + abs(l) <= p && i + k >= 0 && i + k < side_length && j + l >= 0 && j + l < side_length && (k != 0 || l != 0)) {
							add_edge(make_pair(make_pair(i, j), make_pair(i + k, j + l)));
						}
					}
				}
			}
		}
	}

// Assembly:
cmpl $0x0, (%rdi)
jle 0x2fe8
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %r13d
movl %esi, %eax
negl %eax
movl %eax, 0x4(%rsp)
leal 0x1(,%r13,2), %eax
movl %eax, 0x14(%rsp)
movq $0x0, 0x8(%rsp)
movq %rdi, 0x18(%rsp)
cmpl $0x0, (%rdi)
jle 0x2fc1
movq 0x8(%rsp), %rax
leaq (%rax,%rax,2), %rax
movq %rax, 0x20(%rsp)
xorl %ebx, %ebx
testl %r13d, %r13d
js 0x2fb2
movl 0x4(%rsp), %eax
movl %eax, %edx
movl %edx, %r15d
negl %r15d
cmovsl %edx, %r15d
movq 0x8(%rsp), %rax
leal (%rdx,%rax), %r12d
movl 0x14(%rsp), %ebp
movl 0x4(%rsp), %r14d
movq %rdx, 0x28(%rsp)
movl %r14d, %eax
negl %eax
cmovsl %r14d, %eax
addl %r15d, %eax
cmpl %r13d, %eax
jg 0x2f9d
testl %r12d, %r12d
js 0x2f9d
movl (%rdi), %ecx
cmpl %ecx, %r12d
jge 0x2f9d
movl %r14d, %eax
orl %edx, %eax
je 0x2f9d
movl %ebx, %eax
addl %r14d, %eax
js 0x2f9d
cmpl %ecx, %eax
jge 0x2f9d
shlq $0x20, %rax
orq %r12, %rax
movq 0x8(%rdi), %rcx
movq 0x20(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rcx,%rbx,8), %rdi
movq %rax, 0x30(%rsp)
addq $0x8, %rdi
leaq 0x30(%rsp), %rsi
callq 0x3a48
movq 0x28(%rsp), %rdx
movq 0x18(%rsp), %rdi
incl %r14d
decl %ebp
jne 0x2f39
leal 0x1(%rdx), %eax
cmpl %r13d, %edx
movl %eax, %edx
jne 0x2f18
incq %rbx
movslq (%rdi), %rax
cmpq %rax, %rbx
jl 0x2f09
movq 0x8(%rsp), %rdx
incq %rdx
movslq (%rdi), %rax
movq %rdx, 0x8(%rsp)
cmpq %rax, %rdx
jl 0x2ef0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/roornelas[P]small-world/./graph.hpp
// Function: Graph::set_q_r(int, int)
void set_q_r(int q, int r) {
		srand(time(NULL));
		for (int i = 0; i < side_length; i++) {
			for (int j = 0; j < side_length; j++) {
				add_long_edges(make_pair(i, j), q, r);
			}
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
xorl %edi, %edi
callq 0x2130
movl %eax, %edi
callq 0x2140
cmpl $0x0, (%r14)
jle 0x305f
movq $0x0, (%rsp)
movabsq $0x100000000, %r13      # imm = 0x100000000
cmpl $0x0, (%r14)
jle 0x304c
movq (%rsp), %r15
xorl %r12d, %r12d
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x3b9c
incq %r12
movslq (%r14), %rax
addq %r13, %r15
cmpq %rax, %r12
jl 0x302f
movq (%rsp), %rdx
incq %rdx
movslq (%r14), %rax
movq %rdx, (%rsp)
cmpq %rax, %rdx
jl 0x3022
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/roornelas[P]small-world/./graph.hpp
// Function: Graph::~Graph()
~Graph() {
		for (int i = 0; i < side_length; i++) {
			for (int j = 0; j < side_length; j++) {
				if (matrix[i][j]) {
					delete(matrix[i][j]);
				}
			}
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x30cb
xorl %r15d, %r15d
cmpl $0x0, (%rbx)
jle 0x30c0
leaq (%r15,%r15,2), %r12
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rax
movq (%rax,%r13,8), %r14
testq %r14, %r14
je 0x30b5
leaq 0x8(%r14), %rdi
callq 0x3f84
movl $0x38, %esi
movq %r14, %rdi
callq 0x2160
incq %r13
movslq (%rbx), %rax
cmpq %rax, %r13
jl 0x308e
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0x3082
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3328
// File: /workspace/github_cpp_makefile_star2_O1/liujan[P]MPI_multi_thread_randomforest/Node.cpp
// Function: Node::Node()
Node::Node(){
	left = NULL;
	right = NULL;
	sum = 0;
	memset(num, 0, sizeof(num));
	attribute = 0;
	value = 0;
	depth = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, (%rdi)
addq $0x8, %rdi
movl $0xa0, %edx
xorl %esi, %esi
popq %rbp
jmp 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O1/liujan[P]MPI_multi_thread_randomforest/Node.cpp
// Function: Node::Node(Node const&)
Node::Node(const Node &other){
	this->attribute = other.attribute;
	this->value = other.value;
	this->left = other.left;
	this->right = other.right;
	this->sum = other.sum;
	this->samples = other.samples;
	this->depth = other.depth;
	for (int i = 0; i < numOfTypes; i++)
		this->num[i] = other.num[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x90, %esi
leaq (%rdi,%rsi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rdi)
movq $0x0, 0xa0(%rdi)
movl (%rbx), %eax
movl %eax, (%rdi)
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rdi)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rdi)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%rdi)
movl 0x20(%rbx), %eax
movl %eax, 0x20(%rdi)
addq %rbx, %rsi
movq %r15, %rdi
callq 0x2694
movl 0x8c(%rbx), %eax
movl %eax, 0x8c(%r14)
xorl %eax, %eax
movl 0x24(%rbx,%rax,4), %ecx
movl %ecx, 0x24(%r14,%rax,4)
incq %rax
cmpq $0x1a, %rax
jne 0x2664
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x282a
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O1/liujan[P]MPI_multi_thread_randomforest/Tree.cpp
// Function: Tree::readSample(std::vector<std::pair<int, std::vector<double, std::allocator<double>>>, std::allocator<std::pair<int, std::vector<double, std::allocator<double>>>>>)
bool Tree::readSample(vector<pair<int, vector<double> > > all_samples){
	if (all_samples.empty()){
		cout << "[Error] all sample is empty!" << endl;
		return false;
	}

	if (root == NULL)
		root = new Node();

	double p = 0.0;
	for (int i = 0; i < all_samples.size(); i++){
		p = rand() * 1.0 / RAND_MAX;
		if (p <= 0.6) {  //ÿ��������������60%��ѵ��
			root->samples.push_back(all_samples[i]);
			int type = all_samples[i].first;
			root->num[type - 1]++;
		}
	}
	root->sum = root->samples.size();

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rsi), %r12
movq 0x8(%rsi), %r13
cmpq %r13, %r12
je 0x2d04
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, (%rdi)
jne 0x2c6d
movl $0xa8, %edi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
callq 0x25dc
movq %r15, (%rbx)
movq %r13, -0x30(%rbp)
movq %r12, -0x38(%rbp)
movq 0x8(%r14), %rax
cmpq (%r14), %rax
je 0x2ce2
xorl %r15d, %r15d
movl $0x90, %r12d
xorl %r13d, %r13d
callq 0x2090
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x436a(%rip), %xmm0     # 0x7008
movsd 0x436a(%rip), %xmm1     # 0x7010
ucomisd %xmm0, %xmm1
jb 0x2ccb
movq (%rbx), %rdi
addq %r12, %rdi
movq (%r14), %rsi
addq %r15, %rsi
callq 0x3a2c
movq (%r14), %rax
movslq (%rax,%r15), %rax
movq (%rbx), %rcx
incl 0x20(%rcx,%rax,4)
movq 0x8(%r14), %rax
subq (%r14), %rax
incq %r13
sarq $0x5, %rax
addq $0x20, %r15
cmpq %r13, %rax
ja 0x2c8a
movq (%rbx), %rax
movq 0x98(%rax), %rcx
subq 0x90(%rax), %rcx
shrq $0x5, %rcx
movl %ecx, 0x20(%rax)
movq -0x38(%rbp), %r12
movq -0x30(%rbp), %r13
jmp 0x2d46
movq 0x72c5(%rip), %rbx      # 0x9fd0
leaq 0x434e(%rip), %rsi      # 0x7060
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x2240
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2150
cmpq %r13, %r12
setne %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0xa8, %esi
movq %r15, %rdi
callq 0x2200
movq %rbx, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O1/liujan[P]MPI_multi_thread_randomforest/Tree.cpp
// Function: getType(Node*)
int getType(Node *node){
	if (node == NULL)
		return 0;
	int max_value = -1000, index = 0;
	for (int i = 0; i < numOfTypes; i++){
		if (max_value <= node->num[i]){
			max_value = node->num[i];
			index = i + 1;
		}
	}
	return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x36d0
movl $0xfffffc18, %ecx       # imm = 0xFFFFFC18
xorl %edx, %edx
xorl %eax, %eax
movl 0x24(%rdi,%rdx,4), %esi
incq %rdx
cmpl %esi, %ecx
cmovlel %esi, %ecx
cmovlel %edx, %eax
cmpq $0x1a, %rdx
jne 0x36b9
jmp 0x36d2
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/liujan[P]MPI_multi_thread_randomforest/Tree.cpp
// Function: Tree::predict(std::vector<double, std::allocator<double>>)
int Tree::predict(vector<double> features){
	if (root == NULL){
		cout << "[Error] empty tree" << endl;
		return 0;
	}
	Node *head = root;
	while (true) {
		if (head->left == NULL && head->right == NULL){
			return getType(head);
		}
		int attr = head->attribute;
		double value = head->value;
		if (features[attr] < value){
			if (head->left == NULL)
				return getType(head);
			else
				head = head->left;
		}
		else {
			if (head->right == NULL)
				return getType(head);
			else
				head = head->right;
		}
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x3786
movq 0x10(%rcx), %rdx
testq %rdx, %rdx
jne 0x36fa
cmpq $0x0, 0x18(%rcx)
je 0x37cc
movslq (%rcx), %rdi
movsd 0x8(%rcx), %xmm0
movq (%rsi), %r8
ucomisd (%r8,%rdi,8), %xmm0
jbe 0x373f
movb $0x1, %dil
testq %rdx, %rdx
jne 0x3778
movl $0xfffffc18, %edx       # imm = 0xFFFFFC18
xorl %eax, %eax
movl $0x9, %edi
movl (%rcx,%rdi,4), %r8d
leal -0x8(%rdi), %r9d
cmpl %r8d, %edx
cmovlel %r8d, %edx
cmovlel %r9d, %eax
incq %rdi
cmpq $0x23, %rdi
jne 0x3721
jmp 0x3773
movq 0x18(%rcx), %rdx
movb $0x1, %dil
testq %rdx, %rdx
jne 0x3778
movl $0xfffffc18, %edx       # imm = 0xFFFFFC18
xorl %eax, %eax
movl $0x9, %edi
movl (%rcx,%rdi,4), %r8d
leal -0x8(%rdi), %r9d
cmpl %r8d, %edx
cmovlel %r8d, %edx
cmovlel %r9d, %eax
incq %rdi
cmpq $0x23, %rdi
jne 0x3757
xorl %edi, %edi
movq %rcx, %rdx
movq %rdx, %rcx
testb %dil, %dil
jne 0x36e6
jmp 0x37ea
movq 0x6843(%rip), %rbx      # 0x9fd0
leaq 0x3913(%rip), %rsi      # 0x70a7
movl $0x12, %edx
movq %rbx, %rdi
callq 0x2240
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2150
xorl %eax, %eax
jmp 0x37ea
movl $0xfffffc18, %edx       # imm = 0xFFFFFC18
xorl %esi, %esi
xorl %eax, %eax
movl 0x24(%rcx,%rsi,4), %edi
incq %rsi
cmpl %edi, %edx
cmovlel %edi, %edx
cmovlel %esi, %eax
cmpq $0x1a, %rsi
jne 0x37d5
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/liujan[P]MPI_multi_thread_randomforest/Tree.cpp
// Function: Tree::randomSelect()
vector<int> Tree::randomSelect(){
	vector<int> v;
	for (int i = 0; i < numOfFeatures; i++){
		double p = rand() * 1.0 / RAND_MAX;
		if (p <= 0.05)
			v.push_back(i);
	}
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq -0x14(%rbp), %r14
movl $0x0, (%r14)
callq 0x2090
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x37d9(%rip), %xmm0     # 0x7008
movsd 0x3801(%rip), %xmm1     # 0x7038
ucomisd %xmm0, %xmm1
jb 0x3861
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3856
movl -0x14(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x3861
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4d10
movl -0x14(%rbp), %eax
leal 0x1(%rax), %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x268, %eax            # imm = 0x268
jl 0x381b
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3894
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2200
movq %r14, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O1/liujan[P]MPI_multi_thread_randomforest/Tree.cpp
// Function: Tree::~Tree()
Tree::~Tree(){
	Node *head = root;
	queue<Node*>q;
	q.push(head);
	while (!q.empty()){
		head = q.front();
		q.pop();
		if (head == NULL)
			continue;
		Node *left = head->left;
		Node *right = head->right;
		delete head;
		q.push(left);
		q.push(right);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq (%rdi), %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
leaq -0x90(%rbp), %rdi
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
xorl %esi, %esi
callq 0x4048
movq -0x60(%rbp), %rax
movq -0x50(%rbp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x38f5
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
addq $0x8, -0x60(%rbp)
jmp 0x3905
leaq -0x90(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x41d0
movq -0x80(%rbp), %rax
cmpq %rax, -0x60(%rbp)
je 0x3a08
leaq -0x90(%rbp), %rbx
leaq -0x38(%rbp), %r14
leaq -0x30(%rbp), %r15
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq -0x70(%rbp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x393c
addq $0x8, %rax
jmp 0x3969
movq -0x78(%rbp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x2200
movq -0x68(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x68(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x78(%rbp)
leaq 0x200(%rax), %rcx
movq %rcx, -0x70(%rbp)
movq %rax, -0x80(%rbp)
movq -0x28(%rbp), %r12
testq %r12, %r12
je 0x39fa
movq 0x10(%r12), %rax
movq %rax, -0x38(%rbp)
movq 0x18(%r12), %rax
movq %rax, -0x30(%rbp)
leaq 0x90(%r12), %rdi
callq 0x282a
movl $0xa8, %esi
movq %r12, %rdi
callq 0x2200
movq -0x60(%rbp), %rax
movq -0x50(%rbp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x39c5
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
addq $0x8, -0x60(%rbp)
jmp 0x39d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x41d0
movq -0x60(%rbp), %rax
movq -0x50(%rbp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x39ef
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
addq $0x8, -0x60(%rbp)
jmp 0x39fa
movq %rbx, %rdi
movq %r15, %rsi
callq 0x41d0
movq -0x80(%rbp), %rax
cmpq %rax, -0x60(%rbp)
jne 0x3922
leaq -0x90(%rbp), %rdi
callq 0x3c74
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a23
movq %rax, %rdi
callq 0x2887
nop
// File: /workspace/github_cpp_makefile_star2_O1/liujan[P]MPI_multi_thread_randomforest/RandomForest.cpp
// Function: build(void*)
void* build(void *arg){
	M t1 = (M)(*((M*)arg));
	RandomForest *rf = t1.rf;
	int t = t1.i;
	if (rf->test_samples.empty()){
		cout << "[Error] test sample is empty" << endl;
		return NULL;
	}

	Tree *tree = new Tree();
	if (tree->readSample(rf->all_samples)){
		cout << t  << "  ";
		tree->buildTree();
		for (int j = 0; j < rf->test_samples.size(); j++){
			int id = rf->test_samples[j].first;
			int type = tree->predict(rf->test_samples[j].second);
			result[t][id][type]++;
		}
	}
	delete tree;
	
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq (%rdi), %r14
movq 0x18(%r14), %rax
cmpq 0x20(%r14), %rax
je 0x4fc6
movslq 0x8(%rdi), %r15
movl $0x8, %edi
callq 0x21f0
movq %rax, %rbx
movq %rax, %rdi
callq 0x2be8
leaq -0x68(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3a74
movq %rbx, -0x30(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2c28
movl %eax, %r12d
leaq -0x68(%rbp), %rdi
callq 0x282a
testb %r12b, %r12b
je 0x4fab
movq 0x50d2(%rip), %rdi      # 0x9fd0
movl %r15d, %esi
callq 0x2340
leaq 0x2230(%rip), %rsi      # 0x713d
movl $0x2, %edx
movq %rax, %rdi
callq 0x2240
movq -0x30(%rbp), %rdi
callq 0x2d74
movq 0x18(%r14), %rsi
cmpq %rsi, 0x20(%r14)
je 0x4fab
movl $0x8, %r13d
xorl %ebx, %ebx
imulq $0x291b4, %r15, %rax    # imm = 0x291B4
leaq 0x52cd(%rip), %rcx      # 0xa210
addq %rax, %rcx
movq %rcx, -0x38(%rbp)
movslq -0x8(%rsi,%r13), %r12
addq %r13, %rsi
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x29e8
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x36d4
movl %eax, %r15d
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x4f82
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x2200
movslq %r15d, %rax
imulq $0x6c, %r12, %rcx
addq -0x38(%rbp), %rcx
incl (%rcx,%rax,4)
incq %rbx
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rax
subq %rsi, %rax
sarq $0x5, %rax
addq $0x20, %r13
cmpq %rbx, %rax
ja 0x4f4a
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x389c
movl $0x8, %esi
movq %rbx, %rdi
callq 0x2200
jmp 0x5008
movq 0x5003(%rip), %rbx      # 0x9fd0
leaq 0x214c(%rip), %rsi      # 0x7120
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x2240
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2150
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x282a
jmp 0x504c
movq %rax, %r14
movl $0x8, %esi
movq %rbx, %rdi
jmp 0x5047
movq %rax, %r14
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x504c
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x2200
movq %r14, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O1/liujan[P]MPI_multi_thread_randomforest/RandomForest.cpp
// Function: RandomForest::predict()
int** RandomForest::predict(){
	if (this->test_samples.empty()){
		cout << "[Error] test sample is empty" << endl;
		return NULL;
	}
	if (r == NULL){
		cout << "r is NULL" << endl;
		return NULL;
	}
	
	return r;
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rax
cmpq 0x20(%rdi), %rax
je 0x5252
movq 0x30(%rdi), %rax
testq %rax, %rax
jne 0x529a
movq 0x4d8c(%rip), %rdi      # 0x9fd0
leaq 0x1f11(%rip), %rsi      # 0x715c
movl $0x9, %edx
jmp 0x5265
movq 0x4d77(%rip), %rdi      # 0x9fd0
leaq 0x1ec0(%rip), %rsi      # 0x7120
movl $0x1c, %edx
callq 0x2240
movq 0x4d5f(%rip), %rbx      # 0x9fd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2150
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Baobaobear[P]sort/demo.cpp
// Function: main
int main(void)
{
    typedef int sort_t;
    const size_t count = 1000;
    std::vector<sort_t> arr;

    for (size_t i = 0; i < count; i++)
    {
        arr.push_back(i);
    }

    baobao::random_shuffle(arr.begin(), arr.end());
    baobao::sort::insert_sort(arr.begin(), arr.end());
    print_check_sorted(arr.begin(), arr.end());

    baobao::random_shuffle(arr.begin(), arr.end());
    baobao::sort::heap_sort(arr.begin(), arr.end());
    print_check_sorted(arr.begin(), arr.end());

    baobao::random_shuffle(arr.begin(), arr.end());
    baobao::sort::shell_sort(arr.begin(), arr.end());
    print_check_sorted(arr.begin(), arr.end());

    baobao::random_shuffle(arr.begin(), arr.end());
    baobao::sort::quick_sort(arr.begin(), arr.end());
    print_check_sorted(arr.begin(), arr.end());

    baobao::random_shuffle(arr.begin(), arr.end());
    baobao::sort::merge_sort(arr.begin(), arr.end());
    print_check_sorted(arr.begin(), arr.end());

    baobao::random_shuffle(arr.begin(), arr.end());
    baobao::sort::tim_sort(arr.begin(), arr.end());
    print_check_sorted(arr.begin(), arr.end());

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
xorl %r15d, %r15d
leaq 0x1c(%rsp), %r14
movl %r15d, 0x1c(%rsp)
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x1725
movl %r15d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x1730
movq %rbx, %rdi
movq %r14, %rdx
callq 0xe8b4
incq %r15
cmpq $0x3e8, %r15            # imm = 0x3E8
jne 0x1706
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1a62
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xe9eb
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1aa7
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1a62
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xea41
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1aa7
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1a62
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xeb3a
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1aa7
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1a62
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rsi, %rax
subq %rdi, %rax
cmpq $0x5, %rax
jl 0x17e2
callq 0xedc9
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1aa7
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1a62
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1a1
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1aa7
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1a62
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rsi, %rdx
subq %rdi, %rdx
sarq $0x2, %rdx
callq 0xf425
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1aa7
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x185c
callq 0x1110
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x186a
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x187b
callq 0x1110
movq %rbx, %rdi
callq 0x11a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Baobaobear[P]sort/demo.cpp
// Function: void print_check_sorted<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>)
void print_check_sorted(RandomAccessIterator beg, RandomAccessIterator end)
{
    if (check_sorted(beg, end, std::less<typename std::iterator_traits<RandomAccessIterator>::value_type>()))
    {
        printf("OK\n");
    }
    else
    {
        printf("wrong\n");
    }
}

// Assembly:
movq %rdi, %rax
addq $0x4, %rax
leaq 0xf6bc(%rip), %rdi      # 0x11171
cmpq %rsi, %rax
je 0x1170
movq %rax, %rcx
movl (%rax), %edx
addq $0x4, %rax
cmpl -0x4(%rcx), %edx
jge 0x1ab5
cmpq %rsi, %rcx
leaq 0xf69b(%rip), %rax      # 0x11171
leaq 0xf68e(%rip), %rdi      # 0x1116b
cmoveq %rax, %rdi
jmp 0x1170
// File: /workspace/github_cpp_makefile_star2_O1/AgathokakologicalBit[P]wit/src/main.cpp
// Function: (anonymous namespace)::draw_p(unsigned int, unsigned long)
void draw_p(std::uint32_t depth, std::uint64_t mask)
  {
    if (depth == ~(static_cast<std::uint32_t>(0)))
      return;

    std::wcout << L"\x1b[32m";
    for (std::uint32_t i = 0; i < depth; ++i)
    {
      if (mask & (static_cast<std::uint64_t>(1) << i))
        std::cout << "\x20\x20\x20";
      else
        std::cout << "\u2502\x20\x20";
    }

    if (mask & (static_cast<std::uint64_t>(1) << depth))
      std::cout << "\u2514\u2500 ";
    else
      std::cout << "\u251C\u2500 ";

    std::wcout << L"\x1b[37m";
  }

// Assembly:
cmpl $-0x1, %edi
je 0x4df8
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
movq 0x18276(%rip), %rdi     # 0x1cfc8
leaq 0x10557(%rip), %rsi     # 0x152b0
movl $0x5, %edx
callq 0x30f0
testl %r14d, %r14d
je 0x4dab
movl %r14d, %ebp
xorl %r12d, %r12d
movq 0x1824b(%rip), %r15     # 0x1cfc0
leaq 0x1034f(%rip), %r13     # 0x150cb
btq %r12, %rbx
jae 0x4d8f
movl $0x3, %edx
movq %r15, %rdi
movq %r13, %rsi
jmp 0x4d9e
movl $0x5, %edx
movq %r15, %rdi
leaq 0x10331(%rip), %rsi     # 0x150cf
callq 0x3240
incq %r12
cmpq %r12, %rbp
jne 0x4d7c
btq %r14, %rbx
leaq 0x10327(%rip), %rax     # 0x150dd
leaq 0x10318(%rip), %rsi     # 0x150d5
cmovaeq %rax, %rsi
movq 0x181f8(%rip), %rdi     # 0x1cfc0
movl $0x7, %edx
callq 0x3240
movq 0x181ef(%rip), %rdi     # 0x1cfc8
leaq 0x104e8(%rip), %rsi     # 0x152c8
movl $0x5, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x30f0
retq
// File: /workspace/github_cpp_makefile_star2_O1/AgathokakologicalBit[P]wit/src/parsing/../node.hpp
// Function: akbit::system::etype_to_str[abi:cxx11](akbit::system::Node::etype_t)
inline std::string etype_to_str(Node::etype_t t)
  {
    switch (t)
    {
      case Node::etype_t::unknown: return "unknown";
      case Node::etype_t::string: return "string";
      case Node::etype_t::character: return "character";
      case Node::etype_t::integer: return "integer";
      case Node::etype_t::decimal: return "decimal";

      case Node::etype_t::function: return "function";
      case Node::etype_t::tuple: return "tuple";

      case Node::etype_t::any: return "any";
    } 
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movl %esi, %eax
leaq 0xe50c(%rip), %rcx      # 0x15004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xe759(%rip), %rsi      # 0x15261
leaq 0xe759(%rip), %rdx      # 0x15268
jmp 0x6b7f
leaq 0xe92a(%rip), %rsi      # 0x15442
leaq 0xe92a(%rip), %rdx      # 0x15449
jmp 0x6b7f
leaq 0xe653(%rip), %rsi      # 0x1517b
leaq 0xe655(%rip), %rdx      # 0x15184
jmp 0x6b7f
leaq 0xe8fb(%rip), %rsi      # 0x15433
leaq 0xe8fb(%rip), %rdx      # 0x1543a
jmp 0x6b7f
leaq 0xe721(%rip), %rsi      # 0x15269
leaq 0xe71d(%rip), %rdx      # 0x1526c
jmp 0x6b7f
leaq 0xe61c(%rip), %rsi      # 0x15174
leaq 0xe61b(%rip), %rdx      # 0x1517a
jmp 0x6b7f
leaq 0xe61d(%rip), %rsi      # 0x15185
leaq 0xe61e(%rip), %rdx      # 0x1518d
jmp 0x6b7f
leaq 0xe616(%rip), %rsi      # 0x1518e
leaq 0xe614(%rip), %rdx      # 0x15193
movq %rbx, %rdi
callq 0x6c06
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/AgathokakologicalBit[P]wit/src/error_handling.cpp
// Function: akbit::system::log_error(akbit::system::parsing::LexerState&)
void log_error(parsing::LexerState &state)
  {
    log_error_common(state);

    std::cout << "Line: " << state.line << "\n";
    std::cout << "Column: " << state.column << "\n\n";

    // throw std::runtime_error("halt");
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
leaq 0x20(%rsp), %rdi
movq %rax, -0x10(%rdi)
movups (%rbx), %xmm0
movaps %xmm0, -0x20(%rdi)
movl 0x18(%rbx), %eax
movl %eax, -0x8(%rdi)
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
addq %rsi, %rdx
callq 0x6e14
movq 0x15d2c(%rip), %rdi     # 0x1cfc0
leaq 0xe087(%rip), %rsi      # 0x15322
movl $0x9, %edx
callq 0x3240
movl 0x18(%rsp), %esi
movq 0x15d10(%rip), %rdi     # 0x1cfc0
callq 0x3340
leaq 0xe070(%rip), %rsi      # 0x1532c
movl $0x2, %edx
movq %rax, %rdi
callq 0x3240
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x15ce6(%rip), %rdi     # 0x1cfc0
callq 0x3240
leaq 0xe039(%rip), %rsi      # 0x1531f
movl $0x2, %edx
movq %rax, %rdi
callq 0x3240
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x730a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31f0
movq 0x15caf(%rip), %r14     # 0x1cfc0
leaq 0xdff7(%rip), %rsi      # 0x1530f
movl $0x6, %edx
movq %r14, %rdi
callq 0x3240
movl 0x4(%rbx), %esi
movq %r14, %rdi
callq 0x3150
leaq 0xdfe9(%rip), %rsi      # 0x15320
movl $0x1, %edx
movq %rax, %rdi
callq 0x3240
leaq 0xdfcb(%rip), %rsi      # 0x15316
movl $0x8, %edx
movq %r14, %rdi
callq 0x3240
movl 0x8(%rbx), %esi
movq %r14, %rdi
callq 0x3150
leaq 0xdfb5(%rip), %rsi      # 0x1531f
movl $0x2, %edx
movq %rax, %rdi
callq 0x3240
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x7399
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31f0
movq %rbx, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O1/AgathokakologicalBit[P]wit/src/parsing/operators.cpp
// Function: akbit::system::find_operator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
operator_t const * find_operator(std::string representation)
  {
    for (auto& op : operators_list)
      if (op.representation == representation)
        return &op;
    return nullptr;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %r15
xorl %r12d, %r12d
leaq 0x15afc(%rip), %r13     # 0x1d1f8
leaq (%r12,%r13), %rbp
movq 0x18(%r12,%r13), %rdx
cmpq %r15, %rdx
jne 0x7722
testq %rdx, %rdx
je 0x7726
movq (%r14), %rsi
movq 0x10(%rbp), %rdi
callq 0x3210
testl %eax, %eax
sete %al
jmp 0x7728
xorl %eax, %eax
jmp 0x7728
movb $0x1, %al
testb %al, %al
cmovneq %rbp, %rbx
jne 0x773f
addq $0x30, %r12
cmpq $0x420, %r12            # imm = 0x420
jne 0x76fc
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/AgathokakologicalBit[P]wit/src/parsing/token.cpp
// Function: akbit::system::parsing::get_type_name[abi:cxx11](akbit::system::parsing::TokenType)
std::string get_type_name(TokenType type)
  {
    using tt = TokenType;

    switch (type)
    {
      case tt::t_commentary: return "commentary";
      case tt::t_identifier: return "identifier";
      case tt::t_character: return "character";
      case tt::t_string: return "string";
      case tt::t_number: return "number";
      case tt::t_operator: return "operator";
      case tt::t_eof: return "##EOF##";
    
      default: return "#???";
    }
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
decl %esi
cmpl $0x6, %esi
ja 0x77f6
leaq 0xdb83(%rip), %rax      # 0x15330
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0xdc1b(%rip), %rsi      # 0x153d8
leaq 0xdc1e(%rip), %rdx      # 0x153e2
jmp 0x7834
leaq 0xd9ae(%rip), %rsi      # 0x1517b
leaq 0xd9b0(%rip), %rdx      # 0x15184
jmp 0x7834
leaq 0xdc11(%rip), %rsi      # 0x153ee
leaq 0xdc10(%rip), %rdx      # 0x153f4
jmp 0x7834
leaq 0xd987(%rip), %rsi      # 0x15174
leaq 0xd986(%rip), %rdx      # 0x1517a
jmp 0x7834
leaq 0xdc09(%rip), %rsi      # 0x15406
leaq 0xdc06(%rip), %rdx      # 0x1540a
jmp 0x7834
leaq 0xdbd6(%rip), %rsi      # 0x153e3
leaq 0xdbd9(%rip), %rdx      # 0x153ed
jmp 0x7834
leaq 0xdbd8(%rip), %rsi      # 0x153f5
leaq 0xdbd9(%rip), %rdx      # 0x153fd
jmp 0x7834
leaq 0xdbd1(%rip), %rsi      # 0x153fe
leaq 0xdbd1(%rip), %rdx      # 0x15405
movq %rbx, %rdi
callq 0x6c06
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/AgathokakologicalBit[P]wit/src/parsing/token.cpp
// Function: akbit::system::parsing::operator<<(std::ostream&, akbit::system::parsing::Token&)
std::ostream &operator<<(std::ostream &out, parsing::Token &token)
  {
    out << std::setw(4) << token.line << '|' << std::setw(4) << token.column << ' '
        << std::setw(24) << get_sub_type_name(token.sub_type) << "  "
        << token.value;
    return out;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl $0x4, %r12d
movq %r12, 0x10(%rdi,%rax)
movl 0x4(%rsi), %esi
callq 0x3150
leaq 0x8(%rsp), %r15
movb $0x7c, (%r15)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3240
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r12, 0x10(%rax,%rcx)
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x3150
movb $0x20, (%r15)
leaq 0x8(%rsp), %rsi
movl $0x1, %edx
movq %rax, %rdi
callq 0x3240
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rax
movq $0x18, 0x10(%r15,%rax)
movl 0x34(%r14), %esi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x7841
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x3240
movq %rax, %r15
leaq 0xd518(%rip), %rsi      # 0x150cc
movl $0x2, %edx
movq %rax, %rdi
callq 0x3240
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movq %r15, %rdi
callq 0x3240
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7bec
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31f0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7c19
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31f0
movq %rbx, %rdi
callq 0x3350
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/AgathokakologicalBit[P]wit/src/parsing/lexing.cpp
// Function: akbit::system::parsing::LexerState::move()
void LexerState::move()
  {
    if (index >= source.size())
      return;

    ++column;
    if (source[index++] != '\n')
      return;

    ++line;
    column = 1;
  }

// Assembly:
movl (%rdi), %eax
movq 0x10(%rdi), %rcx
cmpq %rax, 0x8(%rcx)
jbe 0x7c4b
incl 0x8(%rdi)
leal 0x1(%rax), %edx
movl %edx, (%rdi)
movq (%rcx), %rcx
cmpb $0xa, (%rcx,%rax)
jne 0x7c4b
incl 0x4(%rdi)
movl $0x1, 0x8(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/AgathokakologicalBit[P]wit/src/parsing/lexing.cpp
// Function: akbit::system::parsing::get_character_type(char)
parsing::TokenSubType get_character_type(char c)
  {
    using tst = TokenSubType;

    switch (c)
    {
      case '@': return tst::t_at_sign;

      case '(': return tst::t_brace_round_left;
      case ')': return tst::t_brace_round_right;
      case '[': return tst::t_brace_square_left;
      case ']': return tst::t_brace_square_right;
      case '<': return tst::t_brace_triangular_left;
      case '>': return tst::t_brace_triangular_right;
      case '{': return tst::t_brace_curly_left;
      case '}': return tst::t_brace_curly_right;

      case '+': return tst::t_plus;
      case '-': return tst::t_dash;
      case '~': return tst::t_tilde;
      case '.': return tst::t_dot;
      case ',': return tst::t_comma;

      case '*': return tst::t_star;
      case '/': return tst::t_slash;
      case '\\': return tst::t_backslash;
      case '%': return tst::t_percent;

      case '|': return tst::t_vertical_bar;
      case '&': return tst::t_ampersand;
      case '^': return tst::t_caret;

      case '=': return tst::t_equal;
      case '!': return tst::t_exclamation_mark;
      case '?': return tst::t_question_mark;

      case ':': return tst::t_colon;
      case ';': return tst::t_semicolon;

      default: return tst::t_unknown;
    }
  }

// Assembly:
leal -0x21(%rdi), %eax
cmpl $0x1f, %eax
ja 0x7c6a
leaq 0xd97d(%rip), %rcx      # 0x155d8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1e, %eax
retq
leal -0x5b(%rdi), %eax
cmpl $0x3, %eax
jbe 0x7c90
addl $-0x7b, %edi
cmpl $0x3, %edi
ja 0x7ca6
leaq 0xd9e7(%rip), %rax      # 0x15668
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0xf, %eax
retq
leaq 0xd9c1(%rip), %rcx      # 0x15658
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xb, %eax
retq
xorl %eax, %eax
retq
movl $0x18, %eax
retq
movl $0x21, %eax
retq
movl $0xd, %eax
retq
movl $0x11, %eax
retq
movl $0xe, %eax
retq
movl $0x1b, %eax
retq
movl $0x20, %eax
retq
movl $0xa, %eax
retq
movl $0x1d, %eax
retq
movl $0x14, %eax
retq
movl $0x12, %eax
retq
movl $0x17, %eax
retq
movl $0x1f, %eax
retq
movl $0x9, %eax
retq
movl $0x19, %eax
retq
movl $0x15, %eax
retq
movl $0x8, %eax
retq
movl $0xc, %eax
retq
movl $0x10, %eax
retq
movl $0x1c, %eax
retq
movl $0x16, %eax
retq
movl $0x13, %eax
retq
movl $0x1a, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/AgathokakologicalBit[P]wit/src/parsing/lexing.cpp
// Function: akbit::system::parsing::tokenize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
std::vector<Token> tokenize(std::string &source)
  {
    std::vector<Token> tokens{};
    parsing::LexerState state(source);

    while (state.index < source.size() && not state.is_error_occurred())
      tokens.push_back(get_next_token(state));

    if (state.is_error_occurred())
    {
      log_error(state);
    }

    return tokens;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movabsq $0x100000000, %rcx      # imm = 0x100000000
leaq 0x30(%rsp), %r13
movq %rcx, -0x30(%r13)
movl $0x1, -0x28(%r13)
movq %rsi, -0x20(%r13)
movl $0x0, -0x18(%r13)
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb $0x0, (%r13)
cmpq %rax, 0x8(%rsi)
je 0x8342
xorl %eax, %eax
testb %al, %al
jne 0x8342
movq %rsi, %r14
leaq 0x60(%rsp), %rbp
leaq 0x40(%rsp), %r15
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x7d33
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8424
movq 0x50(%rsp), %rdi
cmpq %rbp, %rdi
je 0x8332
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x31f0
movl (%rsp), %eax
cmpq %rax, 0x8(%r14)
jbe 0x8342
cmpl $0x0, 0x18(%rsp)
je 0x8305
cmpl $0x0, 0x18(%rsp)
je 0x8351
movq %rsp, %rdi
callq 0x7250
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x8368
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31f0
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x837c
movq %rax, %r14
jmp 0x839b
movq %rax, %r14
movq 0x50(%rsp), %rdi
cmpq %rbp, %rdi
je 0x839b
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x31f0
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x83b2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31f0
movq %rbx, %rdi
callq 0x6b8c
movq %r14, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O1/AgathokakologicalBit[P]wit/src/parsing/parsing.cpp
// Function: akbit::system::parsing::parse(std::vector<akbit::system::parsing::Token, std::allocator<akbit::system::parsing::Token>>&)
std::shared_ptr<Node> parse(std::vector<Token> &tokens)
  {
    ParserState state(tokens);
    auto module = parse_module(state);

    if (state.is_failed())
    {
      std::get<Node::module_t>(module->value).has_errors = state.is_failed();
      log_error(state);
      return module;
    }

    return module;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %rbp
movq %rsi, -0x28(%rbp)
xorl %eax, %eax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movq %rbp, -0x10(%rbp)
movq %rax, -0x8(%rbp)
movb $0x0, (%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbp)
movq %rax, 0x20(%rbp)
leaq 0x60(%rsp), %rcx
movups %xmm0, 0x19(%rcx)
movaps %xmm0, 0x10(%rcx)
movaps %xmm0, (%rcx)
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc2de
movq %r14, 0x8(%rsp)
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x9723
callq 0x6da4
leaq 0x60(%rsp), %r15
movq %r15, %rdi
callq 0x6d5c
movabsq $0x6db6db6db6db6db7, %r14 # imm = 0x6DB6DB6DB6DB6DB7
leaq 0x10(%rsp), %r12
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
imulq %r14, %rcx
decq %rcx
cmpq %rcx, 0x18(%rsp)
jae 0x979f
cmpl $0x0, 0x20(%rsp)
jne 0x979f
movq (%rbx), %rdi
addq $0x10, %rdi
callq 0x6ea4
movq %rax, %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x9941
movq %r13, %rdi
movq %r15, %rsi
callq 0xc77e
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x9798
callq 0x6da4
cmpl $0x0, 0x20(%rsp)
je 0x973f
cmpl $0x0, 0x20(%rsp)
je 0x97c0
movq (%rbx), %rdi
addq $0x10, %rdi
callq 0x6ea4
movb $0x1, 0x28(%rax)
leaq 0x10(%rsp), %rdi
callq 0x73a1
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x97d7
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x31f0
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x97ee
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x31f0
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0xc2c2
jmp 0x983f
jmp 0x982a
jmp 0x982a
movq %rax, %rbx
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x982d
callq 0x6da4
jmp 0x982d
movq %rax, %rbx
movq 0x8(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x983f
callq 0x6da4
leaq 0x10(%rsp), %rdi
callq 0x7610
movq %rbx, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O1/AgathokakologicalBit[P]wit/src/parsing/parsing.cpp
// Function: akbit::system::parsing::convert_to_tuple(std::shared_ptr<akbit::system::Node>)
std::shared_ptr<Node> convert_to_tuple(std::shared_ptr<Node> node)
  {
    if (nullptr == node) return nullptr;
    try
    {
      std::get<Node::value_tuple_t>(node->value);
      return node;
    }
    catch (...) { }
    
    auto container = std::make_shared<Node>(Node::value_tuple_t{
      .entries = {
        {node}
      }
    });

    return container;
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x988c
movq %rsi, %r14
addq $0x10, %rdi
callq 0xc25e
movq (%r14), %rax
movq %rax, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq 0x8(%r14), %rcx
movq %rax, 0x8(%r14)
movq %rcx, 0x8(%rbx)
movq %rax, (%r14)
jmp 0x9892
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x3100
callq 0x3310
movq (%r14), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%r14), %rdi
movq %rdi, 0x18(%rsp)
testq %rdi, %rdi
jne 0x9911
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0xe(%rsp), %rcx
movl $0x1, %edx
callq 0xc216
movq $0x0, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0xf(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %rbx, %rsi
callq 0xda52
leaq 0x20(%rsp), %rdi
callq 0x6d5c
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x9892
callq 0x6da4
jmp 0x9892
callq 0x35fd
jmp 0x98c0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6d5c
jmp 0x992a
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x9939
callq 0x6da4
movq %rbx, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O1/AgathokakologicalBit[P]wit/src/parsing/parsing.cpp
// Function: akbit::system::parsing::(anonymous namespace)::parse_composite_unit(akbit::system::parsing::ParserState&)
std::shared_ptr<Node> parse_composite_unit(ParserState &state)
    {
      auto unit = parse_unit(state);
      if (state.is_failed()) return unit;

      // Function calls
      while (state.peek().sub_type == TokenSubType::t_brace_round_left)
      {
        auto container = std::make_shared<Node>(Node::function_call_t{
          .expression = unit,
          .arguments = parse_unit(state)
        });
        unit = container;
      }

      return unit;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r14
callq 0xb68e
cmpl $0x0, 0x10(%r15)
je 0xb4fd
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x30(%rsp), %r12
leaq 0x8(%r14), %rbx
movq (%r15), %rax
movq (%rax), %rbp
imulq $0x38, 0x8(%r15), %r13
movl 0x8(%rbp,%r13), %eax
movl %eax, 0x18(%rsp)
movq (%rbp,%r13), %rax
movq %rax, 0x10(%rsp)
movq %r12, 0x20(%rsp)
movq 0x10(%rbp,%r13), %rsi
movq 0x18(%rbp,%r13), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x6e14
addq %r13, %rbp
movq 0x30(%rbp), %rax
movq %rax, 0x40(%rsp)
movl 0x44(%rsp), %ebp
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xb567
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31f0
cmpl $0x9, %ebp
jne 0xb4eb
movq (%r14), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0xb59b
movq 0x11a2b(%rip), %rcx     # 0x1cfb8
cmpb $0x0, (%rcx)
je 0xb597
incl 0x8(%rax)
jmp 0xb59b
lock
incl 0x8(%rax)
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0xb68e
movq $0x0, (%rsp)
movl $0x68, %edi
callq 0x31e0
movq %rax, %rbp
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x8(%rbp)
leaq 0x113a6(%rip), %rax     # 0x1c978
movq %rax, (%rbp)
leaq 0x10(%rbp), %r13
movq %rbp, %rdi
addq $0x20, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbp)
leaq 0x10(%rsp), %rsi
callq 0xd582
movb $0x7, 0x58(%rbp)
movl $0x0, 0x60(%rbp)
movq %rbp, 0x8(%rsp)
movq %r13, (%rsp)
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xb615
callq 0x6da4
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xb624
callq 0x6da4
movq (%rsp), %rax
movq %rax, (%r14)
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0xd81c
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xb506
callq 0x6da4
jmp 0xb506
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xc60e
jmp 0xb671
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xb671
callq 0x6da4
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xb67e
callq 0x6da4
movq %r14, %rdi
callq 0x3350
movq %rax, %rdi
callq 0x6c96
// File: /workspace/github_cpp_makefile_star2_O1/AgathokakologicalBit[P]wit/src/parsing/../node.hpp
// Function: akbit::system::make_node_bop(std::shared_ptr<akbit::system::Node>, std::shared_ptr<akbit::system::Node>, akbit::system::operator_t const*)
inline std::shared_ptr<Node> make_node_bop(std::shared_ptr<Node> left, std::shared_ptr<Node> right, operator_t const * operation)
  {
    return std::make_shared<Node>(Node::binary_operation_t{
      .operation = operation,
      .operands = {
        left,
        right,
      }
    });
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq %rcx, 0x28(%rsp)
movq (%rsi), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0xcf93
movq 0x10033(%rip), %rcx     # 0x1cfb8
cmpb $0x0, (%rcx)
je 0xcf8f
incl 0x8(%rax)
jmp 0xcf93
lock
incl 0x8(%rax)
leaq 0x30(%rsp), %r14
movq (%rdx), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rdx), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0xcfc3
movq 0x10003(%rip), %rcx     # 0x1cfb8
cmpb $0x0, (%rcx)
je 0xcfbf
incl 0x8(%rax)
jmp 0xcfc3
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rsi
leaq 0x6(%rsp), %rcx
movl $0x2, %edx
movq %r14, %rdi
callq 0xc216
movq $0x0, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x7(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rbx, %rsi
callq 0xd700
movq %r14, %rdi
callq 0x6d5c
movl $0x20, %r14d
movq (%rsp,%r14), %rdi
testq %rdi, %rdi
je 0xd013
callq 0x6da4
addq $-0x10, %r14
jne 0xd005
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x6d5c
jmp 0xd034
movq %rax, %rbx
movl $0x20, %r14d
movq (%rsp,%r14), %rdi
testq %rdi, %rdi
je 0xd048
callq 0x6da4
addq $-0x10, %r14
jne 0xd03a
movq %rbx, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O1/AgathokakologicalBit[P]wit/src/annotation/tree_preprocessing.cpp
// Function: akbit::system::annotation::(anonymous namespace)::tp_visit(std::shared_ptr<akbit::system::Node>)
void tp_visit(std::shared_ptr<Node> node)
    {
      if (nullptr == node) return;
      std::visit(overloaded {
        [](auto                     & ) {                                  },
        [](Node::module_t           &_) { tp_visit_module(_);              },
        [](Node::declaration_t      &_) { tp_visit_declaration(_);         },
        [](Node::condition_t        &_) { tp_visit_condition(_);           },
        [](Node::block_t            &_) { tp_visit_block(_);               },
        [](Node::unary_operation_t  &_) { tp_visit_unary_operation(_);     },
        [&](Node::binary_operation_t& ) { tp_visit_binary_operation(node); },
        [](Node::function_call_t    &_) { tp_visit_function_call(_);       },
        [](Node::value_function_t   &_) { tp_visit_value_function(_);      },
        [](Node::value_tuple_t      &_) { tp_visit_value_tuple(_);         },
        [](Node::value_variable_t   &_) { tp_visit_value_variable(_);      },
        [](Node::value_string_t     &_) { tp_visit_value_string(_);        },
        [](Node::value_character_t  &_) { tp_visit_value_character(_);     },
        [](Node::value_integer_t    &_) { tp_visit_value_integer(_);       },
        [](Node::value_decimal_t    &_) { tp_visit_value_decimal(_);       },
      }, node->value);
    }

// Assembly:
pushq %rax
movq (%rdi), %rsi
testq %rsi, %rsi
je 0xdb8f
movq %rdi, (%rsp)
movsbq 0x48(%rsi), %rax
cmpq $-0x1, %rax
je 0xdb91
addq $0x10, %rsi
leaq 0xef87(%rip), %rcx      # 0x1cb10
movq %rsp, %rdi
callq *(%rcx,%rax,8)
popq %rax
retq
movl $0x10, %edi
callq 0x3120
leaq 0xecae(%rip), %rcx      # 0x1c850
movq %rcx, (%rax)
leaq 0x7539(%rip), %rcx      # 0x150e5
movq %rcx, 0x8(%rax)
leaq 0xec71(%rip), %rsi      # 0x1c828
movq 0xf41a(%rip), %rdx      # 0x1cfd8
movq %rax, %rdi
callq 0x3330