LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/misc/pciio.cpp
// Function: PCIIO::ReadDATATAG(smooth::IO::InStream*)
bool PCIIO::ReadDATATAG(PCIIn in)
{
	in->Seek(0);

	do
	{
		static String	 dataTag = "DATA";

		if (in->InputString(4).Compare(dataTag) == 0)
		{
			in->RelSeek(2);

			if (in->InputNumber(4) == imageid)
			{
				in->RelSeek(4);

				bmp.CreateBitmap(Size(sizex, sizey));

				DecompressPCI(in);

				return true;
			}
			else
			{
				in->RelSeek(in->InputNumber(4) - 14);
			}
		}
		else
		{
			in->RelSeek(6);

			in->RelSeek(in->InputNumber(4) - 14);
		}
	}
	while (in->Size() > in->GetPos());

	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
xorl %esi, %esi
callq *0x28(%rax)
leaq 0xbbaaa(%rip), %r12     # 0x176ae8
leaq 0xb303b(%rip), %r15     # 0x16e080
movq %rsp, %r13
movb 0xbbab2(%rip), %al      # 0x176b00
testb %al, %al
je 0xbb0e7
movq %r13, %rdi
movq %rbx, %rsi
movl $0x4, %edx
callq 0x589a0
movq %r13, %rdi
movq %r12, %rsi
callq 0x585c0
movl %eax, %ebp
movq %r13, %rdi
callq 0x59200
movq (%rbx), %rax
movq 0x30(%rax), %rax
testl %ebp, %ebp
je 0xbb092
movl $0x6, %esi
movq %rbx, %rdi
callq *%rax
jmp 0xbb0b6
movl $0x2, %esi
movq %rbx, %rdi
callq *%rax
movq %rbx, %rdi
movl $0x4, %esi
callq 0x55e90
movslq 0x68(%r14), %rcx
cmpq %rcx, %rax
je 0xbb147
movq %rbx, %rdi
movl $0x4, %esi
callq 0x55e90
leaq -0xe(%rax), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
cmpw $0x0, 0x8(%rbx)
je 0xbb12d
movq 0x10(%rbx), %rax
cmpq 0x48(%rbx), %rax
jg 0xbb048
jmp 0xbb136
leaq 0xbba12(%rip), %rdi     # 0x176b00
callq 0x56120
testl %eax, %eax
je 0xbb056
movq %r12, %rdi
leaq 0x57d08(%rip), %rsi     # 0x112e0d
callq 0x579f0
movq 0xb0e1f(%rip), %rdi     # 0x16bf30
movq %r12, %rsi
movq %r15, %rdx
callq 0x57e10
leaq 0xbb9dd(%rip), %rdi     # 0x176b00
callq 0x56b80
jmp 0xbb056
movw $0x5, 0xf8(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rax
movl $0x4, %esi
movq %rbx, %rdi
callq *0x30(%rax)
leaq 0x8(%r14), %rdi
movq 0x10(%r14), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x57c20
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb72ca
movb $0x1, %al
jmp 0xbb138
movq %rax, %rbx
leaq 0xbb97a(%rip), %rdi     # 0x176b00
callq 0x56420
jmp 0xbb198
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/misc/pciio.cpp
// Function: PCIIO::ReadNAMETAG(smooth::IO::InStream*)
bool PCIIO::ReadNAMETAG(PCIIn in)
{
	in->Seek(0);

	do
	{
		static String	 nameTag = "NAME";

		if (in->InputString(4).Compare(nameTag) == 0)
		{
			in->RelSeek(2);

			if (in->InputNumber(4) == imageid)
			{
				imagename = in->InputString(in->InputNumber(4) - 14);

				return true;
			}
			else
			{
				in->RelSeek(in->InputNumber(4) - 14);
			}
		}
		else
		{
			in->RelSeek(6);

			in->RelSeek(in->InputNumber(4) - 14);
		}
	}
	while (in->Size() > in->GetPos());

	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
xorl %esi, %esi
callq *0x28(%rax)
leaq 0xbb902(%rip), %r12     # 0x176ac8
leaq 0xb2eb3(%rip), %r15     # 0x16e080
movq %rsp, %r13
movb 0xbb90a(%rip), %al      # 0x176ae0
testb %al, %al
je 0xbb270
movq %r13, %rdi
movq %r14, %rsi
movl $0x4, %edx
callq 0x589a0
movq %r13, %rdi
movq %r12, %rsi
callq 0x585c0
movl %eax, %ebp
movq %r13, %rdi
callq 0x59200
movq (%r14), %rax
movq 0x30(%rax), %rax
testl %ebp, %ebp
je 0xbb21a
movl $0x6, %esi
movq %r14, %rdi
callq *%rax
jmp 0xbb23e
movl $0x2, %esi
movq %r14, %rdi
callq *%rax
movq %r14, %rdi
movl $0x4, %esi
callq 0x55e90
movslq 0x68(%rbx), %rcx
cmpq %rcx, %rax
je 0xbb2d1
movq %r14, %rdi
movl $0x4, %esi
callq 0x55e90
leaq -0xe(%rax), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x30(%rax)
cmpw $0x0, 0x8(%r14)
je 0xbb2b6
movq 0x10(%r14), %rax
cmpq 0x48(%r14), %rax
jg 0xbb1d0
jmp 0xbb2c0
leaq 0xbb869(%rip), %rdi     # 0x176ae0
callq 0x56120
testl %eax, %eax
je 0xbb1de
movq %r12, %rdi
leaq 0x5815c(%rip), %rsi     # 0x1133ea
callq 0x579f0
movq 0xb0c96(%rip), %rdi     # 0x16bf30
movq %r12, %rsi
movq %r15, %rdx
callq 0x57e10
leaq 0xbb834(%rip), %rdi     # 0x176ae0
callq 0x56b80
jmp 0xbb1de
movw $0x5, 0xf8(%r14)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movl $0x4, %esi
callq 0x55e90
leal -0xe(%rax), %edx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x589a0
addq $0x38, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x555f0
movq %rsp, %rdi
callq 0x59200
movb $0x1, %al
jmp 0xbb2c2
movq %rax, %rbx
leaq 0xbb7cc(%rip), %rdi     # 0x176ae0
callq 0x56420
jmp 0xbb328
jmp 0xbb31d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/dialogs/directory/dirdlg_gtk.cpp
// Function: smooth::GUI::Dialogs::DirSelection::ShowDialog()
const Error &S::GUI::Dialogs::DirSelection::ShowDialog()
{
	/* Create file chooser dialog.
	 */
	GtkWidget	*dialog = gtk_file_chooser_dialog_new(caption, NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
							      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
							      GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
							      NULL);

	if (directory != NIL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), directory);

	/* Run dialog and check result.
	 */
	if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
	{
		char	*name = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));

		directory.ImportFrom("UTF-8", name);

		g_free(name);
	}
	else
	{
		directory = NIL;
	}

	gtk_widget_destroy(dialog);

	/* Wait for GTK to finish pending actions.
	 */
	while (gtk_events_pending()) gtk_main_iteration();

	/* Check if we actually have a directory.
	 */
	if (directory != NIL)
	{
		if (!directory.EndsWith(Directory::GetDirectoryDelimiter())) directory.Append(Directory::GetDirectoryDelimiter());
	}
	else
	{
		error = Error();
	}

	return error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
addq $0x5b8, %rdi            # imm = 0x5B8
callq 0x585e0
leaq 0x57ac0(%rip), %rcx     # 0x112e12
leaq 0x57ac4(%rip), %r9      # 0x112e1d
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
movl $0xfffffffa, %r8d       # imm = 0xFFFFFFFA
xorl %eax, %eax
pushq $0x0
pushq $-0x3
callq 0x58960
addq $0x10, %rsp
movq %rax, %r15
leaq 0x5e8(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x56bd0
testb %al, %al
je 0xbb3b6
callq 0x577f0
movq %r15, %rdi
movq %rax, %rsi
callq 0x55410
movq %rax, %r12
movq %r14, %rdi
callq 0x585e0
movq %r12, %rdi
movq %rax, %rsi
callq 0x56180
callq 0x571a0
movq %r15, %rdi
movq %rax, %rsi
callq 0x55410
movq %rax, %rdi
callq 0x55c40
cmpl $-0x3, %eax
jne 0xbb40a
callq 0x577f0
movq %r15, %rdi
movq %rax, %rsi
callq 0x55410
movq %rax, %rdi
callq 0x57a90
movq %rax, %r12
leaq 0x56ee1(%rip), %rsi     # 0x1122d6
movq %r14, %rdi
movq %rax, %rdx
callq 0x56950
movq %r12, %rdi
callq 0x55b40
jmp 0xbb414
movq %r14, %rdi
xorl %esi, %esi
callq 0x579e0
movq %r15, %rdi
callq 0x55580
callq 0x58500
testl %eax, %eax
je 0xbb42c
callq 0x55060
jmp 0xbb41c
movq %r14, %rdi
xorl %esi, %esi
callq 0x56bd0
testb %al, %al
je 0xbb497
callq 0x55370
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x579f0
movq %r14, %rdi
movq %r15, %rsi
callq 0x58b10
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x59200
testb %bpl, %bpl
jne 0xbb4a1
callq 0x55370
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x579f0
movq %r14, %rdi
movq %r15, %rsi
callq 0x562f0
leaq 0x8(%rsp), %rdi
callq 0x59200
jmp 0xbb4a1
movl $0xffffffff, 0x5e0(%rbx) # imm = 0xFFFFFFFF
addq $0x5d8, %rbx            # imm = 0x5D8
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbb4ba
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/backends/xlib/backendxlib.cpp
// Function: smooth::Backends::BackendXLib::Init()
S::Int S::Backends::BackendXLib::Init()
{
	XInitThreads();

	/* Open display.
	 */
	const char	*displayId = getenv("DISPLAY");

	if (displayId != NIL)
	{
		display	= XOpenDisplay(NIL);

		if (display == NIL)
		{
			fprintf(stderr, "Error: Unable to open display at %s.\n", displayId);

			return Error();
		}

		/* Init the GTK with SIGALRM signals disabled to make
		 * threads created by gtk_init inherit this SIGMASK.
		 */
		toggleTimerInterrupts(false);

		gtk_init(NULL, NULL);

		toggleTimerInterrupts(true);

		/* Get default colors.
		 */
		UpdateColors();

		/* Set locale and open input method.
		 */
		setlocale(LC_ALL, "");

		XSetLocaleModifiers("");

		im = XOpenIM(display, NIL, NIL, NIL);
	}

	return Success();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x553e0
leaq 0x57076(%rip), %rdi     # 0x112e58
callq 0x57720
testq %rax, %rax
je 0xbbe5a
movq %rax, %r14
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x59130
movq %rax, 0xbad31(%rip)     # 0x176b30
testq %rax, %rax
je 0xbbe66
xorl %edi, %edi
callq 0xbbe88
xorl %edi, %edi
xorl %esi, %esi
callq 0x564c0
movl $0x1, %edi
callq 0xbbe88
callq 0xbbec6
leaq 0x55bfe(%rip), %r14     # 0x111a28
movl $0x6, %edi
movq %r14, %rsi
callq 0x577c0
movq %r14, %rdi
callq 0x561d0
movq 0xbacea(%rip), %rdi     # 0x176b30
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x562a0
movq %rax, 0xbace0(%rip)     # 0x176b38
jmp 0xbbe5c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xafa5b(%rip), %rax     # 0x16b8c8
movq (%rax), %rdi
leaq 0x56fe9(%rip), %rsi     # 0x112e60
movq %r14, %rdx
xorl %eax, %eax
callq 0x558d0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0xbbe5c
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/backends/xlib/backendxlib.cpp
// Function: smooth::Backends::BackendXLib::UpdateColors()
S::Void S::Backends::BackendXLib::UpdateColors()
{
	/* Check desktop environment.
	 */
	String			 desktop = getenv("XDG_CURRENT_DESKTOP");
	const Array<String>	&IDs	 = desktop.Explode(":");

	foreach (const String &ID, IDs)
	{
		if (ID == "KDE" && UpdateColorsKDE()) return;
	}

	UpdateColorsGnome();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
leaq 0x56fad(%rip), %rdi     # 0x112e86
callq 0x57720
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x579f0
leaq 0x371f5(%rip), %rsi     # 0xf30e7
leaq 0x8(%rsp), %rdi
callq 0x579f0
leaq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x57f10
leaq 0x8(%rsp), %rdi
callq 0x59200
cmpl $0x0, 0x40(%rsp)
jle 0xbbf60
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
leaq 0x38(%rsp), %r14
leaq 0x56f68(%rip), %r15     # 0x112e9a
incl %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x64250
movq %rax, %rdi
movq %r15, %rsi
callq 0x57ef0
testb %al, %al
je 0xbbf56
callq 0xbbfe6
testb %al, %al
jne 0xbbf65
movl 0x40(%rsp), %eax
decl %eax
cmpl %eax, %ebx
jl 0xbbf32
callq 0xbc750
leaq 0x38(%rsp), %rdi
callq 0x63e3c
leaq 0x20(%rsp), %rdi
callq 0x59200
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xbbf9e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
jmp 0xbbfab
movq %rax, %rbx
jmp 0xbbfab
jmp 0xbbf9e
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x63e3c
leaq 0x20(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/backends/xlib/backendxlib.cpp
// Function: get_gtk_color(unsigned long, char const*, GtkStateFlags, bool)
static GdkRGBA get_gtk_color(GType type, const gchar *className, GtkStateFlags stateFlags, bool background)
{
	/* Create dummy widget of requested type.
	 */
	GtkWidget	*widget = NIL;

	if	(type == GTK_TYPE_WINDOW)      widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	else if	(type == GTK_TYPE_TOOLTIP)     widget = gtk_window_new(GTK_WINDOW_POPUP);
	else if	(type == GTK_TYPE_BUTTON)      widget = gtk_button_new();
	else if	(type == GTK_TYPE_TEXT_VIEW)   widget = gtk_text_view_new();
	else if	(type == GTK_TYPE_LINK_BUTTON) widget = gtk_link_button_new("");

	if (widget == NIL) return { 0, 0, 0, 0 };

	/* Get GtkStyleContext to query color.
	 */
	GtkStyleContext *style = gtk_widget_get_style_context(widget);

	gtk_style_context_add_class(style, className);

	/* Query color from style context.
	 */
	GdkRGBA	 color;

	if (background) gtk_style_context_get_background_color(style, stateFlags, &color);
	else		gtk_style_context_get_color(style, stateFlags, &color);

	g_object_ref_sink(widget);
	g_object_unref(widget);

	return color;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r14d
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x58c50
cmpq %r12, %rax
jne 0xbcdb9
xorl %edi, %edi
jmp 0xbcdc8
callq 0x56f10
cmpq %r12, %rax
jne 0xbce26
movl $0x1, %edi
callq 0x58520
movq %rax, %r12
testq %rax, %rax
je 0xbce63
movq %r12, %rdi
callq 0x55360
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x57bb0
movq %r13, %rdi
movl %ebp, %esi
movq %rbx, %rdx
testb %r14b, %r14b
je 0xbce03
callq 0x57f20
jmp 0xbce08
callq 0x555a0
movq %r12, %rdi
callq 0x57200
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x584a0
callq 0x56ab0
cmpq %r12, %rax
jne 0xbce37
callq 0x56000
jmp 0xbcdcd
callq 0x57240
cmpq %r12, %rax
jne 0xbce48
callq 0x58df0
jmp 0xbcdcd
callq 0x55a10
cmpq %r12, %rax
jne 0xbce63
leaq 0x54bcf(%rip), %rdi     # 0x111a28
callq 0x55d50
jmp 0xbcdcd
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/backends/xlib/backendxlib.cpp
// Function: get_kde_color(smooth::String const&, smooth::String const&)
static S::GUI::Color get_kde_color(const S::String &category, const S::String &color)
{
	S::String			 spec	= S::Backends::BackendXLib::QueryKDESettings(S::String("Colors:").Append(category), color);
	const S::Array<S::String>	&values = spec.Explode(",");

	if (values.Length() != 3) return S::GUI::Color();

	return S::GUI::Color(values.GetNth(0).ToInt(), values.GetNth(1).ToInt(), values.GetNth(2).ToInt());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x560bc(%rip), %rsi     # 0x112f56
leaq 0x30(%rsp), %r12
movq %r12, %rdi
callq 0x579f0
movq %r12, %rdi
movq %r15, %rsi
callq 0x562f0
leaq 0x18(%rsp), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xbd3b4
leaq 0x30(%rsp), %rdi
callq 0x59200
leaq 0x5608b(%rip), %rsi     # 0x112f5e
movq %rsp, %rdi
callq 0x579f0
leaq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movq %rsp, %rdx
callq 0x57f10
movq %rsp, %rdi
callq 0x59200
cmpl $0x3, 0x38(%rsp)
jne 0xbcf56
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x6b610
movq %rax, %rdi
callq 0x568c0
movq %rax, %r14
leaq 0x30(%rsp), %rdi
movl $0x1, %esi
callq 0x6b610
movq %rax, %rdi
callq 0x568c0
movq %rax, %r15
leaq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x6b610
movq %rax, %rdi
callq 0x568c0
shll $0x10, %eax
shll $0x8, %r15d
orl %r14d, %r15d
orl %eax, %r15d
movslq %r15d, %rax
jmp 0xbcf58
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movl $0x0, (%rbx)
leaq 0x30(%rsp), %rdi
callq 0x63e3c
leaq 0x18(%rsp), %rdi
callq 0x59200
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59200
jmp 0xbcfae
movq %rax, %rbx
jmp 0xbcfae
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0xbcfb3
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x63e3c
leaq 0x18(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/backends/xlib/backendxlib.cpp
// Function: smooth::Backends::BackendXLib::FindExecutable(smooth::String const&)
S::String S::Backends::BackendXLib::FindExecutable(const String &executable)
{
	/* Search the path for executable.
	 */
	String			 path  = getenv("PATH");
	const Array<String>	&paths = path.Explode(":");

	foreach (const String &path, paths)
	{
		/* Check for executable in this path.
		 */
		File	 file(String(path).Append("/").Append(executable));

		if (file.Exists()) return file;
	}

	return NIL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
leaq 0x55537(%rip), %rdi     # 0x112527
callq 0x57720
leaq 0x40(%rsp), %rdi
movq %rax, %rsi
callq 0x579f0
leaq 0x360de(%rip), %rsi     # 0xf30e7
leaq 0x10(%rsp), %rdi
callq 0x579f0
movq %rbx, (%rsp)
leaq 0xa0(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x57f10
leaq 0x10(%rsp), %rdi
callq 0x59200
cmpl $0x0, 0xa8(%rsp)
jle 0xbd0fd
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x88(%rsp), %r12
leaq 0x70(%rsp), %rbx
leaq 0x58(%rsp), %r15
leaq 0x10(%rsp), %r13
incl %ebp
leaq 0xa0(%rsp), %rdi
movl %ebp, %esi
callq 0x64250
movq %r12, %rdi
movq %rax, %rsi
callq 0x570b0
movq %rbx, %rdi
leaq 0x36662(%rip), %rsi     # 0xf36ea
callq 0x579f0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x562f0
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x562f0
movq %rax, %r14
movq %r15, %rdi
xorl %esi, %esi
callq 0x58e20
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x56800
movq %r15, %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x59200
movq %r12, %rdi
callq 0x59200
movq %r13, %rdi
callq 0x56ef0
testb %al, %al
jne 0xbd10d
movq %r13, %rdi
callq 0x59178
movl 0xa8(%rsp), %eax
decl %eax
cmpl %eax, %ebp
jl 0xbd062
movq (%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58e20
jmp 0xbd128
leaq 0x10(%rsp), %rsi
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x58fa0
leaq 0x10(%rsp), %rdi
callq 0x59178
leaq 0xa0(%rsp), %rdi
callq 0x63e3c
leaq 0x40(%rsp), %rdi
callq 0x59200
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbd182
jmp 0xbd193
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x59200
jmp 0xbd1bf
movq %rax, %rbx
jmp 0xbd1bf
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x59200
jmp 0xbd19b
movq %rax, %rbx
jmp 0xbd1a5
jmp 0xbd193
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x59178
jmp 0xbd1b2
jmp 0xbd198
movq %rax, %rbx
jmp 0xbd1b2
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x59200
leaq 0x88(%rsp), %rdi
callq 0x59200
leaq 0xa0(%rsp), %rdi
callq 0x63e3c
leaq 0x40(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/backends/xlib/backendxlib.cpp
// Function: smooth::Backends::BackendXLib::QueryGSettings(smooth::String const&, smooth::String const&)
S::String S::Backends::BackendXLib::QueryGSettings(const String &schema, const String &key)
{
	static String	 gsettings = FindExecutable("gsettings");

	if (gsettings == NIL) return NIL;

	/* Execute gsettings to query value.
	 */
	FILE	*pstdin = popen(String(gsettings).Append(" get ").Append(schema).Append(" ").Append(key), "r");

	if (pstdin != NIL)
	{
		char	 value[256];

		if (fgets(value, 256, pstdin) != NIL)
		{
			pclose(pstdin);

			return value;
		}

		pclose(pstdin);
	}

	return NIL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movb 0xb996b(%rip), %al      # 0x176b58
testb %al, %al
je 0xbd2f5
leaq 0xb9944(%rip), %rdi     # 0x176b40
xorl %esi, %esi
callq 0x55260
testb %al, %al
jne 0xbd2db
leaq 0xb992e(%rip), %rsi     # 0x176b40
leaq 0x30(%rsp), %rdi
callq 0x570b0
leaq 0x55d0b(%rip), %rsi     # 0x112f2e
leaq 0x18(%rsp), %rdi
callq 0x579f0
leaq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x562f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x562f0
movq %rax, %r15
leaq 0x6b3bf(%rip), %rsi     # 0x128610
movq %rsp, %rdi
callq 0x579f0
movq %rsp, %rsi
movq %r15, %rdi
callq 0x562f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x562f0
movq %rax, %rdi
callq 0x585e0
leaq 0x55a93(%rip), %rsi     # 0x112d11
movq %rax, %rdi
callq 0x57b60
movq %rax, %r14
movq %rsp, %rdi
callq 0x59200
leaq 0x18(%rsp), %rdi
callq 0x59200
leaq 0x30(%rsp), %rdi
callq 0x59200
testq %r14, %r14
je 0xbd2db
leaq 0x30(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdx
callq 0x56f20
movq %rax, %r15
movq %r14, %rdi
callq 0x552b0
testq %r15, %r15
je 0xbd2db
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x579f0
jmp 0xbd2e5
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58e20
movq %rbx, %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb985c(%rip), %rdi     # 0x176b58
callq 0x56120
testl %eax, %eax
je 0xbd1f5
leaq 0x55c14(%rip), %rsi     # 0x112f24
leaq 0x30(%rsp), %rdi
callq 0x579f0
leaq 0xb981f(%rip), %rdi     # 0x176b40
leaq 0x30(%rsp), %rsi
callq 0xbcfd0
leaq 0x30(%rsp), %rdi
callq 0x59200
movq 0xaebf4(%rip), %rdi     # 0x16bf30
leaq 0xb97fd(%rip), %rsi     # 0x176b40
leaq 0xb0d36(%rip), %rdx     # 0x16e080
callq 0x57e10
leaq 0xb9802(%rip), %rdi     # 0x176b58
callq 0x56b80
jmp 0xbd1f5
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x59200
jmp 0xbd372
movq %rax, %rbx
leaq 0xb97df(%rip), %rdi     # 0x176b58
callq 0x56420
jmp 0xbd3ab
jmp 0xbd387
movq %rax, %rbx
jmp 0xbd3a1
movq %rax, %rbx
jmp 0xbd397
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59200
leaq 0x18(%rsp), %rdi
callq 0x59200
leaq 0x30(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/backends/xlib/backendxlib.cpp
// Function: smooth::Backends::BackendXLib::QueryXfConf(smooth::String const&, smooth::String const&)
S::String S::Backends::BackendXLib::QueryXfConf(const String &channel, const String &property)
{
	static String	 xfconfquery = FindExecutable("xfconf-query");

	if (xfconfquery == NIL) return NIL;

	/* Execute xfconf-query to query value.
	 */
	FILE	*pstdin = popen(String(xfconfquery).Append(" -c ").Append(channel).Append(" -p ").Append(property), "r");

	if (pstdin != NIL)
	{
		char	 value[256];

		if (fgets(value, 256, pstdin) != NIL)
		{
			pclose(pstdin);

			return value;
		}

		pclose(pstdin);
	}

	return NIL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movb 0xb93ff(%rip), %al      # 0x176b78
testb %al, %al
je 0xbd881
leaq 0xb93d8(%rip), %rdi     # 0x176b60
xorl %esi, %esi
callq 0x55260
testb %al, %al
jne 0xbd867
leaq 0xb93c2(%rip), %rsi     # 0x176b60
leaq 0x30(%rsp), %rdi
callq 0x570b0
leaq 0x5579d(%rip), %rsi     # 0x112f4c
leaq 0x18(%rsp), %rdi
callq 0x579f0
leaq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x562f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x562f0
movq %rax, %r15
leaq 0x55774(%rip), %rsi     # 0x112f51
movq %rsp, %rdi
callq 0x579f0
movq %rsp, %rsi
movq %r15, %rdi
callq 0x562f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x562f0
movq %rax, %rdi
callq 0x585e0
leaq 0x55507(%rip), %rsi     # 0x112d11
movq %rax, %rdi
callq 0x57b60
movq %rax, %r14
movq %rsp, %rdi
callq 0x59200
leaq 0x18(%rsp), %rdi
callq 0x59200
leaq 0x30(%rsp), %rdi
callq 0x59200
testq %r14, %r14
je 0xbd867
leaq 0x30(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdx
callq 0x56f20
movq %rax, %r15
movq %r14, %rdi
callq 0x552b0
testq %r15, %r15
je 0xbd867
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x579f0
jmp 0xbd871
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58e20
movq %rbx, %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb92f0(%rip), %rdi     # 0x176b78
callq 0x56120
testl %eax, %eax
je 0xbd781
leaq 0x556a3(%rip), %rsi     # 0x112f3f
leaq 0x30(%rsp), %rdi
callq 0x579f0
leaq 0xb92b3(%rip), %rdi     # 0x176b60
leaq 0x30(%rsp), %rsi
callq 0xbcfd0
leaq 0x30(%rsp), %rdi
callq 0x59200
movq 0xae668(%rip), %rdi     # 0x16bf30
leaq 0xb9291(%rip), %rsi     # 0x176b60
leaq 0xb07aa(%rip), %rdx     # 0x16e080
callq 0x57e10
leaq 0xb9296(%rip), %rdi     # 0x176b78
callq 0x56b80
jmp 0xbd781
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x59200
jmp 0xbd8fe
movq %rax, %rbx
leaq 0xb9273(%rip), %rdi     # 0x176b78
callq 0x56420
jmp 0xbd937
jmp 0xbd913
movq %rax, %rbx
jmp 0xbd92d
movq %rax, %rbx
jmp 0xbd923
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59200
leaq 0x18(%rsp), %rdi
callq 0x59200
leaq 0x30(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/backends/xlib/bitmapxlib.cpp
// Function: smooth::GUI::BitmapXLib::DeleteBitmap()
S::Bool S::GUI::BitmapXLib::DeleteBitmap()
{
	if (bitmap != NIL)
	{
		delete [] bitmap->data;

		bitmap->data = NIL;

		XDestroyImage(bitmap);

		bitmap	     = NIL;

		size	     = Size(0, 0);
		depth	     = 0;

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

	return True;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0xbde2a
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xbde0b
movq %rax, %rdi
callq 0x561e0
movq 0x28(%rbx), %rdi
xorl %r14d, %r14d
movq %r14, 0x10(%rdi)
callq *0x60(%rdi)
movq %r14, 0x28(%rbx)
movw $0x0, 0xa(%rbx)
movb $0x0, 0xc(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/backends/xlib/bitmapxlib.cpp
// Function: smooth::GUI::BitmapXLib::SetSystemBitmap(void*)
S::Bool S::GUI::BitmapXLib::SetSystemBitmap(Void *nBitmap)
{
	if (nBitmap == GetSystemBitmap()) return True;

	if (nBitmap == NIL)
	{
		DeleteBitmap();
	}
	else
	{
		XImage	*image = (XImage *) nBitmap;

		CreateBitmap(Size(image->width, image->height), image->depth);

		memcpy(bitmap->data, image->data, size_t(image->height) * size_t(image->bytes_per_line));
	}

	return True;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x28(%rax)
cmpq %rbx, %rax
je 0xbde8b
testq %rbx, %rbx
je 0xbde82
movq (%rbx), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movl 0x28(%rbx), %edx
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq 0x28(%r14), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rbx), %rsi
movslq 0x4(%rbx), %rax
movslq 0x2c(%rbx), %rdx
imulq %rax, %rdx
callq 0x552d0
jmp 0xbde8b
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/graphics/backends/xlib/bitmapxlib.cpp
// Function: smooth::GUI::BitmapXLib::SetPixel(smooth::GUI::Point const&, smooth::GUI::Color const&)
S::Bool S::GUI::BitmapXLib::SetPixel(const Point &iPoint, const Color &iColor)
{
	if (bitmap == NIL) return Error();

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

	if	(depth == 16) XPutPixel(bitmap, iPoint.x, iPoint.y, 			       ((color.GetRed() >> 3) << 11) | ((color.GetGreen() >> 2) << 5) | (color.GetBlue() >> 3));
	else if (depth == 24) XPutPixel(bitmap, iPoint.x, iPoint.y, 			       ( color.GetRed()	      << 16) | ( color.GetGreen()       << 8) | (color.GetBlue()     ));
	else if (depth == 32) XPutPixel(bitmap, iPoint.x, iPoint.y, (color.GetAlpha() << 24) | ( color.GetRed()	      << 16) | ( color.GetGreen()	<< 8) | (color.GetBlue()     ));

	return True;
}

// Assembly:
cmpq $0x0, 0x28(%rdi)
je 0xbdf73
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
movl $0x1, %edx
callq 0x57d10
movzbl 0xa(%r14), %eax
cmpl $0x20, %eax
je 0xbdf3d
cmpl $0x18, %eax
je 0xbdf11
cmpl $0x10, %eax
jne 0xbdf6c
movq 0x28(%r14), %rdi
movl (%rbx), %esi
movl 0x4(%rbx), %edx
movl 0x10(%rsp), %ecx
movl %ecx, %eax
shll $0x8, %eax
andl $0xf800, %eax           # imm = 0xF800
movl %ecx, %r8d
shrl $0x5, %r8d
andl $0x7e0, %r8d            # imm = 0x7E0
orl %eax, %r8d
shrl $0x13, %ecx
andl $0x1f, %ecx
orl %r8d, %ecx
jmp 0xbdf69
movq 0x28(%r14), %rdi
movl (%rbx), %esi
movl 0x4(%rbx), %edx
movq 0x10(%rsp), %rax
movzbl %al, %ecx
shll $0x10, %ecx
movl %eax, %r8d
andl $0xff00, %r8d           # imm = 0xFF00
orq %rcx, %r8
shrl $0x10, %eax
movzbl %al, %ecx
orq %r8, %rcx
jmp 0xbdf69
movq 0x28(%r14), %rdi
movl (%rbx), %esi
movl 0x4(%rbx), %edx
movl 0x10(%rsp), %eax
movzbl %al, %ecx
shll $0x10, %ecx
movl %eax, %r8d
andl $0xff00ff00, %r8d       # imm = 0xFF00FF00
orl %ecx, %r8d
shrl $0x10, %eax
movzbl %al, %eax
orl %r8d, %eax
movslq %eax, %rcx
callq *0x70(%rdi)
addq $0x18, %rsp
popq %rbx
popq %r14
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/clipboard/backends/xlib/clipboardxlib.cpp
// Function: smooth::GUI::ClipboardXLib::QueryAtom(X11::_XDisplay*, unsigned long, unsigned long, unsigned long) const
unsigned char *S::GUI::ClipboardXLib::QueryAtom(Display *display, X11::Window self, Atom clipboard, Atom atom) const
{
	XConvertSelection(display, clipboard, atom, atom, self, CurrentTime);
	XFlush(display);

	/* Wait for SelectionNotify event to be sent.
	 */
	XEvent	 e;

	do
	{
		XNextEvent(display, &e);

		WindowXLib	*backend = GUI::WindowXLib::GetWindowBackend(e.xany.window);

		if (backend != NIL) backend->ProcessSystemMessages(&e);
	}
	while (e.type != SelectionNotify);

	Atom		 type;
	int		 format;
	unsigned long	 items, bytes;
	unsigned char	*data = NIL;

	/* Do not get any data yet, see how much data is there.
	 */
	if (XGetWindowProperty(display, self, atom, 0, 0, 0, AnyPropertyType, &type, &format, &items, &bytes, &data) == 0)
	{
		if (data != NIL) { XFree(data); data = NIL; }

		/* Data is there!
		 */
		if (bytes > 0) XGetWindowProperty(display, self, atom, 0, bytes, 0, AnyPropertyType, &type, &format, &items, &bytes, &data);
	}

	return data;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r8, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rsi, %rdi
movq %rcx, %rsi
movq %r8, %rdx
movq %r8, %rcx
movq %r14, %r8
xorl %r9d, %r9d
callq 0x587e0
movq %r15, %rdi
callq 0x55e10
leaq 0x28(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x57ee0
movq 0x48(%rsp), %rdi
callq 0xbeb56
testq %rax, %rax
je 0xbe157
movq %rax, %rdi
movq %r12, %rsi
callq 0xbedc2
cmpl $0x1f, 0x28(%rsp)
jne 0xbe132
xorl %eax, %eax
leaq 0x8(%rsp), %rbp
movq %rax, (%rbp)
leaq 0x10(%rsp), %r13
leaq 0x20(%rsp), %r12
leaq 0x4(%rsp), %r11
leaq 0x18(%rsp), %r10
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rbp
pushq %r13
pushq %r12
pushq %r11
pushq %r10
pushq %rax
callq 0x58180
addq $0x30, %rsp
movl %eax, %ecx
movq (%rbp), %rax
testl %ecx, %ecx
jne 0xbe1fe
testq %rax, %rax
je 0xbe1c1
movq %rax, %rdi
callq 0x57e80
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %r8
testq %r8, %r8
je 0xbe1fc
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r9d, %r9d
pushq %rbp
pushq %r13
pushq %r12
leaq 0x1c(%rsp), %rax
pushq %rax
leaq 0x38(%rsp), %rax
pushq %rax
pushq $0x0
callq 0x58180
addq $0x30, %rsp
movq 0x8(%rsp), %rax
jmp 0xbe1fe
xorl %eax, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/clipboard/backends/xlib/clipboardxlib.cpp
// Function: smooth::GUI::ClipboardXLib::GetText(unsigned long) const
S::String S::GUI::ClipboardXLib::GetText(Atom clipboard) const
{
	if (window == NIL) return NIL;

	String		 text;

	X11::Window	 self  = (X11::Window) window->GetSystemWindow();
	X11::Window	 owner = XGetSelectionOwner(display, clipboard);

	if (owner != None)
	{
		unsigned char *data = QueryAtom(display, self, clipboard, XInternAtom(display, "UTF8_STRING", True));

		if (data != NIL)
		{
			text.ImportFrom("UTF-8", (char *) data);

			XFree(data);
		}
		else
		{
			unsigned char *data = QueryAtom(display, self, clipboard, XA_STRING);

			if (data != NIL)
			{
				text = (char *) data;

				XFree(data);
			}
		}
	}

	return text;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x18(%rsi), %r12
xorl %esi, %esi
callq 0x58e20
testq %r12, %r12
je 0xbe2d0
movq 0x18(%r15), %rdi
callq 0x55280
movq %rax, %r12
movq 0x10(%r15), %rdi
movq %r14, %rsi
callq 0x58510
testq %rax, %rax
je 0xbe2d0
movq 0x10(%r15), %r13
leaq 0x54d3c(%rip), %rsi     # 0x112f9a
movq %r13, %rdi
movl $0x1, %edx
callq 0x57ea0
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0xbe0f4
movq %rax, %r13
testq %rax, %rax
je 0xbe2a0
leaq 0x5404b(%rip), %rsi     # 0x1122d6
movq %rbx, %rdi
movq %r13, %rdx
callq 0x56950
movq %r13, %rdi
callq 0x57e80
jmp 0xbe2d0
movq 0x10(%r15), %rsi
movl $0x1f, %r8d
movq %r12, %rdx
movq %r14, %rcx
callq 0xbe0f4
movq %rax, %r14
testq %rax, %rax
je 0xbe2d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x55f40
movq %r14, %rdi
callq 0x57e80
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xbe2e3
jmp 0xbe2e3
jmp 0xbe2e3
movq %rax, %r14
movq %rbx, %rdi
callq 0x59200
movq %r14, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/clipboard/backends/xlib/clipboardxlib.cpp
// Function: smooth::GUI::ClipboardXLib::SetText(unsigned long, smooth::String const&)
S::Bool S::GUI::ClipboardXLib::SetText(Atom clipboard, const String &text)
{
	if (window == NIL) return False;

	X11::Window	 self	 = (X11::Window) window->GetSystemWindow();
	WindowXLib	*backend = GUI::WindowXLib::GetWindowBackend(self);

	if (backend != NIL)
	{
		if	(clipboard == XA_PRIMARY)			       backend->SetSelection(text);
		else if (clipboard == XInternAtom(display, "CLIPBOARD", True)) backend->SetClipboard(text);
	}

	XSetSelectionOwner(display, clipboard, self, CurrentTime);
	XFlush(display);

	return True;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rbx
testq %rbx, %rbx
je 0xbe380
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq %rbx, %rdi
callq 0x55280
movq %rax, %r13
movq %rax, %rdi
callq 0xbeb56
testq %rax, %rax
je 0xbe366
movq %rax, %rbp
movl $0x1b8, %ecx            # imm = 0x1B8
cmpq $0x1, %r15
je 0xbe358
movq 0x10(%r14), %rdi
leaq 0x54c62(%rip), %rsi     # 0x112fa6
movl $0x1, %edx
callq 0x57ea0
movl $0x1d0, %ecx            # imm = 0x1D0
cmpq %r15, %rax
jne 0xbe366
addq %rcx, %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x555f0
movq 0x10(%r14), %rdi
movq %r15, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x55090
movq 0x10(%r14), %rdi
callq 0x55e10
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/window/backends/xlib/windowxlib.cpp
// Function: smooth::GUI::WindowXLib::SetCursor(smooth::GUI::Cursor*, smooth::GUI::Point const&)
S::Void S::GUI::WindowXLib::SetCursor(Cursor *cursor, const Point &point)
{
	WindowXLib	*window = GetWindowBackend((X11::Window) cursor->GetContainerWindow()->GetSystemWindow());

	if (window != NIL)
	{
		/* Remove active cursor.
		 */
		if (cursor != activeCursor && activeCursor != NIL) RemoveCursor(activeCursor);

		/* Create input context.
		 */
		window->CreateInputContext();

		if (window->ic != NIL)
		{
			/* Move input window to cursor position.
			 */
			XMoveWindow(window->display, window->iwnd, point.x - 3, point.y + cursor->GetFont().GetScaledTextSizeY() + 1);

			/* Set input focus on input window.
			 */
			X11::Window	 focusWnd = None;
			int		 revertTo = RevertToNone;

			XGetInputFocus(window->display, &focusWnd, &revertTo);

			if (focusWnd != window->iwnd)
			{
				XSetInputFocus(window->display, window->iwnd, RevertToParent, CurrentTime);
				XFlush(window->display);
			}

			/* Set current input context.
			 */
			XSetICFocus(window->ic);
		}
	}

	activeCursor	= cursor;
	activeCursorPos = point;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x559e0
movq %rax, %rdi
callq 0x55280
movq %rax, %rdi
callq 0xbeb56
testq %rax, %rax
je 0xbe5ec
movq %rax, %r15
movq 0xb86f0(%rip), %rdi     # 0x176c08
cmpq %r14, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0xbe52d
callq 0xbe60c
movq %r15, %rdi
callq 0xc21ec
cmpq $0x0, 0x148(%r15)
je 0xbe5ec
movq 0x120(%r15), %rax
movq %rax, (%rsp)
movq 0x150(%r15), %r13
movl (%rbx), %ebp
movl 0x4(%rbx), %r12d
addl $-0x3, %ebp
movq (%r14), %rax
movq %r14, %rdi
callq *0xe8(%rax)
movq 0xad847(%rip), %rsi     # 0x16bdb8
movq %rax, %rdi
callq 0x57680
leal (%r12,%rax), %ecx
incl %ecx
movq (%rsp), %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0x550b0
leaq 0x10(%rsp), %r12
movq $0x0, (%r12)
leaq 0xc(%rsp), %rdx
movl $0x0, (%rdx)
movq 0x120(%r15), %rdi
movq %r12, %rsi
callq 0x55a20
movq 0x150(%r15), %rsi
cmpq %rsi, (%r12)
je 0xbe5e0
movq 0x120(%r15), %rdi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0x56aa0
movq 0x120(%r15), %rdi
callq 0x55e10
movq 0x148(%r15), %rdi
callq 0x556e0
movq %r14, 0xb8615(%rip)     # 0x176c08
movq (%rbx), %rax
movq %rax, 0xb8613(%rip)     # 0x176c10
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/window/backends/xlib/windowxlib.cpp
// Function: smooth::GUI::WindowXLib::RemoveCursor(smooth::GUI::Cursor*)
S::Void S::GUI::WindowXLib::RemoveCursor(Cursor *cursor)
{
	if (activeCursor != cursor) return;

	WindowXLib	*window = GetWindowBackend((X11::Window) cursor->GetContainerWindow()->GetSystemWindow());

	if (window != NIL && window->ic != NIL)
	{
		/* Destroy input context.
		 */
		window->DestroyInputContext();

		/* Clear preediting area.
		 */
		if (activeCursor->IsVisible())
		{
			Rect	 rect = Rect::OverlapRect(Rect(activeCursorPos - Point(1, 1), activeCursor->GetRealSize()), Rect(activeCursor->GetRealPosition(), activeCursor->GetRealSize()));

			activeCursor->SetIMECursor(True);

			window->drawSurface->StartPaint(rect);
			window->drawSurface->Box(rect, activeCursor->GetBackgroundColor(), Rect::Filled);

			activeCursor->Paint(SP_PAINT);

			window->drawSurface->EndPaint();

			activeCursor->SetIMECursor(False);
		}
	}

	activeCursor	= NIL;
	activeCursorPos = Point();
}

// Assembly:
cmpq %rdi, 0xb85f5(%rip)     # 0x176c08
je 0xbe616
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
callq 0x559e0
movq %rax, %rdi
callq 0x55280
movq %rax, %rdi
callq 0xbeb56
testq %rax, %rax
je 0xbe782
movq %rax, %rbx
cmpq $0x0, 0x148(%rax)
je 0xbe782
movq %rbx, %rdi
callq 0xc107e
movq 0xb85a8(%rip), %rdi     # 0x176c08
movq (%rdi), %rax
callq *0x90(%rax)
testb %al, %al
je 0xbe782
movl 0xb8598(%rip), %r14d    # 0x176c10
leal -0x1(%r14), %ebp
movl 0xb8591(%rip), %r15d    # 0x176c14
leal -0x1(%r15), %r12d
movq 0xb857a(%rip), %rdi     # 0x176c08
movq (%rdi), %rax
callq *0x50(%rax)
leal (%r14,%rax), %ecx
decl %ecx
shrq $0x20, %rax
movq %rsp, %r14
movl %ebp, (%r14)
movl %r12d, 0x4(%r14)
movl %ecx, 0x8(%r14)
leal -0x1(%r15,%rax), %eax
movl %eax, 0xc(%r14)
movq 0xb854c(%rip), %rdi     # 0x176c08
movq (%rdi), %rax
callq *0x48(%rax)
movq %rax, %r15
movq %rax, %r12
shrq $0x20, %r12
movq 0xb8535(%rip), %rdi     # 0x176c08
movq (%rdi), %rax
callq *0x50(%rax)
leal (%rax,%r15), %ecx
shrq $0x20, %rax
leaq 0x20(%rsp), %rsi
movl %r15d, (%rsi)
movl %r12d, 0x4(%rsi)
movl %ecx, 0x8(%rsi)
addl %r12d, %eax
movl %eax, 0xc(%rsi)
movq %r14, %rdi
callq 0x58af0
leaq 0x10(%rsp), %r15
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
movq 0xb84f7(%rip), %rdi     # 0x176c08
movl $0x1, %esi
callq 0x57c40
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x55160
movq 0x10(%rbx), %r12
movq 0xb84d6(%rip), %rdi     # 0x176c08
movq (%rdi), %rax
callq *0x140(%rax)
movq 0xad866(%rip), %rcx     # 0x16bfa8
movl (%rcx), %ecx
movq $0x0, (%r14)
movq %rsp, %r8
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x57930
movq 0xb84a5(%rip), %rdi     # 0x176c08
movq (%rdi), %rax
xorl %esi, %esi
callq *0x78(%rax)
movq 0x10(%rbx), %rdi
callq 0x58780
movq 0xb848d(%rip), %rdi     # 0x176c08
xorl %esi, %esi
callq 0x57c40
xorl %eax, %eax
movq %rax, 0xb847d(%rip)     # 0x176c08
movq %rax, 0xb847e(%rip)     # 0x176c10
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/window/backends/xlib/windowxlib.cpp
// Function: smooth::GUI::WindowXLib::WindowXLib(void*)
S::GUI::WindowXLib::WindowXLib(Void *iWindow)
{
	type		= WINDOW_XLIB;

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

	if (display == NIL)
	{
		fprintf(stderr, "Error: Unable to open display.\n");

		exit(EXIT_FAILURE);
	}

	wnd		= None;
	oldwnd		= None;

	ic		= NIL;
	iwnd		= None;

	id		= windowBackends.Add(this);

	minSize		= Size(160, 24);

	maximized	= False;

	fontSize	= Surface().GetSurfaceDPI() / 96.0;

	flags		= 0;

	sysIcon		= NIL;
	sysIconSize	= 0;

	xdndTimeStamp	= CurrentTime;
	acceptDrop	= False;
	enableDropFiles	= False;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %esi, %esi
callq 0x9a1bc
leaq 0xab28c(%rip), %rax     # 0x169a48
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1a4(%rbx)
leaq 0x1b8(%rbx), %r14
movups %xmm0, 0x180(%rbx)
movups %xmm0, 0x190(%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x58e20
leaq 0x1d0(%rbx), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x58e20
movw $0x2, 0x8(%rbx)
callq 0xbcfc0
movq %rax, 0x120(%rbx)
callq 0xbcfc8
movq %rax, 0x128(%rbx)
cmpq $0x0, 0x120(%rbx)
je 0xbe8dd
xorps %xmm0, %xmm0
movups %xmm0, 0x148(%rbx)
movups %xmm0, 0x138(%rbx)
leaq 0x8(%rsp), %rsi
movq %rbx, (%rsi)
leaq 0xb836b(%rip), %rdi     # 0x176bb0
callq 0x5aed8
movl %eax, 0x130(%rbx)
movabsq $0x18000000a0, %rax     # imm = 0x18000000A0
movq %rax, 0x190(%rbx)
movb $0x0, 0x1a0(%rbx)
leaq 0x10(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x57150
leaq 0x8(%rsp), %rdi
callq 0x58930
cwtl
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x34e1e(%rip), %xmm0    # 0xf36b8
movsd %xmm0, 0x178(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x57b20
xorl %eax, %eax
movl %eax, 0x1b4(%rbx)
movq %rax, 0x158(%rbx)
movl %eax, 0x160(%rbx)
movq %rax, 0x168(%rbx)
movw $0x0, 0x170(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x59220
movq %rax, %r12
leaq 0x8(%rsp), %rdi
callq 0x57b20
jmp 0xbe902
jmp 0xbe8ff
jmp 0xbe8ff
movq %rax, %r12
jmp 0xbe90a
movq %rax, %r12
jmp 0xbe912
movq %rax, %r12
movq %r15, %rdi
callq 0x59200
movq %r14, %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x9a31e
movq %r12, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/window/backends/xlib/windowxlib.cpp
// Function: smooth::GUI::WindowXLib::~WindowXLib()
S::GUI::WindowXLib::~WindowXLib()
{
	if (sysIcon != NIL)
	{
		delete [] sysIcon;

		sysIcon	    = NIL;
		sysIconSize = 0;
	}

	windowBackends.Remove(id);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xab11b(%rip), %rax     # 0x169a48
movq %rax, (%rdi)
movq 0x158(%rdi), %rdi
testq %rdi, %rdi
je 0xbe956
callq 0x561e0
movq $0x0, 0x158(%rbx)
movl $0x0, 0x160(%rbx)
movl 0x130(%rbx), %esi
leaq 0xb824d(%rip), %rdi     # 0x176bb0
callq 0x58bb0
leaq 0x1d0(%rbx), %rdi
callq 0x59200
leaq 0x1b8(%rbx), %rdi
callq 0x59200
movq %rbx, %rdi
popq %rbx
jmp 0x9a31e
movq %rax, %rdi
callq 0x5aeae
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/window/backends/xlib/windowxlib.cpp
// Function: smooth::GUI::WindowXLib::UpdateWMNormalHints()
S::Void S::GUI::WindowXLib::UpdateWMNormalHints()
{
	if (wnd == None) return;

	XSizeHints	 normal;

	normal.flags	   = (minSize != Size() ? PMinSize : 0) |
			     (maxSize != Size() ? PMaxSize : 0) |
			     (flags & WF_NORESIZE ? PPosition | PSize : 0);

	normal.x	   = pos.x;
	normal.y	   = pos.y;

	normal.width	   = Math::Round(size.cx * fontSize) + sizeModifier.cx;
	normal.height	   = Math::Round(size.cy * fontSize) + sizeModifier.cy;

	normal.min_width   = Math::Round(minSize.cx * fontSize) + sizeModifier.cx;
	normal.min_height  = Math::Round(minSize.cy * fontSize) + sizeModifier.cy;

	normal.max_width   = Math::Round(maxSize.cx * fontSize) + sizeModifier.cx;
	normal.max_height  = Math::Round(maxSize.cy * fontSize) + sizeModifier.cy;

	XSetWMNormalHints(display, wnd, &normal);
}

// Assembly:
movq 0x138(%rdi), %rsi
testq %rsi, %rsi
je 0xbeb4d
subq $0x58, %rsp
xorl %ecx, %ecx
testb $0x4, 0x1b4(%rdi)
movl $0xc, %eax
cmoveq %rcx, %rax
movq 0x180(%rdi), %rcx
leaq 0x8(%rsp), %rdx
movq %rcx, 0x8(%rdx)
movdqu 0x188(%rdi), %xmm5
movq 0x18(%rdi), %xmm0
pshufd $0xee, %xmm5, %xmm1     # xmm1 = xmm5[2,3,2,3]
cvtdq2pd %xmm1, %xmm8
pshufd $0x44, %xmm0, %xmm6     # xmm6 = xmm0[0,1,0,1]
cvtdq2pd %xmm5, %xmm9
movsd 0x178(%rdi), %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm1, %xmm9
mulpd %xmm1, %xmm8
xorpd %xmm2, %xmm2
movapd %xmm8, %xmm7
cmpltpd %xmm2, %xmm7
movapd %xmm9, %xmm10
cmpltpd %xmm2, %xmm10
movapd 0x34af8(%rip), %xmm4    # 0xf3530
movapd 0x34b00(%rip), %xmm3    # 0xf3540
movapd %xmm3, %xmm11
andpd %xmm10, %xmm11
andnpd %xmm4, %xmm10
orpd %xmm11, %xmm10
movapd %xmm3, %xmm11
andpd %xmm7, %xmm11
andnpd %xmm4, %xmm7
orpd %xmm11, %xmm7
addpd %xmm8, %xmm7
addpd %xmm9, %xmm10
cvttsd2si %xmm10, %rcx
movq %rcx, %xmm8
unpckhpd %xmm10, %xmm10          # xmm10 = xmm10[1,1]
cvttsd2si %xmm10, %rcx
movq %rcx, %xmm9
punpcklqdq %xmm9, %xmm8    # xmm8 = xmm8[0],xmm9[0]
cvttsd2si %xmm7, %rcx
movq %rcx, %xmm9
unpckhpd %xmm7, %xmm7            # xmm7 = xmm7[1,1]
cvttsd2si %xmm7, %rcx
movq %rcx, %xmm7
punpcklqdq %xmm7, %xmm9    # xmm9 = xmm9[0],xmm7[0]
shufps $0x88, %xmm9, %xmm8     # xmm8 = xmm8[0,2],xmm9[0,2]
paddd %xmm6, %xmm8
movdqu %xmm8, 0x10(%rdx)
movsd 0x198(%rdi), %xmm6
cvtdq2pd %xmm6, %xmm7
shufps $0xb1, %xmm5, %xmm6     # xmm6 = xmm6[1,0],xmm5[3,2]
pcmpeqd %xmm2, %xmm6
movmskps %xmm6, %ecx
xorl $0xf, %ecx
xorl %r8d, %r8d
testb $0xc, %cl
setne %r8b
shll $0x4, %r8d
xorl %r9d, %r9d
testb $0x3, %cl
setne %r9b
shll $0x5, %r9d
orl %r8d, %r9d
orq %rax, %r9
movq %r9, (%rdx)
mulpd %xmm1, %xmm7
movapd %xmm7, %xmm1
cmpltpd %xmm2, %xmm1
andpd %xmm1, %xmm3
andnpd %xmm4, %xmm1
orpd %xmm3, %xmm1
addpd %xmm7, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
cvttsd2si %xmm1, %rax
movq %rax, %xmm1
punpckldq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
paddd %xmm0, %xmm2
movq %xmm2, 0x20(%rdx)
movq 0x120(%rdi), %rdi
callq 0x565e0
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/window/backends/xlib/windowxlib.cpp
// Function: smooth::GUI::WindowXLib::GetWindowBackend(unsigned long)
S::GUI::WindowXLib *S::GUI::WindowXLib::GetWindowBackend(X11::Window wnd)
{
	if (wnd == None) return NIL;

	foreach (WindowXLib *window, windowBackends)
	{
		if (window == NIL) continue;

		if (window->wnd    == wnd ||
		    window->iwnd   == wnd ||
		    window->oldwnd == wnd) return window;
	}

	return NIL;
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0xbebba
cmpl $0x0, 0xb8054(%rip)     # 0x176bb8
jle 0xbebba
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0xb8037(%rip), %r14     # 0x176bb0
incl %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x60a9a
movq (%rax), %rax
testq %rax, %rax
je 0xbeba8
cmpq %rbx, 0x138(%rax)
je 0xbebb6
cmpq %rbx, 0x150(%rax)
je 0xbebb6
cmpq %rbx, 0x140(%rax)
je 0xbebb6
movl 0xb800a(%rip), %eax     # 0x176bb8
decl %eax
cmpl %eax, %ebp
jl 0xbeb79
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/gui/window/backends/xlib/windowxlib.cpp
// Function: smooth::GUI::WindowXLib::IsModalWindowActive()
S::Bool S::GUI::WindowXLib::IsModalWindowActive()
{
	/* Ignore modal windows if this is a topmost window.
	 */
	if (flags & WF_TOPMOST) return False;

	/* Look for modal windows opened after ourselves.
	 */
	foreachreverse (WindowXLib *backend, windowBackends)
	{
		if	(backend == this)				    return False;
		else if (backend->wnd != None && backend->flags & WF_MODAL) return True;
	}

	return False;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testb $0x2, 0x1b4(%rdi)
sete %al
movl 0xb6678(%rip), %r15d    # 0x176bb8
testl %r15d, %r15d
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xc058e
movq %rdi, %rbx
incl %r15d
leaq 0xb6656(%rip), %r14     # 0x176bb0
leal -0x2(%r15), %esi
movq %r14, %rdi
callq 0x60a9a
movq (%rax), %rax
cmpq %rbx, %rax
je 0xc0592
cmpq $0x0, 0x138(%rax)
je 0xc0581
testb $0x1, 0x1b4(%rax)
jne 0xc0598
decl %r15d
cmpl $0x1, %r15d
ja 0xc055a
xorl %eax, %eax
jmp 0xc059c
xorl %eax, %eax
jmp 0xc059e
movb $0x1, %al
xorl %ecx, %ecx
jmp 0xc059c
movb $0x1, %al
movb $0x1, %cl
andb %cl, %al
popq %rbx
popq %r14
popq %r15
retq