LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/SeTriones[P]Anubis/acceptor.cpp
// Function: acceptor::del_input_fd(int, int)
int acceptor::del_input_fd(int fd, int efd) {
	epoll_event event;
	event.events = EPOLLIN | EPOLLET;
	event.data.fd = fd;
	int ret = epoll_ctl(efd, EPOLL_CTL_DEL, fd, &event);
	if (ret < 0) {
		_ERROR("del_input_fd err,fd=%d,errno=%d", fd, errno);
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movl %edx, %edi
movl %esi, %ebx
leaq 0x14(%rsp), %rcx
movl $0x80000001, (%rcx)     # imm = 0x80000001
movl %esi, 0x4(%rcx)
pushq $0x2
popq %rsi
movl %ebx, %edx
callq 0x22d0
movl %eax, %ebp
testl %eax, %eax
js 0x2c8b
movl %ebp, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x21d0
leaq 0x38(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2100
leaq 0x3355(%rip), %rdx      # 0x6004
leaq 0x20(%rsp), %r14
pushq $0x12
popq %rsi
movq %r14, %rdi
movq %r15, %rcx
callq 0x2180
movq 0x730f(%rip), %rax      # 0x9fd8
movq (%rax), %r15
callq 0x21b0
movq %rax, %r12
callq 0x2040
movl (%rax), %eax
movl %eax, (%rsp)
leaq 0x33f1(%rip), %rsi      # 0x60d6
leaq 0x348f(%rip), %r8       # 0x617b
movq %r15, %rdi
movq %r14, %rdx
movq %r12, %rcx
movl %ebx, %r9d
xorl %eax, %eax
callq 0x22e0
jmp 0x2c7c
// File: /workspace/github_cpp_makefile_star2_O2/SeTriones[P]Anubis/acceptor.cpp
// Function: acceptor::create_pipe(int)
int acceptor::create_pipe(int idx) {
	int options;
	int pipe_fd[2];
	
	if (pipe(pipe_fd)) {
		return -1;
	}

	pipe_read_fds[idx] = pipe_fd[0];
	pipe_write_fds[idx] = pipe_fd[1];

	for (int i = 0;i < 2;i++) {
		if ((options = fcntl(pipe_fd[i], F_GETFL)) == -1) {
			return -1;
		}
		if (fcntl(pipe_fd[i], F_SETFL, options | O_NONBLOCK) == -1) {
			return -1;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x22b0
testl %eax, %eax
je 0x2d30
pushq $-0x1
popq %rax
jmp 0x2d99
movl 0x8(%rsp), %eax
movq 0x90(%rbx), %rcx
movslq %ebp, %rdx
movl %eax, (%rcx,%rdx,4)
movl 0xc(%rsp), %eax
movq 0x98(%rbx), %rcx
movl %eax, (%rcx,%rdx,4)
pushq $0x3
popq %rbx
pushq $0x4
popq %rbp
xorl %ecx, %ecx
movq %rcx, %r14
cmpq $0x2, %rcx
je 0x2d91
movl 0x8(%rsp,%r14,4), %edi
movl %ebx, %esi
xorl %eax, %eax
callq 0x2120
cmpl $-0x1, %eax
je 0x2d91
movl 0x8(%rsp,%r14,4), %edi
orl $0x800, %eax            # imm = 0x800
movl %ebp, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x2120
leaq 0x1(%r14), %rcx
cmpl $-0x1, %eax
jne 0x2d57
xorl %eax, %eax
cmpq $0x2, %r14
sbbl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/SeTriones[P]Anubis/base_nio_handler.cpp
// Function: base_nio_handler::readn_timeout(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int)
int base_nio_handler::readn_timeout(int fd, std::string &content, int buf_len) {
    char buf[READ_BUF_SIZE+1];
    timeval timeout = {
        0,
        recv_timeout * 1000
    };
    int n,len;
    int left = buf_len;

    while (left > 0)
    {
        len = left>READ_BUF_SIZE?READ_BUF_SIZE:left;
        if ((n = read_data(fd, buf, len,&timeout)) <= 0)
            return buf_len - left;

        buf[n] = '\0';
        content += buf;
        left -= n;
    }

    return buf_len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp            # imm = 0x428
movl %ecx, %ebx
movq %rdx, %r14
leaq 0x10(%rsp), %r15
andq $0x0, (%r15)
movl %esi, %ebp
movslq (%rdi), %rax
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
movq %rax, 0x8(%r15)
leaq 0x20(%rsp), %r12
movl %ecx, 0xc(%rsp)
testl %ebx, %ebx
jle 0x2e1a
movl $0x400, %eax            # imm = 0x400
cmpl %eax, %ebx
movl $0x400, %ecx            # imm = 0x400
cmovbl %ebx, %ecx
movl %ebp, %esi
movq %r12, %rdx
movq %r15, %r8
callq 0x2e38
testl %eax, %eax
jle 0x2e20
movl %eax, %r13d
movl %eax, %eax
movb $0x0, 0x20(%rsp,%rax)
movq %r14, %rdi
movq %r12, %rsi
callq 0x23e0
subl %r13d, %ebx
jmp 0x2ddc
movl 0xc(%rsp), %eax
jmp 0x2e26
movl 0xc(%rsp), %eax
subl %ebx, %eax
addq $0x428, %rsp            # imm = 0x428
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/SeTriones[P]Anubis/base_nio_handler.cpp
// Function: base_nio_handler::readn_timeout(int, char*, int, timeval*)
int base_nio_handler::readn_timeout(int fd, char* content, int need_to_read, timeval* timeout) {
	char buf[READ_BUF_SIZE + 1];
	int n, left;
	int len;
    int ptr = 0;
	left = need_to_read;
	while (left > 0) {
		len = left > READ_BUF_SIZE ? READ_BUF_SIZE : left;
		n = read_data(fd, buf, len, timeout);
		if (n <= 0 ) {
			if(n == 0)
				return -2;
			return need_to_read - left;
		}
		buf[n] = '\0';
        memcpy(content + ptr, buf, len);
        ptr = ptr + n;
		left = left - n;
	}
	return need_to_read;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp            # imm = 0x428
movq %r8, 0x18(%rsp)
movl %ecx, %r14d
movq %rdx, 0x10(%rsp)
movl %esi, %ebp
xorl %r15d, %r15d
leaq 0x20(%rsp), %r12
movl %ecx, 0xc(%rsp)
testl %r14d, %r14d
jle 0x31ec
movl $0x400, %eax            # imm = 0x400
cmpl %eax, %r14d
movl $0x400, %ebx            # imm = 0x400
cmovbl %r14d, %ebx
movl %ebp, %esi
movq %r12, %rdx
movl %ebx, %ecx
movq 0x18(%rsp), %r8
callq 0x2e38
movl %eax, %r13d
testl %eax, %eax
jle 0x31f2
movl %r13d, %eax
movb $0x0, 0x20(%rsp,%rax)
movl %r15d, %edi
addq 0x10(%rsp), %rdi
movl %ebx, %edx
movq %r12, %rsi
callq 0x2190
addl %r13d, %r15d
subl %r13d, %r14d
jmp 0x319c
movl 0xc(%rsp), %eax
jmp 0x3202
movl 0xc(%rsp), %eax
subl %r14d, %eax
testl %r13d, %r13d
pushq $-0x2
popq %rcx
cmovel %ecx, %eax
addq $0x428, %rsp            # imm = 0x428
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/SeTriones[P]Anubis/base_nio_handler.cpp
// Function: base_nio_handler::setSocket(int&)
int base_nio_handler::setSocket(int& fd) {
    if (fd <= 0) {
        _ERROR("error socket fd=%d", fd);
        return -1;
    }
    int options;
    options = SOCKET_SND_BUF_SIZE;
    setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &options, sizeof(int));
    options = SOCKET_RCV_BUF_SIZE;
    setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &options, sizeof(int));
    options = 1;
    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &options, sizeof(int));
    options = fcntl(fd, F_GETFL);
    fcntl(fd, F_SETFL, options | O_NONBLOCK);
    int on = 1;
    int ret = -1;
    ret = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&on, sizeof(on));
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movl (%rsi), %edi
testl %edi, %edi
jle 0x352f
movl $0x100000, %r12d        # imm = 0x100000
leaq 0x28(%rsp), %r15
movl %r12d, (%r15)
pushq $0x1
popq %rbp
pushq $0x7
popq %rdx
pushq $0x4
popq %r14
movl %ebp, %esi
movq %r15, %rcx
movl %r14d, %r8d
callq 0x23b0
movl %r12d, (%r15)
movl (%rbx), %edi
pushq $0x8
popq %rdx
movl %ebp, %esi
movq %r15, %rcx
movl %r14d, %r8d
callq 0x23b0
movl %ebp, (%r15)
movl (%rbx), %edi
pushq $0x2
popq %rdx
movl %ebp, %esi
movq %r15, %rcx
movl %r14d, %r8d
callq 0x23b0
movl (%rbx), %edi
pushq $0x3
popq %rsi
xorl %eax, %eax
callq 0x2120
movl %eax, (%r15)
movl (%rbx), %edi
orl $0x800, %eax            # imm = 0x800
movl %r14d, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x2120
leaq 0x10(%rsp), %rcx
movl %ebp, (%rcx)
movl (%rbx), %edi
pushq $0x6
popq %rsi
movl %ebp, %edx
movl %r14d, %r8d
callq 0x23b0
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x21d0
leaq 0x28(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2100
leaq 0x2ab1(%rip), %rdx      # 0x6004
leaq 0x10(%rsp), %r14
pushq $0x12
popq %rsi
movq %r14, %rdi
movq %r15, %rcx
callq 0x2180
movq 0x6a6b(%rip), %rax      # 0x9fd8
movq (%rax), %r15
callq 0x21b0
movl (%rbx), %r9d
leaq 0x2c60(%rip), %rsi      # 0x61df
leaq 0x2bf5(%rip), %r8       # 0x617b
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x22e0
pushq $-0x1
popq %rax
jmp 0x3522
nop
// File: /workspace/github_cpp_makefile_star2_O2/SeTriones[P]Anubis/key_group.cpp
// Function: KeyGroup::KeyGroup(int)
KeyGroup::KeyGroup(int _capacity) {
	capacity = _capacity;
	cache = new LRUCache(capacity);
	store = (int*)malloc(sizeof(int) * capacity);
	memset(store, 0, sizeof(int) * capacity);
	for (int i = 0; i < capacity; i++) {
		free_poses.push_back(i);
	}
	pthread_mutex_init(&group_mutex, NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, 0x20(%rdi)
movq %rbx, 0x18(%rdi)
andq $0x0, 0x28(%rdi)
movl %esi, (%rdi)
pushq $0x40
popq %rdi
callq 0x21e0
movq %rax, %r15
movq %rax, %rdi
movl %ebp, %esi
callq 0x3bd4
movq %r15, 0x10(%r14)
movslq (%r14), %r12
movq %r12, %rsi
shlq $0x2, %rsi
pushq $0x1
popq %rdi
callq 0x2140
movq %rax, 0x8(%r14)
xorl %eax, %eax
leaq 0xc(%rsp), %r15
movl %eax, 0xc(%rsp)
cmpl %r12d, %eax
jge 0x3891
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3ac0
movl 0xc(%rsp), %eax
incl %eax
movl (%r14), %r12d
jmp 0x3872
addq $0x30, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x2320
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
pushq $0x40
popq %rsi
movq %r15, %rdi
callq 0x21f0
jmp 0x38c1
jmp 0x38be
movq %rax, %r14
movq %rbx, %rdi
callq 0x3ad4
movq %r14, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/SeTriones[P]Anubis/key_group.cpp
// Function: KeyGroup::Inc(unsigned long)
int KeyGroup::Inc(uint64_t key) {
	int ret;
	pthread_mutex_lock(&group_mutex);
	int* pos = cache->get(key);
	if (pos == NULL) {
		if (free_poses.empty()) {
			_INFO("no free pos");
			pos = NULL;
		} else {
			int idx = free_poses.front();
			free_poses.pop_front();
			pos = store + idx;
		}
		pos = cache->set(key, pos, 0);
		*pos = 1;
		pthread_mutex_unlock(&group_mutex);
		return 1;
	} else {
		pthread_mutex_unlock(&group_mutex);
		ret = __sync_add_and_fetch(pos, 1);
		return ret;
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x30(%rdi), %rbx
movq %rbx, %rdi
callq 0x2310
movq 0x10(%r15), %rdi
movq %r14, %rsi
callq 0x3c4c
testq %rax, %rax
je 0x3963
movq %rax, %r12
movq %rbx, %rdi
callq 0x2160
pushq $0x1
popq %rax
lock
xaddl %eax, (%r12)
incl %eax
jmp 0x39a3
leaq 0x18(%r15), %rdi
movq 0x18(%r15), %rax
cmpq %rdi, %rax
je 0x39b2
movslq 0x10(%rax), %r12
callq 0x3acc
shlq $0x2, %r12
addq 0x8(%r15), %r12
movq 0x10(%r15), %rdi
movq %r14, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x3c96
movl $0x1, (%rax)
movq %rbx, %rdi
callq 0x2160
pushq $0x1
popq %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x21d0
leaq 0x30(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x2100
leaq 0x262e(%rip), %rdx      # 0x6004
leaq 0x10(%rsp), %rbp
pushq $0x12
popq %rsi
movq %rbp, %rdi
movq %r13, %rcx
callq 0x2180
movq 0x65e8(%rip), %rax      # 0x9fd8
movq (%rax), %r13
callq 0x21b0
leaq 0x2900(%rip), %rsi      # 0x62ff
leaq 0x2775(%rip), %r8       # 0x617b
xorl %r12d, %r12d
movq %r13, %rdi
movq %rbp, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x22e0
jmp 0x3981
// File: /workspace/github_cpp_makefile_star2_O2/SeTriones[P]Anubis/lru_cache.cpp
// Function: LRUCache::get(unsigned long)
int* LRUCache::get(uint64_t key){
	std::tr1::unordered_map<uint64_t, struct HashItem>::iterator it;
	it = hash.find(key);
	if (it == hash.end()) {
		return NULL;
	}
	mv_node_to_header(list, it->second.node, 0);
	return it->second.pos;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rax
movq %rsi, (%rax)
addq $0x10, %rdi
movq %rax, %rsi
callq 0x3da6
movq %rax, %r14
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
cmpq (%rax,%rcx,8), %r14
je 0x3c8b
movq 0x8(%rbx), %rdi
movq 0x8(%r14), %rsi
xorl %edx, %edx
callq 0x256d
movq 0x10(%r14), %rax
jmp 0x3c8d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
leaq 0x10(%rdi), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x3da6
movq 0x18(%r14), %rcx
movq 0x20(%r14), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0x3ce8
testl %ebp, %ebp
je 0x3cd7
movq %rbx, 0x10(%rax)
movq 0x8(%r14), %rdi
movq 0x8(%rax), %rsi
xorl %edx, %edx
callq 0x256d
jmp 0x3d67
movl (%r14), %eax
cmpl 0x4(%r14), %eax
jne 0x3d22
movq 0x8(%r14), %rdi
callq 0x2678
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x3da6
movq 0x10(%rax), %rbx
movq %r15, %rdi
movq %rax, %rsi
callq 0x3df4
movq %r12, %rdi
callq 0x2250
decl (%r14)
callq 0x2562
movq %rax, %r12
movq 0x8(%rsp), %rax
movq %rax, (%r12)
movq 0x8(%r14), %rdi
pushq $0x1
popq %rdx
movq %r12, %rsi
callq 0x256d
movq 0x8(%rsp), %rax
leaq 0x28(%rsp), %rdx
movq %rax, (%rdx)
movq %r12, 0x8(%rdx)
movq %rbx, 0x10(%rdx)
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x40b4
incl (%r14)
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/SeTriones[P]Anubis/main.cpp
// Function: testKeyGroup()
void testKeyGroup() {
	KeyGroup* kg = new KeyGroup(10);
	kg->dump();
	int cnt;
	for (int i = 0; i < 10; i++) {
		for (int inc_cnt = 0; inc_cnt <= i; inc_cnt++) {
			cnt = kg->Inc((uint64_t)i);
			_INFO("inc %d,get %d", i, cnt);
		}
	}
	for (int i = 0; i < 100; i++) {
		kg->Inc(1);
		kg->Inc(2);
		kg->Inc(3);
		kg->Inc(4);
	}
	kg->dump();
	for (int i = 0; i < 5; i++) {
		for (int inc_cnt = 0; inc_cnt < i + 10; inc_cnt++) {
			int tmp = i + 20;
			cnt = kg->Inc((uint64_t)tmp);
			_INFO("inc %d,get %d", tmp, cnt);
		}
	}
	kg->dump();
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
pushq $0x58
popq %rdi
callq 0x21e0
movq %rax, %rbx
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x3818
movq %rbx, %rdi
callq 0x3a1e
pushq $0x1
popq %r15
xorl %r12d, %r12d
cmpq $0xa, %r12
je 0x4497
movl %r15d, 0xc(%rsp)
subl $0x1, %r15d
jb 0x4487
movq %rbx, %rdi
movq %r12, %rsi
callq 0x391a
movl %eax, %ebp
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x21d0
movq %r14, %rdi
leaq 0x40(%rsp), %r14
movq %r14, %rsi
callq 0x2100
leaq 0x20(%rsp), %r13
movq %r13, %rdi
pushq $0x12
popq %rsi
leaq 0x1bba(%rip), %rdx      # 0x6004
movq %r14, %rcx
callq 0x2180
movq 0x5b7f(%rip), %rax      # 0x9fd8
movq (%rax), %r14
callq 0x21b0
movl %ebp, (%rsp)
movq %r14, %rdi
leaq 0x1ef6(%rip), %rsi      # 0x6364
movq %r13, %rdx
movq %rax, %rcx
leaq 0x1d00(%rip), %r8       # 0x617b
movl %r12d, %r9d
xorl %eax, %eax
callq 0x22e0
jmp 0x4408
incq %r12
movl 0xc(%rsp), %r15d
incl %r15d
jmp 0x43f9
pushq $0x64
popq %rbp
pushq $0x1
popq %r14
pushq $0x2
popq %r15
pushq $0x3
popq %r12
pushq $0x4
popq %r13
movq %rbx, %rdi
subl $0x1, %ebp
jb 0x44dd
movq %r14, %rsi
callq 0x391a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x391a
movq %rbx, %rdi
movq %r12, %rsi
callq 0x391a
movq %rbx, %rdi
movq %r13, %rsi
callq 0x391a
jmp 0x44aa
callq 0x3a1e
xorl %eax, %eax
pushq $0xa
popq %r13
cmpq $0x5, %rax
je 0x45a1
movq %rax, 0x10(%rsp)
leaq 0x14(%rax), %r12
movl %r13d, 0xc(%rsp)
subl $0x1, %r13d
jb 0x458c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x391a
movl %eax, %ebp
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x21d0
movq %r14, %rdi
leaq 0x40(%rsp), %r14
movq %r14, %rsi
callq 0x2100
movq %rbx, %r15
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
pushq $0x12
popq %rsi
leaq 0x1abb(%rip), %rdx      # 0x6004
movq %r14, %rcx
callq 0x2180
movq 0x5a80(%rip), %rax      # 0x9fd8
movq (%rax), %r14
callq 0x21b0
movl %ebp, (%rsp)
movq %r14, %rdi
leaq 0x1df7(%rip), %rsi      # 0x6364
movq %rbx, %rdx
movq %r15, %rbx
movq %rax, %rcx
leaq 0x1bfe(%rip), %r8       # 0x617b
movl %r12d, %r9d
xorl %eax, %eax
callq 0x22e0
jmp 0x4500
movq 0x10(%rsp), %rax
incq %rax
movl 0xc(%rsp), %r13d
incl %r13d
jmp 0x44e8
movq %rbx, %rdi
callq 0x3a1e
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
pushq $0x58
popq %rsi
movq %rbx, %rdi
callq 0x21f0
movq %r14, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x52fc
leaq 0x40(%rbx), %r14
movq %r14, %rdi
movl %r13d, %esi
movl %r12d, %edx
callq 0x269c
leaq 0x546d(%rip), %rax      # 0x9ca8
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)
xorl %r13d, %r13d
pushq $0x58
popq %r15
movslq %ebp, %rax
cmpq %rax, %r13
jge 0x48a3
movq %r15, %rdi
callq 0x21e0
movq %rax, %r12
movl 0xf0(%rbx), %esi
movq %rax, %rdi
callq 0x3818
movq 0xf8(%rbx), %rax
movq %r12, (%rax,%r13,8)
incq %r13
movl 0xec(%rbx), %ebp
jmp 0x486c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x48d2
movq %rax, %r15
pushq $0x58
popq %rsi
movq %r12, %rdi
callq 0x21f0
jmp 0x48ca
movq %rax, %r15
movq %r14, %rdi
callq 0x2866
movq %rbx, %rdi
callq 0x530e
movq %r15, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x68, %rsp
movl %esi, %ebp
movq %rdi, %r14
leaq 0x40(%rdi), %r15
xorl %ebx, %ebx
movslq 0x44(%r14), %rax
cmpq %rax, %rbx
jge 0x49a4
movl 0x40(%r14), %edi
callq 0x23d0
movq 0x50(%r14), %rcx
movl %eax, (%rcx,%rbx,4)
cmpl $-0x1, %eax
je 0x49ff
incq %rbx
jmp 0x4981
xorl %ebx, %ebx
movslq %eax, %rcx
cmpq %rcx, %rbx
jge 0x49e2
movq %r15, %rdi
movl %ebx, %esi
callq 0x2d10
testl %eax, %eax
js 0x4a4e
movq 0x50(%r14), %rax
movq 0xd0(%r14), %rcx
movl (%rcx,%rbx,4), %esi
movl (%rax,%rbx,4), %edx
movq %r15, %rdi
callq 0x29c8
incq %rbx
movl 0x44(%r14), %eax
jmp 0x49a6
imull %ebp, %eax
movslq %eax, %rsi
movl $0x40000, %edx          # imm = 0x40000
movq %r14, %rdi
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x532a
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x21d0
leaq 0x30(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2100
leaq 0x15e1(%rip), %rdx      # 0x6004
leaq 0x10(%rsp), %r14
pushq $0x12
popq %rsi
movq %r14, %rdi
movq %r15, %rcx
callq 0x2180
movq 0x559b(%rip), %rax      # 0x9fd8
movq (%rax), %r15
callq 0x21b0
leaq 0x19dd(%rip), %rsi      # 0x6429
jmp 0x4a9b
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x21d0
leaq 0x30(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2100
leaq 0x1592(%rip), %rdx      # 0x6004
leaq 0x10(%rsp), %r14
pushq $0x12
popq %rsi
movq %r14, %rdi
movq %r15, %rcx
callq 0x2180
movq 0x554c(%rip), %rax      # 0x9fd8
movq (%rax), %r15
callq 0x21b0
leaq 0x19bd(%rip), %rsi      # 0x6458
leaq 0x16d9(%rip), %r8       # 0x617b
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
movl %ebx, %r9d
xorl %eax, %eax
callq 0x22e0
pushq $-0x1
popq %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
xorl %r12d, %r12d
leaq 0x30(%rsp), %r14
pushq $0x1
popq %r15
movslq 0x44(%rbx), %rax
cmpq %rax, %r12
jge 0x4b13
movl $0x1, 0x30(%rsp)
movq 0xd8(%rbx), %rax
movl (%rax,%r12,4), %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x20b0
cmpl $0x1, %eax
jne 0x4b95
incq %r12
jmp 0x4ade
movl $0x1, 0x58(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x21d0
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2100
leaq 0x14bd(%rip), %rdx      # 0x6004
leaq 0x10(%rsp), %rbx
pushq $0x12
popq %rsi
movq %rbx, %rdi
movq %r14, %rcx
callq 0x2180
movq 0x5477(%rip), %rax      # 0x9fd8
movq (%rax), %r14
callq 0x21b0
leaq 0x1953(%rip), %rsi      # 0x64c3
leaq 0x1604(%rip), %r8       # 0x617b
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x22e0
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x18ee(%rip), %rdi      # 0x648a
leaq 0x18f6(%rip), %rsi      # 0x6499
leaq 0x18fc(%rip), %rcx      # 0x64a6
pushq $0x40
popq %rdx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
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 0x2b28
testl %eax, %eax
jne 0x528c
movl 0x4c(%rbx), %esi
movq 0x50(%rbx), %rax
movl (%rax), %edx
movq %r14, %rdi
callq 0x29c8
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x21d0
leaq 0x28(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2100
leaq 0xd54(%rip), %rdx       # 0x6004
leaq 0x10(%rsp), %r14
pushq $0x12
popq %rsi
movq %r14, %rdi
movq %r15, %rcx
callq 0x2180
movq 0x4d0e(%rip), %rax      # 0x9fd8
movq (%rax), %r15
callq 0x21b0
movl 0x48(%rbx), %r9d
leaq 0x127e(%rip), %rsi      # 0x655b
leaq 0xe97(%rip), %r8        # 0x617b
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x22e0
pushq $-0x1
popq %rax
jmp 0x5282
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %r12
movq %r12, %rdi
callq 0x2260
movq %r12, %rdi
xorl %esi, %esi
callq 0x2290
movq %r12, %rdi
movq %rbx, %rsi
callq 0x22c0
pushq $-0x1
popq %rbp
testq %r15, %r15
je 0x53da
testl %eax, %eax
jne 0x53da
leaq (,%r15,8), %rdi
callq 0x22a0
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x53da
leaq 0x18(%r14), %rdi
leal 0x1(%r15), %edx
xorl %r13d, %r13d
xorl %esi, %esi
callq 0x2360
leaq 0x58(%rip), %rbp        # 0x53f4
movq %rsp, %r12
xorl %ebx, %ebx
cmpq %rbx, %r15
je 0x53c8
movq 0x8(%r14), %rdi
addq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
movq %r14, %rcx
callq 0x23c0
testl %eax, %eax
jne 0x53cb
incq %rbx
addq $0x8, %r13
jmp 0x53a1
movq %r15, %rbx
movq %rbx, 0x10(%r14)
xorl %ebp, %ebp
cmpq %r15, %rbx
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
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5473
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
pushq $0xf
popq %rbp
movq 0x8(%rbx), %rdi
cmpq 0x10(%rbx), %r14
jae 0x5459
movq (%rdi,%r14,8), %rdi
movl %ebp, %esi
callq 0x2280
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
xorl %esi, %esi
callq 0x21c0
incq %r14
jmp 0x5430
callq 0x2250
andq $0x0, 0x8(%rbx)
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x2200
popq %rbx
popq %r14
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %rsi
subq %rax, %rsi
sarq $0x2, %rsi
xorl %ecx, %ecx
xorl %r15d, %r15d
cmpq %rcx, %rsi
je 0x11f1
movl (%rax,%rcx,4), %edx
cmpl %r15d, %edx
movl %r15d, %edi
cmovll %edx, %edi
testl %r15d, %r15d
cmovel %edx, %edi
testl %edx, %edx
cmovgl %edi, %r15d
incq %rcx
jmp 0x11cf
testl %r15d, %r15d
sete %al
cmpl $0x2, %r15d
setge %cl
orb %al, %cl
je 0x1207
pushq $0x1
popq %rbx
jmp 0x127c
leaq -0x20(%rbp), %rdx
andl $0x0, (%rdx)
leaq -0x38(%rbp), %r14
leaq -0x19(%rbp), %rcx
movq %r14, %rdi
callq 0x1292
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
subq %rcx, %rax
sarq $0x2, %rax
movl %r15d, %edx
notl %edx
xorl %esi, %esi
movq (%r14), %rdi
cmpq %rsi, %rax
je 0x1255
movl (%rcx,%rsi,4), %r8d
addl %edx, %r8d
js 0x1250
movl %r8d, %r8d
cmpq %r8, %rax
jbe 0x1250
incl (%rdi,%r8,4)
incq %rsi
jmp 0x1236
movq -0x38(%rbp), %rdx
xorl %ebx, %ebx
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x1273
cmpl $0x0, (%rdx,%rcx,4)
je 0x126d
incq %rcx
jmp 0x125d
leal (%r15,%rcx), %ebx
incl %ebx
leaq -0x38(%rbp), %rdi
callq 0x132c
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x1bcb(%rip), %rsi      # 0x4020
callq 0x2080
testq %rax, %rax
je 0x24b3
movq %rax, %r14
leaq 0x1be4(%rip), %rsi      # 0x404d
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x2b3c
leaq 0x10(%rsp), %r15
movq %r14, %rdi
callq 0x2230
testl %eax, %eax
jne 0x24a9
movq %r15, %rdi
movl $0x80, %esi
movq %r14, %rdx
callq 0x2250
testq %rax, %rax
je 0x247b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22e0
jmp 0x247b
movq %r14, %rdi
callq 0x21e0
jmp 0x24c7
leaq 0x1b68(%rip), %rsi      # 0x4022
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x2b3c
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
leaq 0x20(%rsp), %r14
pushq $0x18
popq %rdx
movq %r14, %rdi
callq 0x2260
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movsbl %bpl, %ebp
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x22d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x254f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2b78
jmp 0x2527
movq %rsp, %rdi
callq 0x20c0
leaq 0x20(%rsp), %rdi
callq 0x2110
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20c0
leaq 0x20(%rsp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq (%rdi), %rdi
callq 0x2200
testq %rax, %rax
je 0x261f
movq %rax, %r14
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %r12
leaq 0x1a6b(%rip), %r13      # 0x4029
leaq 0x1a63(%rip), %rbp      # 0x4028
movq %r14, %rdi
callq 0x2210
testq %rax, %rax
je 0x2617
addq $0x13, %rax
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x2b3c
movq %r15, %rdi
movq %r13, %rsi
callq 0x2ba4
testb %al, %al
je 0x260d
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2ba4
testb %al, %al
je 0x260d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2b78
movq %r15, %rdi
callq 0x20c0
jmp 0x25c5
movq %r14, %rdi
callq 0x2270
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x2ff8
movq %rax, 0x8(%rbx)
movl 0xc(%r14), %edx
movq 0x58(%r14), %rax
xorl %ecx, %ecx
testl %edx, %edx
cmovlel %ecx, %edx
imulq $0x30, %rdx, %rdx
xorl %esi, %esi
cmpq %rcx, %rdx
je 0x3027
movq 0x8(%rax,%rcx), %rdi
subq (%rax,%rcx), %rdi
shrq $0x3, %rdi
addl %edi, %esi
addq $0x30, %rcx
jmp 0x300d
movslq %esi, %rsi
movq %rbx, %rdi
callq 0x31f6
xorl %r15d, %r15d
movslq 0xc(%r14), %rax
cmpq %rax, %r15
jge 0x3077
imulq $0x30, %r15, %r12
addq 0x58(%r14), %r12
xorl %eax, %eax
movl %eax, %r13d
movq (%r12), %rax
movq 0x8(%r12), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jbe 0x3072
leaq (%rax,%r13,8), %rsi
movq %rbx, %rdi
callq 0x3394
leal 0x1(%r13), %eax
jmp 0x3048
incq %r15
jmp 0x3035
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x44f2
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
movslq 0xc(%rdi), %rax
movq 0x58(%rdi), %rcx
xorl %edx, %edx
cmpq %rax, %rdx
jge 0x3134
imulq $0x30, %rdx, %r9
leaq (%rcx,%r9), %rdi
movq (%rcx,%r9), %r8
movq 0x8(%rcx,%r9), %r9
subq %r8, %r9
sarq $0x3, %r9
movq 0x10(%rsi), %r10
movslq 0x4(%rsi), %rbx
movslq %edx, %r11
imulq %rbx, %r11
xorl %ebx, %ebx
movl %ebx, %ebx
cmpq %rbx, %r9
jbe 0x312f
movsd (%r8,%rbx,8), %xmm0
movq 0x18(%rdi), %r14
movslq (%r14,%rbx,4), %r14
addq %r11, %r14
movsd %xmm0, (%r10,%r14,8)
incl %ebx
jmp 0x310d
incq %rdx
jmp 0x30df
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
movq %rsi, 0x48(%rdi)
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
andq $0x0, 0x10(%r15)
leaq 0x8(%rdi), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x36e6
movq %r15, %rdi
callq 0x34d8
leaq 0x40(%rbx), %rsi
leaq 0x28(%rbx), %rdx
movq %r12, %rdi
movq %r14, %rcx
callq 0x36d0
andq $0x0, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x38e9
cmpq $0x0, 0x18(%rsi)
je 0x390a
movb $0x6b, 0xc(%rbx)
movl 0x4(%rdx), %edi
movq 0x20(%rsi), %rdx
movq 0x38(%rsi), %rax
movq %rcx, %rsi
movq %rax, %rcx
callq 0x5c3c
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 0x5c14
jmp 0x3903
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x8(%rdi)
movq 0x10(%rdi), %r14
testq %r14, %r14
je 0x3a6e
movq %r14, %rdi
callq 0x3a50
leaq 0x10(%rbx), %r15
movq %r14, %rdi
callq 0x2130
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x3a8b
movq %r14, %rdi
callq 0x3a50
movq %r14, %rdi
callq 0x2130
leaq 0x38(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
callq 0x3af4
addq $0x20, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3af4
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rsp, %rdi
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movl (%rbx), %r14d
movslq %r14d, %rsi
callq 0x349c
movq (%rsp), %rax
xorl %ecx, %ecx
testl %r14d, %r14d
cmovlel %ecx, %r14d
cmpq %rcx, %r14
je 0x4ac5
movl %ecx, (%rax,%rcx,4)
incq %rcx
jmp 0x4ab8
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x4b04
movq %rax, %rbx
movq %rsp, %rdi
callq 0x414e
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x414e
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rdi), %edx
leaq 0x33f1(%rip), %rsi      # 0x80d8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2200
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rbx, %rdi
callq 0x4ebd
leaq 0x33dc(%rip), %rdi      # 0x80e4
pushq $0x6
popq %rsi
pushq $0x1
popq %r15
movq %r15, %rdx
movq %rbx, %rcx
callq 0x22c0
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
movq %rbx, %rdi
callq 0x4ebd
leaq 0x33ba(%rip), %rdi      # 0x80eb
pushq $0x2
popq %rsi
movq %r15, %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r15
leaq 0x3393(%rip), %r12      # 0x80ee
pushq $0x2
popq %r13
pushq $0x1
popq %rbp
testl %ebx, %ebx
movl %ebx, %eax
movl $0x0, %ebx
movl %eax, 0x4(%rsp)
cmovgl %eax, %ebx
testq %rsi, %rsi
je 0x4dba
movq %rsi, %r14
subl $0x1, %ebx
jb 0x4d95
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r15, %rcx
callq 0x22c0
movq %r14, %rsi
jmp 0x4d7a
movq %rsi, %rdi
movq %r15, %rsi
callq 0x4cd2
movq 0x10(%r14), %rsi
movl 0x4(%rsp), %ebx
incl %ebx
movq %r15, %rdi
movl %ebx, %edx
callq 0x4d44
movq 0x18(%r14), %rsi
jmp 0x4d62
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x5b
popq %rdi
movq %rbx, %rsi
callq 0x21d0
cmpq %r14, %r15
je 0x4f07
leaq 0x323f(%rip), %rsi      # 0x8124
leaq 0x3236(%rip), %r12      # 0x8122
movsd (%r15), %xmm0
movq %rbx, %rdi
movb $0x1, %al
callq 0x2200
addq $0x8, %r15
movq %r12, %rsi
cmpq %r14, %r15
jne 0x4eec
pushq $0x5d
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x561c
movslq %edx, %rdi
testb %cl, %cl
je 0x5620
pushq $0x8
popq %rsi
callq 0x20c0
jmp 0x5629
xorl %eax, %eax
jmp 0x5629
shlq $0x3, %rdi
callq 0x21e0
movq %rax, 0x10(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5672
movq %rsi, %rbx
shlq $0x3, %r15
movq %r15, %rdi
callq 0x21e0
movq %rax, 0x10(%r14)
movq 0x10(%rbx), %rsi
movq %rax, %rdi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x20f0
andq $0x0, 0x10(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, %rbx
leaq 0x16(%rsp), %r15
movw $0x9, (%r15)
movl (%rsi), %eax
movl 0x4(%rsi), %r13d
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
movl %eax, 0xc(%rsp)
cmpl 0xc(%rsp), %edx
je 0x5717
movq 0x10(%r14), %rax
movslq 0x4(%r14), %rcx
movl %edx, 0x10(%rsp)
movslq %edx, %r12
imulq %r12, %rcx
movsd (%rax,%rcx,8), %xmm0
movq %rbx, %rdi
callq 0x2250
pushq $0x1
popq %rbp
movq %rbx, %rdi
cmpl %r13d, %ebp
jge 0x5707
movq %r15, %rsi
callq 0x2150
movq 0x10(%r14), %rcx
movslq 0x4(%r14), %rdx
imulq %r12, %rdx
addq %rbp, %rdx
movsd (%rcx,%rdx,8), %xmm0
movq %rax, %rdi
callq 0x2250
incq %rbp
jmp 0x56d6
pushq $0xa
popq %rsi
callq 0x2180
movl 0x10(%rsp), %edx
incl %edx
jmp 0x56ad
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_O2/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
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xe(%rsp), %rax
movw $0x9, (%rax)
movl (%rsi), %eax
movl 0x4(%rsi), %ebp
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
movl %eax, 0x10(%rsp)
leaq 0x29ca(%rip), %r13      # 0x8128
cmpl 0x10(%rsp), %edx
je 0x57d4
movq 0x10(%rbx), %rax
movslq 0x4(%rbx), %rcx
movl %edx, 0x14(%rsp)
movslq %edx, %r12
imulq %r12, %rcx
movsd (%rax,%rcx,8), %xmm0
movq %r14, %rdi
leaq 0x299e(%rip), %rsi      # 0x8124
movb $0x1, %al
callq 0x2200
pushq $0x1
popq %r15
cmpl %ebp, %r15d
jge 0x57c1
movq 0x10(%rbx), %rax
movslq 0x4(%rbx), %rcx
imulq %r12, %rcx
addq %r15, %rcx
movsd (%rax,%rcx,8), %xmm0
movq %r14, %rdi
movq %r13, %rsi
leaq 0xe(%rsp), %rdx
movb $0x1, %al
callq 0x2200
incq %r15
jmp 0x5791
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x21d0
movl 0x14(%rsp), %edx
incl %edx
jmp 0x575e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rdi, %rbx
leaq 0x2939(%rip), %rsi      # 0x812e
callq 0x2190
testq %rax, %rax
je 0x581a
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x5729
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2160
movq 0x67b7(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
leaq 0x2905(%rip), %rsi      # 0x8130
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2200
leaq 0x2906(%rip), %rdi      # 0x8142
popq %rbx
popq %r14
popq %r15
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/sharmaeklavya2[P]ctmeans/src/lib/matrix.cpp
// Function: input(_IO_FILE*, Matrix&)
void input(FILE* fp, Matrix& X) {
    MatrixElemType* data = X.data();
    int mn = X.size();
    for(int i=0; i<mn; ++i) {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-result"
        fscanf(fp, "%lf", data+i);
#pragma GCC diagnostic pop
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %r14
movl 0x8(%rsi), %r12d
xorl %eax, %eax
testl %r12d, %r12d
cmovlel %eax, %r12d
leaq 0x28bb(%rip), %r15      # 0x8124
subq $0x1, %r12
jb 0x5885
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x22a0
addq $0x8, %r14
jmp 0x5869
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28a7(%rip), %rsi      # 0x814a
callq 0x2190
testq %rax, %rax
je 0x58c8
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x5846
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2160
movq 0x6709(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
leaq 0x2857(%rip), %rsi      # 0x8130
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2200
leaq 0x2862(%rip), %rdi      # 0x814c
popq %rbx
popq %r14
popq %r15
jmp 0x2100