LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %eax, %eax
movl %eax, (%rdi)
movl %eax, 0x4(%rdi)
pushq $0x8
popq %rdi
callq 0x56700
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x568d0
movq %rbx, 0x8(%r14)
pushq $0x8
popq %rdi
callq 0x56700
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x568d0
movq %rbx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xadc96
movq %rax, %r14
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x564c0
movq %r14, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
cmpq %rdi, %rsi
je 0xadcf7
xorl %eax, %eax
movl %eax, (%rbx)
movl %eax, 0x4(%rbx)
pushq $0x8
popq %rdi
callq 0x56700
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
callq 0x568d0
movq %r14, 0x8(%rbx)
pushq $0x8
popq %rdi
callq 0x56700
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
callq 0x568d0
movq %r14, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xadd04
movq %rax, %rbx
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x564c0
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/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 0xadfcd
movq %rsi, %r14
xorl %edi, %edi
callq 0xae562
movq %rax, 0x38(%rbx)
movq 0xb3a7f(%rip), %rax     # 0x161a30
movzwl (%rax), %eax
movw %ax, 0x20(%rbx)
andw $0x0, 0x34(%rbx)
addq $0x40, %r14
leaq 0x40(%rbx), %rdi
movq %r14, %rsi
callq 0xae19e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb3aad(%rip), %rax     # 0x161a90
addq $0x10, %rax
movq %rax, (%rdi)
movzwl 0x34(%rdi), %eax
cmpl $0x3, %eax
je 0xadffc
cmpl $0x2, %eax
je 0xae020
testl %eax, %eax
jne 0xae004
movw $0x2, 0x34(%rbx)
jmp 0xae020
movw $0x2, 0x34(%rbx)
movq 0xb3687(%rip), %rdi     # 0x161698
callq 0x575e0
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xae02f
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x40(%rbx), %rdi
callq 0xae184
movq %rbx, %rdi
popq %rbx
jmp 0x56d00
movq %rax, %rdi
callq 0x5bffa
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq $-0x1
popq %rax
cmpl $0x3, %ecx
je 0xae0b2
testl %ecx, %ecx
jne 0xae0f3
leaq 0xb63af(%rip), %rdx     # 0x164468
cmpb $0x0, (%rdx)
je 0xae0cb
testw %cx, %cx
jne 0xae0f3
movw $0x3, 0x34(%rbx)
jmp 0xae0f1
movq 0xb35c6(%rip), %rdi     # 0x161698
callq 0x57040
movw $0x1, 0x34(%rbx)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movq 0xb3e5d(%rip), %rsi     # 0x161f48
movq %rbx, %rdx
callq *0x10(%rax)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xb3228(%rip), %rdi     # 0x161330
callq 0x57820
movq %r14, 0x28(%rax)
leaq 0x40(%rbx), %rdi
movq %rbx, %rsi
callq 0xae3da
pushq $0x1
popq %rdi
callq 0x59720
movw $0x2, 0x34(%rbx)
movq 0xb3563(%rip), %rdi     # 0x161698
callq 0x575e0
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x28(%rax)
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testl %eax, %eax
je 0xae163
pushq $-0x1
popq %rax
jmp 0xae177
movw $0x2, 0x34(%rbx)
movq 0xb3528(%rip), %rdi     # 0x161698
callq 0x575e0
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xae3b1
movq %rsi, %r14
movq %rbx, %rdi
callq 0xae1ec
cmpq $0x0, 0x10(%r14)
je 0xae34b
pushq $0x58
popq %rdi
callq 0x56700
movq %rax, %r15
movq %rax, %rdi
callq 0x5c808
movq %r15, 0x10(%rbx)
movq %r15, %rdi
callq 0x583a0
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
movq 0x10(%r14), %rdi
cmpl 0x8(%rdi), %ebp
jge 0xae34b
movq 0x10(%rbx), %r12
movl %ebp, %esi
callq 0x5c1b6
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%rsp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x5c03a
incl %ebp
jmp 0xae31a
cmpq $0x0, 0x18(%r14)
je 0xae3a9
pushq $0x58
popq %rdi
callq 0x56700
movq %rax, %r15
movq %rax, %rdi
callq 0x5c808
movq %r15, 0x18(%rbx)
movq %r15, %rdi
callq 0x583a0
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
movq 0x18(%r14), %rdi
cmpl 0x8(%rdi), %ebp
jge 0xae3a9
movq 0x18(%rbx), %r12
movl %ebp, %esi
callq 0x5c1b6
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%rsp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x5c03a
incl %ebp
jmp 0xae378
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 0xae3c3
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r15, %rdi
callq 0x564c0
movq %rbx, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x5a180
orl $-0x1, (%r15)
movq %r14, %rdi
callq 0x56680
movl %eax, 0x4(%r15)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x56630
movl 0x4(%r15), %esi
movq 0xb3143(%rip), %rdi     # 0x161720
callq 0x972a8
movq %rax, %rdi
xorl %esi, %esi
callq 0x56280
testb %al, %al
je 0xae603
movl 0x4(%r15), %edx
movq 0xb3125(%rip), %rdi     # 0x161720
movq %r14, %rsi
callq 0x64e48
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5a588
movq %r14, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/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 0x5a180
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x57940
leaq 0x38(%rsp), %rdi
callq 0x580a0
movl %eax, %r15d
leaq 0x38(%rsp), %rdi
callq 0x5a500
leaq 0x8(%rsp), %rdi
callq 0x5a588
pushq $-0x1
popq %rbp
testb %r15b, %r15b
je 0xae8d1
leaq 0x539bb(%rip), %rsi     # 0x1021c6
movq %r14, %rdi
callq 0x58b90
movq %rax, %rdi
callq 0x59a50
testq %rax, %rax
je 0xae8d1
movq %rax, %r14
movq %r14, %rdi
callq 0x591f0
cmpl $0x1, %eax
jne 0xae8c4
movq %r14, %rdi
callq 0x57c30
cmpl $0x1, %eax
jne 0xae827
leaq 0x5397a(%rip), %rsi     # 0x1021c6
leaq 0x38(%rsp), %rdi
callq 0x5a450
pushq $0x30
popq %rdi
callq 0x56700
movq %rax, %r15
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x5a180
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x5a180
leaq 0x8(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %r15, %rdi
callq 0x578f0
movq %r15, 0x18(%rbx)
leaq 0x20(%rsp), %rdi
callq 0x5a588
leaq 0x8(%rsp), %rdi
callq 0x5a588
movb $0x1, 0x20(%rbx)
movq 0x18(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x58880
leaq 0x38(%rsp), %rdi
callq 0x57b90
xorl %ebp, %ebp
jmp 0xae8c9
movl %eax, %ebp
sarl $0x1f, %ebp
movq %r14, %rdi
callq 0x56dd0
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5a588
jmp 0xae8f0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5a588
jmp 0xae8ff
movq %rax, %rbx
pushq $0x30
popq %rsi
movq %r15, %rdi
callq 0x564c0
jmp 0xae90f
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x57b90
jmp 0xae937
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x5a500
jmp 0xae92d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x56980
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x58c40
movq %rbx, %rdi
movq %r12, %rsi
callq 0x57e10
leaq 0x8(%rsp), %rdi
callq 0x5a588
movq %r14, %rdi
callq 0x57410
testl %eax, %eax
je 0xae9f2
leaq 0x8(%rsp), %r12
leaq 0x20(%rsp), %r13
movq %r14, %rdi
callq 0x57d30
movq %r14, %rdi
cmpl $0x1, %eax
jne 0xae9ed
callq 0x56980
movq %r12, %rdi
movq %rax, %rsi
callq 0x58c40
movq %r14, %rdi
callq 0x593f0
movq %r13, %rdi
movq %rax, %rsi
callq 0x58c40
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x59460
movq %r13, %rdi
callq 0x5a588
movq %r12, %rdi
callq 0x5a588
jmp 0xae99a
callq 0x58160
movq %r14, %rdi
callq 0x57070
xorl %ebp, %ebp
testl %eax, %eax
je 0xaea11
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x591f0
pushq $-0x1
popq %rbp
cmpl $-0x1, %eax
je 0xaea00
leaq 0x8(%rsp), %r12
leaq 0x20(%rsp), %r13
movq %r14, %rdi
callq 0x57c30
cmpl $0x1, %eax
je 0xaea65
cmpl $0xf, %eax
je 0xaeabb
addl $-0x3, %eax
cmpl $0x1, %eax
ja 0xaeaa5
movq %r14, %rdi
callq 0x593f0
movq %r12, %rdi
movq %rax, %rsi
callq 0x58c40
movq %rbx, %rdi
movq %r12, %rsi
callq 0x56950
jmp 0xaea9d
movq %r12, %rdi
xorl %esi, %esi
callq 0x5a180
movq %r13, %rdi
xorl %esi, %esi
callq 0x5a180
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x56880
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x58880
movq %r13, %rdi
callq 0x5a588
movq %r12, %rdi
callq 0x5a588
movq %r14, %rdi
callq 0x591f0
cmpl $-0x1, %eax
jne 0xaea2b
jmp 0xaea00
xorl %ebp, %ebp
jmp 0xaea00
jmp 0xaead9
jmp 0xaead9
jmp 0xaead9
jmp 0xaeaca
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5a588
jmp 0xaeadc
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/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 0x57e40
pushq $-0x1
popq %rbp
testq %rax, %rax
je 0xaebe1
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x58ab0
testq %rax, %rax
je 0xaebd9
movq %rax, %r14
movq %r14, %rdi
callq 0x591f0
cmpl $0x1, %eax
jne 0xaebcc
movq %r14, %rdi
callq 0x57c30
cmpl $0x1, %eax
jne 0xaeb2e
leaq 0x53673(%rip), %rsi     # 0x1021c6
leaq 0x38(%rsp), %rdi
callq 0x5a450
pushq $0x30
popq %rdi
callq 0x56700
movq %rax, %r12
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x5a180
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x5a180
leaq 0x20(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
callq 0x578f0
movq %r12, 0x18(%r15)
leaq 0x8(%rsp), %rdi
callq 0x5a588
leaq 0x20(%rsp), %rdi
callq 0x5a588
movb $0x1, 0x20(%r15)
movq 0x18(%r15), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x58880
leaq 0x38(%rsp), %rdi
callq 0x57b90
xorl %ebp, %ebp
jmp 0xaebd1
movl %eax, %ebp
sarl $0x1f, %ebp
movq %r14, %rdi
callq 0x56dd0
movq %rbx, %rdi
callq 0x594e0
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 0x5a588
jmp 0xaec02
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5a588
jmp 0xaec11
movq %rax, %rbx
pushq $0x30
popq %rsi
movq %r12, %rdi
callq 0x564c0
jmp 0xaec21
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x57b90
movq %rbx, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x53581(%rip), %rsi     # 0x1021c6
movq %rax, %rdi
callq 0x58b90
movq %rax, %rdi
xorl %esi, %esi
callq 0x56350
movq %rax, %r14
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x5a100
movq %rbx, %rdi
callq 0x598d0
leaq 0x53ccf(%rip), %rsi     # 0x102943
movq %r14, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x58fe0
movq 0x18(%rbx), %rdx
testq %rdx, %rdx
je 0xaec95
movq %rbx, %rdi
movq %r14, %rsi
callq 0x58c00
movq %r14, %rdi
callq 0x566b0
movq %r14, %rdi
callq 0x566e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x58fd0
leaq 0x534f3(%rip), %r12     # 0x1021c6
movq %rax, %rdi
movq %r12, %rsi
callq 0x58b90
movq %rbx, %rdi
movq %rax, %rsi
callq 0x58050
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x56530
movq %r14, %rdi
cmpl %eax, %ebp
jge 0xaed46
movl %ebp, %esi
callq 0x590d0
movq %rax, %rdi
callq 0x59eb0
movq %rax, %rdi
movq %r12, %rsi
callq 0x58b90
movq %rax, %r13
movq %r14, %rdi
movl %ebp, %esi
callq 0x590d0
movq %rax, %rdi
callq 0x56780
movq %rax, %rdi
movq %r12, %rsi
callq 0x58b90
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x59260
incl %ebp
jmp 0xaeceb
callq 0x5a160
leaq 0x53474(%rip), %rsi     # 0x1021c6
movq %rax, %rdi
callq 0x58b90
movq %rbx, %rdi
movq %rax, %rsi
callq 0x585a0
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x57130
cmpl %eax, %ebp
jge 0xaed8f
movq %r14, %rdi
movl %ebp, %esi
callq 0x590b0
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x58c00
incl %ebp
jmp 0xaed67
movq %rbx, %rdi
callq 0x591d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5a180
orl $-0x1, 0x10(%r15)
movq %r14, %rdi
callq 0x56680
movl %eax, 0x14(%r15)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x56630
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movl 0x14(%r15), %esi
movq 0xb30e3(%rip), %rdi     # 0x161ed8
callq 0x972a8
movq %rax, %rdi
xorl %esi, %esi
callq 0x56280
testb %al, %al
je 0xaee1b
movl 0x14(%r15), %edx
movq 0xb30c5(%rip), %rdi     # 0x161ed8
movq %r14, %rsi
callq 0x64e48
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5a588
movq %r14, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/xml/node.cpp
// Function: smooth::XML::Node::Node(smooth::XML::Node const&)
S::XML::Node::Node(const Node &oNode)
{
	nodeID		= -1;

	nameIndex	= oNode.nameIndex;
	content		= oNode.content;

	attributes	= NIL;
	subnodes	= NIL;

	/* Copy attributes.
	 */
	if (oNode.attributes != NIL)
	{
		foreach (Attribute *oAttribute, *oNode.attributes)
		{
			Attribute	*attribute = new Attribute(*oAttribute);

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

			attribute->SetAttributeID(attributes->Add(attribute));
		}
	}

	/* Copy subnodes.
	 */
	if (oNode.subnodes != NIL)
	{
		foreach (Node *oSubnode, *oNode.subnodes)
		{
			Node	*node = new Node(*oSubnode);

			if (subnodes == NIL) subnodes = new Array<Node *, Void *>();

			node->SetNodeID(subnodes->Add(node));
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a180
orl $-0x1, 0x10(%r15)
movl 0x14(%r14), %eax
movl %eax, 0x14(%r15)
leaq 0x18(%r14), %rsi
movq %rbx, 0x8(%rsp)
movq %rbx, %rdi
callq 0x56630
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq (%r14), %rdi
testq %rdi, %rdi
je 0xaef05
xorl %r12d, %r12d
leaq 0x10(%rsp), %rbx
leal -0x1(%r12), %eax
movl 0x8(%rdi), %ecx
decl %ecx
cmpl %ecx, %eax
jge 0xaef05
movl %r12d, %esi
callq 0x6180a
movq (%rax), %r13
pushq $0x20
popq %rdi
callq 0x56700
movq %rax, %rbp
movq %rax, %rdi
movq %r13, %rsi
callq 0x579e0
movq %rbp, 0x10(%rsp)
movq (%r15), %r13
testq %r13, %r13
jne 0xaeee8
pushq $0x58
popq %rdi
callq 0x56700
movq %rax, %r13
movq %rax, %rdi
callq 0xaf43c
movq %r13, (%r15)
movq 0x10(%rsp), %rbp
movq %r13, %rdi
movq %rbx, %rsi
callq 0xaf452
movq %rbp, %rdi
movl %eax, %esi
callq 0x56890
movq (%r14), %rdi
incl %r12d
jmp 0xaee91
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xaef82
xorl %ebx, %ebx
leaq 0x10(%rsp), %rbp
leal -0x1(%rbx), %eax
movl 0x8(%rdi), %ecx
decl %ecx
cmpl %ecx, %eax
jge 0xaef82
movl %ebx, %esi
callq 0x6180a
movq (%rax), %r12
pushq $0x30
popq %rdi
callq 0x56700
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x57cb0
movq %r13, 0x10(%rsp)
movq 0x8(%r15), %r12
testq %r12, %r12
jne 0xaef6b
pushq $0x58
popq %rdi
callq 0x56700
movq %rax, %r12
movq %rax, %rdi
callq 0xaf464
movq %r12, 0x8(%r15)
movq 0x10(%rsp), %r13
movq %r12, %rdi
movq %rbp, %rsi
callq 0xaf47a
movl %eax, 0x10(%r13)
movq 0x8(%r14), %rdi
incl %ebx
jmp 0xaef15
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xaefc6
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r12, %rdi
jmp 0xaefbd
movq %rax, %rbx
pushq $0x58
jmp 0xaefac
jmp 0xaefc6
movq %rax, %rbx
pushq $0x30
popq %rsi
movq %r13, %rdi
jmp 0xaefbd
jmp 0xaefc6
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %rbp, %rdi
callq 0x564c0
jmp 0xaefc9
jmp 0xaefc6
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xaf03a
xorl %r14d, %r14d
pushq $0x20
popq %r15
leal -0x1(%r14), %eax
movl 0x8(%rdi), %ecx
decl %ecx
cmpl %ecx, %eax
jge 0xaf034
movl %r14d, %esi
callq 0x6180a
movq (%rax), %r12
testq %r12, %r12
je 0xaf021
movq %r12, %rdi
callq 0x58ba0
movq %r12, %rdi
movq %r15, %rsi
callq 0x564c0
movq (%rbx), %rdi
incl %r14d
jmp 0xaeffc
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xaf089
xorl %r14d, %r14d
pushq $0x30
popq %r15
leal -0x1(%r14), %eax
movl 0x8(%rdi), %ecx
decl %ecx
cmpl %ecx, %eax
jge 0xaf083
movl %r14d, %esi
callq 0x6180a
movq (%rax), %r12
testq %r12, %r12
je 0xaf06f
movq %r12, %rdi
callq 0x57050
movq %r12, %rdi
movq %r15, %rsi
callq 0x564c0
movq 0x8(%rbx), %rdi
incl %r14d
jmp 0xaf04a
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x18, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5a588
jmp 0xaf0a2
movq %rax, %rdi
callq 0x5bffa
// File: /workspace/github_c_makefile_star2_O2/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 0x5a060
testq %rax, %rax
je 0xaf1df
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x578b0
jmp 0xaf235
pushq $0x20
popq %rdi
callq 0x56700
movq %rax, %rbx
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x59d30
movq %rbx, (%rsp)
movq (%r14), %r15
testq %r15, %r15
jne 0xaf21a
pushq $0x58
popq %rdi
callq 0x56700
movq %rax, %r15
movq %rax, %rdi
callq 0xaf43c
movq %r15, (%r14)
movq %rsp, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0xaf452
movq %rbx, %rdi
movl %eax, %esi
callq 0x56890
movq (%r14), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
pushq $0x58
popq %rsi
movq %r15, %rdi
jmp 0xaf258
movq %rax, %r14
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x564c0
movq %r14, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/xml/node.cpp
// Function: smooth::XML::Node::RemoveAttribute(smooth::XML::Attribute*)
S::Int S::XML::Node::RemoveAttribute(Attribute *attribute)
{
	if (attribute == NIL) return Error();

	attributes->Remove(attribute->GetAttributeID());

	delete attribute;

	return Success();
}

// Assembly:
testq %rsi, %rsi
je 0xaf2a4
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %r14
movq %rsi, %rdi
callq 0x59f20
movq %r14, %rdi
movl %eax, %esi
callq 0x59f00
movq %rbx, %rdi
callq 0x58ba0
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x564c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/xml/node.cpp
// Function: smooth::XML::Node::AddNode(smooth::String const&, smooth::String const&)
S::XML::Node *S::XML::Node::AddNode(const String &iName, const String &iContent)
{
	Node	*node = new Node(iName, iContent);

	if (subnodes == NIL) subnodes = new Array<Node *, Void *>();

	node->SetNodeID(subnodes->Add(node));

	return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
pushq $0x30
popq %rdi
callq 0x56700
movq %rax, %rbx
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x578f0
movq %rbx, (%rsp)
movq 0x8(%r14), %r15
testq %r15, %r15
jne 0xaf3a0
pushq $0x58
popq %rdi
callq 0x56700
movq %rax, %r15
movq %rax, %rdi
callq 0xaf464
movq %r15, 0x8(%r14)
movq %rsp, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0xaf47a
movl %eax, 0x10(%rbx)
movq (%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
pushq $0x58
popq %rsi
movq %r15, %rdi
jmp 0xaf3d4
movq %rax, %r14
pushq $0x30
popq %rsi
movq %rbx, %rdi
callq 0x564c0
movq %r14, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/xml/node.cpp
// Function: smooth::XML::Node::RemoveNode(smooth::XML::Node*)
S::Int S::XML::Node::RemoveNode(Node *node)
{
	if (node == NIL) return Error();

	subnodes->Remove(node->GetNodeID());

	delete node;

	return Success();
}

// Assembly:
testq %rsi, %rsi
je 0xaf40e
pushq %rbx
movq %rsi, %rbx
movq 0x8(%rdi), %rdi
movl 0x10(%rsi), %esi
callq 0x59f00
movq %rbx, %rdi
callq 0x57050
pushq $0x30
popq %rsi
movq %rbx, %rdi
callq 0x564c0
xorl %eax, %eax
popq %rbx
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/xml/xul/button.cpp
// Function: smooth::XML::XUL::Button::Button(smooth::XML::Node*)
S::XML::XUL::Button::Button(Node *node) : Widget(node)
{
	button = NIL;

	defaultWidth = 80;
	defaultHeight = 22;

	if (node != NIL)
	{
		button = new GUI::Button(GetXMLAttributeValue(node, "label"), GUI::Point(0, 0), GUI::Size(0, 0));

		if (GetXMLAttributeValue(node, "disabled") == "true") button->Deactivate();
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x58bf0
leaq 0xafbfc(%rip), %rax     # 0x15f5f0
movq %rax, (%rbx)
andq $0x0, 0x80(%rbx)
movabsq $0x1600000050, %rax     # imm = 0x1600000050
movq %rax, 0x48(%rbx)
testq %r14, %r14
je 0xafae2
movl $0x5c8, %edi            # imm = 0x5C8
callq 0x56700
movq %rax, %r15
leaq 0x52f78(%rip), %rsi     # 0x1029a2
leaq 0x8(%rsp), %rdi
callq 0x58c40
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rcx
movq %rbx, %rsi
movq %r14, %rdx
callq 0x57590
leaq 0x40(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x38(%rsp), %rcx
andq $0x0, (%rcx)
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x585b0
movq %r15, 0x80(%rbx)
leaq 0x20(%rsp), %rdi
callq 0x5a588
leaq 0x8(%rsp), %rdi
callq 0x5a588
leaq 0x52f68(%rip), %rsi     # 0x1029f2
leaq 0x8(%rsp), %rdi
callq 0x58c40
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rcx
movq %rbx, %rsi
movq %r14, %rdx
callq 0x57590
leaq 0x52c22(%rip), %rsi     # 0x1026d2
leaq 0x20(%rsp), %rdi
callq 0x59180
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
callq 0x5a588
leaq 0x8(%rsp), %rdi
callq 0x5a588
testb %bpl, %bpl
je 0xafae2
movq 0x80(%rbx), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x5a588
jmp 0xafaff
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5a588
jmp 0xafb40
jmp 0xafb3d
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x5a588
jmp 0xafb1f
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5a588
jmp 0xafb2e
movq %rax, %r14
movl $0x5c8, %esi            # imm = 0x5C8
movq %r15, %rdi
callq 0x564c0
jmp 0xafb40
movq %rax, %r14
movq %rbx, %rdi
callq 0x5a3a0
movq %r14, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/xml/xul/renderer.cpp
// Function: smooth::XML::XUL::Renderer::LoadXUL(smooth::String const&)
S::Int S::XML::XUL::Renderer::LoadXUL(const String &fileName)
{
	CloseXUL();

	Int		 rVal	= Error();
	Document	*xul	= new Document();

	xul->LoadFile(fileName);

	if (xul->GetRootNode() != NIL) rVal = RenderXUL(xul);

	delete xul;

	return rVal;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
callq 0x57a50
pushq $0x28
popq %rdi
callq 0x56700
movq %rax, %rbx
movq %rax, %rdi
callq 0x58e60
movq %rbx, %rdi
movq %r15, %rsi
callq 0x56560
movq %rbx, %rdi
callq 0x58010
testq %rax, %rax
je 0xb0576
movq %r14, %rdi
movq %rbx, %rsi
callq 0x595e0
movl %eax, %ebp
jmp 0xb0579
pushq $-0x1
popq %rbp
movq %rbx, %rdi
callq 0x56440
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x564c0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x564c0
movq %r14, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/xml/xul/widget.cpp
// Function: smooth::XML::XUL::Widget::GetXMLAttributeValue(smooth::XML::Node*, smooth::String const&) const
S::String S::XML::XUL::Widget::GetXMLAttributeValue(Node *node, const String &attribute) const
{
	if (node != NIL)
	{
		if (node->GetAttributeByName(attribute) != NIL)
		{
			return node->GetAttributeByName(attribute)->GetContent();
		}
	}

	return NIL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdx, %rdx
je 0xb0ea1
movq %rcx, %r14
movq %rdx, %r15
movq %rdx, %rdi
movq %rcx, %rsi
callq 0x5a060
testq %rax, %rax
je 0xb0ea1
movq %r15, %rdi
movq %r14, %rsi
callq 0x5a060
movq %rax, %rdi
callq 0x56780
movq %rbx, %rdi
movq %rax, %rsi
callq 0x58280
jmp 0xb0eab
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a180
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/xml/xul/window.cpp
// Function: smooth::XML::XUL::Window::~Window()
S::XML::XUL::Window::~Window()
{
	for (Int i = 0; i < widgets.Length(); i++) delete widgets.GetNth(i);

	widgets.RemoveAll();

	if (titlebar != NIL)	Object::DeleteObject(titlebar);
	if (window != NIL)	Object::DeleteObject(window);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xae34a(%rip), %rax     # 0x15f838
movq %rax, (%rdi)
leaq 0x90(%rdi), %r14
xorl %ebp, %ebp
cmpl 0x98(%rbx), %ebp
jge 0xb151e
movq %r14, %rdi
movl %ebp, %esi
callq 0x5c1b6
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb151a
movq (%rdi), %rax
callq *0x8(%rax)
incl %ebp
jmp 0xb14fa
movq %r14, %rdi
callq 0x5bef6
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0xb1537
callq 0x5a010
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0xb1548
callq 0x5a010
movq %r14, %rdi
callq 0x5c22c
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5a3a0
jmp 0xb155e
movq %rax, %rdi
callq 0x5bffa
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/codecs.cpp
// Function: PCIIO::CompressPCI(smooth::IO::OutStream*)
Bool PCIIO::CompressPCI(PCIOut out)
{
	IO::FilterBZip2	*filter = NULL;

	palentries   = 0;
	bits	     = 0;
	bitssaa	     = 0;
	bitsnrle     = 0;
	bitssaanrle  = 0;

	previousLine = new Int [sizex];

	for (Int x = 0; x < sizex; x++) previousLine[x] = 0;
	for (Int x = 0; x < 338;   x++) palette[x]	= 0;

	if (compression == BZIP2)
	{
		filter = new IO::FilterBZip2();

		out->SetFilter(filter);
	}

	for (Int y = 0; y < sizey; y++) WriteLine(out, y);

	if (compression == BZIP2)
	{
		out->RemoveFilter();

		delete filter;
	}

	delete [] previousLine;

	return True;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
andl $0x0, 0xbb499(%rip)     # 0x16ca30
andl $0x0, 0xbb496(%rip)     # 0x16ca34
andl $0x0, 0xbb493(%rip)     # 0x16ca38
andl $0x0, 0xbb490(%rip)     # 0x16ca3c
andl $0x0, 0xbb48d(%rip)     # 0x16ca40
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x10(%rdi), %r15
leaq (,%r15,4), %rax
testq %r15, %r15
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x577a0
movq %rax, 0xbae35(%rip)     # 0x16c410
xorl %ecx, %ecx
testl %r15d, %r15d
movl $0x0, %edx
cmovgl %r15d, %edx
cmpq %rcx, %rdx
je 0xb15f7
andl $0x0, (%rax,%rcx,4)
incq %rcx
jmp 0xb15e9
xorl %eax, %eax
leaq 0xbae20(%rip), %rcx     # 0x16c420
cmpq $0x548, %rax            # imm = 0x548
je 0xb1612
andl $0x0, (%rax,%rcx)
addq $0x4, %rax
jmp 0xb1600
xorl %r12d, %r12d
cmpl $0x4, 0x50(%r14)
jne 0xb163d
pushq $0x18
popq %rdi
callq 0x56700
movq %rax, %r15
movq %rax, %rdi
callq 0x5a370
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x10(%rax)
jmp 0xb1653
xorl %r15d, %r15d
jmp 0xb1653
movq %r14, %rdi
movq %rbx, %rsi
movl %r12d, %edx
callq 0xb16ac
incl %r12d
cmpl 0x14(%r14), %r12d
jl 0xb1642
cmpl $0x4, 0x50(%r14)
jne 0xb1677
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
testq %r15, %r15
je 0xb1677
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq 0xbad92(%rip), %rdi     # 0x16c410
testq %rdi, %rdi
je 0xb1688
callq 0x572d0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x18
popq %rsi
movq %r15, %rdi
callq 0x564c0
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/codecs.cpp
// Function: PCIIO::DecompressPCI(smooth::IO::InStream*)
Bool PCIIO::DecompressPCI(PCIIn in)
{
	IO::FilterBZip2	*filter = NULL;

	palentries   = 0;
	bits	     = 0;
	bitssaa	     = 0;
	bitsnrle     = 0;
	bitssaanrle  = 0;

	previousLine = new Int [sizex];

	for (Int x = 0; x < sizex; x++) previousLine[x] = 0;
	for (Int x = 0; x < 338;   x++) palette[x]  = 0;

	if (compression == BZIP2)
	{
		filter = new IO::FilterBZip2();

		in->SetFilter(filter);
	}

	for (Int y = 0; y < sizey; y++) ReadLine(in, y);

	if (compression == BZIP2)
	{
		in->RemoveFilter();

		delete filter;
	}

	delete [] previousLine;

	return True;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
andl $0x0, 0xbabeb(%rip)     # 0x16ca30
andl $0x0, 0xbabe8(%rip)     # 0x16ca34
andl $0x0, 0xbabe5(%rip)     # 0x16ca38
andl $0x0, 0xbabe2(%rip)     # 0x16ca3c
andl $0x0, 0xbabdf(%rip)     # 0x16ca40
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x10(%rdi), %r15
leaq (,%r15,4), %rax
testq %r15, %r15
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x577a0
movq %rax, 0xba587(%rip)     # 0x16c410
xorl %ecx, %ecx
testl %r15d, %r15d
movl $0x0, %edx
cmovgl %r15d, %edx
cmpq %rcx, %rdx
je 0xb1ea5
andl $0x0, (%rax,%rcx,4)
incq %rcx
jmp 0xb1e97
xorl %eax, %eax
leaq 0xba572(%rip), %rcx     # 0x16c420
cmpq $0x548, %rax            # imm = 0x548
je 0xb1ec0
andl $0x0, (%rax,%rcx)
addq $0x4, %rax
jmp 0xb1eae
xorl %r12d, %r12d
cmpl $0x4, 0x50(%r14)
jne 0xb1eeb
pushq $0x18
popq %rdi
callq 0x56700
movq %rax, %r15
movq %rax, %rdi
callq 0x5a370
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x10(%rax)
jmp 0xb1f01
xorl %r15d, %r15d
jmp 0xb1f01
movq %r14, %rdi
movq %rbx, %rsi
movl %r12d, %edx
callq 0xb1f5a
incl %r12d
cmpl 0x14(%r14), %r12d
jl 0xb1ef0
cmpl $0x4, 0x50(%r14)
jne 0xb1f25
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
testq %r15, %r15
je 0xb1f25
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq 0xba4e4(%rip), %rdi     # 0x16c410
testq %rdi, %rdi
je 0xb1f36
callq 0x572d0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x18
popq %rsi
movq %r15, %rdi
callq 0x564c0
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/codecs.cpp
// Function: GetRLE(int*, int, int, int)
int GetRLE(int line[], int sx, int x, int maxbits)
{
	if (x == sx - 1) return 0;

	int	 rle = 0;

	for (int i = x + 1; i < x + Math::Pow(2l, maxbits); i++)
	{
		if (line[i] == line[x]) rle++;
		else			break;

		if (i == sx - 1) break;
	}

	return rle;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0x4(%rsp)
leal -0x1(%rsi), %eax
xorl %r12d, %r12d
cmpl %edx, %eax
je 0xb2531
movl %edx, %r14d
movq %rdi, %r15
cvtsi2sd %edx, %xmm0
movsd %xmm0, 0x8(%rsp)
movslq %edx, %r13
movl %edx, %ebp
notl %ebp
addl %esi, %ebp
incl %r14d
leaq (%rdi,%r13,4), %rbx
addq $0x4, %rbx
xorl %r12d, %r12d
leal (%r14,%r12), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%rsp)
pushq $0x2
popq %rdi
movl 0x4(%rsp), %esi
callq 0x570f0
addsd 0x8(%rsp), %xmm0
ucomisd 0x10(%rsp), %xmm0
jbe 0xb2531
movl (%rbx,%r12,4), %eax
cmpl (%r15,%r13,4), %eax
jne 0xb2531
incq %r12
cmpl %r12d, %ebp
jne 0xb24f7
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/codecs.cpp
// Function: RotatePaletteEntry(int)
int RotatePaletteEntry(int entry)
{
	Int	 col = palette[entry];

	for (Int x = entry; x < palentries - 1; x++) palette[x] = palette[x + 1];

	palette[palentries - 1] = col;

	return 1;
}

// Assembly:
movslq %edi, %rdx
leaq 0xb8ed5(%rip), %rax     # 0x16c420
movl (%rax,%rdx,4), %ecx
movslq 0xb94db(%rip), %rsi     # 0x16ca30
leaq -0x1(%rsi), %rdi
cmpq %rdi, %rdx
jge 0xb356c
movl 0x4(%rax,%rdx,4), %r8d
movl %r8d, (%rax,%rdx,4)
incq %rdx
jmp 0xb3559
movl %ecx, -0x4(%rax,%rsi,4)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/codecs.cpp
// Function: GetVRLE(int*, int*, int, int, int)
int GetVRLE(int line[], int prevline[], int sx, int x, int maxbits)
{
	if (x == sx - 1) return 0;

	int	 rle = 0;

	for (int i = x + 1; i < x + Math::Pow(2l, maxbits); i++)
	{
		if (line[i] == prevline[i]) rle++;
		else			    break;

		if (i == sx - 1) break;
	}

	return rle;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r15d
leal -0x1(%r15), %eax
xorl %r14d, %r14d
cmpl %ecx, %eax
je 0xb35ee
movl %r8d, %ebx
movl %ecx, %ebp
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x8(%rsp)
movslq %ecx, %rax
incl %ebp
leaq (%rdi,%rax,4), %r13
addq $0x4, %r13
leaq (%rsi,%rax,4), %r12
addq $0x4, %r12
xorl %r14d, %r14d
cvtsi2sd %ebp, %xmm0
movsd %xmm0, 0x10(%rsp)
pushq $0x2
popq %rdi
movl %ebx, %esi
callq 0x570f0
addsd 0x8(%rsp), %xmm0
ucomisd 0x10(%rsp), %xmm0
jbe 0xb35ee
movl (%r13,%r14,4), %eax
cmpl (%r12,%r14,4), %eax
jne 0xb35ee
incq %r14
incl %ebp
cmpl %ebp, %r15d
jne 0xb35b7
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/init.cpp
// Function: smooth::AddInitFunction(int (*)())
S::Int S::AddInitFunction(Int (*initFunction)())
{
	if (initFunction == NIL) return Error();

	if (initFunctions == NIL) initFunctions = new Array<Int (*)(), Void *>;

	initFunctions->Add(initFunction);

	return Success();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
testq %rdi, %rdi
je 0xb399a
movq 0xb913c(%rip), %rbx     # 0x16caa8
testq %rbx, %rbx
jne 0xb398b
pushq $0x58
popq %rdi
callq 0x56700
movq %rax, %rbx
movq %rax, %rdi
callq 0xb3c56
movq %rbx, 0xb911d(%rip)     # 0x16caa8
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5c03a
xorl %eax, %eax
jmp 0xb399d
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
pushq $0x58
popq %rsi
movq %rbx, %rdi
callq 0x564c0
movq %r14, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/init.cpp
// Function: smooth::AddFreeFunction(int (*)())
S::Int S::AddFreeFunction(Int (*freeFunction)())
{
	if (freeFunction == NIL) return Error();

	if (freeFunctions == NIL) freeFunctions = new Array<Int (*)(), Void *>;

	freeFunctions->Add(freeFunction);

	return Success();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
testq %rdi, %rdi
je 0xb39fd
movq 0xb90e1(%rip), %rbx     # 0x16cab0
testq %rbx, %rbx
jne 0xb39ee
pushq $0x58
popq %rdi
callq 0x56700
movq %rax, %rbx
movq %rax, %rdi
callq 0xb3c56
movq %rbx, 0xb90c2(%rip)     # 0x16cab0
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5c03a
xorl %eax, %eax
jmp 0xb3a00
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
pushq $0x58
popq %rsi
movq %rbx, %rdi
callq 0x564c0
movq %r14, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/init.cpp
// Function: smooth::Init()
S::Bool S::Init()
{
	if (initCount++) return True;

	/* Init system backends.
	 */
	if (Backends::Backend::InitBackends() == Error()) return False;

	/* Call registered init functions.
	 */
	foreach (Int (*initFunction)(), (*initFunctions))
	{
		if (initFunction() != Success())
		{
			/* Deinit system backends.
			 */
			Backends::Backend::DeinitBackends();

			return False;
		}
	}

#if defined __WIN32__
	if (hDllInstance == NIL) hDllInstance = hInstance;

	SMOOTHICON = (HICON) LoadImage(hDllInstance, MAKEINTRESOURCE(IDI_ICON), IMAGE_ICON, 0, 0, LR_DEFAULTSIZE | LR_LOADMAP3DCOLORS | LR_SHARED);

	if (LoadIconvDLL() == True) Setup::useIconv = True;

	use_iconv = (Setup::useIconv ? 1 : 0);
#endif

	/* Init internationalization system.
	 */
	I18n::Translator::defaultTranslator = new I18n::TranslatorInternal();
	I18n::Translator::defaultTranslator->SelectUserDefaultLanguage();

	Setup::rightToLeft = I18n::Translator::defaultTranslator->IsActiveLanguageRightToLeft();

	/* Finished initializing.
	 */
	initializing = False;

	/* Start waiting threads.
	 */
	for (Int i = 0; i < Object::GetNOfObjects(); i++)
	{
		Object	*object = Object::GetNthObject(i);

		if (object == NIL) continue;

		if (object->GetObjectType() == Threads::Thread::classID &&
		    ((Threads::Thread *) object)->GetStatus() == Threads::THREAD_STARTME) ((Threads::Thread *) object)->Start();
	}

	return True;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0xb9075(%rip), %eax     # 0x16caa0
leal 0x1(%rax), %ecx
movl %ecx, 0xb906c(%rip)     # 0x16caa0
movb $0x1, %bl
testl %eax, %eax
jne 0xb3a8c
callq 0x5bb60
xorl %ecx, %ecx
cmpl $-0x1, %eax
je 0xb3a8a
pushq $-0x1
popq %r14
movl %r14d, %ebp
testl %ecx, %ecx
jne 0xb3a99
movq 0xb9050(%rip), %rdi     # 0x16caa8
movl 0x8(%rdi), %eax
decl %eax
cmpl %eax, %ebp
jge 0xb3a99
incl %ebp
movl %ebp, %esi
callq 0x6180a
movq (%rax), %r15
movb $0x1, %dl
movl %r14d, %ecx
testb $0x1, %dl
je 0xb3a4d
callq *%r15
xorl %edx, %edx
movl $0x0, %ecx
testl %eax, %eax
je 0xb3a72
callq 0x5bc58
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x80, %edi
callq 0x56700
movq %rax, %r14
movq %rax, %rdi
callq 0x994dc
movq 0xad933(%rip), %r15     # 0x1613e8
movq %r14, (%r15)
movq %r14, %rdi
callq 0x58630
movq (%r15), %rdi
callq 0x564d0
movq 0xae011(%rip), %rcx     # 0x161ae0
movb %al, (%rcx)
movb $0x0, 0xb0990(%rip)     # 0x164468
movq 0xadf51(%rip), %rax     # 0x161a30
xorl %ebp, %ebp
movswl (%rax), %r14d
callq 0x587f0
cmpl %eax, %ebp
jge 0xb3a8c
movl %ebp, %edi
callq 0x59b10
testq %rax, %rax
je 0xb3b23
movq %rax, %r15
leaq 0x20(%rax), %rdi
movl %r14d, %esi
callq 0x58720
testb %al, %al
je 0xb3b23
movq %r15, %rdi
callq 0x578e0
cmpw $0x3, %ax
jne 0xb3b23
movq %r15, %rdi
callq 0x58e80
incl %ebp
jmp 0xb3ae5
movq %rax, %rbx
movl $0x80, %esi
movq %r14, %rdi
callq 0x564c0
movq %rbx, %rdi
callq 0x58260