LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/window/backends/xlib/windowxlib.cpp
// Function: smooth::GUI::WindowXLib::Close()
S::Int S::GUI::WindowXLib::Close()
{
	if (wnd == None) return Success();

	/* Delete surface.
	 */
	if (drawSurface != NIL) delete drawSurface;

	drawSurface = NIL;

	/* Destroy input context.
	 */
	DestroyInputContext();

	/* Destroy input window.
	 */
	if (iwnd != None)
	{
		XDestroyWindow(display, iwnd);

		iwnd = None;
	}

	/* Destroy window.
	 */
	XDestroyWindow(display, wnd);

	oldwnd	= wnd;
	wnd	= None;

	return Success();
}

// Assembly:
cmpq $0x0, 0x138(%rdi)
je 0xc107b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r14
testq %r14, %r14
je 0xc1015
movq %r14, %rdi
callq 0x57b20
movl $0x8, %esi
movq %r14, %rdi
callq 0x55480
movq $0x0, 0x10(%rbx)
movq %rbx, %rdi
callq 0xc107e
movq 0x150(%rbx), %rsi
testq %rsi, %rsi
je 0xc1048
movq 0x120(%rbx), %rdi
callq 0x56ee0
movq $0x0, 0x150(%rbx)
movq 0x120(%rbx), %rdi
movq 0x138(%rbx), %rsi
callq 0x56ee0
movq 0x138(%rbx), %rax
movq %rax, 0x140(%rbx)
movq $0x0, 0x138(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/window/backends/xlib/windowxlib.cpp
// Function: smooth::GUI::WindowXLib::DestroyInputContext()
S::Void S::GUI::WindowXLib::DestroyInputContext()
{
	if (ic == NIL) return;

	XLockDisplay(display);

	/* Reset event mask.
	 */
	XSelectInput(display, iwnd, 0);

	/* Clear input context.
	 */
	char *string = Xutf8ResetIC(ic);

	if (string != NIL) XFree(string);

	/* Destroy input context.
	 */
	XDestroyIC(ic);

	ic = NIL;

	XUnlockDisplay(display);
}

// Assembly:
cmpq $0x0, 0x148(%rdi)
je 0xc10ea
pushq %rbx
movq %rdi, %rbx
movq 0x120(%rdi), %rdi
callq 0x58ec0
movq 0x120(%rbx), %rdi
movq 0x150(%rbx), %rsi
xorl %edx, %edx
callq 0x58600
movq 0x148(%rbx), %rdi
callq 0x58880
testq %rax, %rax
je 0xc10c6
movq %rax, %rdi
callq 0x57e80
movq 0x148(%rbx), %rdi
callq 0x58d80
movq $0x0, 0x148(%rbx)
movq 0x120(%rbx), %rdi
popq %rbx
jmp 0x56760
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/window/backends/xlib/windowxlib.cpp
// Function: smooth::GUI::WindowXLib::SetTitle(smooth::String const&)
S::Int S::GUI::WindowXLib::SetTitle(const String &nTitle)
{
	if (wnd == None) return Error();

	static Atom	 wmNameAtom	= XInternAtom(display, "_NET_WM_NAME", False);
	static Atom	 wmIconNameAtom = XInternAtom(display, "_NET_WM_ICON_NAME", False);

	XTextProperty	 titleProp;
	XTextProperty	 titlePropUTF8;

	const char	*title	   = nTitle.ConvertTo("ISO-8859-1");
	const char	*titleUTF8 = nTitle.ConvertTo("UTF-8");

	/* Set ISO encoded window name.
	 */
	if (XStringListToTextProperty((char **) &title, 1, &titleProp) != 0)
	{
		XSetWMName(display, wnd, &titleProp);
		XSetWMIconName(display, wnd, &titleProp);

		XFree(titleProp.value);
	}

	/* Set UTF-8 encoded window name.
	 */
	if (Xutf8TextListToTextProperty(display, (char **) &titleUTF8, 1, XUTF8StringStyle, &titlePropUTF8) == 0)
	{
		XSetTextProperty(display, wnd, &titlePropUTF8, wmNameAtom);
		XSetTextProperty(display, wnd, &titlePropUTF8, wmIconNameAtom);

		XFree(titlePropUTF8.value);
	}

	return Success();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
cmpq $0x0, 0x138(%rdi)
je 0xc122b
movq %rsi, %r14
movq %rdi, %rbx
movb 0xb5d29(%rip), %al      # 0x176e58
testb %al, %al
je 0xc123a
movb 0xb5d2b(%rip), %al      # 0x176e68
testb %al, %al
je 0xc127e
leaq 0x50af5(%rip), %rsi     # 0x111c41
movq %r14, %rdi
callq 0x57940
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
leaq 0x51173(%rip), %rsi     # 0x1122d6
movq %r14, %rdi
callq 0x57940
movq %rax, (%rsp)
leaq 0x30(%rsp), %rdx
movq %r15, %rdi
movl $0x1, %esi
callq 0x56e40
testl %eax, %eax
je 0xc11be
movq 0x120(%rbx), %rdi
movq 0x138(%rbx), %rsi
leaq 0x30(%rsp), %r14
movq %r14, %rdx
callq 0x55780
movq 0x120(%rbx), %rdi
movq 0x138(%rbx), %rsi
movq %r14, %rdx
callq 0x56c60
movq (%r14), %rdi
callq 0x57e80
movq 0x120(%rbx), %rdi
movq %rsp, %rsi
leaq 0x10(%rsp), %r8
movl $0x1, %edx
movl $0x4, %ecx
callq 0x57c10
testl %eax, %eax
jne 0xc1227
movq 0x120(%rbx), %rdi
movq 0x138(%rbx), %rsi
movq 0xb5c5b(%rip), %rcx     # 0x176e50
leaq 0x10(%rsp), %r14
movq %r14, %rdx
callq 0x55430
movq 0x120(%rbx), %rdi
movq 0x138(%rbx), %rsi
movq 0xb5c49(%rip), %rcx     # 0x176e60
movq %r14, %rdx
callq 0x55430
movq (%r14), %rdi
callq 0x57e80
xorl %eax, %eax
jmp 0xc1230
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb5c17(%rip), %r15     # 0x176e58
movq %r15, %rdi
callq 0x56120
testl %eax, %eax
je 0xc1137
movq 0x120(%rbx), %rdi
leaq 0x52183(%rip), %rsi     # 0x1133e2
xorl %edx, %edx
callq 0x57ea0
movq %rax, 0xb5be3(%rip)     # 0x176e50
leaq 0xb5be4(%rip), %rdi     # 0x176e58
callq 0x56b80
jmp 0xc1137
leaq 0xb5be3(%rip), %r15     # 0x176e68
movq %r15, %rdi
callq 0x56120
testl %eax, %eax
je 0xc1145
movq 0x120(%rbx), %rdi
leaq 0x5214c(%rip), %rsi     # 0x1133ef
xorl %edx, %edx
callq 0x57ea0
movq %rax, 0xb5baf(%rip)     # 0x176e60
leaq 0xb5bb0(%rip), %rdi     # 0x176e68
callq 0x56b80
jmp 0xc1145
jmp 0xc12c4
movq %rax, %rbx
movq %r15, %rdi
callq 0x56420
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/window/backends/xlib/windowxlib.cpp
// Function: smooth::GUI::WindowXLib::EnableDropFiles(bool)
S::Int S::GUI::WindowXLib::EnableDropFiles(Bool nEnableDropFiles)
{
	enableDropFiles = nEnableDropFiles;

	if (wnd == None) return Success();

	static Atom	 xdndAwareAtom = XInternAtom(display, "XdndAware", False);

	Int32	 xdndVersion = 5;

	if (enableDropFiles) XChangeProperty(display, wnd, xdndAwareAtom, XA_ATOM, 32, PropModeReplace, (unsigned char *) &xdndVersion, 1);
	else		     XDeleteProperty(display, wnd, xdndAwareAtom);

	return Success();
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movb %sil, 0x171(%rdi)
cmpq $0x0, 0x138(%rdi)
je 0xc14f1
movq %rdi, %rbx
movb 0xb59d7(%rip), %al      # 0x176e78
testb %al, %al
je 0xc14f9
movl $0x5, 0xc(%rsp)
movq 0x120(%rbx), %rdi
movq 0x138(%rbx), %rsi
movq 0xb59ae(%rip), %rdx     # 0x176e70
cmpb $0x1, 0x171(%rbx)
jne 0xc14ec
leaq 0xc(%rsp), %rax
movl $0x4, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq $0x1
pushq %rax
callq 0x57730
addq $0x10, %rsp
jmp 0xc14f1
callq 0x585b0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0xb5978(%rip), %rdi     # 0x176e78
callq 0x56120
testl %eax, %eax
je 0xc14a5
movq 0x120(%rbx), %rdi
leaq 0x51eea(%rip), %rsi     # 0x113401
xorl %edx, %edx
callq 0x57ea0
movq %rax, 0xb594b(%rip)     # 0x176e70
leaq 0xb594c(%rip), %rdi     # 0x176e78
callq 0x56b80
jmp 0xc14a5
movq %rax, %rbx
leaq 0xb5938(%rip), %rdi     # 0x176e78
callq 0x56420
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/window/backends/xlib/windowxlib.cpp
// Function: smooth::GUI::WindowXLib::SetMinimumSize(smooth::GUI::Size const&)
S::Int S::GUI::WindowXLib::SetMinimumSize(const Size &nMinSize)
{
	minSize = nMinSize;

	UpdateWMNormalHints();

	if (wnd != None)
	{
		XResizeWindow(display, wnd, Math::Round(Math::Max(size.cx, minSize.cx) * fontSize) + sizeModifier.cx,
					    Math::Round(Math::Max(size.cy, minSize.cy) * fontSize) + sizeModifier.cy);
		XFlush(display);
	}

	return Success();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, 0x190(%rdi)
callq 0xbe9aa
movq 0x138(%rbx), %rsi
testq %rsi, %rsi
je 0xc1af2
movupd 0x178(%rbx), %xmm0
movq 0x188(%rbx), %xmm1
movq 0x190(%rbx), %xmm2
movdqa %xmm1, %xmm3
pcmpgtd %xmm2, %xmm3
pand %xmm3, %xmm1
pandn %xmm2, %xmm3
por %xmm1, %xmm3
cvtdq2pd %xmm3, %xmm1
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm1, %xmm0
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm2
cmpltpd %xmm1, %xmm2
movmskpd %xmm2, %eax
movsd 0x318ee(%rip), %xmm1    # 0xf3390
movsd 0x318ee(%rip), %xmm2    # 0xf3398
movapd %xmm1, %xmm3
testb $0x1, %al
jne 0xc1ab6
movapd %xmm2, %xmm3
addsd %xmm0, %xmm3
cvttsd2si %xmm3, %rdx
movq 0x120(%rbx), %rdi
addl 0x18(%rbx), %edx
testb $0x2, %al
jne 0xc1ad1
movapd %xmm2, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
addl 0x1c(%rbx), %ecx
callq 0x58940
movq 0x120(%rbx), %rdi
callq 0x55e10
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/window/backends/xlib/windowxlib.cpp
// Function: smooth::GUI::WindowXLib::SetMaximumSize(smooth::GUI::Size const&)
S::Int S::GUI::WindowXLib::SetMaximumSize(const Size &nMaxSize)
{
	maxSize = nMaxSize;

	UpdateWMNormalHints();

	if (wnd != None)
	{
		XResizeWindow(display, wnd, Math::Round(Math::Min(size.cx, maxSize.cx) * fontSize) + sizeModifier.cx,
					    Math::Round(Math::Min(size.cy, maxSize.cy) * fontSize) + sizeModifier.cy);
		XFlush(display);
	}

	return Success();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, 0x198(%rdi)
callq 0xbe9aa
movq 0x138(%rbx), %rsi
testq %rsi, %rsi
je 0xc1bba
movupd 0x178(%rbx), %xmm0
movq 0x188(%rbx), %xmm1
movq 0x198(%rbx), %xmm2
movdqa %xmm2, %xmm3
pcmpgtd %xmm1, %xmm3
pand %xmm3, %xmm1
pandn %xmm2, %xmm3
por %xmm1, %xmm3
cvtdq2pd %xmm3, %xmm1
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm1, %xmm0
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm2
cmpltpd %xmm1, %xmm2
movmskpd %xmm2, %eax
movsd 0x31826(%rip), %xmm1    # 0xf3390
movsd 0x31826(%rip), %xmm2    # 0xf3398
movapd %xmm1, %xmm3
testb $0x1, %al
jne 0xc1b7e
movapd %xmm2, %xmm3
addsd %xmm0, %xmm3
cvttsd2si %xmm3, %rdx
movq 0x120(%rbx), %rdi
addl 0x18(%rbx), %edx
testb $0x2, %al
jne 0xc1b99
movapd %xmm2, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
addl 0x1c(%rbx), %ecx
callq 0x58940
movq 0x120(%rbx), %rdi
callq 0x55e10
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/window/backends/xlib/windowxlib.cpp
// Function: smooth::GUI::WindowXLib::SetMetrics(smooth::GUI::Point const&, smooth::GUI::Size const&)
S::Int S::GUI::WindowXLib::SetMetrics(const Point &nPos, const Size &nSize)
{
	if (wnd == None) return Success();

	XMoveResizeWindow(display, wnd, nPos.x, nPos.y, Math::Round(nSize.cx * fontSize) + sizeModifier.cx, Math::Round(nSize.cy * fontSize) + sizeModifier.cy);
	XFlush(display);

	return Success();
}

// Assembly:
movq %rsi, %rax
movq 0x138(%rdi), %rsi
testq %rsi, %rsi
je 0xc1cb7
pushq %rbx
movq %rdi, %rbx
cvtdq2pd (%rdx), %xmm1
movupd 0x178(%rdi), %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm1, %xmm0
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm2
cmpltpd %xmm1, %xmm2
movmskpd %xmm2, %r9d
movsd 0x31735(%rip), %xmm1    # 0xf3390
movsd 0x31735(%rip), %xmm2    # 0xf3398
movapd %xmm1, %xmm3
testb $0x1, %r9b
jne 0xc1c71
movapd %xmm2, %xmm3
movq 0x120(%rbx), %rdi
movl (%rax), %edx
addsd %xmm0, %xmm3
cvttsd2si %xmm3, %r8
movl 0x4(%rax), %ecx
addl 0x18(%rbx), %r8d
testb $0x2, %r9b
jne 0xc1c94
movapd %xmm2, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %r9
addl 0x1c(%rbx), %r9d
callq 0x56f60
movq 0x120(%rbx), %rdi
callq 0x55e10
popq %rbx
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/window/backends/xlib/windowxlib.cpp
// Function: smooth::GUI::WindowXLib::Maximize()
S::Int S::GUI::WindowXLib::Maximize()
{
	if (wnd == None) return Success();

	static Atom	 wmStateAtom		  = XInternAtom(display, "_NET_WM_STATE", False);
	static Atom	 wmStateMaximizedHorzAtom = XInternAtom(display, "_NET_WM_STATE_MAXIMIZED_HORZ", False);
	static Atom	 wmStateMaximizedVertAtom = XInternAtom(display, "_NET_WM_STATE_MAXIMIZED_VERT", False);

	static Atom	 wmStateMaximizedAtoms[2] = { wmStateMaximizedHorzAtom, wmStateMaximizedVertAtom };

	if (!maximized)
	{
		XChangeProperty(display, wnd, wmStateAtom, XA_ATOM, 32, PropModeAppend, (unsigned char *) wmStateMaximizedAtoms, 2);
		XFlush(display);
	}

	return Success();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x138(%rdi)
je 0xc1d55
movq %rdi, %rbx
movb 0xb5233(%rip), %al      # 0x176f08
testb %al, %al
je 0xc1d5f
movb 0xb5235(%rip), %al      # 0x176f18
testb %al, %al
je 0xc1da3
movb 0xb5237(%rip), %al      # 0x176f28
testb %al, %al
je 0xc1de7
movb 0xb5241(%rip), %al      # 0x176f40
testb %al, %al
je 0xc1e2b
cmpb $0x0, 0x1a0(%rbx)
jne 0xc1d55
movq 0x120(%rbx), %rdi
movq 0x138(%rbx), %rsi
movq 0xb51db(%rip), %rdx     # 0x176f00
leaq 0xb5204(%rip), %rax     # 0x176f30
movl $0x4, %ecx
movl $0x20, %r8d
movl $0x2, %r9d
pushq $0x2
pushq %rax
callq 0x57730
addq $0x10, %rsp
movq 0x120(%rbx), %rdi
callq 0x55e10
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xb51a2(%rip), %r14     # 0x176f08
movq %r14, %rdi
callq 0x56120
testl %eax, %eax
je 0xc1cdd
movq 0x120(%rbx), %rdi
leaq 0x51515(%rip), %rsi     # 0x113299
xorl %edx, %edx
callq 0x57ea0
movq %rax, 0xb516e(%rip)     # 0x176f00
leaq 0xb516f(%rip), %rdi     # 0x176f08
callq 0x56b80
jmp 0xc1cdd
leaq 0xb516e(%rip), %r14     # 0x176f18
movq %r14, %rdi
callq 0x56120
testl %eax, %eax
je 0xc1ceb
movq 0x120(%rbx), %rdi
leaq 0x514df(%rip), %rsi     # 0x1132a7
xorl %edx, %edx
callq 0x57ea0
movq %rax, 0xb513a(%rip)     # 0x176f10
leaq 0xb513b(%rip), %rdi     # 0x176f18
callq 0x56b80
jmp 0xc1ceb
leaq 0xb513a(%rip), %r14     # 0x176f28
movq %r14, %rdi
callq 0x56120
testl %eax, %eax
je 0xc1cf9
movq 0x120(%rbx), %rdi
leaq 0x514b8(%rip), %rsi     # 0x1132c4
xorl %edx, %edx
callq 0x57ea0
movq %rax, 0xb5106(%rip)     # 0x176f20
leaq 0xb5107(%rip), %rdi     # 0x176f28
callq 0x56b80
jmp 0xc1cf9
callq 0x5926c
jmp 0xc1d07
jmp 0xc1e39
jmp 0xc1e39
movq %rax, %rbx
movq %r14, %rdi
callq 0x56420
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/window/backends/xlib/../../../../../include/smooth/templates/signals/signal.h
// Function: int smooth::Signal2<void, smooth::GUI::Cursor*, smooth::GUI::Point const&>::Disconnect<void>(void (*)(smooth::GUI::Cursor*, smooth::GUI::Point const&))
Int Disconnect(slotReturnTYPE (*proc)(SIGNALS_ARGUMENT_TYPES))
			{
				if (slotsN == NIL) return Error();

				SIGNALS_SLOT_GLOBAL_CLASS_NAME<slotReturnTYPE SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES>	 slot(proc);

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

						break;
					}
				}

				return Success();
			}

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xc254a
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xa7671(%rip), %rcx     # 0x169b78
movq %rsp, %r14
movq %rcx, (%r14)
movq %rsi, 0x8(%r14)
movl 0x8(%rax), %ebp
testl %ebp, %ebp
jle 0xc253f
decl %ebp
movq 0x10(%rbx), %rdi
movl %ebp, %esi
callq 0x5b074
movq (%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x20(%rax)
testb %al, %al
je 0xc2514
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9513a
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/system/backends/xlib/eventxlib.cpp
// Function: smooth::System::EventXLib::EventXLib()
S::System::EventXLib::EventXLib()
{
	type = EVENT_XLIB;

	display	= Backends::BackendXLib::GetDisplay();

	/* Deny timer interrupts outside of any event loops
	 * to prevent interruption of sensitive code.
	 */
	if (!nested++) EventProcessor::denyTimerInterrupts.Call();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xb2826
leaq 0xa7325(%rip), %rax     # 0x169c78
movq %rax, (%rbx)
movw $0x2, 0x8(%rbx)
callq 0xbcfc0
movq %rax, 0x10(%rbx)
movl 0xb4629(%rip), %eax     # 0x176f94
leal 0x1(%rax), %ecx
movl %ecx, 0xb4620(%rip)     # 0x176f94
testl %eax, %eax
jne 0xc2984
movq 0xa92e9(%rip), %rdi     # 0x16bc68
callq 0xc2b38
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xb2838
movq %r14, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/system/backends/xlib/eventxlib.cpp
// Function: smooth::System::EventXLib::ProcessNextEvent()
S::Bool S::System::EventXLib::ProcessNextEvent()
{
	if (display == NIL) return False;

	/* Process events on main thread only.
	 */
	if (Threads::Thread::GetCurrentThreadID() != Threads::MainThreadID)
	{
		S::System::System::Sleep(1);

		return True;
	}

	/* Emulate a timeout of ~100ms by trying to find a message
	 * 10 times while sleeping for 10ms between trying.
	 */
	for (Int i = 0; i < 10; i++)
	{
		/* XEventsQueued with QueuedAfterFlush sometimes hanged,
		 * so we flush manually and use QueuedAfterReading then.
		 */
		XFlush(display);

		if (XEventsQueued(display, QueuedAfterReading))
		{
			XEvent		 e;

			XNextEvent(display, &e);

			if (XFilterEvent(&e, None)) break;

			/* Process only the most recent MotionNotify and ConfigureNotify events.
			 */
			if (e.type == MotionNotify)    while (XCheckIfEvent(display, &e, FindMotionEvent,    (XPointer) e.xany.window)) { }
			if (e.type == ConfigureNotify) while (XCheckIfEvent(display, &e, FindConfigureEvent, (XPointer) e.xany.window)) { }

			/* Find window and dispatch event.
			 */
			GUI::WindowXLib	*window = GUI::WindowXLib::GetWindowBackend(e.xany.window);

			if (window != NIL) window->ProcessSystemMessages(&e);

			break;
		}

		/* Allow timeouts to be processed.
		 */
		EventProcessor::allowTimerInterrupts.Call();

		/* Now sleep for 10ms.
		 */
		System::System::Sleep(10);

		/* Prevent timeouts from being processed.
		 */
		EventProcessor::denyTimerInterrupts.Call();
	}

	return True;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq 0x10(%rdi), %r12
testq %r12, %r12
je 0xc2b21
movq %rdi, %rbx
callq 0x55300
testl %eax, %eax
je 0xc2a45
movl $0x1, %edi
callq 0x578c0
jmp 0xc2b21
movl $0xa, %ebp
movq 0xa911f(%rip), %r14     # 0x16bb70
movq 0xa9210(%rip), %r15     # 0x16bc68
movq 0x10(%rbx), %rdi
callq 0x55e10
movq 0x10(%rbx), %rdi
movl $0x1, %esi
callq 0x55c00
testl %eax, %eax
jne 0xc2a96
movq %r14, %rdi
callq 0xc2b38
movl $0xa, %edi
callq 0x578c0
movq %r15, %rdi
callq 0xc2b38
decl %ebp
jne 0xc2a58
jmp 0xc2b21
movq 0x10(%rbx), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0x57ee0
movq %r14, %rdi
xorl %esi, %esi
callq 0x55080
testl %eax, %eax
jne 0xc2b21
movl (%rsp), %eax
cmpl $0x6, %eax
jne 0xc2ae0
leaq -0xd7(%rip), %r14       # 0xc29eb
movq %rsp, %r15
movq 0x10(%rbx), %rdi
movq 0x20(%rsp), %rcx
movq %r15, %rsi
movq %r14, %rdx
callq 0x56c40
testl %eax, %eax
jne 0xc2ac5
movl (%rsp), %eax
cmpl $0x16, %eax
jne 0xc2b07
leaq -0xf0(%rip), %r14       # 0xc29fc
movq %rsp, %r15
movq 0x10(%rbx), %rdi
movq 0x20(%rsp), %rcx
movq %r15, %rsi
movq %r14, %rdx
callq 0x56c40
testl %eax, %eax
jne 0xc2aef
movq 0x20(%rsp), %rdi
callq 0xbeb56
testq %rax, %rax
je 0xc2b21
movq %rsp, %rsi
movq %rax, %rdi
callq 0xbedc2
testq %r12, %r12
setne %al
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/system/backends/xlib/screenxlib.cpp
// Function: smooth::System::ScreenXLib::Initialize()
S::Int S::System::ScreenXLib::Initialize()
{
	libXrandr = dlopen("libXrandr.so", RTLD_NOW | RTLD_LOCAL);

	if (libXrandr != NIL)
	{
		XRRGetMonitors	= (xrrgetmonitors_t) dlsym(libXrandr, "XRRGetMonitors");
		XRRFreeMonitors	= (xrrfreemonitors_t) dlsym(libXrandr, "XRRFreeMonitors");
	}

	return Success();
}

// Assembly:
pushq %rax
leaq 0x509ac(%rip), %rdi     # 0x1135e0
movl $0x2, %esi
callq 0x57cf0
movq %rax, 0xb4373(%rip)     # 0x176fb8
testq %rax, %rax
je 0xc2c7a
leaq 0x5099c(%rip), %rsi     # 0x1135ed
movq %rax, %rdi
callq 0x557b0
movq %rax, 0xb4348(%rip)     # 0x176fa8
movq 0xb4351(%rip), %rdi     # 0x176fb8
leaq 0x5098e(%rip), %rsi     # 0x1135fc
callq 0x557b0
movq %rax, 0xb4336(%rip)     # 0x176fb0
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/system/backends/xlib/screenxlib.cpp
// Function: smooth::MonitorRectFromPoint(X11::_XDisplay*, smooth::GUI::Point const&)
GUI::Rect MonitorRectFromPoint(Display *display, const GUI::Point &point)
	{
		if (XRRGetMonitors == NIL) return GUI::Rect();

		GUI::Rect	 metrics;

		int		 monitorCount = 0;
		XRRMonitorInfo	*monitors     = XRRGetMonitors(display, DefaultRootWindow(display), True, &monitorCount);

		for (Int i = 0; i < monitorCount; i++)
		{
			if (point.x >= monitors[i].x			 &&
			    point.x <  monitors[i].x + monitors[i].width &&
			    point.y >= monitors[i].y			 &&
			    point.y <  monitors[i].y + monitors[i].height) metrics = GUI::Rect(GUI::Point(monitors[i].x, monitors[i].y), GUI::Size(monitors[i].width, monitors[i].height));
		}

		XRRFreeMonitors(monitors);

		return metrics;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0xb4301(%rip), %rax     # 0x176fa8
testq %rax, %rax
je 0xc2d51
movq %rsi, %r14
leaq 0xc(%rsp), %rbx
movl $0x0, (%rbx)
movq 0xe8(%rdi), %rcx
movslq 0xe0(%rdi), %rdx
shlq $0x7, %rdx
movq 0x10(%rcx,%rdx), %rsi
movl $0x1, %edx
movq %rbx, %rcx
callq *%rax
movslq (%rbx), %rsi
xorl %ebx, %ebx
testq %rsi, %rsi
jle 0xc2d58
movl (%r14), %ecx
movl 0x4(%r14), %edx
imulq $0x38, %rsi, %rsi
xorl %edi, %edi
xorl %r8d, %r8d
xorl %r14d, %r14d
movl 0x14(%rax,%rdi), %r9d
cmpl %r9d, %ecx
jl 0xc2d3d
movl 0x1c(%rax,%rdi), %r11d
addl %r9d, %r11d
cmpl %r11d, %ecx
jge 0xc2d3d
movl 0x18(%rax,%rdi), %r10d
cmpl %r10d, %edx
jl 0xc2d3d
movl 0x20(%rax,%rdi), %r15d
addl %r10d, %r15d
cmpl %r15d, %edx
jge 0xc2d3d
movl %r11d, %r8d
shlq $0x20, %r15
orq %r8, %r15
movq %r15, %r14
movl %r10d, %r8d
movl %r9d, %ebx
addq $0x38, %rdi
cmpq %rdi, %rsi
jne 0xc2cfc
shlq $0x20, %r8
movl %ebx, %ecx
movq %r8, %rbx
jmp 0xc2d5d
xorl %r14d, %r14d
xorl %ebx, %ebx
jmp 0xc2d69
xorl %r14d, %r14d
xorl %ecx, %ecx
orq %rcx, %rbx
movq %rax, %rdi
callq *0xb4247(%rip)          # 0x176fb0
movq %rbx, %rax
movq %r14, %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/system/backends/xlib/screenxlib.cpp
// Function: smooth::System::ScreenXLib::GetActiveScreenMetrics()
S::GUI::Rect S::System::ScreenXLib::GetActiveScreenMetrics()
{
	if (display == NIL) return GUI::Rect();

	if (XRRGetMonitors != NIL)
	{
		GUI::Rect	 metrics = MonitorRectFromPoint(display, Input::Pointer::GetPosition());

		if (metrics != GUI::Rect()) return metrics;
	}

	return GUI::Rect(GUI::Point(0, 0), GUI::Size(XWidthOfScreen(XDefaultScreenOfDisplay(display)), XHeightOfScreen(XDefaultScreenOfDisplay(display))));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
testq %r14, %r14
je 0xc2e4c
movq %rdi, %rbx
cmpq $0x0, 0xb41b8(%rip)     # 0x176fa8
je 0xc2e1c
callq 0x555d0
movq %r14, %rdi
movq %rax, %rsi
callq 0xc2c97
movq %rax, %rcx
shrq $0x20, %rcx
testl %eax, %eax
jne 0xc2e52
shrq $0x20, %rax
jne 0xc2e50
testq %rdx, %rdx
jne 0xc2e4e
movq 0x10(%rbx), %r14
movq %r14, %rdi
callq 0x57050
movq %rax, %rdi
callq 0x562c0
movl %eax, %ebp
movq 0x10(%rbx), %rdi
callq 0x57050
movq %rax, %rdi
callq 0x58370
movl %eax, %edx
movl %ebp, %eax
shlq $0x20, %rdx
orq %rax, %rdx
jmp 0xc2e4e
xorl %edx, %edx
xorl %ecx, %ecx
xorl %eax, %eax
shlq $0x20, %rcx
movl %eax, %eax
orq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/system/backends/xlib/screenxlib.cpp
// Function: smooth::System::ScreenXLib::GetActiveScreenWorkArea()
S::GUI::Rect S::System::ScreenXLib::GetActiveScreenWorkArea()
{
	if (display == NIL) return GUI::Rect();

	if (XRRGetMonitors != NIL)
	{
		GUI::Rect	 metrics = MonitorRectFromPoint(display, Input::Pointer::GetPosition());

		if (metrics != GUI::Rect()) return metrics;
	}

	return GUI::Rect(GUI::Point(0, 0), GUI::Size(XWidthOfScreen(XDefaultScreenOfDisplay(display)), XHeightOfScreen(XDefaultScreenOfDisplay(display))));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
testq %r14, %r14
je 0xc2ed4
movq %rdi, %rbx
cmpq $0x0, 0xb4130(%rip)     # 0x176fa8
je 0xc2ea4
callq 0x555d0
movq %r14, %rdi
movq %rax, %rsi
callq 0xc2c97
movq %rax, %rcx
shrq $0x20, %rcx
testl %eax, %eax
jne 0xc2eda
shrq $0x20, %rax
jne 0xc2ed8
testq %rdx, %rdx
jne 0xc2ed6
movq 0x10(%rbx), %r14
movq %r14, %rdi
callq 0x57050
movq %rax, %rdi
callq 0x562c0
movl %eax, %ebp
movq 0x10(%rbx), %rdi
callq 0x57050
movq %rax, %rdi
callq 0x58370
movl %eax, %edx
movl %ebp, %eax
shlq $0x20, %rdx
orq %rax, %rdx
jmp 0xc2ed6
xorl %edx, %edx
xorl %ecx, %ecx
xorl %eax, %eax
shlq $0x20, %rcx
movl %eax, %eax
orq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/system/backends/xlib/screenxlib.cpp
// Function: smooth::System::ScreenXLib::GetVirtualScreenMetrics()
S::GUI::Rect S::System::ScreenXLib::GetVirtualScreenMetrics()
{
	if (display == NIL) return GUI::Rect();

	if (XRRGetMonitors != NIL)
	{
		GUI::Rect	 metrics;

		int		 monitorCount = 0;
		XRRMonitorInfo	*monitors     = XRRGetMonitors(display, DefaultRootWindow(display), True, &monitorCount);

		for (Int i = 0; i < monitorCount; i++)
		{
			metrics.left   = Math::Min(metrics.left, monitors[i].x);
			metrics.top    = Math::Min(metrics.top, monitors[i].y);
			metrics.right  = Math::Max(metrics.right, monitors[i].x + monitors[i].width);
			metrics.bottom = Math::Max(metrics.bottom, monitors[i].y + monitors[i].height);
		}

		XRRFreeMonitors(monitors);

		if (monitorCount > 0) return metrics;
	}

	return GUI::Rect(GUI::Point(0, 0), GUI::Size(XWidthOfScreen(XDefaultScreenOfDisplay(display)), XHeightOfScreen(XDefaultScreenOfDisplay(display))));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
xorl %r15d, %r15d
testq %rdi, %rdi
je 0xc2f97
movq 0xb409f(%rip), %rax     # 0x176fa8
testq %rax, %rax
je 0xc2fb8
leaq 0x4(%rsp), %r14
movl $0x0, (%r14)
movq 0xe8(%rdi), %rcx
movslq 0xe0(%rdi), %rdx
shlq $0x7, %rdx
movq 0x10(%rcx,%rdx), %rsi
movl $0x1, %edx
movq %r14, %rcx
callq *%rax
movslq (%r14), %rcx
testq %rcx, %rcx
jle 0xc2f9c
imulq $0x38, %rcx, %rcx
xorl %edx, %edx
xorl %ebp, %ebp
xorl %r15d, %r15d
xorl %esi, %esi
movl 0x14(%rax,%rdx), %edi
movl 0x18(%rax,%rdx), %r14d
cmpl %edi, %ebp
cmovgel %edi, %ebp
cmpl %r14d, %r15d
cmovgel %r14d, %r15d
addl 0x1c(%rax,%rdx), %edi
cmpl %edi, %esi
cmovgl %esi, %edi
shrq $0x20, %rsi
addl 0x20(%rax,%rdx), %r14d
cmpl %r14d, %esi
cmovgl %esi, %r14d
shlq $0x20, %r14
orq %rdi, %r14
addq $0x38, %rdx
movq %r14, %rsi
cmpq %rdx, %rcx
jne 0xc2f54
jmp 0xc2fa4
xorl %r14d, %r14d
jmp 0xc2fe7
xorl %r14d, %r14d
xorl %r15d, %r15d
xorl %ebp, %ebp
movq %rax, %rdi
callq *0xb4003(%rip)          # 0x176fb0
cmpl $0x0, 0x4(%rsp)
jg 0xc2fe9
movq 0x10(%rbx), %rdi
callq 0x57050
movq %rax, %rdi
callq 0x562c0
movl %eax, %ebp
movq 0x10(%rbx), %rdi
callq 0x57050
movq %rax, %rdi
callq 0x58370
movl %eax, %r14d
movl %ebp, %eax
shlq $0x20, %r14
orq %rax, %r14
xorl %r15d, %r15d
xorl %ebp, %ebp
shlq $0x20, %r15
movl %ebp, %eax
orq %r15, %rax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/backends/cairo/surfacecairo.cpp
// Function: smooth::GUI::SurfaceCairo::~SurfaceCairo()
S::GUI::SurfaceCairo::~SurfaceCairo()
{
	if (window != NIL)
	{
		cairo_destroy(paintContextCairo);
		cairo_surface_destroy(paintSurfaceCairo);

		XFreePixmap(display, paintBitmap);
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xa6497(%rip), %rax     # 0x169d48
movq %rax, (%rdi)
cmpq $0x0, 0x50(%rdi)
je 0xc38e0
movq 0xd0(%rbx), %rdi
callq 0x58b80
movq 0xc8(%rbx), %rdi
callq 0x57630
movq 0x40(%rbx), %rdi
movq 0x58(%rbx), %rsi
callq 0x56360
leaq 0x60(%rbx), %rdi
callq 0xc6236
movq %rbx, %rdi
popq %rbx
jmp 0x60c0a
movq %rax, %rdi
callq 0x5aeae
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/backends/cairo/surfacecairo.cpp
// Function: smooth::GUI::SurfaceCairo::SetSize(smooth::GUI::Size const&)
S::Int S::GUI::SurfaceCairo::SetSize(const Size &nSize)
{
	size = nSize;

	rightToLeft.SetSurfaceSize(size);

	if (allocSize.cx >= nSize.cx && allocSize.cy >= nSize.cy) return Success();

	if (window != NIL && !painting)
	{
		cairo_destroy(paintContextCairo);
		cairo_surface_destroy(paintSurfaceCairo);

		XFreePixmap(display, paintBitmap);

		paintRects.RemoveAll();

		XWindowAttributes	 windowAttributes;

		XGetWindowAttributes(display, window, &windowAttributes);

		paintBitmap	  = XCreatePixmap(display, DefaultRootWindow(display), size.cx, size.cy, windowAttributes.depth);
		paintSurfaceCairo = cairo_xlib_surface_create(display, paintBitmap, visual, size.cx, size.cy);
		paintContextCairo = cairo_create(paintSurfaceCairo);

		paintRects.Add(Rect(Point(0, 0), size));

		cairo_set_antialias(paintContextCairo, CAIRO_ANTIALIAS_NONE);
	}

	allocSize = nSize;

	return Success();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc(%rdi), %rsi
movq (%r14), %rax
movq %rax, 0xc(%rdi)
addq $0x28, %rdi
callq 0x632fa
movl 0x34(%rbx), %eax
cmpl (%r14), %eax
jl 0xc394f
movl 0x38(%rbx), %eax
cmpl 0x4(%r14), %eax
jge 0xc3a39
cmpq $0x0, 0x50(%rbx)
je 0xc3a32
cmpw $0x0, 0xa(%rbx)
jne 0xc3a32
movq 0xd0(%rbx), %rdi
callq 0x58b80
movq 0xc8(%rbx), %rdi
callq 0x57630
movq 0x40(%rbx), %rdi
movq 0x58(%rbx), %rsi
callq 0x56360
leaq 0x60(%rbx), %r15
movq %r15, %rdi
callq 0xc626e
movq 0x40(%rbx), %rdi
movq 0x50(%rbx), %rsi
leaq 0x10(%rsp), %r12
movq %r12, %rdx
callq 0x56fd0
movq 0x40(%rbx), %rdi
movq 0xe8(%rdi), %rax
movslq 0xe0(%rdi), %rcx
shlq $0x7, %rcx
movq 0x10(%rax,%rcx), %rsi
movl 0xc(%rbx), %edx
movl 0x10(%rbx), %ecx
movl 0x14(%r12), %r8d
callq 0x56340
movq %rax, 0x58(%rbx)
movq 0x40(%rbx), %rdi
movq 0x48(%rbx), %rdx
movl 0xc(%rbx), %ecx
movl 0x10(%rbx), %r8d
movq %rax, %rsi
callq 0x57860
movq %rax, 0xc8(%rbx)
movq %rax, %rdi
callq 0x58060
movq %rax, 0xd0(%rbx)
movq %rsp, %rsi
movq $0x0, (%rsi)
movq 0xc(%rbx), %rax
movq %rax, 0x8(%rsi)
movq %r15, %rdi
callq 0xc6536
movq 0xd0(%rbx), %rdi
movl $0x1, %esi
callq 0x56410
movq (%r14), %rax
movq %rax, 0x34(%rbx)
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/backends/cairo/surfacecairo.cpp
// Function: smooth::GUI::SurfaceCairo::PaintRect(smooth::GUI::Rect const&)
S::Int S::GUI::SurfaceCairo::PaintRect(const Rect &pRect)
{
	if (painting) return Error();

	if (window != NIL)
	{
		GC	 gc = XCreateGC(display, window, 0, NIL);

		XCopyArea(display, paintBitmap, window, gc, pRect.left, pRect.top, pRect.GetWidth(), pRect.GetHeight(), pRect.left, pRect.top);

		XFreeGC(display, gc);
	}

	return Success();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpw $0x0, 0xa(%rdi)
jne 0xc3acd
movq %rsi, %r12
movq %rdi, %r14
movq 0x50(%rdi), %rsi
testq %rsi, %rsi
je 0xc3acb
movq 0x40(%r14), %rdi
xorl %ebx, %ebx
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x56e00
movq %rax, %r15
movq 0x58(%r14), %rsi
movq 0x40(%r14), %rdi
movq 0x50(%r14), %rdx
movl (%r12), %r8d
movl 0x4(%r12), %r9d
movl 0x8(%r12), %eax
subl %r8d, %eax
movl 0xc(%r12), %r10d
subl %r9d, %r10d
movq %r15, %rcx
pushq %r9
pushq %r8
pushq %r10
pushq %rax
callq 0x58d70
addq $0x20, %rsp
movq 0x40(%r14), %rdi
movq %r15, %rsi
callq 0x59030
jmp 0xc3acd
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/backends/cairo/surfacecairo.cpp
// Function: smooth::GUI::SurfaceCairo::StartPaint(smooth::GUI::Rect const&)
S::Int S::GUI::SurfaceCairo::StartPaint(const Rect &iPRect)
{
	if (window == NIL) return Success();

	Rect	 pRect = Rect::OverlapRect(rightToLeft.TranslateRect(iPRect), paintRects.GetLast());

	cairo_save(paintContextCairo);
	cairo_rectangle(paintContextCairo, pRect.left, pRect.top, pRect.GetWidth(), pRect.GetHeight());
	cairo_clip(paintContextCairo);

	paintRects.Add(pRect);

	painting++;

	return Success();
}

// Assembly:
cmpq $0x0, 0x50(%rdi)
je 0xc3b99
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
addq $0x28, %rdi
callq 0x632ca
movq %rsp, %r15
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
leaq 0x60(%rbx), %r14
movq %r14, %rdi
callq 0xc66d2
movq %r15, %rdi
movq %rax, %rsi
callq 0x58af0
movq %rax, %r12
movq %rdx, %r13
leaq 0x10(%rsp), %r15
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
movq 0xd0(%rbx), %rdi
callq 0x56e50
movq 0xd0(%rbx), %rdi
cvtsi2sd %r12d, %xmm0
movq %r12, %rax
shrq $0x20, %rax
cvtsi2sd %eax, %xmm1
movl %r13d, %ecx
subl %r12d, %ecx
cvtsi2sd %ecx, %xmm2
shrq $0x20, %r13
subl %eax, %r13d
cvtsi2sd %r13d, %xmm3
callq 0x565a0
movq 0xd0(%rbx), %rdi
callq 0x57b50
movq %r14, %rdi
movq %r15, %rsi
callq 0xc6536
incw 0xa(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/backends/cairo/surfacecairo.cpp
// Function: smooth::GUI::SurfaceCairo::EndPaint()
S::Int S::GUI::SurfaceCairo::EndPaint()
{
	if (!painting) return Error();

	painting--;

	if (painting == 0) PaintRect(paintRects.GetLast());

	paintRects.RemoveNth(paintRects.Length() - 1);

	cairo_restore(paintContextCairo);

	return Success();
}

// Assembly:
movzwl 0xa(%rdi), %eax
testw %ax, %ax
je 0xc3be5
pushq %rbx
movq %rdi, %rbx
decw %ax
movw %ax, 0xa(%rdi)
jne 0xc3bc7
leaq 0x60(%rbx), %rdi
callq 0xc66d2
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x30(%rcx)
leaq 0x60(%rbx), %rdi
movl 0x68(%rbx), %esi
decl %esi
callq 0xc62f0
movq 0xd0(%rbx), %rdi
callq 0x57ab0
xorl %eax, %eax
popq %rbx
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/backends/cairo/surfacecairo.cpp
// Function: smooth::GUI::SurfaceCairo::CreateCairoContext()
S::Void S::GUI::SurfaceCairo::CreateCairoContext()
{
	if (context != NIL || surface != NIL) return;

	surface = cairo_xlib_surface_create(display, window, visual, size.cx, size.cy);
	context = cairo_create(surface);

	cairo_set_antialias(context, CAIRO_ANTIALIAS_NONE);
}

// Assembly:
pushq %rbx
cmpq $0x0, 0xc0(%rdi)
jne 0xc3f30
movq %rdi, %rbx
cmpq $0x0, 0xb8(%rdi)
je 0xc3f32
popq %rbx
retq
movq 0x40(%rbx), %rdi
movq 0x50(%rbx), %rsi
movq 0x48(%rbx), %rdx
movl 0xc(%rbx), %ecx
movl 0x10(%rbx), %r8d
callq 0x57860
movq %rax, 0xb8(%rbx)
movq %rax, %rdi
callq 0x58060
movq %rax, 0xc0(%rbx)
movq %rax, %rdi
movl $0x1, %esi
popq %rbx
jmp 0x56410
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/backends/cairo/surfacecairo.cpp
// Function: smooth::GUI::SurfaceCairo::DestroyCairoContext()
S::Void S::GUI::SurfaceCairo::DestroyCairoContext()
{
	if (context == NIL || surface == NIL) return;

	cairo_destroy(context);
	cairo_surface_destroy(surface);

	context = NIL;
	surface = NIL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xc0(%rdi), %rdi
testq %rdi, %rdi
je 0xc3fa2
cmpq $0x0, 0xb8(%rbx)
je 0xc3fa2
addq $0xb8, %rbx
callq 0x58b80
movq (%rbx), %rdi
callq 0x57630
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/backends/cairo/surfacecairo.cpp
// Function: smooth::GUI::SurfaceCairo::SetPixel(smooth::GUI::Point const&, smooth::GUI::Color const&)
S::Int S::GUI::SurfaceCairo::SetPixel(const Point &iPoint, const Color &color)
{
	if (window == NIL) return Success();

	Point	 point = rightToLeft.TranslatePoint(iPoint);

	if (!painting)
	{
		CreateCairoContext();

		cairo_set_source_rgb(context, color.GetRed() / 255.0, color.GetGreen() / 255.0, color.GetBlue() / 255.0);
		cairo_rectangle(context, point.x, point.y, 1.0, 1.0);
		cairo_fill(context);

		DestroyCairoContext();
	}

	cairo_set_source_rgb(paintContextCairo, color.GetRed() / 255.0, color.GetGreen() / 255.0, color.GetBlue() / 255.0);
	cairo_rectangle(paintContextCairo, point.x, point.y, 1.0, 1.0);
	cairo_fill(paintContextCairo);

	return Success();
}

// Assembly:
cmpq $0x0, 0x50(%rdi)
je 0xc4114
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
addq $0x28, %rdi
callq 0x632a6
movq %rax, %r15
movq %rax, %r12
shrq $0x20, %r12
cmpw $0x0, 0xa(%rbx)
je 0xc3ff8
cvtsi2sd %r15d, %xmm0
movsd %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %r12d, %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0xc408c
movq %rbx, %rdi
callq 0xc3f18
movq 0xc0(%rbx), %rdi
movl 0x8(%r14), %eax
movl $0xff, %ecx
movl %eax, %edx
andl %ecx, %edx
cvtsi2sd %edx, %xmm0
movsd 0x2f348(%rip), %xmm3    # 0xf3368
divsd %xmm3, %xmm0
movl %eax, %edx
shrl $0x8, %edx
andl %ecx, %edx
cvtsi2sd %edx, %xmm1
divsd %xmm3, %xmm1
shrl $0x10, %eax
andl %ecx, %eax
cvtsi2sd %eax, %xmm2
divsd %xmm3, %xmm2
callq 0x58030
movq 0xc0(%rbx), %rdi
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r12d, %xmm1
movsd 0x2f324(%rip), %xmm2    # 0xf3388
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movaps %xmm2, %xmm3
callq 0x565a0
movq 0xc0(%rbx), %rdi
callq 0x57d40
movq %rbx, %rdi
callq 0xc3f6e
movq 0xd0(%rbx), %rdi
movl 0x8(%r14), %eax
movl $0xff, %ecx
movl %eax, %edx
andl %ecx, %edx
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
movsd 0x2f2b9(%rip), %xmm3    # 0xf3368
divsd %xmm3, %xmm0
movl %eax, %edx
shrl $0x8, %edx
andl %ecx, %edx
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
divsd %xmm3, %xmm1
shrl $0x10, %eax
andl %ecx, %eax
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
divsd %xmm3, %xmm2
callq 0x58030
movq 0xd0(%rbx), %rdi
movsd 0x2f29f(%rip), %xmm2    # 0xf3388
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movaps %xmm2, %xmm3
callq 0x565a0
movq 0xd0(%rbx), %rdi
callq 0x57d40
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/system/backends/posix/timerposix.cpp
// Function: smooth::System::TimerPOSIX::Stop()
S::Int S::System::TimerPOSIX::Stop()
{
	if (timer == NIL) return Error();

	timer_delete(*timer);

	delete timer;

	timer = NIL;

	return Success();
}

// Assembly:
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0xc6a17
pushq %rbx
movq %rdi, %rbx
movq (%rax), %rdi
callq 0x56860
movq 0x18(%rbx), %rdi
movl $0x8, %esi
callq 0x55480
movq $0x0, 0x18(%rbx)
xorl %eax, %eax
popq %rbx
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/system/backends/posix/../../../../include/smooth/system/../templates/signals/signalr.h
// Function: smooth::SignalR0<int>::Disconnect(int (*)())
Int Disconnect(returnTYPE (*proc)(SIGNALS_ARGUMENT_TYPES))
			{
				if (slotsN == NIL) return Error();

				SIGNALS_SLOT_GLOBAL_CLASS_NAME<returnTYPE SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES>	 slot(proc);

				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 0xc6a8c
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xa34e7(%rip), %rcx     # 0x169f30
movq %rsp, %r14
movq %rcx, (%r14)
movq %rsi, 0x8(%r14)
movl 0x8(%rax), %ebp
testl %ebp, %ebp
jle 0xc6a81
decl %ebp
movq 0x10(%rbx), %rdi
movl %ebp, %esi
callq 0x5b074
movq (%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x20(%rax)
testb %al, %al
je 0xc6a56
movq %rbx, %rdi
movl %ebp, %esi
callq 0xb0fce
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/system/backends/posix/../../../../include/smooth/system/../templates/signals/signalr.h
// Function: smooth::SignalR0<int>::Connect(int (*)())
Int Connect(returnTYPE (*proc)(SIGNALS_ARGUMENT_TYPES))
			{
				if (slotsN == NIL)
				{
					slotsN = new Array<Void *>();
					slotsN->EnableLocking();
				}

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

				return Success();
			}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq 0x10(%rdi), %r15
testq %r15, %r15
jne 0xc6aec
movq %rdi, %r14
movl $0x58, %edi
callq 0x556b0
movq %rax, %r15
movq %rax, %rdi
callq 0x55d90
leaq 0x98d3a(%rip), %rax     # 0x15f800
movq %rax, 0x40(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r15)
leaq 0x98e47(%rip), %rax     # 0x15f920
movq %rax, (%r15)
movq %r15, 0x10(%r14)
movq %r15, %rdi
callq 0x571b0
movq 0x10(%r14), %r15
movl $0x10, %edi
callq 0x556b0
leaq 0xa3433(%rip), %rcx     # 0x169f30
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x5aed8
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x58, %esi
movq %r15, %rdi
callq 0x55480
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/threads/backends/posix/mutexposix.cpp
// Function: smooth::Threads::MutexPOSIX::MutexPOSIX(void*)
S::Threads::MutexPOSIX::MutexPOSIX(Void *iMutex)
{
	type = MUTEX_POSIX;

	if (iMutex != NIL)
	{
		mutex	= (pthread_mutex_t *) iMutex;
		myMutex	= False;
	}
	else
	{
		mutex	= new pthread_mutex_t;
		myMutex	= True;

		pthread_mutexattr_t	 mutexattr;

		pthread_mutexattr_init(&mutexattr);
		pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_RECURSIVE);

		if (pthread_mutex_init(mutex, &mutexattr) != 0)
		{
			delete mutex;

			mutex = NIL;
		}

		pthread_mutexattr_destroy(&mutexattr);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
callq 0xb356a
leaq 0xa33b2(%rip), %rax     # 0x169f80
movq %rax, (%rbx)
movw $0x1, 0x8(%rbx)
testq %r14, %r14
je 0xc6be6
movq %r14, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
jmp 0xc6c42
movl $0x28, %edi
callq 0x556b0
movq %rax, 0x10(%rbx)
movb $0x1, 0x18(%rbx)
leaq 0x4(%rsp), %r14
movq %r14, %rdi
callq 0x584d0
movq %r14, %rdi
movl $0x1, %esi
callq 0x56a50
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x56280
testl %eax, %eax
je 0xc6c38
movq 0x10(%rbx), %rdi
movl $0x28, %esi
callq 0x55480
movq $0x0, 0x10(%rbx)
leaq 0x4(%rsp), %rdi
callq 0x55ca0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xb357c
movq %r14, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/threads/backends/posix/semaphoreposix.cpp
// Function: smooth::Threads::SemaphorePOSIX::SemaphorePOSIX(int, void*)
S::Threads::SemaphorePOSIX::SemaphorePOSIX(Int iValue, Void *iSemaphore) : SemaphoreBackend(iValue)
{
	type = SEMAPHORE_POSIX;

	if (iSemaphore != NIL)
	{
		SemaphorePOSIX	*oSemaphore = (SemaphorePOSIX *) iSemaphore;

		mutex	    = oSemaphore->mutex;
		condition   = oSemaphore->condition;

		count	    = oSemaphore->count;
		max	    = oSemaphore->max;

		mySemaphore = False;
	}
	else
	{
		mutex	    = new pthread_mutex_t;
		condition   = new pthread_cond_t;

		count	    = iValue;
		max	    = iValue;

		mySemaphore = True;

		if (pthread_mutex_init(mutex, NIL) != 0)
		{
			delete mutex;
			delete condition;

			mutex	  = NIL;
			condition = NIL;
		}
		else if (pthread_cond_init(condition, NIL) != 0)
		{
			pthread_mutex_destroy(mutex);

			delete mutex;
			delete condition;

			mutex	  = NIL;
			condition = NIL;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
xorl %edx, %edx
callq 0xb35de
leaq 0xa3267(%rip), %rax     # 0x169fd8
movq %rax, (%rbx)
movw $0x1, 0x8(%rbx)
testq %r14, %r14
je 0xc6d96
movups 0x10(%r14), %xmm0
movups %xmm0, 0x10(%rbx)
movq 0x20(%r14), %rax
movq %rax, 0x20(%rbx)
movb $0x0, 0x28(%rbx)
jmp 0xc6e0c
movl $0x28, %edi
callq 0x556b0
movq %rax, %r14
movq %rax, 0x10(%rbx)
movl $0x30, %edi
callq 0x556b0
leaq 0x10(%rbx), %r15
movq %rax, 0x18(%rbx)
movl %ebp, 0x20(%rbx)
movl %ebp, 0x24(%rbx)
movb $0x1, 0x28(%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x56280
testl %eax, %eax
jne 0xc6de9
movq 0x18(%rbx), %rdi
xorl %esi, %esi
callq 0x56470
testl %eax, %eax
je 0xc6e0c
movq 0x10(%rbx), %rdi
callq 0x554a0
movq 0x10(%rbx), %rdi
movl $0x28, %esi
callq 0x55480
movq 0x18(%rbx), %rdi
movl $0x30, %esi
callq 0x55480
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xb35f0
movq %r14, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/threads/backends/posix/semaphoreposix.cpp
// Function: smooth::Threads::SemaphorePOSIX::~SemaphorePOSIX()
S::Threads::SemaphorePOSIX::~SemaphorePOSIX()
{
	if (mySemaphore && mutex != NIL)
	{
		pthread_mutex_destroy(mutex);
		pthread_cond_destroy(condition);

		delete mutex;
		delete condition;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xa31a3(%rip), %rax     # 0x169fd8
movq %rax, (%rdi)
cmpb $0x1, 0x28(%rdi)
jne 0xc6e71
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xc6e71
callq 0x554a0
movq 0x18(%rbx), %rdi
callq 0x55e50
movq 0x10(%rbx), %rdi
movl $0x28, %esi
callq 0x55480
movq 0x18(%rbx), %rdi
movl $0x30, %esi
callq 0x55480
movq %rbx, %rdi
popq %rbx
jmp 0xb35f0
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/threads/backends/posix/semaphoreposix.cpp
// Function: smooth::Threads::SemaphorePOSIX::Wait()
S::Bool S::Threads::SemaphorePOSIX::Wait()
{
	if (mutex == NIL) return False;

	pthread_mutex_lock(mutex);

	while (count <= 0) pthread_cond_wait(condition, mutex);

	count -= 1;

	pthread_mutex_unlock(mutex);

	return True;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rbx
testq %rbx, %rbx
je 0xc6ed4
movq %rdi, %r14
movq %rbx, %rdi
callq 0x55da0
movl 0x20(%r14), %eax
testl %eax, %eax
jg 0xc6ec5
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdi
callq 0x56990
jmp 0xc6eae
decl %eax
movl %eax, 0x20(%r14)
movq 0x10(%r14), %rdi
callq 0x55c20
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/threads/backends/posix/semaphoreposix.cpp
// Function: smooth::Threads::SemaphorePOSIX::TryWait()
S::Bool S::Threads::SemaphorePOSIX::TryWait()
{
	if (mutex == NIL) return False;

	pthread_mutex_lock(mutex);

	if (count > 0)
	{
		count -= 1;

		pthread_mutex_unlock(mutex);

		return True;
	}

	pthread_mutex_unlock(mutex);

	return False;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xc6f13
callq 0x55da0
movl 0x20(%r14), %eax
testl %eax, %eax
setg %bl
jle 0xc6f08
decl %eax
movl %eax, 0x20(%r14)
movq 0x10(%r14), %rdi
callq 0x55c20
jmp 0xc6f15
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/threads/backends/posix/semaphoreposix.cpp
// Function: smooth::Threads::SemaphorePOSIX::Release()
S::Bool S::Threads::SemaphorePOSIX::Release()
{
	if (mutex == NIL) return False;

	pthread_mutex_lock(mutex);

	if (count < max)
	{
		count += 1;

		pthread_cond_signal(condition);
		pthread_mutex_unlock(mutex);

		return True;
	}

	pthread_mutex_unlock(mutex);

	return False;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xc6f5c
callq 0x55da0
movl 0x20(%r14), %eax
cmpl 0x24(%r14), %eax
setl %bl
jge 0xc6f51
incl %eax
movl %eax, 0x20(%r14)
movq 0x18(%r14), %rdi
callq 0x57490
movq 0x10(%r14), %rdi
callq 0x55c20
jmp 0xc6f5e
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/threads/backends/posix/threadposix.cpp
// Function: smooth::Threads::ThreadPOSIX::ThreadPOSIX(void*)
S::Threads::ThreadPOSIX::ThreadPOSIX(Void *iThread)
{
	pthread_mutex_init(&mutex, NIL);

	type		 = THREAD_POSIX;

	thread		 = NIL;
	myThread	 = False;

	info.threadProc	 = NIL;
	info.threadParam = NIL;

	if (iThread != NIL) thread = (pthread_t *) iThread;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
callq 0xb364e
leaq 0xa306e(%rip), %rax     # 0x16a030
movq %rax, (%r14)
leaq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0x56280
movw $0x1, 0x8(%r14)
movq $0x0, 0x48(%r14)
movb $0x0, 0x50(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
testq %rbx, %rbx
je 0xc6ff5
movq %rbx, 0x48(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop