LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x61942
movq %rbx, %rdi
callq 0x58410
movl (%rax), %ebp
movl 0x4(%rax), %eax
movl $0x0, 0x10(%rsp)
movl %eax, 0x14(%rsp)
testl %eax, %eax
jle 0x61942
xorl %eax, %eax
leaq 0x28(%rsp), %r14
leaq 0xc(%rsp), %r15
movl $0xff, %r13d
leaq 0x18(%rsp), %r12
movl $0x0, 0xc(%rsp)
testl %ebp, %ebp
jle 0x61932
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 0x6191c
movl %eax, %edx
andl %r13d, %edx
imull %ecx, %edx
imull $0x8081, %edx, %edx     # imm = 0x8081
shrl $0x17, %edx
movl %eax, %esi
shrl $0x8, %esi
andl %r13d, %esi
imull %ecx, %esi
imull $0x8081, %esi, %esi     # imm = 0x8081
shrl $0xf, %esi
andl $0x1ff00, %esi          # imm = 0x1FF00
movl %eax, %edi
shrl $0x10, %edi
andl %r13d, %edi
imull %ecx, %edi
imull $0x8081, %edi, %ecx     # imm = 0x8081
shrl $0x7, %ecx
andl $0x1ff0000, %ecx        # imm = 0x1FF0000
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 0x61890
movl 0x10(%rsp), %eax
incl %eax
movl %eax, 0x10(%rsp)
cmpl 0x14(%rsp), %eax
jl 0x61880
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_O3/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:
movw $0xffff, %ax            # imm = 0xFFFF
cmpl $0xc, %esi
jl 0x61f6b
movq (%rdi), %rcx
movzbl (%rcx), %edx
cmpl $0x88, %edx
jg 0x61f51
cmpl $0x50, %edx
je 0x61f6c
cmpl $0x52, %edx
jne 0x61f6b
cmpb $0x49, 0x1(%rcx)
jne 0x61f6b
cmpb $0x46, 0x2(%rcx)
jne 0x61f6b
cmpb $0x46, 0x3(%rcx)
jne 0x61f6b
cmpb $0x57, 0x8(%rcx)
jne 0x61f6b
cmpb $0x45, 0x9(%rcx)
jne 0x61f6b
cmpb $0x42, 0xa(%rcx)
jne 0x61f6b
xorl %eax, %eax
cmpb $0x50, 0xb(%rcx)
sete %al
leal -0x1(,%rax,4), %eax
retq
cmpl $0x89, %edx
je 0x61f81
cmpl $0xff, %edx
jne 0x61f6b
movw $0x2, %ax
cmpb $-0x28, 0x1(%rcx)
jne 0x61faf
retq
cmpb $0x43, 0x1(%rcx)
jne 0x61faf
cmpb $0x49, 0x2(%rcx)
jne 0x61faf
cmpb $0x46, 0x3(%rcx)
jne 0x61faf
xorl %eax, %eax
retq
cmpb $0x50, 0x1(%rcx)
jne 0x61faf
cmpb $0x4e, 0x2(%rcx)
jne 0x61faf
cmpb $0x47, 0x3(%rcx)
jne 0x61faf
cmpb $0xd, 0x4(%rcx)
jne 0x61faf
cmpb $0xa, 0x5(%rcx)
jne 0x61faf
cmpb $0x1a, 0x6(%rcx)
jne 0x61faf
movw $0x1, %ax
cmpb $0xa, 0x7(%rcx)
je 0x61f6b
movw $0xffff, %ax            # imm = 0xFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/imageloader/imageloader.cpp
// Function: smooth::GUI::ImageLoader::Load(smooth::Buffer<unsigned char> const&, short)
S::GUI::Bitmap S::GUI::ImageLoader::Load(const Buffer<UnsignedByte> &buffer, Short format)
{
	/* Auto-detect image format.
	 */
	if (format == IMAGE_FORMAT_AUTO) format = DetectImageFormat(buffer);

	/* Create image loader.
	 */
	ImageLoader	*loader = NIL;

	if	(format == IMAGE_FORMAT_PCI)  loader = new ImageLoaderPCI(buffer);
	else if (format == IMAGE_FORMAT_PNG)  loader = new ImageLoaderPNG(buffer);
	else if (format == IMAGE_FORMAT_JPEG) loader = new ImageLoaderJPEG(buffer);
	else if (format == IMAGE_FORMAT_WEBP) loader = new ImageLoaderWebP(buffer);

	if (loader == NIL) return NIL;

	Bitmap	 bitmap = loader->Load();

	delete loader;

	return bitmap;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
cmpw $-0x1, %dx
jne 0x61fd4
movq 0x8(%r15), %rdi
movl 0x10(%r15), %esi
callq 0x61efb
movl %eax, %edx
cmpw $0x3, %dx
ja 0x62076
movzwl %dx, %eax
leaq 0x91608(%rip), %rcx     # 0xf35f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x48, %edi
callq 0x556b0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x6247e
jmp 0x62057
movl $0x48, %edi
callq 0x556b0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x6218a
jmp 0x62057
movl $0x48, %edi
callq 0x556b0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x62cf6
jmp 0x62057
movl $0x48, %edi
callq 0x556b0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x62726
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x57160
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
jmp 0x62080
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58950
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x6208f
jmp 0x6208f
jmp 0x6208f
movq %rax, %rbx
movl $0x48, %esi
movq %r14, %rdi
callq 0x55480
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/application/application.cpp
// Function: smooth::GUI::Application::Loop()
S::Int S::GUI::Application::Loop()
{
	static Bool	 firstTime = True;

	if (firstTime)
	{
		firstTime = False;

		/* Show pending windows when we are called for the first time.
		 */
		for (Int i = 0; i < Window::GetNOfWindows(); i++)
		{
			Window	*window = Window::GetNthWindow(i);

			if (window != NIL && !window->IsVisibilitySet()) window->Show();
		}
	}

	/* Enter main application loop.
	 */
	System::EventProcessor	 event;

	while (GUI::Window::nOfActiveWindows > 0)
	{
		if (!event.ProcessNextEvent()) break;
	}

	return Success();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpb $0x0, 0x10b435(%rip)    # 0x16e850
jne 0x6345b
movb $0x1, 0x10b42c(%rip)    # 0x16e850
movq 0x108285(%rip), %rbx    # 0x16b6b0
cmpl $0x0, 0x8(%rbx)
jle 0x6345b
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5b074
movq (%rax), %rdi
testq %rdi, %rdi
je 0x63454
cmpb $0x0, 0x5cc(%rdi)
jne 0x63454
movq (%rdi), %rax
callq *0x58(%rax)
incl %ebp
cmpl 0x8(%rbx), %ebp
jl 0x63433
movq %rsp, %rdi
callq 0x57260
movq 0x1081d6(%rip), %r14    # 0x16b640
cmpw $0x0, (%r14)
jle 0x63488
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x568b0
cmpw $0x0, (%r14)
setg %cl
testb %cl, %al
jne 0x63474
movq %rsp, %rdi
callq 0x557d0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x557d0
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/application/application.cpp
// Function: smooth::GUI::Application::SetArguments(smooth::Array<smooth::String, smooth::String> const&)
foreach (const String &arg, nArgs)
	{
		/* Filter out scale factor argument.
		 */
		if (arg.StartsWith("--scale:")) { scaleFactor = arg.Tail(arg.Length() - 8).ToFloat(); continue; }

		/* Add to arguments array.
		 */
		args.Add(arg);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x0, 0x8(%rdi)
jle 0x63558
movq %rdi, %rbx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x901fe(%rip), %r14     # 0xf36d3
movq %rsp, %r15
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x64250
movq %rax, %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0x579f0
movq %r13, %rdi
movq %r15, %rsi
callq 0x577d0
movl %eax, %r12d
movq %r15, %rdi
callq 0x59200
testb %r12b, %r12b
je 0x63540
movq %r13, %rdi
callq 0x57180
leal -0x8(%rax), %edx
movq %r15, %rdi
movq %r13, %rsi
callq 0x57f90
movq %r15, %rdi
callq 0x577b0
movq 0x108506(%rip), %rax    # 0x16ba38
movsd %xmm0, (%rax)
movq %r15, %rdi
callq 0x59200
jmp 0x6354f
movq 0x1083a1(%rip), %rdi    # 0x16b8e8
movq %r13, %rsi
callq 0x642ac
movl 0x8(%rbx), %eax
decl %eax
cmpl %eax, %ebp
jl 0x634d8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x63569
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/application/application.cpp
// Function: smooth::GUI::Application::GetStartupDirectory()
S::String S::GUI::Application::GetStartupDirectory()
{
	if (startupDirectory != NIL) return startupDirectory;

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

	if (GetCurrentDirectory(buffer.Size(), buffer))	startupDirectory = buffer;

	if (!startupDirectory.EndsWith("\\")) startupDirectory.Append("\\");
#else
	Buffer<char>	 buffer(PATH_MAX + 1);

	if (getcwd(buffer, buffer.Size()) != NIL) startupDirectory = buffer;

	if (!startupDirectory.EndsWith("/")) startupDirectory.Append("/");
#endif

	return startupDirectory;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x1083aa(%rip), %rdi    # 0x16b938
xorl %esi, %esi
callq 0x56bd0
testb %al, %al
je 0x635ad
movq 0x108398(%rip), %rsi    # 0x16b938
movq %rbx, %rdi
callq 0x570b0
jmp 0x63671
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movl $0x1001, %esi           # imm = 0x1001
callq 0x5cf6a
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x635cd
movq (%rax), %rdi
jmp 0x635cf
xorl %edi, %edi
movslq 0x28(%rsp), %rsi
callq 0x561f0
testq %rax, %rax
je 0x635fb
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x635ed
movq (%rax), %rsi
jmp 0x635ef
xorl %esi, %esi
movq 0x108342(%rip), %rdi    # 0x16b938
callq 0x55f40
leaq 0x900e8(%rip), %rsi     # 0xf36ea
movq %rsp, %rdi
callq 0x579f0
movq 0x108327(%rip), %rdi    # 0x16b938
movq %rsp, %rsi
callq 0x58b10
movl %eax, %ebp
movq %rsp, %rdi
callq 0x59200
testb %bpl, %bpl
jne 0x6364e
leaq 0x900bb(%rip), %rsi     # 0xf36ea
movq %rsp, %rdi
callq 0x579f0
movq 0x1082fa(%rip), %rdi    # 0x16b938
movq %rsp, %rsi
callq 0x562f0
movq %rsp, %rdi
callq 0x59200
movq 0x1082e3(%rip), %rsi    # 0x16b938
movq %rbx, %rdi
callq 0x570b0
leaq 0xfc694(%rip), %rax     # 0x15fcf8
leaq 0x18(%rsp), %rdi
movq %rax, (%rdi)
callq 0x5d81a
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x63681
jmp 0x63690
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59200
jmp 0x63693
jmp 0x63690
movq %rax, %rbx
leaq 0xfc65e(%rip), %rax     # 0x15fcf8
leaq 0x18(%rsp), %rdi
movq %rax, (%rdi)
callq 0x5d81a
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/dialogs/colordlg.cpp
// Function: smooth::GUI::Dialogs::ColorSelection::ColorDlgHueEdit()
void S::GUI::Dialogs::ColorSelection::ColorDlgHueEdit()
{
	Int	 newhue = Math::Max(0, Math::Min(255, (Int) hueedit->GetText().ToInt()));

	if (newhue != acthue)
	{
		acthue = newhue;

		updatetext = False;

		ColorDlgHueSlider();
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x406e8(%rdi), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
movq %rax, %rdi
callq 0x568c0
movl $0xff, %ecx
cmpl %ecx, %eax
cmovll %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovgl %ecx, %eax
cmpl 0x614(%rbx), %eax
jne 0x6705d
popq %rbx
retq
movl %eax, 0x614(%rbx)
movb $0x0, 0x606(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x591c0
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/dialogs/colordlg.cpp
// Function: smooth::GUI::Dialogs::ColorSelection::ColorDlgValEdit()
void S::GUI::Dialogs::ColorSelection::ColorDlgValEdit()
{
	Int	 newval = Math::Max(0, Math::Min(255, (Int) valedit->GetText().ToInt()));

	if (newval != actval)
	{
		actval = newval;

		updatetext = False;

		ColorDlgValSlider();
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x406f8(%rdi), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
movq %rax, %rdi
callq 0x568c0
movl $0xff, %ecx
cmpl %ecx, %eax
cmovll %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovgl %ecx, %eax
cmpl 0x61c(%rbx), %eax
jne 0x670f9
popq %rbx
retq
movl %eax, 0x61c(%rbx)
movb $0x0, 0x606(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x59100
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/dialogs/colordlg.cpp
// Function: smooth::GUI::Dialogs::ColorSelection::~ColorSelection()
S::GUI::Dialogs::ColorSelection::~ColorSelection()
{
	DeleteObject(titlebar);
	DeleteObject(divbar);
	DeleteObject(dlgwnd);
	DeleteObject(okbtn);
	DeleteObject(cancelbtn);
	DeleteObject(ncarea);
	DeleteObject(ocarea);
	DeleteObject(hueslider);
	DeleteObject(satslider);
	DeleteObject(valslider);
	DeleteObject(redslider);
	DeleteObject(greenslider);
	DeleteObject(blueslider);
	DeleteObject(huetext);
	DeleteObject(sattext);
	DeleteObject(valtext);
	DeleteObject(redtext);
	DeleteObject(greentext);
	DeleteObject(bluetext);
	DeleteObject(hueedit);
	DeleteObject(satedit);
	DeleteObject(valedit);
	DeleteObject(rededit);
	DeleteObject(greenedit);
	DeleteObject(blueedit);
	DeleteObject(hextext);
	DeleteObject(hexedit);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x1035a9(%rip), %rax    # 0x16ba00
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x40650(%rdi), %rdi
callq 0x58cc0
movq 0x40658(%rbx), %rdi
callq 0x58cc0
movq 0x40648(%rbx), %rdi
callq 0x58cc0
movq 0x40660(%rbx), %rdi
callq 0x58cc0
movq 0x40668(%rbx), %rdi
callq 0x58cc0
movq 0x40670(%rbx), %rdi
callq 0x58cc0
movq 0x40678(%rbx), %rdi
callq 0x58cc0
movq 0x40680(%rbx), %rdi
callq 0x58cc0
movq 0x40688(%rbx), %rdi
callq 0x58cc0
movq 0x40690(%rbx), %rdi
callq 0x58cc0
movq 0x40698(%rbx), %rdi
callq 0x58cc0
movq 0x406a0(%rbx), %rdi
callq 0x58cc0
movq 0x406a8(%rbx), %rdi
callq 0x58cc0
movq 0x406b0(%rbx), %rdi
callq 0x58cc0
movq 0x406b8(%rbx), %rdi
callq 0x58cc0
movq 0x406c0(%rbx), %rdi
callq 0x58cc0
movq 0x406c8(%rbx), %rdi
callq 0x58cc0
movq 0x406d0(%rbx), %rdi
callq 0x58cc0
movq 0x406d8(%rbx), %rdi
callq 0x58cc0
movq 0x406e8(%rbx), %rdi
callq 0x58cc0
movq 0x406f0(%rbx), %rdi
callq 0x58cc0
movq 0x406f8(%rbx), %rdi
callq 0x58cc0
movq 0x40700(%rbx), %rdi
callq 0x58cc0
movq 0x40708(%rbx), %rdi
callq 0x58cc0
movq 0x40710(%rbx), %rdi
callq 0x58cc0
movq 0x406e0(%rbx), %rdi
callq 0x58cc0
movq 0x40718(%rbx), %rdi
callq 0x58cc0
leaq 0x40630(%rbx), %rdi
callq 0x59200
movq %rbx, %rdi
popq %rbx
jmp 0x55b00
movq %rax, %rdi
callq 0x5aeae
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/dialogs/messagebox.cpp
// Function: smooth::GUI::Dialogs::MessageDlg::~MessageDlg()
S::GUI::Dialogs::MessageDlg::~MessageDlg()
{
	foreach (Button *button, buttonWidgets) DeleteObject(button);

	DeleteObject(layer);
	DeleteObject(icon);
	DeleteObject(titlebar);
	DeleteObject(msgbox);

	if (checkbox != NIL) DeleteObject(checkbox);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x100d16(%rip), %rax    # 0x16bd10
addq $0x10, %rax
movq %rax, (%rdi)
cmpl $0x0, 0x670(%rdi)
jle 0x6b036
leaq 0x668(%rbx), %r14
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
incl %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x60a9a
movq (%rax), %rdi
callq 0x58cc0
movl 0x670(%rbx), %eax
decl %eax
cmpl %eax, %ebp
jl 0x6b016
movq 0x600(%rbx), %rdi
callq 0x58cc0
movq 0x608(%rbx), %rdi
callq 0x58cc0
movq 0x5f8(%rbx), %rdi
callq 0x58cc0
movq 0x5f0(%rbx), %rdi
callq 0x58cc0
movq 0x6c8(%rbx), %rdi
testq %rdi, %rdi
je 0x6b077
callq 0x58cc0
leaq 0x668(%rbx), %rdi
callq 0x5b0ee
leaq 0x610(%rbx), %rdi
callq 0x63e3c
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x55b00
jmp 0x6b09d
movq %rax, %rdi
callq 0x5aeae
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/dialogs/messagebox.cpp
// Function: smooth::GUI::Dialogs::MessageDlg::MessageButton(int)
S::Void S::GUI::Dialogs::MessageDlg::MessageButton(Int buttonID)
{
	if	(buttonLabels.GetNth(buttonID) == "OK")	    buttonCode = Message::Button::Ok;
	else if	(buttonLabels.GetNth(buttonID) == "Cancel") buttonCode = Message::Button::Cancel;
	else if	(buttonLabels.GetNth(buttonID) == "Yes")    buttonCode = Message::Button::Yes;
	else if	(buttonLabels.GetNth(buttonID) == "No")	    buttonCode = Message::Button::No;
	else if	(buttonLabels.GetNth(buttonID) == "Retry")  buttonCode = Message::Button::Retry;
	else if	(buttonLabels.GetNth(buttonID) == "Abort")  buttonCode = Message::Button::Abort;
	else if	(buttonLabels.GetNth(buttonID) == "Ignore") buttonCode = Message::Button::Ignore;

	msgbox->Close();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x610(%rdi), %r14
movq %r14, %rdi
callq 0x6b610
leaq 0xc3045(%rip), %rsi     # 0x12e148
movq %rax, %rdi
callq 0x57ef0
movl $0x1, %ecx
testb %al, %al
jne 0x6b1ec
movq %r14, %rdi
movl %ebp, %esi
callq 0x6b610
leaq 0x88717(%rip), %rsi     # 0xf3840
movq %rax, %rdi
callq 0x57ef0
movl $0x2, %ecx
testb %al, %al
jne 0x6b1ec
movq %r14, %rdi
movl %ebp, %esi
callq 0x6b610
leaq 0x888fd(%rip), %rsi     # 0xf3a4c
movq %rax, %rdi
callq 0x57ef0
movl $0x6, %ecx
testb %al, %al
jne 0x6b1ec
movq %r14, %rdi
movl %ebp, %esi
callq 0x6b610
leaq 0x888db(%rip), %rsi     # 0xf3a50
movq %rax, %rdi
callq 0x57ef0
movl $0x7, %ecx
testb %al, %al
jne 0x6b1ec
movq %r14, %rdi
movl %ebp, %esi
callq 0x6b610
leaq 0x888bc(%rip), %rsi     # 0xf3a53
movq %rax, %rdi
callq 0x57ef0
movl $0x4, %ecx
testb %al, %al
jne 0x6b1ec
movq %r14, %rdi
movl %ebp, %esi
callq 0x6b610
leaq 0x888a0(%rip), %rsi     # 0xf3a59
movq %rax, %rdi
callq 0x57ef0
movl $0x3, %ecx
testb %al, %al
jne 0x6b1ec
movq %r14, %rdi
movl %ebp, %esi
callq 0x6b610
leaq 0x88884(%rip), %rsi     # 0xf3a5f
movq %rax, %rdi
callq 0x57ef0
movl $0x5, %ecx
testb %al, %al
je 0x6b1f2
movl %ecx, 0x6c0(%rbx)
movq 0x5f0(%rbx), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x58420
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/dialogs/splashscreen.cpp
// Function: smooth::GUI::Dialogs::SplashScreen::SplashPaintProc()
S::Void S::GUI::Dialogs::SplashScreen::SplashPaintProc()
{
	Surface	*surface = splashscreen->GetDrawSurface();
	Rect	 bmpRect;

	bmpRect.left	= 1;
	bmpRect.top	= 1;
	bmpRect.right	= bmpRect.left + bitmap.GetSize().cx;
	bmpRect.bottom	= bmpRect.top + bitmap.GetSize().cy;

	surface->BlitFromBitmap(bitmap, Rect(Point(0, 0), bitmap.GetSize()), bmpRect);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x5f8(%rdi), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, %r15
movabsq $0x100000001, %rax      # imm = 0x100000001
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
addq $0x5f0, %rbx            # imm = 0x5F0
movq %rbx, %rdi
callq 0x58410
movl (%rax), %eax
incl %eax
movl %eax, 0x8(%r14)
movq %rbx, %rdi
callq 0x58410
movl 0x4(%rax), %eax
incl %eax
movl %eax, 0xc(%r14)
movq %rbx, %rdi
callq 0x58410
movq %rsp, %rdx
movq $0x0, (%rdx)
movq (%rax), %rax
movq %rax, 0x8(%rdx)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x55ba0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/dialogs/tipodaydlg.cpp
// Function: smooth::GUI::Dialogs::TipOfTheDay::OnNext()
S::Void S::GUI::Dialogs::TipOfTheDay::OnNext()
{
	if (tips.Length() <= 1) return;

	String	 tip;

	switch (mode)
	{
		case TIP_ORDERED:
			tip = tips.GetNth(offset++);

			if (offset == tips.Length()) offset = 0;

			break;
		case TIP_RANDOM:
			Math::RandomSeed();

			do
			{
				tip = tips.GetNth(Math::Random() % tips.Length());
			}
			while (tip == txt_tip->GetText());

			break;
	}

	txt_tip->SetText(tip);

	OnPaint();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpl $0x2, 0x648(%rdi)
jl 0x6c65a
movq %rdi, %rbx
leaq 0x640(%rdi), %r14
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x58e20
movl 0x698(%rbx), %eax
cmpl $0x1, %eax
je 0x6c5e9
testl %eax, %eax
jne 0x6c633
movl 0x69c(%rbx), %esi
leal 0x1(%rsi), %eax
movl %eax, 0x69c(%rbx)
movq %r14, %rdi
callq 0x6b610
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x555f0
movl 0x69c(%rbx), %eax
cmpl 0x648(%rbx), %eax
jne 0x6c633
movl $0x0, 0x69c(%rbx)
jmp 0x6c633
callq 0x55890
leaq 0x8(%rsp), %r15
callq 0x55fc0
cltd
idivl 0x648(%rbx)
movq %r14, %rdi
movl %edx, %esi
callq 0x6b610
movq %r15, %rdi
movq %rax, %rsi
callq 0x555f0
movq 0x628(%rbx), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x55900
testb %al, %al
jne 0x6c5f3
movq 0x628(%rbx), %rdi
movq (%rdi), %rax
leaq 0x8(%rsp), %rsi
callq *0xa0(%rax)
movq %rbx, %rdi
callq 0x59160
leaq 0x8(%rsp), %rdi
callq 0x59200
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x6c666
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/dialogs/tipodaydlg.cpp
// Function: smooth::GUI::Dialogs::TipOfTheDay::~TipOfTheDay()
S::GUI::Dialogs::TipOfTheDay::~TipOfTheDay()
{
	DeleteObject(dlgwnd);

	DeleteObject(titlebar);
	DeleteObject(divbar);

	DeleteObject(btn_ok);
	DeleteObject(btn_next);
	DeleteObject(check_showtips);

	DeleteObject(img_light);
	DeleteObject(txt_didyouknow);

	DeleteObject(layer_inner);

	DeleteObject(txt_tip);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xff833(%rip), %rax     # 0x16bf60
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x5e8(%rdi), %rdi
callq 0x58cc0
movq 0x5f0(%rbx), %rdi
callq 0x58cc0
movq 0x5f8(%rbx), %rdi
callq 0x58cc0
movq 0x600(%rbx), %rdi
callq 0x58cc0
movq 0x608(%rbx), %rdi
callq 0x58cc0
movq 0x610(%rbx), %rdi
callq 0x58cc0
movq 0x618(%rbx), %rdi
callq 0x58cc0
movq 0x620(%rbx), %rdi
callq 0x58cc0
movq 0x630(%rbx), %rdi
callq 0x58cc0
movq 0x628(%rbx), %rdi
callq 0x58cc0
leaq 0x640(%rbx), %rdi
callq 0x63e3c
movq %rbx, %rdi
popq %rbx
jmp 0x55b00
movq %rax, %rdi
callq 0x5aeae
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/widgets/layer.cpp
// Function: smooth::GUI::Layer::Layer(smooth::String const&)
S::GUI::Layer::Layer(const String &name) : Widget(Point(0, 0), Size(32768, 32768))
{
	type	    = classID;

	text	    = name;
	orientation = OR_CENTER;

	ComputeTextSize();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rsi
movq $0x0, (%rsi)
movabsq $0x800000008000, %rax   # imm = 0x800000008000
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
callq 0x57a30
movq 0xfe9c1(%rip), %rax     # 0x16bac8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0xfe6eb(%rip), %rax     # 0x16b800
movzwl (%rax), %eax
movw %ax, 0x20(%rbx)
leaq 0xf0(%rbx), %rdi
movq %r14, %rsi
callq 0x555f0
movw $0x40, 0xd0(%rbx)
movq %rbx, %rdi
callq 0x55bb0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x57640
movq %r14, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/widgets/layer.cpp
// Function: smooth::GUI::Layer::Paint(int)
S::Int S::GUI::Layer::Paint(Int message)
{
	if (!IsRegistered()) return Error();
	if (!IsVisible())    return Success();

	switch (message)
	{
		case SP_PAINT:
			if (IsBackgroundColorSet())
			{
				Surface	*surface = GetDrawSurface();

				surface->Box(Rect(GetRealPosition(), GetRealSize()), GetBackgroundColor(), Rect::Filled);
			}

			break;
	}

	return Widget::Paint(message);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x88(%rax)
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %cl, %cl
je 0x6d24f
movq (%r14), %rax
movq %r14, %rdi
callq *0x90(%rax)
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0x6d24f
testl %ebx, %ebx
jne 0x6d245
movq (%r14), %rax
movq %r14, %rdi
callq *0x148(%rax)
testb %al, %al
je 0x6d245
movq (%r14), %rax
movq %r14, %rdi
callq *0x40(%rax)
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x48(%rax)
movq %rax, %r12
movq %rax, %rbp
shrq $0x20, %rbp
movq (%r14), %rax
movq %r14, %rdi
callq *0x50(%rax)
leal (%rax,%r12), %ecx
shrq $0x20, %rax
leaq 0x8(%rsp), %r13
movl %r12d, (%r13)
movl %ebp, 0x4(%r13)
movl %ecx, 0x8(%r13)
addl %ebp, %eax
movl %eax, 0xc(%r13)
movq (%r14), %rax
movq %r14, %rdi
callq *0x140(%rax)
movq 0xfed7d(%rip), %rcx     # 0x16bfa8
movl (%rcx), %ecx
movq %rsp, %r8
movq $0x0, (%r8)
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x57930
movq %r14, %rdi
movl %ebx, %esi
callq 0x567d0
addq $0x18, %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/gui/widgets/widget.cpp
// Function: smooth::GUI::Widget::DeactivateTooltip()
S::Void S::GUI::Widget::DeactivateTooltip()
{
	Application::Lock	 lock;

	if (tipTimer != NIL)
	{
		tipTimer->Stop();

		DeleteObject(tipTimer);

		tipTimer = NIL;
	}

	if (tooltip != NIL)
	{
		PopupMenu::internalOnOpenPopupMenu.Disconnect(&Widget::DeactivateTooltip, this);

		tooltip->Hide();

		DeleteObject(tooltip);

		tooltip = NIL;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x55420
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x6df9f
callq 0x59190
movq 0xa0(%rbx), %rdi
callq 0x58cc0
movq $0x0, 0xa0(%rbx)
cmpq $0x0, 0x90(%rbx)
je 0x6dfe5
movq 0xfd7d8(%rip), %rdi     # 0x16b788
movq 0xfe009(%rip), %rsi     # 0x16bfc0
xorl %edx, %edx
movq %rbx, %rcx
callq 0x705c0
movq 0x90(%rbx), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movq 0x90(%rbx), %rdi
callq 0x58cc0
movq $0x0, 0x90(%rbx)
callq 0x56e90
popq %rbx
retq
jmp 0x6dffe
movq %rax, %rbx
callq 0x56e90
movq %rbx, %rdi
callq 0x57090
movq %rax, %rdi
callq 0x5aeae
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/widgets/widget.cpp
// Function: smooth::GUI::Widget::CloseContextMenu()
S::Void S::GUI::Widget::CloseContextMenu()
{
	if (contextMenu != NIL)
	{
		contextMenu->internalRequestClose.Disconnect(&Widget::CloseContextMenu, this);

		Remove(contextMenu);

		contextMenu = NIL;

		onCloseContextMenu.Emit();
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x198(%rdi), %rdi
testq %rdi, %rdi
je 0x6e059
addq $0x698, %rdi            # imm = 0x698
movq 0xfd504(%rip), %rsi     # 0x16b528
xorl %edx, %edx
movq %rbx, %rcx
callq 0x7062c
movq (%rbx), %rax
movq 0x198(%rbx), %rsi
movq %rbx, %rdi
callq *0x38(%rax)
movq $0x0, 0x198(%rbx)
addq $0x4b8, %rbx            # imm = 0x4B8
movq %rbx, %rdi
popq %rbx
jmp 0x701aa
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/widgets/widget.cpp
// Function: smooth::GUI::Widget::EnableLocking(bool)
S::Int S::GUI::Widget::EnableLocking(Bool enable)
{
	if (enable) widgets.EnableLocking();
	else	    widgets.DisableLocking();

	foreach (Widget *widget, widgets) widget->EnableLocking(enable);

	return Object::EnableLocking(enable);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
movq %r14, %rdi
testl %esi, %esi
je 0x6e092
callq 0x571b0
jmp 0x6e097
callq 0x57810
cmpl $0x0, 0x40(%rbx)
movzbl %bpl, %ebp
jle 0x6e0ca
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
incl %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x60a9a
movq (%rax), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x18(%rax)
movl 0x40(%rbx), %eax
decl %eax
cmpl %eax, %r15d
jl 0x6e0a7
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x55af0
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/widgets/widget.cpp
// Function: smooth::GUI::Widget::EnqueueForDeletion()
S::Void S::GUI::Widget::EnqueueForDeletion()
{
	onEnqueueForDeletion.Emit();

	DeactivateTooltip();

	CloseContextMenu();

	if (registered && container != NIL) container->Remove(this);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x598, %rdi            # imm = 0x598
callq 0x701aa
movq %rbx, %rdi
callq 0x59208
movq %rbx, %rdi
callq 0x59128
cmpb $0x1, 0xca(%rbx)
jne 0x6e120
movq 0x190(%rbx), %rdi
testq %rdi, %rdi
je 0x6e120
movq (%rdi), %rax
movq 0x38(%rax), %rax
movq %rbx, %rsi
popq %rbx
jmpq *%rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/widgets/widget.cpp
// Function: smooth::GUI::Widget::Add(smooth::GUI::Widget*)
S::Int S::GUI::Widget::Add(Widget *widget)
{
	if (widget == NIL) return Error();

	if (!widget->IsRegistered())
	{
		widgets.Add(widget, widget->GetHandle());

		widget->EnableLocking(IsLockingEnabled());

		widget->SetContainer(this);
		widget->SetRegisteredFlag(True);

		widget->onRegister.Emit(this);

		if (widget->visible)
		{
			widget->visible = False;

			widget->Show();
		}

		return Success();
	}

	return Error();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0x6e1a4
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x88(%rax)
testb %al, %al
jne 0x6e1a4
leaq 0x38(%r14), %rdi
movl 0x8(%rbx), %edx
leaq 0x8(%rsp), %rsi
movq %rbx, (%rsi)
callq 0x5af42
movzbl 0x18(%r14), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %r14, 0x190(%rbx)
movb $0x1, 0xca(%rbx)
leaq 0x558(%rbx), %rdi
movq %r14, %rsi
callq 0x7024c
xorl %ebp, %ebp
cmpb $0x1, 0xcb(%rbx)
jne 0x6e1a4
movb $0x0, 0xcb(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x58(%rax)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/widgets/widget.cpp
// Function: smooth::GUI::Widget::Remove(smooth::GUI::Widget*)
S::Int S::GUI::Widget::Remove(Widget *widget)
{
	if (widget == NIL) return Error();

	if (widget->IsRegistered())
	{
		if (widgets.Remove(widget->GetHandle()) == True)
		{
			widget->Hide();
			widget->onUnregister.Emit(this);

			widget->SetRegisteredFlag(False);
			widget->SetContainer(NIL);

			widget->visible = True;

			return Success();
		}
	}

	return Error();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0x6e212
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x88(%rax)
testb %al, %al
je 0x6e212
leaq 0x38(%r14), %rdi
movl 0x8(%rbx), %esi
callq 0x58bb0
testb %al, %al
je 0x6e212
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x60(%rax)
leaq 0x578(%rbx), %rdi
movq %r14, %rsi
callq 0x7024c
movw $0x100, 0xca(%rbx)      # imm = 0x100
movq $0x0, 0x190(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/widgets/widget.cpp
// Function: smooth::GUI::Widget::GetContainerWindow() const
S::GUI::Window *S::GUI::Widget::GetContainerWindow() const
{
	Widget	*widget = const_cast<Widget *>(this);

	while (widget->GetObjectType() != Window::classID)
	{
		if (widget->GetContainer() == NIL) return NIL;

		widget = widget->GetContainer();
	}

	return (Window *) widget;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xfd601(%rip), %rax     # 0x16b828
movswl (%rax), %ebp
leaq 0x20(%rbx), %rdi
movl %ebp, %esi
callq 0x57520
testb %al, %al
jne 0x6e247
movq 0x190(%rbx), %rbx
testq %rbx, %rbx
jne 0x6e22a
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/widgets/widget.cpp
// Function: smooth::GUI::Widget::GetPreviousTabstopWidget(int) const
S::GUI::Widget *S::GUI::Widget::GetPreviousTabstopWidget(Int widgetHandle) const
{
	Widget	*lastTabstopObject = NIL;

	if (registered && widgetHandle != 0) lastTabstopObject = container->GetPreviousTabstopWidget(GetHandle());

	foreach (Widget *widget, widgets)
	{
		if (widget->GetHandle() == widgetHandle) return lastTabstopObject;

		if	(widget->IsTabstopCapable() && widget->IsActive()) lastTabstopObject = widget;
		else if (widget->GetPreviousTabstopWidget(0) != NIL)	   lastTabstopObject = widget->GetPreviousTabstopWidget(0);
	}

	if (widgetHandle == 0) return lastTabstopObject;

	return NIL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
testl %esi, %esi
je 0x6e2ac
cmpb $0x0, 0xca(%r14)
je 0x6e2ac
movq 0x190(%r14), %rdi
movl 0x8(%r14), %esi
callq 0x57d00
movq %rax, %r15
cmpl $0x0, 0x40(%r14)
jle 0x6e317
leaq 0x38(%r14), %r12
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
incl %ebp
movq %r12, %rdi
movl %ebp, %esi
callq 0x71140
movq (%rax), %r13
cmpl %ebx, 0x8(%r13)
je 0x6e31f
cmpb $0x1, 0xd2(%r13)
jne 0x6e2f1
movq (%r13), %rax
movq %r13, %rdi
callq *0x98(%rax)
testb %al, %al
je 0x6e2f1
movq %r13, %r15
jmp 0x6e30d
movq %r13, %rdi
xorl %esi, %esi
callq 0x57d00
testq %rax, %rax
je 0x6e30d
movq %r13, %rdi
xorl %esi, %esi
callq 0x57d00
movq %rax, %r15
movl 0x40(%r14), %eax
decl %eax
cmpl %eax, %ebp
jl 0x6e2bc
xorl %eax, %eax
testl %ebx, %ebx
cmovneq %rax, %r15
movq %r15, %rax
addq $0x8, %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/gui/widgets/widget.cpp
// Function: smooth::GUI::Widget::GetNextTabstopWidget(int) const
S::GUI::Widget *S::GUI::Widget::GetNextTabstopWidget(Int widgetHandle) const
{
	Bool	 found = False;

	if (widgetHandle == 0) found = True;

	foreach (Widget *widget, widgets)
	{
		if (widget->GetHandle() == widgetHandle)
		{
			found = True;
			continue;
		}

		if	(found && widget->IsTabstopCapable() && widget->IsActive()) return widget;
		else if (found && widget->GetNextTabstopWidget(0) != NIL)	    return widget->GetNextTabstopWidget(0);
	}

	if (registered && widgetHandle != 0) return container->GetNextTabstopWidget(GetHandle());

	return NIL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r12d
movq %rdi, %r15
movq $0x0, 0x8(%rsp)
movl %r12d, %ebx
movq %r15, %r13
cmpl $0x0, 0x40(%r15)
jle 0x6e3d3
testl %ebx, %ebx
sete %r14b
leaq 0x38(%r13), %rax
movq %rax, 0x10(%rsp)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
incl %ebp
movq 0x10(%rsp), %rdi
movl %ebp, %esi
callq 0x71140
movq (%rax), %r15
movl 0x8(%r15), %eax
cmpl %ebx, %eax
sete %cl
orb %r14b, %cl
cmpl %ebx, %eax
je 0x6e3c6
testb $0x1, %r14b
je 0x6e3c6
cmpb $0x1, 0xd2(%r15)
jne 0x6e3b1
movq (%r15), %rax
movq %r15, %rdi
callq *0x98(%rax)
testb %al, %al
jne 0x6e3f1
xorl %r12d, %r12d
movq %r15, %rdi
xorl %esi, %esi
callq 0x55fe0
movl %r14d, %ecx
testq %rax, %rax
jne 0x6e34f
movl 0x40(%r13), %eax
decl %eax
movl %ecx, %r14d
cmpl %eax, %ebp
jl 0x6e370
testl %ebx, %ebx
je 0x6e3f6
cmpb $0x0, 0xca(%r13)
je 0x6e3f6
movq 0x190(%r13), %r15
movl 0x8(%r13), %r12d
jmp 0x6e34f
movq %r15, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %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/gui/widgets/widget.cpp
// Function: smooth::GUI::Widget::ComputeTextSize()
S::Void S::GUI::Widget::ComputeTextSize()
{
	scaledTextSize.cx = font.GetScaledTextSizeX(text);
	scaledTextSize.cy = font.GetScaledTextSizeY(text);

	Float	 dpi = Surface().GetSurfaceDPI();

	if (Math::Abs(dpi - 96.0) < 0.1) unscaledTextSize = scaledTextSize;
	else				 unscaledTextSize = scaledTextSize * 96.0 / dpi;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x140(%rdi), %r14
leaq 0xf0(%rdi), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x56730
movl %eax, 0x188(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x57680
movl %eax, 0x18c(%rbx)
leaq 0x28(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x57150
movq %r14, %rdi
callq 0x58930
cwtl
cvtsi2sd %eax, %xmm0
movapd %xmm0, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x57b20
movsd 0x8508a(%rip), %xmm0    # 0xf3510
addsd 0x10(%rsp), %xmm0
callq 0x55660
movsd 0x8507f(%rip), %xmm1    # 0xf3518
ucomisd %xmm0, %xmm1
jbe 0x6e4ab
movq 0x188(%rbx), %rax
jmp 0x6e54a
cvtdq2pd 0x188(%rbx), %xmm0
mulpd 0x85065(%rip), %xmm0    # 0xf3520
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm2
cmpltpd %xmm1, %xmm2
movapd 0x85060(%rip), %xmm3    # 0xf3530
movapd 0x85068(%rip), %xmm4    # 0xf3540
movapd %xmm4, %xmm5
andpd %xmm2, %xmm5
andnpd %xmm3, %xmm2
orpd %xmm5, %xmm2
addpd %xmm0, %xmm2
cvttsd2si %xmm2, %rax
movq %rax, %xmm0
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
cvttsd2si %xmm2, %rax
movq %rax, %xmm2
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
cvtdq2pd %xmm0, %xmm0
movapd 0x10(%rsp), %xmm2
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
divpd %xmm2, %xmm0
movapd %xmm0, %xmm2
cmpltpd %xmm1, %xmm2
andpd %xmm2, %xmm4
andnpd %xmm3, %xmm2
orpd %xmm4, %xmm2
addpd %xmm0, %xmm2
cvttsd2si %xmm2, %rax
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
cvttsd2si %xmm2, %rcx
shlq $0x20, %rcx
movl %eax, %eax
orq %rcx, %rax
movq %rax, 0x180(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x57b20
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/widgets/widget.cpp
// Function: smooth::GUI::Widget::GetRealPosition() const
S::GUI::Point S::GUI::Widget::GetRealPosition() const
{
	if (!registered)  return pos;
	if (realPosValid) return realPos;

	Surface	*surface = GetDrawSurface();

	Point	 containerPos  = container->GetRealPosition();
	Size	 containerSize = container->GetRealSize();
	Point	 scaledPos     = pos * surface->GetSurfaceDPI() / 96.0;

	realPos	= containerPos + scaledPos;

	if (orientation == OR_UPPERRIGHT)
	{
		realPos.x = containerPos.x + containerSize.cx - scaledPos.x;
	}
	else if (orientation == OR_LOWERLEFT)
	{
		realPos.y = containerPos.y + containerSize.cy - scaledPos.y;
	}
	else if (orientation == OR_LOWERRIGHT)
	{
		realPos.x = containerPos.x + containerSize.cx - scaledPos.x;
		realPos.y = containerPos.y + containerSize.cy - scaledPos.y;
	}

	realPosValid = True;

	return realPos;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0xca(%rdi)
je 0x6e5d9
cmpb $0x1, 0xc8(%rbx)
jne 0x6e5e8
addq $0xb8, %rbx
jmp 0x6e5e0
addq $0xa8, %rbx
movq %rbx, %rdx
jmp 0x6e736
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
movq %rax, %r12
movq 0x190(%rbx), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq %rax, %r14
movq %rax, %r13
shrq $0x20, %r13
movq 0x190(%rbx), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq %rax, %r15
movq %r12, %rdi
callq 0x58930
cwtl
cvtsi2sd %eax, %xmm0
cvtdq2pd 0xa8(%rbx), %xmm1
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm1, %xmm0
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm2
cmpltpd %xmm1, %xmm2
movapd %xmm2, %xmm3
andnpd 0x84edf(%rip), %xmm3    # 0xf3530
andpd 0x84ee7(%rip), %xmm2    # 0xf3540
orpd %xmm3, %xmm2
addpd %xmm0, %xmm2
cvttsd2si %xmm2, %rax
movq %rax, %xmm0
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
cvttsd2si %xmm2, %rax
movq %rax, %xmm2
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
cvtdq2pd %xmm0, %xmm0
divpd 0x84e97(%rip), %xmm0    # 0xf3520
movapd %xmm0, %xmm2
cmpltpd %xmm1, %xmm2
movmskpd %xmm2, %edx
movsd 0x84cf2(%rip), %xmm1    # 0xf3390
movsd 0x84cf2(%rip), %xmm2    # 0xf3398
movapd %xmm1, %xmm3
testb $0x1, %dl
jne 0x6e6b3
movapd %xmm2, %xmm3
movq %r15, %rax
shrq $0x20, %rax
addsd %xmm0, %xmm3
cvttsd2si %xmm3, %rcx
testb $0x2, %dl
jne 0x6e6cc
movapd %xmm2, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rsi
leal (%r14,%rcx), %edi
leal (%rsi,%r13), %edx
shlq $0x20, %rdx
orq %rdx, %rdi
leaq 0xb8(%rbx), %rdx
movq %rdi, 0xb8(%rbx)
movzwl 0xd0(%rbx), %edi
cmpl $0x18, %edi
je 0x6e724
cmpl $0x28, %edi
je 0x6e717
cmpl $0x24, %edi
jne 0x6e72f
addl %r14d, %r15d
subl %ecx, %r15d
movl %r15d, (%rdx)
jmp 0x6e72f
addl %r14d, %r15d
subl %ecx, %r15d
movl %r15d, 0xb8(%rbx)
addl %r13d, %eax
subl %esi, %eax
movl %eax, 0xbc(%rbx)
movb $0x1, 0xc8(%rbx)
movq (%rdx), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/widgets/widget.cpp
// Function: smooth::GUI::Widget::GetRealSize() const
S::GUI::Size S::GUI::Widget::GetRealSize() const
{
	if (!registered)   return size;
	if (realSizeValid) return realSize;

	Surface	*surface = GetDrawSurface();

	realSize      = size * surface->GetSurfaceDPI() / 96.0;
	realSizeValid = True;

	return realSize;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0xca(%rdi)
je 0x6e766
cmpb $0x1, 0xc9(%rbx)
jne 0x6e772
movq 0xc0(%rbx), %rax
jmp 0x6e82f
movq 0xb0(%rbx), %rax
jmp 0x6e82f
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
movq %rax, %rdi
callq 0x58930
cwtl
cvtsi2sd %eax, %xmm0
cvtdq2pd 0xb0(%rbx), %xmm1
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm1, %xmm0
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm2
cmpltpd %xmm1, %xmm2
movapd 0x84d83(%rip), %xmm3    # 0xf3530
movapd 0x84d8b(%rip), %xmm4    # 0xf3540
movapd %xmm4, %xmm5
andpd %xmm2, %xmm5
andnpd %xmm3, %xmm2
orpd %xmm5, %xmm2
addpd %xmm0, %xmm2
cvttsd2si %xmm2, %rax
movq %rax, %xmm0
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
cvttsd2si %xmm2, %rax
movq %rax, %xmm2
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
cvtdq2pd %xmm0, %xmm0
divpd 0x84d2f(%rip), %xmm0    # 0xf3520
movapd %xmm0, %xmm2
cmpltpd %xmm1, %xmm2
andpd %xmm2, %xmm4
andnpd %xmm3, %xmm2
orpd %xmm4, %xmm2
addpd %xmm0, %xmm2
cvttsd2si %xmm2, %rax
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
cvttsd2si %xmm2, %rcx
shlq $0x20, %rcx
movl %eax, %eax
orq %rcx, %rax
movq %rax, 0xc0(%rbx)
movb $0x1, 0xc9(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/widgets/widget.cpp
// Function: smooth::GUI::Widget::SetBackgroundColor(smooth::GUI::Color const&)
S::Int S::GUI::Widget::SetBackgroundColor(const Color &nColor)
{
	if (backgroundColorSet && backgroundColor == nColor) return Success();

	backgroundColor	   = nColor;
	backgroundColorSet = True;

	Paint(SP_PAINT);

	return Success();
}

// Assembly:
cmpb $0x1, 0xd8(%rdi)
jne 0x6e848
movq 0xe8(%rdi), %rax
cmpq 0x8(%rsi), %rax
je 0x6e866
pushq %rax
movups (%rsi), %xmm0
movups %xmm0, 0xe0(%rdi)
movb $0x1, 0xd8(%rdi)
movq (%rdi), %rax
xorl %esi, %esi
callq *0x78(%rax)
addq $0x8, %rsp
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/widgets/widget.cpp
// Function: smooth::GUI::Widget::Show()
S::Int S::GUI::Widget::Show()
{
	if (visible) return Success();

	/* Show ourself.
	 */
	visible = True;

	if (!registered) return Success();

	if (IsVisible()) Paint(SP_PAINT);

	/* Show child widgets.
	 */
	for (Int i = 0; i < GetNOfObjects(); i++)
	{
		Widget	*object = GetNthObject(i);

		if (object == NIL || !object->IsVisible()) continue;

		visible = False;
		object->Hide();

		visible = True;
		object->Show();
	}

	/* Notify listeners.
	 */
	onShow.Emit();

	return Success();
}

// Assembly:
cmpb $0x0, 0xcb(%rdi)
jne 0x6e990
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0xcb(%rdi)
cmpb $0x1, 0xca(%rdi)
jne 0x6e986
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x90(%rax)
testb %al, %al
je 0x6e922
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
callq *0x78(%rax)
cmpl $0x0, 0x40(%rbx)
jle 0x6e977
leaq 0x38(%rbx), %r14
xorl %ebp, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x5b074
movq (%rax), %r15
testq %r15, %r15
je 0x6e970
movq (%r15), %rax
movq %r15, %rdi
callq *0x90(%rax)
testb %al, %al
je 0x6e970
movb $0x0, 0xcb(%rbx)
movq (%r15), %rax
movq %r15, %rdi
callq *0x60(%rax)
movb $0x1, 0xcb(%rbx)
movq (%r15), %rax
movq %r15, %rdi
callq *0x58(%rax)
incl %ebp
cmpl 0x40(%rbx), %ebp
jl 0x6e92e
addq $0x1f8, %rbx            # imm = 0x1F8
movq %rbx, %rdi
callq 0x701aa
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/widgets/widget.cpp
// Function: smooth::GUI::Widget::Hide()
S::Int S::GUI::Widget::Hide()
{
	if (!visible) return Success();

	/* Hide child widgets.
	 */
	for (Int i = 0; i < GetNOfObjects(); i++)
	{
		Widget	*object = GetNthObject(i);

		if (object == NIL || !object->IsVisible()) continue;

		object->Hide();
		visible = False;

		object->Show();
		visible = True;
	}

	/* Hide ourself.
	 */
	Surface	*surface = (IsVisible() ? GetDrawSurface() : NIL);

	visible = False;

	if (!registered) return Success();

	if (surface)
	{
		if (focussed) { focussed = False; onLoseFocus.Emit(); }

		surface->Box(GetVisibleArea(), container->GetBackgroundColor(), Rect::Filled);

		DeactivateTooltip();
	}

	/* Reset mouse status.
	 */
	mouseOver	= False;

	leftButtonDown	= False;
	rightButtonDown	= False;

	mouseDragging	= False;

	/* Notify listeners.
	 */
	onHide.Emit();

	return Success();
}

// Assembly:
cmpb $0x1, 0xcb(%rdi)
jne 0x6eade
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x40(%rdi)
jle 0x6ea03
leaq 0x38(%rbx), %r14
xorl %ebp, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x5b074
movq (%rax), %r15
testq %r15, %r15
je 0x6e9fc
movq (%r15), %rax
movq %r15, %rdi
callq *0x90(%rax)
testb %al, %al
je 0x6e9fc
movq (%r15), %rax
movq %r15, %rdi
callq *0x60(%rax)
movb $0x0, 0xcb(%rbx)
movq (%r15), %rax
movq %r15, %rdi
callq *0x58(%rax)
movb $0x1, 0xcb(%rbx)
incl %ebp
cmpl 0x40(%rbx), %ebp
jl 0x6e9ba
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x90(%rax)
testb %al, %al
je 0x6eaab
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
movb $0x0, 0xcb(%rbx)
cmpb $0x0, 0xca(%rbx)
je 0x6ead4
movq %rax, %r14
testq %rax, %rax
je 0x6eabb
cmpb $0x1, 0xcd(%rbx)
jne 0x6ea58
movb $0x0, 0xcd(%rbx)
leaq 0x518(%rbx), %rdi
callq 0x701aa
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x130(%rax)
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
movq 0x190(%rbx), %rdi
movq (%rdi), %rax
callq *0x140(%rax)
movq 0xfd521(%rip), %rcx     # 0x16bfa8
movl (%rcx), %ecx
movq %rsp, %r8
movq $0x0, (%r8)
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x57930
movq %rbx, %rdi
callq 0x59208
jmp 0x6eabb
movb $0x0, 0xcb(%rbx)
cmpb $0x0, 0xca(%rbx)
je 0x6ead4
movl $0x0, 0xd4(%rbx)
addq $0x218, %rbx            # imm = 0x218
movq %rbx, %rdi
callq 0x701aa
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/widgets/widget.cpp
// Function: smooth::GUI::Widget::Activate()
S::Int S::GUI::Widget::Activate()
{
	if (active) return Success();

	Surface	*surface = (IsVisible() ? GetDrawSurface() : NIL);

	if (surface) { surface->StartPaint(GetVisibleArea()); Hide(); }

	active = True;

	if (surface) { Show(); Process(SM_MOUSEMOVE, 0, 0); surface->EndPaint(); }

	onActivate.Emit();

	return Success();
}

// Assembly:
cmpb $0x0, 0xcc(%rdi)
jne 0x6eb8c
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x90(%rax)
testb %al, %al
je 0x6eb6f
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
testq %rax, %rax
je 0x6eb6f
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x130(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %r14, %rdi
callq 0x55160
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x60(%rax)
movb $0x1, 0xcc(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x58(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x7800, %esi           # imm = 0x7800
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x80(%rax)
movq %r14, %rdi
callq 0x58780
jmp 0x6eb76
movb $0x1, 0xcc(%rbx)
addq $0x238, %rbx            # imm = 0x238
movq %rbx, %rdi
callq 0x701aa
addq $0x18, %rsp
popq %rbx
popq %r14
xorl %eax, %eax
retq
nop