LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/basic/object.cpp
// Function: smooth::Object::Object()
S::Object::Object() : type(this)
{
	/* Enable R/W locking for object lists.
	 */
	if (objects.Length() == 0)
	{
		objects.EnableLocking();
		deletable.EnableLocking();
	}

	type	       = classID;

	handle	       = RequestObjectHandle();
	name	       = NIL;

	lockingEnabled = False;

	isDeletable    = False;
	isObjectInUse  = 0;

	flags	       = 0;

	objects.Add(this, handle);

	/* Create periodical cleanup timer if we
	 * just created the first object.
	 */
	if (objects.Length() == 1)
	{
		cleanupTimer = new System::Timer();

		cleanupTimer->onInterval.Connect(&Object::ObjectCleanup);
		cleanupTimer->Start(1000);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x110743(%rip), %rax    # 0x16b8a8
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x20(%rdi), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x57ad0
movq 0x11063e(%rip), %r14    # 0x16b7c0
cmpl $0x0, 0x8(%r14)
jne 0x5b1a1
movq 0x110630(%rip), %rdi    # 0x16b7c0
callq 0x571b0
movq 0x1108a4(%rip), %rdi    # 0x16ba40
callq 0x571b0
movq 0x110bd8(%rip), %rax    # 0x16bd80
movzwl (%rax), %eax
movw %ax, (%r15)
leaq 0x1130f2(%rip), %rax    # 0x16e2a8
cmpb $0x1, (%rax)
jne 0x5b1cb
movq 0x110556(%rip), %rax    # 0x16b718
movl (%rax), %edx
leal 0x1(%rdx), %ecx
movl %ecx, (%rax)
jmp 0x5b1db
movq 0x110546(%rip), %rdi    # 0x16b718
callq 0x578f0
movl %eax, %edx
decl %edx
movl %edx, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movw $0x0, 0x18(%rbx)
xorl %eax, %eax
movl %eax, 0x1c(%rbx)
movl %eax, 0x30(%rbx)
leaq 0x8(%rsp), %rsi
movq %rbx, (%rsi)
movq %r14, %rdi
callq 0x5af42
cmpl $0x1, 0x8(%r14)
jne 0x5b24a
movl $0x68, %edi
callq 0x556b0
movq %rax, %rbx
movq %rax, %rdi
callq 0x55b80
movq 0x110211(%rip), %r14    # 0x16b438
movq %rbx, (%r14)
addq $0x48, %rbx
movq 0x1103a3(%rip), %rsi    # 0x16b5d8
movq %rbx, %rdi
callq 0x5b63e
movq (%r14), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x55100
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x68, %esi
movq %rbx, %rdi
callq 0x55480
movq %r14, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/basic/object.cpp
// Function: smooth::Object::~Object()
S::Object::~Object()
{
	/* Try to remove ourself from the object list
	 * as DeleteObject might not have been called.
	 */
	if (!isDeletable) objects.Remove(handle);

	/* Free periodical cleanup timer if the timer
	 * itself is the only remaining object.
	 */
	if (objects.Length() == 1)
	{
		cleanupTimer->Stop();

		DeleteObject(cleanupTimer);
	}

	/* Delete name string if it was created.
	 */
	if (name != NIL) delete name;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1105b6(%rip), %rax    # 0x16b8a8
addq $0x10, %rax
movq %rax, (%rdi)
cmpb $0x0, 0x19(%rdi)
jne 0x5b30e
movl 0x8(%rbx), %esi
movq 0x1104b7(%rip), %rdi    # 0x16b7c0
callq 0x58bb0
movq 0x1104ab(%rip), %rax    # 0x16b7c0
cmpl $0x1, 0x8(%rax)
jne 0x5b332
movq 0x110116(%rip), %r14    # 0x16b438
movq (%r14), %rdi
callq 0x59190
movq (%r14), %rdi
callq 0x58cc0
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x5b357
movq %rbx, %rdi
callq 0x59200
movl $0x18, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x55480
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x5aeae
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/basic/object.cpp
// Function: smooth::Object::DeleteObject(smooth::Object*)
S::Int S::Object::DeleteObject(Object *object)
{
	if (object == NIL || objects.Get(object->handle) == NIL) return Error();

	/* Notify object that it will be deleted soon.
	 */
	object->EnqueueForDeletion();
	object->isDeletable = True;

	if (!object->IsObjectInUse())
	{
		/* Delete object immediately if
		 * it is not currently in use.
		 */
		objects.Remove(object->handle);
		delete object;
	}
	else
	{
		/* Remove object from object list and add
		 * it to the list of objects to delete.
		 */
		objects.Remove(object->handle);
		deletable.Add(object, object->handle);
	}

	return Success();
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x5b3d1
movq %rdi, %rbx
movl 0x8(%rdi), %esi
movq 0x11043e(%rip), %rdi    # 0x16b7c0
callq 0x5b778
cmpq $0x0, (%rax)
je 0x5b3d1
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movb $0x1, 0x19(%rbx)
movl 0x1c(%rbx), %ebp
movl 0x8(%rbx), %esi
movq 0x11041a(%rip), %rdi    # 0x16b7c0
callq 0x58bb0
testl %ebp, %ebp
jle 0x5b3c6
movl 0x8(%rbx), %edx
movq %rsp, %rsi
movq %rbx, (%rsi)
movq 0x110681(%rip), %rdi    # 0x16ba40
callq 0x5af42
jmp 0x5b3cf
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/basic/object.cpp
// Function: smooth::Object::GetObject(int, short)
S::Object *S::Object::GetObject(Int objectHandle, Short objectType)
{
	Object	*object = objects.Get(objectHandle);

	if (object == NIL) return NIL;

	if (object->GetObjectType() == objectType) return object;
	else					   return NIL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %esi
movq 0x110397(%rip), %rdi    # 0x16b7c0
callq 0x5b778
movq (%rax), %r14
testq %r14, %r14
je 0x5b44e
leaq 0x20(%r14), %rdi
movswl %bx, %esi
callq 0x57520
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
cmovneq %r14, %rax
jmp 0x5b450
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/basic/object.cpp
// Function: smooth::Object::SetName(smooth::String const&)
S::Int S::Object::SetName(const String &nName)
{
	if (GetObject(nName) != NIL) return Error();

	if (name == NIL) name = new String();

	*name = nName;

	return Success();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x58e80
movq %rax, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
jne 0x5b4ff
movq 0x10(%r14), %r15
testq %r15, %r15
jne 0x5b4f2
movl $0x18, %edi
callq 0x556b0
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
callq 0x58e20
movq %r15, 0x10(%r14)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x555f0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x18, %esi
movq %r15, %rdi
callq 0x55480
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/basic/../../include/smooth/system/../templates/signals/signal.h
// Function: int smooth::Signal0<void>::Connect<void>(void (*)())
Int Connect(slotReturnTYPE (*proc)(SIGNALS_ARGUMENT_TYPES))
			{
				if (slotsN == NIL)
				{
					slotsN = new Array<Void *>();
					slotsN->EnableLocking();
				}

				slotsN->Add(new SIGNALS_SLOT_GLOBAL_CLASS_NAME<slotReturnTYPE SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES>(proc));

				return Success();
			}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq 0x10(%rdi), %r15
testq %r15, %r15
jne 0x5b698
movq %rdi, %r14
movl $0x58, %edi
callq 0x556b0
movq %rax, %r15
movq %rax, %rdi
callq 0x55d90
leaq 0x10418e(%rip), %rax    # 0x15f800
movq %rax, 0x40(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r15)
leaq 0x10429b(%rip), %rax    # 0x15f920
movq %rax, (%r15)
movq %r15, 0x10(%r14)
movq %r15, %rdi
callq 0x571b0
movq 0x10(%r14), %r15
movl $0x10, %edi
callq 0x556b0
leaq 0x1042c7(%rip), %rcx    # 0x15f970
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x5aed8
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x58, %esi
movq %r15, %rdi
callq 0x55480
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/files/directory.cpp
// Function: smooth::Directory::GetActiveDirectory()
S::Directory S::Directory::GetActiveDirectory()
{
#ifdef __WIN32__
	Buffer<wchar_t>	 buffer(32768 + 1);

	GetCurrentDirectory(buffer.Size(), buffer);

	String		 dir = (wchar_t *) buffer;
#else
	Buffer<char>	 buffer(PATH_MAX + 1);
	String		 dir;

	if (getcwd(buffer, buffer.Size()) != NIL) dir = buffer;
#endif

	return Directory(NIL, dir);
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl $0x1001, %esi           # imm = 0x1001
callq 0x5cf6a
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x58e20
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x5bed4
movq (%rax), %rdi
jmp 0x5bed6
xorl %edi, %edi
movslq 0x18(%rsp), %rsi
callq 0x561f0
testq %rax, %rax
je 0x5bf00
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x5bef4
movq (%rax), %rsi
jmp 0x5bef6
xorl %esi, %esi
leaq 0x20(%rsp), %rdi
callq 0x55f40
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x58e20
leaq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x58c60
leaq 0x38(%rsp), %rdi
callq 0x59200
leaq 0x20(%rsp), %rdi
callq 0x59200
leaq 0x103dbf(%rip), %rax    # 0x15fcf8
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x5d81a
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
retq
jmp 0x5bf60
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x59200
jmp 0x5bf63
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x59200
jmp 0x5bf72
movq %rax, %rbx
leaq 0x103d7f(%rip), %rax    # 0x15fcf8
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x5d81a
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/files/directory.cpp
// Function: smooth::Directory::Create()
S::Int S::Directory::Create()
{
	if (Exists()) return Success();

	Bool	 result	   = False;
	String	 directory = *this;

	for (Int i = 1; i <= directory.Length(); i++)
	{
		if (directory[i] == '\\' || directory[i] == '/' || directory[i] == 0)
		{
			String	 path = directory.Head(i);

#ifdef __WIN32__
			result = CreateDirectory(MakeExtendedPath(path), NIL);
#else
			if (mkdir(path.ConvertTo("UTF-8"), 0777) == 0) result = True;
			else					       result = False;
#endif
		}
	}

	if (result == False) return Error();
	else		     return Success();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
callq 0x55440
xorl %ebx, %ebx
testb %al, %al
jne 0x5cb83
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x56d90
movl $0x1, %ebp
xorl %r12d, %r12d
leaq 0x18(%rsp), %r14
leaq 0xb57d6(%rip), %r15     # 0x1122d6
movq %rbx, %rdi
callq 0x57180
cmpl %eax, %ebp
jg 0x5cb70
movq %rbx, %rdi
movl %ebp, %esi
callq 0x58990
cmpl $0x5c, (%rax)
je 0x5cb39
movq %rbx, %rdi
movl %ebp, %esi
callq 0x58990
cmpl $0x2f, (%rax)
je 0x5cb39
movq %rbx, %rdi
movl %ebp, %esi
callq 0x58990
cmpl $0x0, (%rax)
jne 0x5cb6c
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x58b00
movq %r14, %rdi
movq %r15, %rsi
callq 0x57940
movq %rax, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x55d70
testl %eax, %eax
sete %r12b
movq %r14, %rdi
callq 0x59200
incl %ebp
jmp 0x5cb00
andb $0x1, %r12b
decb %r12b
movsbl %r12b, %ebx
movq %rsp, %rdi
callq 0x59200
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5cba3
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x59200
jmp 0x5cba6
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/files/directory.cpp
// Function: smooth::Directory::Move(smooth::Directory const&)
S::Int S::Directory::Move(const Directory &destination)
{
	if (!Exists()) return Error();

#ifdef __WIN32__
	Bool	 result = MoveFile(MakeExtendedPath(*this), MakeExtendedPath(destination));
#else
	Bool	 result = (rename(String(*this).ConvertTo("UTF-8"), String(destination).ConvertTo("UTF-8")) == 0);
#endif

	if (result == False) return Error();
	else		     return Success();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x55440
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %cl, %cl
je 0x5cc3c
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x56d90
leaq 0xb56e4(%rip), %rsi     # 0x1122d6
movq %r15, %rdi
callq 0x57940
movq %rax, %r14
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x56d90
leaq 0xb56c7(%rip), %rsi     # 0x1122d6
movq %rsp, %rdi
callq 0x57940
movq %r14, %rdi
movq %rax, %rsi
callq 0x58ba0
movl %eax, %ebx
movq %rsp, %rdi
callq 0x59200
leaq 0x18(%rsp), %rdi
callq 0x59200
xorl %eax, %eax
negl %ebx
sbbl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59200
jmp 0x5cc58
jmp 0x5cc55
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/files/file.cpp
// Function: smooth::DateTimeToFileTime(smooth::DateTime const&)
FileTime DateTimeToFileTime(const DateTime &dateTime)
	{
		tm	 time;

		memset(&time, 0, sizeof(time));

		time.tm_year  = dateTime.GetYear() - 1900;
		time.tm_mon   = dateTime.GetMonth() - 1;
		time.tm_mday  = dateTime.GetDay();

		time.tm_hour  = dateTime.GetHour();
		time.tm_min   = dateTime.GetMinute();
		time.tm_sec   = dateTime.GetSecond();

		time.tm_isdst = -1;

		return mktime(&time);
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rbx
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x18(%rbx)
callq 0x58c70
addl $0xfffff894, %eax       # imm = 0xFFFFF894
movl %eax, 0x14(%rbx)
movq %r14, %rdi
callq 0x563d0
decl %eax
movl %eax, 0x10(%rbx)
movq %r14, %rdi
callq 0x56930
movl %eax, 0xc(%rbx)
movq %r14, %rdi
callq 0x57c70
movl %eax, 0x8(%rbx)
movq %r14, %rdi
callq 0x58e40
movl %eax, 0x4(%rbx)
movq %r14, %rdi
callq 0x55700
movl %eax, (%rbx)
movl $0xffffffff, 0x20(%rbx) # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x56300
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/files/file.cpp
// Function: smooth::GetFileTime(smooth::File const&, long*, long*, long*)
Bool GetFileTime(const File &file, FileTime *cTime, FileTime *aTime, FileTime *wTime)
	{
		if (!file.Exists()) return False;

		struct stat	 info;

		if (stat(String(file).ConvertTo("UTF-8"), &info) != 0) return False;

		if (cTime != NIL) *cTime = info.st_mtime;
		if (aTime != NIL) *aTime = info.st_atime;
		if (wTime != NIL) *wTime = info.st_mtime;

		return True;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x56ef0
testb %al, %al
je 0x5d9c8
movq %rsp, %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x58fa0
leaq 0xb495d(%rip), %rsi     # 0x1122d6
movq %r13, %rdi
callq 0x57940
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x58620
movl %eax, %ebp
movq %rsp, %rdi
callq 0x59200
testl %ebp, %ebp
sete %al
jne 0x5d9ca
testq %r15, %r15
je 0x5d9ac
movq 0x70(%rsp), %rcx
movq %rcx, (%r15)
testq %r14, %r14
je 0x5d9b9
movq 0x60(%rsp), %rcx
movq %rcx, (%r14)
testq %rbx, %rbx
je 0x5d9ca
movq 0x70(%rsp), %rcx
movq %rcx, (%rbx)
jmp 0x5d9ca
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/files/file.cpp
// Function: smooth::SetFileTime(smooth::File const&, long*, long*, long*)
Bool SetFileTime(const File &file, FileTime *cTime, FileTime *aTime, FileTime *wTime)
	{
		if (!file.Exists()) return False;

		struct stat	 info;
		struct utimbuf	 times;

		if (stat(String(file).ConvertTo("UTF-8"), &info) != 0) return False;

		times.actime  = info.st_atime;
		times.modtime = info.st_mtime;

		if (cTime != NIL) times.modtime = *cTime;
		if (aTime != NIL) times.actime  = *aTime;
		if (wTime != NIL) times.modtime = *wTime;

		if (utime(String(file).ConvertTo("UTF-8"), &times) != 0) return False;

		return True;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x56ef0
testb %al, %al
je 0x5db33
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x58fa0
leaq 0xb47c8(%rip), %rsi     # 0x1122d6
movq %r13, %rdi
callq 0x57940
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x58620
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
callq 0x59200
testl %ebp, %ebp
je 0x5db49
xorl %ebx, %ebx
movl %ebx, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x70(%rsp), %rax
movq 0x80(%rsp), %rcx
movq %rax, (%rsp)
movq %rcx, 0x8(%rsp)
testq %r12, %r12
je 0x5db6d
movq (%r12), %rax
movq %rax, 0x8(%rsp)
testq %r15, %r15
je 0x5db79
movq (%r15), %rax
movq %rax, (%rsp)
testq %r14, %r14
je 0x5db86
movq (%r14), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x58fa0
leaq 0xb4739(%rip), %rsi     # 0x1122d6
movq %r14, %rdi
callq 0x57940
movq %rsp, %rsi
movq %rax, %rdi
callq 0x575c0
testl %eax, %eax
sete %bl
leaq 0x10(%rsp), %rdi
callq 0x59200
jmp 0x5db35
jmp 0x5dbc6
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/files/file.cpp
// Function: smooth::File::GetFileSize() const
S::Int64 S::File::GetFileSize() const
{
	if (!Exists()) return -1;

#ifdef __WIN32__
	HANDLE	 handle	  = CreateFile(Directory::MakeExtendedPath(*this), GENERIC_READ, FILE_SHARE_READ, NIL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NIL);

	DWORD	 sizeLow  = 0;
	DWORD	 sizeHigh = 0;

	sizeLow = ::GetFileSize(handle, &sizeHigh);

	CloseHandle(handle);

	return (Int64(sizeHigh) << 32) + sizeLow;
#else
	struct stat	 info;

	if (stat(String(*this).ConvertTo("UTF-8"), &info) != 0) return 0;

	return info.st_size;
#endif
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
callq 0x56ef0
movl %eax, %ecx
movq $-0x1, %rax
testb %cl, %cl
je 0x5e0ec
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x58fa0
leaq 0xb4216(%rip), %rsi     # 0x1122d6
movq %r14, %rdi
callq 0x57940
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x58620
movl %eax, %ebx
movq %rsp, %rdi
callq 0x59200
testl %ebx, %ebx
jne 0x5e0ea
movq 0x48(%rsp), %rax
jmp 0x5e0ec
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/files/file.cpp
// Function: smooth::File::Copy(smooth::File const&)
S::Int S::File::Copy(const File &destination)
{
	if (!Exists()) return Error();

#ifdef __WIN32__
	Bool	 result = CopyFile(Directory::MakeExtendedPath(*this), Directory::MakeExtendedPath(destination), True);
#else
	Bool	 result = False;

	FILE	*source	= fopen(String(*this).ConvertTo("UTF-8"), "rb");
	FILE	*dest	= fopen(String(destination).ConvertTo("UTF-8"), "wb");

	if (source != NIL && dest != NIL)
	{
		Int	 bytesLeft = GetFileSize();
		Int	 chunkSize = 32768;

		UnsignedByte	*buffer = new UnsignedByte [chunkSize];

		while (bytesLeft)
		{
			chunkSize = Math::Min(chunkSize, bytesLeft);

			if (fread(buffer, chunkSize, 1, source) == 1) fwrite(buffer, chunkSize, 1, dest);
			else					      break;

			bytesLeft -= chunkSize;
		}

		delete [] buffer;

		if (!bytesLeft) result = True;
	}

	if (source != NIL) fclose(source);
	if (dest != NIL) fclose(dest);
#endif

	if (result == False) return Error();
	else		     return Success();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
callq 0x56ef0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testb %al, %al
je 0x5e387
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x58fa0
leaq 0xb406b(%rip), %rsi     # 0x1122d6
movq %rbx, %rdi
callq 0x57940
leaq 0x950e3(%rip), %rsi     # 0xf335d
movq %rax, %rdi
callq 0x586e0
movq %rax, %r13
leaq 0x10(%rsp), %rdi
callq 0x59200
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x58fa0
leaq 0xb4030(%rip), %rsi     # 0x1122d6
movq %rbx, %rdi
callq 0x57940
leaq 0x950ab(%rip), %rsi     # 0xf3360
movq %rax, %rdi
callq 0x586e0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x59200
testq %r13, %r13
sete %al
testq %rbx, %rbx
sete %cl
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
orb %al, %cl
jne 0x5e36d
movq %r15, %rdi
callq 0x56890
movq %rax, %r12
movl $0x8000, %edi           # imm = 0x8000
callq 0x56670
movq %rax, %r15
testl %r12d, %r12d
je 0x5e363
movq %rbx, 0x8(%rsp)
movq %r13, %r14
movl $0x8000, %ebp           # imm = 0x8000
cmpl %r12d, %ebp
cmovgel %r12d, %ebp
movslq %ebp, %r13
movl $0x1, %edx
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rcx
callq 0x56a20
movq %rax, %rbx
cmpq $0x1, %rax
jne 0x5e34d
movl $0x1, %edx
movq %r15, %rdi
movq %r13, %rsi
movq 0x8(%rsp), %rcx
callq 0x588d0
subl %r13d, %r12d
jne 0x5e30d
xorl %ebp, %ebp
cmpq $0x1, %rbx
setne %bpl
negl %ebp
movq %r14, %r13
movq 0x8(%rsp), %rbx
jmp 0x5e365
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x561e0
testq %r13, %r13
je 0x5e37a
movq %r13, %rdi
callq 0x564b0
testq %rbx, %rbx
je 0x5e387
movq %rbx, %rdi
callq 0x564b0
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5e39a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/files/file.cpp
// Function: smooth::File::Move(smooth::File const&)
S::Int S::File::Move(const File &destination)
{
	if (!Exists()) return Error();

#ifdef __WIN32__
	String		 fileName	= Directory::MakeExtendedPath(*this);
	UnsignedInt	 fileAttributes	= GetFileAttributes(fileName);

	SetFileAttributes(fileName, fileAttributes & ~FILE_ATTRIBUTE_READONLY);

	Bool	 result = MoveFile(fileName, Directory::MakeExtendedPath(destination));

	SetFileAttributes(fileName, fileAttributes);
#else
	Bool	 result = (rename(String(*this).ConvertTo("UTF-8"), String(destination).ConvertTo("UTF-8")) == 0);
#endif

	if (result == False) return Error();
	else		     return Success();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x56ef0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %cl, %cl
je 0x5e430
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x58fa0
leaq 0xb3ef0(%rip), %rsi     # 0x1122d6
movq %r15, %rdi
callq 0x57940
movq %rax, %r14
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x58fa0
leaq 0xb3ed3(%rip), %rsi     # 0x1122d6
movq %rsp, %rdi
callq 0x57940
movq %r14, %rdi
movq %rax, %rsi
callq 0x58ba0
movl %eax, %ebx
movq %rsp, %rdi
callq 0x59200
leaq 0x18(%rsp), %rdi
callq 0x59200
xorl %eax, %eax
negl %ebx
sbbl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59200
jmp 0x5e44c
jmp 0x5e449
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/files/file.cpp
// Function: smooth::File::Delete()
S::Int S::File::Delete()
{
	if (!Exists()) return Error();

#ifdef __WIN32__
	String	 fileName = Directory::MakeExtendedPath(*this);

	SetFileAttributes(fileName, GetFileAttributes(fileName) & ~FILE_ATTRIBUTE_READONLY);

	Bool	 result = DeleteFile(fileName);
#else
	Bool	 result = (remove(String(*this).ConvertTo("UTF-8")) == 0);
#endif

	if (result == False) return Error();
	else		     return Success();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x56ef0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %cl, %cl
je 0x5e4ad
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x58fa0
leaq 0xb3e49(%rip), %rsi     # 0x1122d6
movq %r14, %rdi
callq 0x57940
movq %rax, %rdi
callq 0x559d0
movl %eax, %ebx
movq %rsp, %rdi
callq 0x59200
xorl %eax, %eax
negl %ebx
sbbl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/bitmap.cpp
// Function: smooth::GUI::Bitmap::operator==(smooth::GUI::Bitmap const&) const
S::Bool S::GUI::Bitmap::operator ==(const Bitmap &bitmap) const
{
	if (*this == NIL && bitmap == NIL) return True;
	if (*this == NIL || bitmap == NIL) return False;

	if (GetSize()	       != bitmap.GetSize()	   ||
	    GetDepth()	       != bitmap.GetDepth()	   ||
	    GetBitsPerPixel()  != bitmap.GetBitsPerPixel() ||
	    GetLineAlignment() != bitmap.GetLineAlignment()) return False;

	Size	 size  = GetSize();
	Int	 bpp   = GetBitsPerPixel();
	Int	 align = GetLineAlignment();
	Int	 bpl   = ((align - ((size.cx * (bpp / 8)) % align)) % align) + size.cx * (bpp / 8);
	Int	 bytes = bpl * size.cy;

	if (memcmp(GetBytes(), bitmap.GetBytes(), bytes) != 0) return False;

	return True;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x78(%rax)
testb %al, %al
je 0x5e765
movq (%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x78(%rax)
movb $0x1, %bpl
testb %al, %al
jne 0x5e887
movq (%r14), %rdi
movq (%rdi), %rax
xorl %ebp, %ebp
xorl %esi, %esi
callq *0x78(%rax)
testb %al, %al
jne 0x5e887
movq (%rbx), %rdi
movq (%rdi), %rax
xorl %ebp, %ebp
xorl %esi, %esi
callq *0x78(%rax)
testb %al, %al
jne 0x5e887
movq (%r14), %rdi
callq 0x5fac4
movq %rax, %r15
movq (%rbx), %rdi
callq 0x5fac4
movl (%r15), %ecx
xorl %ebp, %ebp
cmpl (%rax), %ecx
jne 0x5e887
movl 0x4(%rax), %eax
cmpl %eax, 0x4(%r15)
jne 0x5e887
movq (%r14), %rdi
callq 0x5faca
movl %eax, %ebp
movq (%rbx), %rdi
callq 0x5faca
cmpb %al, %bpl
jne 0x5e885
movq (%r14), %rdi
callq 0x5fad4
movl %eax, %ebp
movq (%rbx), %rdi
callq 0x5fad4
cmpb %al, %bpl
jne 0x5e885
movq (%r14), %rdi
callq 0x5fad8
movl %eax, %ebp
movq (%rbx), %rdi
callq 0x5fad8
cmpb %al, %bpl
jne 0x5e885
movq (%r14), %rdi
callq 0x5fac4
movl (%rax), %r15d
movslq 0x4(%rax), %r12
movq (%r14), %rdi
callq 0x5fad4
movl %eax, %ebp
movq (%r14), %rdi
callq 0x5fad8
movsbl %al, %esi
movl %ebp, %eax
sarb $0x7, %al
shrb $0x5, %al
addb %bpl, %al
sarb $0x3, %al
movsbl %al, %ecx
imull %r15d, %ecx
movl %ecx, %eax
cltd
idivl %esi
movl %esi, %eax
subl %edx, %eax
cwtd
idivw %si
movswl %dx, %eax
addl %ecx, %eax
movslq %eax, %r15
imulq %r12, %r15
movq (%r14), %rdi
callq 0x5face
movq %rax, %r14
movq (%rbx), %rdi
callq 0x5face
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x57320
testl %eax, %eax
sete %bpl
jmp 0x5e887
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/color.cpp
// Function: smooth::GUI::Color::Downsample(int) const
S::GUI::Color S::GUI::Color::Downsample(Int bpcc) const
{
	if (bpcc == 8) return *this;

	int first  = GetRed();
	int second = GetGreen();
	int third  = GetBlue();

	first  >>= (8 - bpcc);
	second >>= (8 - bpcc);
	third  >>= (8 - bpcc);

	return Color((Long) (first + Math::Pow(2, bpcc) * second + Math::Pow(4, bpcc) * third), colorSpace);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
cmpl $0x8, %edx
je 0x5f04f
movl %edx, %ebp
movl $0xff, %eax
movl %r15d, %edx
andl %eax, %edx
movl %r15d, %r12d
shrl $0x8, %r12d
andl %eax, %r12d
shrl $0x10, %r15d
andl %eax, %r15d
movb $0x8, %cl
subb %bpl, %cl
shrl %cl, %edx
shrl %cl, %r12d
shrl %cl, %r15d
cvtsi2sd %edx, %xmm0
movsd %xmm0, 0x8(%rsp)
movl $0x2, %edi
movl %ebp, %esi
callq 0x56010
cvtsi2sd %r12d, %xmm1
mulsd %xmm0, %xmm1
addsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x8(%rsp)
movl $0x4, %edi
movl %ebp, %esi
callq 0x56010
xorps %xmm1, %xmm1
cvtsi2sd %r15d, %xmm1
mulsd %xmm0, %xmm1
addsd 0x8(%rsp), %xmm1
cvttsd2si %xmm1, %r15
movl (%r14), %eax
movq %r15, 0x8(%rbx)
movl %eax, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/color.cpp
// Function: smooth::GUI::Color::Upsample(int) const
S::GUI::Color S::GUI::Color::Upsample(Int bpcc) const
{
	if (bpcc == 8) return *this;

	int first  =  color		   & (int) (Math::Pow(2, bpcc) - 1);
	int second = (color >>	    bpcc ) & (int) (Math::Pow(2, bpcc) - 1);
	int third  = (color >> (2 * bpcc)) & (int) (Math::Pow(2, bpcc) - 1);

	first  = (int) (255 / (Math::Pow(2, bpcc) - 1) * (double) first);
	second = (int) (255 / (Math::Pow(2, bpcc) - 1) * (double) second);
	third  = (int) (255 / (Math::Pow(2, bpcc) - 1) * (double) third);

	return Color(first, second, third, colorSpace);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r12
cmpl $0x8, %edx
je 0x5f1e5
movl %edx, %r15d
movl $0x2, %edi
movl %edx, %esi
callq 0x56010
addsd 0x94310(%rip), %xmm0    # 0xf33b0
cvttsd2si %xmm0, %eax
andl %eax, %r12d
movdqu (%r14), %xmm0
pshufd $0xee, %xmm0, %xmm0     # xmm0 = xmm0[2,3,2,3]
movdqa %xmm0, 0x30(%rsp)
movl $0x2, %edi
movl %r15d, %esi
callq 0x56010
movdqa %xmm0, 0x40(%rsp)
leal (%r15,%r15), %r13d
movsd 0x8(%r14), %xmm0
movapd %xmm0, (%rsp)
movl $0x2, %edi
movl %r15d, %esi
callq 0x56010
movapd %xmm0, 0x20(%rsp)
movl $0x2, %edi
movl %r15d, %esi
callq 0x56010
addsd 0x942af(%rip), %xmm0    # 0xf33b0
movsd 0x9425f(%rip), %xmm1    # 0xf3368
cvtsi2sd %r12d, %xmm2
divsd %xmm0, %xmm1
mulsd %xmm1, %xmm2
cvttsd2si %xmm2, %ebp
movl $0x2, %edi
movl %r15d, %esi
callq 0x56010
movapd %xmm0, 0x10(%rsp)
movl $0x2, %edi
movl %r15d, %esi
callq 0x56010
movd %r13d, %xmm1
movd %r15d, %xmm2
pshufd $0x44, (%rsp), %xmm3    # xmm3 = mem[0,1,0,1]
movdqa 0x9435e(%rip), %xmm4    # 0xf34b0
movdqa %xmm4, %xmm5
psrlq %xmm2, %xmm5
psrlq %xmm1, %xmm4
movdqa 0x30(%rsp), %xmm6
psrlq %xmm2, %xmm6
psrlq %xmm1, %xmm3
movsd %xmm5, %xmm4            # xmm4 = xmm5[0],xmm4[1]
movsd %xmm6, %xmm3            # xmm3 = xmm6[0],xmm3[1]
xorpd %xmm4, %xmm3
movapd 0x40(%rsp), %xmm2
unpcklpd 0x20(%rsp), %xmm2       # xmm2 = xmm2[0],mem[0]
movapd 0x94334(%rip), %xmm1    # 0xf34c0
addpd %xmm1, %xmm2
cvttpd2dq %xmm2, %xmm2
psubq %xmm4, %xmm3
pshufd $0xe8, %xmm3, %xmm3     # xmm3 = xmm3[0,2,2,3]
pand %xmm2, %xmm3
movapd 0x10(%rsp), %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
addpd %xmm1, %xmm2
movapd 0x94319(%rip), %xmm0    # 0xf34d0
cvtdq2pd %xmm3, %xmm1
divpd %xmm2, %xmm0
mulpd %xmm0, %xmm1
cvttpd2dq %xmm1, %xmm0
pshufd $0x55, %xmm0, %xmm1     # xmm1 = xmm0[1,1,1,1]
pslld $0x8, %xmm0
movd %xmm0, %eax
orl %ebp, %eax
pslld $0x10, %xmm1
movd %xmm1, %ecx
orl %eax, %ecx
movslq %ecx, %r12
movl (%r14), %eax
movq %r12, 0x8(%rbx)
movl %eax, (%rbx)
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/font.cpp
// Function: smooth::GUI::Font::operator==(smooth::GUI::Font const&) const
S::Bool S::GUI::Font::operator ==(const Font &font) const
{
	if (fontName   == font.GetName()   &&
	    fontSize   == font.GetSize()   &&
	    fontColor  == font.GetColor()  &&
	    fontWeight == font.GetWeight() &&
	    fontStyle  == font.GetStyle()) return True;
	else				   return False;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %rdi
addq $0x10, %rsi
callq 0x55900
testb %al, %al
je 0x5f488
movzwl 0x8(%r14), %eax
cmpw 0x8(%rbx), %ax
jne 0x5f488
movq 0x30(%r14), %rax
cmpq 0x30(%rbx), %rax
jne 0x5f488
movzwl 0x38(%r14), %eax
cmpw 0x38(%rbx), %ax
jne 0x5f488
movzwl 0x3a(%r14), %ecx
movb $0x1, %al
cmpw 0x3a(%rbx), %cx
je 0x5f48a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/backends/bitmapbackend.cpp
// Function: smooth::GUI::BitmapBackend::BitmapBackend(smooth::GUI::Size const&, int)
S::GUI::BitmapBackend::BitmapBackend(const Size &iSize, Int iDepth)
{
	type	= BITMAP_NONE;

	size	= iSize;
	depth	= iDepth;

	bytes	= NIL;
	bpp	= 0;
	align	= 0;
}

// Assembly:
leaq 0x1002d3(%rip), %rax    # 0x15fd28
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movw %ax, 0x8(%rdi)
movq (%rsi), %rcx
movq %rcx, 0x10(%rdi)
movb %dl, 0xa(%rdi)
movq %rax, 0x18(%rdi)
movw %ax, 0xb(%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/backends/bitmapbackend.cpp
// Function: smooth::GUI::BitmapBackend::GrayscaleBitmap()
S::Int S::GUI::BitmapBackend::GrayscaleBitmap()
{
	Point	 point;

	for (point.y = 0; point.y < size.cy; point.y++)
	{
		for (point.x = 0; point.x < size.cx; point.x++)
		{
			Color	 pixel = GetPixel(point);

			Int	 gray  = (pixel.GetRed() + pixel.GetGreen() + pixel.GetBlue()) / 3;

			if (depth == 32) SetPixel(point, Color(gray | (gray << 8) | (gray << 16) | (pixel.GetAlpha() << 24), Color::RGBA));
			else		 SetPixel(point, Color(gray, gray, gray));
		}
	}

	return Success();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl $0x0, 0xc(%rsp)
movl 0x14(%rdi), %ecx
testl %ecx, %ecx
jle 0x5fbe7
movq %rdi, %rbx
movl 0x10(%rdi), %eax
xorl %edx, %edx
leaq 0x20(%rsp), %r14
leaq 0x8(%rsp), %r15
movl $0xff, %ebp
leaq 0x10(%rsp), %r12
movl $0x0, 0x8(%rsp)
testl %eax, %eax
jle 0x5fbd9
movq (%rbx), %rax
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq *0x60(%rax)
movl 0x28(%rsp), %eax
movl %eax, %ecx
andl %ebp, %ecx
movl %eax, %edx
shrl $0x8, %edx
andl %ebp, %edx
addl %ecx, %edx
movl %eax, %ecx
shrl $0x10, %ecx
andl %ebp, %ecx
addl %edx, %ecx
imull $0x5556, %ecx, %ecx     # imm = 0x5556
shrl $0x10, %ecx
cmpb $0x20, 0xa(%rbx)
jne 0x5fb93
movl %ecx, %edx
shll $0x8, %edx
orl %ecx, %edx
shll $0x10, %ecx
andl $0xff000000, %eax       # imm = 0xFF000000
orl %ecx, %eax
orl %edx, %eax
cltq
movq %rax, 0x18(%rsp)
movl $0x1, 0x10(%rsp)
jmp 0x5fbae
movl %ecx, %eax
shll $0x10, %eax
movl %ecx, %edx
shll $0x8, %edx
orl %eax, %edx
orl %ecx, %edx
movq %rdx, 0x18(%rsp)
movl $0x0, 0x10(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x58(%rax)
movl 0x8(%rsp), %ecx
incl %ecx
movl %ecx, 0x8(%rsp)
movl 0x10(%rbx), %eax
cmpl %eax, %ecx
jl 0x5fb37
movl 0xc(%rsp), %edx
movl 0x14(%rbx), %ecx
incl %edx
movl %edx, 0xc(%rsp)
cmpl %ecx, %edx
jl 0x5fb27
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/backends/bitmapbackend.cpp
// Function: smooth::GUI::BitmapBackend::InvertColors()
S::Int S::GUI::BitmapBackend::InvertColors()
{
	Point	 point;

	for (point.y = 0; point.y < size.cy; point.y++)
	{
		for (point.x = 0; point.x < size.cx; point.x++)
		{
			Color	 pixel = GetPixel(point);

			Int	 red   = 255 - pixel.GetRed();
			Int	 green = 255 - pixel.GetGreen();
			Int	 blue  = 255 - pixel.GetBlue();

			if (depth == 32) SetPixel(point, Color(red | (green << 8) | (blue << 16) | (pixel.GetAlpha() << 24), Color::RGBA));
			else		 SetPixel(point, Color(red, green, blue));
		}
	}

	return Success();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl $0x0, 0xc(%rsp)
movl 0x14(%rdi), %ecx
testl %ecx, %ecx
jle 0x5fce2
movq %rdi, %rbx
movl 0x10(%rdi), %eax
xorl %edx, %edx
leaq 0x20(%rsp), %r14
leaq 0x8(%rsp), %r15
movl $0xff, %ebp
leaq 0x10(%rsp), %r12
movl $0x0, 0x8(%rsp)
testl %eax, %eax
jle 0x5fcd4
movq (%rbx), %rax
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq *0x60(%rax)
movl 0x28(%rsp), %edx
movl %edx, %ecx
notl %ecx
movl %ecx, %eax
andl %ebp, %eax
movl %ecx, %esi
shrl $0x8, %esi
andl %ebp, %esi
shrl $0x10, %ecx
andl %ebp, %ecx
cmpb $0x20, 0xa(%rbx)
jne 0x5fc92
shll $0x8, %esi
shll $0x10, %ecx
orl %esi, %ecx
andl $0xff000000, %edx       # imm = 0xFF000000
orl %ecx, %edx
orl %eax, %edx
movslq %edx, %rax
movq %rax, 0x18(%rsp)
movl $0x1, 0x10(%rsp)
jmp 0x5fca9
shll $0x10, %ecx
shll $0x8, %esi
orl %ecx, %esi
orl %eax, %esi
movq %rsi, 0x18(%rsp)
movl $0x0, 0x10(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x58(%rax)
movl 0x8(%rsp), %ecx
incl %ecx
movl %ecx, 0x8(%rsp)
movl 0x10(%rbx), %eax
cmpl %eax, %ecx
jl 0x5fc41
movl 0xc(%rsp), %edx
movl 0x14(%rbx), %ecx
incl %edx
movl %edx, 0xc(%rsp)
cmpl %ecx, %edx
jl 0x5fc31
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/backends/bitmapbackend.cpp
// Function: smooth::GUI::BitmapBackend::ReplaceColor(smooth::GUI::Color const&, smooth::GUI::Color const&)
S::Int S::GUI::BitmapBackend::ReplaceColor(const Color &iColor1, const Color &iColor2)
{
	Color	 color1 = iColor1.ConvertTo(Color::RGB);
	Color	 color2 = iColor2.ConvertTo(Color::RGB);

	Point	 point;

	for (point.y = 0; point.y < size.cy; point.y++)
	{
		for (point.x = 0; point.x < size.cx; point.x++)
		{
			Color	 pixel = GetPixel(point);

			if (pixel.ConvertTo(Color::RGB) != color1) continue;

			if (depth == 32) SetPixel(point, Color(Long(color2) | (pixel.GetAlpha() << 24), Color::RGBA));
			else		 SetPixel(point, color2);
		}
	}

	return Success();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %rdi
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x57d10
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x57d10
movl $0x0, 0x4(%rsp)
movl 0x14(%rbx), %ecx
testl %ecx, %ecx
jle 0x5fde2
movl 0x10(%rbx), %eax
leaq 0x28(%rsp), %r14
movq %rsp, %r15
leaq 0x8(%rsp), %r12
leaq 0x18(%rsp), %r13
movl $0x0, (%rsp)
testl %eax, %eax
jle 0x5fdd4
movq (%rbx), %rax
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq *0x60(%rax)
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x57d10
movq 0x10(%rsp), %rax
cmpq 0x40(%rsp), %rax
jne 0x5fdbe
cmpb $0x20, 0xa(%rbx)
jne 0x5fdaf
movslq 0x30(%rsp), %rax
andq $-0x1000000, %rax       # imm = 0xFF000000
orq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x1, 0x8(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
jmp 0x5fdbb
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq *0x58(%rax)
movl (%rsp), %ecx
incl %ecx
movl %ecx, (%rsp)
movl 0x10(%rbx), %eax
cmpl %eax, %ecx
jl 0x5fd56
movl 0x4(%rsp), %ebp
movl 0x14(%rbx), %ecx
incl %ebp
movl %ebp, 0x4(%rsp)
cmpl %ecx, %ebp
jl 0x5fd4b
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/backends/bitmapbackend.cpp
// Function: smooth::GUI::BitmapBackend::SetBackgroundColor(smooth::GUI::Color const&)
S::Int S::GUI::BitmapBackend::SetBackgroundColor(const Color &iColor)
{
	if (depth != 32) return Success();

	Color	 color = iColor.ConvertTo(Color::RGB);

	Point	 point;

	for (point.y = 0; point.y < size.cy; point.y++)
	{
		for (point.x = 0; point.x < size.cx; point.x++)
		{
			Color	 pixel = GetPixel(point);

			if (pixel.GetAlpha() != 255)
			{
				Color	 result = Color((pixel.GetRed()   * pixel.GetAlpha() + color.GetRed()   * (255 - pixel.GetAlpha())) / 255,
							(pixel.GetGreen() * pixel.GetAlpha() + color.GetGreen() * (255 - pixel.GetAlpha())) / 255,
							(pixel.GetBlue()  * pixel.GetAlpha() + color.GetBlue()  * (255 - pixel.GetAlpha())) / 255);

				SetPixel(point, 255 << 24 | result);
			}
		}
	}

	return Success();
}

// Assembly:
cmpb $0x20, 0xa(%rdi)
jne 0x5ff54
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
xorl %r13d, %r13d
xorl %edx, %edx
callq 0x57d10
movl $0x0, 0x4(%rsp)
movl 0x14(%rbx), %ecx
testl %ecx, %ecx
jle 0x5ff46
movl 0x10(%rbx), %eax
leaq 0x18(%rsp), %r14
movq %rsp, %r15
movl $0xff, %ebp
leaq 0x8(%rsp), %r12
movl $0x0, (%rsp)
testl %eax, %eax
jle 0x5ff35
movq (%rbx), %rax
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq *0x60(%rax)
movl 0x20(%rsp), %eax
movl %eax, %ecx
shrl $0x18, %ecx
cmpl $0xff, %ecx
je 0x5ff1a
movl %eax, %esi
andl %ebp, %esi
imull %ecx, %esi
movl 0x30(%rsp), %edx
movl %edx, %r8d
andl %ebp, %r8d
movl %ecx, %edi
xorl %ebp, %edi
imull %edi, %r8d
addl %esi, %r8d
imulq $0x1010102, %r8, %rsi   # imm = 0x1010102
shrq $0x20, %rsi
movl %eax, %r8d
shrl $0x8, %r8d
andl %ebp, %r8d
imull %ecx, %r8d
movl %edx, %r9d
shrl $0x8, %r9d
andl %ebp, %r9d
imull %edi, %r9d
addl %r8d, %r9d
imulq $0x1010102, %r9, %r8    # imm = 0x1010102
shrq $0x20, %r8
shrl $0x10, %eax
andl %ebp, %eax
imull %ecx, %eax
shrl $0x10, %edx
andl %ebp, %edx
imull %edi, %edx
addl %eax, %edx
imulq $0x1010102, %rdx, %rax  # imm = 0x1010102
shrq $0x20, %rax
shll $0x10, %eax
shll $0x8, %r8d
orl %esi, %r8d
orl %eax, %r8d
orl $0xff000000, %r8d       # imm = 0xFF000000
movslq %r8d, %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x58(%rax)
movl (%rsp), %ecx
incl %ecx
movl %ecx, (%rsp)
movl 0x10(%rbx), %eax
cmpl %eax, %ecx
jl 0x5fe55
movl 0x4(%rsp), %r13d
movl 0x14(%rbx), %ecx
incl %r13d
movl %r13d, 0x4(%rsp)
cmpl %ecx, %r13d
jl 0x5fe46
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/backends/fontbackend.cpp
// Function: smooth::GUI::FontBackend::FontBackend(smooth::String const&, short, short, short, smooth::GUI::Color const&)
S::GUI::FontBackend::FontBackend(const String &iFontName, Short iFontSize, Short iFontWeight, Short iFontStyle, const Color &iFontColor)
{
#if defined __WIN32__ && defined SMOOTH_STATIC
	volatile Bool	 null = 0;

	if (null) FontGDI();
#endif

	type = FONT_NONE;

	fontName   = iFontName;
	fontSize   = iFontSize;
	fontColor  = iFontColor;
	fontWeight = iFontWeight;
	fontStyle  = iFontStyle;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movl %r8d, 0x4(%rsp)
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r15
leaq 0xff961(%rip), %rax     # 0x15fdd0
movq %rax, (%rdi)
leaq 0x10(%rdi), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x58e20
movq $0x0, 0x30(%r15)
movl $0x0, 0x28(%r15)
movw $0x0, 0x8(%r15)
movq %r13, %rdi
movq %rbx, %rsi
callq 0x555f0
leaq 0x28(%r15), %rax
movw %r12w, 0xa(%r15)
movups (%r14), %xmm0
movups %xmm0, (%rax)
movw %bp, 0x38(%r15)
movl 0x4(%rsp), %eax
movw %ax, 0x3a(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r13, %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/backends/fontbackend.cpp
// Function: smooth::GUI::FontBackend::GetTextSizeX(smooth::String const&, bool) const
S::Int S::GUI::FontBackend::GetTextSizeX(const String &text, Bool scaled) const
{
	if (text == NIL) return 0;

	Int	 length	= text.Length();
	Int	 offset	= 0;
	Int	 sizex	= 0;

	for (Int i = 0; i <= length; i++)
	{
		if (i < length && text[i] != '\n') continue;

		sizex  = (Int) Math::Max(sizex, GetTextSize(text.SubString(offset, i - offset), scaled).cx);
		offset = i + 1;
	}

	return sizex;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
xorl %ebp, %ebp
movq %rsi, %rdi
xorl %esi, %esi
callq 0x55260
testb %al, %al
jne 0x605da
movq %rbx, %rdi
callq 0x57180
testl %eax, %eax
js 0x605da
movl %eax, %r15d
leal 0x1(%r15), %eax
movl %eax, 0x4(%rsp)
xorl %r13d, %r13d
leaq 0x10(%rsp), %r12
movzbl %r14b, %eax
movl %eax, (%rsp)
xorl %ebp, %ebp
xorl %r14d, %r14d
cmpl %r15d, %r14d
jge 0x6058f
movq %rbx, %rdi
movl %r14d, %esi
callq 0x57fe0
cmpl $0xa, %eax
jne 0x605d0
movl %r14d, %ecx
subl %r13d, %ecx
movq %r12, %rdi
movq %rbx, %rsi
movl %r13d, %edx
callq 0x58f50
movq 0x8(%rsp), %rdi
movq %r12, %rsi
movl (%rsp), %edx
callq 0x60600
movq %rax, %r13
cmpl %r13d, %ebp
cmovgl %ebp, %r13d
movq %r12, %rdi
callq 0x59200
incl %r14d
movl %r13d, %ebp
movl %r14d, %r13d
jmp 0x605d3
incl %r14d
cmpl 0x4(%rsp), %r14d
jne 0x6057a
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/backends/fontbackend.cpp
// Function: smooth::GUI::FontBackend::GetTextSizeY(smooth::String const&, bool) const
S::Int S::GUI::FontBackend::GetTextSizeY(const String &text, Bool scaled) const
{
	if (text == NIL) return 0;

	Int	 length	= text.Length();
	Int	 lines	= 1;

	for (Int i = 0; i < length; i++)
	{
		if (text[i] == '\n') lines++;
	}

	/* Line height is always the same regardless of the actual text,
	 * so we use a default text here and multiply by the numer of lines.
	 */
	static String	 string	= "abcdefghijklmnopqrstuvwxyz";

	return (lines * (GetTextSize(string, scaled).cy - 1)) + (lines - 1) * 3;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movq %rsi, %rdi
xorl %esi, %esi
callq 0x55260
testb %al, %al
jne 0x6094a
movq %r14, %rdi
callq 0x57180
testl %eax, %eax
jle 0x60914
movl %eax, %r15d
xorl %r12d, %r12d
movl $0x1, %r13d
movq %r14, %rdi
movl %r12d, %esi
callq 0x57fe0
xorl %ecx, %ecx
cmpl $0xa, %eax
sete %cl
addl %ecx, %r13d
incl %r12d
cmpl %r12d, %r15d
jne 0x608f4
jmp 0x6091a
movl $0x1, %r13d
movb 0x10de70(%rip), %al     # 0x16e790
testb %al, %al
je 0x6095c
movzbl %bpl, %edx
leaq 0x10de49(%rip), %rsi    # 0x16e778
movq %rbx, %rdi
callq 0x60600
movq %rax, %r15
shrq $0x20, %r15
addl $0x2, %r15d
imull %r13d, %r15d
addl $-0x3, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10de2d(%rip), %rdi    # 0x16e790
callq 0x56120
testl %eax, %eax
je 0x60924
leaq 0x10de05(%rip), %rdi    # 0x16e778
leaq 0x92bd6(%rip), %rsi     # 0xf3550
callq 0x579f0
movq 0x10b5aa(%rip), %rdi    # 0x16bf30
leaq 0x10ddeb(%rip), %rsi    # 0x16e778
leaq 0x10d6ec(%rip), %rdx    # 0x16e080
callq 0x57e10
leaq 0x10ddf0(%rip), %rdi    # 0x16e790
callq 0x56b80
jmp 0x60924
movq %rax, %rbx
leaq 0x10dddc(%rip), %rdi    # 0x16e790
callq 0x56420
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/backends/surfacebackend.cpp
// Function: smooth::GUI::SurfaceBackend::SurfaceBackend(void*, smooth::GUI::Size const&)
S::GUI::SurfaceBackend::SurfaceBackend(Void *iSurface, const Size &maxSize)
{
#if defined __WIN32__ && defined SMOOTH_STATIC
	volatile Bool	 null = 0;

	if (null) SurfaceGDI();
#endif

	type = SURFACE_NONE;

	size.cx	= 0;
	size.cy	= 0;

	paintRect.left = -1;
	paintRect.top = -1;
	paintRect.right = -1;
	paintRect.bottom = -1;

	painting = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xff2aa(%rip), %rax     # 0x15fe58
movq %rax, (%rdi)
leaq 0x24(%rdi), %r14
pxor %xmm0, %xmm0
movdqu %xmm0, 0xc(%rdi)
movq $0x0, 0x1c(%rdi)
movq %r14, %rdi
callq 0x62fb0
leaq 0x28(%rbx), %rdi
callq 0x63288
movq $0x0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x62fb6
movq %rbx, %rdi
callq 0x57090