LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x460, %rsp            # imm = 0x460
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x458(%rbp)
movl $0x0, -0x450(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x448(%rbp)
cmpl $0x0, -0x448(%rbp)
jle 0x3b01
cmpl $0x400, -0x448(%rbp)    # imm = 0x400
jle 0x3a41
movl $0x400, %eax            # imm = 0x400
movl %eax, -0x45c(%rbp)
jmp 0x3a4d
movl -0x448(%rbp), %eax
movl %eax, -0x45c(%rbp)
movq -0x458(%rbp), %rdi
movl -0x45c(%rbp), %eax
movl %eax, -0x44c(%rbp)
movl -0x14(%rbp), %esi
leaq -0x440(%rbp), %rdx
movl -0x44c(%rbp), %ecx
movq -0x30(%rbp), %r8
callq 0x3630
movl %eax, -0x444(%rbp)
cmpl $0x0, -0x444(%rbp)
jg 0x3aa8
cmpl $0x0, -0x444(%rbp)
jne 0x3a9a
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x3b07
movl -0x24(%rbp), %eax
subl -0x448(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3b07
movslq -0x444(%rbp), %rax
movb $0x0, -0x440(%rbp,%rax)
movq -0x20(%rbp), %rdi
movslq -0x450(%rbp), %rax
addq %rax, %rdi
leaq -0x440(%rbp), %rsi
movslq -0x44c(%rbp), %rdx
callq 0x21a0
movl -0x450(%rbp), %eax
addl -0x444(%rbp), %eax
movl %eax, -0x450(%rbp)
movl -0x448(%rbp), %eax
subl -0x444(%rbp), %eax
movl %eax, -0x448(%rbp)
jmp 0x3a1b
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x460, %rsp            # imm = 0x460
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jg 0x3ebc
leaq -0x20(%rbp), %rdi
callq 0x21e0
leaq -0x20(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2120
leaq -0x70(%rbp), %rdi
movl $0x12, %esi
leaq 0x51ae(%rip), %rdx      # 0x9004
leaq -0x58(%rbp), %rcx
callq 0x2190
movq 0x9172(%rip), %rax      # 0xcfd8
movq (%rax), %rax
movq %rax, -0x90(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0x21c0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rdx
movq %rax, %rcx
movq -0x18(%rbp), %rax
movl (%rax), %r9d
leaq 0x5340(%rip), %rsi      # 0x91df
leaq 0x52d5(%rip), %r8       # 0x917b
movb $0x0, %al
callq 0x2310
movl %eax, -0x74(%rbp)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3f94
movl $0x100000, -0x78(%rbp)  # imm = 0x100000
movq -0x18(%rbp), %rax
movl (%rax), %edi
movl $0x1, %esi
movl $0x7, %edx
leaq -0x78(%rbp), %rcx
movl $0x4, %r8d
callq 0x23e0
movl $0x100000, -0x78(%rbp)  # imm = 0x100000
movq -0x18(%rbp), %rax
movl (%rax), %edi
movl $0x1, %esi
movl $0x8, %edx
leaq -0x78(%rbp), %rcx
movl $0x4, %r8d
callq 0x23e0
movl $0x1, -0x78(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x78(%rbp), %rcx
movl $0x4, %r8d
callq 0x23e0
movq -0x18(%rbp), %rax
movl (%rax), %edi
movl $0x3, %esi
movb $0x0, %al
callq 0x2140
movl %eax, -0x78(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edi
movl -0x78(%rbp), %edx
orl $0x800, %edx            # imm = 0x800
movl $0x4, %esi
movb $0x0, %al
callq 0x2140
movl $0x1, -0x7c(%rbp)
movl $0xffffffff, -0x80(%rbp) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movl (%rax), %edi
movl $0x6, %esi
movl $0x1, %edx
leaq -0x7c(%rbp), %rcx
movl $0x4, %r8d
callq 0x23e0
movl %eax, -0x80(%rbp)
movl -0x80(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x18, %rdi
movq %rdi, -0x38(%rbp)
callq 0x4810
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl $0x40, %edi
callq 0x2200
movq %rax, -0x28(%rbp)
jmp 0x443d
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
movl (%rax), %esi
callq 0x5040
jmp 0x444e
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movslq (%rax), %rdi
shlq $0x2, %rdi
callq 0x22d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rdi
movslq (%rax), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x2130
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl (%rcx), %eax
jge 0x44df
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
leaq -0x20(%rbp), %rsi
callq 0x4830
jmp 0x44a8
jmp 0x44aa
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x448a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x44f6
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x40, %esi
callq 0x2210
jmp 0x44f6
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2350
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4870
movq -0x18(%rbp), %rdi
callq 0x23d0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x90(%rbp)
addq $0x30, %rdi
callq 0x2340
movq -0x90(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x5140
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x46ef
movq -0x90(%rbp), %rdi
addq $0x18, %rdi
callq 0x4890
testb $0x1, %al
jne 0x45e3
jmp 0x4669
leaq -0x30(%rbp), %rdi
callq 0x21e0
leaq -0x30(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x2120
leaq -0x80(%rbp), %rdi
movl $0x12, %esi
leaq 0x49fb(%rip), %rdx      # 0x9004
leaq -0x68(%rbp), %rcx
callq 0x2190
movq 0x89bf(%rip), %rax      # 0xcfd8
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
leaq -0x80(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x21c0
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rdx
movq %rax, %rcx
leaq 0x4cb4(%rip), %rsi      # 0x92ff
leaq 0x4b29(%rip), %r8       # 0x917b
movb $0x0, %al
callq 0x2310
movl %eax, -0x84(%rbp)
movq $0x0, -0x28(%rbp)
jmp 0x46ae
movq -0x90(%rbp), %rdi
addq $0x18, %rdi
callq 0x48b0
movq -0x90(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x88(%rbp)
addq $0x18, %rdi
callq 0x48e0
movq -0x90(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x88(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x90(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
xorl %ecx, %ecx
callq 0x5200
movq -0x90(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x1, (%rax)
addq $0x30, %rdi
callq 0x2170
movl $0x1, -0x4(%rbp)
jmp 0x4718
movq -0x90(%rbp), %rdi
addq $0x30, %rdi
callq 0x2170
movq -0x28(%rbp), %rcx
movl $0x1, %eax
lock
xaddl %eax, (%rcx)
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5550
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
leaq -0x18(%rbp), %rsi
callq 0x5580
movq -0x50(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x10, %rdi
callq 0x5660
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x5630
testb $0x1, %al
jne 0x51b2
jmp 0x51bc
movq $0x0, -0x8(%rbp)
jmp 0x51f1
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x56a0
movq -0x58(%rbp), %rdi
movq 0x8(%rax), %rsi
xorl %edx, %edx
callq 0x2640
leaq -0x28(%rbp), %rdi
callq 0x56a0
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: SeTriones[P]Anubis/receiver.cpp
// Function: testEndian()
uint8_t testEndian() {
	uint16_t v = 0x1234;
	uint8_t* a = (uint8_t*)&v;
	if (a[0] == 0x12) {
		return 1;
	} else {
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw $0x1234, -0x4(%rbp)     # imm = 0x1234
leaq -0x4(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x12, %eax
jne 0x7764
movb $0x1, -0x1(%rbp)
jmp 0x7768
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x8860
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x29f0
jmp 0x77ab
movq -0x30(%rbp), %rax
leaq 0x54e2(%rip), %rcx      # 0xcc98
addq $0x10, %rcx
movq %rcx, (%rax)
callq 0x7740
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, 0xf4(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0xec(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0xf0(%rax)
movslq 0xec(%rax), %rdi
shlq $0x3, %rdi
callq 0x22d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0xf8(%rax)
movl $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movl -0x28(%rbp), %eax
cmpl 0xec(%rcx), %eax
jge 0x7893
movl $0x58, %edi
callq 0x2200
movq %rax, -0x38(%rbp)
jmp 0x7824
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movl 0xf0(%rax), %esi
callq 0x4400
jmp 0x7839
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rax
movq 0xf8(%rax), %rax
movslq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x7805
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x78a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x7899
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x58, %esi
callq 0x2210
jmp 0x7899
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
callq 0x2d50
movq -0x30(%rbp), %rdi
callq 0x8890
movq -0x20(%rbp), %rdi
callq 0x23d0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
movl $0x0, -0x18(%rbp)
movq -0xe0(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x44(%rcx), %eax
jge 0x7aa5
movq -0xe0(%rbp), %rax
movl 0x40(%rax), %edi
callq 0x2410
movl %eax, %esi
movq -0xe0(%rbp), %rax
movq 0x50(%rax), %rcx
movslq -0x18(%rbp), %rdx
movl %esi, (%rcx,%rdx,4)
movq 0x50(%rax), %rax
movslq -0x18(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
jne 0x7a95
leaq -0x20(%rbp), %rdi
callq 0x21e0
leaq -0x20(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2120
leaq -0x70(%rbp), %rdi
movl $0x12, %esi
leaq 0x15d2(%rip), %rdx      # 0x9004
leaq -0x58(%rbp), %rcx
callq 0x2190
movq 0x5596(%rip), %rax      # 0xcfd8
movq (%rax), %rax
movq %rax, -0xf0(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0xe8(%rbp)
callq 0x21c0
movq -0xf0(%rbp), %rdi
movq -0xe8(%rbp), %rdx
movq %rax, %rcx
movl -0x18(%rbp), %r9d
leaq 0x19a5(%rip), %rsi      # 0x941d
leaq 0x16fc(%rip), %r8       # 0x917b
movb $0x0, %al
callq 0x2310
movl %eax, -0x74(%rbp)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7bc8
jmp 0x7a97
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x79c4
movl $0x0, -0x78(%rbp)
movq -0xe0(%rbp), %rcx
movl -0x78(%rbp), %eax
cmpl 0x44(%rcx), %eax
jge 0x7baa
movq -0xe0(%rbp), %rdi
addq $0x40, %rdi
movl -0x78(%rbp), %esi
callq 0x3440
cmpl $0x0, %eax
jge 0x7b70
leaq -0x80(%rbp), %rdi
callq 0x21e0
leaq -0x80(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x2120
leaq -0xd0(%rbp), %rdi
movl $0x12, %esi
leaq 0x14fd(%rip), %rdx      # 0x9004
leaq -0xb8(%rbp), %rcx
callq 0x2190
movq 0x54be(%rip), %rax      # 0xcfd8
movq (%rax), %rax
movq %rax, -0x100(%rbp)
leaq -0xd0(%rbp), %rax
movq %rax, -0xf8(%rbp)
callq 0x21c0
movq -0x100(%rbp), %rdi
movq -0xf8(%rbp), %rdx
movq %rax, %rcx
movl -0x78(%rbp), %r9d
leaq 0x18f9(%rip), %rsi      # 0x944c
leaq 0x1621(%rip), %r8       # 0x917b
movb $0x0, %al
callq 0x2310
movl %eax, -0xd4(%rbp)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7bc8
movq -0xe0(%rbp), %rax
movq %rax, %rdi
addq $0x40, %rdi
movq 0xd0(%rax), %rcx
movslq -0x78(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
movq 0x50(%rax), %rax
movslq -0x78(%rbp), %rcx
movl (%rax,%rcx,4), %edx
callq 0x2f90
movl -0x78(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x78(%rbp)
jmp 0x7aac
movq -0xe0(%rbp), %rdi
movl -0x14(%rbp), %eax
imull 0x44(%rdi), %eax
movslq %eax, %rsi
movl $0x40000, %edx          # imm = 0x40000
callq 0x88e0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x80(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x44(%rcx), %eax
jge 0x7c6f
movq -0x80(%rbp), %rax
movl $0x1, -0x14(%rbp)
movq 0xd8(%rax), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edi
leaq -0x14(%rbp), %rsi
movl $0x1, %edx
callq 0x20d0
movl %eax, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0x7c43
jmp 0x7c62
leaq 0x1834(%rip), %rdi      # 0x947e
leaq 0x183c(%rip), %rsi      # 0x948d
movl $0x40, %edx
leaq 0x183d(%rip), %rcx      # 0x949a
callq 0x2150
jmp 0x7c64
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x7c05
movq -0x80(%rbp), %rdi
movl $0x1, 0x58(%rdi)
movq (%rdi), %rax
callq *0x30(%rax)
leaq -0x20(%rbp), %rdi
callq 0x21e0
leaq -0x20(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2120
leaq -0x70(%rbp), %rdi
movl $0x12, %esi
leaq 0x135e(%rip), %rdx      # 0x9004
leaq -0x58(%rbp), %rcx
callq 0x2190
movq 0x5322(%rip), %rax      # 0xcfd8
movq (%rax), %rax
movq %rax, -0x90(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0x21c0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rdx
movq %rax, %rcx
leaq 0x17cf(%rip), %rsi      # 0x94b7
leaq 0x148c(%rip), %r8       # 0x917b
movb $0x0, %al
callq 0x2310
movl %eax, -0x74(%rbp)
xorl %eax, %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, 0x48(%rax)
movq %rax, %rdi
addq $0x40, %rdi
movq %rax, %rsi
addq $0x40, %rsi
addq $0xc, %rsi
movl 0x48(%rax), %eax
movzwl %ax, %edx
callq 0x3160
cmpl $0x0, %eax
je 0x8620
leaq -0x20(%rbp), %rdi
callq 0x21e0
leaq -0x20(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2120
leaq -0x70(%rbp), %rdi
movl $0x12, %esi
leaq 0xa48(%rip), %rdx       # 0x9004
leaq -0x58(%rbp), %rcx
callq 0x2190
movq 0x4a0c(%rip), %rax      # 0xcfd8
movq (%rax), %rax
movq %rax, -0x90(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0x21c0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rdx
movq %rax, %rcx
movq -0x80(%rbp), %rax
movl 0x48(%rax), %r9d
leaq 0xf49(%rip), %rsi       # 0x954f
leaq 0xb6e(%rip), %r8        # 0x917b
movb $0x0, %al
callq 0x2310
movl %eax, -0x74(%rbp)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8640
movq -0x80(%rbp), %rax
movq %rax, %rdi
addq $0x40, %rdi
movl 0x4c(%rax), %esi
movq 0x50(%rax), %rax
movl (%rax), %edx
callq 0x2f90
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: SeTriones[P]Anubis/./util.hpp
// Function: get_raw_key(char*, unsigned char*)
static uint64_t get_raw_key(char* buf, uint8_t* section_id) {
	request* req = (request*)buf;
	uint32_t klen = ntohl(req->key_len);
	uint32_t blen = ntohl(req->body_len);
	raw_key* rkey = (raw_key*)req->content;
	_INFO("key_len=%u,body_len=%u,interval=%u", klen, blen, ntohl(rkey->interval_in_seconds));
	uint8_t* key_buf = (uint8_t*)malloc(klen);
	memcpy(key_buf, rkey->key, klen - sizeof(uint32_t));
	uint32_t time_slot = 0;
	time_t cur_seconds = time(NULL);
	time_slot = cur_seconds / ntohl(rkey->interval_in_seconds); 
	memcpy(key_buf, &time_slot, klen - sizeof(uint32_t));
	uint64_t ret = get_key(key_buf, klen, section_id);
	free(key_buf);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x2290
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x2290
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x21e0
leaq -0x30(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x2120
leaq -0x80(%rbp), %rdi
movl $0x12, %esi
leaq 0x94a(%rip), %rdx       # 0x9004
leaq -0x68(%rbp), %rcx
callq 0x2190
movq 0x490e(%rip), %rax      # 0xcfd8
movq (%rax), %rax
movq %rax, -0xd0(%rbp)
leaq -0x80(%rbp), %rax
movq %rax, -0xc8(%rbp)
callq 0x21c0
movq %rax, -0xc0(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0xb8(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0xb4(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %edi
callq 0x2290
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rdx
movq -0xc0(%rbp), %rcx
movl -0xb8(%rbp), %r9d
movl -0xb4(%rbp), %r10d
leaq 0xeac(%rip), %rsi       # 0x95de
leaq 0xa42(%rip), %r8        # 0x917b
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x2310
movl %eax, -0x84(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %edi
callq 0x22d0
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x4, %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
subq $0x4, %rdx
callq 0x21a0
movl $0x0, -0x94(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x21e0
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %edi
callq 0x2290
movl %eax, %ecx
movq -0xb0(%rbp), %rax
movl %ecx, %ecx
cqto
idivq %rcx
movl %eax, -0x94(%rbp)
movq -0x90(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %edx
subq $0x4, %rdx
leaq -0x94(%rbp), %rsi
callq 0x21a0
movq -0x90(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
movq -0x10(%rbp), %rdx
callq 0x8820
movq %rax, -0xa8(%rbp)
movq -0x90(%rbp), %rdi
callq 0x2270
movq -0xa8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: SeTriones[P]Anubis/./util.hpp
// Function: get_key(unsigned char*, unsigned long, unsigned char*)
static uint64_t get_key(uint8_t* key, size_t key_len, uint8_t* section_id) {
	uint8_t buf[MD5_DIGEST_LENGTH];
	uint64_t ret;
	MD5((const unsigned char*)key, key_len, buf);
	memcpy(&ret, buf, sizeof(ret));
	*section_id = buf[0];
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x2370
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movb -0x30(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
leaq -0x60(%rbp), %rdi
callq 0x2280
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
callq 0x22c0
movq -0x18(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x22f0
cmpl $0x0, %eax
je 0x892e
jmp 0x89d7
cmpq $0x0, -0x10(%rbp)
je 0x8950
movq -0x10(%rbp), %rdi
shlq $0x3, %rdi
callq 0x22d0
movq -0x68(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x8955
jmp 0x89d7
movq -0x68(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rax
addq $0x1, %rax
movl %eax, %edx
xorl %eax, %eax
movl %eax, %esi
callq 0x2390
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x89bc
movq -0x68(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
leaq -0x60(%rbp), %rsi
leaq 0x50(%rip), %rdx        # 0x89f0
callq 0x23f0
cmpl $0x0, %eax
je 0x89ac
jmp 0x89bc
jmp 0x89ae
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x8978
movq -0x68(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rax, 0x10(%rcx)
cmpq -0x10(%rbp), %rax
je 0x89d0
jmp 0x89d7
movl $0x0, -0x1c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x23c0
movl -0x1c(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: SeTriones[P]Anubis/task_base.cpp
// Function: task_base::run_svc(void*)
void* task_base::run_svc(void *arg)
{
	task_base *task = (task_base *)arg;
	pthread_barrier_wait(&task->m_barrier);
	task->svc();
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x2240
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x8af4
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x8ad2
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0xf, %esi
callq 0x22b0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x21d0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8a83
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2270
movq -0x18(%rbp), %rdi
movq $0x0, 0x8(%rdi)
addq $0x18, %rdi
callq 0x2220
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: 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:
subq $0xe8, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq 0xd8(%rsp), %rdi
callq 0x30d0
movq %rax, %rdi
leaq 0x4a25(%rip), %rsi      # 0x8010
callq 0x3090
movq %rax, 0xd0(%rsp)
cmpq $0x0, 0xd0(%rsp)
jne 0x3665
leaq 0xcf(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x33f0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x49ec(%rip), %rsi      # 0x8012
callq 0x4400
jmp 0x362d
leaq 0xcf(%rsp), %rdi
callq 0x3270
jmp 0x375c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0xcf(%rsp), %rdi
callq 0x3270
jmp 0x3769
movb $0x0, 0x2f(%rsp)
leaq 0x2e(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x33f0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x49b3(%rip), %rsi      # 0x803d
callq 0x4400
jmp 0x3691
leaq 0x2e(%rsp), %rdi
callq 0x3270
movq 0xd0(%rsp), %rdi
callq 0x3360
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x36b6
jmp 0x3735
movq 0xd0(%rsp), %rdx
leaq 0x30(%rsp), %rdi
movl $0x80, %esi
callq 0x3380
movq %rax, (%rsp)
jmp 0x36d3
movq (%rsp), %rax
cmpq $0x0, %rax
je 0x3730
movq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x3200
jmp 0x36ee
jmp 0x3730
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0x2e(%rsp), %rdi
callq 0x3270
jmp 0x3769
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
callq 0x3140
jmp 0x3769
jmp 0x369b
movq 0xd0(%rsp), %rdi
callq 0x3300
jmp 0x3744
movb $0x1, 0x2f(%rsp)
testb $0x1, 0x2f(%rsp)
jne 0x375a
movq 0x18(%rsp), %rdi
callq 0x3140
jmp 0x375c
movq 0x20(%rsp), %rax
addq $0xe8, %rsp
retq
movq 0xc0(%rsp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x1e8, %rsp            # imm = 0x1E8
movb %sil, %al
movq %rdi, 0x1e0(%rsp)
movb %al, 0x1df(%rsp)
movq %rdx, 0x1d0(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x44c0
movq 0x10(%rsp), %rsi
movl %eax, %edx
leaq 0x48(%rsp), %rdi
callq 0x3390
leaq 0x28(%rsp), %rdi
callq 0x32f0
movsbl 0x1df(%rsp), %edx
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x3410
movq %rax, 0x8(%rsp)
jmp 0x37f6
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x32c0
movb %al, 0x7(%rsp)
jmp 0x3810
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x381a
jmp 0x3854
movq 0x1d0(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x44e0
jmp 0x382e
jmp 0x37d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x3140
leaq 0x48(%rsp), %rdi
callq 0x31a0
jmp 0x3870
leaq 0x28(%rsp), %rdi
callq 0x3140
leaq 0x48(%rsp), %rdi
callq 0x31a0
addq $0x1e8, %rsp            # imm = 0x1E8
retq
movq 0x20(%rsp), %rdi
callq 0x33e0
nopw (%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
callq 0x30d0
movq %rax, %rdi
callq 0x3330
movq %rax, 0x60(%rsp)
cmpq $0x0, %rax
jne 0x38b0
jmp 0x39aa
jmp 0x38b2
movq 0x60(%rsp), %rdi
callq 0x3340
movq %rax, 0x58(%rsp)
cmpq $0x0, %rax
je 0x39a0
movq 0x58(%rsp), %rax
addq $0x13, %rax
movq %rax, 0x10(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x33f0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0x4400
jmp 0x38fe
leaq 0x37(%rsp), %rdi
callq 0x3270
leaq 0x470a(%rip), %rsi      # 0x8019
leaq 0x38(%rsp), %rdi
callq 0x4550
movb %al, 0xf(%rsp)
jmp 0x391f
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x3929
jmp 0x3991
leaq 0x46e8(%rip), %rsi      # 0x8018
leaq 0x38(%rsp), %rdi
callq 0x4550
movb %al, 0xe(%rsp)
jmp 0x3940
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x394a
jmp 0x3991
movq 0x68(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x44e0
jmp 0x395b
jmp 0x3991
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x37(%rsp), %rdi
callq 0x3270
jmp 0x39af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x3140
jmp 0x39af
leaq 0x38(%rsp), %rdi
callq 0x3140
jmp 0x38b2
movq 0x60(%rsp), %rdi
callq 0x33a0
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x33e0
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rdi
callq 0x4120
movl $0x0, 0x54(%rsp)
movl $0x0, 0x50(%rsp)
movq 0x18(%rsp), %rcx
movl 0x50(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0x37f7
movq 0x18(%rsp), %rdi
addq $0x58, %rdi
movslq 0x50(%rsp), %rsi
callq 0x4750
movq %rax, %rdi
callq 0x4270
movq %rax, %rcx
movslq 0x54(%rsp), %rax
addq %rcx, %rax
movl %eax, 0x54(%rsp)
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x37b2
movq 0x58(%rsp), %rdi
movslq 0x54(%rsp), %rsi
callq 0x3e30
movl $0x0, 0x4c(%rsp)
movq 0x18(%rsp), %rcx
movl 0x4c(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0x38a6
movq 0x18(%rsp), %rdi
addq $0x58, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x4750
movq %rax, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0x4270
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x3894
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0x4770
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x4200
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x3840
jmp 0x3896
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x380e
movq 0x58(%rsp), %rdi
callq 0x47d0
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rdi
callq 0x4800
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x4790
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x44(%rsp)
movq 0x20(%rsp), %rcx
movl 0x44(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0x3a74
movq 0x20(%rsp), %rdi
addq $0x58, %rdi
movslq 0x44(%rsp), %rsi
callq 0x4750
movq 0x20(%rsp), %rdi
movq %rax, 0x38(%rsp)
addq $0x58, %rdi
movslq 0x44(%rsp), %rsi
callq 0x4750
addq $0x18, %rax
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4270
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x3a62
movq 0x38(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x4770
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x48d0
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movl (%rax), %edx
callq 0x4340
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x39de
jmp 0x3a64
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x3990
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, 0x48(%rax)
leaq 0x8(%rsp), %rdi
callq 0x49c0
movq (%rsp), %rdi
addq $0x8, %rdi
leaq 0x8(%rsp), %rsi
callq 0x5910
leaq 0x8(%rsp), %rdi
callq 0x49f0
movq (%rsp), %rcx
movq %rcx, %rdi
addq $0x8, %rdi
movq %rcx, %rsi
addq $0x40, %rsi
movq %rcx, %rdx
addq $0x28, %rdx
addq $0x48, %rcx
callq 0x5940
movq (%rsp), %rax
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x48(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x626b
movq 0x48(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x626b
movq 0x30(%rsp), %rax
movb $0x70, 0xc(%rax)
movq 0x40(%rsp), %rdi
callq 0x4cd0
movl %eax, 0x24(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rax
movl 0x4(%rax), %esi
callq 0x3ab0
movl 0x24(%rsp), %edi
movq 0x28(%rsp), %rsi
movq %rax, %rdx
callq 0x109d0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x10(%rax)
jmp 0x62d8
movq 0x30(%rsp), %rax
movb $0x6b, 0xc(%rax)
movq 0x40(%rsp), %rdi
callq 0x4cd0
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0xc(%rsp)
movq 0x38(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rdi
addq $0x20, %rdi
callq 0x62e0
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x62e0
movl 0xc(%rsp), %edi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rcx
callq 0x10a60
movq 0x30(%rsp), %rax
movsd %xmm0, 0x10(%rax)
addq $0x58, %rsp
retq
nopl (%rax)
// File: sharmaeklavya2[P]ctmeans/src/lib/nniter_kd.h
// Function: operator<(KDHeapElem const&, KDHeapElem const&)
inline bool operator<(const KDHeapElem& x, const KDHeapElem& y) {
    if(x.prio != y.prio) {
        return x.prio > y.prio;
    }
    else {
        return x.point > y.point;
    }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rsp), %rax
ucomisd 0x10(%rax), %xmm0
jne 0x6ae4
jp 0x6ae4
jmp 0x6b03
movq -0x10(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rsp), %rax
ucomisd 0x10(%rax), %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x6b1c
movq -0x10(%rsp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
setg %al
andb $0x1, %al
movb %al, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: sharmaeklavya2[P]ctmeans/src/lib/kdtree.h
// Function: KDNode::~KDNode()
~KDNode() {
        parent = nullptr;
        delete left;
        delete right;
        left = nullptr;
        right = nullptr;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x6b6e
movq 0x18(%rsp), %rdi
callq 0x6b30
movq 0x18(%rsp), %rdi
callq 0x2140
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x6b96
movq 0x8(%rsp), %rdi
callq 0x6b30
movq 0x8(%rsp), %rdi
callq 0x2140
movq 0x10(%rsp), %rdi
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
addq $0x38, %rdi
callq 0x4450
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0x4450
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: sharmaeklavya2[P]ctmeans/src/lib/matrix.h
// Function: Matrix::swap(Matrix&)
void swap(Matrix& X) {
        std::swap(m, X.m);
        std::swap(n, X.n);
        std::swap(mn, X.mn);
        std::swap(a, X.a);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
callq 0x6d10
movq (%rsp), %rdi
addq $0x4, %rdi
movq 0x8(%rsp), %rsi
addq $0x4, %rsi
callq 0x6d10
movq (%rsp), %rdi
addq $0x8, %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0x6d10
movq (%rsp), %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
callq 0x6d40
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x3e20
movq 0x60(%rsp), %rdi
callq 0x4cc0
movl %eax, 0x1c(%rsp)
jmp 0xc6e3
movl 0x1c(%rsp), %eax
movl %eax, 0x44(%rsp)
movslq 0x44(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x4830
jmp 0xc6fc
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0xc752
movl 0x30(%rsp), %eax
movl %eax, 0x18(%rsp)
movslq 0x30(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x42c0
movl 0x18(%rsp), %ecx
movl %ecx, (%rax)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0xc704
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x43f0
jmp 0xc7a9
leaq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x7280
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
callq 0x7100
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %rdx
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
xorl %ecx, %ecx
movl %ecx, %r8d
callq 0xc7c0
movq %rax, 0x10(%rsp)
jmp 0xc795
leaq 0x48(%rsp), %rdi
callq 0x43f0
movq 0x10(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x22a0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl 0x4(%rax), %edx
leaq 0x7351(%rip), %rsi      # 0x140c8
movb $0x0, %al
callq 0x2220
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
addq $0x20, %rdi
callq 0xd520
movq 0x8(%rsp), %rdi
movq %rax, 0x30(%rsp)
addq $0x20, %rdi
callq 0xd550
movq (%rsp), %rdi
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0xd430
movq 0x38(%rsp), %rdi
leaq 0x7308(%rip), %rsi      # 0x140d4
movb $0x0, %al
callq 0x2220
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x38, %rdi
callq 0xd520
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x38, %rdi
callq 0xd550
movq 0x10(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xd430
movq 0x38(%rsp), %rdi
leaq 0x72b8(%rip), %rsi      # 0x140db
movb $0x0, %al
callq 0x2220
addq $0x48, %rsp
retq
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xcebb
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
jge 0xce78
movq 0x10(%rsp), %rdi
leaq 0x7278(%rip), %rsi      # 0x140de
movb $0x0, %al
callq 0x2220
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0xce51
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xcd50
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
movl 0x4(%rsp), %edx
addl $0x1, %edx
callq 0xce30
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
movl 0x4(%rsp), %edx
addl $0x1, %edx
callq 0xce30
addq $0x18, %rsp
retq
// File: 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:
subq $0x38, %rsp
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x6cc3(%rip), %rsi      # 0x14112
movb $0x0, %al
callq 0x2220
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xf890
testb $0x1, %al
jne 0xd46e
jmp 0xd500
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xf8d0
movq 0x8(%rsp), %rdi
movsd (%rax), %xmm0
leaq 0x6c84(%rip), %rsi      # 0x14116
movb $0x1, %al
callq 0x2220
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0xf8e0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xf890
testb $0x1, %al
jne 0xd4c9
jmp 0xd4fe
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0xf8d0
movq (%rsp), %rdi
movsd (%rax), %xmm0
leaq 0x6c29(%rip), %rsi      # 0x14114
movb $0x1, %al
callq 0x2220
leaq 0x18(%rsp), %rdi
callq 0xf920
jmp 0xd4b4
jmp 0xd500
movq 0x20(%rsp), %rdi
leaq 0x6d2b(%rip), %rsi      # 0x14237
movb $0x0, %al
callq 0x2220
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movb %cl, %al
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %ecx
movl %ecx, (%rax)
movl 0x18(%rsp), %ecx
movl %ecx, 0x4(%rax)
movl 0x1c(%rsp), %ecx
imull 0x18(%rsp), %ecx
movl %ecx, 0x8(%rax)
cmpl $0x0, 0x8(%rax)
je 0xf9ca
testb $0x1, 0x17(%rsp)
je 0xf9aa
movq 0x8(%rsp), %rax
movslq 0x8(%rax), %rdi
movl $0x8, %esi
callq 0x20d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0xf9c8
movq 0x8(%rsp), %rax
movslq 0x8(%rax), %rdi
shlq $0x3, %rdi
callq 0x21f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0xf9d7
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq 0x8(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
movq 0x8(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
cmpl $0x0, 0x8(%rax)
je 0xfa54
movq (%rsp), %rax
movslq 0x8(%rax), %rdi
shlq $0x3, %rdi
callq 0x21f0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rsi
movslq 0x8(%rax), %rdx
shlq $0x3, %rdx
callq 0x2100
jmp 0xfa60
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)