LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x5db85
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x58fa0
leaq 0xb55c6(%rip), %rsi     # 0x113126
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 0x5db9b
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 0x5dbbf
movq (%r12), %rax
movq %rax, 0x8(%rsp)
testq %r15, %r15
je 0x5dbcb
movq (%r15), %rax
movq %rax, (%rsp)
testq %r14, %r14
je 0x5dbd8
movq (%r14), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x58fa0
leaq 0xb5537(%rip), %rsi     # 0x113126
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 0x5db87
jmp 0x5dc18
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x5e13e
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x58fa0
leaq 0xb5014(%rip), %rsi     # 0x113126
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 0x5e13c
movq 0x48(%rsp), %rax
jmp 0x5e13e
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_O1/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 0x5e3d4
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x58fa0
leaq 0xb4e69(%rip), %rsi     # 0x113126
movq %rbx, %rdi
callq 0x57940
leaq 0x96091(%rip), %rsi     # 0xf435d
movq %rax, %rdi
callq 0x586e0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x59200
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x58fa0
leaq 0xb4e2e(%rip), %rsi     # 0x113126
movq %r12, %rdi
callq 0x57940
leaq 0x96059(%rip), %rsi     # 0xf4360
movq %rax, %rdi
callq 0x586e0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x59200
testq %rbx, %rbx
sete %al
testq %r14, %r14
sete %cl
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
orb %al, %cl
jne 0x5e3ba
movq %rbx, 0x8(%rsp)
movq %r15, %rdi
callq 0x56890
movq %rax, %r12
movl $0x8000, %edi           # imm = 0x8000
callq 0x56670
movq %rax, %r15
testl %r12d, %r12d
setne %bl
je 0x5e3a8
movl $0x8000, %ebp           # imm = 0x8000
cmpl %ebp, %r12d
cmovll %r12d, %ebp
movslq %ebp, %r13
movl $0x1, %edx
movq %r15, %rdi
movq %r13, %rsi
movq 0x8(%rsp), %rcx
callq 0x56a20
cmpq $0x1, %rax
jne 0x5e3a8
movl $0x1, %edx
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rcx
callq 0x588d0
subl %ebp, %r12d
setne %bl
je 0x5e3a8
cmpl %r12d, %ebp
cmovgel %r12d, %ebp
jmp 0x5e366
movq %r15, %rdi
callq 0x561e0
movzbl %bl, %ebp
negl %ebp
movq 0x8(%rsp), %rbx
testq %rbx, %rbx
je 0x5e3c7
movq %rbx, %rdi
callq 0x564b0
testq %r14, %r14
je 0x5e3d4
movq %r14, %rdi
callq 0x564b0
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5e3e7
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/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 0x5e47c
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x58fa0
leaq 0xb4cf4(%rip), %rsi     # 0x113126
movq %r15, %rdi
callq 0x57940
movq %rax, %r14
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x58fa0
leaq 0xb4cd7(%rip), %rsi     # 0x113126
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 0x5e498
jmp 0x5e495
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/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 0x5e4f9
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x58fa0
leaq 0xb4c4d(%rip), %rsi     # 0x113126
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_O1/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 0x5e7a5
movq (%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x78(%rax)
movb $0x1, %bpl
testb %al, %al
jne 0x5e8c2
movq (%r14), %rdi
movq (%rdi), %rax
xorl %ebp, %ebp
xorl %esi, %esi
callq *0x78(%rax)
testb %al, %al
jne 0x5e8c2
movq (%rbx), %rdi
movq (%rdi), %rax
xorl %ebp, %ebp
xorl %esi, %esi
callq *0x78(%rax)
testb %al, %al
jne 0x5e8c2
movq (%r14), %rdi
callq 0x5fa8c
movq %rax, %r15
movq (%rbx), %rdi
callq 0x5fa8c
movl (%r15), %ecx
xorl %ebp, %ebp
cmpl (%rax), %ecx
jne 0x5e8c2
movl 0x4(%rax), %eax
cmpl %eax, 0x4(%r15)
jne 0x5e8c2
movq (%r14), %rdi
callq 0x5fa92
movl %eax, %ebp
movq (%rbx), %rdi
callq 0x5fa92
cmpb %al, %bpl
jne 0x5e8c0
movq (%r14), %rdi
callq 0x5fa9c
movl %eax, %ebp
movq (%rbx), %rdi
callq 0x5fa9c
cmpb %al, %bpl
jne 0x5e8c0
movq (%r14), %rdi
callq 0x5faa0
movl %eax, %ebp
movq (%rbx), %rdi
callq 0x5faa0
cmpb %al, %bpl
jne 0x5e8c0
movq (%r14), %rdi
callq 0x5fa8c
movl (%rax), %r15d
movslq 0x4(%rax), %r12
movq (%r14), %rdi
callq 0x5fa9c
movl %eax, %ebp
movq (%r14), %rdi
callq 0x5faa0
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
cltd
idivl %esi
addl %ecx, %edx
movslq %edx, %r15
imulq %r12, %r15
movq (%r14), %rdi
callq 0x5fa96
movq %rax, %r14
movq (%rbx), %rdi
callq 0x5fa96
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x57320
testl %eax, %eax
sete %bpl
jmp 0x5e8c2
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
jne 0x5efea
movq %r15, 0x8(%rbx)
movl (%r14), %eax
jmp 0x5f069
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, %rcx
movl (%r14), %eax
movq %rcx, 0x8(%rbx)
movl %eax, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r12
cmpl $0x8, %edx
jne 0x5f0a2
movq %r12, 0x8(%rbx)
movl (%r14), %eax
jmp 0x5f1b4
movl %edx, %r15d
movl $0x2, %edi
movl %edx, %esi
callq 0x56010
addsd 0x952f7(%rip), %xmm0    # 0xf43b0
cvttsd2si %xmm0, %eax
andl %eax, %r12d
movq 0x8(%r14), %r13
movl %r15d, %ecx
sarq %cl, %r13
movl $0x2, %edi
movl %r15d, %esi
callq 0x56010
addsd 0x952d1(%rip), %xmm0    # 0xf43b0
cvttsd2si %xmm0, %eax
andl %eax, %r13d
movq 0x8(%r14), %rbp
leal (%r15,%r15), %ecx
sarq %cl, %rbp
movl $0x2, %edi
movl %r15d, %esi
callq 0x56010
addsd 0x952aa(%rip), %xmm0    # 0xf43b0
cvttsd2si %xmm0, %eax
andl %eax, %ebp
movl $0x2, %edi
movl %r15d, %esi
callq 0x56010
addsd 0x9528f(%rip), %xmm0    # 0xf43b0
movsd 0x9523f(%rip), %xmm1    # 0xf4368
cvtsi2sd %r12d, %xmm2
divsd %xmm0, %xmm1
mulsd %xmm1, %xmm2
cvttsd2si %xmm2, %r12d
movl $0x2, %edi
movl %r15d, %esi
callq 0x56010
addsd 0x95260(%rip), %xmm0    # 0xf43b0
movsd 0x95210(%rip), %xmm1    # 0xf4368
xorps %xmm2, %xmm2
cvtsi2sd %r13d, %xmm2
divsd %xmm0, %xmm1
mulsd %xmm1, %xmm2
cvttsd2si %xmm2, %r13d
movl $0x2, %edi
movl %r15d, %esi
callq 0x56010
addsd 0x9522e(%rip), %xmm0    # 0xf43b0
xorps %xmm1, %xmm1
cvtsi2sd %ebp, %xmm1
movsd 0x951d7(%rip), %xmm2    # 0xf4368
divsd %xmm0, %xmm2
mulsd %xmm2, %xmm1
cvttsd2si %xmm1, %ecx
movl (%r14), %eax
shll $0x10, %ecx
shll $0x8, %r13d
orl %r12d, %r13d
orl %ecx, %r13d
movslq %r13d, %rcx
movq %rcx, 0x8(%rbx)
movl %eax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/graphics/font.cpp
// Function: smooth::GUI::Font::Font(smooth::String const&, short, short, short, smooth::GUI::Color const&)
S::GUI::Font::Font(const String &iFontName, Short iFontSize, Short iFontWeight, Short iFontStyle, const Color &iFontColor)
{
	fontName   = iFontName;
	fontSize   = iFontSize;
	fontColor  = iFontColor;
	fontWeight = iFontWeight;
	fontStyle  = iFontStyle;

	backend = FontBackend::CreateBackendInstance(fontName, fontSize, fontWeight, fontStyle, fontColor);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movl %r8d, %ebp
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58e20
movq $0x0, 0x30(%r14)
movl $0x0, 0x28(%r14)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x555f0
leaq 0x28(%r14), %r8
movw %r12w, 0x8(%r14)
movq (%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, (%r8)
movw %r15w, 0x38(%r14)
movw %bp, 0x3a(%r14)
movswl %r12w, %esi
movswl %r15w, %edx
movswl %bp, %ecx
movq %rbx, %rdi
callq 0x603b4
movq %rax, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
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/graphics/font.cpp
// Function: smooth::GUI::Font::Font(smooth::GUI::Font const&)
S::GUI::Font::Font(const Font &iFont)
{
	fontName   = iFont.fontName;
	fontSize   = iFont.fontSize;
	fontColor  = iFont.fontColor;
	fontWeight = iFont.fontWeight;
	fontStyle  = iFont.fontStyle;

	backend = FontBackend::CreateBackendInstance(fontName, fontSize, fontWeight, fontStyle, fontColor);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58e20
movq $0x0, 0x30(%r14)
movl $0x0, 0x28(%r14)
leaq 0x10(%r15), %rsi
movq %rbx, %rdi
callq 0x555f0
leaq 0x28(%r14), %r8
movswl 0x8(%r15), %esi
movw %si, 0x8(%r14)
movups 0x28(%r15), %xmm0
movups %xmm0, (%r8)
movswl 0x38(%r15), %edx
movw %dx, 0x38(%r14)
movswl 0x3a(%r15), %ecx
movw %cx, 0x3a(%r14)
movq %rbx, %rdi
callq 0x603b4
movq %rax, (%r14)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x59200
movq %r14, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/graphics/font.cpp
// Function: smooth::GUI::Font::operator=(smooth::GUI::Font const&)
S::GUI::Font &S::GUI::Font::operator =(const Font &newFont)
{
	SetName(newFont.GetName());
	SetSize(newFont.GetSize());
	SetColor(newFont.GetColor());
	SetWeight(newFont.GetWeight());
	SetStyle(newFont.GetStyle());

	return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsi), %r15
movq (%rdi), %rdi
addq $0x10, %rdi
movq %r15, %rsi
callq 0x555f0
leaq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x555f0
movzwl 0x8(%r14), %eax
movq (%rbx), %rcx
movw %ax, 0xa(%rcx)
movw %ax, 0x8(%rbx)
movups 0x28(%r14), %xmm0
movups %xmm0, 0x28(%rcx)
movups 0x28(%r14), %xmm0
movups %xmm0, 0x28(%rbx)
movzwl 0x38(%r14), %eax
movq (%rbx), %rcx
movw %ax, 0x38(%rcx)
movw %ax, 0x38(%rbx)
movzwl 0x3a(%r14), %eax
movw %ax, 0x3a(%rcx)
movw %ax, 0x3a(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5f450
movzwl 0x8(%r14), %eax
cmpw 0x8(%rbx), %ax
jne 0x5f450
movq 0x30(%r14), %rax
cmpq 0x30(%rbx), %rax
jne 0x5f450
movzwl 0x38(%r14), %eax
cmpw 0x38(%rbx), %ax
jne 0x5f450
movzwl 0x3a(%r14), %ecx
movb $0x1, %al
cmpw 0x3a(%rbx), %cx
je 0x5f452
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/graphics/surface.cpp
// Function: smooth::GUI::Surface::SetSize(smooth::GUI::Size const&)
S::Int S::GUI::Surface::SetSize(const Size &nSize)
{
	backend->Lock();

	Int	 rVal = backend->SetSize(nSize);

	backend->Release();

	return rVal;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x20(%rax)
movl %eax, %ebx
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/graphics/surface.cpp
// Function: smooth::GUI::Surface::PaintRect(smooth::GUI::Rect const&)
S::Int S::GUI::Surface::PaintRect(const Rect &pRect)
{
	backend->Lock();

	Int	 rVal = backend->PaintRect(pRect);

	backend->Release();

	return rVal;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x30(%rax)
movl %eax, %ebx
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/graphics/surface.cpp
// Function: smooth::GUI::Surface::SetPixel(smooth::GUI::Point const&, smooth::GUI::Color const&)
S::Int S::GUI::Surface::SetPixel(const Point &point, const Color &color)
{
	backend->Lock();

	Int	 rVal = backend->SetPixel(point, color);

	backend->Release();

	return rVal;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x58(%rax)
movl %eax, %ebx
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/graphics/surface.cpp
// Function: smooth::GUI::Surface::Line(smooth::GUI::Point const&, smooth::GUI::Point const&, smooth::GUI::Color const&)
S::Int S::GUI::Surface::Line(const Point &pos1, const Point &pos2, const Color &color)
{
	backend->Lock();

	Int	 rVal = backend->Line(pos1, pos2, color);

	backend->Release();

	return rVal;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r12), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq *0x60(%rax)
movl %eax, %ebx
movq (%r12), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/graphics/surface.cpp
// Function: smooth::GUI::Surface::Frame(smooth::GUI::Rect const&, short)
S::Int S::GUI::Surface::Frame(const Rect &rect, Short style)
{
	backend->Lock();

	Int	 rVal = backend->Frame(rect, style);

	backend->Release();

	return rVal;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *0x68(%rax)
movl %eax, %ebx
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/graphics/surface.cpp
// Function: smooth::GUI::Surface::Box(smooth::GUI::Rect const&, smooth::GUI::Color const&, int, smooth::GUI::Size const&)
S::Int S::GUI::Surface::Box(const Rect &rect, const Color &color, Int style, const Size &ellipse)
{
	backend->Lock();

	Int	 rVal = backend->Box(rect, color, style, ellipse);

	backend->Release();

	return rVal;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r12), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movq %rbx, %r8
callq *0x70(%rax)
movl %eax, %ebx
movq (%r12), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/graphics/surface.cpp
// Function: smooth::GUI::Surface::SetText(smooth::String const&, smooth::GUI::Rect const&, smooth::GUI::Font const&, bool)
S::Int S::GUI::Surface::SetText(const String &string, const Rect &rect, const Font &font, Bool shadow)
{
	backend->Lock();

	Int	 rVal = backend->SetText(string, rect, font, shadow);

	backend->Release();

	return rVal;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r13), %rdi
movq (%rdi), %rax
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebx, %r8d
callq *0x78(%rax)
movl %eax, %ebx
movq (%r13), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/graphics/surface.cpp
// Function: smooth::GUI::Surface::Bar(smooth::GUI::Point const&, smooth::GUI::Point const&, int)
S::Int S::GUI::Surface::Bar(const Point &p1, const Point &p2, Int orientation)
{
	backend->Lock();

	Int	 rVal = backend->Bar(p1, p2, orientation);

	backend->Release();

	return rVal;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r12), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq *0x88(%rax)
movl %eax, %ebx
movq (%r12), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/graphics/surface.cpp
// Function: smooth::GUI::Surface::BlitFromBitmap(smooth::GUI::Bitmap const&, smooth::GUI::Rect const&, smooth::GUI::Rect const&)
S::Int S::GUI::Surface::BlitFromBitmap(const Bitmap &bitmap, const Rect &srcRect, const Rect &destRect)
{
	backend->Lock();

	Int	 rVal = backend->BlitFromBitmap(bitmap, srcRect, destRect);

	backend->Release();

	return rVal;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r12), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq *0x90(%rax)
movl %eax, %ebx
movq (%r12), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x1012eb(%rip), %rax    # 0x160d08
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_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
xorl %edx, %edx
callq 0x57d10
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x57d10
movq $0x0, 0x8(%rsp)
cmpl $0x0, 0x14(%rbx)
jle 0x5fd9b
leaq 0x30(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0x20(%rsp), %r13
movl $0x0, 0x8(%rsp)
cmpl $0x0, 0x10(%rbx)
jle 0x5fd88
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 0x18(%rsp), %rax
cmpq 0x48(%rsp), %rax
jne 0x5fd79
cmpb $0x20, 0xa(%rbx)
jne 0x5fd6a
movslq 0x38(%rsp), %rax
andq $-0x1000000, %rax       # imm = 0xFF000000
orq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x1, 0x10(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
jmp 0x5fd76
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq *0x58(%rax)
movl 0x8(%rsp), %eax
incl %eax
movl %eax, 0x8(%rsp)
cmpl 0x10(%rbx), %eax
jl 0x5fd11
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
cmpl 0x14(%rbx), %eax
jl 0x5fd03
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x5ff01
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
xorl %edx, %edx
callq 0x57d10
movq $0x0, 0x8(%rsp)
cmpl $0x0, 0x14(%rbx)
jle 0x5fef5
leaq 0x20(%rsp), %r14
leaq 0x8(%rsp), %r15
movl $0xff, %ebp
leaq 0x10(%rsp), %r12
movl $0x0, 0x8(%rsp)
cmpl $0x0, 0x10(%rbx)
jle 0x5fee2
movq (%rbx), %rax
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq *0x60(%rax)
movl 0x28(%rsp), %eax
movl %eax, %ecx
shrl $0x18, %ecx
cmpl $0xff, %ecx
je 0x5fecf
movl %eax, %esi
andl %ebp, %esi
imull %ecx, %esi
movl 0x38(%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, 0x18(%rsp)
movl $0x0, 0x10(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x58(%rax)
movl 0x8(%rsp), %eax
incl %eax
movl %eax, 0x8(%rsp)
cmpl 0x10(%rbx), %eax
jl 0x5fe0a
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
cmpl 0x14(%rbx), %eax
jl 0x5fdf8
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1009cd(%rip), %rax    # 0x160db0
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_O1/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 $0x38, %rsp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, 0x18(%rsp)
xorl %ebp, %ebp
movq %rsi, %rdi
xorl %esi, %esi
callq 0x55260
testb %al, %al
jne 0x60553
movq %rbx, %rdi
callq 0x57180
movq %rax, 0x10(%rsp)
testl %eax, %eax
js 0x60553
movq 0x10(%rsp), %rax
incl %eax
movl %eax, 0xc(%rsp)
xorl %r13d, %r13d
leaq 0x20(%rsp), %r12
movzbl %r14b, %eax
movl %eax, 0x8(%rsp)
xorl %ebp, %ebp
xorl %r14d, %r14d
cmpl 0x10(%rsp), %r14d
jge 0x6050b
movq %rbx, %rdi
movl %r14d, %esi
callq 0x57fe0
cmpl $0xa, %eax
jne 0x60549
movl %r14d, %ecx
subl %r13d, %ecx
movq %r12, %rdi
movq %rbx, %rsi
movl %r13d, %edx
callq 0x58f50
movq 0x18(%rsp), %rdi
movq %r12, %rsi
movl 0x8(%rsp), %edx
callq 0x6057a
movq %rax, %r15
cmpl %r15d, %ebp
cmovgl %ebp, %r15d
movq %r12, %rdi
callq 0x59200
leal 0x1(%r14), %r13d
movl %r15d, %ebp
incl %r14d
cmpl %r14d, 0xc(%rsp)
jne 0x604f4
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x608f0
movq %r14, %rdi
callq 0x57180
testl %eax, %eax
jle 0x608ba
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 0x6089a
jmp 0x608c0
movl $0x1, %r13d
movb 0x10eeca(%rip), %al     # 0x16f790
testb %al, %al
je 0x60902
movzbl %bpl, %edx
leaq 0x10eea3(%rip), %rsi    # 0x16f778
movq %rbx, %rdi
callq 0x6057a
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 0x10ee87(%rip), %rdi    # 0x16f790
callq 0x56120
testl %eax, %eax
je 0x608ca
leaq 0x10ee5f(%rip), %rdi    # 0x16f778
leaq 0x93bd8(%rip), %rsi     # 0xf44f8
callq 0x579f0
movq 0x10c604(%rip), %rdi    # 0x16cf30
leaq 0x10ee45(%rip), %rsi    # 0x16f778
leaq 0x10e746(%rip), %rdx    # 0x16f080
callq 0x57e10
leaq 0x10ee4a(%rip), %rdi    # 0x16f790
callq 0x56b80
jmp 0x608ca
movq %rax, %rbx
leaq 0x10ee36(%rip), %rdi    # 0x16f790
callq 0x56420
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/graphics/backends/fontbackend.cpp
// Function: smooth::ExtentsCacheEntry::ExtentsCacheEntry(smooth::String const&, smooth::String const&, int, int, int)
ExtentsCacheEntry(const String &text,
							   const String &fontName,
							   Int fontSize,
							   Int fontWeight,
							   Int fontStyle)	{ crc32 = String(text).Append(fontName)
												      .Append(String::FromInt(fontSize	 << 16 |
															      fontWeight <<  4 |
															      fontStyle)).ComputeCRC32(); }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %ebp
movl %r8d, %r14d
movl %ecx, %r12d
movq %rdx, %r15
movq %rdi, %rbx
movq $0x0, 0x4(%rdi)
leaq 0x20(%rsp), %r13
movq %r13, %rdi
callq 0x570b0
movq %r13, %rdi
movq %r15, %rsi
callq 0x562f0
movq %rax, %r15
shll $0x10, %r12d
shll $0x4, %r14d
orl %r12d, %r14d
orl %ebp, %r14d
movslq %r14d, %rsi
leaq 0x8(%rsp), %rdi
callq 0x56cf0
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x562f0
movq %rax, %rdi
callq 0x55640
movl %eax, (%rbx)
leaq 0x8(%rsp), %rdi
callq 0x59200
leaq 0x20(%rsp), %rdi
callq 0x59200
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x60a03
movq %rax, %rbx
jmp 0x60a15
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
leaq 0x20(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x1002e2(%rip), %rax    # 0x160e38
movq %rax, (%rdi)
leaq 0x24(%rdi), %r14
pxor %xmm0, %xmm0
movdqu %xmm0, 0xc(%rdi)
movq $0x0, 0x1c(%rdi)
movq %r14, %rdi
callq 0x62f28
leaq 0x28(%rbx), %rdi
callq 0x63254
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 0x62f2e
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/graphics/backends/surfacebackend.cpp
// Function: smooth::GUI::SurfaceBackend::SetText(smooth::String const&, smooth::GUI::Rect const&, smooth::GUI::Font const&, bool)
S::Int S::GUI::SurfaceBackend::SetText(const String &string, const Rect &iRect, const Font &iFont, Bool shadow)
{
	if (shadow)
	{
		Rect	 rect = iRect + Point(2, 2);
		Font	 font = iFont;
		Int	 fontColor = font.GetColor();

		font.SetColor(Color((Int) ((Float) Setup::BackgroundColor.GetRed() / 3 * 2), (Int) ((Float) Setup::BackgroundColor.GetGreen() / 3 * 2), (Int) ((Float) Setup::BackgroundColor.GetBlue() / 3 * 2)));

		SetText(string, rect, font, False);

		rect = rect - Point(2, 2);

		font.SetColor(fontColor);

		SetText(string, rect, font, False);
	}

	return Success();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
testl %r8d, %r8d
je 0x61079
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdx), %eax
movl 0x4(%rdx), %esi
addl $0x2, %eax
addl $0x2, %esi
shlq $0x20, %rsi
movl 0x8(%rdx), %edi
movl 0xc(%rdx), %edx
addl $0x2, %edi
addl $0x2, %edx
orq %rsi, %rax
shlq $0x20, %rdx
orq %rdx, %rdi
movq %rax, (%rsp)
movq %rdi, 0x8(%rsp)
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rcx, %rsi
callq 0x55b70
movq %r15, %rdi
callq 0x57550
movq 0x8(%rax), %r15
movq 0x10b559(%rip), %rax    # 0x16c4d0
movl 0x8(%rax), %eax
movl $0xff, %ecx
movl %eax, %edx
andl %ecx, %edx
cvtsi2sd %edx, %xmm0
movsd 0x935d1(%rip), %xmm1    # 0xf4560
divsd %xmm1, %xmm0
addsd %xmm0, %xmm0
cvttsd2si %xmm0, %edx
movl %eax, %esi
shrl $0x8, %esi
andl %ecx, %esi
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
divsd %xmm1, %xmm0
addsd %xmm0, %xmm0
cvttsd2si %xmm0, %esi
shrl $0x10, %eax
andl %ecx, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd %xmm1, %xmm0
addsd %xmm0, %xmm0
cvttsd2si %xmm0, %eax
shll $0x10, %eax
shll $0x8, %esi
orl %edx, %esi
orl %eax, %esi
movslq %esi, %rax
leaq 0x10(%rsp), %rsi
movq %rax, 0x8(%rsi)
movl $0x0, (%rsi)
leaq 0x20(%rsp), %rdi
callq 0x58650
movq (%r14), %rax
movq %rsp, %rdx
leaq 0x20(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %r8d, %r8d
callq *0x78(%rax)
movl (%rsp), %eax
movl 0x4(%rsp), %ecx
addl $-0x2, %eax
addl $-0x2, %ecx
shlq $0x20, %rcx
movl 0x8(%rsp), %edx
movl 0xc(%rsp), %esi
addl $-0x2, %edx
addl $-0x2, %esi
orq %rcx, %rax
shlq $0x20, %rsi
orq %rsi, %rdx
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movslq %r15d, %rax
leaq 0x10(%rsp), %rsi
movq %rax, 0x8(%rsi)
movl $0x0, (%rsi)
leaq 0x20(%rsp), %rdi
callq 0x58650
movq (%r14), %rax
movq %rsp, %rdx
leaq 0x20(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %r8d, %r8d
callq *0x78(%rax)
leaq 0x20(%rsp), %rdi
callq 0x56720
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x61089
jmp 0x61089
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x56720
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/graphics/backends/surfacebackend.cpp
// Function: smooth::GUI::SurfaceBackend::PremultiplyAlpha(smooth::GUI::Bitmap&)
S::Int S::GUI::SurfaceBackend::PremultiplyAlpha(Bitmap &bitmap)
{
	if (bitmap.GetDepth() != 32) return Success();

	Point	 point;
	Size	 size = bitmap.GetSize();

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

			if (pixel.GetAlpha() != 255) bitmap.SetPixel(point, Color( pixel.GetRed()   * pixel.GetAlpha() / 255	    |
										  (pixel.GetGreen() * pixel.GetAlpha() / 255) <<  8 |
										  (pixel.GetBlue()  * pixel.GetAlpha() / 255) << 16 |
												      pixel.GetAlpha()	      << 24, Color::RGBA));
		}
	}

	return Success();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
callq 0x56c20
cmpb $0x20, %al
jne 0x61861
movq $0x0, 0xc(%rsp)
movq %rbx, %rdi
callq 0x58410
movl (%rax), %ebp
movl 0x4(%rax), %eax
movl $0x0, 0x10(%rsp)
movl %eax, 0x14(%rsp)
testl %eax, %eax
jle 0x61861
leaq 0x28(%rsp), %r14
leaq 0xc(%rsp), %r15
movl $0xff, %r13d
leaq 0x18(%rsp), %r12
movl $0x0, 0xc(%rsp)
testl %ebp, %ebp
jle 0x6184d
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x55f30
movl 0x30(%rsp), %eax
movl %eax, %ecx
shrl $0x18, %ecx
cmpl $0xff, %ecx
je 0x6183b
movl %eax, %edx
andl %r13d, %edx
imull %ecx, %edx
imulq $0x1010102, %rdx, %rdx  # imm = 0x1010102
shrq $0x20, %rdx
movl %eax, %esi
shrl $0x8, %esi
andl %r13d, %esi
imull %ecx, %esi
imulq $0x1010102, %rsi, %rsi  # imm = 0x1010102
shrq $0x20, %rsi
shll $0x8, %esi
movl %eax, %edi
shrl $0x10, %edi
andl %r13d, %edi
imull %ecx, %edi
imulq $0x1010102, %rdi, %rcx  # imm = 0x1010102
shrq $0x20, %rcx
shll $0x10, %ecx
andl $0xff000000, %eax       # imm = 0xFF000000
orl %edx, %eax
orl %esi, %eax
orl %ecx, %eax
cltq
movq %rax, 0x20(%rsp)
movl $0x1, 0x18(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x56080
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
cmpl %ebp, %eax
jl 0x617af
movl 0x10(%rsp), %eax
incl %eax
movl %eax, 0x10(%rsp)
cmpl 0x14(%rsp), %eax
jl 0x6179f
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/graphics/forms/rect.cpp
// Function: smooth::GUI::Rect::EncloseRect(smooth::GUI::Rect const&, smooth::GUI::Rect const&)
S::GUI::Rect S::GUI::Rect::EncloseRect(const Rect &rect1, const Rect &rect2)
{
	Rect	 eRect;

	eRect.left   = (Int) Math::Min(rect1.left, rect2.left);
	eRect.top    = (Int) Math::Min(rect1.top, rect2.top);
	eRect.right  = (Int) Math::Max(rect1.right, rect2.right);
	eRect.bottom = (Int) Math::Max(rect1.bottom, rect2.bottom);

	return eRect;
}

// Assembly:
movl (%rdi), %ecx
movl 0x4(%rdi), %edx
movl (%rsi), %eax
movl 0x4(%rsi), %r8d
cmpl %eax, %ecx
cmovll %ecx, %eax
cmpl %r8d, %edx
cmovll %edx, %r8d
movl 0x8(%rdi), %ecx
movl 0x8(%rsi), %r9d
cmpl %r9d, %ecx
cmovgl %ecx, %r9d
movl 0xc(%rdi), %ecx
movl 0xc(%rsi), %edx
cmpl %edx, %ecx
cmovgl %ecx, %edx
shlq $0x20, %rdx
orq %r9, %rdx
shlq $0x20, %r8
orq %r8, %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/graphics/imageloader/imageloader.cpp
// Function: smooth::GUI::DetectImageFormat(smooth::Buffer<unsigned char> const&)
static Short DetectImageFormat(const Buffer<UnsignedByte> &buffer)
		{
			Short	 format = IMAGE_FORMAT_AUTO;

			if (buffer.Size() < 12) return format;

			if	(buffer[ 0] == 0x50 && buffer[ 1] == 0x43 &&
				 buffer[ 2] == 0x49 && buffer[ 3] == 0x46) format = IMAGE_FORMAT_PCI;
			else if (buffer[ 0] == 0xFF && buffer[ 1] == 0xD8) format = IMAGE_FORMAT_JPEG;
			else if (buffer[ 0] == 0x89 && buffer[ 1] == 0x50 &&
				 buffer[ 2] == 0x4E && buffer[ 3] == 0x47 &&
				 buffer[ 4] == 0x0D && buffer[ 5] == 0x0A &&
				 buffer[ 6] == 0x1A && buffer[ 7] == 0x0A) format = IMAGE_FORMAT_PNG;
			else if (buffer[ 0] == 0x52 && buffer[ 1] == 0x49 &&
				 buffer[ 2] == 0x46 && buffer[ 3] == 0x46 &&
				 buffer[ 8] == 0x57 && buffer[ 9] == 0x45 &&
				 buffer[10] == 0x42 && buffer[11] == 0x50) format = IMAGE_FORMAT_WEBP;

			return format;
		}

// Assembly:
cmpl $0xc, 0x10(%rdi)
jge 0x61e1e
movw $0xffff, %ax            # imm = 0xFFFF
retq
movq 0x8(%rdi), %rax
movq (%rax), %rcx
movzbl (%rcx), %edx
cmpl $0x88, %edx
jg 0x61e4f
cmpl $0x50, %edx
jne 0x61ea8
cmpb $0x43, 0x1(%rcx)
jne 0x61e4a
cmpb $0x49, 0x2(%rcx)
jne 0x61e4a
cmpb $0x46, 0x3(%rcx)
jne 0x61e4a
xorl %eax, %eax
retq
cmpl $0x52, %edx
je 0x61eb1
cmpl $0x89, %edx
je 0x61e76
cmpl $0xff, %edx
jne 0x61e19
movw $0x2, %ax
cmpb $-0x28, 0x1(%rcx)
je 0x61e1d
cmpl $0x52, %edx
je 0x61eb1
cmpl $0x89, %edx
jne 0x61e19
cmpb $0x50, 0x1(%rcx)
jne 0x61ea8
cmpb $0x4e, 0x2(%rcx)
jne 0x61ea8
cmpb $0x47, 0x3(%rcx)
jne 0x61ea8
cmpb $0xd, 0x4(%rcx)
jne 0x61ea8
cmpb $0xa, 0x5(%rcx)
jne 0x61ea8
cmpb $0x1a, 0x6(%rcx)
jne 0x61ea8
movw $0x1, %ax
cmpb $0xa, 0x7(%rcx)
je 0x61e1d
cmpl $0x52, %edx
jne 0x61e19
cmpb $0x49, 0x1(%rcx)
jne 0x61e19
cmpb $0x46, 0x2(%rcx)
jne 0x61e19
cmpb $0x46, 0x3(%rcx)
jne 0x61e19
cmpb $0x57, 0x8(%rcx)
jne 0x61e19
cmpb $0x45, 0x9(%rcx)
jne 0x61e19
cmpb $0x42, 0xa(%rcx)
movw $0xffff, %ax            # imm = 0xFFFF
jne 0x61e1d
xorl %eax, %eax
cmpb $0x50, 0xb(%rcx)
sete %al
leal -0x1(,%rax,4), %eax
retq