LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x58e20
cmpl $0x0, 0x180(%r14)
jle 0xae450
movq %r14, %r15
leaq 0x178(%r14), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %r13
movq 0x8(%rsp), %rdi
movl %ebp, %esi
callq 0xaf0aa
movq %rax, %r12
testl %ebp, %ebp
je 0xae406
movq %r13, %rdi
leaq 0x63fbc(%rip), %rsi     # 0x1123aa
callq 0x579f0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x562f0
movq %r13, %rdi
callq 0x59200
movq %rbx, %rdi
movq %r12, %rsi
callq 0x562f0
movq %rax, %r14
movq %r13, %rdi
leaq 0x63eff(%rip), %rsi     # 0x11231d
callq 0x579f0
movq %r14, %rdi
movq %r13, %rsi
callq 0x562f0
addq $0x18, %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x562f0
movq %r13, %rdi
callq 0x59200
incl %ebp
cmpl 0x180(%r15), %ebp
jl 0xae3d1
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xae468
jmp 0xae46d
jmp 0xae468
movq %rax, %r14
jmp 0xae47a
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x59200
movq %r14, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0xa0(%rcx), %rdi
callq 0x99e10
testb %al, %al
je 0xae7d3
xorl %ebx, %ebx
jmp 0xae7e9
movq 0x258(%r12), %rdi
imulq %r15, %rbx
movq %r14, %rsi
movl %ebx, %edx
callq 0x55b50
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq 0xbca91(%rip), %r14     # 0x16bc00
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0xbc4b9(%rip), %rbx     # 0x16b638
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq (%r14), %rdi
testq %rdi, %rdi
je 0xaf196
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xaf1a4
movq (%rdi), %rax
callq *0x8(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
testq %rdi, %rdi
je 0xaf26c
movq %rsi, %rbx
movq 0xbca33(%rip), %r15     # 0x16bc00
movq (%r15), %r14
testq %r14, %r14
jne 0xaf20a
movl $0x58, %edi
callq 0x556b0
movq %rax, %r14
movq %rax, %rdi
callq 0x55d90
leaq 0xb060f(%rip), %rax     # 0x15f800
movq %rax, 0x40(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r14)
leaq 0xb9e0c(%rip), %rax     # 0x169010
movq %rax, (%r14)
movq %r14, (%r15)
movq 0xbc427(%rip), %r12     # 0x16b638
cmpq $0x0, (%r12)
jne 0xaf251
movl $0x58, %edi
callq 0x556b0
movq %rax, %r14
movq %rax, %rdi
callq 0x55d90
leaq 0xb107c(%rip), %rax     # 0x1602b0
movq %rax, 0x40(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r14)
leaq 0xb0fc9(%rip), %rax     # 0x160210
movq %rax, (%r14)
movq %r14, (%r12)
movq (%r15), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x5aed8
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x642ac
xorl %eax, %eax
jmp 0xaf271
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xaf27f
movq %rax, %rbx
movl $0x58, %esi
movq %r14, %rdi
callq 0x55480
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edi, %eax
imulq $0x10624dd3, %rax, %rcx # imm = 0x10624DD3
shrq $0x26, %rcx
leaq 0x10(%rsp), %rax
movq %rcx, (%rax)
imull $0x3e8, %ecx, %ecx      # imm = 0x3E8
subl %ecx, %edi
imull $0xf4240, %edi, %ecx    # imm = 0xF4240
movq %rcx, 0x8(%rax)
movq %rsp, %rsi
movq %rax, %rdi
callq 0x587c0
cmpl $-0x1, %eax
jne 0xb11d0
callq 0x58490
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %rsp, %r15
cmpl $0x4, (%rbx)
jne 0xb11d0
movaps (%rsp), %xmm0
movaps %xmm0, 0x10(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x587c0
cmpl $-0x1, %eax
je 0xb11b2
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/system/system.cpp
// Function: smooth::System::System::OpenURL(smooth::String const&)
S::Bool S::System::System::OpenURL(const String &url)
{
#if defined __WIN32__
	ShellExecute(NULL, (wchar_t *) L"open", url, NULL, NULL, SW_SHOW);
#elif defined __APPLE__
	const char	*args = url;

	if (!fork()) { execl("/usr/bin/open", "open", args, NULL); exit(0); }
#elif defined __HAIKU__
	const char	*args = url;

	if (!fork()) { execl("/boot/system/bin/open", "open", args, NULL); exit(0); }
#else
	/* Try the open commands from freedesktop.org and the Gnome, KDE
	 * and Xfce desktops first, then try some widely used browsers.
	 */
	static const char	*browsers[] = { "xdg-open", "gnome-open", "kde-open", "exo-open",
						"firefox", "safari", "chrome", "opera", "mozilla", "netscape", "epiphany", "konqueror",
						NIL };

	String	 command;

	for (int i = 0; browsers[i] != NIL; i++)
	{
		if (i > 0) command.Append(" || ");

		command.Append(browsers[i]).Append(" \"").Append(url).Append("\"");
	}

	const char	*cmd = command;

	if (!fork()) { execl("/bin/sh", "sh", "-c", cmd, NULL); exit(0); }
#endif

	return True;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, (%rsp)
leaq 0x8(%rsp), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x58e20
leaq 0xb7e3c(%rip), %rbx     # 0x169150
leaq 0x20(%rsp), %r15
leaq 0x50(%rsp), %r13
leaq 0x38(%rsp), %r12
testl %r14d, %r14d
je 0xb1356
cmpl $0xc, %r14d
je 0xb13d8
movq %r15, %rdi
leaq 0x6151a(%rip), %rsi     # 0x112856
callq 0x579f0
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x562f0
movq %r15, %rdi
callq 0x59200
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x579f0
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x562f0
movq %rax, %rbp
movq %r13, %rdi
leaq 0x614e0(%rip), %rsi     # 0x11285b
callq 0x579f0
movq %rbp, %rdi
movq %r13, %rsi
callq 0x562f0
movq %rax, %rdi
movq (%rsp), %rsi
callq 0x562f0
movq %rax, %rbp
movq %r12, %rdi
leaq 0x614b8(%rip), %rsi     # 0x11285c
callq 0x579f0
movq %rbp, %rdi
movq %r12, %rsi
callq 0x562f0
movq %r12, %rdi
callq 0x59200
movq %r13, %rdi
callq 0x59200
movq %r15, %rdi
callq 0x59200
incl %r14d
addq $0x8, %rbx
jmp 0xb1323
leaq 0x8(%rsp), %rdi
callq 0x585e0
movq %rax, %rbx
callq 0x583e0
testl %eax, %eax
je 0xb1409
leaq 0x8(%rsp), %rdi
callq 0x59200
movb $0x1, %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x611b5(%rip), %rdi     # 0x1125c5
leaq 0x611b3(%rip), %rsi     # 0x1125ca
leaq 0x611af(%rip), %rdx     # 0x1125cd
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x59070
xorl %edi, %edi
callq 0x57120
jmp 0xb1450
jmp 0xb1450
jmp 0xb144b
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x59200
jmp 0xb1458
jmp 0xb1455
jmp 0xb144b
movq %rax, %rbx
jmp 0xb1462
movq %rax, %rbx
jmp 0xb146c
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x59200
leaq 0x20(%rsp), %rdi
callq 0x59200
leaq 0x8(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movb 0xc4ba1(%rip), %al      # 0x176030
testb %al, %al
je 0xb1551
leaq 0xc4b7a(%rip), %rdi     # 0x176018
xorl %esi, %esi
callq 0x56bd0
testb %al, %al
jne 0xb1536
callq 0x55370
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x579f0
leaq 0xc4b4f(%rip), %rdi     # 0x176018
movq %r14, %rsi
callq 0x58b10
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x59200
testb %bpl, %bpl
jne 0xb1510
callq 0x55370
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x579f0
leaq 0xc4b1a(%rip), %rdi     # 0x176018
movq %r14, %rsi
callq 0x562f0
leaq 0x8(%rsp), %rdi
callq 0x59200
callq 0x55370
leaq 0xc4afc(%rip), %rdi     # 0x176018
movq %rax, %rsi
callq 0x57ef0
testb %al, %al
je 0xb1536
leaq 0xc4ae9(%rip), %rdi     # 0x176018
xorl %esi, %esi
callq 0x579e0
leaq 0xc4adb(%rip), %rsi     # 0x176018
movq %rbx, %rdi
callq 0x570b0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xc4ad8(%rip), %rdi     # 0x176030
callq 0x56120
testl %eax, %eax
je 0xb1497
leaq 0xc4aac(%rip), %rdi     # 0x176018
xorl %esi, %esi
callq 0x58e20
movq 0xba9b6(%rip), %rdi     # 0x16bf30
leaq 0xc4a97(%rip), %rsi     # 0x176018
leaq 0xbcaf8(%rip), %rdx     # 0x16e080
callq 0x57e10
leaq 0xc4a9c(%rip), %rdi     # 0x176030
callq 0x56b80
jmp 0xb1497
movq %rax, %rbx
leaq 0xc4a88(%rip), %rdi     # 0x176030
callq 0x56420
jmp 0xb15be
jmp 0xb15b1
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/system/system.cpp
// Function: smooth::System::System::GetProgramFilesDirectory()
S::String S::System::System::GetProgramFilesDirectory()
{
	static String	 programsDir;

	if (programsDir != NIL) return programsDir;

#ifdef __WIN32__
	HKEY	 currentVersion;

	if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion", 0, KEY_QUERY_VALUE, &currentVersion) == ERROR_SUCCESS)
	{
		DWORD		 size = (32768 + 1) * sizeof(wchar_t);
		Buffer<BYTE>	 buffer(size);

		RegQueryValueEx(currentVersion, L"ProgramFilesDir", 0, NIL, buffer, &size);

		programsDir = (wchar_t *) (BYTE *) buffer;

		RegCloseKey(currentVersion);
	}

	if (programsDir == NIL)
	{
		/* Failed to get the program files directory from the registry.
		 * Get the directory name from the environment variable.
		 */
		Buffer<wchar_t>	 buffer(32768 + 1);

		ExpandEnvironmentStrings(String("%ProgramFiles%"), buffer, buffer.Size());

		programsDir = buffer;
	}
#endif

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

	return programsDir;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movb 0xc4a79(%rip), %al      # 0x176050
testb %al, %al
je 0xb1699
leaq 0xc4a52(%rip), %rdi     # 0x176038
xorl %esi, %esi
callq 0x56bd0
testb %al, %al
jne 0xb167e
callq 0x55370
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x579f0
leaq 0xc4a27(%rip), %rdi     # 0x176038
movq %r14, %rsi
callq 0x58b10
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x59200
testb %bpl, %bpl
jne 0xb1658
callq 0x55370
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x579f0
leaq 0xc49f2(%rip), %rdi     # 0x176038
movq %r14, %rsi
callq 0x562f0
leaq 0x8(%rsp), %rdi
callq 0x59200
callq 0x55370
leaq 0xc49d4(%rip), %rdi     # 0x176038
movq %rax, %rsi
callq 0x57ef0
testb %al, %al
je 0xb167e
leaq 0xc49c1(%rip), %rdi     # 0x176038
xorl %esi, %esi
callq 0x579e0
leaq 0xc49b3(%rip), %rsi     # 0x176038
movq %rbx, %rdi
callq 0x570b0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xc49b0(%rip), %rdi     # 0x176050
callq 0x56120
testl %eax, %eax
je 0xb15df
leaq 0xc4984(%rip), %rdi     # 0x176038
xorl %esi, %esi
callq 0x58e20
movq 0xba86e(%rip), %rdi     # 0x16bf30
leaq 0xc496f(%rip), %rsi     # 0x176038
leaq 0xbc9b0(%rip), %rdx     # 0x16e080
callq 0x57e10
leaq 0xc4974(%rip), %rdi     # 0x176050
callq 0x56b80
jmp 0xb15df
movq %rax, %rbx
leaq 0xc4960(%rip), %rdi     # 0x176050
callq 0x56420
jmp 0xb1706
jmp 0xb16f9
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/system/system.cpp
// Function: smooth::System::System::GetTempDirectory()
S::String S::System::System::GetTempDirectory()
{
	static String	 tempDir;

	if (tempDir != NIL) return tempDir;

	String::InputFormat	 inputFormat("UTF-8");

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

	GetTempPath(buffer.Size(), buffer);

	tempDir = buffer;
#elif defined __HAIKU__
	FILE		*pstdin = popen("finddir B_COMMON_TEMP_DIRECTORY", "r");
	Buffer<char>	 buffer(PATH_MAX + 1);

	buffer.Zero();

	fscanf(pstdin, String("%[^\n]").Append(String::FromInt(buffer.Size() - 1)), (char *) buffer);

	pclose(pstdin);

	tempDir = buffer;
#else
	tempDir = getenv("TMPDIR");

	if (tempDir == NIL) tempDir = "/var/tmp";
#endif

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

	return tempDir;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movb 0xc3cc9(%rip), %al      # 0x176170
testb %al, %al
je 0xb25d0
leaq 0xc3ca2(%rip), %rdi     # 0x176158
xorl %esi, %esi
callq 0x56bd0
testb %al, %al
je 0xb24d5
leaq 0xc3c90(%rip), %rsi     # 0x176158
movq %rbx, %rdi
callq 0x570b0
jmp 0xb25c6
leaq 0x5fdfa(%rip), %rsi     # 0x1122d6
leaq 0x20(%rsp), %rdi
callq 0x590d0
leaq 0x6040e(%rip), %rdi     # 0x1128fb
callq 0x57720
leaq 0xc3c5f(%rip), %rdi     # 0x176158
movq %rax, %rsi
callq 0x55f40
leaq 0xc3c50(%rip), %rdi     # 0x176158
xorl %esi, %esi
callq 0x55260
testb %al, %al
je 0xb2526
leaq 0xc3c3e(%rip), %rdi     # 0x176158
leaq 0x603e1(%rip), %rsi     # 0x112902
callq 0x55f40
callq 0x55370
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x579f0
leaq 0xc3c19(%rip), %rdi     # 0x176158
leaq 0x8(%rsp), %rsi
callq 0x58b10
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x59200
testb %bpl, %bpl
jne 0xb2587
callq 0x55370
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x579f0
leaq 0xc3be5(%rip), %rdi     # 0x176158
leaq 0x8(%rsp), %rsi
callq 0x562f0
leaq 0x8(%rsp), %rdi
callq 0x59200
callq 0x55370
leaq 0xc3bc5(%rip), %rdi     # 0x176158
movq %rax, %rsi
callq 0x57ef0
testb %al, %al
je 0xb25ad
leaq 0xc3bb2(%rip), %rdi     # 0x176158
xorl %esi, %esi
callq 0x579e0
leaq 0xc3ba4(%rip), %rsi     # 0x176158
movq %rbx, %rdi
callq 0x570b0
leaq 0x20(%rsp), %rdi
callq 0x56a30
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
leaq 0xc3b99(%rip), %rdi     # 0x176170
callq 0x56120
testl %eax, %eax
je 0xb24af
leaq 0xc3b6d(%rip), %rdi     # 0x176158
xorl %esi, %esi
callq 0x58e20
movq 0xb9937(%rip), %rdi     # 0x16bf30
leaq 0xc3b58(%rip), %rsi     # 0x176158
leaq 0xbba79(%rip), %rdx     # 0x16e080
callq 0x57e10
leaq 0xc3b5d(%rip), %rdi     # 0x176170
callq 0x56b80
jmp 0xb24af
movq %rax, %rbx
leaq 0xc3b49(%rip), %rdi     # 0x176170
callq 0x56420
jmp 0xb2650
jmp 0xb2632
jmp 0xb2643
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
jmp 0xb2646
jmp 0xb2643
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x56a30
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x56e70
movq 0xb9624(%rip), %rax     # 0x16bc90
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x48(%rbx), %r14
movq $0x0, 0x50(%rbx)
leaq 0xaf0c2(%rip), %rax     # 0x161748
movq %rax, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rbx)
movq %rbx, %rdi
callq 0xb28fa
movq %rax, 0x38(%rbx)
movq 0xb921c(%rip), %rax     # 0x16b8c0
movzwl (%rax), %eax
movw %ax, 0x20(%rbx)
movl $0x0, 0x40(%rbx)
movw $0x0, 0x44(%rbx)
movq %rbx, 0x50(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x700f4
movq %rbx, %rdi
callq 0x55c60
movq %r15, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/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:
cmpw $0x1, 0x44(%rdi)
jne 0xb2781
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
movl %esi, 0x40(%rdi)
movw $0x1, 0x44(%rdi)
movq 0x38(%rdi), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
jmpq *%rax
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb8e0c(%rip), %r14     # 0x16b7d8
movq (%r14), %rdi
testq %rdi, %rdi
je 0xb29ea
callq 0x558a0
movq (%r14), %rdi
movb (%rbx), %bl
testq %rdi, %rdi
je 0xb29ec
callq 0x58150
jmp 0xb29ec
movb (%rbx), %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0xb8dd1(%rip), %r15     # 0x16b7d8
movq (%r15), %rdi
callq 0x558a0
movb %bl, (%r14)
movb (%r14), %bl
movq (%r15), %rdi
callq 0x58150
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb8da4(%rip), %r14     # 0x16b7d8
movq (%r14), %rdi
testq %rdi, %rdi
je 0xb2a53
callq 0x558a0
movq (%r14), %rdi
movzwl (%rbx), %ebx
testq %rdi, %rdi
je 0xb2a56
callq 0x58150
jmp 0xb2a56
movzwl (%rbx), %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xb8d6a(%rip), %r14     # 0x16b7d8
movq (%r14), %rdi
callq 0x558a0
movzwl (%rbx), %ebp
incl %ebp
movw %bp, (%rbx)
movq (%r14), %rdi
callq 0x58150
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xb8d3c(%rip), %r14     # 0x16b7d8
movq (%r14), %rdi
callq 0x558a0
movzwl (%rbx), %ebp
decl %ebp
movw %bp, (%rbx)
movq (%r14), %rdi
callq 0x58150
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0xb8d0b(%rip), %r15     # 0x16b7d8
movq (%r15), %rdi
callq 0x558a0
movw %bx, (%r14)
movzwl (%r14), %ebx
movq (%r15), %rdi
callq 0x58150
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb8cdc(%rip), %r14     # 0x16b7d8
movq (%r14), %rdi
callq 0x558a0
movl (%rbx), %ebx
movq (%r14), %rdi
callq 0x58150
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xb8cb2(%rip), %r14     # 0x16b7d8
movq (%r14), %rdi
callq 0x558a0
movl (%rbx), %ebp
incl %ebp
movl %ebp, (%rbx)
movq (%r14), %rdi
callq 0x58150
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xb8c86(%rip), %r14     # 0x16b7d8
movq (%r14), %rdi
callq 0x558a0
movl (%rbx), %ebp
decl %ebp
movl %ebp, (%rbx)
movq (%r14), %rdi
callq 0x58150
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0xb8c57(%rip), %r15     # 0x16b7d8
movq (%r15), %rdi
callq 0x558a0
movl %ebx, (%r14)
movl (%r14), %ebx
movq (%r15), %rdi
callq 0x58150
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpq %rdi, %rsi
je 0xb2cdb
xorl %eax, %eax
movl %eax, (%r14)
movl %eax, 0x4(%r14)
movl $0x8, %edi
callq 0x556b0
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x55870
movq %rbx, 0x8(%r14)
movl $0x8, %edi
callq 0x556b0
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x55870
movq %rbx, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xb2ce8
movq %rax, %r14
movl $0x8, %esi
movq %rbx, %rdi
callq 0x55480
movq %r14, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rdi, %rsi
je 0xb2fe9
movq %rsi, %r14
xorl %edi, %edi
callq 0xb3648
movq %rax, 0x38(%rbx)
movq 0xb8a69(%rip), %rax     # 0x16ba30
movzwl (%rax), %eax
movw %ax, 0x20(%rbx)
movw $0x0, 0x34(%rbx)
leaq 0x40(%r14), %rsi
leaq 0x40(%rbx), %rdi
callq 0xb3308
movq 0x60(%r14), %rax
movq %rax, 0x60(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq 0xb8a91(%rip), %rax     # 0x16ba90
addq $0x10, %rax
movq %rax, (%rdi)
movzwl 0x34(%rdi), %eax
cmpl $0x3, %eax
je 0xb3018
cmpl $0x2, %eax
je 0xb303c
testl %eax, %eax
jne 0xb3020
movw $0x2, 0x34(%rbx)
jmp 0xb303c
movw $0x2, 0x34(%rbx)
movq 0xb866b(%rip), %rdi     # 0x16b698
callq 0x564d0
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xb304b
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x40(%rbx), %rdi
leaq 0xb633a(%rip), %rax     # 0x169390
movq %rax, 0x40(%rbx)
callq 0xb3222
movq %rbx, %rdi
popq %rbx
jmp 0x55c60
jmp 0xb306a
movq %rax, %rdi
callq 0x5aeae
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movzwl 0x34(%rdi), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x3, %ecx
je 0xb30de
testl %ecx, %ecx
jne 0xb311f
leaq 0xbb1c3(%rip), %rdx     # 0x16e2a8
cmpb $0x0, (%rdx)
je 0xb30f7
testw %cx, %cx
jne 0xb311f
movw $0x3, 0x34(%rbx)
jmp 0xb311d
movq 0xb859a(%rip), %rdi     # 0x16b698
callq 0x55f70
movw $0x1, 0x34(%rbx)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movq 0xb8e31(%rip), %rsi     # 0x16bf48
movq %rbx, %rdx
callq *0x10(%rax)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x8(%rdi), %r14
leaq 0xb81fc(%rip), %rdi     # 0x16b330
callq 0x566e0
movq %r14, 0x28(%rax)
leaq 0x40(%rbx), %rdi
movq %rbx, %rsi
callq 0xb3468
movl $0x1, %edi
callq 0x58440
movw $0x2, 0x34(%rbx)
movq 0xb8535(%rip), %rdi     # 0x16b698
callq 0x564d0
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x28(%rax)
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/threads/../../include/smooth/threads/../templates/signals/signalr.h
// Function: smooth::SignalR1<int, smooth::Threads::Thread*>::operator=(smooth::SignalR1<int, smooth::Threads::Thread*> const&)
SIGNALS_SIGNAL_CLASS_NAME<returnTYPE SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES> &operator =(const SIGNALS_SIGNAL_CLASS_NAME<returnTYPE SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES> &oSignal)
			{
				if (&oSignal == this) return *this;

				DisconnectAll();

				if (oSignal.slotsN != NIL)
				{
					slotsN = new Array<Void *>();
					slotsN->EnableLocking();

					for (Int i = 0; i < oSignal.slotsN->Length(); i++)
					{
						slotsN->Add(((SIGNALS_SLOT_BASE_CLASS_NAME<returnTYPE SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES> *) oSignal.slotsN->GetNth(i))->Copy());
					}
				}

				if (oSignal.slots0 != NIL)
				{
					slots0 = new Array<Void *>();
					slots0->EnableLocking();

					for (Int j = 0; j < oSignal.slots0->Length(); j++)
					{
						slots0->Add(((SlotRBase0<returnTYPE> *) oSignal.slots0->GetNth(j))->Copy());
					}
				}

				parent = oSignal.parent;

				return *this;
			}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq %rdi, %rsi
je 0xb343d
movq %rsi, %r14
movq %rbx, %rdi
callq 0xb3222
cmpq $0x0, 0x10(%r14)
je 0xb33b0
movl $0x58, %edi
callq 0x556b0
movq %rax, %r15
movq %rax, %rdi
callq 0x55d90
leaq 0xac4b2(%rip), %rax     # 0x15f800
movq %rax, 0x40(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r15)
leaq 0xac5bf(%rip), %rax     # 0x15f920
movq %rax, (%r15)
movq %r15, 0x10(%rbx)
movq %r15, %rdi
callq 0x571b0
movq 0x10(%r14), %rdi
cmpl $0x0, 0x8(%rdi)
jle 0xb33b0
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
movq 0x10(%rbx), %r12
movl %ebp, %esi
callq 0x5b074
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%rsp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x5aed8
incl %ebp
movq 0x10(%r14), %rdi
cmpl 0x8(%rdi), %ebp
jl 0xb3381
cmpq $0x0, 0x18(%r14)
je 0xb3435
movl $0x58, %edi
callq 0x556b0
movq %rax, %r15
movq %rax, %rdi
callq 0x55d90
leaq 0xac42d(%rip), %rax     # 0x15f800
movq %rax, 0x40(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r15)
leaq 0xac53a(%rip), %rax     # 0x15f920
movq %rax, (%r15)
movq %r15, 0x18(%rbx)
movq %r15, %rdi
callq 0x571b0
movq 0x18(%r14), %rdi
cmpl $0x0, 0x8(%rdi)
jle 0xb3435
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
movq 0x18(%rbx), %r12
movl %ebp, %esi
callq 0x5b074
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%rsp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x5aed8
incl %ebp
movq 0x18(%r14), %rdi
cmpl 0x8(%rdi), %ebp
jl 0xb3406
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb344f
movq %rax, %rbx
movl $0x58, %esi
movq %r15, %rdi
callq 0x55480
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58e20
movl $0xffffffff, (%r15)     # imm = 0xFFFFFFFF
movq %r14, %rdi
callq 0x55640
movl %eax, 0x4(%r15)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x555f0
movl 0x4(%r15), %esi
movq 0xb8050(%rip), %rdi     # 0x16b720
callq 0x9b2d4
movq %rax, %rdi
xorl %esi, %esi
callq 0x55260
testb %al, %al
je 0xb36f6
movl 0x4(%r15), %edx
movq 0xb8032(%rip), %rdi     # 0x16b720
movq %r14, %rsi
callq 0x64316
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x59200
movq %r14, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/xml/document.cpp
// Function: smooth::XML::Document::LoadFile(smooth::String const&)
S::Int S::XML::Document::LoadFile(const String &fileName)
{
	if (!File(fileName).Exists()) return Error();

	xmlTextReaderPtr reader = xmlNewTextReaderFilename(fileName.ConvertTo("UTF-8"));

	if (reader == NIL) return Error();

	Int	 ret = 1;

	while ((ret = xmlTextReaderRead(reader)) == 1)
	{
		if (xmlTextReaderNodeType(reader) == XML_ELEMENT_NODE)
		{
			String::InputFormat	 inputFormat("UTF-8");

			rootNode = new Node(NIL);
			ownRoot	 = True;

			LoadNode(reader, rootNode);

			break;
		}
	}

	xmlFreeTextReader(reader);

	if (ret >= 0)	return Success();
	else		return Error();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x58e20
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x56800
leaq 0x38(%rsp), %rdi
callq 0x56ef0
movl %eax, %r15d
leaq 0x38(%rsp), %rdi
callq 0x59178
leaq 0x8(%rsp), %rdi
callq 0x59200
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testb %r15b, %r15b
je 0xb39d9
leaq 0x5e9cd(%rip), %rsi     # 0x1122d6
movq %r14, %rdi
callq 0x57940
movq %rax, %rdi
callq 0x58760
testq %rax, %rax
je 0xb39d9
movq %rax, %r14
movq %r14, %rdi
callq 0x57f60
cmpl $0x1, %eax
jne 0xb39cc
movq %r14, %rdi
callq 0x56ac0
cmpl $0x1, %eax
jne 0xb3925
leaq 0x5e98c(%rip), %rsi     # 0x1122d6
leaq 0x38(%rsp), %rdi
callq 0x590d0
movl $0x30, %edi
callq 0x556b0
movq %rax, %r15
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x58e20
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x58e20
leaq 0x8(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %r15, %rdi
callq 0x567b0
movq %r15, 0x18(%rbx)
leaq 0x20(%rsp), %rdi
callq 0x59200
leaq 0x8(%rsp), %rdi
callq 0x59200
movb $0x1, 0x20(%rbx)
movq 0x18(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x57660
leaq 0x38(%rsp), %rdi
callq 0x56a30
movq %r14, %rdi
callq 0x55d20
xorl %ebp, %ebp
jmp 0xb39d9
movl %eax, %ebp
movq %r14, %rdi
callq 0x55d20
sarl $0x1f, %ebp
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x59200
jmp 0xb39f8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
jmp 0xb3a07
movq %rax, %rbx
movl $0x30, %esi
movq %r15, %rdi
callq 0x55480
jmp 0xb3a19
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x56a30
jmp 0xb3a41
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x59178
jmp 0xb3a37
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/xml/document.cpp
// Function: smooth::XML::Document::LoadNode(_xmlTextReader*, smooth::XML::Node*)
S::Int S::XML::Document::LoadNode(xmlTextReaderPtr reader, Node *node)
{
	node->SetName((const char *) xmlTextReaderConstName(reader));

	if (xmlTextReaderHasAttributes(reader))
	{
		while (xmlTextReaderMoveToNextAttribute(reader) == 1) node->SetAttribute((const char *) xmlTextReaderConstName(reader), (const char *) xmlTextReaderConstValue(reader));

		xmlTextReaderMoveToElement(reader);
	}

	if (!xmlTextReaderIsEmptyElement(reader))
	{
		Int	 nodeType = 0;

		if (xmlTextReaderRead(reader) == -1) return Error();

		while ((nodeType = xmlTextReaderNodeType(reader)) != XML_ELEMENT_DECL)
		{
			if	(nodeType == XML_ELEMENT_NODE)					  LoadNode(reader, node->AddNode(NIL));
			else if (nodeType == XML_TEXT_NODE || nodeType == XML_CDATA_SECTION_NODE) node->SetContent((const char *) xmlTextReaderConstValue(reader));

			if (xmlTextReaderRead(reader) == -1) return Error();
		}
	}

	return Success();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x55920
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x579f0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x56c90
leaq 0x8(%rsp), %rdi
callq 0x59200
movq %r14, %rdi
callq 0x56320
testl %eax, %eax
je 0xb3b0a
movq %r14, %rdi
callq 0x56bc0
cmpl $0x1, %eax
jne 0xb3b02
leaq 0x8(%rsp), %r12
leaq 0x20(%rsp), %r13
movq %r14, %rdi
callq 0x55920
movq %r12, %rdi
movq %rax, %rsi
callq 0x579f0
movq %r14, %rdi
callq 0x58160
movq %r13, %rdi
movq %rax, %rsi
callq 0x579f0
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x581c0
movq %r13, %rdi
callq 0x59200
movq %r12, %rdi
callq 0x59200
movq %r14, %rdi
callq 0x56bc0
cmpl $0x1, %eax
je 0xb3ab1
movq %r14, %rdi
callq 0x56fb0
movq %r14, %rdi
callq 0x55fa0
xorl %ebp, %ebp
testl %eax, %eax
je 0xb3b29
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x57f60
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
je 0xb3b18
leaq 0x8(%rsp), %r12
leaq 0x20(%rsp), %r13
movq %r14, %rdi
callq 0x56ac0
cmpl $0x1, %eax
je 0xb3b7f
cmpl $0xf, %eax
je 0xb3bd5
addl $-0x3, %eax
cmpl $0x1, %eax
ja 0xb3bbf
movq %r14, %rdi
callq 0x58160
movq %r12, %rdi
movq %rax, %rsi
callq 0x579f0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x558f0
jmp 0xb3bb7
movq %r12, %rdi
xorl %esi, %esi
callq 0x58e20
movq %r13, %rdi
xorl %esi, %esi
callq 0x58e20
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x55820
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x57660
movq %r13, %rdi
callq 0x59200
movq %r12, %rdi
callq 0x59200
movq %r14, %rdi
callq 0x57f60
cmpl $-0x1, %eax
jne 0xb3b45
jmp 0xb3b18
xorl %ebp, %ebp
jmp 0xb3b18
jmp 0xb3bf3
jmp 0xb3bf3
jmp 0xb3bf3
jmp 0xb3be4
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x59200
jmp 0xb3bf6
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/xml/document.cpp
// Function: smooth::XML::Document::ParseMemory(void const*, int)
S::Int S::XML::Document::ParseMemory(const Void *memory, Int size)
{
	xmlParserInputBufferPtr	 buffer = xmlParserInputBufferCreateMem((char *) memory, size, XML_CHAR_ENCODING_NONE);

	if (buffer == NIL) { return Error(); }

	xmlTextReaderPtr	 reader = xmlNewTextReader(buffer, NIL);

	if (reader == NIL) { xmlFreeParserInputBuffer(buffer); return Error(); }

	Int	 ret = 1;

	while ((ret = xmlTextReaderRead(reader)) == 1)
	{
		if (xmlTextReaderNodeType(reader) == XML_ELEMENT_NODE)
		{
			String::InputFormat	 inputFormat("UTF-8");

			rootNode = new Node(NIL);
			ownRoot	 = True;

			LoadNode(reader, rootNode);

			break;
		}
	}

	xmlFreeTextReader(reader);
	xmlFreeParserInputBuffer(buffer);

	if (ret >= 0)	return Success();
	else		return Error();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r15
movq %rsi, %rdi
movl %edx, %esi
xorl %edx, %edx
callq 0x56cc0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0xb3cff
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x57870
testq %rax, %rax
je 0xb3cf7
movq %rax, %r14
movq %r14, %rdi
callq 0x57f60
cmpl $0x1, %eax
jne 0xb3cea
movq %r14, %rdi
callq 0x56ac0
cmpl $0x1, %eax
jne 0xb3c4a
leaq 0x5e667(%rip), %rsi     # 0x1122d6
leaq 0x38(%rsp), %rdi
callq 0x590d0
movl $0x30, %edi
callq 0x556b0
movq %rax, %r12
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x58e20
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x58e20
leaq 0x20(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
callq 0x567b0
movq %r12, 0x18(%r15)
leaq 0x8(%rsp), %rdi
callq 0x59200
leaq 0x20(%rsp), %rdi
callq 0x59200
movb $0x1, 0x20(%r15)
movq 0x18(%r15), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x57660
leaq 0x38(%rsp), %rdi
callq 0x56a30
xorl %ebp, %ebp
jmp 0xb3cef
movl %eax, %ebp
sarl $0x1f, %ebp
movq %r14, %rdi
callq 0x55d20
movq %rbx, %rdi
callq 0x58230
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
jmp 0xb3d20
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x59200
jmp 0xb3d2f
movq %rax, %rbx
movl $0x30, %esi
movq %r12, %rdi
callq 0x55480
jmp 0xb3d41
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x56a30
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x5e571(%rip), %rsi     # 0x1122d6
movq %rax, %rdi
callq 0x57940
movq %rax, %rdi
xorl %esi, %esi
callq 0x55320
movq %rax, %r14
movq %rax, %rdi
movl $0x1, %esi
callq 0x58db0
movq %rbx, %rdi
callq 0x585e0
leaq 0x5ecbd(%rip), %rsi     # 0x112a53
movq %r14, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x57d60
movq 0x18(%rbx), %rdx
testq %rdx, %rdx
je 0xb3db7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x579b0
movq %r14, %rdi
callq 0x55670
movq %r14, %rdi
callq 0x55690
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, %rdi
callq 0x57d50
leaq 0x5e4e1(%rip), %rsi     # 0x1122d6
movq %rax, %rdi
callq 0x57940
movq %rbx, %rdi
movq %rax, %rsi
callq 0x56ea0
movq %r14, %rdi
callq 0x554f0
testl %eax, %eax
jle 0xb3e76
xorl %ebp, %ebp
leaq 0x5e4b9(%rip), %r12     # 0x1122d6
movq %r14, %rdi
movl %ebp, %esi
callq 0x57e40
movq %rax, %rdi
callq 0x58b70
movq %rax, %rdi
movq %r12, %rsi
callq 0x57940
movq %rax, %r13
movq %r14, %rdi
movl %ebp, %esi
callq 0x57e40
movq %rax, %rdi
callq 0x55720
movq %rax, %rdi
movq %r12, %rsi
callq 0x57940
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x57fd0
incl %ebp
movq %r14, %rdi
callq 0x554f0
cmpl %eax, %ebp
jl 0xb3e1d
movq %r14, %rdi
callq 0x58e00
leaq 0x5e451(%rip), %rsi     # 0x1122d6
movq %rax, %rdi
callq 0x57940
movq %rbx, %rdi
movq %rax, %rsi
callq 0x573a0
movq %r14, %rdi
callq 0x56050
testl %eax, %eax
jle 0xb3ecc
xorl %ebp, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x57e20
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x579b0
incl %ebp
movq %r14, %rdi
callq 0x56050
cmpl %eax, %ebp
jl 0xb3ea6
movq %rbx, %rdi
callq 0x57f40
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58e20
movl $0xffffffff, 0x10(%r15) # imm = 0xFFFFFFFF
movq %r14, %rdi
callq 0x55640
movl %eax, 0x14(%r15)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x555f0
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movl 0x14(%r15), %esi
movq 0xb7fa0(%rip), %rdi     # 0x16bed8
callq 0x9b2d4
movq %rax, %rdi
xorl %esi, %esi
callq 0x55260
testb %al, %al
je 0xb3f5e
movl 0x14(%r15), %edx
movq 0xb7f82(%rip), %rdi     # 0x16bed8
movq %r14, %rsi
callq 0x64316
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x59200
movq %r14, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/xml/node.cpp
// Function: smooth::XML::Node::~Node()
S::XML::Node::~Node()
{
	/* Delete attributes.
	 */
	if (attributes != NIL)
	{
		foreach (Attribute *attribute, *attributes) delete attribute;

		delete attributes;
	}

	/* Delete subnodes.
	 */
	if (subnodes != NIL)
	{
		foreach (Node *subnode, *subnodes) delete subnode;

		delete subnodes;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xb41d8
cmpl $0x0, 0x8(%rdi)
jle 0xb41d2
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
incl %ebp
movl %ebp, %esi
callq 0x60a9a
movq (%rax), %r14
testq %r14, %r14
je 0xb41b9
movq %r14, %rdi
callq 0x57950
movl $0x20, %esi
movq %r14, %rdi
callq 0x55480
movq (%rbx), %rdi
movl 0x8(%rdi), %eax
decl %eax
cmpl %eax, %ebp
jl 0xb41a0
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xb4225
cmpl $0x0, 0x8(%rdi)
jle 0xb421f
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
incl %ebp
movl %ebp, %esi
callq 0x60a9a
movq (%rax), %r14
testq %r14, %r14
je 0xb4205
movq %r14, %rdi
callq 0x55f80
movl $0x30, %esi
movq %r14, %rdi
callq 0x55480
movq 0x8(%rbx), %rdi
movl 0x8(%rdi), %eax
decl %eax
cmpl %eax, %ebp
jl 0xb41ec
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x18, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x59200
jmp 0xb4237
movq %rax, %rdi
callq 0x5aeae
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/xml/node.cpp
// Function: smooth::XML::Node::SetAttribute(smooth::String const&, smooth::String const&)
S::XML::Attribute *S::XML::Node::SetAttribute(const String &attributeName, const String &attributeContent)
{
	Attribute	*attribute = GetAttributeByName(attributeName);

	if (attribute == NIL)
	{
		attribute = new Attribute(attributeName, attributeContent);

		if (attributes == NIL) attributes = new Array<Attribute *, Void *>();

		attribute->SetAttributeID(attributes->Add(attribute));
	}
	else
	{
		attribute->SetContent(attributeContent);
	}

	return attribute;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x58d10
testq %rax, %rax
je 0xb436f
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x56770
jmp 0xb43df
movl $0x20, %edi
callq 0x556b0
movq %rax, %rbx
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x58a00
movq (%r14), %r15
testq %r15, %r15
jne 0xb43c7
movl $0x58, %edi
callq 0x556b0
movq %rax, %r15
movq %rax, %rdi
callq 0x55d90
leaq 0xab452(%rip), %rax     # 0x15f800
movq %rax, 0x40(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r15)
leaq 0xb50df(%rip), %rax     # 0x1694a0
movq %rax, (%r15)
movq %r15, (%r14)
movq %rsp, %rsi
movq %rbx, (%rsi)
movq %r15, %rdi
callq 0x5aed8
movq %rbx, %rdi
movl %eax, %esi
callq 0x55830
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x58, %esi
movq %r15, %rdi
jmp 0xb4406
movq %rax, %r14
movl $0x20, %esi
movq %rbx, %rdi
callq 0x55480
movq %r14, %rdi
callq 0x57090
nop