LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: nightmeng[P]net/src/socket.cpp
// Function: socket::sync_read(void*, unsigned long)
int socket::sync_read(void *buff, size_t length){
	int transfered = 0;
	std::mutex sync_mutex;
	std::unique_lock<std::mutex> locker(sync_mutex);
	bool processed = false;
	std::condition_variable sync_cv;
	{
		std::lock_guard<std::mutex> scope_locker(rd_mutex);
		rd_request.push_back(std::bind(&socket::sync_rd_action, this, 
					reinterpret_cast<char*>(buff), length, std::ref(transfered),
					std::ref(sync_cv), std::ref(processed)));
		if(rdable)
			rd_worker.active();
	}
	sync_cv.wait(locker, [&processed]()->bool{return processed;});

	return transfered;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x150(%rbp)
movl $0x0, -0x1c(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x158(%rbp)
callq 0xc2d0
movq -0x158(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xc4b0
movb $0x0, -0x59(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x42a0
movq -0x150(%rbp), %rsi
addq $0x120, %rsi            # imm = 0x120
leaq -0x98(%rbp), %rdi
callq 0x7330
jmp 0xb7e5
movq -0x150(%rbp), %rax
movq %rax, %rcx
addq $0x198, %rcx            # imm = 0x198
movq %rcx, -0x160(%rbp)
leaq 0x1cc(%rip), %rcx       # 0xb9d0
movq %rcx, -0x118(%rbp)
movq $0x0, -0x110(%rbp)
movq %rax, -0x120(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0xc970
movq %rax, -0x130(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xc580
movq %rax, -0x138(%rbp)
leaq -0x59(%rbp), %rdi
callq 0xc5b0
movq %rax, -0x140(%rbp)
movq %rsp, %rax
leaq -0x140(%rbp), %rcx
movq %rcx, 0x8(%rax)
leaq -0x138(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x108(%rbp), %rdi
leaq -0x118(%rbp), %rsi
leaq -0x120(%rbp), %rdx
leaq -0x128(%rbp), %rcx
leaq -0x18(%rbp), %r8
leaq -0x130(%rbp), %r9
callq 0xca40
jmp 0xb8a1
leaq -0xc8(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0xcab0
jmp 0xb8b6
movq -0x160(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0xc4f0
jmp 0xb8cb
leaq -0xc8(%rbp), %rdi
callq 0x6b50
movq -0x150(%rbp), %rax
testb $0x1, 0x1f0(%rax)
je 0xb946
movq -0x150(%rbp), %rdi
addq $0x10, %rdi
callq 0x144e0
jmp 0xb8f9
jmp 0xb946
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0xb9af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0xb9a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x6b50
jmp 0xb9a3
leaq -0x98(%rbp), %rdi
callq 0x73e0
leaq -0x59(%rbp), %rax
movq %rax, -0x148(%rbp)
movq -0x148(%rbp), %rdx
leaq -0x90(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xba20
jmp 0xb976
movl -0x1c(%rbp), %eax
movl %eax, -0x164(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x4380
leaq -0x58(%rbp), %rdi
callq 0xc680
movl -0x164(%rbp), %eax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
leaq -0x98(%rbp), %rdi
callq 0x73e0
leaq -0x90(%rbp), %rdi
callq 0x4380
leaq -0x58(%rbp), %rdi
callq 0xc680
movq -0xa0(%rbp), %rdi
callq 0x4360
// File: nightmeng[P]net/src/socket.cpp
// Function: socket::async_write(void const*, unsigned long, std::function<void (int, int)>)
void socket::async_write(const void *buff, size_t length, ocallback ocb){
	std::lock_guard<std::mutex> locker(rd_mutex);
	wr_request.push_back(
			std::bind(&socket::async_wr_action, this, reinterpret_cast<const char *>(buff), length, ocb));

	if(wrable)
		wr_worker.active();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rcx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xd8(%rbp)
addq $0x120, %rsi            # imm = 0x120
leaq -0x28(%rbp), %rdi
callq 0x7330
movq -0xd8(%rbp), %rax
movq -0xd0(%rbp), %r9
movq %rax, %rcx
addq $0x1b0, %rcx            # imm = 0x1B0
movq %rcx, -0xc8(%rbp)
leaq 0x12d(%rip), %rcx       # 0xbc00
movq %rcx, -0xa0(%rbp)
movq $0x0, -0x98(%rbp)
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
leaq -0x18(%rbp), %r8
callq 0xcb50
jmp 0xbb1e
leaq -0x48(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0xcba0
jmp 0xbb30
movq -0xc8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xc4f0
jmp 0xbb42
leaq -0x48(%rbp), %rdi
callq 0x6b50
leaq -0x90(%rbp), %rdi
callq 0xcc40
movq -0xd8(%rbp), %rax
testb $0x1, 0x1f1(%rax)
je 0xbbcf
movq -0xd8(%rbp), %rdi
addq $0x98, %rdi
callq 0x144e0
jmp 0xbb7c
jmp 0xbbcf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0xbbe1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0xbbc1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6b50
leaq -0x90(%rbp), %rdi
callq 0xcc40
jmp 0xbbe1
leaq -0x28(%rbp), %rdi
callq 0x73e0
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x73e0
movq -0xb8(%rbp), %rdi
callq 0x4360
nopw %cs:(%rax,%rax)
// File: nightmeng[P]net/src/socket.cpp
// Function: socket::async_wr_action(char const*, unsigned long, std::function<void (int, int)>)
void socket::async_wr_action(const char *buff, size_t length, ocallback ocb){
	int transfered = write_some(buff, length);
	int ec = 0;
	if(transfered == -1){
		socklen_t len = sizeof(ec);
		if(::getsockopt(sock, SOL_SOCKET, SO_ERROR, &ec, &len) < 0){
			//
		}
	}

	singleton<scheduler>::instance()->arrange(std::bind(ocb, ec, transfered));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rcx, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xce30
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0xbc7b
movq -0x90(%rbp), %rax
movl $0x4, -0x2c(%rbp)
movl 0x8(%rax), %edi
movl $0x1, %esi
movl $0x4, %edx
leaq -0x28(%rbp), %rcx
leaq -0x2c(%rbp), %r8
callq 0x4180
cmpl $0x0, %eax
jge 0xbc79
jmp 0xbc79
jmp 0xbc7b
callq 0x6910
movq %rax, %rdi
callq 0x6a00
movq -0x98(%rbp), %rsi
movq %rax, -0xa8(%rbp)
leaq -0x78(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
leaq -0x28(%rbp), %rdx
leaq -0x24(%rbp), %rcx
callq 0xcef0
movq -0xa0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xcf30
jmp 0xbcc0
movq -0xa8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x8e20
jmp 0xbcd2
leaq -0x50(%rbp), %rdi
callq 0x6b50
leaq -0x78(%rbp), %rdi
callq 0xcfd0
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xbd16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x6b50
leaq -0x78(%rbp), %rdi
callq 0xcfd0
movq -0x80(%rbp), %rdi
callq 0x4360
nopl (%rax,%rax)
// File: nightmeng[P]net/src/socket.cpp
// Function: socket::async_read(void*, unsigned long, std::function<void (int, int)>)
void socket::async_read(void *buff, size_t length, icallback icb){
	std::lock_guard<std::mutex> locker(wr_mutex);
	rd_request.push_back(
			std::bind(&socket::async_rd_action, this, reinterpret_cast<char*>(buff), length, icb));

	if(rdable)
		rd_worker.active();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rcx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xd8(%rbp)
addq $0x148, %rsi            # imm = 0x148
leaq -0x28(%rbp), %rdi
callq 0x7330
movq -0xd8(%rbp), %rax
movq -0xd0(%rbp), %r9
movq %rax, %rcx
addq $0x198, %rcx            # imm = 0x198
movq %rcx, -0xc8(%rbp)
leaq 0x12d(%rip), %rcx       # 0xbec0
movq %rcx, -0xa0(%rbp)
movq $0x0, -0x98(%rbp)
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
leaq -0x18(%rbp), %r8
callq 0xcc60
jmp 0xbdde
leaq -0x48(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0xccb0
jmp 0xbdf0
movq -0xc8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xc4f0
jmp 0xbe02
leaq -0x48(%rbp), %rdi
callq 0x6b50
leaq -0x90(%rbp), %rdi
callq 0xcd50
movq -0xd8(%rbp), %rax
testb $0x1, 0x1f0(%rax)
je 0xbe8c
movq -0xd8(%rbp), %rdi
addq $0x10, %rdi
callq 0x144e0
jmp 0xbe39
jmp 0xbe8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0xbe9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0xbe7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6b50
leaq -0x90(%rbp), %rdi
callq 0xcd50
jmp 0xbe9e
leaq -0x28(%rbp), %rdi
callq 0x73e0
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x73e0
movq -0xb8(%rbp), %rdi
callq 0x4360
nopw %cs:(%rax,%rax)
// File: nightmeng[P]net/src/socket.cpp
// Function: socket::async_rd_action(char*, unsigned long, std::function<void (int, int)>)
void socket::async_rd_action(char *buff, size_t length, icallback icb){
	int transfered = read_some(buff, length);
	int ec = 0;
	if(transfered == -1){
		socklen_t len = sizeof(ec);
		if(::getsockopt(sock, SOL_SOCKET, SO_ERROR, &ec, &len) < 0){
			//
		}
	}
	singleton<scheduler>::instance()->arrange(std::bind(icb, ec, transfered));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rcx, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xcd70
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0xbf3b
movq -0x90(%rbp), %rax
movl $0x4, -0x2c(%rbp)
movl 0x8(%rax), %edi
movl $0x1, %esi
movl $0x4, %edx
leaq -0x28(%rbp), %rcx
leaq -0x2c(%rbp), %r8
callq 0x4180
cmpl $0x0, %eax
jge 0xbf39
jmp 0xbf39
jmp 0xbf3b
callq 0x6910
movq %rax, %rdi
callq 0x6a00
movq -0x98(%rbp), %rsi
movq %rax, -0xa8(%rbp)
leaq -0x78(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
leaq -0x28(%rbp), %rdx
leaq -0x24(%rbp), %rcx
callq 0xcef0
movq -0xa0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xcf30
jmp 0xbf80
movq -0xa8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x8e20
jmp 0xbf92
leaq -0x50(%rbp), %rdi
callq 0x6b50
leaq -0x78(%rbp), %rdi
callq 0xcfd0
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xbfd6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x6b50
leaq -0x78(%rbp), %rdi
callq 0xcfd0
movq -0x80(%rbp), %rdi
callq 0x4360
nopl (%rax,%rax)
// File: nightmeng[P]net/src/socket.cpp
// Function: socket::rdhupevent()
void socket::rdhupevent(){
	unregister_epoll_req();
	connect_status = PRECONNECT;
	rdable = false;
	wrable = false;
	close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x13850
movq -0x10(%rbp), %rdi
movl $0x0, 0x1f4(%rdi)
movb $0x0, 0x1f0(%rdi)
movb $0x0, 0x1f1(%rdi)
callq 0x138b0
addq $0x10, %rsp
popq %rbp
retq
// File: nightmeng[P]net/src/socket.cpp
// Function: socket::eevent()
void socket::eevent(){
	if(CONNECTING == connect_status){
		std::function<void()> callback;
		{
			std::lock_guard<std::mutex> locker(conn_mutex);
			if(conn_request.empty()){
				return;
			}
			callback = conn_request.front();
			conn_request.pop_front();
			if(nullptr == callback)
				return;
		}
		callback();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movl $0x1, %eax
cmpl 0x1f4(%rcx), %eax
jne 0xc1d1
leaq -0x28(%rbp), %rdi
callq 0xcff0
movq -0x48(%rbp), %rsi
addq $0x170, %rsi            # imm = 0x170
leaq -0x30(%rbp), %rdi
callq 0x7330
jmp 0xc0f4
movq -0x48(%rbp), %rdi
addq $0x1c8, %rdi            # imm = 0x1C8
callq 0xd030
testb $0x1, %al
jne 0xc10a
jmp 0xc124
movl $0x1, -0x40(%rbp)
jmp 0xc18c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xc1c6
movq -0x48(%rbp), %rdi
addq $0x1c8, %rdi            # imm = 0x1C8
callq 0xd050
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0xd080
jmp 0xc142
movq -0x48(%rbp), %rdi
addq $0x1c8, %rdi            # imm = 0x1C8
callq 0xd0d0
xorl %eax, %eax
movl %eax, %edi
leaq -0x28(%rbp), %rsi
callq 0xd100
testb $0x1, %al
jne 0xc165
jmp 0xc185
movl $0x1, -0x40(%rbp)
jmp 0xc18c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x73e0
jmp 0xc1c6
movl $0x0, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x73e0
movl -0x40(%rbp), %eax
testl %eax, %eax
jne 0xc1b0
jmp 0xc19e
leaq -0x28(%rbp), %rdi
callq 0xd130
jmp 0xc1a9
movl $0x0, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6b50
movl -0x40(%rbp), %eax
testl %eax, %eax
je 0xc1c4
jmp 0xc1c2
jmp 0xc1d1
jmp 0xc1d1
leaq -0x28(%rbp), %rdi
callq 0x6b50
jmp 0xc1d7
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4360
// File: nightmeng[P]net/src/socket.cpp
// Function: socket::read_some(char*, unsigned long)
inline int socket::read_some(char *buff, size_t length){
	int cnt = 0;
	int nread = 0;

	while(cnt < length && (nread = ::read(sock, buff, length)) > 0){
		cnt += nread;
	}

	if(nread > 0){
		return cnt;
	}
	else if(-1 == nread && EAGAIN == errno){
		rdable = false;
		return cnt;
	}
	else{
		return -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movslq -0x24(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x31(%rbp)
jae 0xcdc9
movq -0x30(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x42b0
movl %eax, -0x28(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xcdd2
jmp 0xcddd
movl -0x28(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0xcd9a
cmpl $0x0, -0x28(%rbp)
jle 0xcdeb
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xce20
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x28(%rbp), %eax
jne 0xce19
callq 0x4030
movq %rax, %rcx
movl $0xb, %eax
cmpl (%rcx), %eax
jne 0xce19
movq -0x30(%rbp), %rax
movb $0x0, 0x1f0(%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xce20
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: nightmeng[P]net/src/socket.cpp
// Function: socket::write_some(char const*, unsigned long)
inline int socket::write_some(const char *buff, size_t length){
	int cnt = 0;
	int nwrite = 0;
	while(cnt < length && (nwrite = ::write(sock, buff, length)) > 0){
		cnt += nwrite;
	}

	if(nwrite > 0){
		return cnt;
	}
	else if(-1 == nwrite && EAGAIN == errno){
		wrable = false;
		return cnt;
	}
	else{
		return -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movslq -0x24(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x31(%rbp)
jae 0xce89
movq -0x30(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x40c0
movl %eax, -0x28(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xce92
jmp 0xce9d
movl -0x28(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0xce5a
cmpl $0x0, -0x28(%rbp)
jle 0xceab
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcee0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x28(%rbp), %eax
jne 0xced9
callq 0x4030
movq %rax, %rcx
movl $0xb, %eax
cmpl (%rcx), %eax
jne 0xced9
movq -0x30(%rbp), %rax
movb $0x0, 0x1f1(%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcee0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: nightmeng[P]net/src/socket_base.cpp
// Function: socket_base::register_epoll_req()
void socket_base::register_epoll_req(){
	if(-1 == sock){
		return;
	}
	if(!epolled){
		singleton<epoll>::instance()->add_request(
				this, EPOLLHUP|EPOLLRDHUP|EPOLLPRI|EPOLLOUT|EPOLLIN|EPOLLET);
		epolled = true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x8(%rcx), %eax
jne 0x13780
jmp 0x137b0
movq -0x10(%rbp), %rax
testb $0x1, 0xc(%rax)
jne 0x137b0
callq 0x13a70
movq %rax, %rdi
callq 0x13b60
movq -0x10(%rbp), %rsi
movq %rax, %rdi
movl $0x80002017, %edx       # imm = 0x80002017
callq 0x15e50
movq -0x10(%rbp), %rax
movb $0x1, 0xc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nightmeng[P]net/src/socket_base.cpp
// Function: socket_base::unregister_epoll_req()
void socket_base::unregister_epoll_req(){
	if(-1 == sock){
		return;
	}
	if(epolled){
		singleton<epoll>::instance()->del_request(this);
		epolled = false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x8(%rcx), %eax
jne 0x13870
jmp 0x1389b
movq -0x10(%rbp), %rax
testb $0x1, 0xc(%rax)
je 0x1389b
callq 0x13a70
movq %rax, %rdi
callq 0x13b60
movq -0x10(%rbp), %rsi
movq %rax, %rdi
callq 0x15ef0
movq -0x10(%rbp), %rax
movb $0x0, 0xc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nightmeng[P]net/src/socket_base.cpp
// Function: socket_base::set_noblock()
bool socket_base::set_noblock(){
	if(-1 == sock){
		return false;
	}
	int flags = fcntl(sock, F_GETFL, 0);
	if(flags < 0){
		return false;
	}

	if(fcntl(sock, F_SETFL, flags | O_NONBLOCK) < 0) {
		return false;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x8(%rcx), %eax
jne 0x13944
movb $0x0, -0x1(%rbp)
jmp 0x13993
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edi
movl $0x3, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0x4150
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x13968
movb $0x0, -0x1(%rbp)
jmp 0x13993
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edi
movl -0x14(%rbp), %edx
orl $0x800, %edx            # imm = 0x800
movl $0x4, %esi
movb $0x0, %al
callq 0x4150
cmpl $0x0, %eax
jge 0x1398f
movb $0x0, -0x1(%rbp)
jmp 0x13993
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: nightmeng[P]net/src/worker.cpp
// Function: worker::worker()
worker::worker():stop(false), onced(true){
	mutex.lock();
	stop = false;
	thread = std::shared_ptr<std::thread>(
			new std::thread(std::bind(&worker::work, this)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xc2d0
movq -0x70(%rbp), %rdi
movb $0x0, 0x28(%rdi)
movb $0x1, 0x2a(%rdi)
addq $0x30, %rdi
movq %rdi, -0x60(%rbp)
callq 0x145d0
movq -0x70(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x78(%rbp)
callq 0xcff0
movq -0x70(%rbp), %rdi
addq $0x78, %rdi
movq %rdi, -0x68(%rbp)
callq 0x145f0
movq -0x60(%rbp), %rdi
callq 0x14610
jmp 0x14172
movq -0x70(%rbp), %rax
movb $0x0, 0x28(%rax)
movl $0x8, %edi
callq 0x4210
movq %rax, -0x80(%rbp)
jmp 0x1418a
movq -0x70(%rbp), %rax
leaq 0xab(%rip), %rcx        # 0x14240
movq %rcx, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x14640
jmp 0x141b8
movq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x14680
jmp 0x141c7
movq -0x80(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x14730
jmp 0x141d6
movq -0x70(%rbp), %rdi
addq $0x78, %rdi
leaq -0x28(%rbp), %rsi
callq 0x14760
leaq -0x28(%rbp), %rdi
callq 0x14790
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1421c
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x41f0
movq -0x68(%rbp), %rdi
callq 0x14790
movq -0x78(%rbp), %rdi
callq 0x6b50
movq -0x10(%rbp), %rdi
callq 0x4360
nopw (%rax,%rax)
// File: nightmeng[P]net/src/worker.cpp
// Function: worker::work()
void worker::work(){
	while(true){
		while(!mutex.try_lock_for(std::chrono::milliseconds(30))){
			if(stop)
				return;
		}
		std::lock_guard<std::mutex> locker(task_safe);
		if(proc != nullptr)
			proc();
		if(once){
			proc = nullptr;
			onced = true;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x14256
movq -0x38(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x40(%rbp)
movl $0x1e, -0x14(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x14890
movq -0x40(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x14860
xorb $-0x1, %al
testb $0x1, %al
jne 0x1428b
jmp 0x1429d
movq -0x38(%rbp), %rax
testb $0x1, 0x28(%rax)
je 0x1429b
addq $0x40, %rsp
popq %rbp
retq
jmp 0x14256
movq -0x38(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x7330
movq -0x38(%rbp), %rdi
addq $0x58, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x148b0
testb $0x1, %al
jne 0x142c1
jmp 0x142e9
movq -0x38(%rbp), %rdi
addq $0x58, %rdi
callq 0xd130
jmp 0x142d0
jmp 0x142e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x73e0
jmp 0x1431a
movq -0x38(%rbp), %rax
testb $0x1, 0x29(%rax)
je 0x1430c
movq -0x38(%rbp), %rdi
addq $0x58, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x148e0
movq -0x38(%rbp), %rax
movb $0x1, 0x2a(%rax)
leaq -0x20(%rbp), %rdi
callq 0x73e0
jmp 0x14254
movq -0x28(%rbp), %rdi
callq 0x4360
nopw %cs:(%rax,%rax)
// File: nightmeng[P]net/src/worker.cpp
// Function: worker::interrupt()
void worker::interrupt(){
	if(nullptr != thread){
		stop = true;
		if(thread->joinable()){
			thread->join();
		}
		thread = nullptr;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x20(%rbp)
addq $0x78, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x147b0
testb $0x1, %al
jne 0x143a7
jmp 0x14402
movq -0x20(%rbp), %rdi
movb $0x1, 0x28(%rdi)
addq $0x78, %rdi
callq 0x147e0
movq %rax, %rdi
callq 0x14800
testb $0x1, %al
jne 0x143c6
jmp 0x143db
movq -0x20(%rbp), %rdi
addq $0x78, %rdi
callq 0x147e0
movq %rax, %rdi
callq 0x4330
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x14840
movq -0x20(%rbp), %rdi
addq $0x78, %rdi
leaq -0x18(%rbp), %rsi
callq 0x14760
leaq -0x18(%rbp), %rdi
callq 0x14790
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: nightmeng[P]net/src/worker.cpp
// Function: worker::task(std::function<void ()>)
bool worker::task(std::function<void()> job){
	if(task_safe.try_lock()){
		once = false;
		proc = job;
		task_safe.unlock();
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x14940
testb $0x1, %al
jne 0x14437
jmp 0x1445b
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movb $0x0, 0x29(%rdi)
addq $0x58, %rdi
callq 0xd080
movq -0x20(%rbp), %rdi
callq 0x7860
movb $0x1, -0x1(%rbp)
jmp 0x1445f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: nightmeng[P]net/src/worker.cpp
// Function: worker::task_once(std::function<void ()>)
bool worker::task_once(std::function<void()> job){
	if(onced && task_safe.try_lock()){
		once = true;
		onced = false;
		proc = job;
		task_safe.unlock();
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x2a(%rax)
je 0x144c9
movq -0x20(%rbp), %rdi
callq 0x14940
testb $0x1, %al
jne 0x144a1
jmp 0x144c9
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movb $0x1, 0x29(%rdi)
movb $0x0, 0x2a(%rdi)
addq $0x58, %rdi
callq 0xd080
movq -0x20(%rbp), %rdi
callq 0x7860
movb $0x1, -0x1(%rbp)
jmp 0x144cd
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: nightmeng[P]net/src/epoll.cpp
// Function: epoll::interrupt()
void epoll::interrupt(){
	if(nullptr != service){
		polling = false;
		if(service->joinable()){
			service->join();
		}
		service = nullptr;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x20(%rbp)
addq $0x8, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x147b0
testb $0x1, %al
jne 0x15de7
jmp 0x15e41
movq -0x20(%rbp), %rdi
movb $0x0, (%rdi)
addq $0x8, %rdi
callq 0x147e0
movq %rax, %rdi
callq 0x14800
testb $0x1, %al
jne 0x15e05
jmp 0x15e1a
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x147e0
movq %rax, %rdi
callq 0x4330
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x14840
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
leaq -0x18(%rbp), %rsi
callq 0x14760
leaq -0x18(%rbp), %rdi
callq 0x14790
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: nightmeng[P]net/src/epoll.cpp
// Function: epoll::add_request(socket_base*, int)
void epoll::add_request(socket_base *sock, int events){
	struct epoll_event ev;
	ev.events = events;
	ev.data.ptr = sock;

	epoll_ctl(fd, EPOLL_CTL_ADD, sock->fd(), &ev);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x1c(%rbp)
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13900
movl -0x24(%rbp), %edi
movl %eax, %edx
movl $0x1, %esi
leaq -0x20(%rbp), %rcx
callq 0x4290
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: nightmeng[P]net/src/epoll.cpp
// Function: epoll::update_request(socket_base*, int)
void epoll::update_request(socket_base *sock, int events){
	struct epoll_event ev;
	ev.events = events;
	ev.data.ptr = sock;

	epoll_ctl(fd, EPOLL_CTL_MOD, sock->fd(), &ev);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x1c(%rbp)
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13900
movl -0x24(%rbp), %edi
movl %eax, %edx
movl $0x3, %esi
leaq -0x20(%rbp), %rcx
callq 0x4290
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: nightmeng[P]net/src/epoll.cpp
// Function: epoll::poll_service()
void epoll::poll_service(){
	struct epoll_event evs[20000];
	polling = true;
	while(polling){
		int cnt = ::epoll_wait(fd, evs, 20000, 30);

		for(int i = 0; i != cnt; ++i){
			struct epoll_event &ev = evs[i];

			socket_base *sock = reinterpret_cast<socket_base*>(ev.data.ptr);
			if(nullptr == sock){
				continue;
			}

			if(ev.events & EPOLLRDHUP){
				sock->rdhupevent();
			}
			else{
				if(ev.events & EPOLLERR){
					sock->eevent();
				}
				if(ev.events & EPOLLIN){
					sock->ievent();
				}
				if(ev.events & EPOLLOUT){
					sock->oevent();
				}
				if(ev.events & EPOLLHUP){
					sock->hupevent();
				}
				if(ev.events & EPOLLPRI){
					sock->prievent();
				}
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3a9b0, %rsp          # imm = 0x3A9B0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x3a9b0(%rbp)
movb $0x1, (%rax)
movq -0x3a9b0(%rbp), %rax
testb $0x1, (%rax)
je 0x16175
movq -0x3a9b0(%rbp), %rax
movl 0x4(%rax), %edi
leaq -0x3a990(%rbp), %rsi
movl $0x4e20, %edx           # imm = 0x4E20
movl $0x1e, %ecx
callq 0x4120
movl %eax, -0x3a994(%rbp)
movl $0x0, -0x3a998(%rbp)
movl -0x3a998(%rbp), %eax
cmpl -0x3a994(%rbp), %eax
je 0x16170
movslq -0x3a998(%rbp), %rcx
leaq -0x3a990(%rbp), %rax
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x3a9a0(%rbp)
movq -0x3a9a0(%rbp), %rax
movq 0x4(%rax), %rax
movq %rax, -0x3a9a8(%rbp)
xorl %eax, %eax
cmpq -0x3a9a8(%rbp), %rax
jne 0x1609d
jmp 0x1615c
movq -0x3a9a0(%rbp), %rax
movl (%rax), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x160c2
movq -0x3a9a8(%rbp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
jmp 0x1615a
movq -0x3a9a0(%rbp), %rax
movl (%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x160e0
movq -0x3a9a8(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x3a9a0(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x160fe
movq -0x3a9a8(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x3a9a0(%rbp), %rax
movl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x1611c
movq -0x3a9a8(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x3a9a0(%rbp), %rax
movl (%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x1613a
movq -0x3a9a8(%rbp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq -0x3a9a0(%rbp), %rax
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x16158
movq -0x3a9a8(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
jmp 0x1615a
jmp 0x1615c
movl -0x3a998(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3a998(%rbp)
jmp 0x1604d
jmp 0x1600d
addq $0x3a9b0, %rsp          # imm = 0x3A9B0
popq %rbp
retq
nop
// File: qema[P]orca-py/liborca.cpp
// Function: operator<(TRIPLE const&, TRIPLE const&)
bool operator<(const TRIPLE &x, const TRIPLE &y) {
    if (x.a==y.a) {
        if (x.b==y.b) return x.c<y.c;
        else return x.b<y.b;
    } else return x.a<y.a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x106ea
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x106d2
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x106fe
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x106fe
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: qema[P]orca-py/liborca.cpp
// Function: writeResults(int, char const*)
int writeResults(int g, const char* output_filename) {
    fstream fout; 
    if (fout.fail()) {
        cerr << "Failed to open file " << output_filename << endl;
        return 1;
    }
    fout.open(output_filename, fstream::out | fstream::binary);
    int no[] = {0,0,1,4,15,73};
    for (int i=0;i<n;i++) {
        for (int j=0;j<no[g];j++) {
            if (j!=0) 
                fout << " ";
            fout << orbit[i][j];
        }
        fout << endl;
    }
    fout.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x10290
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x10030
movb %al, -0x259(%rbp)
jmp 0x1f3be
movb -0x259(%rbp), %al
testb $0x1, %al
jne 0x1f3cd
jmp 0x1f454
movq 0xec1c(%rip), %rdi      # 0x2dff0
leaq 0x8c45(%rip), %rsi      # 0x28020
callq 0x10200
movq %rax, -0x268(%rbp)
jmp 0x1f3e9
movq -0x268(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10200
movq %rax, -0x270(%rbp)
jmp 0x1f402
movq -0x270(%rbp), %rdi
movq 0xeb50(%rip), %rsi      # 0x2df60
callq 0x10240
jmp 0x1f417
leaq -0x220(%rbp), %rdi
callq 0x10070
movl $0x1, %eax
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x10070
jmp 0x1f593
movq -0x10(%rbp), %rax
movq %rax, -0x280(%rbp)
movl $0x10, %edi
movl $0x4, %esi
callq 0x21280
movl %eax, -0x274(%rbp)
jmp 0x1f476
movl -0x274(%rbp), %edx
movq -0x280(%rbp), %rsi
leaq -0x220(%rbp), %rdi
callq 0x101d0
jmp 0x1f491
movq 0x8d88(%rip), %rax      # 0x28220
movq %rax, -0x250(%rbp)
movq 0x8d82(%rip), %rax      # 0x28228
movq %rax, -0x248(%rbp)
movq 0x8d7c(%rip), %rax      # 0x28230
movq %rax, -0x240(%rbp)
movl $0x0, -0x254(%rbp)
movl -0x254(%rbp), %eax
movq 0xeace(%rip), %rcx      # 0x2dfa0
cmpl (%rcx), %eax
jge 0x1f583
movl $0x0, -0x258(%rbp)
movl -0x258(%rbp), %eax
movslq -0x4(%rbp), %rcx
cmpl -0x250(%rbp,%rcx,4), %eax
jge 0x1f558
cmpl $0x0, -0x258(%rbp)
je 0x1f517
leaq -0x210(%rbp), %rdi
leaq 0x8b25(%rip), %rsi      # 0x28033
callq 0x10200
jmp 0x1f515
jmp 0x1f517
leaq -0x210(%rbp), %rdi
movq 0xea13(%rip), %rax      # 0x2df38
movq (%rax), %rax
movslq -0x254(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x258(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x100d0
jmp 0x1f545
jmp 0x1f547
movl -0x258(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x258(%rbp)
jmp 0x1f4e4
leaq -0x210(%rbp), %rdi
movq 0xe9fa(%rip), %rsi      # 0x2df60
callq 0x10240
jmp 0x1f56d
jmp 0x1f56f
movl -0x254(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x254(%rbp)
jmp 0x1f4c5
leaq -0x220(%rbp), %rdi
callq 0x10040
jmp 0x1f591
ud2
movq -0x228(%rbp), %rdi
callq 0x10390
nop
// File: qema[P]orca-py/liborca.cpp
// Function: writeResultsString[abi:cxx11](int)
string writeResultsString(int g) {
    std::stringstream ss("", ios_base::app | ios_base::out);
    int no[] = {0,0,1,4,15,73};
    for (int i=0;i<n;i++) {
        for (int j=0;j<no[g];j++) {
            if (j!=0) 
                ss << " ";
            ss << orbit[i][j];
        }
        ss << endl;
    }
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x210(%rbp)
movq %rdi, %rax
movq %rax, -0x208(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x1b9(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0x103a0
movq -0x200(%rbp), %rdx
leaq 0x8b73(%rip), %rsi      # 0x28157
leaq -0x1b8(%rbp), %rdi
callq 0x212a0
jmp 0x1f5f2
movl $0x1, %edi
movl $0x10, %esi
callq 0x21280
movl %eax, -0x214(%rbp)
jmp 0x1f609
movl -0x214(%rbp), %edx
leaq -0x198(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x10350
jmp 0x1f624
leaq -0x1b8(%rbp), %rdi
callq 0x103e8
leaq -0x1b9(%rbp), %rdi
callq 0x10260
movq 0x8bfd(%rip), %rax      # 0x28240
movq %rax, -0x1f0(%rbp)
movq 0x8bf7(%rip), %rax      # 0x28248
movq %rax, -0x1e8(%rbp)
movq 0x8bf1(%rip), %rax      # 0x28250
movq %rax, -0x1e0(%rbp)
movl $0x0, -0x1f4(%rbp)
movl -0x1f4(%rbp), %eax
movq 0xe923(%rip), %rcx      # 0x2dfa0
cmpl (%rcx), %eax
jge 0x1f79b
movl $0x0, -0x1f8(%rbp)
movl -0x1f8(%rbp), %eax
movslq -0xc(%rbp), %rcx
cmpl -0x1f0(%rbp,%rcx,4), %eax
jge 0x1f770
cmpl $0x0, -0x1f8(%rbp)
je 0x1f72c
leaq -0x188(%rbp), %rdi
leaq 0x8976(%rip), %rsi      # 0x28033
callq 0x10200
jmp 0x1f6c4
jmp 0x1f72c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
jmp 0x1f6f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x103e8
leaq -0x1b9(%rbp), %rdi
callq 0x10260
jmp 0x1f7cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x10160
jmp 0x1f7cc
leaq -0x188(%rbp), %rdi
movq 0xe7fe(%rip), %rax      # 0x2df38
movq (%rax), %rax
movslq -0x1f4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1f8(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x100d0
jmp 0x1f75a
jmp 0x1f75c
movl -0x1f8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1f8(%rbp)
jmp 0x1f68f
leaq -0x188(%rbp), %rdi
movq 0xe7e2(%rip), %rsi      # 0x2df60
callq 0x10240
jmp 0x1f785
jmp 0x1f787
movl -0x1f4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1f4(%rbp)
jmp 0x1f670
movq -0x210(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x101f0
jmp 0x1f7b0
leaq -0x198(%rbp), %rdi
callq 0x10160
movq -0x208(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq -0x1c8(%rbp), %rdi
callq 0x10390
nopl (%rax,%rax)
// File: qema[P]orca-py/liborca.cpp
// Function: writeEdgeResults(int, char const*)
int writeEdgeResults(int g, const char* output_filename) {
    fstream fout; 
    if (fout.fail()) {
        cerr << "Failed to open file " << output_filename << endl;
        return 1;
    }
    int no[] = {0,0,0,2,12,68};
    for (int i=0;i<m;i++) {
        for (int j=0;j<no[g];j++) {
            if (j!=0) fout << " ";
            fout << eorbit[i][j];
        }
        fout << endl;
    }
    fout.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x10290
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x10030
movb %al, -0x259(%rbp)
jmp 0x1f81e
movb -0x259(%rbp), %al
testb $0x1, %al
jne 0x1f82d
jmp 0x1f8b4
movq 0xe7bc(%rip), %rdi      # 0x2dff0
leaq 0x87e5(%rip), %rsi      # 0x28020
callq 0x10200
movq %rax, -0x268(%rbp)
jmp 0x1f849
movq -0x268(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10200
movq %rax, -0x270(%rbp)
jmp 0x1f862
movq -0x270(%rbp), %rdi
movq 0xe6f0(%rip), %rsi      # 0x2df60
callq 0x10240
jmp 0x1f877
leaq -0x220(%rbp), %rdi
callq 0x10070
movl $0x1, %eax
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x10070
jmp 0x1f9b6
movq 0x89a5(%rip), %rax      # 0x28260
movq %rax, -0x250(%rbp)
movq 0x899f(%rip), %rax      # 0x28268
movq %rax, -0x248(%rbp)
movq 0x8999(%rip), %rax      # 0x28270
movq %rax, -0x240(%rbp)
movl $0x0, -0x254(%rbp)
movl -0x254(%rbp), %eax
movq 0xe653(%rip), %rcx      # 0x2df48
cmpl (%rcx), %eax
jge 0x1f9a6
movl $0x0, -0x258(%rbp)
movl -0x258(%rbp), %eax
movslq -0x4(%rbp), %rcx
cmpl -0x250(%rbp,%rcx,4), %eax
jge 0x1f97b
cmpl $0x0, -0x258(%rbp)
je 0x1f93a
leaq -0x210(%rbp), %rdi
leaq 0x8702(%rip), %rsi      # 0x28033
callq 0x10200
jmp 0x1f938
jmp 0x1f93a
leaq -0x210(%rbp), %rdi
movq 0xe610(%rip), %rax      # 0x2df58
movq (%rax), %rax
movslq -0x254(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x258(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x100d0
jmp 0x1f968
jmp 0x1f96a
movl -0x258(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x258(%rbp)
jmp 0x1f907
leaq -0x210(%rbp), %rdi
movq 0xe5d7(%rip), %rsi      # 0x2df60
callq 0x10240
jmp 0x1f990
jmp 0x1f992
movl -0x254(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x254(%rbp)
jmp 0x1f8e8
leaq -0x220(%rbp), %rdi
callq 0x10040
jmp 0x1f9b4
ud2
movq -0x228(%rbp), %rdi
callq 0x10390
nopw %cs:(%rax,%rax)
// File: qema[P]orca-py/liborca.cpp
// Function: writeEdgeResultsString[abi:cxx11](int)
string writeEdgeResultsString(int g) {
    std::stringstream ss("", ios_base::app | ios_base::out);
    int no[] = {0,0,0,2,12,68};
    for (int i=0;i<m;i++) {
        for (int j=0;j<no[g];j++) {
            if (j!=0) ss << " ";
            ss << eorbit[i][j];
        }
        ss << endl;
    }
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x210(%rbp)
movq %rdi, %rax
movq %rax, -0x208(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x1b9(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0x103a0
movq -0x200(%rbp), %rdx
leaq 0x8743(%rip), %rsi      # 0x28157
leaq -0x1b8(%rbp), %rdi
callq 0x212a0
jmp 0x1fa22
movl $0x1, %edi
movl $0x10, %esi
callq 0x21280
movl %eax, -0x214(%rbp)
jmp 0x1fa39
movl -0x214(%rbp), %edx
leaq -0x198(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x10350
jmp 0x1fa54
leaq -0x1b8(%rbp), %rdi
callq 0x103e8
leaq -0x1b9(%rbp), %rdi
callq 0x10260
movq 0x880d(%rip), %rax      # 0x28280
movq %rax, -0x1f0(%rbp)
movq 0x8807(%rip), %rax      # 0x28288
movq %rax, -0x1e8(%rbp)
movq 0x8801(%rip), %rax      # 0x28290
movq %rax, -0x1e0(%rbp)
movl $0x0, -0x1f4(%rbp)
movl -0x1f4(%rbp), %eax
movq 0xe49b(%rip), %rcx      # 0x2df48
cmpl (%rcx), %eax
jge 0x1fbcb
movl $0x0, -0x1f8(%rbp)
movl -0x1f8(%rbp), %eax
movslq -0xc(%rbp), %rcx
cmpl -0x1f0(%rbp,%rcx,4), %eax
jge 0x1fba0
cmpl $0x0, -0x1f8(%rbp)
je 0x1fb5c
leaq -0x188(%rbp), %rdi
leaq 0x8546(%rip), %rsi      # 0x28033
callq 0x10200
jmp 0x1faf4
jmp 0x1fb5c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
jmp 0x1fb28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x103e8
leaq -0x1b9(%rbp), %rdi
callq 0x10260
jmp 0x1fbfc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x10160
jmp 0x1fbfc
leaq -0x188(%rbp), %rdi
movq 0xe3ee(%rip), %rax      # 0x2df58
movq (%rax), %rax
movslq -0x1f4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1f8(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x100d0
jmp 0x1fb8a
jmp 0x1fb8c
movl -0x1f8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1f8(%rbp)
jmp 0x1fabf
leaq -0x188(%rbp), %rdi
movq 0xe3b2(%rip), %rsi      # 0x2df60
callq 0x10240
jmp 0x1fbb5
jmp 0x1fbb7
movl -0x1f4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1f4(%rbp)
jmp 0x1faa0
movq -0x210(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x101f0
jmp 0x1fbe0
leaq -0x198(%rbp), %rdi
callq 0x10160
movq -0x208(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq -0x1c8(%rbp), %rdi
callq 0x10390
nopl (%rax,%rax)
// File: qema[P]orca-py/liborca.cpp
// Function: motif_counts_wrap(_object*, _object*)
PyObject * motif_counts_wrap(PyObject *self, PyObject *args) {
    //(const char* orbit_type, int graphlet_size, 
    //    const char* input_filename, const char* output_filename, string &out_str)
    char *orbit_type, *input_filename;//, *output_filename;
	int graphlet_size;

	if(!PyArg_ParseTuple(args, "sis", &orbit_type, &graphlet_size,
                &input_filename))
		return NULL;

	//sprintf(eq, "%d + %d", num1, num2);
    static string out;
    motif_counts(orbit_type, graphlet_size, input_filename, "", out);

	//return Py_BuildValue("is", num1 + num2, eq);
	return PyUnicode_FromString(out.c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x757d(%rip), %rsi      # 0x28158
leaq -0x20(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
leaq -0x28(%rbp), %r8
movb $0x0, %al
callq 0x102d0
cmpl $0x0, %eax
jne 0x20c00
movq $0x0, -0x8(%rbp)
jmp 0x20c82
cmpb $0x0, 0xd7c1(%rip)      # 0x2e3c8
jne 0x20c4c
leaq 0xd7b8(%rip), %rdi      # 0x2e3c8
callq 0x103c0
cmpl $0x0, %eax
je 0x20c4c
leaq 0xd787(%rip), %rdi      # 0x2e3a8
callq 0x10300
movq 0xd36b(%rip), %rdi      # 0x2df98
leaq 0xd774(%rip), %rsi      # 0x2e3a8
leaq 0xd5b5(%rip), %rdx      # 0x2e1f0
callq 0x101b0
leaq 0xd781(%rip), %rdi      # 0x2e3c8
callq 0x10100
movq -0x20(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x28(%rbp), %rdx
leaq 0x74f9(%rip), %rcx      # 0x28157
leaq 0xd743(%rip), %r8       # 0x2e3a8
callq 0x1fc10
leaq 0xd737(%rip), %rdi      # 0x2e3a8
callq 0x100b0
movq %rax, %rdi
callq 0x101a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: qema[P]orca-py/liborca.cpp
// Function: init(int, char**)
int init(int argc, char *argv[]) {
    if (argc!=5) {
        cerr << "Incorrect number of arguments." << endl;
        cerr << "Usage: orca.exe [orbit type: node|edge] [graphlet size: 4/5] [graph - input file] [graphlets - output file]" << endl;
        return 0;
    }
    int graphlet_size;
    sscanf(argv[2],"%d", &graphlet_size);
    string out;
    motif_counts(argv[1], graphlet_size, argv[3], argv[4], out);

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x5, -0x8(%rbp)
je 0x20cf2
movq 0xd344(%rip), %rdi      # 0x2dff0
leaq 0x74a9(%rip), %rsi      # 0x2815c
callq 0x10200
movq %rax, %rdi
movq 0xd29e(%rip), %rsi      # 0x2df60
callq 0x10240
movq 0xd322(%rip), %rdi      # 0x2dff0
leaq 0x74a6(%rip), %rsi      # 0x2817b
callq 0x10200
movq %rax, %rdi
movq 0xd27c(%rip), %rsi      # 0x2df60
callq 0x10240
movl $0x0, -0x4(%rbp)
jmp 0x20d60
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x74e6(%rip), %rsi      # 0x281e7
xorl %eax, %eax
leaq -0x14(%rbp), %rdx
callq 0x101e0
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x10300
movq -0x50(%rbp), %r8
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %esi
movq 0x8(%rax), %rdi
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rcx
callq 0x1fc10
jmp 0x20d37
movl $0x1, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x103e8
jmp 0x20d60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x103e8
jmp 0x20d69
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x10390
nopw %cs:(%rax,%rax)
// File: qema[P]orca-py/liborca.cpp
// Function: main
int main(int argc, char *argv[]) {


    if (!init(argc, argv)) {
//        cerr << "Stopping!" << endl;
        return 1;
    }
    

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x20c90
cmpl $0x0, %eax
jne 0x20db0
movl $0x1, -0x4(%rbp)
jmp 0x20db7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: qema[P]orca-py/liborca.cpp
// Function: TRIPLE::TRIPLE(int, int, int)
TRIPLE(int a0, int b0, int c0) {
        a=a0; b=b0; c=c0;
        if (a>b) swap(a,b);
        if (b>c) swap(b,c);
        if (a>b) swap(a,b);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, (%rcx)
movl -0x10(%rbp), %eax
movl %eax, 0x4(%rcx)
movl -0x14(%rbp), %eax
movl %eax, 0x8(%rcx)
movl (%rcx), %eax
cmpl 0x4(%rcx), %eax
jle 0x21085
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x4, %rsi
callq 0x222f0
movq -0x20(%rbp), %rcx
movl 0x4(%rcx), %eax
cmpl 0x8(%rcx), %eax
jle 0x210a5
movq -0x20(%rbp), %rsi
movq %rsi, %rdi
addq $0x4, %rdi
addq $0x8, %rsi
callq 0x222f0
movq -0x20(%rbp), %rcx
movl (%rcx), %eax
cmpl 0x4(%rcx), %eax
jle 0x210c0
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x4, %rsi
callq 0x222f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ivanzamanov[P]kmeans/src/stemmer/stemmer.cpp
// Function: main
int main(int argc, char** argv) {
	int inputFD = -1;
	int outputFD = -1;

	const char* inputPath = "STDIN";
	if(argc < 2) {
		inputFD = 0;
	} else {
		inputPath = argv[1];
		inputFD = open(inputPath, O_RDONLY);
		if(inputFD < 0) {
			printf("Cannot open file %s\n", inputPath);
			return 1;
		}
	}

	if(argc < 3) {
		outputFD = 1;
	} else {
		char* outputPath = argv[2];
		outputFD = open(outputPath, O_WRONLY | O_CREAT, 0664);
		if(outputFD < 0) {
			printf("Cannot open file %s\n", outputPath);
			return 1;
		}
	}

	struct stat fileStat;
	if(fstat(inputFD, &fileStat) != 0) {
		printf("Cannot stat file %s\n", inputPath);
		return 1;
	}

	processFile(inputFD, outputFD, &fileStat);

	if(outputFD == 1) {
		printf("\n");
	}
}

// Assembly:
subq $0xb8, %rsp
movl $0x0, 0xb4(%rsp)
movl %edi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movl $0xffffffff, 0xa4(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0xa0(%rsp) # imm = 0xFFFFFFFF
leaq 0x1df6(%rip), %rax      # 0x3004
movq %rax, 0x98(%rsp)
cmpl $0x2, 0xb0(%rsp)
jge 0x122d
movl $0x0, 0xa4(%rsp)
jmp 0x128b
movq 0xa8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x1080
movl %eax, 0xa4(%rsp)
cmpl $0x0, 0xa4(%rsp)
jge 0x1289
movq 0x98(%rsp), %rsi
leaq 0x1d98(%rip), %rdi      # 0x300a
movb $0x0, %al
callq 0x1040
movl $0x1, 0xb4(%rsp)
jmp 0x136a
jmp 0x128b
cmpl $0x3, 0xb0(%rsp)
jge 0x12a2
movl $0x1, 0xa0(%rsp)
jmp 0x1305
movq 0xa8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rdi
movl $0x41, %esi
movl $0x1b4, %edx            # imm = 0x1B4
movb $0x0, %al
callq 0x1080
movl %eax, 0xa0(%rsp)
cmpl $0x0, 0xa0(%rsp)
jge 0x1303
movq 0x90(%rsp), %rsi
leaq 0x1d1b(%rip), %rdi      # 0x300a
movb $0x0, %al
callq 0x1040
movl $0x1, 0xb4(%rsp)
jmp 0x136a
jmp 0x1305
movl 0xa4(%rsp), %edi
movq %rsp, %rsi
callq 0x10c0
cmpl $0x0, %eax
je 0x133c
movq 0x98(%rsp), %rsi
leaq 0x1cf7(%rip), %rdi      # 0x301f
movb $0x0, %al
callq 0x1040
movl $0x1, 0xb4(%rsp)
jmp 0x136a
movl 0xa4(%rsp), %edi
movl 0xa0(%rsp), %esi
movq %rsp, %rdx
callq 0x1380
cmpl $0x1, 0xa0(%rsp)
jne 0x136a
leaq 0x1f40(%rip), %rdi      # 0x32a3
movb $0x0, %al
callq 0x1040
movl 0xb4(%rsp), %eax
addq $0xb8, %rsp
retq
nopl (%rax)