LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/widgets/special/tooltip.cpp
// Function: smooth::GUI::Tooltip::Tooltip()
S::GUI::Tooltip::Tooltip() : Widget(Point(), Size())
{
	type		= classID;
	orientation	= OR_FREE;
	toolWindow	= NIL;
	timeOut		= 5000;
	timer		= NIL;

	layer		= NIL;

	font.SetColor(Setup::TooltipTextColor);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
leaq 0x10(%rsp), %rsi
movq %r14, (%rsi)
leaq 0x8(%rsp), %rdx
movq %r14, (%rdx)
callq 0x57a30
movq 0xd5d73(%rip), %rax     # 0x16cd48
addq $0x10, %rax
movq %rax, (%rbx)
movq 0xd5665(%rip), %rax     # 0x16c648
movzwl (%rax), %eax
movw %ax, 0x20(%rbx)
movw $0x80, 0xd0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x5b8(%rbx)
movl $0x1388, 0x5c8(%rbx)    # imm = 0x1388
movq %r14, 0x5d0(%rbx)
leaq 0x140(%rbx), %rdi
movq 0xd5874(%rip), %rsi     # 0x16c890
callq 0x58650
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x57640
movq %r14, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/widgets/special/tooltip.cpp
// Function: smooth::GUI::Tooltip::~Tooltip()
S::GUI::Tooltip::~Tooltip()
{
	if (timer != NIL)
	{
		timer->Stop();

		DeleteObject(timer);
	}

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xd5d01(%rip), %rax     # 0x16cd48
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x5c0(%rdi), %rdi
testq %rdi, %rdi
je 0x9706b
callq 0x59190
movq 0x5c0(%rbx), %rdi
callq 0x58cc0
movq 0x5b8(%rbx), %rdi
testq %rdi, %rdi
je 0x9707c
callq 0x58cc0
movq %rbx, %rdi
popq %rbx
jmp 0x57640
movq %rax, %rdi
callq 0x5aede
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/widgets/special/tooltip.cpp
// Function: smooth::GUI::Tooltip::OnToolWindowPaint()
S::Void S::GUI::Tooltip::OnToolWindowPaint()
{
	Surface	*surface = toolWindow->GetDrawSurface();
	Rect	 tRect	 = Rect(Point(0, 0), surface->GetSize());

	surface->Box(tRect, Color(0, 0, 0), Rect::Outlined);

	surface->SetText(text, tRect + Point(2, 1), font);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x5b8(%rdi), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, %r14
movq %rax, %rdi
callq 0x57a60
xorl %edx, %edx
leaq 0x18(%rsp), %r12
movq %rdx, (%r12)
movl (%rax), %ecx
movl %ecx, 0x8(%r12)
movl 0x4(%rax), %eax
movl %eax, 0xc(%r12)
movq %rsp, %r15
movq %rdx, 0x8(%r15)
movl $0x0, (%r15)
movq 0xd53cb(%rip), %rax     # 0x16c820
movl (%rax), %ecx
leaq 0x10(%rsp), %r8
movq %rdx, (%r8)
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x57930
leaq 0xf0(%rbx), %rsi
movl (%r12), %eax
movl 0x4(%r12), %ecx
addl $0x2, %eax
incl %ecx
shlq $0x20, %rcx
movl 0x8(%r12), %edx
movl 0xc(%r12), %edi
addl $0x2, %edx
incl %edi
orq %rcx, %rax
shlq $0x20, %rdi
orq %rdi, %rdx
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
addq $0x140, %rbx            # imm = 0x140
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x57b80
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/widgets/special/tooltip.cpp
// Function: smooth::GUI::Tooltip::OnToolWindowEvent(int, int, int)
S::Void S::GUI::Tooltip::OnToolWindowEvent(Int message, Int wParam, Int lParam)
{
	static Bool	 forwarding = False;

	if (forwarding) return;

	Window	*window	= container ? container->GetContainerWindow() : NIL;

	if (window == NIL) return;

	forwarding = True;

	EnterProtectedRegion();

	switch (message)
	{
		/* Forward mouse wheel messages posted to
		 * the tool window to our parent window.
		 */
		case SM_MOUSEWHEEL:
			window->Process(message, wParam, lParam);

			break;

		/* Pass on keyboard events as well and hide
		 * the tooltip immediately after char events.
		 */
		case SM_KEYDOWN:
		case SM_KEYUP:
#ifdef __WIN32__
			window->Process(message, wParam, lParam);
#endif
			break;
		case SM_CHAR:
#ifdef __WIN32__
			window->Process(message, wParam, lParam);
#endif
			Hide();

			break;
	}

	LeaveProtectedRegion();

	forwarding = False;
}

// Assembly:
cmpb $0x0, 0xd856f(%rip)     # 0x16fa40
jne 0x9756d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movq 0x190(%rdi), %rdi
testq %rdi, %rdi
je 0x97502
callq 0x559e0
movq %rax, %r13
jmp 0x97505
xorl %r13d, %r13d
testq %r13, %r13
je 0x9755f
movb $0x1, 0xd852f(%rip)     # 0x16fa40
leaq 0x1c(%r14), %r12
movq %r12, %rdi
callq 0x578f0
cmpl $0x7810, %r15d          # imm = 0x7810
je 0x97547
cmpl $0x780c, %r15d          # imm = 0x780C
jne 0x97550
movq (%r13), %rax
movq %r13, %rdi
movl $0x780c, %esi           # imm = 0x780C
movl %ebp, %edx
movl %ebx, %ecx
callq *0x80(%rax)
jmp 0x97550
movq (%r14), %rax
movq %r14, %rdi
callq *0x60(%rax)
movq %r12, %rdi
callq 0x55cc0
movb $0x0, 0xd84e1(%rip)     # 0x16fa40
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/gui/widgets/special/tooltip.cpp
// Function: smooth::GUI::Tooltip::OnTimer()
S::Void S::GUI::Tooltip::OnTimer()
{
	Hide();

	timer->Stop();

	DeleteObject(timer);

	timer = NIL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x60(%rax)
movq 0x5c0(%rbx), %rdi
callq 0x59190
movq 0x5c0(%rbx), %rdi
callq 0x58cc0
movq $0x0, 0x5c0(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/widgets/special/tooltip.cpp
// Function: smooth::GUI::Tooltip::Hide()
S::Int S::GUI::Tooltip::Hide()
{
	if (!visible) return Success();

	visible = False;

	if (!IsRegistered()) return Success();

	if (toolWindow != NIL)
	{
		toolWindow->Close();

		Remove(toolWindow);

		if (layer != NIL) toolWindow->Remove(layer);

		toolWindow->onPaint.Disconnect(&Tooltip::OnToolWindowPaint, this);
		toolWindow->onEvent.Disconnect(&Tooltip::OnToolWindowEvent, this);

		DeleteObject(toolWindow);

		toolWindow = NIL;
	}

	onHide.Emit();

	return Success();
}

// Assembly:
cmpb $0x1, 0xcb(%rdi)
jne 0x97662
pushq %rbx
movq %rdi, %rbx
movb $0x0, 0xcb(%rdi)
movq (%rdi), %rax
callq *0x88(%rax)
testb %al, %al
je 0x97661
movq 0x5b8(%rbx), %rdi
testq %rdi, %rdi
je 0x97652
callq 0x58420
movq 0x5b8(%rbx), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x38(%rax)
movq 0x5d0(%rbx), %rsi
testq %rsi, %rsi
je 0x97601
movq 0x5b8(%rbx), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movl $0x648, %edi            # imm = 0x648
addq 0x5b8(%rbx), %rdi
movq 0xd4d44(%rip), %rsi     # 0x16c358
xorl %edx, %edx
movq %rbx, %rcx
callq 0x977e2
movl $0x668, %edi            # imm = 0x668
addq 0x5b8(%rbx), %rdi
movq 0xd5617(%rip), %rsi     # 0x16cc48
xorl %edx, %edx
movq %rbx, %rcx
callq 0x9784e
movq 0x5b8(%rbx), %rdi
callq 0x58cc0
movq $0x0, 0x5b8(%rbx)
addq $0x218, %rbx            # imm = 0x218
movq %rbx, %rdi
callq 0x70488
popq %rbx
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/toolwindow.cpp
// Function: smooth::GUI::ToolWindow::ToolWindow(smooth::GUI::Point const&, smooth::GUI::Size const&)
S::GUI::ToolWindow::ToolWindow(const Point &iPos, const Size &iSize) : Window("smooth ToolWindow", iPos, iSize)
{
	type		= classID;
	orientation	= OR_FREE;
	visible		= True;

	frameWidth	= 0;

	backend->SetSizeModifier(Size());

	SetFlags(WF_TOPMOST | WF_NOTASKBUTTON | WF_THINBORDER);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x6050b(%rip), %rsi     # 0xf7f3e
movq %rsp, %r12
movq %r12, %rdi
callq 0x579f0
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x58c10
movq %rsp, %r14
movq %r14, %rdi
callq 0x59200
movq 0xd4b54(%rip), %rax     # 0x16c5b8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0xd5266(%rip), %rax     # 0x16ccd8
movzwl (%rax), %eax
movw %ax, 0x20(%rbx)
movw $0x80, 0xd0(%rbx)
movb $0x1, 0xcb(%rbx)
movl $0x0, 0x5e8(%rbx)
movq 0x5c0(%rbx), %rdi
movq $0x0, (%r14)
movq %rsp, %rsi
callq 0x9ace6
movl $0x1a, 0x30(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x559c0
jmp 0x97ad4
movq %rax, %r14
movq %rsp, %rdi
callq 0x59200
movq %r14, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/toolwindow.cpp
// Function: smooth::GUI::ToolWindow::Create()
S::Bool S::GUI::ToolWindow::Create()
{
	if (IsRegistered())
	{
		Window	*containerWindow = container->GetContainerWindow();

		if (containerWindow != NIL)
		{
			if (IsRightToLeft()) Window::SetMetrics(Point(containerWindow->GetRealSize().cx - (GetX() + GetRealSize().cx), GetY()), GetSize());

			Window::SetMetrics(GetPosition() + containerWindow->GetPosition(), GetSize());
		}
	}

	return Window::Create();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x88(%rax)
testb %al, %al
je 0x97bb1
movq 0x190(%rbx), %rdi
callq 0x559e0
testq %rax, %rax
je 0x97bb1
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x160(%rax)
testb %al, %al
je 0x97b7b
movq (%r14), %rax
movq %r14, %rdi
callq *0x50(%rax)
movq %rax, %r15
movl 0xa8(%rbx), %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x50(%rax)
addl %ebp, %eax
subl %eax, %r15d
movl 0xac(%rbx), %eax
movq %rsp, %rsi
movl %r15d, (%rsi)
movl %eax, 0x4(%rsi)
leaq 0xb0(%rbx), %rdx
movq %rbx, %rdi
callq 0x55bf0
movl 0xa8(%r14), %eax
addl 0xa8(%rbx), %eax
movl 0xac(%r14), %ecx
addl 0xac(%rbx), %ecx
shlq $0x20, %rcx
orq %rcx, %rax
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0xb0(%rbx), %rdx
movq %rbx, %rdi
callq 0x55bf0
movq %rbx, %rdi
callq 0x553f0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/toolwindow.cpp
// Function: smooth::GUI::ToolWindow::SetMetrics(smooth::GUI::Point const&, smooth::GUI::Size const&)
S::Int S::GUI::ToolWindow::SetMetrics(const Point &nPos, const Size &nSize)
{
	Point	 position = nPos;

	if (IsRegistered() && created)
	{
		Window	*containerWindow = container->GetContainerWindow();

		if (containerWindow != NIL)
		{
			if (IsRightToLeft())
			{
				Surface	*surface  = GetDrawSurface();
				Float	 fontSize = surface->GetSurfaceDPI() / 96.0;

				position.x = containerWindow->GetRealSize().cx - (nPos.x + Math::Round(nSize.cx * fontSize));
			}

			position += containerWindow->GetPosition();
		}
	}

	return Window::SetMetrics(position, nSize);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rax
movq %rax, 0x8(%rsp)
movq (%rdi), %rax
callq *0x88(%rax)
testb %al, %al
je 0x97ca1
cmpb $0x1, 0x5ca(%r14)
jne 0x97ca1
movq 0x190(%r14), %rdi
callq 0x559e0
testq %rax, %rax
je 0x97ca1
movq %rax, %r12
movq (%r14), %rax
movq %r14, %rdi
callq *0x160(%rax)
testb %al, %al
je 0x97c89
movq (%r14), %rax
movq %r14, %rdi
callq *0x40(%rax)
movq %rax, %rdi
callq 0x58930
cwtl
cvtsi2sd %eax, %xmm0
divsd 0x5c8ab(%rip), %xmm0    # 0xf44f0
movsd %xmm0, 0x10(%rsp)
movq (%r12), %rax
movq %r12, %rdi
callq *0x50(%rax)
xorps %xmm0, %xmm0
cvtsi2sdl (%rbx), %xmm0
mulsd 0x10(%rsp), %xmm0
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
ucomisd %xmm0, %xmm1
seta %cl
leaq 0x5cb1a(%rip), %rdx     # 0xf4790
addsd (%rdx,%rcx,8), %xmm0
cvttsd2si %xmm0, %rcx
addl (%r15), %ecx
subl %ecx, %eax
movl %eax, 0x8(%rsp)
movl 0xa8(%r12), %eax
addl %eax, 0x8(%rsp)
movl 0xac(%r12), %eax
addl %eax, 0xc(%rsp)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x55bf0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/toolwindow.cpp
// Function: smooth::GUI::ToolWindow::IsRightToLeft() const
S::Bool S::GUI::ToolWindow::IsRightToLeft() const
{
	if (IsRegistered() && layoutDirection == LD_DEFAULT)
	{
		Window	*containerWindow = container->GetContainerWindow();

		if (containerWindow != NIL) return containerWindow->IsRightToLeft();
	}

	return Window::IsRightToLeft();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x88(%rax)
testb %al, %al
je 0x97d0c
cmpl $0x0, 0x618(%rbx)
jne 0x97d0c
movq 0x190(%rbx), %rdi
callq 0x559e0
movq %rax, %r14
testq %rax, %rax
je 0x97cfd
movq (%r14), %rax
movq %r14, %rdi
callq *0x160(%rax)
jmp 0x97cfd
testq %r14, %r14
je 0x97d0c
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x57440
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/window.cpp
// Function: smooth::GUI::Window::~Window()
S::GUI::Window::~Window()
{
	backend->onEvent.Disconnect(&Window::Process, this);

	if (created && !destroyed) backend->Close();

	Remove(mainLayer);
	DeleteObject(mainLayer);

	windows.Remove(GetHandle());

	delete backend;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xd45f6(%rip), %rax     # 0x16c748
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x5c0(%rdi), %rdi
addq $0x58, %rdi
movl $0x81, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x99fbc
cmpb $0x1, 0x5ca(%rbx)
jne 0x98192
cmpb $0x0, 0x5cb(%rbx)
jne 0x98192
movq 0x5c0(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x620(%rbx), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x38(%rax)
movq 0x620(%rbx), %rdi
callq 0x58cc0
movl 0x8(%rbx), %esi
movq 0xd44f8(%rip), %rdi     # 0x16c6b0
callq 0x58bb0
movq 0x5c0(%rbx), %rdi
testq %rdi, %rdi
je 0x981cf
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x6b0(%rbx), %rdi
leaq 0xd0c63(%rip), %rax     # 0x168e40
movq %rax, 0x6b0(%rbx)
callq 0x9a180
leaq 0x688(%rbx), %rdi
leaq 0xd0bd9(%rip), %rax     # 0x168dd0
movq %rax, 0x688(%rbx)
callq 0x6b418
leaq 0x668(%rbx), %rdi
leaq 0xd0c9f(%rip), %rax     # 0x168eb0
movq %rax, 0x668(%rbx)
callq 0x9a2b4
leaq 0x648(%rbx), %rdi
leaq 0xca51d(%rip), %r14     # 0x162748
movq %r14, 0x648(%rbx)
callq 0x70d68
leaq 0x628(%rbx), %rdi
movq %r14, 0x628(%rbx)
callq 0x70d68
leaq 0x600(%rbx), %rdi
callq 0x59200
leaq 0x5d0(%rbx), %rdi
callq 0x59148
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x57640
jmp 0x9827b
jmp 0x9827b
jmp 0x9827b
jmp 0x9827b
jmp 0x9827b
movq %rax, %rdi
callq 0x5aede
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/window.cpp
// Function: smooth::GUI::Window::SetMetrics(smooth::GUI::Point const&, smooth::GUI::Size const&)
S::Int S::GUI::Window::SetMetrics(const Point &nPos, const Size &nSize)
{
	if (created && visible) backend->SetMetrics(nPos, nSize);

	Bool	 resized     = (GetSize() != nSize);
	Bool	 prevVisible = visible;

	visible = False;

	Widget::SetMetrics(nPos, nSize);

	if (resized) CalculateOffsets();

	visible = prevVisible;

	return Success();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
cmpb $0x1, 0x5ca(%rdi)
jne 0x982d8
cmpb $0x1, 0xcb(%rbx)
jne 0x982d8
movq 0x5c0(%rbx), %rdi
movq (%rdi), %rax
movq %rsi, %r15
movq %r14, %rdx
callq *0x90(%rax)
movq %r15, %rsi
movl (%r14), %ebp
movl 0xb0(%rbx), %r15d
movl 0xb4(%rbx), %r12d
movl 0x4(%r14), %r13d
movb 0xcb(%rbx), %al
movb %al, 0x7(%rsp)
movb $0x0, 0xcb(%rbx)
movq %rbx, %rdi
movq %r14, %rdx
callq 0x57080
cmpl %ebp, %r15d
jne 0x98313
cmpl %r13d, %r12d
je 0x9831b
movq %rbx, %rdi
callq 0x55ef0
movb 0x7(%rsp), %al
movb %al, 0xcb(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/window.cpp
// Function: smooth::GUI::Window::SetIcon(smooth::GUI::Bitmap const&)
S::Int S::GUI::Window::SetIcon(const Bitmap &nIcon)
{
	Bitmap	 newIcon = nIcon;

#ifdef __WIN32__
	if (newIcon == NIL) newIcon = ImageLoader::Load(String("Icon:").Append(String::FromInt(IDI_ICON)));
#endif

	if (newIcon != NIL)
	{
		icon = newIcon;

		backend->SetIcon(icon);
	}

	return Success();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x57160
movq %r14, %rdi
xorl %esi, %esi
callq 0x563f0
testb %al, %al
je 0x9870c
leaq 0x5d0(%rbx), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x582c0
movq 0x5c0(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x40(%rax)
movq %rsp, %rdi
callq 0x59148
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59148
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/window.cpp
// Function: smooth::GUI::Window::SetText(smooth::String const&)
S::Int S::GUI::Window::SetText(const String &nTitle)
{
	text = nTitle;

	if (created && !destroyed)
	{
		Process(SM_WINDOWTITLECHANGED, 0, 0);

		backend->SetTitle(text);
	}

	return Success();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0xf0(%rdi), %rbx
movq %rbx, %rdi
callq 0x555f0
cmpb $0x1, 0x5ca(%r14)
jne 0x98793
cmpb $0x0, 0x5cb(%r14)
jne 0x98793
movq (%r14), %rax
movq %r14, %rdi
movl $0x780a, %esi           # imm = 0x780A
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x80(%rax)
movq 0x5c0(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/window.cpp
// Function: smooth::GUI::Window::SetStatusText(smooth::String const&)
S::Int S::GUI::Window::SetStatusText(const String &nStatus)
{
	for (Int i = 0; i < GetNOfObjects(); i++)
	{
		Widget *widget = GetNthObject(i);

		if (widget == NIL) continue;

		if (widget->GetObjectType() == Statusbar::classID)
		{
			widget->SetText(nStatus);

			return Success();
		}
	}

	return Error();
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x0, 0x40(%rdi)
jle 0x98832
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x38(%rdi), %r12
movq 0xd3cc7(%rip), %rax     # 0x16c490
xorl %ebp, %ebp
movswl (%rax), %r13d
movq %r12, %rdi
movl %ebp, %esi
callq 0x5b0a4
movq (%rax), %rbx
testq %rbx, %rbx
je 0x98809
leaq 0x20(%rbx), %rdi
movl %r13d, %esi
callq 0x57520
xorl %ecx, %ecx
testb %al, %al
je 0x9880e
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0xa0(%rax)
movl $0x1, %ecx
jmp 0x9880e
movl $0x4, %ecx
testb $0x3, %cl
jne 0x98822
incl %ebp
cmpl 0x40(%r15), %ebp
jl 0x987cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x98824
xorl %eax, %eax
addq $0x8, %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/gui/window/window.cpp
// Function: smooth::GUI::Window::GetStatusText() const
const S::String &S::GUI::Window::GetStatusText() const
{
	for (Int i = 0; i < GetNOfObjects(); i++)
	{
		Widget *widget = GetNthObject(i);

		if (widget == NIL) continue;

		if (widget->GetObjectType() == Statusbar::classID) return widget->GetText();
	}

	return defaultStatus;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x40(%rdi)
setg %r14b
jle 0x988b0
leaq 0x38(%rbx), %r15
movq 0xd3c39(%rip), %rax     # 0x16c490
xorl %ebp, %ebp
movswl (%rax), %r12d
movq %r15, %rdi
movl %ebp, %esi
callq 0x5b0a4
movq (%rax), %r13
testq %r13, %r13
je 0x98899
leaq 0x20(%r13), %rdi
movl %r12d, %esi
callq 0x57520
xorl %ecx, %ecx
testb %al, %al
je 0x9889e
movq (%r13), %rax
movq %r13, %rdi
callq *0xa8(%rax)
movq %rax, (%rsp)
movl $0x1, %ecx
jmp 0x9889e
movl $0x4, %ecx
testb $0x3, %cl
jne 0x988b0
incl %ebp
cmpl 0x40(%rbx), %ebp
setl %r14b
jl 0x9885d
jmp 0x988b0
addq $0x600, %rbx            # imm = 0x600
testb $0x1, %r14b
cmovneq (%rsp), %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/gui/window/window.cpp
// Function: smooth::GUI::Window::RestoreDefaultStatusText()
S::Int S::GUI::Window::RestoreDefaultStatusText()
{
	for (Int i = 0; i < GetNOfObjects(); i++)
	{
		Widget *widget = GetNthObject(i);

		if (widget == NIL) continue;

		if (widget->GetObjectType() == Statusbar::classID)
		{
			widget->SetText(defaultStatus);

			break;
		}
	}

	return Success();
}

// Assembly:
cmpl $0x0, 0x40(%rdi)
jle 0x98978
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
movq 0xd3b7f(%rip), %rax     # 0x16c490
leaq 0x600(%rdi), %r15
xorl %ebp, %ebp
movswl (%rax), %r12d
movq %r14, %rdi
movl %ebp, %esi
callq 0x5b0a4
movq (%rax), %r13
testq %r13, %r13
je 0x98959
leaq 0x20(%r13), %rdi
movl %r12d, %esi
callq 0x57520
xorl %ecx, %ecx
testb %al, %al
je 0x9895e
movq (%r13), %rax
movq %r13, %rdi
movq %r15, %rsi
callq *0xa0(%rax)
movl $0x2, %ecx
jmp 0x9895e
movl $0x4, %ecx
testb $0x3, %cl
jne 0x9896a
incl %ebp
cmpl 0x40(%rbx), %ebp
jl 0x9891e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/window.cpp
// Function: smooth::GUI::Window::SetRightToLeft(bool)
S::Int S::GUI::Window::SetRightToLeft(Bool nRightToLeft)
{
	Surface	*surface = GetDrawSurface();

	surface->SetRightToLeft(nRightToLeft);

	layoutDirection = (nRightToLeft ? LD_RIGHTTOLEFT : LD_LEFTTORIGHT);

	return Success();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, %rdi
movl %ebx, %esi
callq 0x58480
incl %ebx
movl %ebx, 0x618(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/window.cpp
// Function: smooth::GUI::Window::Show()
S::Int S::GUI::Window::Show()
{
	order = Object::RequestObjectHandle();

	if (!created) Create();

	backend->SetMetrics(GetPosition(), GetSize());

	onChangePosition.Emit(GetPosition());
	onChangeSize.Emit(GetSize());

	if (maximized && !visibilitySet)
	{
		backend->Hide();

		maximized = False;
		Maximize();
	}

	if (minimized && !visibilitySet)
	{
		backend->Hide();

		minimized = False;
		Minimize();
	}

	visible	      = True;
	visibilitySet = True;

	backend->Show();

	onShow.Emit();

	return Success();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x55bd0
movl %eax, 0x5b8(%rbx)
cmpb $0x0, 0x5ca(%rbx)
jne 0x98a0e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x168(%rax)
movq 0x5c0(%rbx), %rdi
leaq 0xa8(%rbx), %r14
leaq 0xb0(%rbx), %r15
movq (%rdi), %rax
movq %r14, %rsi
movq %r15, %rdx
callq *0x90(%rax)
leaq 0x278(%rbx), %rdi
movq %r14, %rsi
callq 0x70676
leaq 0x298(%rbx), %rdi
movq %r15, %rsi
callq 0x7094c
cmpb $0x1, 0x5c8(%rbx)
jne 0x98a9b
cmpb $0x0, 0x5cc(%rbx)
jne 0x98a9b
movq 0x5c0(%rbx), %rdi
movq (%rdi), %rax
callq *0x80(%rax)
movb $0x0, 0x5c8(%rbx)
cmpb $0x0, 0x5ca(%rbx)
je 0x98a94
movq 0x5c0(%rbx), %rdi
movq (%rdi), %rax
callq *0xa0(%rax)
jmp 0x98a9b
movb $0x1, 0x5c8(%rbx)
cmpb $0x1, 0x5c9(%rbx)
jne 0x98ae6
cmpb $0x0, 0x5cc(%rbx)
jne 0x98ae6
movq 0x5c0(%rbx), %rdi
movq (%rdi), %rax
callq *0x80(%rax)
movb $0x0, 0x5c9(%rbx)
cmpb $0x0, 0x5ca(%rbx)
je 0x98adf
movq 0x5c0(%rbx), %rdi
movq (%rdi), %rax
callq *0x98(%rax)
jmp 0x98ae6
movb $0x1, 0x5c9(%rbx)
movb $0x1, %al
movb %al, 0xcb(%rbx)
movb %al, 0x5cc(%rbx)
movq 0x5c0(%rbx), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
addq $0x1f8, %rbx            # imm = 0x1F8
movq %rbx, %rdi
callq 0x70488
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/window.cpp
// Function: smooth::GUI::Window::Maximize()
S::Int S::GUI::Window::Maximize()
{
	if (maximized) return Success();

	if (!created)
	{
		maximized = True;

		return Success();
	}

	backend->Maximize();

	return Success();
}

// Assembly:
cmpb $0x0, 0x5c8(%rdi)
jne 0x98b48
cmpb $0x0, 0x5ca(%rdi)
je 0x98b41
pushq %rax
movq 0x5c0(%rdi), %rdi
movq (%rdi), %rax
callq *0xa0(%rax)
addq $0x8, %rsp
jmp 0x98b48
movb $0x1, 0x5c8(%rdi)
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/window.cpp
// Function: smooth::GUI::Window::Minimize()
S::Int S::GUI::Window::Minimize()
{
	if (minimized) return Success();

	if (!created)
	{
		minimized = True;

		return Success();
	}

	backend->Minimize();

	return Success();
}

// Assembly:
cmpb $0x0, 0x5c9(%rdi)
jne 0x98b7c
cmpb $0x0, 0x5ca(%rdi)
je 0x98b75
pushq %rax
movq 0x5c0(%rdi), %rdi
movq (%rdi), %rax
callq *0x98(%rax)
addq $0x8, %rsp
jmp 0x98b7c
movb $0x1, 0x5c9(%rdi)
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/window.cpp
// Function: smooth::GUI::Window::Hide()
S::Int S::GUI::Window::Hide()
{
	if (!visible) return Success();

	if (created) backend->Hide();

	visible	      = False;
	visibilitySet = True;

	onHide.Emit();

	return Success();
}

// Assembly:
cmpb $0x1, 0xcb(%rdi)
jne 0x98bc4
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x5ca(%rdi)
jne 0x98ba6
movq 0x5c0(%rbx), %rdi
movq (%rdi), %rax
callq *0x80(%rax)
movb $0x0, 0xcb(%rbx)
movb $0x1, 0x5cc(%rbx)
addq $0x218, %rbx            # imm = 0x218
movq %rbx, %rdi
callq 0x70488
popq %rbx
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/window.cpp
// Function: smooth::GUI::Window::Restore()
S::Int S::GUI::Window::Restore()
{
	if (!maximized && !minimized) return Success();

	if (!created)
	{
		maximized = False;
		minimized = False;

		return Success();
	}

	backend->Restore();

	return Success();
}

// Assembly:
cmpb $0x0, 0x5c8(%rdi)
jne 0x98bda
cmpb $0x1, 0x5c9(%rdi)
jne 0x98c03
cmpb $0x0, 0x5ca(%rdi)
je 0x98bfa
pushq %rax
movq 0x5c0(%rdi), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
addq $0x8, %rsp
jmp 0x98c03
movw $0x0, 0x5c8(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/window.cpp
// Function: smooth::GUI::Window::Create()
S::Bool S::GUI::Window::Create()
{
	if (!IsRegistered() || created) return False;

#ifdef __WIN32__
	if (flags & WF_NORESIZE) frameWidth = 4;
#endif

	/* Check if there is a titlebar.
	 */
	flags |= WF_NOTITLE;

	for (Int i = 0; i < GetNOfObjects(); i++)
	{
		Widget	*widget = GetNthObject(i);

		if (widget->GetObjectType() == Titlebar::classID) { flags ^= WF_NOTITLE; break; }
	}

	/* Open the new window.
	 */
	if (backend->Open(text, GetPosition(), GetSize(), flags) == Success())
	{
		Surface	*surface = GetDrawSurface();

		surface->SetRightToLeft(IsRightToLeft());

		visible = False;

		return True;
	}

	return False;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x88(%rax)
testb %al, %al
je 0x98de1
cmpb $0x0, 0x5ca(%rbx)
jne 0x98de1
orb $0x40, 0x31(%rbx)
cmpl $0x0, 0x40(%rbx)
jle 0x98db7
leaq 0x38(%rbx), %r14
movq 0xd3ac1(%rip), %rax     # 0x16c848
xorl %ebp, %ebp
movswl (%rax), %r15d
movq %r14, %rdi
movl %ebp, %esi
callq 0x5b0a4
movq (%rax), %rdi
addq $0x20, %rdi
movl %r15d, %esi
callq 0x57520
testb %al, %al
jne 0x98db3
incl %ebp
cmpl 0x40(%rbx), %ebp
jl 0x98d8d
jmp 0x98db7
xorb $0x40, 0x31(%rbx)
movq 0x5c0(%rbx), %rdi
leaq 0xf0(%rbx), %rsi
leaq 0xa8(%rbx), %rdx
leaq 0xb0(%rbx), %rcx
movl 0x30(%rbx), %r8d
movq (%rdi), %rax
callq *0x20(%rax)
testl %eax, %eax
je 0x98dee
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x160(%rax)
movzbl %al, %esi
movq %r14, %rdi
callq 0x58480
movb $0x0, 0xcb(%rbx)
movb $0x1, %al
jmp 0x98de3
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/window.cpp
// Function: smooth::GUI::Window::WaitUntilClosed()
S::Int S::GUI::Window::WaitUntilClosed()
{
	if (!IsRegistered()) return Error();

	if (!created) Create();
	if (!visible) Show();

	/* Wait here until window is closed.
	 */
	System::EventProcessor	 event;

	while (!destroyed) event.ProcessNextEvent();

	/* Sleep while Window is still in use.
	 */
	while (IsObjectInUse()) S::System::System::Sleep(10);

	return Success();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x88(%rax)
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %cl, %cl
je 0x98e9e
cmpb $0x0, 0x5ca(%rbx)
jne 0x98e4f
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x168(%rax)
cmpb $0x0, 0xcb(%rbx)
jne 0x98e61
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x58(%rax)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x57260
movb 0x5cb(%rbx), %al
cmpb $0x1, %al
je 0x98e8c
movq %r14, %rdi
callq 0x568b0
jmp 0x98e6e
movl $0xa, %edi
callq 0x578c0
cmpl $0x0, 0x1c(%rbx)
jg 0x98e82
leaq 0x8(%rsp), %rdi
callq 0x557d0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x98ea8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x557d0
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/window.cpp
// Function: smooth::GUI::Window::OnCreate()
S::Void S::GUI::Window::OnCreate()
{
	EnterProtectedRegion();

	if (GetObjectType() != ToolWindow::classID) nOfActiveWindows++;

	created = True;

	CalculateOffsets();

	onCreate.Emit();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x1c, %rdi
callq 0x578f0
leaq 0x20(%rbx), %rdi
movq 0xd3df0(%rip), %rax     # 0x16ccd8
movswl (%rax), %esi
callq 0x57520
testb %al, %al
jne 0x98efe
movq 0xd3745(%rip), %rax     # 0x16c640
incw (%rax)
movb $0x1, 0x5ca(%rbx)
movq %rbx, %rdi
callq 0x55ef0
addq $0x628, %rbx            # imm = 0x628
movq %rbx, %rdi
popq %rbx
jmp 0x70488
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/window.cpp
// Function: smooth::GUI::Window::OnDestroy()
S::Void S::GUI::Window::OnDestroy()
{
	destroyed = True;
	visible	  = False;

	if (GetObjectType() != ToolWindow::classID) nOfActiveWindows--;

	LeaveProtectedRegion();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb $0x1, 0x5cb(%rdi)
movb $0x0, 0xcb(%rdi)
addq $0x20, %rdi
movq 0xd3d9d(%rip), %rax     # 0x16ccd8
movswl (%rax), %esi
callq 0x57520
testb %al, %al
jne 0x98f51
movq 0xd36f2(%rip), %rax     # 0x16c640
decw (%rax)
addq $0x1c, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x55cc0
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/window.cpp
// Function: smooth::GUI::Window::GetMousePosition() const
S::GUI::Point S::GUI::Window::GetMousePosition() const
{
	Point	 position = Input::Pointer::GetPosition();

	if (IsRightToLeft()) position = Point(GetRealSize().cx - (position.x - GetX()) - 1, position.y - GetY());
	else		     position -= GetPosition();

	return position;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x555d0
movq (%rax), %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x160(%rax)
testb %al, %al
je 0x99a75
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x50(%rax)
movl %r14d, %ecx
notl %ecx
addl 0xa8(%rbx), %ecx
addl %eax, %ecx
jmp 0x99a80
movl 0xa8(%rbx), %eax
movl %r14d, %ecx
subl %eax, %ecx
shrq $0x20, %r14
subl 0xac(%rbx), %r14d
shlq $0x20, %r14
movl %ecx, %eax
orq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/window.cpp
// Function: smooth::GUI::Window::IsMouseOn(smooth::GUI::Rect const&) const
S::Bool S::GUI::Window::IsMouseOn(const Rect &rect) const
{
	Surface	*surface = GetDrawSurface();

	if (surface->GetSystemSurface() == NIL) return False;

	Point	 mousePos = GetMousePosition();

	if ((mousePos.x >= rect.left) && (mousePos.x < rect.right) && (mousePos.y >= rect.top) && (mousePos.y < rect.bottom))
	{
		if (Input::Pointer::GetPointerWindow() != this)	return False;
		else						return True;
	}

	return False;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, %rdi
callq 0x556f0
testq %rax, %rax
je 0x99aee
movq %rbx, %rdi
callq 0x56b50
movq %rax, %rcx
xorl %eax, %eax
cmpl %ecx, (%r14)
jg 0x99af0
cmpl %ecx, 0x8(%r14)
jle 0x99af0
shrq $0x20, %rcx
cmpl %ecx, 0x4(%r14)
jg 0x99af0
cmpl %ecx, 0xc(%r14)
jle 0x99af0
callq 0x57530
cmpq %rbx, %rax
sete %al
jmp 0x99af0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/window.cpp
// Function: smooth::GUI::Window::Remove(smooth::GUI::Widget*)
S::Int S::GUI::Window::Remove(Widget *widget)
{
	if (widget == NIL) return Error();

	if (widget->GetOrientation() == OR_UPPERLEFT || widget->GetOrientation() == OR_UPPERRIGHT || widget->GetOrientation() == OR_LOWERLEFT || widget->GetOrientation() == OR_LOWERRIGHT)
	{
		if (mainLayer->Remove(widget) == Success())
		{
			/* Disable drag & drop if the removed widget was a target.
			 */
			if (!IsDropTarget()) backend->EnableDropFiles(False);

			return Success();
		}

		return Error();
	}

	if (Widget::Remove(widget) == Success())
	{
		/* Recalculate offsets unless the removed widget had free orientation.
		 */
		if (widget->GetOrientation() != OR_FREE) CalculateOffsets();

		/* Disable drag & drop if the removed widget was a target.
		 */
		if (!IsDropTarget()) backend->EnableDropFiles(False);

		return Success();
	}

	return Error();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0x99e21
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x128(%rax)
cmpl $0x14, %eax
je 0x99dec
movq (%r14), %rax
movq %r14, %rdi
callq *0x128(%rax)
cmpl $0x24, %eax
je 0x99dec
movq (%r14), %rax
movq %r14, %rdi
callq *0x128(%rax)
cmpl $0x18, %eax
je 0x99dec
movq (%r14), %rax
movq %r14, %rdi
callq *0x128(%rax)
cmpl $0x28, %eax
jne 0x99e28
movq 0x620(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x38(%rax)
testl %eax, %eax
jne 0x99e21
movq %rbx, %rdi
callq 0x57e00
testb %al, %al
je 0x99e10
xorl %ebp, %ebp
jmp 0x99e21
movq 0x5c0(%rbx), %rdi
movq (%rdi), %rax
xorl %ebp, %ebp
xorl %esi, %esi
callq *0x58(%rax)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x56df0
testl %eax, %eax
jne 0x99e21
movq (%r14), %rax
movq %r14, %rdi
callq *0x128(%rax)
cmpl $0x80, %eax
je 0x99e00
movq %rbx, %rdi
callq 0x55ef0
jmp 0x99e00
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/window.cpp
// Function: smooth::GUI::Window::GetWindow(void*)
S::GUI::Window *S::GUI::Window::GetWindow(Void *sysWindow)
{
	if (sysWindow == NIL) return NIL;

	for (Int i = 0; i < windows.Length(); i++)
	{
		Window		*window = windows.GetNth(i);

		if (window->GetSystemWindow() == sysWindow) return window;
	}

	return NIL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x99ea4
movq 0xd2846(%rip), %r15     # 0x16c6b0
cmpl $0x0, 0x8(%r15)
jle 0x99ea4
movq %rdi, %r14
xorl %ebp, %ebp
movq %r15, %rdi
movl %ebp, %esi
callq 0x5b0a4
movq (%rax), %r12
movq 0x5c0(%r12), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpq %r14, %rax
cmoveq %r12, %rbx
je 0x99ea4
incl %ebp
cmpl 0x8(%r15), %ebp
jl 0x99e76
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/../../../include/smooth/templates/signals/signalr.h
// Function: int smooth::SignalR3<int, int, int, int>::Disconnect<smooth::GUI::Window, smooth::GUI::Window>(int (smooth::GUI::Window::*)(int, int, int), smooth::GUI::Window*)
Int Disconnect(returnTYPE (classTYPE::*proc)(SIGNALS_ARGUMENT_TYPES), oClassTYPE *inst)
			{
				if (slotsN == NIL) return Error();

				SIGNALS_SLOT_CLASS_CLASS_NAME<classTYPE, returnTYPE SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES>	 slot(proc, inst);

				for (Int i = slotsN->Length() - 1; i >= 0; i--)
				{
					if ((*((SIGNALS_SLOT_BASE_CLASS_NAME<returnTYPE SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES> *) slotsN->GetNth(i))) == slot)
					{
						RemoveNthN(i);

						break;
					}
				}

				return Success();
			}

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x9a022
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0xcef11(%rip), %rdi     # 0x168ee8
movq %rsp, %r14
movq %rdi, (%r14)
movq %rsi, 0x10(%r14)
movq %rdx, 0x18(%r14)
movq %rcx, 0x8(%r14)
movl 0x8(%rax), %ebp
testl %ebp, %ebp
jle 0x9a017
decl %ebp
movq 0x10(%rbx), %rdi
movl %ebp, %esi
callq 0x5b0a4
movq (%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x20(%rax)
testb %al, %al
je 0x99fec
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9a1ba
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/../../../include/smooth/templates/signals/signalr.h
// Function: smooth::SignalR0<bool>::Connect(smooth::SignalR0<bool>*)
Int Connect(SIGNALS_SIGNAL_CLASS_NAME<returnTYPE SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES> *sig)
			{
				if ((Signal *) sig == (Signal *) this) return Error();

				if (slotsN == NIL)
				{
					slotsN = new Array<Void *>();
					slotsN->EnableLocking();
				}

				slotsN->Add(new SIGNALS_SLOT_SIGNAL_CLASS_NAME<returnTYPE SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES>(sig));

				return Success();
			}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq %rdi, %rsi
je 0x9a595
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
jne 0x9a565
movl $0x58, %edi
callq 0x556b0
movq %rax, %r15
movq %rax, %rdi
callq 0x55d90
leaq 0xc629d(%rip), %rax     # 0x1607e0
movq %rax, 0x40(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r15)
leaq 0xc63aa(%rip), %rax     # 0x160900
movq %rax, (%r15)
movq %r15, 0x10(%r14)
movq %r15, %rdi
callq 0x571b0
movq 0x10(%r14), %r14
movl $0x10, %edi
callq 0x556b0
leaq 0xcea1e(%rip), %rcx     # 0x168f98
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x5af08
xorl %eax, %eax
jmp 0x9a59a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x58, %esi
movq %r15, %rdi
callq 0x55480
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/gui/window/backends/windowbackend.cpp
// Function: smooth::GUI::WindowBackend::WindowBackend(void*)
S::GUI::WindowBackend::WindowBackend(Void *iWindow)
{
#if defined __WIN32__ && defined SMOOTH_STATIC
	volatile Bool	 null = 0;

	if (null) WindowGDI();
#endif

	type = WINDOW_NONE;

	drawSurface = NIL;

	doClose.Connect(True);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0xce6eb(%rip), %rax     # 0x169098
movq %rax, (%rdi)
leaq 0x30(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
xorl %eax, %eax
movq %rax, 0x48(%rdi)
movups %xmm0, 0x18(%rdi)
movq %rax, 0x28(%rdi)
leaq 0xce3b0(%rip), %rcx     # 0x168d80
movq %rcx, 0x30(%rdi)
leaq 0x58(%rdi), %rcx
movq %rcx, 0x10(%rsp)
movups %xmm0, 0x60(%rdi)
movq %rax, 0x70(%rdi)
leaq 0xce404(%rip), %rcx     # 0x168df0
movq %rcx, 0x58(%rdi)
leaq 0x80(%rdi), %r15
leaq 0xc7c6a(%rip), %rcx     # 0x162668
movq %rax, 0x88(%rdi)
leaq 0xc7d3c(%rip), %rdx     # 0x162748
movq %rdx, 0x80(%rdi)
movups %xmm0, 0x90(%rdi)
leaq 0xa0(%rdi), %r12
movq %rax, 0xa8(%rdi)
movq %rdx, 0xa0(%rdi)
movups %xmm0, 0xb0(%rdi)
leaq 0xc0(%rdi), %r13
movq %rcx, 0xc0(%rdi)
movq %rax, 0xc8(%rdi)
movq %rdx, 0xc0(%rdi)
movups %xmm0, 0xd0(%rdi)
leaq 0xe0(%rdi), %rbp
movq %rcx, 0xe0(%rdi)
movq %rax, 0xe8(%rdi)
movq %rdx, 0xe0(%rdi)
movups %xmm0, 0xf0(%rdi)
leaq 0x100(%rdi), %r14
movq %rax, 0x108(%rdi)
movq %rdx, 0x100(%rdi)
movups %xmm0, 0x110(%rdi)
movw $0x0, 0x8(%rdi)
movq %rax, 0x10(%rdi)
movq %rbx, %rdi
callq 0x6b418
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9a6b4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x8(%rsp)
movq %r14, %rdi
callq 0x703d2
movq %rbp, %rdi
callq 0x703d2
movq %r13, %rdi
callq 0x703d2
movq %r12, %rdi
callq 0x703d2
movq %r15, %rdi
callq 0x703d2
movq 0x10(%rsp), %rdi
callq 0x99f6e
movq %rbx, %rdi
callq 0x99f88
movq 0x8(%rsp), %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/i18n/language.cpp
// Function: smooth::I18n::Language::Parse(smooth::XML::Node*)
S::Errors::Error S::I18n::Language::Parse(XML::Node *language)
{
	if (language == NIL) return Error();

	XML::Node	*data = language->GetNodeByName("data");

	/* Return an error if we didn't find a data node.
	 */
	if (data == NIL) return Error();

	return Section::Parse(data);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testq %rdx, %rdx
je 0x9b0f8
movq %rdx, %r15
movq %rsi, %r14
leaq 0x5d097(%rip), %rsi     # 0xf8159
movq %rsp, %r12
movq %r12, %rdi
callq 0x579f0
movq %r15, %rdi
movq %r12, %rsi
callq 0x56810
movq %rax, %r15
movq %rsp, %rdi
callq 0x59200
testq %r15, %r15
je 0x9b0f8
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x55800
jmp 0x9b10d
movq 0xd15c9(%rip), %rax     # 0x16c6c8
addq $0x10, %rax
movq %rax, (%rbx)
movl $0xffffffff, 0x8(%rbx)  # imm = 0xFFFFFFFF
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/i18n/section.cpp
// Function: smooth::I18n::Section::GetString(smooth::String const&) const
const S::String &S::I18n::Section::GetString(const String &string) const
{
	if (contextSection != NIL)
	{
		const String	&result = contextSection->GetString(string);

		if (result != NIL) return result;
	}

	return strings.Get(string.ComputeCRC32());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x9b56a
movq %r14, %rsi
callq 0x562e0
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
callq 0x56bd0
testb %al, %al
je 0x9b56a
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
addq $0x40, %rbx
movq %r14, %rdi
callq 0x55640
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x9bb08
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/i18n/section.cpp
// Function: smooth::I18n::Section::SetContext(smooth::String const&)
S::Bool S::I18n::Section::SetContext(const String &nContext)
{
	context		= nContext;
	contextSection	= NIL;

	if (context != NIL)
	{
		Int	 index = context.Find("::");

		String	 contextFirst = context;
		String	 contextRest;

		if (index >= 0)
		{
			contextFirst = context.Head(index);
			contextRest = context.Tail(context.Length() - index - 2);
		}

		foreach (Section *section, sections)
		{
			if (section->GetName() == contextFirst)
			{
				section->SetContext(contextRest);

				contextSection = section;

				return True;
			}
		}

		return False;
	}

	return True;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r15
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x555f0
movq $0x0, 0x38(%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x56bd0
movb $0x1, %r13b
testb %al, %al
je 0x9b715
leaq 0x58b1f(%rip), %rsi     # 0xf40e6
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x579f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x57610
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
callq 0x59200
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x570b0
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x58e20
testl %ebp, %ebp
js 0x9b665
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x58b00
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x555f0
leaq 0x8(%rsp), %rdi
callq 0x59200
movq %r14, %rdi
callq 0x57180
subl %ebp, %eax
addl $-0x2, %eax
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x57f90
leaq 0x40(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x555f0
leaq 0x8(%rsp), %rdi
callq 0x59200
cmpl $0x0, 0xa0(%r15)
jle 0x9b6fe
movq %r15, (%rsp)
leaq 0x98(%r15), %rax
movq %rax, 0x38(%rsp)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x20(%rsp), %r15
incl %ebp
movq 0x38(%rsp), %rdi
movl %ebp, %esi
callq 0x60a40
movq (%rax), %r12
leaq 0x8(%r12), %rbx
movb $0x1, %cl
xorl %edx, %edx
movl %edx, %r14d
testb $0x1, %cl
je 0x9b6e8
movl %ecx, %r13d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x55900
movb $0x1, %dl
xorl %ecx, %ecx
testb %al, %al
je 0x9b6a7
movq %r12, %rdi
leaq 0x40(%rsp), %rsi
callq 0x56140
movq (%rsp), %rax
movq %r12, 0x38(%rax)
notb %r14b
orb %r13b, %r14b
testb $0x1, %r14b
je 0x9b6f2
jmp 0x9b701
testb $0x1, %r14b
movq (%rsp), %rax
je 0x9b6fe
movl 0xa0(%rax), %eax
decl %eax
cmpl %eax, %ebp
jl 0x9b68d
xorl %r13d, %r13d
leaq 0x40(%rsp), %rdi
callq 0x59200
leaq 0x20(%rsp), %rdi
callq 0x59200
andb $0x1, %r13b
movl %r13d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9b72d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
jmp 0x9b74c
jmp 0x9b749
jmp 0x9b740
movq %rax, %rbx
jmp 0x9b756
jmp 0x9b749
jmp 0x9b749
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x59200
leaq 0x20(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/i18n/translator.cpp
// Function: smooth::I18n::Translator::Translator(smooth::String const&)
S::I18n::Translator::Translator(const String &iAppPrefix)
{
	appPrefix      = iAppPrefix.ToLower();
	activeLanguage = NIL;

	GetSupportedLanguages();

	ActivateLanguage("internal");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r15
movq 0xd0e80(%rip), %rax     # 0x16c9f8
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58e20
leaq 0x20(%r15), %r14
movq %r14, %rdi
callq 0x55d90
leaq 0xc4c40(%rip), %rax     # 0x1607e0
movq %rax, 0x60(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%r15)
leaq 0xcd6c5(%rip), %rax     # 0x169278
movq %rax, 0x20(%r15)
movq %rsp, %rdi
movq %r12, %rsi
callq 0x58090
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x555f0
movq %rsp, %rdi
callq 0x59200
movq $0x0, 0x78(%r15)
movq %r15, %rdi
callq 0x55500
leaq 0x5c5e2(%rip), %rsi     # 0xf81ce
movq %rsp, %rdi
callq 0x579f0
movq (%r15), %rax
movq %rsp, %rsi
movq %r15, %rdi
callq *0x10(%rax)
movq %rsp, %rdi
callq 0x59200
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x9bc1a
jmp 0x9bc27
jmp 0x9bc27
movq %rax, %r15
movq %rsp, %rdi
callq 0x59200
jmp 0x9bc2a
movq %rax, %r15
movq %r14, %rdi
callq 0x5b11e
movq %rbx, %rdi
callq 0x59200
movq %r15, %rdi
callq 0x57090
movq %rax, %r15
jmp 0x9bc32
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/i18n/translator.cpp
// Function: smooth::I18n::Translator::SetInternalLanguageInfo(smooth::String const&, smooth::String const&, smooth::String const&, bool)
S::Int S::I18n::Translator::SetInternalLanguageInfo(const String &langName, const String &author, const String &url, Bool rightToLeft)
{
	Language	*iLang = NIL;

	for (Int n = 0; n < languages.Length(); n++)
	{
		if (languages.GetNth(n)->magic == "internal")
		{
			iLang = languages.GetNth(n);

			languages.Remove(languages.GetNthIndex(n));

			break;
		}
	}

	if (iLang != NIL)
	{
		iLang->SetName(langName);

		iLang->author	   = author;
		iLang->url	   = url;
		iLang->rightToLeft = rightToLeft;

		AddLanguage(iLang);
	}

	return Success();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movq %rcx, %r15
movq %rdx, %r13
movq %rdi, %r14
xorl %r12d, %r12d
cmpl $0x0, 0x28(%rdi)
jle 0x9c0df
movq %rsi, 0x10(%rsp)
movq %r13, 0x18(%rsp)
movq %r15, 0x20(%rsp)
movl %ebx, 0xc(%rsp)
leaq 0x20(%r14), %rbx
movl $0x108, %ebp            # imm = 0x108
leaq 0x5c150(%rip), %r13     # 0xf81ce
xorl %r15d, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5b0a4
movq (%rax), %rdi
addq %rbp, %rdi
movq %r13, %rsi
callq 0x57ef0
testb %al, %al
jne 0x9c0a9
incl %r15d
cmpl 0x28(%r14), %r15d
jl 0x9c081
jmp 0x9c0cc
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5b0a4
movq (%rax), %r12
movq %rbx, %rdi
movl %r15d, %esi
callq 0x570f0
movq %rbx, %rdi
movl %eax, %esi
callq 0x58bb0
movl 0xc(%rsp), %ebx
movq 0x20(%rsp), %r15
movq 0x18(%rsp), %r13
movq 0x10(%rsp), %rsi
testq %r12, %r12
je 0x9c121
leaq 0x8(%r12), %rdi
callq 0x555f0
leaq 0x120(%r12), %rdi
movq %r13, %rsi
callq 0x555f0
leaq 0x138(%r12), %rdi
movq %r15, %rsi
callq 0x555f0
movb %bl, 0x150(%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0x55b30
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq