LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/SeTriones[P]Anubis/lru_cache.cpp
// Function: LRUCache::set(unsigned long, int*, int)
int* LRUCache::set(uint64_t key, int* pos, int overwrite){
	std::tr1::unordered_map<uint64_t, struct HashItem>::iterator it;
	it = hash.find(key);
	if (it != hash.end()) {
		if(overwrite) {
			it->second.pos = pos;
			mv_node_to_header(list, it->second.node, 0);
		}
		else {
			mv_node_to_header(list, it->second.node, 0);
		}
		return pos;
	}
	int* free_pos = pos;
	if (size == capacity) {
		node *n = pop_from_tail(list);
		it = hash.find(n->key);
		free_pos = it->second.pos;
		hash.erase(it);
		free(n);
		size--;
	}
	node *tmp = new_node();
	tmp->key = key;
	mv_node_to_header(list, tmp, 1);
	HashItem item;
	item.node = tmp;
	item.pos = free_pos;
	hash.insert(std::pair<uint64_t, struct HashItem>(key, item));
	size++;
	return free_pos;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq 0x20(%r14), %r8
xorl %esi, %esi
movq %r15, %rax
xorl %edx, %edx
divq %r8
movq (%rdi,%rdx,8), %rax
testq %rax, %rax
je 0x3fb6
xorl %esi, %esi
cmpq %r15, (%rax)
je 0x3fb3
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0x3fa3
jmp 0x3fb6
movq %rax, %rsi
testq %rsi, %rsi
jne 0x3fbf
movq (%rdi,%r8,8), %rsi
cmpq (%rdi,%r8,8), %rsi
je 0x3fde
testl %ecx, %ecx
je 0x3fcd
movq %rbx, 0x10(%rsi)
movq 0x8(%r14), %rdi
movq 0x8(%rsi), %rsi
xorl %edx, %edx
callq 0x3166
jmp 0x4056
leaq 0x10(%r14), %r12
movl (%r14), %eax
cmpl 0x4(%r14), %eax
jne 0x401c
movq 0x8(%r14), %rdi
callq 0x32b6
movq %rax, %r13
movq %r12, %rdi
movq %rax, %rsi
callq 0x40aa
movq 0x10(%rax), %rbx
movq %r12, %rdi
movq %rax, %rsi
callq 0x4256
movq %r13, %rdi
callq 0x2250
decl (%r14)
callq 0x314b
movq %rax, %r13
movq %r15, (%rax)
movq 0x8(%r14), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x3166
leaq 0x18(%rsp), %rdx
movq %r15, (%rdx)
movq %r13, 0x8(%rdx)
movq %rbx, 0x10(%rdx)
movq %rsp, %rdi
movq %r12, %rsi
callq 0x4290
incl (%r14)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/SeTriones[P]Anubis/receiver.cpp
// Function: receiver::receiver(int, int, int, int)
receiver::receiver(int _epoll_cnt, int _max_conn, int _key_group_cnt, int _group_capacity) : acceptor(_epoll_cnt, _max_conn) {
	endian = testEndian();
	key_group_cnt = _key_group_cnt;
	group_capacity = _group_capacity;
	key_groups = (KeyGroup**)malloc(key_group_cnt * sizeof(KeyGroup*));
	for (int i = 0; i < key_group_cnt; i++) {
		key_groups[i] = new KeyGroup(group_capacity);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r15d
movl %ecx, %ebp
movl %edx, %r12d
movl %esi, %r13d
movq %rdi, %rbx
callq 0x5534
leaq 0x40(%rbx), %r14
movq %r14, %rdi
movl %r13d, %esi
movl %r12d, %edx
callq 0x2420
leaq 0x4209(%rip), %rax      # 0x8ca8
movq %rax, (%rbx)
movb $0x0, 0xf4(%rbx)
movl %ebp, 0xec(%rbx)
movl %r15d, 0xf0(%rbx)
movslq %ebp, %rdi
shlq $0x3, %rdi
callq 0x22a0
movq %rax, 0xf8(%rbx)
cmpl $0x0, 0xec(%rbx)
jle 0x4b0a
xorl %r15d, %r15d
movl $0x58, %edi
callq 0x21e0
movq %rax, %r12
movl 0xf0(%rbx), %esi
movq %rax, %rdi
callq 0x3c84
movq 0xf8(%rbx), %rax
movq %r12, (%rax,%r15,8)
incq %r15
movslq 0xec(%rbx), %rax
cmpq %rax, %r15
jl 0x4ad5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x4b3b
movq %rax, %r15
jmp 0x4b33
movq %rax, %r15
movl $0x58, %esi
movq %r12, %rdi
callq 0x21f0
movq %r14, %rdi
callq 0x32e0
movq %rbx, %rdi
callq 0x5546
movq %r15, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/SeTriones[P]Anubis/receiver.cpp
// Function: receiver::open(int)
int receiver::open(int thread_cnt) {
	for (int i = 0; i < epoll_cnt; i++) {
		epoll_fds[i] = epoll_create(max_conn);
		if (epoll_fds[i] == -1) {
			_ERROR("create epoll fd %d err", i);
			return -1;
		}
	}
	for (int i = 0; i < epoll_cnt; i++) {
		if (create_pipe(i) < 0) {
			_ERROR("create pipe err on idx=%d", i);
			return -1;
		}
		add_input_fd(pipe_read_fds[i], epoll_fds[i]);
	}
	return task_base::open(thread_cnt * epoll_cnt, 256 * (1<<10));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x0, 0x44(%rdi)
setg %r13b
jle 0x4cba
movl 0x40(%rbx), %edi
callq 0x23d0
movq 0x50(%rbx), %rcx
movl %eax, (%rcx)
cmpl $-0x1, %eax
je 0x4c40
movl $0x1, %r14d
movslq 0x44(%rbx), %rax
cmpq %rax, %r14
setl %r13b
jge 0x4cba
movl 0x40(%rbx), %edi
callq 0x23d0
movq 0x50(%rbx), %rcx
movl %eax, (%rcx,%r14,4)
incq %r14
cmpl $-0x1, %eax
jne 0x4c12
decl %r14d
jmp 0x4c43
xorl %r14d, %r14d
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x21d0
leaq 0x30(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2100
leaq 0x139d(%rip), %rdx      # 0x6004
leaq 0x10(%rsp), %r15
movl $0x12, %esi
movq %r15, %rdi
movq %r12, %rcx
callq 0x2180
movq 0x4355(%rip), %rax      # 0x8fd8
movq (%rax), %r12
callq 0x21b0
leaq 0x1783(%rip), %rsi      # 0x6415
leaq 0x14e2(%rip), %r8       # 0x617b
movq %r12, %rdi
movq %r15, %rdx
movq %rax, %rcx
movl %r14d, %r9d
xorl %eax, %eax
callq 0x22e0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %r13b, %r13b
jne 0x4da9
cmpl $0x0, 0x44(%rbx)
setg %r13b
jle 0x4d91
leaq 0x40(%rbx), %r15
xorl %r14d, %r14d
movq %r15, %rdi
xorl %esi, %esi
callq 0x35b0
testl %eax, %eax
js 0x4d1e
xorl %r14d, %r14d
movq 0x50(%rbx), %rax
movq 0xd0(%rbx), %rcx
movl (%rcx,%r14,4), %esi
movl (%rax,%r14,4), %edx
movq %r15, %rdi
callq 0x33da
incq %r14
movslq 0x44(%rbx), %rax
cmpq %rax, %r14
setl %r13b
jge 0x4d91
movq %r15, %rdi
movl %r14d, %esi
callq 0x35b0
testl %eax, %eax
jns 0x4ce0
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x21d0
leaq 0x30(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2100
leaq 0x12c2(%rip), %rdx      # 0x6004
leaq 0x10(%rsp), %r15
movl $0x12, %esi
movq %r15, %rdi
movq %r12, %rcx
callq 0x2180
movq 0x427a(%rip), %rax      # 0x8fd8
movq (%rax), %r12
callq 0x21b0
leaq 0x16d7(%rip), %rsi      # 0x6444
leaq 0x1407(%rip), %r8       # 0x617b
movq %r12, %rdi
movq %r15, %rdx
movq %rax, %rcx
movl %r14d, %r9d
xorl %eax, %eax
callq 0x22e0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %r13b, %r13b
jne 0x4da9
movslq 0x44(%rbx), %rax
movslq %ebp, %rsi
imulq %rax, %rsi
movl $0x40000, %edx          # imm = 0x40000
movq %rbx, %rdi
callq 0x5562
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/SeTriones[P]Anubis/receiver.cpp
// Function: receiver::stop()
int receiver::stop() {
	int write_cnt = 0;
	for (int i = 0; i < epoll_cnt; i++) {
		int stop = 1;
		write_cnt = write(pipe_write_fds[i], &stop, 1);
		assert(write_cnt == 1);
	}
	stop_task = 1;
	join();
	_INFO("receiver stops");
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x44(%rdi)
jle 0x4e03
xorl %r15d, %r15d
leaq 0xc(%rsp), %r14
movl $0x1, 0xc(%rsp)
movq 0xd8(%rbx), %rax
movl (%rax,%r15,4), %edi
movl $0x1, %edx
movq %r14, %rsi
callq 0x20b0
cmpl $0x1, %eax
jne 0x4e17
incq %r15
movslq 0x44(%rbx), %rax
cmpq %rax, %r15
jl 0x4dd2
movq %rbx, %rdi
callq 0x2e7c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1658(%rip), %rdi      # 0x6476
leaq 0x1660(%rip), %rsi      # 0x6485
leaq 0x1666(%rip), %rcx      # 0x6492
movl $0x40, %edx
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/SeTriones[P]Anubis/receiver.cpp
// Function: receiver::start_listen(int)
int receiver::start_listen(int port) {
	listen_port = port;
	if (create_listen(listen_fd, listen_port)) {
		_ERROR("create listen fail on port=%d", listen_port);
		return -1;
	}
	add_input_fd(listen_fd, epoll_fds[0]);
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x40(%rdi), %r14
movl %esi, 0x48(%rdi)
leaq 0x4c(%rdi), %rax
movzwl %si, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x3416
testl %eax, %eax
jne 0x5521
movl 0x4c(%rbx), %esi
movq 0x50(%rbx), %rax
movl (%rax), %edx
movq %r14, %rdi
callq 0x33da
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x48, %rbx
movq %rbx, %rdi
callq 0x2f7e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x5519
// File: /workspace/github_cpp_makefile_star2_O1/SeTriones[P]Anubis/task_base.cpp
// Function: task_base::open(unsigned long, unsigned long)
int task_base::open(size_t thread_num, size_t stack_size)
{
	int ret = -1;
	size_t i;
	pthread_attr_t attr;
	pthread_attr_init(&attr);

	do {
		pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
		if (pthread_attr_setstacksize(&attr, stack_size))
			break;

		if (thread_num == 0 || (m_thread = (pthread_t*)malloc(thread_num * sizeof(pthread_t))) == NULL)
			break;

		pthread_barrier_init(&m_barrier, NULL, thread_num + 1);
		for (i=0; i<thread_num; i++)
			if (pthread_create(m_thread+i, &attr, run_svc, this))
				break;

		if ((m_thread_num = i) != thread_num)
			break;

		ret = 0;
	} while (false);

	pthread_attr_destroy(&attr);
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r12
movq %r12, %rdi
callq 0x2260
movq %r12, %rdi
xorl %esi, %esi
callq 0x2290
movq %r12, %rdi
movq %r15, %rsi
callq 0x22c0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rbx, %rbx
je 0x5619
testl %eax, %eax
jne 0x5619
leaq (,%rbx,8), %rdi
callq 0x22a0
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x5619
leaq 0x18(%r14), %rdi
leal 0x1(%rbx), %edx
xorl %r13d, %r13d
xorl %esi, %esi
callq 0x2360
testq %rbx, %rbx
je 0x560a
xorl %ebp, %ebp
leaq 0x56(%rip), %r15        # 0x5632
movq %rsp, %r12
xorl %r13d, %r13d
movq 0x8(%r14), %rdi
addq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x23c0
testl %eax, %eax
jne 0x560a
incq %r13
addq $0x8, %rbp
cmpq %r13, %rbx
jne 0x55e2
movq %rbx, %r13
movq %r13, 0x10(%r14)
xorl %ebp, %ebp
cmpq %rbx, %r13
setne %bpl
negl %ebp
movq %rsp, %rdi
callq 0x2390
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/SeTriones[P]Anubis/task_base.cpp
// Function: task_base::join()
int task_base::join()
{
	if (m_thread) {
		for (size_t i=0; i<m_thread_num; i++) {
			pthread_kill(m_thread[i], SIGTERM);
			pthread_join(m_thread[i], NULL);
		}
		free(m_thread);
		m_thread = NULL;
		pthread_barrier_destroy(&m_barrier);
	}
	return 0;
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x56c0
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x569c
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
movl $0xf, %esi
callq 0x2280
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
xorl %esi, %esi
callq 0x21c0
incq %r14
cmpq 0x10(%rbx), %r14
jb 0x5672
movq 0x8(%rbx), %rdi
callq 0x2250
movq $0x0, 0x8(%rbx)
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x2200
addq $0x8, %rsp
popq %rbx
popq %r14
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/zengfenfei[P]codility/src/MissingInteger.cpp
// Function: solution(std::vector<int, std::allocator<int>>&)
int solution(vector<int> &A) {
	int min = 0;	// Positive minimal
	for (int i = 0; i < A.size(); i++) {
		if (A[i] > 0 && (min == 0 || A[i] < min)) {
			min = A[i];
		}
	}
	if (min == 0 || min > 1) {
		return 1;
	}

	vector<int> possibleMissing(A.size(), 0);
	for (int i = 0; i < A.size(); i++) {
		int minOffset = A[i] - min - 1;
		if (minOffset >= 0 && minOffset < A.size()) {
			possibleMissing[minOffset]++;
		}
	}

	for (int i = 0; i < A.size(); i++) {
		if (possibleMissing[i] == 0) {
			return min + i + 1;
		}
	}
	return 0; 	// Will never run
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x2, %rsi
cmpq %rax, %rcx
je 0x11f9
cmpq $0x1, %rsi
movq %rsi, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
xorl %edi, %edi
movl (%rax,%rdx,4), %r8d
cmpl %edi, %r8d
movl %edi, %r15d
cmovll %r8d, %r15d
testl %edi, %edi
cmovel %r8d, %r15d
testl %r8d, %r8d
cmovlel %edi, %r15d
incq %rdx
movl %r15d, %edi
cmpq %rdx, %rcx
jne 0x11d1
jmp 0x11fc
xorl %r15d, %r15d
testl %r15d, %r15d
sete %al
cmpl $0x2, %r15d
setge %cl
orb %al, %cl
movl $0x1, %r14d
jne 0x12ba
leaq -0x20(%rbp), %rdx
movl $0x0, (%rdx)
leaq -0x38(%rbp), %rdi
leaq -0x19(%rbp), %rcx
callq 0x12d0
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
movq %rdx, %rax
subq %rcx, %rax
sarq $0x2, %rax
cmpq %rcx, %rdx
je 0x1278
movl %r15d, %esi
notl %esi
movq -0x38(%rbp), %rdi
cmpq $0x1, %rax
movq %rax, %r8
adcq $0x0, %r8
xorl %r9d, %r9d
movl (%rcx,%r9,4), %r10d
addl %esi, %r10d
js 0x1270
movl %r10d, %r10d
cmpq %r10, %rax
jbe 0x1270
incl (%rdi,%r10,4)
incq %r9
cmpq %r9, %r8
jne 0x125b
cmpq %rcx, %rdx
je 0x1299
movq -0x38(%rbp), %rdx
cmpq $0x1, %rax
adcq $0x0, %rax
xorl %ecx, %ecx
cmpl $0x0, (%rdx,%rcx,4)
je 0x129e
incq %rcx
cmpq %rcx, %rax
jne 0x128b
xorl %r14d, %r14d
jmp 0x12a5
leal (%r15,%rcx), %r14d
incl %r14d
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x12ba
movq -0x28(%rbp), %rsi
subq %rdi, %rsi
callq 0x1070
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/byronknoll[P]paqclass/runner.cpp
// Function: exec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string exec(const string& cmd) {
    FILE* pipe = popen(cmd.c_str(), "r");
    if (!pipe) return "ERROR";
    char buffer[128];
    string result = "";
    while(!feof(pipe)) {
    	if(fgets(buffer, 128, pipe) != NULL)
    		result += buffer;
    }
    pclose(pipe);
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x1bb9(%rip), %rsi      # 0x4020
callq 0x2090
testq %rax, %rax
je 0x24d2
movq %rax, %r14
leaq 0x10(%rbx), %r12
movq %r12, (%rbx)
leaq 0x1bcb(%rip), %rdx      # 0x404d
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x3252
movq %r14, %rdi
callq 0x2240
testl %eax, %eax
jne 0x24c8
movq %rsp, %r15
movq %r15, %rdi
movl $0x80, %esi
movq %r14, %rdx
callq 0x2260
testq %rax, %rax
je 0x24bc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22f0
movq %r14, %rdi
callq 0x2240
testl %eax, %eax
je 0x249c
movq %r14, %rdi
callq 0x21e0
jmp 0x24ef
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1b42(%rip), %rsi      # 0x4022
leaq 0x1b40(%rip), %rdx      # 0x4027
movq %rbx, %rdi
callq 0x3252
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x2518
movq (%r12), %rsi
incq %rsi
callq 0x21a0
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O1/byronknoll[P]paqclass/runner.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*)
void split(const string& s, char delim, vector<string>* elems) {
    stringstream ss(s);
    string item;
    while (getline(ss, item, delim)) {
        elems->push_back(item);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x2270
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movsbl %bpl, %ebp
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x22e0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2592
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2fc0
jmp 0x256a
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x25a9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x3a10(%rip), %rsi      # 0x5fc0
leaq 0x28(%rsp), %rdi
callq 0x2130
leaq 0xa8(%rsp), %rdi
callq 0x20b0
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x25f1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x39c8(%rip), %rsi      # 0x5fc0
leaq 0x28(%rsp), %rdi
callq 0x2130
leaq 0xa8(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O1/byronknoll[P]paqclass/runner.cpp
// Function: list(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*)
void list(const string& dir, vector<string>* files) {
    DIR *dp;
    struct dirent *dirp;
    if((dp  = opendir(dir.c_str())) == NULL) return;
    while ((dirp = readdir(dp)) != NULL) {
        string file = string(dirp->d_name);
        if (file != "." && file != "..") files->push_back(file);
    }
    closedir(dp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, (%rsp)
movq (%rdi), %rdi
callq 0x2200
testq %rax, %rax
je 0x26e3
movq %rax, %r14
movq %rax, %rdi
callq 0x2210
testq %rax, %rax
je 0x26db
movq %rax, %rbp
leaq 0x18(%rsp), %rbx
leaq 0x8(%rsp), %r15
leaq 0x19c7(%rip), %r12      # 0x4029
leaq 0x13(%rbp), %r13
movq %rbx, 0x8(%rsp)
movq %r13, %rdi
callq 0x20e0
leaq (%rax,%rbp), %rdx
addq $0x13, %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x3252
movq %r15, %rdi
movq %r12, %rsi
callq 0x2080
testl %eax, %eax
je 0x26b4
movq %r15, %rdi
leaq 0x1989(%rip), %rsi      # 0x4028
callq 0x2080
testl %eax, %eax
je 0x26b4
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x2fc0
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x26cb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %r14, %rdi
callq 0x2210
movq %rax, %rbp
testq %rax, %rax
jne 0x2662
movq %r14, %rdi
callq 0x2280
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x270c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ctmeans/src/lib/ctmeans.cpp
// Function: CTMeans::get_flat_U(std::vector<double, std::allocator<double>>&) const
void CTMeans::get_flat_U(std::vector<double>& flatu) const {
    flatu.clear();
    int flatu_size = 0;
    for(int i=0; i<n; ++i) {
        flatu_size += U[i].first.size();
    }
    flatu.reserve(flatu_size);
    for(int i=0; i<n; ++i) {
        const std::vector<double>& us = U[i].first;
        for(unsigned i2=0; i2<us.size(); ++i2) {
            flatu.push_back(us[i2]);
        }
    }
    std::sort(flatu.begin(), flatu.end(), std::greater<double>());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x3547
movq %rax, 0x8(%rbx)
movslq 0xc(%r14), %rcx
xorl %esi, %esi
testq %rcx, %rcx
jle 0x357b
movq 0x58(%r14), %rax
shlq $0x4, %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %edx, %edx
movq 0x8(%rax,%rdx), %rdi
subq (%rax,%rdx), %rdi
shrq $0x3, %rdi
addl %edi, %esi
addq $0x30, %rdx
cmpq %rdx, %rcx
jne 0x3560
movslq %esi, %rsi
movq %rbx, %rdi
callq 0x3776
cmpl $0x0, 0xc(%r14)
jle 0x35fb
xorl %r15d, %r15d
movq 0x58(%r14), %r12
leaq (%r15,%r15,2), %rcx
shlq $0x4, %rcx
movq (%r12,%rcx), %rax
cmpq %rax, 0x8(%r12,%rcx)
je 0x35ef
addq %rcx, %r12
movl $0x1, %ebp
xorl %ecx, %ecx
leaq (%rax,%rcx,8), %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x35ce
movsd (%rdx), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x35d6
movq %rbx, %rdi
callq 0x488c
movl %ebp, %ecx
movq (%r12), %rax
movq 0x8(%r12), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x35ae
incq %r15
movslq 0xc(%r14), %rax
cmpq %rax, %r15
jl 0x358d
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
cmpq %rbx, %r14
je 0x363c
movq %rbx, %rax
subq %r14, %rax
sarq $0x3, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4b3f
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4c38
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ctmeans/src/lib/ctmeans.cpp
// Function: CTMeans::get_dense_U(Matrix&) const
void CTMeans::get_dense_U(Matrix& U2) const {
    for(int i=0; i<n; ++i) {
        const std::vector<double>& us = U[i].first;
        const std::vector<int>& indices = U[i].second;
        for(unsigned i2=0; i2<us.size(); ++i2) {
            U2(i, indices[i2]) = us[i2];
        }
    }
}

// Assembly:
movslq 0xc(%rdi), %rax
testq %rax, %rax
jle 0x36fe
pushq %r14
pushq %rbx
movq 0x58(%rdi), %rcx
movq 0x10(%rsi), %rdx
movslq 0x4(%rsi), %rsi
xorl %edi, %edi
leaq (%rdi,%rdi,2), %r10
shlq $0x4, %r10
movq (%rcx,%r10), %r8
movq 0x8(%rcx,%r10), %r9
subq %r8, %r9
je 0x36f3
addq %rcx, %r10
sarq $0x3, %r9
movq 0x18(%r10), %r10
movq %rdi, %r11
imulq %rsi, %r11
leaq (%rdx,%r11,8), %r11
xorl %ebx, %ebx
movsd (%r8,%rbx,8), %xmm0
movslq (%r10,%rbx,4), %r14
movsd %xmm0, (%r11,%r14,8)
incq %rbx
movl %ebx, %r14d
cmpq %r14, %r9
ja 0x36d8
incq %rdi
cmpq %rax, %rdi
jne 0x36aa
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ctmeans/src/lib/nniter_kd.h
// Function: NNIterKD::set_point(double const*)
void set_point(const double* _x_beg) {
        x_beg = _x_beg;
        pq = KDPQ();
        pq.emplace(root, C, x_beg);
        heap_ops = 0;
        counter = 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
movq %rsi, 0x48(%rdi)
leaq 0x8(%rdi), %r15
movq 0x8(%rdi), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
testq %rdi, %rdi
je 0x38c3
callq 0x2130
leaq 0x40(%rbx), %rsi
leaq 0x28(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rcx
callq 0x3bd2
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ctmeans/src/lib/nniter_kd.h
// Function: KDHeapElem::KDHeapElem(KDNode const*, Matrix const&, double const*)
KDHeapElem(const KDNode* _kdnode, const Matrix& X, const double* p2):
        kdnode(_kdnode), point(kdnode->point) {
        if(_kdnode->left == nullptr && _kdnode->right == nullptr) {
            type = 'p';
            prio = point_point_norm(X.cols(), p2, X.begin_row(_kdnode->point));
        }
        else {
            type = 'k';
            prio = point_range_norm(X.cols(), p2, kdnode->cmin.data(), kdnode->cmax.data());
        }
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, (%rdi)
movl 0x4(%rsi), %eax
movl %eax, 0x8(%rdi)
cmpq $0x0, 0x10(%rsi)
jne 0x3e49
cmpq $0x0, 0x18(%rsi)
je 0x3e6a
movb $0x6b, 0xc(%rbx)
movl 0x4(%rdx), %edi
movq 0x20(%rsi), %rdx
movq 0x38(%rsi), %rax
movq %rcx, %rsi
movq %rax, %rcx
callq 0x617f
movsd %xmm0, 0x10(%rbx)
popq %rbx
retq
movb $0x70, 0xc(%rbx)
movl 0x4(%rdx), %edi
imull %edi, %eax
cltq
shlq $0x3, %rax
addq 0x10(%rdx), %rax
movq %rcx, %rsi
movq %rax, %rdx
callq 0x6154
jmp 0x3e63
nop
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ctmeans/src/lib/kdtree.h
// Function: KDNode::~KDNode()
~KDNode() {
        parent = nullptr;
        delete left;
        delete right;
        left = nullptr;
        right = nullptr;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
movq 0x10(%rdi), %r14
testq %r14, %r14
je 0x3f2d
movq %r14, %rdi
callq 0x3f04
movq %r14, %rdi
callq 0x2130
leaq 0x10(%rbx), %r15
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x3f4a
movq %r14, %rdi
callq 0x3f04
movq %r14, %rdi
callq 0x2130
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x3f5f
callq 0x2130
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x3f72
popq %rbx
popq %r14
popq %r15
jmp 0x2130
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ctmeans/src/lib/kdtree.cpp
// Function: get_kd_tree(Matrix const&)
KDNode* get_kd_tree(const Matrix& X) {
    std::vector<int> v;
    int n = X.rows();
    v.resize(n);
    for(int i=0; i<n; ++i) {
        v[i] = i;
    }
    return get_kd_tree(v.begin(), v.end(), X, 0, nullptr);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pxor %xmm0, %xmm0
movq %rsp, %rdi
movdqa %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movslq (%rbx), %r14
movq %r14, %rsi
callq 0x39f8
testl %r14d, %r14d
jle 0x50df
movq (%rsp), %rax
leal 0x1(%r14), %ecx
andl $-0x2, %ecx
decq %r14
movq %r14, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x2fd3(%rip), %xmm1     # 0x8040
xorl %edx, %edx
movdqa 0x2fd9(%rip), %xmm2     # 0x8050
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x3089(%rip), %xmm4     # 0x8110
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x50bc
movl %edx, (%rax,%rdx,4)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x50d2
leal 0x1(%rdx), %esi
movl %esi, 0x4(%rax,%rdx,4)
addq $0x2, %rdx
paddq %xmm4, %xmm1
cmpq %rdx, %rcx
jne 0x5087
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x512a
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5106
callq 0x2130
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5122
callq 0x2130
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ctmeans/src/lib/kdtree.cpp
// Function: KDNode::print_nl(_IO_FILE*) const
void KDNode::print_nl(FILE* fp) const {
    fprintf(fp, "KD(%d, min=", point);
    print(fp, cmin.cbegin(), cmin.cend());
    fprintf(fp, ", max=");
    print(fp, cmax.cbegin(), cmax.cend());
    fprintf(fp, ")\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rdi), %edx
leaq 0x2de0(%rip), %rsi      # 0x8120
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21f0
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rbx, %rdi
callq 0x54d6
leaq 0x2dcb(%rip), %rdi      # 0x812c
movl $0x6, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x22c0
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
movq %rbx, %rdi
callq 0x54d6
leaq 0x2da9(%rip), %rdi      # 0x8133
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22c0
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ctmeans/src/lib/kdtree.cpp
// Function: print_kd_tree(_IO_FILE*, KDNode const*, int)
void print_kd_tree(FILE* fp, const KDNode* root, int indent) {
    if(root != nullptr)
    {
        for(int i=0; i<indent; ++i) {
            fprintf(fp, "  ");
        }
        root->print_nl(fp);
        print_kd_tree(fp, root->left, indent+1);
        print_kd_tree(fp, root->right, indent+1);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2d7c(%rip), %r12      # 0x8136
testq %r14, %r14
je 0x53ff
movl %ebx, %ebp
testl %ebx, %ebx
jle 0x53de
movl $0x2, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rcx
callq 0x22c0
decl %ebp
jne 0x53c5
movq %r14, %rdi
movq %r15, %rsi
callq 0x532c
movq 0x10(%r14), %rsi
incl %ebx
movq %r15, %rdi
movl %ebx, %edx
callq 0x53a3
movq 0x18(%r14), %r14
jmp 0x53ba
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ctmeans/src/lib/vecio.h
// Function: void print<__gnu_cxx::__normal_iterator<double const*, std::vector<double, std::allocator<double>>>>(_IO_FILE*, __gnu_cxx::__normal_iterator<double const*, std::vector<double, std::allocator<double>>>, __gnu_cxx::__normal_iterator<double const*, std::vector<double, std::allocator<double>>>)
void print(FILE* fp, IterT begin, IterT end) {
    fprintf(fp, "[");
    if(begin != end)
    {
        fprintf(fp, "%lf", double(*begin));
        IterT it = begin; it++;
        for(; it != end; ++it) {
            fprintf(fp, ", %lf", double(*it));
        }
    }
    fprintf(fp, "]");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x5b, %edi
movq %rbx, %rsi
callq 0x21c0
cmpq %r14, %r15
je 0x553a
movsd (%r15), %xmm0
leaq 0x2c67(%rip), %rsi      # 0x816c
movq %rbx, %rdi
movb $0x1, %al
callq 0x21f0
addq $0x8, %r15
cmpq %r14, %r15
je 0x553a
leaq 0x2c4b(%rip), %r12      # 0x816a
movsd (%r15), %xmm0
movq %rbx, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x21f0
addq $0x8, %r15
cmpq %r14, %r15
jne 0x551f
movl $0x5d, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ctmeans/src/lib/matrix.cpp
// Function: Matrix::_init(int, int, bool)
void Matrix::_init(int _m, int _n, bool zero) {
    m = _m; n = _n, mn = _m * _n;
    if(mn) {
        if(zero) {
            a = (MatrixElemType*)(std::calloc(mn, sizeof(MatrixElemType)));
        }
        else {
            a = (MatrixElemType*)(std::malloc(mn * sizeof(MatrixElemType)));
        }
    }
    else {a = nullptr;}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
imull %esi, %edx
movl %edx, 0x8(%rdi)
testl %edx, %edx
je 0x5b6e
movslq %edx, %rdi
testb %cl, %cl
je 0x5b72
movl $0x8, %esi
callq 0x20b0
jmp 0x5b7b
xorl %eax, %eax
jmp 0x5b7b
shlq $0x3, %rdi
callq 0x21d0
movq %rax, 0x10(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ctmeans/src/lib/matrix.cpp
// Function: Matrix::_init(Matrix const&)
void Matrix::_init(const Matrix& X) {
    m = X.m; n = X.n, mn = X.mn;
    if(mn) {
        a = (MatrixElemType*)(std::malloc(mn * sizeof(MatrixElemType)));
        std::memcpy(a, X.a, mn * sizeof(MatrixElemType));
    }
    else {a = nullptr;}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rax, (%rdi)
movslq 0x8(%rsi), %r15
movl %r15d, 0x8(%rdi)
testq %r15, %r15
je 0x5bc4
movq %rsi, %rbx
shlq $0x3, %r15
movq %r15, %rdi
callq 0x21d0
movq %rax, 0x10(%r14)
movq 0x10(%rbx), %rsi
movq %rax, %rdi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x20f0
movq $0x0, 0x10(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ctmeans/src/lib/matrix.cpp
// Function: operator<<(std::ostream&, Matrix const&)
std::ostream& operator<<(std::ostream& os, const Matrix& X) {
    const char indent[] = "\t";
    int m = X.rows(), n = X.cols();
    for(int i=0; i<m; ++i) {
        os << X(i, 0);
        for(int j=1; j<n; ++j) {
            os << indent << X(i, j);
        }
        os << '\n';
    }
    return os;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movw $0x9, 0xe(%rsp)
movl (%rsi), %eax
movl %eax, 0x10(%rsp)
testl %eax, %eax
jle 0x5c93
movq %rsi, %r14
movl 0x4(%rsi), %r13d
xorl %edx, %edx
leaq 0xe(%rsp), %r15
movq 0x10(%r14), %rax
movslq 0x4(%r14), %rcx
movl %edx, 0x14(%rsp)
movslq %edx, %rbp
imulq %rbp, %rcx
movsd (%rax,%rcx,8), %xmm0
movq %rbx, %rdi
callq 0x2240
cmpl $0x2, %r13d
jl 0x5c6c
movl $0x1, %r12d
movq %r15, %rdi
callq 0x2080
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2170
movq 0x10(%r14), %rax
movslq 0x4(%r14), %rcx
imulq %rbp, %rcx
addq %r12, %rcx
movsd (%rax,%rcx,8), %xmm0
movq %rbx, %rdi
callq 0x2240
incq %r12
cmpl %r12d, %r13d
jne 0x5c32
movb $0xa, 0xd(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
leaq 0xd(%rsp), %rsi
callq 0x2170
movl 0x14(%rsp), %edx
incl %edx
cmpl 0x10(%rsp), %edx
jne 0x5c06
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ctmeans/src/lib/matrix.cpp
// Function: output(_IO_FILE*, Matrix const&)
void output(FILE* fp, const Matrix& X) {
    const char indent[] = "\t";
    int m = X.rows(), n = X.cols();
    for(int i=0; i<m; ++i) {
        std::fprintf(fp, "%lf", X(i, 0));
        for(int j=1; j<n; ++j) {
            std::fprintf(fp, "%s%lf", indent, X(i, j));
        }
        std::fprintf(fp, "\n");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movw $0x9, 0x6(%rsp)
movl (%rsi), %eax
movl %eax, 0x8(%rsp)
testl %eax, %eax
jle 0x5d80
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rsi), %r15d
xorl %edx, %edx
movq %rsi, 0x10(%rsp)
movq 0x10(%rbx), %rax
movslq 0x4(%rbx), %rcx
movl %edx, 0xc(%rsp)
movslq %edx, %rbp
imulq %rbp, %rcx
movsd (%rax,%rcx,8), %xmm0
movq %r14, %rdi
leaq 0x2471(%rip), %rsi      # 0x816c
movb $0x1, %al
callq 0x21f0
cmpl $0x2, %r15d
leaq 0x2463(%rip), %rsi      # 0x8170
leaq 0x6(%rsp), %rdx
jl 0x5d63
movl $0x1, %r12d
movq 0x10(%rbx), %rax
movslq 0x4(%rbx), %rcx
imulq %rbp, %rcx
addq %r12, %rcx
movsd (%rax,%rcx,8), %xmm0
movq %r14, %rdi
movq %rsi, %r13
movb $0x1, %al
movq %rbp, %rbx
movq %r15, %rbp
movq %r14, %r15
movq %rdx, %r14
callq 0x21f0
movq %r14, %rdx
movq %r15, %r14
movq %rbp, %r15
movq %rbx, %rbp
movq 0x10(%rsp), %rbx
movq %r13, %rsi
incq %r12
cmpl %r12d, %r15d
jne 0x5d1a
movl $0xa, %edi
movq %r14, %rsi
callq 0x21c0
movl 0xc(%rsp), %edx
incl %edx
cmpl 0x8(%rsp), %edx
jne 0x5cd9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ctmeans/src/lib/matrix.cpp
// Function: savetxt(char const*, Matrix const&)
void savetxt(const char* fname, const Matrix& X) {
    FILE* fp = fopen(fname, "w");
    if(fp == NULL) {
        fprintf(stderr, "Couldn't open %s\n", fname);
        perror("savetxt");
    }
    else {
        output(fp, X);
        fclose(fp);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x23d5(%rip), %rsi      # 0x8176
callq 0x2180
testq %rax, %rax
je 0x5dc6
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5ca5
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2150
movq %r14, %rdi
callq 0x239f
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ctmeans/src/lib/matrix.cpp
// Function: loadtxt(char const*, Matrix&)
void loadtxt(const char* fname, Matrix& X) {
    FILE* fp = fopen(fname, "r");
    if(fp == NULL) {
        fprintf(stderr, "Couldn't open %s\n", fname);
        perror("loadtxt");
    }
    else {
        input(fp, X);
        fclose(fp);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2365(%rip), %rsi      # 0x8192
callq 0x2180
testq %rax, %rax
je 0x5e7a
movq %rax, %rbx
movslq 0x8(%r14), %r12
testq %r12, %r12
jle 0x5e67
movq 0x10(%r14), %r14
leaq 0x231e(%rip), %r15      # 0x816c
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x22a0
addq $0x8, %r14
decq %r12
jne 0x5e4e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2150
movq %r15, %rdi
callq 0x23c8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ctmeans/src/lib/nniter.cpp
// Function: NNIterSort::set_point(double const*)
void NNIterSort::set_point(const MatrixElemType* _x_beg) {
    x_beg = _x_beg;
    counter = 0;
    for(int i=0; i<c; ++i) {
        norms[i].second = i;
        double dist = 0;
        for(int j=0; j<d; ++j) {
            dist += (x_beg[j] - C(i, j)) * (x_beg[j] - C(i, j));
        }
        norms[i].first = dist;
    }
    // std::sort(norms.begin(), norms.end());
    std::make_heap(norms.begin(), norms.end(), std::greater<dipair>());
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x28(%rdi)
movl $0x0, 0x8(%rdi)
movslq (%rdi), %rax
testq %rax, %rax
jle 0x5f02
movq 0x30(%rdi), %rcx
movl 0x4(%rdi), %edx
movq 0x20(%rdi), %r8
movslq 0x14(%rdi), %r9
shlq $0x3, %r9
xorl %r10d, %r10d
movq %r10, %r11
shlq $0x4, %r11
movl %r10d, 0x8(%rcx,%r11)
xorpd %xmm0, %xmm0
testl %edx, %edx
jle 0x5eef
xorl %ebx, %ebx
movsd (%rsi,%rbx,8), %xmm1
subsd (%r8,%rbx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rbx
cmpq %rbx, %rdx
jne 0x5ed4
addq %rcx, %r11
movsd %xmm0, (%r11)
incq %r10
addq %r9, %r8
cmpq %rax, %r10
jne 0x5ebe
movq 0x30(%rdi), %rax
movq 0x38(%rdi), %rsi
leaq 0xf(%rsp), %rdx
movq %rax, %rdi
callq 0x5f9b
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ctmeans/src/lib/nniter.cpp
// Function: NNIterSort::get_neighbor()
typename NNIterSort::dipair NNIterSort::get_neighbor() {
    if(counter >= c) {
        fprintf(stderr, "NNIterSort: counter overflow\n");
    }
    // return norms[counter++];
    std::pop_heap(norms.begin(), norms.end() - counter, std::greater<dipair>());
    return norms[c - (++counter)];
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl (%rdi), %eax
jge 0x5f94
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rax
movslq 0x8(%rbx), %rcx
shlq $0x4, %rcx
subq %rcx, %rax
movq %rax, %rcx
subq %rdi, %rcx
cmpq $0x11, %rcx
jl 0x5f71
leaq -0x10(%rax), %rdx
movsd -0x10(%rax), %xmm0
movl -0x8(%rax), %ecx
movsd (%rdi), %xmm1
movsd %xmm1, -0x10(%rax)
movl 0x8(%rdi), %esi
movl %esi, -0x8(%rax)
subq %rdi, %rdx
sarq $0x4, %rdx
xorl %esi, %esi
callq 0x600a
movslq (%rbx), %rax
movslq 0x8(%rbx), %rcx
incq %rcx
movl %ecx, 0x8(%rbx)
subq %rcx, %rax
movq 0x30(%rbx), %rcx
shlq $0x4, %rax
movsd (%rcx,%rax), %xmm0
movl 0x8(%rcx,%rax), %eax
popq %rbx
retq
callq 0x23f1
jmp 0x5f29
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ctmeans/src/lib/nniter_kd.cpp
// Function: point_point_norm(int, double const*, double const*)
double point_point_norm(int d, const double* p1, const double* p2) {
    double res = 0;
    for(int j=0; j<d; ++j) {
        double p = p1[j] - p2[j];
        res += p*p;
    }
    return res;
}

// Assembly:
testl %edi, %edi
jle 0x617b
movl %edi, %eax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
movsd (%rsi,%rcx,8), %xmm1
subsd (%rdx,%rcx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x6160
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ctmeans/src/lib/nniter_kd.cpp
// Function: point_range_norm(int, double const*, double const*, double const*)
double point_range_norm(int d, const double* p, const double* rmin, const double* rmax) {
    double res = 0;
    for(int j=0; j<d; ++j) {
        double p1 = rmin[j] - p[j];
        if(p1 > 0) {
            res += p1*p1;
        }
        else {
            double p3 = p[j] - rmax[j];
            if(p3 > 0) {
                res += p3*p3;
            }
        }
    }
    return res;
}

// Assembly:
testl %edi, %edi
jle 0x61e0
movl %edi, %eax
xorpd %xmm1, %xmm1
xorl %edi, %edi
xorpd %xmm0, %xmm0
movsd (%rdx,%rdi,8), %xmm3
movsd (%rsi,%rdi,8), %xmm2
subsd %xmm2, %xmm3
ucomisd %xmm1, %xmm3
jbe 0x61ad
mulsd %xmm3, %xmm3
addsd %xmm3, %xmm0
jmp 0x61d7
subsd (%rcx,%rdi,8), %xmm2
movapd %xmm2, %xmm3
mulsd %xmm2, %xmm3
addsd %xmm0, %xmm3
xorpd %xmm4, %xmm4
cmpltsd %xmm2, %xmm4
andpd %xmm4, %xmm3
andnpd %xmm0, %xmm4
orpd %xmm3, %xmm4
movapd %xmm4, %xmm0
incq %rdi
cmpq %rdi, %rax
jne 0x618f
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ctmeans/src/lib/nniter_kd.cpp
// Function: NNIterKD::get_neighbor_node()
KDHeapElem NNIterKD::get_neighbor_node() {
    if(pq.empty()) {
        std::fprintf(stderr, "NNIterKD: No neighbors left\n");
    }
    KDHeapElem top(pq.top());
    pq.pop();
    if(top.type == 'k') {
        pq.emplace(top.point, C, x_beg);
        if(top.kdnode->left != nullptr) {
            pq.emplace(top.kdnode->left, C, x_beg);
        }
        if(top.kdnode->right != nullptr) {
            pq.emplace(top.kdnode->right, C, x_beg);
        }
    }
    else if(top.type == 'p') {
        counter++;
    }
    heap_ops++;
    return top;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsi), %r15
movq 0x8(%rsi), %rax
cmpq 0x10(%rsi), %rax
je 0x6294
movq (%r15), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r14)
movups (%rax), %xmm0
movups %xmm0, (%r14)
movq %r15, %rdi
callq 0x62e0
movzbl 0xc(%r14), %eax
cmpl $0x70, %eax
je 0x6282
cmpl $0x6b, %eax
jne 0x6285
leaq 0x8(%r14), %rsi
leaq 0x28(%rbx), %r12
leaq 0x48(%rbx), %r13
movq %r15, %rdi
movq %r12, %rdx
movq %r13, %rcx
callq 0x635a
movq (%r14), %rsi
cmpq $0x0, 0x10(%rsi)
je 0x6264
addq $0x10, %rsi
movq %r15, %rdi
movq %r12, %rdx
movq %r13, %rcx
callq 0x6420
movq (%r14), %rsi
cmpq $0x0, 0x18(%rsi)
je 0x6285
addq $0x18, %rsi
movq %r15, %rdi
movq %r12, %rdx
movq %r13, %rcx
callq 0x6420
jmp 0x6285
incl 0x4(%rbx)
incl (%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x240d
jmp 0x6205
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ctmeans/src/lib/nniter_kd.cpp
// Function: NNIterKD::get_neighbor()
std::pair<double, int> NNIterKD::get_neighbor() {
    if(pq.empty()) {
        std::fprintf(stderr, "NNIterKD: No neighbors left\n");
    }
    KDHeapElem heap_elem;
    do {
        heap_elem = get_neighbor_node();
    } while(heap_elem.type != 'p');
    return std::pair<double, int>(heap_elem.prio, heap_elem.point);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x62d9
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x61e4
cmpb $0x70, 0xc(%rsp)
jne 0x62b5
movl 0x8(%rsp), %eax
movsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x2429
jmp 0x62b2
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ctmeans/src/main.cpp
// Function: output_vec_vec_to_file(char const*, char const*, int, int, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&)
double output_vec_vec_to_file(const char* fname, const char* name, int n, int c, const vector<vector<int> >& V) {
    long long sum = 0;
    int count = 0;
    FILE* fp = fopen(fname, "w");
    for(const vector<int>& v: V) {
        if(v.size() > 0) {
            count += v.size();
            sum += v[0];
            fprintf(fp, "%lf", double(v[0])/n);
            for(unsigned i=1; i<v.size(); ++i) {
                sum += v[i];
                fprintf(fp, " %lf", double(v[i])/n);
            }
        }
        fprintf(fp, "\n");
    }
    fclose(fp);
    return double(sum) / count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movl %edx, %ebp
leaq 0x17b3(%rip), %rsi      # 0x8176
callq 0x2180
movq %rax, %rbx
movq (%r14), %r12
movq 0x8(%r14), %r13
cmpq %r13, %r12
je 0x6ac1
cvtsi2sd %ebp, %xmm1
xorl %ebp, %ebp
leaq 0x1783(%rip), %r15      # 0x816b
xorl %r14d, %r14d
movsd %xmm1, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq (%r12), %rax
movq 0x8(%r12), %rcx
subq %rax, %rcx
je 0x6a8f
shrq $0x2, %rcx
addl %ecx, %r14d
movslq (%rax), %rax
addq %rax, %rbp
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd %xmm1, %xmm0
movq %rbx, %rdi
leaq 0x1742(%rip), %rsi      # 0x816c
movb $0x1, %al
callq 0x21f0
movq (%r12), %rax
movq 0x8(%r12), %rcx
subq %rax, %rcx
cmpq $0x5, %rcx
jb 0x6a8f
movl $0x1, %ecx
movl $0x2, %r13d
movslq (%rax,%rcx,4), %rax
addq %rax, %rbp
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x21f0
movl %r13d, %ecx
movq (%r12), %rax
movq 0x8(%r12), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
incl %r13d
cmpq %rcx, %rdx
ja 0x6a4e
movq 0x10(%rsp), %r13
movl $0xa, %edi
movq %rbx, %rsi
callq 0x21c0
addq $0x18, %r12
cmpq %r13, %r12
movsd 0x8(%rsp), %xmm1
jne 0x69f6
xorps %xmm1, %xmm1
cvtsi2sd %rbp, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
jmp 0x6ac9
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq %rbx, %rdi
callq 0x2150
movsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ctmeans/src/lib/vecio.h
// Function: void savetxt<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>(char const*, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>)
void savetxt(const char* fname, IterT begin, IterT end) {
    FILE* fp = fopen(fname, "w");
    if(fp == NULL) {
        fprintf(stderr, "Couldn't open %s\n", fname);
        perror("savetxt");
    }
    else {
        output(fp, begin, end);
        fclose(fp);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0xb82(%rip), %rsi       # 0x8176
callq 0x2180
testq %rax, %rax
je 0x7639
movq %rax, %r15
cmpq %rbx, %r14
je 0x7626
leaq 0xa6b(%rip), %r12       # 0x8078
movl (%r14), %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x21f0
addq $0x4, %r14
cmpq %rbx, %r14
jne 0x760d
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2150
movq %r12, %rdi
callq 0x255b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH03_StringsVectorsAndArrays/examples/string_size2.cc
// Function: main
int main() 
{
	string line;

	// read input a line at a time and print lines that are longer than 80 characters
	while (getline(cin, line))
		if (line.size() > 80)
			cout << line << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movq 0x2db7(%rip), %rbx      # 0x3fe0
leaq -0x48(%rbp), %r14
movq 0x2d9c(%rip), %r15      # 0x3fd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x12a6
movq -0x40(%rbp), %rdx
cmpq $0x51, %rdx
jb 0x1234
movq -0x48(%rbp), %rsi
movq %r15, %rdi
callq 0x1080
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r12, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
jmp 0x1234
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x12bb
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x1070
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x12e4
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x1070
movq %rbx, %rdi
callq 0x10a0