LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/net/protocols/http.cpp
// Function: smooth::Net::Protocols::HTTP::GetParametersURLEncoded() const
S::String S::Net::Protocols::HTTP::GetParametersURLEncoded() const
{
	String	 str;

	for (Int i = 0; i < requestParameters.Length(); i++)
	{
		const Parameter	&parameter = requestParameters.GetNth(i);

		if (i > 0) str.Append("&");

		str.Append(parameter.key).Append("=").Append(parameter.value);
	}

	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x0, -0x11(%rbp)
xorl %esi, %esi
callq 0x5da90
movl $0x0, -0x18(%rbp)
movq -0x68(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x80(%rbp)
addq $0x178, %rdi            # imm = 0x178
callq 0x5c990
movl %eax, -0x7c(%rbp)
jmp 0x103d93
movl -0x80(%rbp), %eax
movl -0x7c(%rbp), %ecx
cmpl %ecx, %eax
jge 0x103eaa
movq -0x68(%rbp), %rdi
addq $0x178, %rdi            # imm = 0x178
movl -0x18(%rbp), %esi
callq 0x104960
movq %rax, -0x88(%rbp)
jmp 0x103dbd
movq -0x88(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x103e25
leaq 0xa1ee5(%rip), %rsi     # 0x1a5cba
leaq -0x48(%rbp), %rdi
callq 0x5c1f0
jmp 0x103de0
movq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x5a710
jmp 0x103def
leaq -0x48(%rbp), %rdi
callq 0x5df00
jmp 0x103e25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x103eca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5df00
jmp 0x103eca
movq -0x78(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x5a710
movq %rax, -0x90(%rbp)
jmp 0x103e3b
leaq 0xa1deb(%rip), %rsi     # 0x1a5c2d
leaq -0x60(%rbp), %rdi
callq 0x5c1f0
jmp 0x103e4d
movq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x5a710
movq %rax, -0x98(%rbp)
jmp 0x103e66
movq -0x98(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x18, %rsi
callq 0x5a710
jmp 0x103e7c
leaq -0x60(%rbp), %rdi
callq 0x5df00
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x103d78
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5df00
jmp 0x103eca
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x103ebd
movq -0x78(%rbp), %rdi
callq 0x5df00
movq -0x70(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x5df00
movq -0x20(%rbp), %rdi
callq 0x5b6b0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/net/protocols/http.cpp
// Function: smooth::Net::Protocols::httpWrite(char*, unsigned long, unsigned long, void*)
size_t S::Net::Protocols::httpWrite(char *buffer, size_t size, size_t n, void *data)
{
	HTTP	*http = (HTTP *) data;

	/* Cancel download if requested.
	 */
	if (http->doCancelDownload.Call()) return 0;

	/* Write data to output file.
	 */
	http->out->OutputData(buffer, size * n);

	return size * n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0xa0, %rdi
callq 0x1049c0
testb $0x1, %al
jne 0x104416
jmp 0x104420
movq $0x0, -0x8(%rbp)
jmp 0x10444c
movq -0x30(%rbp), %rax
movq 0x258(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
imulq -0x20(%rbp), %rax
movl %eax, %edx
callq 0x59d70
movq -0x18(%rbp), %rax
imulq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/net/protocols/protocol.cpp
// Function: smooth::Net::Protocols::Protocol::RemoveAllProtocols()
S::Int S::Net::Protocols::Protocol::RemoveAllProtocols()
{
	protocol_creators->RemoveAll();
	protocol_magics->RemoveAll();

	delete protocol_creators;
	delete protocol_magics;

	return Success();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x103501(%rip), %rax    # 0x208bf0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x102f11(%rip), %rax    # 0x208610
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x1034e1(%rip), %rax    # 0x208bf0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x105726
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x102ee3(%rip), %rax    # 0x208610
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x105744
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x5ca80
movq -0x40(%rbp), %rdi
callq 0x59680
movl %eax, -0x34(%rbp)
jmp 0x10575f
leaq -0x10(%rbp), %rdi
callq 0x5a410
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x5a410
movq -0x18(%rbp), %rdi
callq 0x5b6b0
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/net/protocols/protocol.cpp
// Function: smooth::Net::Protocols::Protocol::AddProtocol(smooth::Net::Protocols::Protocol* (*)(smooth::String const&), smooth::String const&)
S::Int S::Net::Protocols::Protocol::AddProtocol(Protocol *(*protocol)(const String &), const String &magic)
{
	if (protocol == NIL) return Error();

	if (protocol_creators == NIL)	protocol_creators = new Array<Protocol *(*)(const String &), Void *>;
	if (protocol_magics == NIL)	protocol_magics = new Array<String>;

	protocol_creators->Add(protocol);
	protocol_magics->Add(magic);

	return Success();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1057f8
leaq -0x28(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5a9c0
movq -0x58(%rbp), %rdi
callq 0x59680
movl %eax, -0x4c(%rbp)
jmp 0x1057ca
movl -0x4c(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5b5b0
jmp 0x10590c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5b5b0
jmp 0x105918
movq 0x1033f1(%rip), %rax    # 0x208bf0
cmpq $0x0, (%rax)
jne 0x10584f
movl $0x58, %edi
callq 0x59820
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x1060c0
jmp 0x105820
movq -0x60(%rbp), %rcx
movq 0x1033c5(%rip), %rax    # 0x208bf0
movq %rcx, (%rax)
jmp 0x10584f
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x58, %esi
callq 0x595b0
jmp 0x105918
movq 0x102dba(%rip), %rax    # 0x208610
cmpq $0x0, (%rax)
jne 0x1058a3
movl $0x58, %edi
callq 0x59820
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
callq 0x74650
jmp 0x105877
movq -0x68(%rbp), %rcx
movq 0x102d8e(%rip), %rax    # 0x208610
movq %rcx, (%rax)
jmp 0x1058a3
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x58, %esi
callq 0x595b0
jmp 0x105918
movq 0x103346(%rip), %rax    # 0x208bf0
movq (%rax), %rdi
leaq -0x10(%rbp), %rsi
callq 0x106100
movq 0x102d53(%rip), %rax    # 0x208610
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x74750
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x5ca80
movq -0x78(%rbp), %rdi
callq 0x59680
movl %eax, -0x6c(%rbp)
jmp 0x1058e4
movl -0x6c(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5a410
jmp 0x10590c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5a410
jmp 0x105918
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x5b6b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/system/console.cpp
// Function: smooth::System::Console::OutputString(smooth::String const&)
S::Int S::System::Console::OutputString(const String &string)
{
#if defined __WIN32__
	String::OutputFormat	 format("UTF-8");
#endif

	printf("%s", (char *) string);
	fflush(stdout);

	return Success();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d090
movq %rax, %rsi
leaq 0xa1980(%rip), %rdi     # 0x1a7c2f
xorl %eax, %eax
callq 0x592c0
movq 0x10254b(%rip), %rax    # 0x208808
movq (%rax), %rdi
callq 0x5ace0
leaq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x5ca80
movq -0x30(%rbp), %rdi
callq 0x59680
movl %eax, -0x28(%rbp)
jmp 0x1062e0
leaq -0x18(%rbp), %rdi
callq 0x5a410
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x5a410
movq -0x20(%rbp), %rdi
callq 0x5b6b0
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/system/cpu.cpp
// Function: smooth::System::CPU::GetEndianness() const
S::System::Endianness S::System::CPU::GetEndianness() const
{
	UnsignedInt32	 value;
	UnsignedInt8	*buffer = (UnsignedInt8 *) &value;

	buffer[0] = 0x00;
	buffer[1] = 0x01;
	buffer[2] = 0x02;
	buffer[3] = 0x03;

	if	(value == 0x00010203) return EndianBig;
	else if (value == 0x03020100) return EndianLittle;

	return EndianUnknown;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
leaq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
movb $0x1, 0x1(%rax)
movq -0x20(%rbp), %rax
movb $0x2, 0x2(%rax)
movq -0x20(%rbp), %rax
movb $0x3, 0x3(%rax)
cmpl $0x10203, -0x14(%rbp)   # imm = 0x10203
jne 0x1068b1
movl $0x1, -0x4(%rbp)
jmp 0x1068cc
cmpl $0x3020100, -0x14(%rbp) # imm = 0x3020100
jne 0x1068c3
movl $0x2, -0x4(%rbp)
jmp 0x1068cc
jmp 0x1068c5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/system/event.cpp
// Function: smooth::System::EventProcessor::ProcessNextEvent()
S::Bool S::System::EventProcessor::ProcessNextEvent()
{
	Int	 suspendCount = GUI::Application::Lock::SuspendLock();
	Bool	 result	      = backend->ProcessNextEvent();

	GUI::Application::Lock::ResumeLock(suspendCount);

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x5dd60
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0xc(%rbp)
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
andb $0x1, %al
movb %al, -0xd(%rbp)
movl -0xc(%rbp), %edi
callq 0x5bc30
movb -0xd(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/system/system.cpp
// Function: smooth::System::System::Sleep(unsigned int)
S::Bool S::System::System::Sleep(UnsignedInt mSeconds)
{
#ifdef __WIN32__
	::Sleep(mSeconds);
#else
	timespec	 req;
	timespec	 rem;

	req.tv_sec  = mSeconds / 1000;
	req.tv_nsec = (mSeconds % 1000) * 1000000;

	while (nanosleep(&req, &rem) == -1)
	{
		if (errno != EINTR) break;

		req.tv_sec  = rem.tv_sec;
		req.tv_nsec = rem.tv_nsec;
	}
#endif

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
movl %eax, %eax
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
imull $0xf4240, %edx, %eax    # imm = 0xF4240
movl %eax, %eax
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5d2b0
cmpl $-0x1, %eax
jne 0x1092b5
callq 0x5cf30
cmpl $0x4, (%rax)
je 0x1092a3
jmp 0x1092b5
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x109285
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/system/system.cpp
// Function: smooth::System::System::GetWindowsRootDirectory()
S::String S::System::System::GetWindowsRootDirectory()
{
	static String	 windowsDir;

	if (windowsDir != NIL) return windowsDir;

#ifdef __WIN32__
	Buffer<wchar_t>	 buffer(32768 + 1);

	GetWindowsDirectory(buffer, buffer.Size());

	windowsDir = buffer;
#endif

	if (!windowsDir.EndsWith(Directory::GetDirectoryDelimiter())) windowsDir.Append(Directory::GetDirectoryDelimiter());
	if ( windowsDir == Directory::GetDirectoryDelimiter())	      windowsDir = NIL;

	return windowsDir;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
cmpb $0x0, 0x10a5ef(%rip)    # 0x213c80
jne 0x1096da
leaq 0x10a5e6(%rip), %rdi    # 0x213c80
callq 0x5a4e0
cmpl $0x0, %eax
je 0x1096da
leaq 0x10a5bd(%rip), %rdi    # 0x213c68
xorl %esi, %esi
callq 0x5da90
jmp 0x1096b4
movq 0xff86d(%rip), %rdi     # 0x208f28
leaq 0x10a5a6(%rip), %rsi    # 0x213c68
leaq 0x102037(%rip), %rdx    # 0x20b700
callq 0x5c700
leaq 0x10a5ab(%rip), %rdi    # 0x213c80
callq 0x5b0c0
leaq 0x10a587(%rip), %rdi    # 0x213c68
xorl %esi, %esi
callq 0x5b110
testb $0x1, %al
jne 0x1096ee
jmp 0x109720
movq -0x58(%rbp), %rdi
leaq 0x10a56f(%rip), %rsi    # 0x213c68
callq 0x5b6d0
jmp 0x1097fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq 0x10a56a(%rip), %rdi    # 0x213c80
callq 0x5a860
jmp 0x109809
callq 0x59460
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x5c1f0
movq -0x68(%rbp), %rsi
leaq 0x10a528(%rip), %rdi    # 0x213c68
callq 0x5d6c0
movb %al, -0x59(%rbp)
jmp 0x10974a
movb -0x59(%rbp), %al
xorb $-0x1, %al
movb %al, -0x69(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5df00
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x109764
jmp 0x1097c4
callq 0x59460
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x5c1f0
movq -0x78(%rbp), %rsi
leaq 0x10a4e4(%rip), %rdi    # 0x213c68
callq 0x5a710
jmp 0x10978b
leaq -0x48(%rbp), %rdi
callq 0x5df00
jmp 0x1097c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5df00
jmp 0x109809
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5df00
jmp 0x109809
callq 0x59460
movq %rax, %rsi
leaq 0x10a495(%rip), %rdi    # 0x213c68
callq 0x5c7f0
testb $0x1, %al
jne 0x1097de
jmp 0x1097ec
leaq 0x10a483(%rip), %rdi    # 0x213c68
xorl %esi, %esi
callq 0x5c1e0
movq -0x58(%rbp), %rdi
leaq 0x10a471(%rip), %rsi    # 0x213c68
callq 0x5b6d0
movq -0x50(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x5b6b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/system/timer.cpp
// Function: smooth::System::Timer::Timer()
S::System::Timer::Timer()
{
	backend = TimerBackend::CreateBackendInstance(this);

	type = classID;

	interval = 0;
	status = TIMER_STOPPED;

	onInterval.SetParentObject(this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x5b420
movq -0x28(%rbp), %rdi
movq 0xfd8ec(%rip), %rax     # 0x208c80
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x48, %rdi
movq %rdi, -0x20(%rbp)
callq 0x8aae0
jmp 0x10b3aa
movq -0x28(%rbp), %rdi
callq 0x10bc30
movq %rax, -0x30(%rbp)
jmp 0x10b3b9
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, 0x38(%rdi)
movq 0xfd4cc(%rip), %rax     # 0x208898
movswl (%rax), %esi
addq $0x20, %rdi
callq 0x5a2e0
jmp 0x10b3da
movq -0x28(%rbp), %rsi
movl $0x0, 0x40(%rsi)
movw $0x0, 0x44(%rsi)
movq %rsi, %rdi
addq $0x48, %rdi
callq 0x8ad00
jmp 0x10b3f9
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x10b422
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x8ad70
movq -0x28(%rbp), %rdi
callq 0x59ec0
movq -0x10(%rbp), %rdi
callq 0x5b6b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/system/timer.cpp
// Function: smooth::System::Timer::Start(int)
S::Int S::System::Timer::Start(Int iInterval)
{
	if (status == TIMER_RUNNING) return Error();

	interval = iInterval;
	status = TIMER_RUNNING;

	return backend->Start(interval);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movswl 0x44(%rax), %eax
cmpl $0x1, %eax
jne 0x10b5d8
leaq -0x28(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5a9c0
movq -0x50(%rbp), %rdi
callq 0x59680
movl %eax, -0x44(%rbp)
jmp 0x10b5b0
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5b5b0
jmp 0x10b5f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5b5b0
jmp 0x10b601
movq -0x40(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x40(%rax)
movw $0x1, 0x44(%rax)
movq 0x38(%rax), %rdi
movl 0x40(%rax), %esi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x5b6b0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/threads/access.cpp
// Function: smooth::Threads::Access::Value(bool volatile&)
S::Bool S::Threads::Access::Value(volatile Bool &value)
{
	if (mutex != NIL) mutex->Lock();

	Bool	 result = value;

	if (mutex != NIL) mutex->Release();

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xfc8bd(%rip), %rax     # 0x2087b0
cmpq $0x0, (%rax)
je 0x10bf08
movq 0xfc8b0(%rip), %rax     # 0x2087b0
movq (%rax), %rdi
callq 0x59a60
movq -0x8(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movq 0xfc896(%rip), %rax     # 0x2087b0
cmpq $0x0, (%rax)
je 0x10bf2f
movq 0xfc889(%rip), %rax     # 0x2087b0
movq (%rax), %rdi
callq 0x5caf0
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/threads/access.cpp
// Function: smooth::Threads::Access::Set(bool volatile&, bool)
S::Bool S::Threads::Access::Set(volatile Bool &value, Bool n)
{
	mutex->Lock();

	Bool	 result = value = n;

	mutex->Release();

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq 0xfc855(%rip), %rax     # 0x2087b0
movq (%rax), %rdi
callq 0x59a60
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movb (%rax), %al
andb $0x1, %al
movb %al, -0xa(%rbp)
movq 0xfc833(%rip), %rax     # 0x2087b0
movq (%rax), %rdi
callq 0x5caf0
movb -0xa(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/threads/access.cpp
// Function: smooth::Threads::Access::Value(short volatile&)
S::Short S::Threads::Access::Value(volatile Short &value)
{
	if (mutex != NIL) mutex->Lock();

	Short	 result = value;

	if (mutex != NIL) mutex->Release();

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xfc80d(%rip), %rax     # 0x2087b0
cmpq $0x0, (%rax)
je 0x10bfb8
movq 0xfc800(%rip), %rax     # 0x2087b0
movq (%rax), %rdi
callq 0x59a60
movq -0x8(%rbp), %rax
movw (%rax), %ax
movw %ax, -0xa(%rbp)
movq 0xfc7e6(%rip), %rax     # 0x2087b0
cmpq $0x0, (%rax)
je 0x10bfdf
movq 0xfc7d9(%rip), %rax     # 0x2087b0
movq (%rax), %rdi
callq 0x5caf0
movw -0xa(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/threads/access.cpp
// Function: smooth::Threads::Access::Increment(short volatile&)
S::Short S::Threads::Access::Increment(volatile Short &value)
{
	mutex->Lock();

	Short	 result = ++value;

	mutex->Release();

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xfc7ad(%rip), %rax     # 0x2087b0
movq (%rax), %rdi
callq 0x59a60
movq -0x8(%rbp), %rcx
movw (%rcx), %ax
addw $0x1, %ax
movw %ax, (%rcx)
movw %ax, -0xa(%rbp)
movq 0xfc78c(%rip), %rax     # 0x2087b0
movq (%rax), %rdi
callq 0x5caf0
movw -0xa(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/threads/access.cpp
// Function: smooth::Threads::Access::Decrement(short volatile&)
S::Short S::Threads::Access::Decrement(volatile Short &value)
{
	mutex->Lock();

	Short	 result = --value;

	mutex->Release();

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xfc75d(%rip), %rax     # 0x2087b0
movq (%rax), %rdi
callq 0x59a60
movq -0x8(%rbp), %rcx
movw (%rcx), %ax
addw $-0x1, %ax
movw %ax, (%rcx)
movw %ax, -0xa(%rbp)
movq 0xfc73c(%rip), %rax     # 0x2087b0
movq (%rax), %rdi
callq 0x5caf0
movw -0xa(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/threads/access.cpp
// Function: smooth::Threads::Access::Set(short volatile&, short)
S::Short S::Threads::Access::Set(volatile Short &value, Short n)
{
	mutex->Lock();

	Short	 result = value = n;

	mutex->Release();

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq 0xfc706(%rip), %rax     # 0x2087b0
movq (%rax), %rdi
callq 0x59a60
movw -0xa(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, (%rax)
movw (%rax), %ax
movw %ax, -0xc(%rbp)
movq 0xfc6e5(%rip), %rax     # 0x2087b0
movq (%rax), %rdi
callq 0x5caf0
movw -0xc(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/threads/access.cpp
// Function: smooth::Threads::Access::Value(int volatile&)
S::Int S::Threads::Access::Value(volatile Int &value)
{
	mutex->Lock();

	Int	 result = value;

	mutex->Release();

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xfc6bd(%rip), %rax     # 0x2087b0
movq (%rax), %rdi
callq 0x59a60
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq 0xfc6a5(%rip), %rax     # 0x2087b0
movq (%rax), %rdi
callq 0x5caf0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/threads/access.cpp
// Function: smooth::Threads::Access::Increment(int volatile&)
S::Int S::Threads::Access::Increment(volatile Int &value)
{
	mutex->Lock();

	Int	 result = ++value;

	mutex->Release();

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xfc67d(%rip), %rax     # 0x2087b0
movq (%rax), %rdi
callq 0x59a60
movq -0x8(%rbp), %rcx
movl (%rcx), %eax
addl $0x1, %eax
movl %eax, (%rcx)
movl %eax, -0xc(%rbp)
movq 0xfc660(%rip), %rax     # 0x2087b0
movq (%rax), %rdi
callq 0x5caf0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/threads/access.cpp
// Function: smooth::Threads::Access::Decrement(int volatile&)
S::Int S::Threads::Access::Decrement(volatile Int &value)
{
	mutex->Lock();

	Int	 result = --value;

	mutex->Release();

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xfc62d(%rip), %rax     # 0x2087b0
movq (%rax), %rdi
callq 0x59a60
movq -0x8(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
movl %eax, -0xc(%rbp)
movq 0xfc610(%rip), %rax     # 0x2087b0
movq (%rax), %rdi
callq 0x5caf0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/threads/access.cpp
// Function: smooth::Threads::Access::Set(int volatile&, int)
S::Int S::Threads::Access::Set(volatile Int &value, Int n)
{
	mutex->Lock();

	Int	 result = value = n;

	mutex->Release();

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0xfc5da(%rip), %rax     # 0x2087b0
movq (%rax), %rdi
callq 0x59a60
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movq 0xfc5bd(%rip), %rax     # 0x2087b0
movq (%rax), %rdi
callq 0x5caf0
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/threads/rwlock.cpp
// Function: smooth::Threads::RWLock::RWLock()
S::Threads::RWLock::RWLock()
{
	readLocked  = 0;
	writeLocked = 0;

	exclusiveAccessMutex = new Mutex();
	sharedAccessMutex    = new Mutex();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
movl $0x8, %edi
callq 0x59820
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x59a30
jmp 0x10c410
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x8, %edi
callq 0x59820
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x59a30
jmp 0x10c43b
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x8, %esi
callq 0x595b0
jmp 0x10c483
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x8, %esi
callq 0x595b0
movq -0x10(%rbp), %rdi
callq 0x5b6b0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/threads/rwlock.cpp
// Function: smooth::Threads::RWLock::operator=(smooth::Threads::RWLock const&)
S::Threads::RWLock &S::Threads::RWLock::operator =(const RWLock &oRWLock)
{
	if (&oRWLock == this) return *this;

	readLocked  = 0;
	writeLocked = 0;

	exclusiveAccessMutex = new Mutex();
	sharedAccessMutex    = new Mutex();

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq %rax, -0x18(%rbp)
jne 0x10c4eb
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10c590
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
movl $0x8, %edi
callq 0x59820
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x59a30
jmp 0x10c51b
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x8, %edi
callq 0x59820
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x59a30
jmp 0x10c546
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq %rax, -0x8(%rbp)
jmp 0x10c590
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x8, %esi
callq 0x595b0
jmp 0x10c59a
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x8, %esi
callq 0x595b0
jmp 0x10c59a
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5b6b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/threads/rwlock.cpp
// Function: smooth::Threads::RWLock::LockForRead()
S::Bool S::Threads::RWLock::LockForRead()
{
	/* Acquire exclusive lock.
	 */
	exclusiveAccessMutex->Lock();

	/* Increase read lock counter by one.
	 */
	sharedAccessMutex->Lock();

	readLocked++;

	sharedAccessMutex->Release();

	/* Allow other read and write locks.
	 */
	exclusiveAccessMutex->Release();

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x8(%rax), %rdi
callq 0x59a60
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x59a60
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0x10(%rax), %rdi
callq 0x5caf0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5caf0
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/threads/rwlock.cpp
// Function: smooth::Threads::RWLock::LockForWrite()
S::Bool S::Threads::RWLock::LockForWrite()
{
	/* Acquire exclusive lock.
	 */
	exclusiveAccessMutex->Lock();

	/* Wait for read operations to finish.
	 */
	sharedAccessMutex->Lock();

	while (readLocked)
	{
		sharedAccessMutex->Release();
		exclusiveAccessMutex->Release();

		S::System::System::Sleep(0);

		exclusiveAccessMutex->Lock();
		sharedAccessMutex->Lock();
	}

	/* Increase write lock counter.
	 */
	writeLocked++;

	sharedAccessMutex->Release();

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x8(%rax), %rdi
callq 0x59a60
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x59a60
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl $0x0, %eax
je 0x10c6f2
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5caf0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5caf0
xorl %edi, %edi
callq 0x5c090
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x59a60
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x59a60
jmp 0x10c6aa
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq 0x10(%rax), %rdi
callq 0x5caf0
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/threads/rwlock.cpp
// Function: smooth::Threads::RWLock::Release()
S::Bool S::Threads::RWLock::Release()
{
	/* Check if we are locked for write.
	 */
	sharedAccessMutex->Lock();

	if (writeLocked && !readLocked)
	{
		/* Decrease write lock counter.
		 */
		writeLocked--;

		sharedAccessMutex->Release();

		/* Allow new read and write locks again.
		 */
		exclusiveAccessMutex->Release();

		return True;
	}

	/* Decrease read lock counter by one.
	 */
	readLocked--;

	sharedAccessMutex->Release();

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x10(%rax), %rdi
callq 0x59a60
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
cmpl $0x0, %eax
je 0x10c77d
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl $0x0, %eax
jne 0x10c77d
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq 0x10(%rax), %rdi
callq 0x5caf0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5caf0
movb $0x1, -0x1(%rbp)
jmp 0x10c795
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq 0x10(%rax), %rdi
callq 0x5caf0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/threads/semaphore.cpp
// Function: smooth::Threads::Semaphore::operator=(smooth::Threads::Semaphore const&)
S::Threads::Semaphore &S::Threads::Semaphore::operator =(const Semaphore &oSemaphore)
{
	if (&oSemaphore == this) return *this;

	backend = SemaphoreBackend::CreateBackendInstance(oSemaphore.max, NIL);

	max = oSemaphore.max;

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq %rax, -0x18(%rbp)
jne 0x10c838
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10c860
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x10da70
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/threads/thread.cpp
// Function: smooth::Threads::Thread::operator=(smooth::Threads::Thread const&)
S::Threads::Thread &S::Threads::Thread::operator =(const Thread &oThread)
{
	if (&oThread == this) return *this;

	backend = ThreadBackend::CreateBackendInstance(NIL);

	type	= classID;
	status	= THREAD_CREATED;

	threadMain = oThread.threadMain;

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq %rax, -0x18(%rbp)
jne 0x10cae8
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10cb32
xorl %eax, %eax
movl %eax, %edi
callq 0x10dc90
movq -0x20(%rbp), %rdi
movq %rax, 0x38(%rdi)
movq 0xfbf10(%rip), %rax     # 0x208a10
movw (%rax), %ax
addq $0x20, %rdi
movswl %ax, %esi
callq 0x5a2e0
movq -0x20(%rbp), %rdi
movw $0x0, 0x34(%rdi)
movq -0x18(%rbp), %rsi
addq $0x40, %rsi
addq $0x40, %rdi
callq 0x10d0a0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/threads/thread.cpp
// Function: smooth::Threads::Thread::~Thread()
S::Threads::Thread::~Thread()
{
	if (status == THREAD_CREATED || status == THREAD_STARTME)
	{
		status = THREAD_STOPPED;
	}

	if (status != THREAD_STOPPED)
	{
		status = THREAD_STOPPED;

		Access::Decrement(nOfRunningThreads);

		backend->Stop();
	}

	delete backend;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0xfbf1d(%rip), %rcx     # 0x208a78
addq $0x10, %rcx
movq %rcx, (%rax)
movswl 0x34(%rax), %eax
cmpl $0x0, %eax
je 0x10cb78
movq -0x10(%rbp), %rax
movswl 0x34(%rax), %eax
cmpl $0x3, %eax
jne 0x10cb82
movq -0x10(%rbp), %rax
movw $0x2, 0x34(%rax)
movq -0x10(%rbp), %rax
movswl 0x34(%rax), %eax
cmpl $0x2, %eax
je 0x10cbbc
movq -0x10(%rbp), %rax
movw $0x2, 0x34(%rax)
movq 0xfbad0(%rip), %rdi     # 0x208670
callq 0x5a920
jmp 0x10cba7
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
jmp 0x10cbba
jmp 0x10cbbc
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x10cbd8
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x10d080
movq -0x10(%rbp), %rdi
callq 0x59ec0
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x61c50
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/threads/thread.cpp
// Function: smooth::Threads::Thread::Start()
S::Int S::Threads::Thread::Start()
{
	if ((status == THREAD_CREATED || status == THREAD_STARTME) && !initializing)
	{
		Access::Increment(nOfRunningThreads);

		status = THREAD_RUNNING;

		backend->Start((Void (*)(Void *)) MainCaller, this);

		return Success();
	}
	else if (status == THREAD_CREATED && initializing)
	{
		status = THREAD_STARTME;

		return Success();
	}

	return Error();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movswl 0x34(%rax), %eax
cmpl $0x0, %eax
je 0x10cd0d
movq -0x58(%rbp), %rax
movswl 0x34(%rax), %eax
cmpl $0x3, %eax
jne 0x10cd8c
leaq 0xfef14(%rip), %rax     # 0x20bc28
testb $0x1, (%rax)
jne 0x10cd8c
movq 0xfb950(%rip), %rdi     # 0x208670
callq 0x5a260
movq -0x58(%rbp), %rdx
movw $0x1, 0x34(%rdx)
movq 0x38(%rdx), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq 0xfc1ff(%rip), %rsi     # 0x208f40
callq *%rax
leaq -0x20(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x5ca80
movq -0x68(%rbp), %rdi
callq 0x59680
movl %eax, -0x5c(%rbp)
jmp 0x10cd5e
movl -0x5c(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5a410
jmp 0x10ce42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5a410
jmp 0x10ce4e
movq -0x58(%rbp), %rax
movswl 0x34(%rax), %eax
cmpl $0x0, %eax
jne 0x10cdf2
leaq 0xfee88(%rip), %rax     # 0x20bc28
testb $0x1, (%rax)
je 0x10cdf2
movq -0x58(%rbp), %rax
movw $0x3, 0x34(%rax)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x5ca80
movq -0x78(%rbp), %rdi
callq 0x59680
movl %eax, -0x6c(%rbp)
jmp 0x10cdca
movl -0x6c(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5a410
jmp 0x10ce42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5a410
jmp 0x10ce4e
jmp 0x10cdf4
leaq -0x50(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5a9c0
movq -0x88(%rbp), %rdi
callq 0x59680
movl %eax, -0x7c(%rbp)
jmp 0x10ce1a
movl -0x7c(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5b5b0
jmp 0x10ce42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5b5b0
jmp 0x10ce4e
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5b6b0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/threads/thread.cpp
// Function: smooth::Threads::Thread::MainCaller(smooth::Threads::Thread*)
S::Void S::Threads::Thread::MainCaller(Thread *thread)
{
	/* Set thread ID and call thread callback.
	 */
	threadID = thread->GetHandle();

	thread->threadMain.Call(thread);

	/* Clean up and exit thread.
	 */
	String::DeleteTemporaryBuffers(True);

	thread->status = THREAD_STOPPED;

	Access::Decrement(nOfRunningThreads);

	thread->backend->Exit();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d050
cltq
movq %rax, -0x10(%rbp)
leaq 0xfb47e(%rip), %rdi     # 0x208300
callq 0x5abb0
movq -0x10(%rbp), %rcx
leaq 0x28(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
movq -0x8(%rbp), %rsi
callq 0x10d0e0
movl $0x1, %edi
callq 0x5cec0
movq -0x8(%rbp), %rax
movw $0x2, 0x34(%rax)
movq 0xfb7af(%rip), %rdi     # 0x208670
callq 0x5a920
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/threads/thread.cpp
// Function: smooth::Threads::Thread::Stop()
S::Int S::Threads::Thread::Stop()
{
	if (backend->Stop() == Success())
	{
		status = THREAD_STOPPED;

		Access::Decrement(nOfRunningThreads);

		return Success();
	}

	return Error();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq 0x38(%rax), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movl %eax, -0x64(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x5ca80
movq -0x60(%rbp), %rdi
callq 0x59680
movl %eax, -0x54(%rbp)
jmp 0x10cf22
leaq -0x20(%rbp), %rdi
callq 0x5a410
movl -0x54(%rbp), %ecx
movl -0x64(%rbp), %eax
cmpl %ecx, %eax
jne 0x10cfa8
movq -0x70(%rbp), %rax
movw $0x2, 0x34(%rax)
movq 0xfb72a(%rip), %rdi     # 0x208670
callq 0x5a920
leaq -0x40(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x5ca80
movq -0x80(%rbp), %rdi
callq 0x59680
movl %eax, -0x74(%rbp)
jmp 0x10cf66
movl -0x74(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5a410
jmp 0x10cffc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5a410
jmp 0x10d008
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5a410
jmp 0x10d008
leaq -0x50(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5a9c0
movq -0x90(%rbp), %rdi
callq 0x59680
movl %eax, -0x84(%rbp)
jmp 0x10cfd1
movl -0x84(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5b5b0
jmp 0x10cffc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5b5b0
jmp 0x10d008
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5b6b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/xml/attribute.cpp
// Function: smooth::XML::Attribute::Attribute(smooth::String const&, smooth::String const&)
S::XML::Attribute::Attribute(const String &iName, const String &iContent)
{
	attributeID	= -1;

	nameIndex	= iName.ComputeCRC32();
	content		= iContent;

	if (attributeNames.Get(nameIndex) == NIL) attributeNames.Add(iName, nameIndex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
callq 0x5da90
movq -0x30(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
callq 0x597b0
movl %eax, -0x28(%rbp)
jmp 0x10dec3
movq -0x30(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, 0x4(%rdi)
movq -0x18(%rbp), %rsi
addq $0x8, %rdi
callq 0x59760
jmp 0x10dedc
movq -0x30(%rbp), %rax
movl 0x4(%rax), %esi
movq 0xfa80e(%rip), %rdi     # 0x2086f8
callq 0xde7c0
movq %rax, -0x40(%rbp)
jmp 0x10def5
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x59320
movb %al, -0x41(%rbp)
jmp 0x10df05
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x10df0e
jmp 0x10df40
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rsi
movl 0x4(%rax), %edx
movq 0xfa7d8(%rip), %rdi     # 0x2086f8
callq 0xde810
jmp 0x10df27
jmp 0x10df40
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5df00
jmp 0x10df46
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5b6b0
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/xml/document.cpp
// Function: smooth::XML::Document::SaveFile(smooth::String const&)
S::Int S::XML::Document::SaveFile(const String &fileName)
{
	xmlTextWriterPtr	 writer = xmlNewTextWriterFilename(fileName.ConvertTo("UTF-8"), 0);

	xmlTextWriterSetIndent(writer, 1);
	xmlTextWriterStartDocument(writer, "1.0", encoding, NIL);

	if (rootNode != NIL) SaveNode(writer, rootNode);

	xmlTextWriterEndDocument(writer);
	xmlFreeTextWriter(writer);

	return Success();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x96c53(%rip), %rsi     # 0x1a5be6
callq 0x5c120
movq %rax, %rdi
xorl %esi, %esi
callq 0x59410
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x5da00
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x5d090
movq -0x48(%rbp), %rdi
movq %rax, %rdx
leaq 0x9737b(%rip), %rsi     # 0x1a634e
xorl %eax, %eax
movl %eax, %ecx
callq 0x5c640
movq -0x40(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x10eff8
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x18(%rdi), %rdx
callq 0x5c1a0
movq -0x18(%rbp), %rdi
callq 0x597e0
movq -0x18(%rbp), %rdi
callq 0x59800
leaq -0x28(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x5ca80
movq -0x58(%rbp), %rdi
callq 0x59680
movl %eax, -0x4c(%rbp)
jmp 0x10f025
leaq -0x28(%rbp), %rdi
callq 0x5a410
movl -0x4c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5a410
movq -0x30(%rbp), %rdi
callq 0x5b6b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/xml/document.cpp
// Function: smooth::XML::Document::SaveNode(_xmlTextWriter*, smooth::XML::Node*)
S::Int S::XML::Document::SaveNode(xmlTextWriterPtr writer, Node *node)
{
	xmlTextWriterStartElement(writer, (xmlChar *) node->GetName().ConvertTo("UTF-8"));

	for (Int i = 0; i < node->GetNOfAttributes(); i++) xmlTextWriterWriteAttribute(writer, (xmlChar *) node->GetNthAttribute(i)->GetName().ConvertTo("UTF-8"), (xmlChar *) node->GetNthAttribute(i)->GetContent().ConvertTo("UTF-8"));

	xmlTextWriterWriteString(writer, (xmlChar *) node->GetContent().ConvertTo("UTF-8"));

	for (Int i = 0; i < node->GetNOfNodes(); i++) SaveNode(writer, node->GetNthNode(i));

	xmlTextWriterEndElement(writer);

	return Success();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5c630
movq %rax, %rdi
leaq 0x96b4c(%rip), %rsi     # 0x1a5be6
callq 0x5c120
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x5b450
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x18(%rbp), %rdi
callq 0x59630
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jge 0x10f13a
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x5c740
movq %rax, %rdi
callq 0x5d730
movq %rax, %rdi
leaq 0x96af6(%rip), %rsi     # 0x1a5be6
callq 0x5c120
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x5c740
movq %rax, %rdi
callq 0x598c0
movq %rax, %rdi
leaq 0x96acf(%rip), %rsi     # 0x1a5be6
callq 0x5c120
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rdx
callq 0x5c8e0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x10f0b2
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5da60
movq %rax, %rdi
leaq 0x96a91(%rip), %rsi     # 0x1a5be6
callq 0x5c120
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x5ba40
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x74(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5a380
movl %eax, %ecx
movl -0x74(%rbp), %eax
cmpl %ecx, %eax
jge 0x10f1b4
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x5c710
movq -0x50(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq %rax, %rdx
callq 0x5c1a0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x10f16d
movq -0x10(%rbp), %rdi
callq 0x5c850
leaq -0x30(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x5ca80
movq -0x90(%rbp), %rdi
callq 0x59680
movl %eax, -0x84(%rbp)
jmp 0x10f1e1
leaq -0x30(%rbp), %rdi
callq 0x5a410
movl -0x84(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5a410
movq -0x38(%rbp), %rdi
callq 0x5b6b0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/xml/node.cpp
// Function: smooth::XML::Node::Node(smooth::String const&, smooth::String const&)
S::XML::Node::Node(const String &iName, const String &iContent)
{
	nodeID		= -1;

	nameIndex	= iName.ComputeCRC32();
	content		= iContent;

	attributes	= NIL;
	subnodes	= NIL;

	if (elementNames.Get(nameIndex) == NIL) elementNames.Add(iName, nameIndex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x18, %rdi
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
callq 0x5da90
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
callq 0x597b0
movl %eax, -0x28(%rbp)
jmp 0x10f264
movq -0x30(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, 0x14(%rdi)
movq -0x18(%rbp), %rsi
addq $0x18, %rdi
callq 0x59760
jmp 0x10f27d
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movl 0x14(%rax), %esi
movq 0xf9c36(%rip), %rdi     # 0x208ed0
callq 0xde7c0
movq %rax, -0x40(%rbp)
jmp 0x10f2a5
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x59320
movb %al, -0x41(%rbp)
jmp 0x10f2b5
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x10f2be
jmp 0x10f2f0
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rsi
movl 0x14(%rax), %edx
movq 0xf9c00(%rip), %rdi     # 0x208ed0
callq 0xde810
jmp 0x10f2d7
jmp 0x10f2f0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5df00
jmp 0x10f2f6
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5b6b0
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/xml/node.cpp
// Function: smooth::XML::Node::GetAttributeByName(smooth::String const&) const
S::XML::Attribute *S::XML::Node::GetAttributeByName(const String &attributeName) const
{
	Int	 nOfAttributes = GetNOfAttributes();

	if (nOfAttributes == 0) return NIL;

	Int	 nameIndex     = attributeName.ComputeCRC32();

	for (Int i = 0; i < nOfAttributes; i++)
	{
		Attribute	*attribute = GetNthAttribute(i);

		if (attribute->nameIndex == nameIndex) return attribute;
	}

	return NIL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x59630
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x10fbc0
movq $0x0, -0x8(%rbp)
jmp 0x10fc16
movq -0x18(%rbp), %rdi
callq 0x597b0
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x10fc0e
movq -0x38(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x5c740
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x20(%rbp), %eax
jne 0x10fc01
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10fc16
jmp 0x10fc03
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x10fbd3
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq