LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: nmmmnu[P]asyncore_cpp/net/test/test_selector_impl.h
// Function: main
int main(){
	using MySelector = MySelector;
	using MyWorker   = MyWorker;

	int const fd1 = net::socket_create(net::socket_tcp,  "localhost.not.used.yet", 2000);
	int const fd2 = net::socket_create(net::socket_tcp,  "localhost.not.used.yet", 2002);
	int const fd3 = net::socket_create(net::socket_unix, "/tmp/echo");

	net::AsyncLoop<MySelector, MyWorker> loop( MySelector{ 4 }, MyWorker{}, { fd1, fd2, fd3 } );

	while(loop.process());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movl $0x0, -0x4(%rbp)
leaq 0x5c27(%rip), %rdi      # 0x8060
movq %rdi, -0xf8(%rbp)
movl $0x7d0, %esi            # imm = 0x7D0
xorl %ecx, %ecx
movl %ecx, -0xec(%rbp)
movl %ecx, %edx
callq 0x7840
movq -0xf8(%rbp), %rdi
movl -0xec(%rbp), %ecx
movl %eax, -0x8(%rbp)
movl $0x7d2, %esi            # imm = 0x7D2
movl %ecx, %edx
callq 0x7840
movl -0xec(%rbp), %esi
movl %eax, -0x10(%rbp)
leaq 0x5bf7(%rip), %rdi      # 0x8077
movl $0x1, %edx
callq 0x79c0
movl %eax, -0x18(%rbp)
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
movl $0x4, %esi
callq 0x6130
movq -0xe8(%rbp), %rsi
movl -0x8(%rbp), %eax
movl %eax, -0xcc(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0xc8(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0xc4(%rbp)
leaq -0xcc(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq $0x3, -0xb8(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0xa9(%rbp), %rdx
leaq -0xc0(%rbp), %rcx
callq 0x2590
jmp 0x24fc
leaq -0xa8(%rbp), %rdi
callq 0x62a0
leaq -0x90(%rbp), %rdi
callq 0x2700
movb %al, -0xf9(%rbp)
jmp 0x251c
movb -0xf9(%rbp), %al
testb $0x1, %al
jne 0x2528
jmp 0x256a
jmp 0x2508
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x62a0
jmp 0x2582
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x2840
jmp 0x2582
leaq -0x90(%rbp), %rdi
callq 0x2840
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xd8(%rbp), %rdi
callq 0x2230
nop
// File: nmmmnu[P]asyncore_cpp/net/asyncloop_impl.h
// Function: net::AsyncLoop<net::selector::PollSelector, net::worker::EchoWorker, net::ClientBuffer<1024ul>>::expireFD_()
void AsyncLoop<SELECTOR, WORKER, CLIENTBUFFER>::expireFD_(){
	for(const auto &p : clients_){
		int const fd = p.first;
		auto &c = p.second;

		if (c.expired(CONN_TIMEOUT)){
			handleDisconnect_(fd, DisconnectStatus::TIMEOUT);
			// iterator is invalid now...
			return;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x38, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3cd0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3d00
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3d30
testb $0x1, %al
jne 0x38d9
jmp 0x3936
leaq -0x18(%rbp), %rdi
callq 0x3d60
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
addq $0x404, %rdi            # imm = 0x404
movl $0x14, %esi
callq 0x3d80
testb $0x1, %al
jne 0x3916
jmp 0x3929
movq -0x40(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl $0x2, %edx
callq 0x3bd0
jmp 0x3936
jmp 0x392b
leaq -0x18(%rbp), %rdi
callq 0x3dc0
jmp 0x38c6
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: nmmmnu[P]asyncore_cpp/net/asyncloop_impl.h
// Function: net::AsyncLoop<net::selector::PollSelector, net::worker::EchoWorker, net::ClientBuffer<1024ul>>::handleRead_(int)
void AsyncLoop<SELECTOR, WORKER, CLIENTBUFFER>::handleRead_(int const fd){
	if ( isServerFD_(fd) ){
		while (handleConnect_(fd));
		return;
	}

	// -------------------------------------

	auto it = clients_.find(fd);

	if (it == clients_.end())
		return handleDisconnect_(fd, DisconnectStatus::PROBLEM_MAP_NOT_FOUND);

	auto &buffer = it->second;

	// -------------------------------------

	auto available = buffer.capacity();

	if (available == 0){
		// buffer will overfow, disconnect.
		return handleDisconnect_(fd, DisconnectStatus::PROBLEM_BUFFER_READ);
	}

	ssize_t const size = ::read(fd, buffer.dataTail(), available);

	if (size <= 0)
		return handleSocketOps_(fd, size);

	buffer.push((size_t) size);

	buffer.restartTimer();

	handleWorker_(fd, buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl -0xc(%rbp), %esi
callq 0x3e70
testb $0x1, %al
jne 0x3985
jmp 0x39a0
jmp 0x3987
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x3ee0
testb $0x1, %al
jne 0x3999
jmp 0x399b
jmp 0x3987
jmp 0x3a93
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
leaq -0xc(%rbp), %rsi
callq 0x3f60
movq -0x40(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x38, %rdi
callq 0x3d00
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3f90
testb $0x1, %al
jne 0x39d9
jmp 0x39ef
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x5, %edx
callq 0x3bd0
jmp 0x3a93
leaq -0x18(%rbp), %rdi
callq 0x3fc0
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3fe0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3a27
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x6, %edx
callq 0x3bd0
jmp 0x3a93
movl -0xc(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4000
movl -0x44(%rbp), %edi
movq %rax, %rsi
movq -0x30(%rbp), %rdx
callq 0x21e0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jg 0x3a62
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x38(%rbp), %rdx
callq 0x4020
jmp 0x3a93
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4080
movq -0x28(%rbp), %rdi
addq $0x404, %rdi            # imm = 0x404
callq 0x4110
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x4140
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: nmmmnu[P]asyncore_cpp/net/asyncloop_impl.h
// Function: net::AsyncLoop<net::selector::PollSelector, net::worker::EchoWorker, net::ClientBuffer<1024ul>>::handleWrite_(int)
void AsyncLoop<SELECTOR, WORKER, CLIENTBUFFER>::handleWrite_(int const fd){
	if ( isServerFD_(fd) ){
		// WTF?!?
		return;
	}

	// -------------------------------------

	auto it = clients_.find(fd);

	if (it == clients_.end())
		return handleDisconnect_(fd, DisconnectStatus::PROBLEM_MAP_NOT_FOUND);

	CLIENTBUFFER &buffer = it->second;

	// -------------------------------------

	auto available = buffer.size();

	if (available <= 0){
		// this must never happen, disconnect.
		return handleDisconnect_(fd, DisconnectStatus::PROBLEM_BUFFER_WRITE);
	}

	ssize_t const size = ::write(fd, buffer.data(), available);

	// -------------------------------------

	if (size <= 0)
		return handleSocketOps_(fd, size);

	buffer.pop((size_t) size);

	buffer.restartTimer();

	if (buffer.size() == 0){
		// process with read
		selector_.updateFD(fd, selector::FDEvent::READ);

		return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl -0xc(%rbp), %esi
callq 0x3e70
testb $0x1, %al
jne 0x3ac5
jmp 0x3aca
jmp 0x3bc6
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
leaq -0xc(%rbp), %rsi
callq 0x3f60
movq -0x40(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x38, %rdi
callq 0x3d00
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3f90
testb $0x1, %al
jne 0x3b03
jmp 0x3b19
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x5, %edx
callq 0x3bd0
jmp 0x3bc6
leaq -0x18(%rbp), %rdi
callq 0x3fc0
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5880
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
ja 0x3b51
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x7, %edx
callq 0x3bd0
jmp 0x3bc6
movl -0xc(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5a10
movl -0x44(%rbp), %edi
movq %rax, %rsi
movq -0x30(%rbp), %rdx
callq 0x20c0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jg 0x3b8c
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x38(%rbp), %rdx
callq 0x4020
jmp 0x3bc6
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x5b70
movq -0x28(%rbp), %rdi
addq $0x404, %rdi            # imm = 0x404
callq 0x4110
movq -0x28(%rbp), %rdi
callq 0x5880
cmpq $0x0, %rax
jne 0x3bc6
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x65e0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: nmmmnu[P]asyncore_cpp/net/asyncloop_impl.h
// Function: net::AsyncLoop<net::selector::PollSelector, net::worker::EchoWorker, net::ClientBuffer<1024ul>>::handleWorker_(int, net::ClientBuffer<1024ul>&)
bool AsyncLoop<SELECTOR, WORKER, CLIENTBUFFER>::handleWorker_(int const fd, CLIENTBUFFER &buffer){
//	static const char *redis_ok  = "$2\r\nOK\r\n";
//	static const char *redis_err = "-ERR Error\r\n";

	const WorkerStatus status = worker_( buffer );

	switch( status ){
	case WorkerStatus::PASS:
		return false;

	case WorkerStatus::READ:
		selector_.updateFD(fd, selector::FDEvent::READ);

		return true;

	case WorkerStatus::WRITE:
		selector_.updateFD(fd, selector::FDEvent::WRITE);

		return true;

	case WorkerStatus::DISCONNECT:
		handleDisconnect_(fd, DisconnectStatus::WORKER_NORMAL);

		return true;

	case WorkerStatus::SHUTDOWN:
	//	handleDisconnect_(fd, DisconnectStatus::WORKER_NORMAL);
		keepProcessing_ = false;

		return true;

	default:
	case WorkerStatus::DISCONNECT_ERROR:
		handleDisconnect_(fd, DisconnectStatus::WORKER_ERROR);

		return true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x18, %rdi
movq -0x20(%rbp), %rsi
callq 0x5790
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x5, %rax
ja 0x41e2
movq -0x30(%rbp), %rax
leaq 0x3eb5(%rip), %rcx      # 0x8038
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x0, -0x1(%rbp)
jmp 0x41f9
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0x65e0
movb $0x1, -0x1(%rbp)
jmp 0x41f9
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0x65e0
movb $0x1, -0x1(%rbp)
jmp 0x41f9
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x3, %edx
callq 0x3bd0
movb $0x1, -0x1(%rbp)
jmp 0x41f9
movq -0x38(%rbp), %rax
movb $0x0, 0x6c(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x41f9
jmp 0x41e4
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x4, %edx
callq 0x3bd0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: nmmmnu[P]asyncore_cpp/net/asyncloop_impl.h
// Function: net::AsyncLoop<net::selector::PollSelector, net::worker::EchoWorker, net::ClientBuffer<1024ul>>::insertFD_(int)
bool AsyncLoop<SELECTOR, WORKER, CLIENTBUFFER>::insertFD_(int const fd){
	// one for server fd
	if (connectedClients_ + 1 >= selector_.maxFD() )
		return false;

	bool const result = selector_.insertFD(fd);

	if (result == false)
		return false;

	//clients_.insert(std::make_pair(fd, CLIENTBUFFER{}));
	clients_[fd];

	++connectedClients_;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl 0x68(%rdi), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
callq 0x6360
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jb 0x46c4
movb $0x0, -0x1(%rbp)
jmp 0x470c
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0x64a0
andb $0x1, %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x46ea
movb $0x0, -0x1(%rbp)
jmp 0x470c
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
leaq -0x14(%rbp), %rsi
callq 0x4720
movq -0x28(%rbp), %rax
movl 0x68(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x68(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: nmmmnu[P]asyncore_cpp/include/stringref.h
// Function: StringRef::compare(char const*, unsigned long) const
inline int StringRef::compare(const char *data, size_t const size) const noexcept{
	if (COMPARE_MICRO_OPTIMIZATIONS){
		if (_data == data && _size == size)
			return 0;
	}

	return __compare(_data, _size, data, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x59ec
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x59ec
movl $0x0, -0x4(%rbp)
jmp 0x5a07
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x5a30
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: nmmmnu[P]asyncore_cpp/include/stringref.h
// Function: StringRef::__compare(char const*, unsigned long, char const*, unsigned long)
inline int StringRef::__compare(const char *s1, size_t const size1, const char *s2, size_t const size2) noexcept{
	// Lazy based on LLVM::StringRef
	// http://llvm.org/docs/doxygen/html/StringRef_8h_source.html

	// check prefix
	if ( int res = __memcmp(s1, s2, __std_min(size1, size2 ) ) )
		return res < 0 ? -1 : +1;

	// prefixes match, so we only need to check the lengths.
	if (size1 == size2)
		return 0;

	return size1 < size2 ? -1 : +1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5b00
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x5ad0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x5a96
movl -0x2c(%rbp), %edx
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x0, %edx
cmovll %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x5ac4
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x5aa9
movl $0x0, -0x4(%rbp)
jmp 0x5ac4
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rsi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovbl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: nmmmnu[P]asyncore_cpp/net/selector/pollselector.cc
// Function: net::selector::PollSelector::wait(int)
WaitStatus PollSelector::wait(int const timeout){
	int const activity = poll(statusData_.data(), statusData_.size(), timeout);

	if (activity < 0)
		return WaitStatus::ERROR;

	if (activity == 0)
		return WaitStatus::NONE;

	return WaitStatus::OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x68a0
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x6880
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
callq 0x2200
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x63ca
movl $0x2, -0x4(%rbp)
jmp 0x63e0
cmpl $0x0, -0x18(%rbp)
jne 0x63d9
movl $0x1, -0x4(%rbp)
jmp 0x63e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: nmmmnu[P]asyncore_cpp/net/selector/pollselector.cc
// Function: net::selector::PollSelector::updateFD(int, net::selector::FDEvent)
bool PollSelector::updateFD(int fd, FDEvent event){
	// bit ugly.
	for(auto &item : statusData_)
		if (item.fd == fd){
			item.events = pollConvert(event);
			return true;
		}

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6920
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6950
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6980
testb $0x1, %al
jne 0x6627
jmp 0x6665
leaq -0x28(%rbp), %rdi
callq 0x69c0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x6658
movl -0x18(%rbp), %edi
callq 0x65a0
movw %ax, %cx
movq -0x38(%rbp), %rax
movw %cx, 0x4(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x6669
jmp 0x665a
leaq -0x28(%rbp), %rdi
callq 0x69e0
jmp 0x6614
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nmmmnu[P]asyncore_cpp/net/sockets.cc
// Function: net::socket_create(net::SOCKET_TCP, char const*, unsigned short, unsigned short, int)
int socket_create(const SOCKET_TCP,  const char *ip, uint16_t const port, uint16_t const backlog, int const options) noexcept{
	int fd = socket(AF_INET , SOCK_STREAM , 0);

	if(fd < 0)
		return SOCKET_ERROR_CREATE;

	int const opt = 1;
	if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, & opt, sizeof opt) < 0){
		::close(fd);
		return SOCKET_ERROR_OPTIONS;
	}

	if (options & SOCKET_NONBLOCK)
	if (! socket_makeNonBlocking(fd) ){
		::close(fd);
		return SOCKET_ERROR_NONBLOCK;
	}

	if (options & SOCKET_TCPNODELAY)
	if (! socket_makeTCPNoDelay(fd) ){
		::close(fd);
		return SOCKET_ERROR_NODELAY;
	}

	struct sockaddr_in address;

	address.sin_family = AF_INET;
	address.sin_addr.s_addr = INADDR_ANY;
	address.sin_port = htons(port);

	if (bind(fd, (struct sockaddr *) & address, sizeof address) < 0){
		::close(fd);
		return SOCKET_ERROR_BIND;
	}

	if (listen(fd, backlog ? backlog : SOMAXCONN) < 0){
		::close(fd);
		return SOCKET_ERROR_BACKLOG;
	}

	return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %dx, %ax
movw %si, %dx
movq %rdi, -0x10(%rbp)
movw %dx, -0x12(%rbp)
movw %ax, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2090
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x7883
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x79ab
movl $0x1, -0x20(%rbp)
movl -0x1c(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x20(%rbp), %rcx
movl $0x4, %r8d
callq 0x2240
cmpl $0x0, %eax
jge 0x78c1
movl -0x1c(%rbp), %edi
callq 0x2250
jmp 0x78b5
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x79ab
movl -0x18(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x78f0
movl -0x1c(%rbp), %edi
callq 0x7720
testb $0x1, %al
jne 0x78ee
movl -0x1c(%rbp), %edi
callq 0x2250
jmp 0x78e2
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x79ab
jmp 0x78f0
movl -0x18(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x791f
movl -0x1c(%rbp), %edi
callq 0x7780
testb $0x1, %al
jne 0x791d
movl -0x1c(%rbp), %edi
callq 0x2250
jmp 0x7911
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x79ab
jmp 0x791f
movw $0x2, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
movzwl -0x12(%rbp), %edi
callq 0x2060
movw %ax, -0x2e(%rbp)
movl -0x1c(%rbp), %edi
leaq -0x30(%rbp), %rsi
movl $0x10, %edx
callq 0x2070
cmpl $0x0, %eax
jge 0x7962
movl -0x1c(%rbp), %edi
callq 0x2250
jmp 0x7959
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x79ab
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
cmpw $0x0, -0x14(%rbp)
je 0x7978
movzwl -0x14(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x7982
movl $0x1000, %eax           # imm = 0x1000
movl %eax, -0x38(%rbp)
jmp 0x7982
movl -0x34(%rbp), %edi
movl -0x38(%rbp), %esi
callq 0x21c0
cmpl $0x0, %eax
jge 0x79a5
movl -0x1c(%rbp), %edi
callq 0x2250
jmp 0x799c
movl $0xfffffffa, -0x4(%rbp) # imm = 0xFFFFFFFA
jmp 0x79ab
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3020
nopl (%rax)
// File: nmmmnu[P]asyncore_cpp/net/sockets.cc
// Function: net::socket_create(net::SOCKET_UNIX, char const*, unsigned short, int)
int socket_create(const SOCKET_UNIX, const char *path, uint16_t const backlog, int const options) noexcept{
	struct sockaddr_un address;

	if (sizeof address.sun_path < strlen(path))
		return SOCKET_NAME_SIZE;


	int fd = socket(AF_UNIX , SOCK_STREAM , 0);

	if(fd < 0)
		return SOCKET_ERROR_CREATE;

	if (options & SOCKET_NONBLOCK)
	if (! socket_makeNonBlocking(fd) ){
		::close(fd);
		return SOCKET_ERROR_NONBLOCK;
	}

	//struct sockaddr_in address
	address.sun_family = AF_UNIX;
	strcpy(address.sun_path, path);

	unlink(address.sun_path);

	if (bind(fd, (struct sockaddr *) & address, sizeof address) < 0){
		::close(fd);
		return SOCKET_ERROR_BIND;
	}

	if (listen(fd, backlog ? backlog : SOMAXCONN) < 0){
		::close(fd);
		return SOCKET_ERROR_BACKLOG;
	}

	return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20f0
movq %rax, %rcx
movl $0x6c, %eax
cmpq %rcx, %rax
jae 0x79fb
movl $0xfffffff9, -0x4(%rbp) # imm = 0xFFFFFFF9
jmp 0x7b19
movl $0x1, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x2090
movl %eax, -0x8c(%rbp)
cmpl $0x0, -0x8c(%rbp)
jge 0x7a24
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7b19
movl -0x18(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x7a59
movl -0x8c(%rbp), %edi
callq 0x7720
testb $0x1, %al
jne 0x7a57
movl -0x8c(%rbp), %edi
callq 0x2250
jmp 0x7a4b
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x7b19
jmp 0x7a59
movw $0x1, -0x86(%rbp)
leaq -0x86(%rbp), %rdi
addq $0x2, %rdi
movq -0x10(%rbp), %rsi
callq 0x2180
leaq -0x86(%rbp), %rdi
addq $0x2, %rdi
callq 0x2110
movl -0x8c(%rbp), %edi
leaq -0x86(%rbp), %rsi
movl $0x6e, %edx
callq 0x2070
cmpl $0x0, %eax
jge 0x7ab8
movl -0x8c(%rbp), %edi
callq 0x2250
jmp 0x7aaf
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x7b19
movl -0x8c(%rbp), %eax
movl %eax, -0x90(%rbp)
cmpw $0x0, -0x12(%rbp)
je 0x7ad7
movzwl -0x12(%rbp), %eax
movl %eax, -0x94(%rbp)
jmp 0x7ae4
movl $0x1000, %eax           # imm = 0x1000
movl %eax, -0x94(%rbp)
jmp 0x7ae4
movl -0x90(%rbp), %edi
movl -0x94(%rbp), %esi
callq 0x21c0
cmpl $0x0, %eax
jge 0x7b10
movl -0x8c(%rbp), %edi
callq 0x2250
jmp 0x7b07
movl $0xfffffffa, -0x4(%rbp) # imm = 0xFFFFFFFA
jmp 0x7b19
movl -0x8c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3020
// File: mh0fm4[P]SCDC/test/demos/fstream/fstream.cc
// Function: ifstream_test(char const*)
void ifstream_test(const char *file)
{
  scdc::ifstream ifs;
  string line;

  ifs.open(file, ios_base::in);
  int i = 1;
  while (getline(ifs, line)) {
    cout << i << ": " << line << '\n';
    i++;
  }
  ifs.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x8(%rbp)
leaq -0x238(%rbp), %rdi
movq %rdi, -0x270(%rbp)
callq 0xec80
leaq -0x258(%rbp), %rdi
callq 0xda40
movq -0x270(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x8, %edx
callq 0xed60
jmp 0xea75
movl $0x1, -0x268(%rbp)
leaq -0x238(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0xd110
movq %rax, -0x278(%rbp)
jmp 0xea9b
movq -0x278(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xd930
movb %al, -0x279(%rbp)
jmp 0xeab9
movb -0x279(%rbp), %al
testb $0x1, %al
jne 0xeac8
jmp 0xeb6e
movl -0x268(%rbp), %esi
movq 0xaa4fb(%rip), %rdi     # 0xb8fd0
callq 0xdcd0
movq %rax, -0x288(%rbp)
jmp 0xeae3
movq -0x288(%rbp), %rdi
leaq 0x82f82(%rip), %rsi     # 0x91a73
callq 0xd6e0
movq %rax, -0x290(%rbp)
jmp 0xeaff
movq -0x290(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0xd600
movq %rax, -0x298(%rbp)
jmp 0xeb1b
movq -0x298(%rbp), %rdi
movl $0xa, %esi
callq 0xd890
jmp 0xeb2e
movl -0x268(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x268(%rbp)
jmp 0xea7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x260(%rbp)
movl %eax, -0x264(%rbp)
leaq -0x258(%rbp), %rdi
callq 0xd420
leaq -0x238(%rbp), %rdi
callq 0xee20
jmp 0xeb9d
leaq -0x238(%rbp), %rdi
callq 0xede0
jmp 0xeb7c
leaq -0x258(%rbp), %rdi
callq 0xd420
leaq -0x238(%rbp), %rdi
callq 0xee20
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq -0x260(%rbp), %rdi
callq 0xdd00
nopl (%rax)
// File: mh0fm4[P]SCDC/test/demos/fstream/fstream.cc
// Function: main
int main(int argc, char** argv)
{
  scdc_init(SCDC_INIT_DEFAULT);

  scdc_dataprov_t dpFS = scdc_dataprov_open("storeFS", "fs", "store/");

  const char *uri = "scdc:/storeFS/test.in";

  ifstream_test(uri);

  scdc_dataprov_close(dpFS);

  scdc_release();

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x7fac7(%rip), %rdi     # 0x8e694
movb $0x0, %al
callq 0x128c0
leaq 0x7f429(%rip), %rdi     # 0x8e004
leaq 0x81830(%rip), %rsi     # 0x90412
leaq 0x7f423(%rip), %rdx     # 0x8e00c
movb $0x0, %al
callq 0x12df0
movq %rax, -0x18(%rbp)
leaq 0x7f418(%rip), %rax     # 0x8e013
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xea30
movq -0x18(%rbp), %rdi
callq 0x12ec0
callq 0x12a70
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: mh0fm4[P]SCDC/test/demos/fstream/../../../src/lib/redirect/fstream/basic_file_scdc.h
// Function: scdc::fstream_scdc_env::release()
void release()
    {
      TRACE(__class__, __func__ , "");
      if (initialized < 0)
      {
        TRACE(__class__, __func__, "last release");

          /* on last release */
#ifdef USE_FSTREAM_SCDC_LOCAL
          scdc_dataprov_close(fstream_scdc_dp_local);
#endif /* USE_FSTREAM_SCDC_LOCAL */

          scdc_release();
      }

      if (initialized <= 0) return;

      --initialized;

      if (initialized == 0)
      {
        TRACE(__class__, __func__, "every release");

        /* on every release */
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xee76
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jge 0xee94
jmp 0xee81
jmp 0xee83
movq 0xaa926(%rip), %rdi     # 0xb97b0
callq 0x12ec0
callq 0x12a70
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jg 0xee9f
jmp 0xeeb5
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
cmpl $0x0, (%rax)
jne 0xeeb5
jmp 0xeeb1
jmp 0xeeb3
jmp 0xeeb5
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/test/demos/fstream/../../../src/lib/redirect/fstream/basic_file_scdc.h
// Function: scdc::__basic_file_scdc<char>::close()
__basic_file* 
      close()
      {
        TRACE(__class__, __func__, "");

        __basic_file* ret = this;

        scdc_dataset_close(_M_dataset);
        _M_dataset = SCDC_DATASET_NULL;

        the_fstream_scdc_env.release();

        return ret;
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x10ac6
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rdi
callq 0x13bb0
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
leaq 0xa8cc4(%rip), %rdi     # 0xb97ac
callq 0xee60
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/test/demos/fstream/../../../src/lib/redirect/fstream/basic_file_scdc.h
// Function: scdc::__basic_file_scdc<char>::xsputn(char const*, long)
streamsize 
      xsputn(const char* __s, streamsize __n)
      {
        TRACE(__class__, __func__, "n: %lld", (long long) __n);

        streamsize ret = -1;
        streamsize noffset = offset;

        if (!do_write) goto do_return;

#if BASIC_FILE_SCDC_APPEND
        if (do_append) noffset = 0;
#endif

        scdc_dataset_input_t input;

        scdc_dataset_input_unset(&input);
        SCDC_DATASET_INOUT_BUF_PTR(&input) = const_cast<char *>(__s);
        SCDC_DATASET_INOUT_BUF_SIZE(&input) = __n;
        SCDC_DATASET_INOUT_BUF_CURRENT(&input) = __n;
        input.total_size = __n;
        input.total_size_given = SCDC_DATASET_INOUT_TOTAL_SIZE_GIVEN_EXACT;

        char cmd[256];
        sprintf(cmd, "put %" scdcint_fmt "%c:%" scdcint_fmt,
#if BASIC_FILE_SCDC_APPEND
        (do_append)?0:
#endif
        noffset,
#if BASIC_FILE_SCDC_APPEND
        (do_append)?'B':
#endif
        'F', __n);

        if (scdc_dataset_cmd(_M_dataset, cmd, &input, NULL) != SCDC_SUCCESS) goto do_return;

        ret = __n;
        noffset += __n;

do_return:
        if (ret >= 0)
        {
#if BASIC_FILE_SCDC_APPEND
          if (!do_append)
#endif
          {
            offset = noffset;
          }
        }

        TRACE(__class__, __func__, "return: %lld, offset: %lld", (long long) ret, (long long) offset);

        return ret;
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x188(%rbp)
jmp 0x11114
movq -0x188(%rbp), %rax
movq $-0x1, -0x20(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x28(%rbp)
testb $0x1, 0xa(%rax)
jne 0x11136
jmp 0x111c1
leaq -0x80(%rbp), %rdi
callq 0x33f10
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x78, -0x50(%rbp)
leaq -0x180(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %r8
leaq 0x7ceb0(%rip), %rsi     # 0x8e029
movl $0x46, %ecx
movb $0x0, %al
callq 0xd100
movq -0x188(%rbp), %rax
movq (%rax), %rdi
leaq -0x180(%rbp), %rsi
leaq -0x80(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x14970
cmpq $0x1, %rax
je 0x111ad
jmp 0x111c1
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jl 0x111d7
movq -0x188(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x111d9
jmp 0x111db
movq -0x20(%rbp), %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/test/demos/fstream/../../../src/lib/redirect/fstream/basic_file_scdc.h
// Function: scdc::fstream_scdc_env::init()
void init()
      {
        TRACE(__class__, __func__ , "");
        if (initialized < 0)
        {
          TRACE(__class__, __func__, "first init");

          /* on first init */
          initialized = 0;
          scdc_init(SCDC_INIT_DEFAULT);

#ifdef USE_FSTREAM_SCDC_LOCAL
          const char *local_base = fstream_scdc_local_base;
          const char *local_path = fstream_scdc_local_path;
          if (!local_base || !local_path)
          {
            local_base = FSTREAM_SCDC_LOCAL_BASE;
            local_path = FSTREAM_SCDC_LOCAL_PATH;
          }

          TRACE(__class__, __func__, std::string("local data provider '") + local_base + "' with path '" + local_path + "'");

          fstream_scdc_dp_local = scdc_dataprov_open(local_base, "fs:access", local_path);
#endif /* USE_FSTREAM_SCDC_LOCAL */
        }

      if (initialized == 0)
      {
        TRACE(__class__, __func__, "every init");

        /* on every init */
      }

      ++initialized;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x127a6
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jge 0x12826
jmp 0x127b1
jmp 0x127b3
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
leaq 0x7bed0(%rip), %rdi     # 0x8e694
movb $0x0, %al
callq 0x128c0
movq 0xa6fe6(%rip), %rax     # 0xb97b8
movq %rax, -0x10(%rbp)
movq 0xa6fe3(%rip), %rax     # 0xb97c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x127ef
cmpq $0x0, -0x18(%rbp)
jne 0x12805
leaq 0x7c4b8(%rip), %rax     # 0x8ecae
movq %rax, -0x10(%rbp)
leaq 0x7c4ad(%rip), %rax     # 0x8ecae
movq %rax, -0x18(%rbp)
jmp 0x12807
jmp 0x12809
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x7b980(%rip), %rsi     # 0x8e198
movb $0x0, %al
callq 0x12df0
movq %rax, 0xa6f8a(%rip)     # 0xb97b0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x12835
jmp 0x12831
jmp 0x12833
jmp 0x12835
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/app/icnf/icnf.c
// Function: msg
static void msg (const char * fmt, ...) {
  va_list ap;
  fflush (stderr);
  printf ("c [icnf] ");
  va_start (ap, fmt);
  vprintf (fmt, ap);
  va_end (ap);
  fputc ('\n', stdout);
  fflush (stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x1cf5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x1f2d5(%rip), %rax     # 0x20ff8
movq (%rax), %rdi
callq 0x1140
leaq 0x185c9(%rip), %rdi     # 0x1a2fb
xorl %eax, %eax
callq 0x10a0
leaq -0xd0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1160
movq 0x1f262(%rip), %rax     # 0x20fd0
movq %rax, -0xd8(%rbp)
movq (%rax), %rsi
movl $0xa, %edi
callq 0x10f0
movq -0xd8(%rbp), %rax
movq (%rax), %rdi
callq 0x1140
addq $0xe0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::situation_type_hash::operator()(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&) const
size_t klotski_board::situation_type_hash::operator()(const situation_type& situation) const noexcept{
	size_t seed = 0;
	int n = 1;
	for(const auto& i: situation){
		for(const auto& j: i){
			seed += j * n++;
		}
	}
	return seed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x7640
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x7670
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7a30
testb $0x1, %al
jne 0xc267
jmp 0xc2ef
leaq -0x30(%rbp), %rdi
callq 0x7aa0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x7d30
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x7d60
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xb920
testb $0x1, %al
jne 0xc2a9
jmp 0xc2df
leaq -0x50(%rbp), %rdi
callq 0xb9d0
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movl (%rax), %eax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
imull %ecx, %eax
cltq
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xe690
jmp 0xc296
jmp 0xc2e1
leaq -0x30(%rbp), %rdi
callq 0x7ac0
jmp 0xc251
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::resize_board_to_fit()
void klotski_board::resize_board_to_fit(){
	situation.resize(dy);
	situation.shrink_to_fit();
	std::for_each(situation.begin(), situation.end(),
			[this](std::vector<int>& vec){vec.resize(dx); vec.shrink_to_fit();});
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rax, %rdi
addq $0x18, %rdi
movslq 0xc(%rax), %rsi
callq 0xeb20
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x7420
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x8f50
movq -0x30(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x18, %rdi
callq 0x8f80
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xe5c0
movq %rax, -0x28(%rbp)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::reset()
void klotski_board::reset() noexcept{
	resize_board_to_fit();
	int inc = 1;
	for(auto& i: situation){
		for(int& n: i){
			n = inc++;
		}
	}
	situation[dy - 1][dx - 1] = 0;
	zero_x = dx - 1;
	zero_y = dy - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xc7a0
jmp 0xcc0b
movq -0x58(%rbp), %rax
movl $0x1, -0xc(%rbp)
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8f50
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8f80
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xb880
testb $0x1, %al
jne 0xcc4b
jmp 0xccc6
leaq -0x20(%rbp), %rdi
callq 0x9800
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xafb0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0xae40
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xb8c0
testb $0x1, %al
jne 0xcc8d
jmp 0xccb6
leaq -0x40(%rbp), %rdi
callq 0xb900
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x50(%rbp), %rax
movl %ecx, (%rax)
leaq -0x40(%rbp), %rdi
callq 0xb9f0
jmp 0xcc7a
jmp 0xccb8
leaq -0x20(%rbp), %rdi
callq 0x9820
jmp 0xcc38
movq -0x58(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movl 0xc(%rax), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0xe720
movq %rax, %rdi
movq -0x58(%rbp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0xe740
movq %rax, %rcx
movq -0x58(%rbp), %rax
movl $0x0, (%rcx)
movl 0x8(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x10(%rax)
movl 0xc(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x14(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x5bd0
nopw %cs:(%rax,%rax)
// File: iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::upset(int)
void klotski_board::upset(int depth) noexcept{
	bool is_horizontal = orientation_distribution(random_engine);
	for (int i = 0; i < depth; ++i) {
		if(is_horizontal){
			while(!move_item(x_distribution(random_engine), zero_y));
		}else{
			while(!move_item(zero_x, y_distribution(random_engine)));
		}
		is_horizontal = !is_horizontal;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x40, %rdi
leaq 0x176ee(%rip), %rsi     # 0x24440
callq 0xe760
movb %al, -0x15(%rbp)
jmp 0xcd5c
movb -0x15(%rbp), %al
andb $0x1, %al
movb %al, -0xd(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xce1d
testb $0x1, -0xd(%rbp)
je 0xcdbe
jmp 0xcd7f
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
leaq 0x176b2(%rip), %rsi     # 0x24440
callq 0xe790
movl %eax, -0x24(%rbp)
jmp 0xcd98
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rdi
movl 0x14(%rdi), %edx
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movb %al, -0x25(%rbp)
jmp 0xcdaf
movb -0x25(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xcdba
jmp 0xcdbc
jmp 0xcd7f
jmp 0xce05
jmp 0xcdc0
movq -0x20(%rbp), %rdi
movl 0x10(%rdi), %eax
movl %eax, -0x30(%rbp)
addq $0x38, %rdi
leaq 0x1766b(%rip), %rsi     # 0x24440
callq 0xe790
movl %eax, -0x2c(%rbp)
jmp 0xcddf
movl -0x2c(%rbp), %edx
movl -0x30(%rbp), %esi
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movb %al, -0x31(%rbp)
jmp 0xcdf6
movb -0x31(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xce01
jmp 0xce03
jmp 0xcdc0
jmp 0xce05
movb -0xd(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0xd(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcd6b
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x5bd0
nopl (%rax,%rax)
// File: iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::print_line(int, int, std::ostream&)
void klotski_board::print_line(int dx, int space_n, std::ostream& os) noexcept{
	os<<std::setw(space_n)<<" ";
	for(int j=0; j<dx; ++j){
		os<<std::setw(space_n+1)<<std::setfill('-')<<"+";
	}
	os<<'+'<<std::endl<<std::setfill(' ');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x8(%rbp), %edi
callq 0x5830
movl %eax, -0x24(%rbp)
jmp 0xd44a
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
callq 0x3370
movq %rax, -0x38(%rbp)
jmp 0xd462
movq -0x38(%rbp), %rdi
leaq 0xb020(%rip), %rsi      # 0x1848d
callq 0x32e0
jmp 0xd474
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0xd4f9
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x8(%rbp), %edi
incl %edi
callq 0x5830
movl %eax, -0x3c(%rbp)
jmp 0xd49a
movq -0x48(%rbp), %rdi
movl -0x3c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
callq 0x3370
movq %rax, -0x50(%rbp)
jmp 0xd4b2
movl $0x2d, %edi
callq 0xebb0
movb %al, -0x51(%rbp)
jmp 0xd4c1
movq -0x50(%rbp), %rdi
movb -0x51(%rbp), %al
movb %al, -0x1d(%rbp)
movzbl -0x1d(%rbp), %esi
callq 0x3450
movq %rax, -0x60(%rbp)
jmp 0xd4da
movq -0x60(%rbp), %rdi
leaq 0xb26d(%rip), %rsi      # 0x18752
callq 0x32e0
jmp 0xd4ec
jmp 0xd4ee
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xd47b
movq -0x10(%rbp), %rdi
movl $0x2b, %esi
callq 0x3380
movq %rax, -0x68(%rbp)
jmp 0xd50d
movq -0x68(%rbp), %rdi
movq 0x16a60(%rip), %rsi     # 0x23f78
callq 0x3320
movq %rax, -0x70(%rbp)
jmp 0xd523
movl $0x20, %edi
callq 0xebb0
movb %al, -0x71(%rbp)
jmp 0xd532
movq -0x70(%rbp), %rdi
movb -0x71(%rbp), %al
movb %al, -0x1e(%rbp)
movzbl -0x1e(%rbp), %esi
callq 0x3450
jmp 0xd547
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x5bd0
nopl (%rax,%rax)
// File: iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::move_item(int, int)
bool klotski_board::move_item(int x, int y){
	auto info = get_pos_info(x, y);
	if(info->is_item_can_move){
		if(info->zero_distance != 1){
			if(info->Orientation == pos_info::Horizontal){
				move_item(x, info->is_zero_in_top_or_left?y-1:y+1);
			}else{
				move_item(info->is_zero_in_top_or_left?x-1:x+1, y);
			}
		}
		std::swap(situation[y][x], get_zero());
		zero_x = x;
		zero_y = y;
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x40(%rbp)
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
leaq -0x28(%rbp), %rdi
callq 0xd6e0
leaq -0x28(%rbp), %rdi
callq 0xe800
testb $0x1, 0x5(%rax)
je 0xd6ab
leaq -0x28(%rbp), %rdi
callq 0xe800
cmpl $0x1, 0x8(%rax)
je 0xd651
leaq -0x28(%rbp), %rdi
callq 0xe800
cmpl $0x0, (%rax)
jne 0xd616
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xe800
testb $0x1, 0x4(%rax)
je 0xd5dd
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0xd5e6
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
movl -0x44(%rbp), %esi
movq -0x40(%rbp), %rdi
movl -0x48(%rbp), %edx
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0xd5fa
jmp 0xd64f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xe850
jmp 0xd6ca
leaq -0x28(%rbp), %rdi
callq 0xe800
testb $0x1, 0x4(%rax)
je 0xd630
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0xd639
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
movq -0x40(%rbp), %rdi
movl -0x4c(%rbp), %esi
movl -0x18(%rbp), %edx
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0xd64d
jmp 0xd64f
jmp 0xd651
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
movslq -0x18(%rbp), %rsi
callq 0xe720
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0xe740
movq -0x40(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0xd990
movq %rax, -0x58(%rbp)
jmp 0xd681
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdi
callq 0xe820
movq -0x40(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x14(%rax)
movb $0x1, -0x1(%rbp)
movl $0x1, -0x38(%rbp)
jmp 0xd6b6
movb $0x0, -0x1(%rbp)
movl $0x1, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xe850
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
// File: iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::get_zero()
int& klotski_board::get_zero(){
	if(situation[zero_y][zero_x] != 0){
		for(int i=0; i<dy; ++i){
			for(int j=0; j<dx; ++j){
				if(situation[i][j] == 0){
					zero_x = j;
					zero_y = i;
					return situation[i][j];
				}
			}
		}
	}else{
		return situation[zero_y][zero_x];
	}
	throw std::runtime_error("Can not find zero on klotski board");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rax, %rdi
addq $0x18, %rdi
movslq 0x14(%rax), %rsi
callq 0xe720
movq %rax, %rdi
movq -0x30(%rbp), %rax
movslq 0x10(%rax), %rsi
callq 0xe740
cmpl $0x0, (%rax)
je 0xda6a
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0xda68
movl $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0xda58
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
movslq -0x14(%rbp), %rsi
callq 0xe720
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0xe740
cmpl $0x0, (%rax)
jne 0xda4b
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, 0x10(%rdi)
movl -0x14(%rbp), %eax
movl %eax, 0x14(%rdi)
addq $0x18, %rdi
movslq -0x14(%rbp), %rsi
callq 0xe720
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0xe740
movq %rax, -0x8(%rbp)
jmp 0xdae4
jmp 0xda4d
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xd9eb
jmp 0xda5a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd9d4
jmp 0xda94
movq -0x30(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movslq 0x14(%rax), %rsi
callq 0xe720
movq %rax, %rdi
movq -0x30(%rbp), %rax
movslq 0x10(%rax), %rsi
callq 0xe740
movq %rax, -0x8(%rbp)
jmp 0xdae4
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0xaca7(%rip), %rsi      # 0x18756
callq 0x30d0
jmp 0xdab6
movq -0x38(%rbp), %rdi
movq 0x1652f(%rip), %rsi     # 0x23ff0
movq 0x164c8(%rip), %rdx     # 0x23f90
callq 0x34b0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3210
jmp 0xdaee
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34e0
nopw (%rax,%rax)
// File: iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::is_win(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&)
bool klotski_board::is_win(const situation_type& situation) noexcept{
	int curr_num=1;
	for(auto i=situation.cbegin(); i != situation.cend(); ++i){
		for(auto j = i->cbegin(); j != i->cend(); ++j){
			if(*j != curr_num++ && !(i+1 == situation.cend() && j+1 == i->cend())){
				return false;
			}
		}
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe870
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe8a0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7a30
testb $0x1, %al
jne 0xdb73
jmp 0xdc7a
leaq -0x20(%rbp), %rdi
callq 0xe8d0
movq %rax, %rdi
callq 0xb850
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xe8d0
movq %rax, %rdi
callq 0xb960
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xb920
testb $0x1, %al
jne 0xdbb3
jmp 0xdc6a
leaq -0x30(%rbp), %rdi
callq 0xb9d0
movl (%rax), %ecx
movl -0x14(%rbp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x59(%rbp)
je 0xdc4b
leaq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0xe930
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe8a0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xe8f0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x5a(%rbp)
jne 0xdc0c
jmp 0xdc43
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0xe9b0
movq %rax, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xe8d0
movq %rax, %rdi
callq 0xb960
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xe970
movb %al, -0x5a(%rbp)
movb -0x5a(%rbp), %al
xorb $-0x1, %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0xdc54
jmp 0xdc5a
movb $0x0, -0x1(%rbp)
jmp 0xdc7e
jmp 0xdc5c
leaq -0x30(%rbp), %rdi
callq 0xe690
jmp 0xdb88
jmp 0xdc6c
leaq -0x20(%rbp), %rdi
callq 0x7ac0
jmp 0xdb50
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)