LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Socket.cpp
// Function: u::Socket::operator=(u::Socket&)
Socket& u::Socket::operator =(Socket &value)
{
	destructor();
	Socket(
		value._domain, value._hostname, value._port, value._type
		, value._protocol
	);
	if(value.isConnected())
	{
		connect();
	}
	return *this;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rsi, %r14
movq %rdi, %rbx
callq 0x40dbd2
movl 0x38(%r14), %ebp
leaq 0x58(%r14), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x40cb38
movq 0xb0(%r14), %rcx
movl 0x3c(%r14), %r9d
movl 0x40(%r14), %r8d
leaq 0x60(%rsp), %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x40d860
leaq 0x60(%rsp), %rdi
callq 0x40dba4
leaq 0x8(%rsp), %rdi
callq 0x4050e8
movq %r14, %rdi
callq 0x40dc34
testb %al, %al
je 0x40dd25
movq %rbx, %rdi
callq 0x40dd4c
movq %rbx, %rax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4050e8
movq %rbx, %rdi
callq 0x4ca950
nop
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Socket.cpp
// Function: u::Socket::read(u::ByteArray*)
int64 u::Socket::read(ByteArray *data)
{
	int64 ret				// ammount of received bytes.
		, len					// maximum of read bytes
	;
	char *buffer;		// read buffer

	if(!isConnected()) return -1;

	if(!hasIncomingData()) return 0;

	// set pointer to end for append
	data->position(data->length());

	lock();
	len = receiveBufferSize;
	buffer = new char[len];

	ret = ::recv(_descriptor, buffer, len, 0);
	unlock();

	if(ret > 0)
	{
		data->writeBytes(buffer, ret);
	}

	delete[] buffer;

	data->position(0); // set pointer to begin

	trace(className()+"::read: Received "+int2string(ret)+" bytes.");
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rsi, %r15
movq %rdi, %r14
callq 0x40dc34
testb %al, %al
je 0x40e70e
movq %r14, %rdi
callq 0x40e77c
testb %al, %al
je 0x40e713
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq (%r15), %rcx
movq %r15, %rdi
movq %rax, %rsi
callq *0x20(%rcx)
movq %r14, %rdi
callq 0x40c442
movq 0xc0(%r14), %rbx
movq %rbx, %rdi
callq 0x420b80
movq %rax, %r12
movl 0x34(%r14), %edi
movq %rax, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x55a080
movq %rax, %rbx
movq %r14, %rdi
callq 0x40c3fe
testq %rbx, %rbx
jle 0x40e627
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x409056
movq %r12, %rdi
callq 0x41fb70
movq (%r15), %rax
movq %r15, %rdi
xorl %esi, %esi
callq *0x20(%rax)
movq $0x64ec20, %rdi         # imm = 0x64EC20
leaq 0x1b8a49(%rip), %rsi    # 0x5c7091
callq 0x489b70
movq %rax, %r15
movq (%r14), %rax
leaq 0xc0(%rsp), %rdi
movq %r14, %rsi
callq *0x8(%rax)
leaq 0xf8(%rsp), %rsi
leaq 0x1b96f4(%rip), %rdx    # 0x5c7d64
leaq 0x8(%rsp), %rdi
callq 0x405349
leaq 0x68(%rsp), %rdi
movl %ebx, %esi
callq 0x40c712
leaq 0xa0(%rsp), %rdx
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x406c55
leaq 0x1b96b8(%rip), %rdx    # 0x5c7d5c
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x405349
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
callq 0x49c3f0
leaq 0x1b89e4(%rip), %rsi    # 0x5c70ab
movq %rax, %rdi
callq 0x489b70
movq %rax, %rdi
callq 0x489450
leaq 0x48(%rsp), %rdi
callq 0x499a70
leaq 0x28(%rsp), %rdi
callq 0x499a70
leaq 0x68(%rsp), %rdi
callq 0x4050e8
leaq 0x8(%rsp), %rdi
callq 0x499a70
leaq 0xc0(%rsp), %rdi
callq 0x4050e8
jmp 0x40e715
pushq $-0x1
popq %rbx
jmp 0x40e715
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x40e748
movq %rax, %rbx
jmp 0x40e752
movq %rax, %rbx
jmp 0x40e75c
movq %rax, %rbx
jmp 0x40e766
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x499a70
leaq 0x28(%rsp), %rdi
callq 0x499a70
leaq 0x68(%rsp), %rdi
callq 0x4050e8
leaq 0x8(%rsp), %rdi
callq 0x499a70
leaq 0xc0(%rsp), %rdi
callq 0x4050e8
movq %rbx, %rdi
callq 0x4ca950
nop
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Socket.cpp
// Function: u::Socket::hasIncomingData()
bool u::Socket::hasIncomingData()
{
	fd_set rfds;
	struct timeval tv;
	int retval;

	FD_ZERO(&rfds);
	FD_SET(_descriptor, &rfds);

	tv.tv_sec = 0;
	tv.tv_usec = 0;

	lock();
	retval = select(_descriptor+1, &rfds, NULL, NULL, &tv);
	unlock();

	return retval > 0;

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
xorl %eax, %eax
cmpq $0x10, %rax
je 0x40e79d
andq $0x0, 0x10(%rsp,%rax,8)
incq %rax
jmp 0x40e78c
movl 0x34(%rbx), %ecx
pushq $0x40
popq %rsi
movl %ecx, %eax
cltd
idivl %esi
movslq %eax, %rdx
shll $0x6, %eax
subl %eax, %ecx
pushq $0x1
popq %rax
shlq %cl, %rax
orq %rax, 0x10(%rsp,%rdx,8)
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq %rbx, %rdi
callq 0x40c442
movl 0x34(%rbx), %edi
incl %edi
leaq 0x10(%rsp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r8
callq 0x557d90
movl %eax, %ebp
movq %rbx, %rdi
callq 0x40c3fe
testl %ebp, %ebp
setg %al
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Socket.cpp
// Function: u::Socket::hostip()
String u::Socket::hostip()
{
	if(!isConnected()) return "unknown";
	switch(_domain)
	{
		case AF_UNIX:
		{
			return "127.0.0.1";
		} break;
		default:
		{
			return inet_ntoa(((struct sockaddr_in*)_addr)->sin_addr);
		} break;
	}

	return "";
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x40dc34
testb %al, %al
je 0x40e824
cmpl $0x1, 0x38(%r14)
jne 0x40e830
leaq 0x1b955c(%rip), %rsi    # 0x5c7d7e
jmp 0x40e82b
leaq 0x1b954b(%rip), %rsi    # 0x5c7d76
movq %rbx, %rdi
jmp 0x40e842
movq 0x48(%r14), %rax
movl 0x4(%rax), %edi
callq 0x55ac70
movq %rbx, %rdi
movq %rax, %rsi
callq 0x40c908
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Socket.cpp
// Function: u::Socket::accept()
u::Socket* u::Socket::accept()
{
	Socket* clientSocket; 		// client socket data

	lock();
	int32 srcDescriptor = _descriptor;
	int32 domain = _domain;
	unlock();

	if(srcDescriptor == -1) return null;

	clientSocket = new Socket(domain);
	::close(clientSocket->_descriptor); // try to destroy socket..not needed

	clientSocket->_descriptor = ::accept(
		srcDescriptor
		, (struct sockaddr *)(clientSocket->_addr)
		, &(clientSocket->_addrLen)
	);

	if(clientSocket->_descriptor != -1)
	{
		clientSocket->_con = 1; // set manually to connected status
		return clientSocket;
	}

	clientSocket->destroy();
	return null;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
callq 0x40c442
movl 0x34(%rbx), %ebp
movl 0x38(%rbx), %r14d
movq %rbx, %rdi
callq 0x40c3fe
cmpl $-0x1, %ebp
je 0x40e904
movl $0xc8, %edi
callq 0x420b40
movq %rax, %rbx
leaq 0x1b94e4(%rip), %rsi    # 0x5c7d88
leaq 0x8(%rsp), %rdi
callq 0x40c908
leaq 0x8(%rsp), %rdx
pushq $0x1
popq %r8
movq %rbx, %rdi
movl %r14d, %esi
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x40d860
leaq 0x8(%rsp), %rdi
callq 0x4050e8
movl 0x34(%rbx), %edi
callq 0x556f50
movq 0x48(%rbx), %rsi
movq %rbx, %rdx
addq $0x50, %rdx
movl %ebp, %edi
callq 0x559eb0
movl %eax, 0x34(%rbx)
cmpl $-0x1, %eax
je 0x40e8fc
movl $0x1, 0x54(%rbx)
jmp 0x40e906
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4050e8
jmp 0x40e924
movq %rax, %r14
movl $0xc8, %esi
movq %rbx, %rdi
callq 0x41fb60
movq %r14, %rdi
callq 0x4ca950
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Network/Manager.cpp
// Function: u::Network::Manager::Manager()
Manager::Manager() : EventRoom()
{
	_isClosing = false;
	addEventListener(
		Event::REGISTER_NETWORK
		, Callback(this, cb_cast(&Network::Manager::onRegisterNetwork))
	);
	addEventListener(
		Event::REQUEST_LISTENER
		, Callback(this, cb_cast(&Network::Manager::onRequestListener))
	);
	addEventListener(
		Event::CLOSE
		, Callback(this, cb_cast(&Network::Manager::onCloseRequest))
	);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
callq 0x40c0dc
leaq 0x2335cf(%rip), %rax    # 0x643760
movq %rax, (%rbx)
leaq 0x88(%rbx), %r14
movq %r14, %rdi
callq 0x411060
leaq 0x110(%rbx), %r15
movq %r15, %rdi
callq 0x410bfa
movb $0x0, 0x160(%rbx)
leaq 0xb0(%rsp), %rdi
pushq $0x21
popq %rdx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x409b80
movq $0x64da88, %rsi         # imm = 0x64DA88
leaq 0xb0(%rsp), %rdx
movq %rbx, %rdi
callq 0x40abb6
leaq 0xb0(%rsp), %rdi
callq 0x40c544
leaq 0x58(%rsp), %rdi
pushq $0x29
popq %rdx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x409b80
movq $0x64dae0, %rsi         # imm = 0x64DAE0
leaq 0x58(%rsp), %rdx
movq %rbx, %rdi
callq 0x40abb6
leaq 0x58(%rsp), %rdi
callq 0x40c544
movq %rsp, %rdi
pushq $0x39
popq %rdx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x409b80
movq $0x64dbe8, %rsi         # imm = 0x64DBE8
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x40abb6
movq %rsp, %rdi
callq 0x40c544
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r12
movq %rsp, %rdi
jmp 0x410281
movq %rax, %r12
leaq 0x58(%rsp), %rdi
jmp 0x410281
movq %rax, %r12
leaq 0xb0(%rsp), %rdi
callq 0x40c544
jmp 0x410295
movq %rax, %r12
jmp 0x41029d
movq %rax, %r12
jmp 0x4102a5
movq %rax, %r12
movq %r15, %rdi
callq 0x410c3c
movq %r14, %rdi
callq 0x4111d6
movq %rbx, %rdi
callq 0x40c10a
movq %r12, %rdi
callq 0x4ca950
nop
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Network/Manager.cpp
// Function: u::Network::Manager::~Manager()
Manager::~Manager()
{
	if (_listener.size() > 0) {
		error(
			className()
			+ "::~Manager: Listeners must be closed before destroy."
		);
	}
	
	removeEventListener(
		Event::REGISTER_NETWORK
		, Callback(this, cb_cast(&Network::Manager::onRegisterNetwork))
	);
	removeEventListener(
		Event::REQUEST_LISTENER
		, Callback(this, cb_cast(&Network::Manager::onRequestListener))
	);
	removeEventListener(
		Event::CLOSE
		, Callback(this, cb_cast(&Network::Manager::onCloseRequest))
	);

	trace(className() + "::~Manager: Down.");
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdi, %rbx
leaq 0x233496(%rip), %rax    # 0x643760
movq %rax, (%rdi)
movq 0x150(%rdi), %rax
cmpq 0x148(%rdi), %rax
je 0x41034f
movq $0x64eb00, %rdi         # imm = 0x64EB00
leaq 0x1b6e68(%rip), %rsi    # 0x5c7153
callq 0x489b70
movq %rax, %r14
movq (%rbx), %rax
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq *0x8(%rax)
leaq 0x60(%rsp), %rsi
leaq 0x1b7d5b(%rip), %rdx    # 0x5c8068
leaq 0x8(%rsp), %rdi
callq 0x405349
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x49c3f0
leaq 0x1b6d80(%rip), %rsi    # 0x5c70ab
movq %rax, %rdi
callq 0x489b70
movq %rax, %rdi
callq 0x489450
leaq 0x8(%rsp), %rdi
callq 0x499a70
leaq 0x28(%rsp), %rdi
callq 0x4050e8
leaq 0x130(%rsp), %rdi
pushq $0x21
popq %rdx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x409b80
movq $0x64da88, %rsi         # imm = 0x64DA88
leaq 0x130(%rsp), %rdx
movq %rbx, %rdi
callq 0x40ac48
leaq 0x130(%rsp), %rdi
callq 0x40c544
leaq 0xd8(%rsp), %rdi
pushq $0x29
popq %rdx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x409b80
movq $0x64dae0, %rsi         # imm = 0x64DAE0
leaq 0xd8(%rsp), %rdx
movq %rbx, %rdi
callq 0x40ac48
leaq 0xd8(%rsp), %rdi
callq 0x40c544
leaq 0x80(%rsp), %rdi
pushq $0x39
popq %rdx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x409b80
movq $0x64dbe8, %rsi         # imm = 0x64DBE8
leaq 0x80(%rsp), %rdx
movq %rbx, %rdi
callq 0x40ac48
leaq 0x80(%rsp), %rdi
callq 0x40c544
movq $0x64ec20, %rdi         # imm = 0x64EC20
leaq 0x1b6c80(%rip), %rsi    # 0x5c7091
callq 0x489b70
movq %rax, %r14
movq (%rbx), %rax
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq *0x8(%rax)
leaq 0x60(%rsp), %rsi
leaq 0x1b7c6a(%rip), %rdx    # 0x5c809d
leaq 0x8(%rsp), %rdi
callq 0x405349
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x49c3f0
leaq 0x1b6c5a(%rip), %rsi    # 0x5c70ab
movq %rax, %rdi
callq 0x489b70
movq %rax, %rdi
callq 0x489450
leaq 0x8(%rsp), %rdi
callq 0x499a70
leaq 0x28(%rsp), %rdi
callq 0x4050e8
leaq 0x110(%rbx), %rdi
callq 0x410c3c
leaq 0x88(%rbx), %rdi
callq 0x4111d6
movq %rbx, %rdi
callq 0x40c10a
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x4052dd
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Network/Manager.cpp
// Function: u::Network::Manager::onRegisterNetwork(u::Object*)
void Manager::onRegisterNetwork(Object *arg)
{
	Event* event = ((Event*) arg);

	lock();
	if (_builder.hasKey(event->networkType) == false) {
		_builder[event->networkType] = event->builder;
		Event response(
			Event::NETWORK_REGISTERED
			, event->networkType
		);
		unlock();
		dispatchEvent(&response);
	} else {
		unlock();
	}

	event->destroy();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsi, %rbx
movq %rdi, %r14
callq 0x40c442
leaq 0x88(%r14), %r12
leaq 0x58(%rbx), %r15
leaq 0xb8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x40cb38
movq %r12, %rdi
movq %r13, %rsi
callq 0x411632
movl %eax, %ebp
leaq 0xb8(%rsp), %rdi
callq 0x4050e8
testb %bpl, %bpl
je 0x41053c
movq %r14, %rdi
callq 0x40c3fe
jmp 0x4105c6
movq 0x48(%rbx), %r13
leaq 0x60(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x40cb38
movq %r12, %rdi
movq %rbp, %rsi
callq 0x4112d6
movq %rax, %rdi
movq %r13, %rsi
callq 0x4114c6
leaq 0x60(%rsp), %rdi
callq 0x4050e8
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x40cb38
movq $0x64db38, %rsi         # imm = 0x64DB38
leaq 0x110(%rsp), %rdi
movq %r12, %rdx
callq 0x40ff84
leaq 0x8(%rsp), %rdi
callq 0x4050e8
movq %r14, %rdi
callq 0x40c3fe
leaq 0x110(%rsp), %rsi
movq %r14, %rdi
callq 0x40ad2c
leaq 0x110(%rsp), %rdi
callq 0x4100e2
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x410611
movq %rax, %rbx
leaq 0x110(%rsp), %rdi
callq 0x4100e2
jmp 0x410616
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
jmp 0x410611
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x4050e8
movq %rbx, %rdi
callq 0x4ca950
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Network/Manager.cpp
// Function: u::Network::Manager::onListenerClosed(u::Object*)
void Manager::onListenerClosed(Object *arg)
{
	Event* event = ((Event*) arg);
	lock();
	Network::IListener* listener = ((Network::IListener*) event->target());
	if (_listener.erase(listener) != -1) {
		// Destroy only when owned.
		listener->removeEventListener(
			Event::CLOSED
			, Callback(this, cb_cast(&Network::Manager::onListenerClosed))
		);
		listener->destroy();

		unlock();
		checkForCloseState();
	} else {
		unlock();
	}
	event->destroy();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x40c442
movq %rbx, %rdi
callq 0x409f0c
movq %rax, %r15
leaq 0x110(%r14), %rdi
movq %rax, %rsi
callq 0x410c68
cmpq $-0x1, %rax
je 0x410967
movq %rsp, %r12
pushq $0x31
popq %rdx
movq %r12, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x409b80
movq $0x64dc40, %rsi         # imm = 0x64DC40
movq %r15, %rdi
movq %r12, %rdx
callq 0x40ac48
movq %rsp, %rdi
callq 0x40c544
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
movq %r14, %rdi
callq 0x40c3fe
movq (%r14), %rax
movq %r14, %rdi
callq *0x40(%rax)
jmp 0x41096f
movq %r14, %rdi
callq 0x40c3fe
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x40c544
movq %rbx, %rdi
callq 0x4ca950
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Network/Manager.cpp
// Function: u::Network::Manager::onCloseRequest(u::Object*)
void Manager::onCloseRequest(Object *arg)
{
	trace(className() + ": Start close procedure.");
	arg->destroy();
	lock();
	if(_isClosing == false) {
		uint64 i, length = _listener.length();
		Event close(Event::CLOSE);
		for (i = 0; i < length; i++) {
			_listener[i]->dispatchEvent(&close);
		}
	}
	_isClosing = true;
	unlock();
	checkForCloseState();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq $0x64ec20, %rdi         # imm = 0x64EC20
leaq 0x1b66d7(%rip), %rsi    # 0x5c7091
callq 0x489b70
movq %rax, %r15
movq (%rbx), %rax
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq *0x8(%rax)
leaq 0x60(%rsp), %rsi
leaq 0x1b7704(%rip), %rdx    # 0x5c80e0
leaq 0x8(%rsp), %rdi
callq 0x405349
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x49c3f0
leaq 0x1b66b1(%rip), %rsi    # 0x5c70ab
movq %rax, %rdi
callq 0x489b70
movq %rax, %rdi
callq 0x489450
leaq 0x8(%rsp), %rdi
callq 0x499a70
leaq 0x28(%rsp), %rdi
callq 0x4050e8
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq %rbx, %rdi
callq 0x40c442
cmpb $0x0, 0x160(%rbx)
jne 0x410a91
leaq 0x110(%rbx), %r14
movq 0x150(%rbx), %r13
subq 0x148(%rbx), %r13
sarq $0x3, %r13
movq $0x64dbe8, %rsi         # imm = 0x64DBE8
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x40ffe2
xorl %r12d, %r12d
cmpq %r12, %r13
je 0x410a87
movq %r14, %rdi
movq %r12, %rsi
callq 0x410cd2
movq %rax, %rdi
movq %r15, %rsi
callq 0x40ad2c
incq %r12
jmp 0x410a67
leaq 0x28(%rsp), %rdi
callq 0x4100e2
movb $0x1, 0x160(%rbx)
movq %rbx, %rdi
callq 0x40c3fe
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x410acc
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x499a70
leaq 0x28(%rsp), %rdi
callq 0x4050e8
jmp 0x410ae5
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4100e2
movq %rbx, %rdi
callq 0x4ca950
nop
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Network/Manager.cpp
// Function: u::Network::Manager::checkForCloseState()
void Manager::checkForCloseState()
{
	lock();
	if (_listener.length() == 0) {
		trace(className() + ": All closed.");
		Event closed(Event::CLOSED);
		unlock();
		dispatchEvent(&closed);
	} else {
		unlock();
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
callq 0x40c442
movq 0x150(%rbx), %rax
cmpq 0x148(%rbx), %rax
je 0x410b22
movq %rbx, %rdi
addq $0xd8, %rsp
popq %rbx
popq %r14
jmp 0x40c3fe
movq $0x64ec20, %rdi         # imm = 0x64EC20
leaq 0x1b6561(%rip), %rsi    # 0x5c7091
callq 0x489b70
movq %rax, %r14
movq (%rbx), %rax
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq *0x8(%rax)
leaq 0x58(%rsp), %rsi
leaq 0x1b75a7(%rip), %rdx    # 0x5c80f9
movq %rsp, %rdi
callq 0x405349
movq %rsp, %rsi
movq %r14, %rdi
callq 0x49c3f0
leaq 0x1b653f(%rip), %rsi    # 0x5c70ab
movq %rax, %rdi
callq 0x489b70
movq %rax, %rdi
callq 0x489450
movq %rsp, %rdi
callq 0x499a70
leaq 0x20(%rsp), %rdi
callq 0x4050e8
movq $0x64dc40, %rsi         # imm = 0x64DC40
leaq 0x20(%rsp), %rdi
callq 0x40ffe2
movq %rbx, %rdi
callq 0x40c3fe
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x40ad2c
leaq 0x20(%rsp), %rdi
callq 0x4100e2
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x410be8
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4100e2
jmp 0x410bf2
movq %rax, %rbx
movq %rsp, %rdi
callq 0x499a70
leaq 0x20(%rsp), %rdi
callq 0x4050e8
movq %rbx, %rdi
callq 0x4ca950
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Datablock.cpp
// Function: u::Datablock::operator=(u::Datablock&)
Datablock& Datablock::operator=(Datablock& value)
{
	deleteAttributes();

	int64 i, l;
	l = value._list.size();
	for(i=0; i<l; i++)
	{
		saveAttribute(value._list[i]);
	}
	return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x41114e
leaq 0x38(%r15), %r14
movq 0x78(%r15), %r12
subq 0x70(%r15), %r12
sarq $0x3, %r12
xorl %r15d, %r15d
testq %r12, %r12
cmovleq %r15, %r12
cmpq %r15, %r12
je 0x41113f
movq %r14, %rdi
movq %r15, %rsi
callq 0x411820
movq %rbx, %rdi
movq %rax, %rsi
callq 0x411180
incq %r15
jmp 0x41111f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Datablock.cpp
// Function: u::Datablock::deleteAttributes()
void Datablock::deleteAttributes()
{
	_attribute * entry;
	while(!_list.empty())
	{
		//trace("Remove a entry.");
		entry = _list.back();
		deleteAttribute(entry);
		entry->destroy();
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x78(%rbx), %rax
cmpq %rax, 0x70(%rbx)
je 0x411178
movq -0x8(%rax), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x411204
movq %r14, %rdi
callq 0x4112aa
jmp 0x411155
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Datablock.cpp
// Function: u::Datablock::deleteAttribute(u::Datablock::_attribute*)
void Datablock::deleteAttribute(Datablock::_attribute *entry)
{
	int64 i,l;

	l=_list.size();
	for(i=0; i<l; i++)
	{
		if(_list[i] == entry)
		{
			_list.erase(i);
			break;
		}
	}

	l = entry->ref.size();
	for(i=0; i<l; i++)
	{
		if(entry->ref[i] == this)
		{
			entry->ref.erase(i);
			break;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rdi), %r15
movq 0x78(%rdi), %r13
subq 0x70(%rdi), %r13
sarq $0x3, %r13
xorl %r12d, %r12d
testq %r13, %r13
cmovleq %r12, %r13
cmpq %r12, %r13
je 0x411252
movq %r15, %rdi
movq %r12, %rsi
callq 0x411820
cmpq %r14, %rax
je 0x411247
incq %r12
jmp 0x41122d
movq %r15, %rdi
movq %r12, %rsi
callq 0x41184e
leaq 0x70(%r14), %r15
movq 0xb0(%r14), %r12
subq 0xa8(%r14), %r12
sarq $0x3, %r12
xorl %r14d, %r14d
testq %r12, %r12
cmovleq %r14, %r12
cmpq %r14, %r12
je 0x41128c
movq %r15, %rdi
movq %r14, %rsi
callq 0x411860
cmpq %rbx, %rax
je 0x411296
incq %r14
jmp 0x411272
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x411870
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Datablock.cpp
// Function: u::Datablock::operator[](u::String)
Datablock::_attribute & Datablock::operator[](String name)
{
	int64 i,l;
	_attribute *entry;
	l = _list.size();
	for(i=0; i<l; i++)
	{
		entry = _list[i];
		if(entry->name == name) return *entry;
	}
	entry = new _attribute(name);

	saveAttribute(entry);

	return *entry;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
leaq 0x38(%rdi), %r12
movq 0x78(%rdi), %r15
subq 0x70(%rdi), %r15
sarq $0x3, %r15
movq %rsi, 0x8(%rsp)
leaq 0x38(%rsi), %r13
xorl %ebp, %ebp
testq %r15, %r15
cmovleq %rbp, %r15
cmpq %rbp, %r15
je 0x411331
movq %r12, %rdi
movq %rbp, %rsi
callq 0x411820
movq %rax, %rbx
leaq 0x40(%rax), %rdi
movq %r13, %rsi
callq 0x406883
incq %rbp
testb %al, %al
je 0x411309
jmp 0x41136f
movl $0xc0, %edi
callq 0x420b40
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x40cb38
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x41156a
leaq 0x10(%rsp), %rdi
callq 0x4050e8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x411180
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x4050e8
jmp 0x411393
movq %rax, %r14
movl $0xc0, %esi
movq %rbx, %rdi
callq 0x41fb60
movq %r14, %rdi
callq 0x4ca950
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Datablock.cpp
// Function: u::Datablock::toString()
String Datablock::toString()
{
	String str = "[" + className();
	str += " length=" + int2string(_list.size());
	str += "]";
	return str;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x40(%rsp), %rdi
callq *0x8(%rax)
leaq 0x78(%rsp), %rdx
leaq 0x1b6939(%rip), %rsi    # 0x5c7d08
leaq 0x20(%rsp), %rdi
callq 0x405368
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x40c94e
leaq 0x20(%rsp), %rdi
callq 0x499a70
leaq 0x40(%rsp), %rdi
callq 0x4050e8
movq 0x78(%r14), %rsi
subq 0x70(%r14), %rsi
shrq $0x3, %rsi
leaq 0x40(%rsp), %rdi
callq 0x40c712
leaq 0x78(%rsp), %rdx
leaq 0x1b5c52(%rip), %rsi    # 0x5c706e
movq %rsp, %rdi
callq 0x405368
leaq 0x38(%rbx), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x49b180
movq %rsp, %rdi
callq 0x499a70
leaq 0x40(%rsp), %rdi
callq 0x4050e8
leaq 0x1da95a(%rip), %rsi    # 0x5ebda6
movq %r14, %rdi
callq 0x49b220
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
jmp 0x411480
movq %rax, %r14
movq %rsp, %rdi
callq 0x499a70
jmp 0x411474
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x4050e8
jmp 0x411483
movq %rax, %r14
movq %rbx, %rdi
jmp 0x41149f
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x499a70
jmp 0x41149a
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x4050e8
movq %r14, %rdi
callq 0x4ca950
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Datablock.cpp
// Function: u::Datablock::_attribute::operator=(u::Object*)
Object *Datablock::_attribute::operator =(Object *value)
{
	destroyValue();
	isObject = true;
	this->value = value;
	//trace("Save as Object.");
	return value;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4114ea
movb $0x1, 0x68(%r14)
movq %rbx, 0x60(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Datablock.cpp
// Function: u::Datablock::_attribute::destroyValue()
void Datablock::_attribute::destroyValue()
{
	if(value != null)
	{
		if(isObject == true)
		{
			//trace("Destroy object.");
			if(valid((Object *)value)) ((Object*)value)->destroy();
		}
		else
		{
			//trace("Destroy a int.");
			delete (int64*)value;
		}
		value = null;
		if(_noDelete == false) delete (_attribute*)this;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
testq %rdi, %rdi
je 0x411523
cmpb $0x1, 0x68(%rbx)
jne 0x411511
callq 0x40d1b6
testb %al, %al
je 0x411519
movq 0x60(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
jmp 0x411519
pushq $0x8
popq %rsi
callq 0x41fb60
andq $0x0, 0x60(%rbx)
cmpb $0x0, (%rbx)
je 0x411525
popq %rbx
retq
movq %rbx, %rdi
callq 0x4115da
movl $0xc0, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x41fb60
nop
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Datablock.cpp
// Function: u::Datablock::_attribute::operator=(long)
int64 Datablock::_attribute::operator =(int64 value)
{
	destroyValue();
	isObject = false;
	this->value = new int64();
	*((int64*)this->value) = value;

	return value;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4114ea
movb $0x0, 0x68(%r14)
pushq $0x8
popq %rdi
callq 0x420b40
movq %rax, 0x60(%r14)
movq %rbx, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Datablock.cpp
// Function: u::Datablock::_attribute::_attribute(u::String)
u::Datablock::_attribute::_attribute(String keyName)
{
	_noDelete = false;
	value = null;
	isObject = false;
	name = keyName;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x40c8e2
leaq 0x70(%r12), %r14
movq %r14, %rdi
callq 0x411882
xorl %eax, %eax
movb %al, (%r12)
andq $0x0, 0x60(%r12)
movb %al, 0x68(%r12)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x40cbf6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x4118c4
jmp 0x4115c9
movq %rax, %r15
movq %rbx, %rdi
callq 0x4050e8
movq %r15, %rdi
callq 0x4ca950
nop
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Datablock.cpp
// Function: u::Datablock::hasKey(u::String)
bool u::Datablock::hasKey(String key)
{
	int64 l = _list.length(), i;
	for(i = 0; i < l; i++)
	{
		if(_list[i]->name == key) return true;
	}

	return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq 0x78(%rdi), %r12
subq 0x70(%rdi), %r12
leaq 0x38(%rdi), %r14
sarq $0x3, %r12
addq $0x38, %rbx
xorl %ecx, %ecx
testq %r12, %r12
movl $0x0, %r13d
cmovgq %r12, %r13
movq %rcx, %r15
cmpq %rcx, %r13
je 0x411688
movq %r14, %rdi
movq %r15, %rsi
callq 0x411820
leaq 0x40(%rax), %rdi
movq %rbx, %rsi
callq 0x406883
leaq 0x1(%r15), %rcx
testb %al, %al
je 0x411661
cmpq %r12, %r15
setl %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Datablock.cpp
// Function: u::Datablock::getKeys()
Vector<String> u::Datablock::getKeys()
{
	Vector<String> result;
	int length = _list.length(), i;
	for(i = 0; i < length; i++)
	{
		result.push(_list[i]->name);
	}

	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x4050a6
movq 0x78(%r14), %rbp
subq 0x70(%r14), %rbp
addq $0x38, %r14
shrq $0x3, %rbp
leaq 0x38(%rbx), %r15
xorl %r12d, %r12d
testl %ebp, %ebp
cmovlel %r12d, %ebp
movq %rsp, %r13
cmpq %r12, %rbp
je 0x411708
movq %r14, %rdi
movq %r12, %rsi
callq 0x411820
addq $0x8, %rax
movq %r13, %rdi
movq %rax, %rsi
callq 0x40cb38
movq %r15, %rdi
movq %r13, %rsi
callq 0x407998
movq %r13, %rdi
callq 0x4050e8
incq %r12
jmp 0x4116d1
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x4050e8
jmp 0x41172a
movq %rax, %r14
movq %rbx, %rdi
callq 0x405148
movq %r14, %rdi
callq 0x4ca950
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Datablock.cpp
// Function: u::Datablock::remove(u::String)
void u::Datablock::remove(String key)
{
	int64 l = _list.length(), i;
	for(i = 0; i < l; i++)
	{
		if(_list[i]->name == key) {
			delete (_attribute*)_list[i];
			return;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
leaq 0x38(%rdi), %rbx
movq 0x78(%rdi), %r12
subq 0x70(%rdi), %r12
sarq $0x3, %r12
addq $0x38, %r14
xorl %r15d, %r15d
testq %r12, %r12
cmovleq %r15, %r12
cmpq %r15, %r12
je 0x411788
movq %rbx, %rdi
movq %r15, %rsi
callq 0x411820
leaq 0x40(%rax), %rdi
movq %r14, %rsi
callq 0x406883
testb %al, %al
jne 0x411794
incq %r15
jmp 0x411763
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r15, %rsi
callq 0x411820
movq %rax, %rbx
testq %rax, %rax
je 0x4117af
movq %rbx, %rdi
callq 0x4115da
movl $0xc0, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x41fb60
nop
// File: /workspace/github_cpp_makefile_star2_O2/supervoltage[P]morsetran/source/main.cpp
// Function: main
int main(int argc, char** argv)
{
	if(argc <= 1)
	{	
		cout << "ERROR: No input present\n";
		return 0;
	}
	
	string helpChk = argv[1];
	
	if(helpChk == "--help" || helpChk == "-h")
	{
		cout << "Usage: " << argv[0] << " [TEXT]\n" << "       " <<
				argv[0] << " [MORSE]\n";
		cout << "Translate text into morse code or morse code into text.\n\n";
		cout << "  -h, --help\t\tdisplay this help\n\n";
		
		cout << "Examples:\n\t" << argv[0] << " example text\n";
		cout << "\t" << argv[0] <<
				" . -..- .- -- .--. .-.. .  / -- --- .-. ... .\n\n";
		cout << "Report bugs and suggestions to <ubervoltage@gmail.com>\n";
		return 0;
	}
	
	char prFind;			//determine if program should run in
	prFind = argv[1][0];	//morse-to-text mode or text-to-morse mode
	
	if(prFind == '.' || prFind == '/' || prFind == '-')
		morseToTextMode(argc, argv);
	else
		textToMorseMode(argc, argv);
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x1, %edi
jg 0x12e6
movq 0x2d03(%rip), %rdi      # 0x3fd8
leaq 0xd28(%rip), %rsi       # 0x2004
callq 0x10b0
jmp 0x141d
movq %rsi, %rbx
movl %edi, %r14d
movq 0x8(%rsi), %rsi
leaq -0x40(%rbp), %r15
leaq -0x19(%rbp), %rdx
movq %r15, %rdi
callq 0x1466
leaq 0xd16(%rip), %rsi       # 0x201d
movq %r15, %rdi
callq 0x14a1
testb %al, %al
jne 0x132b
leaq 0xd0a(%rip), %rsi       # 0x2024
leaq -0x40(%rbp), %rdi
callq 0x14a1
testb %al, %al
je 0x142a
movq 0x2ca6(%rip), %rdi      # 0x3fd8
leaq 0xcee(%rip), %rsi       # 0x2027
callq 0x10b0
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x10b0
leaq 0xcdf(%rip), %rsi       # 0x202f
movq %rax, %rdi
callq 0x10b0
leaq 0xcd9(%rip), %rsi       # 0x2038
movq %rax, %rdi
callq 0x10b0
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x10b0
leaq 0xcc7(%rip), %rsi       # 0x2040
movq %rax, %rdi
callq 0x10b0
movq 0x2c50(%rip), %rdi      # 0x3fd8
leaq 0xcbb(%rip), %rsi       # 0x204a
callq 0x10b0
movq 0x2c3d(%rip), %rdi      # 0x3fd8
leaq 0xce2(%rip), %rsi       # 0x2084
callq 0x10b0
movq 0x2c2a(%rip), %rdi      # 0x3fd8
leaq 0xcf1(%rip), %rsi       # 0x20a6
callq 0x10b0
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x10b0
leaq 0xce6(%rip), %rsi       # 0x20b2
movq %rax, %rdi
callq 0x10b0
movq 0x2bfd(%rip), %rdi      # 0x3fd8
leaq 0xcce(%rip), %rsi       # 0x20b0
callq 0x10b0
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x10b0
leaq 0xcc8(%rip), %rsi       # 0x20c1
movq %rax, %rdi
callq 0x10b0
movq 0x2bd0(%rip), %rdi      # 0x3fd8
leaq 0xce2(%rip), %rsi       # 0x20f1
callq 0x10b0
leaq -0x40(%rbp), %rdi
callq 0x1050
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rax
movb (%rax), %al
addb $-0x2d, %al
cmpb $0x2, %al
ja 0x1443
movl %r14d, %edi
movq %rbx, %rsi
callq 0x1550
jmp 0x1414
movl %r14d, %edi
movq %rbx, %rsi
callq 0x1bd0
jmp 0x1414
jmp 0x1452
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x1050
movq %rbx, %rdi
callq 0x10f0
// File: /workspace/github_cpp_makefile_star2_O2/supervoltage[P]morsetran/source/mttmode.cpp
// Function: morseToTextMode(int, char**)
void morseToTextMode(int argc, char **argv)
{
	string morseIn;
	
	for(int i = 1; i < argc; i++)
	{
		morseIn = argv[i];
		cout << getLetter(morseIn);
	}
	cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rsi, %rbx
movb $0x0, (%rax)
movslq %edi, %r13
pushq $0x1
popq %r12
leaq -0x48(%rbp), %r14
leaq -0x68(%rbp), %r15
cmpq %r13, %r12
jge 0x15c3
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
callq 0x1110
movq %r15, %rdi
movq %r14, %rsi
callq 0x10d0
movq %r15, %rdi
callq 0x160b
movsbl %al, %esi
movq 0x2a27(%rip), %rdi      # 0x3fd8
callq 0x10c0
movq %r15, %rdi
callq 0x1050
incq %r12
jmp 0x1583
movq 0x2a0e(%rip), %rdi      # 0x3fd8
callq 0x1060
leaq -0x48(%rbp), %rdi
callq 0x1050
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15f7
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x1050
jmp 0x15fa
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x1050
movq %rbx, %rdi
callq 0x10f0
// File: /workspace/github_cpp_makefile_star2_O2/supervoltage[P]morsetran/source/ttmmode.cpp
// Function: textToMorseMode(int, char**)
void textToMorseMode(int argc, char **argv)
{
	string textIn;
	
	for(int i = 1; i < argc; i++)
	{
		string textIn = argv[i];
		
		for(int j = 0; j < textIn.length(); j++)
		{
			cout << getMorse(textIn[j]) << " ";
		}
		
		if(i == argc - 1)
			break;
		else
			cout << " / ";
	}
	cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, -0x38(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movslq %edi, %rax
movq %rax, -0x40(%rbp)
decl %edi
movq %rdi, -0x30(%rbp)
pushq $0x1
popq %r15
leaq -0x60(%rbp), %r14
leaq -0xa0(%rbp), %r12
movq 0x23c0(%rip), %r13      # 0x3fd8
leaq 0x41f(%rip), %rbx       # 0x203e
cmpq -0x40(%rbp), %r15
jge 0x1ca4
movq -0x38(%rbp), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x1466
xorl %r14d, %r14d
cmpq %r14, -0x58(%rbp)
jbe 0x1c75
movq -0x60(%rbp), %rax
movsbl (%rax,%r14), %esi
movq %r12, %rdi
callq 0x1cff
movq %r13, %rdi
movq %r12, %rsi
callq 0x10a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x10b0
movq %r12, %rdi
callq 0x1050
incq %r14
jmp 0x1c3b
cmpq -0x30(%rbp), %r15
je 0x1c9b
movq %r13, %rdi
leaq 0x6d3(%rip), %rsi       # 0x2358
callq 0x10b0
leaq -0x60(%rbp), %r14
movq %r14, %rdi
callq 0x1050
incq %r15
jmp 0x1c1f
leaq -0x60(%rbp), %rdi
callq 0x1050
movq 0x232d(%rip), %rdi      # 0x3fd8
callq 0x1060
leaq -0x80(%rbp), %rdi
callq 0x1050
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1ccc
jmp 0x1cd1
movq %rax, %rbx
jmp 0x1cee
movq %rax, %rbx
jmp 0x1ce5
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x1050
leaq -0x60(%rbp), %rdi
callq 0x1050
leaq -0x80(%rbp), %rdi
callq 0x1050
movq %rbx, %rdi
callq 0x10f0
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/program_options/src/cmdline.cpp
// Function: boost::program_options::detail::cmdline::init(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
void
    cmdline::init(const vector<string>& args)
    {
        this->args = args;        
        m_style = command_line_style::default_style;
        m_desc = 0;
        m_positional = 0;
        m_allow_unregistered = false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xe89e
movl $0x3f7, 0x18(%rbx)      # imm = 0x3F7
movb $0x0, 0x1c(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/program_options/src/cmdline.cpp
// Function: boost::program_options::detail::cmdline::cmdline(int, char const* const*)
cmdline::cmdline(int argc, const char*const * argv)
    {
#if defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)
        vector<string> args;
        copy(argv+1, argv+argc+!argc, inserter(args, args.end()));
        init(args);
#else
        init(vector<string>(argv+1, argv+argc+!argc));
#endif
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
andq $0x0, 0x30(%rdi)
andq $0x0, 0x50(%rdi)
movslq %esi, %rax
leaq (%rdx,%rax,8), %rcx
leaq 0x8(%rdx), %rsi
xorl %edx, %edx
testl %eax, %eax
sete %dl
leaq (%rcx,%rdx,8), %rdx
leaq -0x38(%rbp), %rdi
leaq -0x19(%rbp), %rcx
callq 0xe86c
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0xcd98
leaq -0x38(%rbp), %rdi
callq 0xe840
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0xe840
jmp 0xce39
movq %rax, %r14
leaq 0x30(%rbx), %r15
leaq 0x50(%rbx), %rdi
callq 0xe818
movq %r15, %rdi
callq 0xe82c
movq %rbx, %rdi
callq 0xe840
movq %r14, %rdi
callq 0xc850
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/program_options/src/cmdline.cpp
// Function: boost::program_options::detail::cmdline::check_style(int) const
void 
    cmdline::check_style(int style) const
    {
        bool allow_some_long = 
            (style & allow_long) || (style & allow_long_disguise);

        const char* error = 0;
        if (allow_some_long && 
            !(style & long_allow_adjacent) && !(style & long_allow_next))
            error = "boost::program_options misconfiguration: "
                    "choose one or other of 'command_line_style::long_allow_next' "
                    "(whitespace separated arguments) or "
                    "'command_line_style::long_allow_adjacent' ('=' separated arguments) for "
                    "long options.";

        if (!error && (style & allow_short) &&
            !(style & short_allow_adjacent) && !(style & short_allow_next))
            error = "boost::program_options misconfiguration: "
                    "choose one or other of 'command_line_style::short_allow_next' "
                    "(whitespace separated arguments) or "
                    "'command_line_style::short_allow_adjacent' ('=' separated arguments) for "
                    "short options.";

        if (!error && (style & allow_short) &&
            !(style & allow_dash_for_short) && !(style & allow_slash_for_short))
            error = "boost::program_options misconfiguration: "
                    "choose one or other of 'command_line_style::allow_slash_for_short' "
                    "(slashes) or 'command_line_style::allow_dash_for_short' (dashes) for "
                    "short options.";

        if (error)
            boost::throw_exception(invalid_command_line_style(error));

        // Need to check that if guessing and long disguise are enabled
        // -f will mean the same as -foo
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
testw $0x1001, %si            # imm = 0x1001
setne %al
testb $0x30, %sil
sete %cl
testb %cl, %al
jne 0xcebd
movl %esi, %eax
andl $0xc2, %eax
cmpl $0x2, %eax
je 0xcec6
andl $0xe, %esi
cmpl $0x2, %esi
je 0xcecf
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1f33a(%rip), %rsi     # 0x2c1fe
jmp 0xced6
leaq 0x1f411(%rip), %rsi     # 0x2c2de
jmp 0xced6
leaq 0x1f4eb(%rip), %rsi     # 0x2c3c1
leaq -0x40(%rbp), %rbx
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0xc1b0
leaq -0x20(%rbp), %rdi
movq %rbx, %rsi
callq 0xe9de
leaq -0x20(%rbp), %rdi
callq 0xe968
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0xc860
jmp 0xcf0c
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xc9a0
movq %rbx, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/program_options/src/cmdline.cpp
// Function: boost::program_options::detail::cmdline::get_canonical_option_prefix()
int
    cmdline::get_canonical_option_prefix()
    {
        if (m_style & allow_long)
            return allow_long;

        if (m_style & allow_long_disguise)
            return allow_long_disguise;

        if ((m_style & allow_short) && (m_style & allow_dash_for_short))
            return allow_dash_for_short;

        if ((m_style & allow_short) && (m_style & allow_slash_for_short))
            return allow_slash_for_short;

        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x18(%rdi), %ecx
testb $0x1, %cl
jne 0xcf6d
movl $0x1000, %eax           # imm = 0x1000
btl $0xc, %ecx
jb 0xcf72
notl %ecx
testb $0x6, %cl
jne 0xcf74
movl $0x4, %eax
jmp 0xcf72
movl $0x1, %eax
popq %rbp
retq
xorl %eax, %eax
testb $0xa, %cl
sete %al
shll $0x3, %eax
jmp 0xcf72
nop
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/program_options/src/cmdline.cpp
// Function: boost::program_options::detail::cmdline::handle_additional_parser(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
vector<option> 
    cmdline::handle_additional_parser(vector<string>& args)
    {
        vector<option> result;
        pair<string, string> r = m_additional_parser(args[0]);
        if (!r.first.empty()) {
            option next;
            next.string_key = r.first;
            if (!r.second.empty())
                next.value.push_back(r.second);
            result.push_back(next);
            args.erase(args.begin());
        }
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdx, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
addq $0x30, %rsi
movq (%rdx), %rdx
leaq -0x50(%rbp), %rdi
callq 0xef86
cmpq $0x0, -0x48(%rbp)
je 0xd892
leaq -0xa0(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
orl $-0x1, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
andw $0x0, 0x48(%rax)
leaq -0xb0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xc2b0
cmpq $0x0, -0x28(%rbp)
je 0xd86c
leaq -0x88(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xeaf4
leaq -0xb0(%rbp), %rsi
movq %rbx, %rdi
callq 0xea8c
movq (%r14), %rsi
movq %r14, %rdi
callq 0xeb30
leaq -0xb0(%rbp), %rdi
callq 0xeb3a
leaq -0x50(%rbp), %rdi
callq 0xefd8
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xd8b1
movq %rax, %r14
jmp 0xd8c9
movq %rax, %r14
leaq -0xb0(%rbp), %rdi
callq 0xeb3a
leaq -0x50(%rbp), %rdi
callq 0xefd8
movq %rbx, %rdi
callq 0xeac8
movq %r14, %rdi
callq 0xc850
nop
// File: /workspace/github_cpp_makefile_star2_O2/demon386[P]git-store/./libs/program_options/src/cmdline.cpp
// Function: boost::program_options::detail::cmdline::parse_disguised_long_option(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
vector<option> 
    cmdline::parse_disguised_long_option(vector<string>& args)
    {
        const string& tok = args[0];
        if (tok.size() >= 2 && 
            ((tok[0] == '-' && tok[1] != '-') ||
             ((m_style & allow_slash_for_short) && tok[0] == '/')))            
        {
            try
            {
                if (m_desc->find_nothrow(tok.substr(1, tok.find('=')-1), 
                                         is_style_active(allow_guessing),
                                         is_style_active(long_case_insensitive),
                                         is_style_active(short_case_insensitive)))
                {
                    args[0].insert(0, "-");
                    if (args[0][1] == '/')
                        args[0][1] = '-';
                    return parse_long_option(args);
                }
            } 
            catch(error_with_option_name& e)
            {
                // add context and rethrow
                e.add_context(tok, tok, get_canonical_option_prefix());
                throw;
            }
        }
        return vector<option>();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
movq (%rdx), %rbx
cmpq $0x2, 0x8(%rbx)
jb 0xdc08
movq %rdx, %r12
movq %rsi, %r14
movq (%rbx), %rcx
movb (%rcx), %al
cmpb $0x2d, %al
jne 0xdb61
cmpb $0x2d, 0x1(%rcx)
jne 0xdb76
cmpb $0x2f, %al
jne 0xdc08
movl 0x18(%r14), %eax
andl $0x8, %eax
je 0xdc08
movq 0x20(%r14), %r13
pushq $0x3d
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xc610
leaq -0x1(%rax), %rcx
leaq -0x48(%rbp), %rdi
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0xc4f0
movl 0x18(%r14), %r8d
movl %r8d, %edx
shrl $0x9, %edx
andl $0x1, %edx
movl %r8d, %ecx
shrl $0xa, %ecx
andl $0x1, %ecx
shrl $0xb, %r8d
andl $0x1, %r8d
leaq -0x48(%rbp), %rsi
movq %r13, %rdi
callq 0x152bc
movq %rax, %r13
leaq -0x48(%rbp), %rdi
callq 0xc9a0
testq %r13, %r13
je 0xdc08
movq (%r12), %rdi
leaq 0x1f7a7(%rip), %rdx     # 0x2d387
xorl %esi, %esi
callq 0xc0f0
movq (%r12), %rax
movq (%rax), %rax
cmpb $0x2f, 0x1(%rax)
jne 0xdbf8
movb $0x2d, 0x1(%rax)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xd8da
jmp 0xdc14
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
andq $0x0, 0x10(%r15)
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r12
movq %rax, %r15
leaq -0x48(%rbp), %rdi
callq 0xc9a0
jmp 0xdc3f
jmp 0xdc39
movq %rdx, %r12
movq %rax, %r15
cmpl $0x1, %r12d
jne 0xdc75
movq %r15, %rdi
callq 0xc1d0
movq %rax, %r15
movq %r14, %rdi
callq 0xcf48
movq %r15, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movl %eax, %ecx
callq 0xeb64
callq 0xc700
movq %rax, %r15
callq 0xc7e0
movq %r15, %rdi
callq 0xc850
movq %rax, %rdi
callq 0xeb96
nop