LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xb8d72(%rip), %r14     # 0x16c7d8
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_O1/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 0xb8d44(%rip), %r14     # 0x16c7d8
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_O1/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 0xb8d13(%rip), %r15     # 0x16c7d8
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_O1/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 0xb8ce4(%rip), %r14     # 0x16c7d8
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_O1/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 0xb8cba(%rip), %r14     # 0x16c7d8
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_O1/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 0xb8c8e(%rip), %r14     # 0x16c7d8
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_O1/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 0xb8c5f(%rip), %r15     # 0x16c7d8
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_O1/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)
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)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xb3c6a
movq %rax, %r14
movl $0x8, %esi
movq %rbx, %rdi
callq 0x55480
movq %r14, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/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 0xb3cd3
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 0xb3ce0
movq %rax, %r14
movl $0x8, %esi
movq %rbx, %rdi
callq 0x55480
movq %r14, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/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 0xb3fe9
movq %rsi, %r14
xorl %edi, %edi
callq 0xb4654
movq %rax, 0x38(%rbx)
movq 0xb8a69(%rip), %rax     # 0x16ca30
movzwl (%rax), %eax
movw %ax, 0x20(%rbx)
movw $0x0, 0x34(%rbx)
leaq 0x40(%r14), %rsi
leaq 0x40(%rbx), %rdi
callq 0xb4318
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_O1/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     # 0x16ca90
addq $0x10, %rax
movq %rax, (%rdi)
movzwl 0x34(%rdi), %eax
cmpl $0x3, %eax
je 0xb4013
testl %eax, %eax
jne 0xb4019
movw $0x2, 0x34(%rbx)
cmpw $0x2, 0x34(%rbx)
je 0xb403c
movw $0x2, 0x34(%rbx)
movq 0xb866b(%rip), %rdi     # 0x16c698
callq 0x564d0
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xb404b
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x40(%rbx), %rdi
leaq 0xb633a(%rip), %rax     # 0x16a390
movq %rax, 0x40(%rbx)
callq 0xb4226
movq %rbx, %rdi
popq %rbx
jmp 0x55c60
jmp 0xb406a
movq %rax, %rdi
callq 0x5aede
// File: /workspace/github_c_makefile_star2_O1/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 0xb40de
testl %ecx, %ecx
jne 0xb4124
leaq 0xbb1c3(%rip), %rdx     # 0x16f2a8
cmpb $0x0, (%rdx)
je 0xb40fc
testw %cx, %cx
jne 0xb4124
cmpb $0x1, (%rdx)
jne 0xb4124
movw $0x3, 0x34(%rbx)
jmp 0xb4122
movq 0xb8595(%rip), %rdi     # 0x16c698
callq 0x55f70
movw $0x1, 0x34(%rbx)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movq 0xb8e2c(%rip), %rsi     # 0x16cf48
movq %rbx, %rdx
callq *0x10(%rax)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb81f8(%rip), %rdi     # 0x16c330
callq 0x566e0
movq %r14, 0x28(%rax)
leaq 0x40(%rbx), %rdi
movq %rbx, %rsi
callq 0xb4478
movl $0x1, %edi
callq 0x58440
movw $0x2, 0x34(%rbx)
movq 0xb8531(%rip), %rdi     # 0x16c698
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_O1/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 0xb444d
movq %rsi, %r14
movq %rbx, %rdi
callq 0xb4226
cmpq $0x0, 0x10(%r14)
je 0xb43c0
movl $0x58, %edi
callq 0x556b0
movq %rax, %r15
movq %rax, %rdi
callq 0x55d90
leaq 0xac482(%rip), %rax     # 0x1607e0
movq %rax, 0x40(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r15)
leaq 0xac58f(%rip), %rax     # 0x160900
movq %rax, (%r15)
movq %r15, 0x10(%rbx)
movq %r15, %rdi
callq 0x571b0
movq 0x10(%r14), %rdi
cmpl $0x0, 0x8(%rdi)
jle 0xb43c0
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
movq 0x10(%rbx), %r12
movl %ebp, %esi
callq 0x5b0a4
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%rsp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x5af08
incl %ebp
movq 0x10(%r14), %rdi
cmpl 0x8(%rdi), %ebp
jl 0xb4391
cmpq $0x0, 0x18(%r14)
je 0xb4445
movl $0x58, %edi
callq 0x556b0
movq %rax, %r15
movq %rax, %rdi
callq 0x55d90
leaq 0xac3fd(%rip), %rax     # 0x1607e0
movq %rax, 0x40(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r15)
leaq 0xac50a(%rip), %rax     # 0x160900
movq %rax, (%r15)
movq %r15, 0x18(%rbx)
movq %r15, %rdi
callq 0x571b0
movq 0x18(%r14), %rdi
cmpl $0x0, 0x8(%rdi)
jle 0xb4445
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
movq 0x18(%rbx), %r12
movl %ebp, %esi
callq 0x5b0a4
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%rsp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x5af08
incl %ebp
movq 0x18(%r14), %rdi
cmpl 0x8(%rdi), %ebp
jl 0xb4416
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 0xb445f
movq %rax, %rbx
movl $0x58, %esi
movq %r15, %rdi
callq 0x55480
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xb8044(%rip), %rdi     # 0x16c720
callq 0x9bb08
movq %rax, %rdi
xorl %esi, %esi
callq 0x55260
testb %al, %al
je 0xb4702
movl 0x4(%r15), %edx
movq 0xb8026(%rip), %rdi     # 0x16c720
movq %r14, %rsi
callq 0x642ea
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_O1/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 0xb49d9
leaq 0x5e811(%rip), %rsi     # 0x113126
movq %r14, %rdi
callq 0x57940
movq %rax, %rdi
callq 0x58760
testq %rax, %rax
je 0xb49d9
movq %rax, %r14
movq %r14, %rdi
callq 0x57f60
movl %eax, %ebp
cmpl $0x1, %eax
jne 0xb49ce
movq %r14, %rdi
callq 0x56ac0
cmpl $0x1, %eax
jne 0xb4931
leaq 0x5e7ce(%rip), %rsi     # 0x113126
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
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 0xb49f8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
jmp 0xb4a07
movq %rax, %rbx
movl $0x30, %esi
movq %r15, %rdi
callq 0x55480
jmp 0xb4a19
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x56a30
jmp 0xb4a41
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x59178
jmp 0xb4a37
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xb4b0a
movq %r14, %rdi
callq 0x56bc0
cmpl $0x1, %eax
jne 0xb4b02
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 0xb4ab1
movq %r14, %rdi
callq 0x56fb0
movq %r14, %rdi
callq 0x55fa0
xorl %ebp, %ebp
testl %eax, %eax
je 0xb4b29
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 0xb4b18
leaq 0x8(%rsp), %r12
leaq 0x20(%rsp), %r13
movq %r14, %rdi
callq 0x56ac0
cmpl $0x1, %eax
je 0xb4b7f
cmpl $0xf, %eax
je 0xb4bd5
addl $-0x3, %eax
cmpl $0x1, %eax
ja 0xb4bbf
movq %r14, %rdi
callq 0x58160
movq %r12, %rdi
movq %rax, %rsi
callq 0x579f0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x558f0
jmp 0xb4bb7
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 0xb4b45
jmp 0xb4b18
xorl %ebp, %ebp
jmp 0xb4b18
jmp 0xb4bf3
jmp 0xb4bf3
jmp 0xb4bf3
jmp 0xb4be4
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x59200
jmp 0xb4bf6
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r15
movq %rsi, %rdi
movl %edx, %esi
xorl %edx, %edx
callq 0x56cc0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0xb4d06
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
callq 0x57870
testq %rax, %rax
je 0xb4cfe
movq %rax, %r12
movq %r12, %rdi
callq 0x57f60
movl %eax, %ebx
cmpl $0x1, %eax
jne 0xb4ce9
movq %r12, %rdi
callq 0x56ac0
cmpl $0x1, %eax
jne 0xb4c4b
leaq 0x5e4b4(%rip), %rsi     # 0x113126
leaq 0x38(%rsp), %rdi
callq 0x590d0
movl $0x30, %edi
callq 0x556b0
movq %rax, %r13
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 %r13, %rdi
callq 0x567b0
movq %r13, 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 %r12, %rsi
callq 0x57660
leaq 0x38(%rsp), %rdi
callq 0x56a30
movq %r12, %rdi
callq 0x55d20
movq %r14, %rdi
callq 0x58230
sarl $0x1f, %ebx
jmp 0xb4d06
movq %r14, %rdi
callq 0x58230
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
jmp 0xb4d28
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x59200
jmp 0xb4d37
movq %rax, %rbx
movl $0x30, %esi
movq %r13, %rdi
callq 0x55480
jmp 0xb4d49
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x56a30
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x5e3b9(%rip), %rsi     # 0x113126
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 0x5eaf0(%rip), %rsi     # 0x11388e
movq %r14, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x57d60
movq 0x18(%rbx), %rdx
testq %rdx, %rdx
je 0xb4dbf
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_O1/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 0x5e329(%rip), %rsi     # 0x113126
movq %rax, %rdi
callq 0x57940
movq %rbx, %rdi
movq %rax, %rsi
callq 0x56ea0
movq %r14, %rdi
callq 0x554f0
testl %eax, %eax
jle 0xb4e7e
xorl %ebp, %ebp
leaq 0x5e301(%rip), %r12     # 0x113126
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 0xb4e25
movq %r14, %rdi
callq 0x58e00
leaq 0x5e299(%rip), %rsi     # 0x113126
movq %rax, %rdi
callq 0x57940
movq %rbx, %rdi
movq %rax, %rsi
callq 0x573a0
movq %r14, %rdi
callq 0x56050
testl %eax, %eax
jle 0xb4ed4
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 0xb4eae
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_O1/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 0xb7f98(%rip), %rdi     # 0x16ced8
callq 0x9bb08
movq %rax, %rdi
xorl %esi, %esi
callq 0x55260
testb %al, %al
je 0xb4f66
movl 0x14(%r15), %edx
movq 0xb7f7a(%rip), %rdi     # 0x16ced8
movq %r14, %rsi
callq 0x642ea
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_O1/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
cmpq $0x0, (%rdi)
je 0xb51e9
movq (%rbx), %rdi
cmpl $0x0, 0x8(%rdi)
jle 0xb51db
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
incl %ebp
movl %ebp, %esi
callq 0x60a40
movq (%rax), %r14
testq %r14, %r14
je 0xb51cf
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 0xb51a9
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xb51e9
movq (%rdi), %rax
callq *0x8(%rax)
cmpq $0x0, 0x8(%rbx)
je 0xb5241
movq 0x8(%rbx), %rdi
cmpl $0x0, 0x8(%rdi)
jle 0xb5232
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
incl %ebp
movl %ebp, %esi
callq 0x60a40
movq (%rax), %r14
testq %r14, %r14
je 0xb5225
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 0xb51ff
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xb5241
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x18, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x59200
jmp 0xb5253
movq %rax, %rdi
callq 0x5aede
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/xml/node.cpp
// Function: smooth::XML::Node::GetAttributeByName(smooth::String const&) const
S::XML::Attribute *S::XML::Node::GetAttributeByName(const String &attributeName) const
{
	Int	 nOfAttributes = GetNOfAttributes();

	if (nOfAttributes == 0) return NIL;

	Int	 nameIndex     = attributeName.ComputeCRC32();

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

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

	return NIL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xb5321
movl 0x8(%rax), %r12d
jmp 0xb5324
xorl %r12d, %r12d
testl %r12d, %r12d
je 0xb535a
movq %rsi, %rdi
callq 0x55640
testl %r12d, %r12d
jle 0xb535a
movl %eax, %ebp
xorl %r15d, %r15d
movq (%rbx), %rdi
movl %r15d, %esi
callq 0x5b0a4
movq (%rax), %rax
cmpl %ebp, 0x4(%rax)
cmoveq %rax, %r14
je 0xb535d
incl %r15d
cmpl %r15d, %r12d
jne 0xb533b
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xb5395
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x56770
jmp 0xb5403
movl $0x20, %edi
callq 0x556b0
movq %rax, %rbx
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x58a00
cmpq $0x0, (%r14)
jne 0xb53eb
movl $0x58, %edi
callq 0x556b0
movq %rax, %r15
movq %rax, %rdi
callq 0x55d90
leaq 0xab40e(%rip), %rax     # 0x1607e0
movq %rax, 0x40(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r15)
leaq 0xb50bb(%rip), %rax     # 0x16a4a0
movq %rax, (%r15)
movq %r15, (%r14)
movq (%r14), %rdi
movq %rsp, %rsi
movq %rbx, (%rsi)
callq 0x5af08
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 0xb542a
movq %rax, %r14
movl $0x20, %esi
movq %rbx, %rdi
callq 0x55480
movq %r14, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/xml/node.cpp
// Function: smooth::XML::Node::GetNodeByName(smooth::String const&) const
S::XML::Node *S::XML::Node::GetNodeByName(const String &nodeName) const
{
	Int	 nOfNodes  = GetNOfNodes();

	if (nOfNodes == 0) return NIL;

	Int	 nameIndex = nodeName.ComputeCRC32();

	for (Int i = 0; i < nOfNodes; i++)
	{
		Node	*node = GetNthNode(i);

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

	return NIL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0xb54e4
movl 0x8(%rax), %r12d
jmp 0xb54e7
xorl %r12d, %r12d
testl %r12d, %r12d
je 0xb551e
movq %rsi, %rdi
callq 0x55640
testl %r12d, %r12d
jle 0xb551e
movl %eax, %ebp
xorl %r15d, %r15d
movq 0x8(%rbx), %rdi
movl %r15d, %esi
callq 0x5b0a4
movq (%rax), %rax
cmpl %ebp, 0x14(%rax)
cmoveq %rax, %r14
je 0xb5521
incl %r15d
cmpl %r15d, %r12d
jne 0xb54fe
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x30, %edi
callq 0x556b0
movq %rax, %rbx
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x567b0
cmpq $0x0, 0x8(%r14)
jne 0xb5597
movl $0x58, %edi
callq 0x556b0
movq %rax, %r15
movq %rax, %rdi
callq 0x55d90
leaq 0xab263(%rip), %rax     # 0x1607e0
movq %rax, 0x40(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r15)
leaq 0xb4f60(%rip), %rax     # 0x16a4f0
movq %rax, (%r15)
movq %r15, 0x8(%r14)
movq 0x8(%r14), %rdi
movq %rsp, %rsi
movq %rbx, (%rsi)
callq 0x5af08
movl %eax, 0x10(%rbx)
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 0xb55d0
movq %rax, %r14
movl $0x30, %esi
movq %rbx, %rdi
callq 0x55480
movq %r14, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xb560c
pushq %rbx
movq %rsi, %rbx
movq 0x8(%rdi), %rdi
movl 0x10(%rsi), %esi
callq 0x58bb0
movq %rbx, %rdi
callq 0x55f80
movl $0x30, %esi
movq %rbx, %rdi
callq 0x55480
xorl %eax, %eax
popq %rbx
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x579a0
leaq 0xb49d4(%rip), %rax     # 0x16a5d0
movq %rax, (%rbx)
movq $0x0, 0x80(%rbx)
movabsq $0x1600000050, %rax     # imm = 0x1600000050
movq %rax, 0x48(%rbx)
testq %r14, %r14
je 0xb5ced
movl $0x5c8, %edi            # imm = 0x5C8
callq 0x556b0
movq %rax, %r15
leaq 0x5dcb8(%rip), %rsi     # 0x1138ed
leaq 0x8(%rsp), %rdi
callq 0x579f0
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rcx
movq %rbx, %rsi
movq %r14, %rdx
callq 0x56490
xorl %eax, %eax
leaq 0x40(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x38(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x573b0
movq %r15, 0x80(%rbx)
leaq 0x20(%rsp), %rdi
callq 0x59200
leaq 0x8(%rsp), %rdi
callq 0x59200
leaq 0x5dca8(%rip), %rsi     # 0x11393d
leaq 0x8(%rsp), %rdi
callq 0x579f0
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rcx
movq %rbx, %rsi
movq %r14, %rdx
callq 0x56490
leaq 0x5d962(%rip), %rsi     # 0x11361d
leaq 0x20(%rsp), %rdi
callq 0x57ef0
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
callq 0x59200
leaq 0x8(%rsp), %rdi
callq 0x59200
testb %bpl, %bpl
je 0xb5ced
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 0x59200
jmp 0xb5d0a
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x59200
jmp 0xb5d4b
jmp 0xb5d48
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x59200
jmp 0xb5d2a
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x59200
jmp 0xb5d39
movq %rax, %r14
movl $0x5c8, %esi            # imm = 0x5C8
movq %r15, %rdi
callq 0x55480
jmp 0xb5d4b
movq %rax, %r14
movq %rbx, %rdi
callq 0x59020
movq %r14, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/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
movq 0x80(%rdi), %rdi
testq %rdi, %rdi
je 0xb67bf
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x80(%r14)
movl $0x28, %edi
callq 0x556b0
movq %rax, %rbx
movq %rax, %rdi
callq 0x57be0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x55520
movq %rbx, %rdi
callq 0x56e60
testq %rax, %rax
je 0xb6806
movq %r14, %rdi
movq %rbx, %rsi
callq 0x58330
movl %eax, %ebp
jmp 0xb680b
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x55400
movl $0x28, %esi
movq %rbx, %rdi
callq 0x55480
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x28, %esi
movq %rbx, %rdi
callq 0x55480
movq %r14, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xb713d
movq %rcx, %r14
movq %rdx, %r15
movq %rdx, %rdi
movq %rcx, %rsi
callq 0x58d10
testq %rax, %rax
je 0xb713d
movq %r15, %rdi
movq %r14, %rsi
callq 0x58d10
movq %rax, %rdi
callq 0x55720
movq %rbx, %rdi
movq %rax, %rsi
callq 0x570b0
jmp 0xb7147
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58e20
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb3078(%rip), %rax     # 0x16a818
movq %rax, (%rdi)
leaq 0x90(%rdi), %r14
cmpl $0x0, 0x98(%rdi)
jle 0xb77d7
xorl %ebp, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x5b0a4
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb77cd
movq (%rdi), %rax
callq *0x8(%rax)
incl %ebp
cmpl 0x98(%rbx), %ebp
jl 0xb77b5
movq %r14, %rdi
callq 0x5adc6
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0xb77f0
callq 0x58cc0
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0xb7801
callq 0x58cc0
movq %r14, %rdi
callq 0x5b11e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x59020
jmp 0xb7817
movq %rax, %rdi
callq 0x5aede
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
movl %ebp, 0xc001b(%rip)     # 0x177870
movl %ebp, 0xc0019(%rip)     # 0x177874
movl %ebp, 0xc0017(%rip)     # 0x177878
movl %ebp, 0xc0015(%rip)     # 0x17787c
movl %ebp, 0xc0013(%rip)     # 0x177880
movslq 0x10(%rdi), %rax
leaq (,%rax,4), %rcx
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x56670
movq %rax, 0xbf9bd(%rip)     # 0x177250
cmpl %ebp, 0x10(%r14)
jle 0xb78b6
movl 0x10(%r14), %ecx
cmpl $0x2, %ecx
movl $0x1, %edx
cmovgel %ecx, %edx
shlq $0x2, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x55f20
leaq 0xbf9a3(%rip), %rdi     # 0x177260
xorl %r15d, %r15d
movl $0x548, %edx            # imm = 0x548
xorl %esi, %esi
callq 0x55f20
cmpl $0x4, 0x50(%r14)
jne 0xb78f4
movl $0x18, %edi
callq 0x556b0
movq %rax, %r15
movq %rax, %rdi
callq 0x58ff0
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x10(%rax)
cmpl $0x0, 0x14(%r14)
jle 0xb7912
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0xb7966
incl %ebp
cmpl 0x14(%r14), %ebp
jl 0xb78fd
cmpl $0x4, 0x50(%r14)
jne 0xb7930
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
testq %r15, %r15
je 0xb7930
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq 0xbf919(%rip), %rdi     # 0x177250
testq %rdi, %rdi
je 0xb7941
callq 0x561e0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x18, %esi
movq %r15, %rdi
callq 0x55480
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
movl %ebp, 0xbf557(%rip)     # 0x177870
movl %ebp, 0xbf555(%rip)     # 0x177874
movl %ebp, 0xbf553(%rip)     # 0x177878
movl %ebp, 0xbf551(%rip)     # 0x17787c
movl %ebp, 0xbf54f(%rip)     # 0x177880
movslq 0x10(%rdi), %rax
leaq (,%rax,4), %rcx
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x56670
movq %rax, 0xbeef9(%rip)     # 0x177250
cmpl %ebp, 0x10(%r14)
jle 0xb837a
movl 0x10(%r14), %ecx
cmpl $0x2, %ecx
movl $0x1, %edx
cmovgel %ecx, %edx
shlq $0x2, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x55f20
leaq 0xbeedf(%rip), %rdi     # 0x177260
xorl %r15d, %r15d
movl $0x548, %edx            # imm = 0x548
xorl %esi, %esi
callq 0x55f20
cmpl $0x4, 0x50(%r14)
jne 0xb83b8
movl $0x18, %edi
callq 0x556b0
movq %rax, %r15
movq %rax, %rdi
callq 0x58ff0
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x10(%rax)
cmpl $0x0, 0x14(%r14)
jle 0xb83d6
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0xb842a
incl %ebp
cmpl 0x14(%r14), %ebp
jl 0xb83c1
cmpl $0x4, 0x50(%r14)
jne 0xb83f4
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
testq %r15, %r15
je 0xb83f4
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq 0xbee55(%rip), %rdi     # 0x177250
testq %rdi, %rdi
je 0xb8405
callq 0x561e0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x18, %esi
movq %r15, %rdi
callq 0x55480
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/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)
movl %esi, %r15d
leal -0x1(%r15), %eax
xorl %r13d, %r13d
cmpl %edx, %eax
je 0xb8be2
movl %edx, %r14d
movq %rdi, %r12
cvtsi2sd %edx, %xmm0
movsd %xmm0, 0x8(%rsp)
movslq %edx, %rbp
movl %edx, %eax
notl %eax
addl %r15d, %eax
movl %eax, (%rsp)
incl %r14d
leaq (%rdi,%rbp,4), %rbx
addq $0x4, %rbx
negl %r15d
addq %r14, %r15
xorl %r13d, %r13d
leal (%r14,%r13), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%rsp)
movl $0x2, %edi
movl 0x4(%rsp), %esi
callq 0x56010
addsd 0x8(%rsp), %xmm0
ucomisd 0x10(%rsp), %xmm0
jbe 0xb8be2
movl (%rbx,%r13,4), %eax
cmpl (%r12,%rbp,4), %eax
jne 0xb8be2
incq %r13
movl %r15d, %eax
addl %r13d, %eax
jne 0xb8b9a
movl (%rsp), %eax
movl %eax, %r13d
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, %rcx
leaq 0xbd237(%rip), %rax     # 0x177260
movl (%rax,%rcx,4), %edx
movslq 0xbd83d(%rip), %rsi     # 0x177870
leal -0x1(%rsi), %edi
cmpl %ecx, %edi
jle 0xba04c
incq %rcx
movl (%rax,%rcx,4), %edi
movl %edi, -0x4(%rax,%rcx,4)
incq %rcx
cmpq %rcx, %rsi
jne 0xba03d
movl %edx, -0x4(%rax,%rsi,4)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x28, %rsp
movl %r8d, 0xc(%rsp)
movq %rsi, 0x18(%rsp)
leal -0x1(%rdx), %eax
xorl %ebp, %ebp
cmpl %ecx, %eax
je 0xba0fc
movl %ecx, %r14d
movq %rdi, %r12
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x10(%rsp)
movslq %ecx, %r13
movl %ecx, %eax
notl %eax
addl %edx, %eax
movl %eax, 0x8(%rsp)
incq %r13
movl %ecx, %r15d
subl %edx, %r15d
xorl %ebp, %ebp
movl $0x1, %ebx
leal (%r14,%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0x2, %edi
movl 0xc(%rsp), %esi
callq 0x56010
addsd 0x10(%rsp), %xmm0
ucomisd 0x20(%rsp), %xmm0
jbe 0xba0fc
movl (%r12,%r13,4), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx,%r13,4), %eax
jne 0xba0f8
incl %ebp
incl %ebx
incq %r13
movl %r15d, %eax
addl %ebx, %eax
jne 0xba0a8
movl 0x8(%rsp), %ebp
jmp 0xba0fc
decl %ebx
movl %ebx, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xba4c6
cmpq $0x0, 0xbd46f(%rip)     # 0x1778e8
jne 0xba4b3
movl $0x58, %edi
callq 0x556b0
movq %rax, %rbx
movq %rax, %rdi
callq 0x55d90
leaq 0xa6349(%rip), %rax     # 0x1607e0
movq %rax, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
leaq 0xb03ff(%rip), %rax     # 0x16a8a8
movq %rax, (%rbx)
movq %rbx, 0xbd435(%rip)     # 0x1778e8
movq 0xbd42e(%rip), %rdi     # 0x1778e8
movq %rsp, %rsi
callq 0x5af08
xorl %eax, %eax
jmp 0xba4cb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x58, %esi
movq %rbx, %rdi
callq 0x55480
movq %r14, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/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 0xba54d
cmpq $0x0, 0xbd3f0(%rip)     # 0x1778f0
jne 0xba53a
movl $0x58, %edi
callq 0x556b0
movq %rax, %rbx
movq %rax, %rdi
callq 0x55d90
leaq 0xa62c2(%rip), %rax     # 0x1607e0
movq %rax, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
leaq 0xb0378(%rip), %rax     # 0x16a8a8
movq %rax, (%rbx)
movq %rbx, 0xbd3b6(%rip)     # 0x1778f0
movq 0xbd3af(%rip), %rdi     # 0x1778f0
movq %rsp, %rsi
callq 0x5af08
xorl %eax, %eax
jmp 0xba552
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x58, %esi
movq %rbx, %rdi
callq 0x55480
movq %r14, %rdi
callq 0x57090