LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::NewEntry()
Void Translator::NewEntry()
{
	Int	 id = 1;

	if (entries.Length() > 7)
	{
		StringItem	*entry = (StringItem *) entries.GetLast();

		id = Math::Max(entry->GetID(), 0) + 1;
	}

	text_id->Activate();
	edit_id->Activate();
	text_original->Activate();
	edit_original->Activate();
	text_translated->Activate();
	edit_translated->Activate();
	button_save->Activate();
	button_remove->Activate();
	button_copy->Activate();

	menu_entry->GetNthEntry(2)->Activate();
	menu_entry->GetNthEntry(3)->Activate();

	text_original->SetText("Original:");
	text_translated->SetText("Translation:");

	edit_id->SetText(String::FromInt(id));
	edit_original->SetText(NIL);
	edit_translated->SetText(NIL);

	modified = True;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x8, 0x6c0(%rdi)
jl 0xdb48
leaq 0x6b8(%rbx), %rdi
callq 0x11c9c
movq (%rax), %rax
movl 0x630(%rax), %eax
xorl %r14d, %r14d
testl %eax, %eax
cmovgl %eax, %r14d
incl %r14d
jmp 0xdb4c
pushq $0x1
popq %r14
movq 0x640(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq 0x648(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq 0x650(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq 0x658(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq 0x660(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq 0x668(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq 0x670(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq 0x678(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq 0x680(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq 0x5e0(%rbx), %rdi
movq (%rdi), %rax
pushq $0x2
popq %rsi
callq *0x180(%rax)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x68(%rcx)
movq 0x5e0(%rbx), %rdi
movq (%rdi), %rax
pushq $0x3
popq %rsi
callq *0x180(%rax)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x68(%rcx)
movq 0x650(%rbx), %r15
leaq 0x47b7(%rip), %rsi      # 0x123be
movq %rsp, %r12
movq %r12, %rdi
callq 0x8800
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0xa0(%rax)
movq %rsp, %rdi
callq 0x8990
movq 0x660(%rbx), %r15
leaq 0x4791(%rip), %rsi      # 0x123c8
movq %rsp, %r12
movq %r12, %rdi
callq 0x8800
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0xa0(%rax)
movq %rsp, %rdi
callq 0x8990
movq 0x648(%rbx), %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x8220
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0xa0(%rax)
movq %rsp, %rdi
callq 0x8990
movq 0x658(%rbx), %r14
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x8480
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0xa0(%rax)
movq %rsp, %rdi
callq 0x8990
movq 0x668(%rbx), %r14
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x8480
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0xa0(%rax)
movq %rsp, %rdi
callq 0x8990
movb $0x1, 0x770(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xdcf6
jmp 0xdcf6
jmp 0xdcf6
jmp 0xdcf6
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8990
movq %rbx, %rdi
callq 0x8290
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::RemoveEntry()
Void Translator::RemoveEntry()
{
	/* Get selected entry.
	 */
	StringItem	*entry = NIL;

	if (edit_filter->GetText() == NIL) entry = (StringItem *) GetSelectedEntry(list_entries);
	else				   entry = (StringItem *) GetSelectedEntry(list_filtered);

	if (entry == NIL) return;

	/* Find list corresponding to selected entry.
	 */
	Int	 id   = entry->GetID();
	List	*list = GetEntryList(list_entries, id);

	entry = (StringItem *) entries.Get(id);

	/* Remove entry.
	 */
	entries.Remove(id);

	list->Remove(entry);

	if (createdEntries.Get(id) != NIL)
	{
		DeleteObject(entry);

		createdEntries.Remove(id);
	}

	SelectEntry(NIL);

	if (edit_filter->GetText() != NIL) FilterEntries();
	else				   list_entries->Paint(SP_PAINT);

	modified = True;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x5f0(%rdi), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
movq %rax, %rdi
xorl %esi, %esi
callq 0x84e0
xorb $0x1, %al
movzbl %al, %eax
movq 0x600(%rbx,%rax,8), %rsi
movq %rbx, %rdi
callq 0x10c1c
testq %rax, %rax
je 0xde02
movl 0x630(%rax), %ebp
movq 0x600(%rbx), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x10ca4
movq %rax, %r15
leaq 0x6b8(%rbx), %r12
movq %r12, %rdi
movl %ebp, %esi
callq 0xab44
movq (%rax), %r14
movq %r12, %rdi
movl %ebp, %esi
callq 0x8930
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x38(%rax)
leaq 0x710(%rbx), %r15
movq %r15, %rdi
movl %ebp, %esi
callq 0xab44
cmpq $0x0, (%rax)
je 0xddba
movq %r14, %rdi
callq 0x8960
movq %r15, %rdi
movl %ebp, %esi
callq 0x8930
movq %rbx, %rdi
xorl %esi, %esi
callq 0xd0a2
movq 0x5f0(%rbx), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
movq %rax, %rdi
xorl %esi, %esi
callq 0x86f0
testb %al, %al
je 0xddec
movq %rbx, %rdi
callq 0xd576
jmp 0xddfb
movq 0x600(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x78(%rax)
movb $0x1, 0x770(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::OpenFile()
Void Translator::OpenFile()
{
	if (!ExitProc()) return;

	FileSelection	 dialog;

	dialog.SetParentWindow(wnd);

	dialog.AddFilter("XML Language Files", "*.xml");
	dialog.AddFilter("All Files", "*.*");

	if (dialog.ShowDialog() == Success())
	{
		OpenFileName(dialog.GetFileName());
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x778, %rsp            # imm = 0x778
movq %rdi, %rbx
callq 0xf284
testb %al, %al
je 0xec69
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x8820
movq 0x5b8(%rbx), %rsi
movq %r14, %rdi
callq 0x80f0
leaq 0x38de(%rip), %rsi      # 0x1246d
leaq 0x8(%rsp), %rdi
callq 0x8800
leaq 0x38e0(%rip), %rsi      # 0x12480
leaq 0x20(%rsp), %rdi
callq 0x8800
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x8230
leaq 0x20(%rsp), %rdi
callq 0x8990
leaq 0x8(%rsp), %rdi
callq 0x8990
leaq 0x38ad(%rip), %rsi      # 0x12486
leaq 0x8(%rsp), %rdi
callq 0x8800
leaq 0x38a6(%rip), %rsi      # 0x12490
leaq 0x20(%rsp), %rdi
callq 0x8800
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x8230
leaq 0x20(%rsp), %rdi
callq 0x8990
leaq 0x8(%rsp), %rdi
callq 0x8990
leaq 0x38(%rsp), %rdi
callq 0x8370
movq 0xa3a3(%rip), %rcx      # 0x18fd0
addq $0x10, %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
andl $0x0, 0x8(%rsi)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
testb %al, %al
je 0xec5f
leaq 0x38(%rsp), %rdi
callq 0x8100
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf426
leaq 0x38(%rsp), %rdi
callq 0x8510
addq $0x778, %rsp            # imm = 0x778
popq %rbx
popq %r14
retq
jmp 0xec9c
jmp 0xec7c
jmp 0xec8b
jmp 0xec9c
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x8990
jmp 0xec8e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8990
jmp 0xec9f
jmp 0xec9c
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x8510
movq %rbx, %rdi
callq 0x8290
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::ExitProc()
Bool Translator::ExitProc()
{
	if (entries.Length() == 0) return True;

	if (!modified)
	{
		CloseFile();

		return True;
	}

	Int	 id = QuickMessage(String("Do you want to save changes in ").Append(GetShortFileName(fileName)).Append("?"), "smooth Translator", Message::Buttons::YesNoCancel, Message::Icon::Question);

	switch (id)
	{
		case Message::Button::Yes:
			SaveFile();
			CloseFile();

			return True;
		case Message::Button::No:
			CloseFile();

			return True;
		case Message::Button::Cancel:
		case Message::Button::Close:
			return False;
	}

	return True;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movb $0x1, %bl
cmpl $0x0, 0x6c0(%rdi)
je 0xf37a
movq %rdi, %r14
cmpb $0x0, 0x770(%rdi)
je 0xf372
leaq 0x3154(%rip), %rsi      # 0x12407
leaq 0x48(%rsp), %rdi
callq 0x8800
leaq 0x688(%r14), %rdx
leaq 0x30(%rsp), %rdi
callq 0xfe32
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x8170
movq %rax, %r15
leaq 0x3140(%rip), %rsi      # 0x12427
leaq 0x18(%rsp), %rdi
callq 0x8800
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x8170
movq %rax, %r15
leaq 0x2fdf(%rip), %rsi      # 0x122e7
movq %rsp, %rdi
callq 0x8800
movq %rsp, %rsi
pushq $0x3
popq %rdx
movq %r15, %rdi
movl $0x7f02, %ecx           # imm = 0x7F02
callq 0x8350
movl %eax, %r15d
movq %rsp, %rdi
callq 0x8990
leaq 0x18(%rsp), %rdi
callq 0x8990
leaq 0x30(%rsp), %rdi
callq 0x8990
leaq 0x48(%rsp), %rdi
callq 0x8990
addl $-0x2, %r15d
cmpl $0x6, %r15d
ja 0xf37a
leaq 0x2f5b(%rip), %rax      # 0x122b8
movslq (%rax,%r15,4), %rcx
addq %rax, %rcx
jmpq *%rcx
xorl %ebx, %ebx
jmp 0xf37a
movq %r14, %rdi
callq 0xecb2
movq %r14, %rdi
callq 0xfbd8
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8990
jmp 0xf398
jmp 0xf395
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x8990
jmp 0xf3a9
jmp 0xf3a6
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x8990
leaq 0x48(%rsp), %rdi
callq 0x8990
movq %rbx, %rdi
callq 0x8290
movq %rax, %rbx
jmp 0xf3b3
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::OnChangeSize(smooth::GUI::Size const&)
Void Translator::OnChangeSize(const Size &size)
{
	Size	 clientSize  = wnd->GetClientRect().GetSize();

	Float	 splitFactor = this->splitFactor;
	Int	 splitterPos = Float(clientSize.cy) * splitFactor;

	updateSplitter = True;

	OnDragSplitter(splitterPos);

	this->splitFactor = splitFactor;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x5b8(%rdi), %rdi
callq 0x8630
shrq $0x20, %rdx
shrq $0x20, %rax
subl %eax, %edx
movsd 0x620(%rbx), %xmm1
movsd %xmm1, 0x8(%rsp)
cvtsi2sd %edx, %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %esi
movb $0x1, 0x628(%rbx)
movq %rbx, %rdi
callq 0xd812
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x620(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::~Translator()
Translator::~Translator()
{
	CloseFile();

	DeleteObject(title);
	DeleteObject(wnd);
	DeleteObject(menubar);
	DeleteObject(menu_file);
	DeleteObject(menu_entry);
	DeleteObject(statusbar);

	DeleteObject(text_filter);
	DeleteObject(edit_filter);
	DeleteObject(button_clear);

	DeleteObject(list_entries);
	DeleteObject(list_filtered);

	DeleteObject(droparea);

	DeleteObject(splitter);

	DeleteObject(layer_edit);

	DeleteObject(text_id);
	DeleteObject(edit_id);
	DeleteObject(text_original);
	DeleteObject(edit_original);
	DeleteObject(text_translated);
	DeleteObject(edit_translated);
	DeleteObject(button_save);
	DeleteObject(button_remove);
	DeleteObject(button_new);
	DeleteObject(button_copy);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x8e11(%rip), %rax      # 0x18880
movq %rax, (%rdi)
callq 0xfbd8
movq 0x5c0(%rbx), %rdi
callq 0x8960
movq 0x5b8(%rbx), %rdi
callq 0x8960
movq 0x5c8(%rbx), %rdi
callq 0x8960
movq 0x5d8(%rbx), %rdi
callq 0x8960
movq 0x5e0(%rbx), %rdi
callq 0x8960
movq 0x5d0(%rbx), %rdi
callq 0x8960
movq 0x5e8(%rbx), %rdi
callq 0x8960
movq 0x5f0(%rbx), %rdi
callq 0x8960
movq 0x5f8(%rbx), %rdi
callq 0x8960
movq 0x600(%rbx), %rdi
callq 0x8960
movq 0x608(%rbx), %rdi
callq 0x8960
movq 0x610(%rbx), %rdi
callq 0x8960
movq 0x618(%rbx), %rdi
callq 0x8960
movq 0x630(%rbx), %rdi
callq 0x8960
movq 0x640(%rbx), %rdi
callq 0x8960
movq 0x648(%rbx), %rdi
callq 0x8960
movq 0x650(%rbx), %rdi
callq 0x8960
movq 0x658(%rbx), %rdi
callq 0x8960
movq 0x660(%rbx), %rdi
callq 0x8960
movq 0x668(%rbx), %rdi
callq 0x8960
movq 0x670(%rbx), %rdi
callq 0x8960
movq 0x678(%rbx), %rdi
callq 0x8960
movq 0x638(%rbx), %rdi
callq 0x8960
movq 0x680(%rbx), %rdi
callq 0x8960
leaq 0x710(%rbx), %rdi
callq 0x112a8
leaq 0x6b8(%rbx), %rdi
callq 0x112a8
leaq 0x6a0(%rbx), %rdi
callq 0x8990
leaq 0x688(%rbx), %rdi
callq 0x8990
movq %rbx, %rdi
popq %rbx
jmp 0x84a0
movq %rax, %rdi
callq 0x9e6f
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::ClearFilter(smooth::GUI::List*)
Void Translator::ClearFilter(List *list)
{
	/* Recursively clear this and subordinate sections.
	 */
	for (Int i = list->Length() - 1; i >= 0; i--)
	{
		ListEntry	*entry = list->GetNthEntry(i);

		if (entry->GetObjectType() == Tree::classID) ClearFilter(((Tree *) entry)->GetList());

		list->Remove(entry);

		delete entry;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x178(%rax)
movl %eax, %ebp
movq 0x90c1(%rip), %rax      # 0x18f88
movswl (%rax), %r15d
testl %ebp, %ebp
jle 0xff1a
decl %ebp
movq (%rbx), %rax
movq %rbx, %rdi
movl %ebp, %esi
callq *0x180(%rax)
movq %rax, %r12
leaq 0x20(%rax), %rdi
movl %r15d, %esi
callq 0x82d0
testb %al, %al
je 0xff02
leaq 0x630(%r12), %rsi
movq %r14, %rdi
callq 0xfea4
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
callq *0x38(%rax)
movq (%r12), %rax
movq %r12, %rdi
callq *0x10(%rax)
jmp 0xfecb
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::OpenTemplate(smooth::String const&)
Int Translator::OpenTemplate(const String &fileName)
{
	if (!File(fileName).Exists()) return Error();

	XML::Document	 doc;

	if (doc.LoadFile(fileName) == Error()) return Error();

	XML::Node	*data = doc.GetRootNode()->GetNodeByName("data");

	dataSection->Parse(data, list_entries, entries);

	return Success();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x8480
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x8660
leaq 0x18(%rsp), %rdi
callq 0x8730
movl %eax, %ebp
leaq 0x18(%rsp), %rdi
callq 0x8250
movq %rsp, %rdi
callq 0x8990
testb %bpl, %bpl
je 0xffe7
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x8310
movq %r15, %rdi
movq %r14, %rsi
callq 0x80c0
cmpl $-0x1, %eax
je 0xffec
leaq 0x18(%rsp), %rdi
callq 0x8260
movq %rax, %r14
leaq 0x24ef(%rip), %rsi      # 0x12494
movq %rsp, %rdi
callq 0x8800
movq %rsp, %rsi
movq %r14, %rdi
callq 0x86a0
movq %rax, %r14
movq %rsp, %rdi
callq 0x8990
movq 0x600(%rbx), %rdx
movq 0x768(%rbx), %rdi
addq $0x6b8, %rbx            # imm = 0x6B8
xorl %ebp, %ebp
movq %r14, %rsi
movq %rbx, %rcx
callq 0x8f50
jmp 0xffef
pushq $-0x1
popq %rbp
jmp 0xfff9
pushq $-0x1
popq %rbp
leaq 0x18(%rsp), %rdi
callq 0x8500
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8990
jmp 0x1001a
jmp 0x10017
jmp 0x10017
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x8500
jmp 0x10040
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x8250
jmp 0x10038
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8990
movq %rbx, %rdi
callq 0x8290
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::ReplaceLineEndings(smooth::String const&)
Void Translator::ReplaceLineEndings(const String &file)
{
	String::InputFormat	 inputFormat("UTF-8");
	String::OutputFormat	 outputFormat("UTF-8");

	IO::InStream	 in(IO::STREAM_FILE, file, IO::IS_READ);

	String		 xmlString = in.InputString(in.Size());

	/* Replace line endings.
	 */
	xmlString.Replace("\n", "&#10;");
	xmlString.Replace(">&#10;", ">\n");

	IO::OutStream	 out(IO::STREAM_FILE, file, IO::OS_REPLACE);

	out.OutputString(xmlString);

	out.Close();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %rsi, %rbx
leaq 0x1e31(%rip), %r14      # 0x12503
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x1139c
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x113e6
leaq 0x170(%rsp), %rdi
pushq $0x3
popq %rsi
pushq $0x2
popq %rcx
movq %rbx, %rdx
callq 0x8400
cmpw $0x0, 0x178(%rsp)
je 0x10716
movl 0x180(%rsp), %edx
jmp 0x10723
movw $0x5, 0x268(%rsp)
pushq $-0x1
popq %rdx
leaq 0x20(%rsp), %rdi
leaq 0x170(%rsp), %rsi
callq 0x8900
leaq 0x1df5(%rip), %rsi      # 0x12531
leaq 0x68(%rsp), %rdi
callq 0x8800
leaq 0x1ddd(%rip), %rsi      # 0x1252a
leaq 0x8(%rsp), %rdi
callq 0x8800
leaq 0x20(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x82e0
leaq 0x8(%rsp), %rdi
callq 0x8990
leaq 0x68(%rsp), %rdi
callq 0x8990
leaq 0x1da3(%rip), %rsi      # 0x12529
leaq 0x68(%rsp), %rdi
callq 0x8800
leaq 0x1d99(%rip), %rsi      # 0x12530
leaq 0x8(%rsp), %rdi
callq 0x8800
leaq 0x20(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x82e0
leaq 0x8(%rsp), %rdi
callq 0x8990
leaq 0x68(%rsp), %rdi
callq 0x8990
leaq 0x68(%rsp), %rdi
pushq $0x3
popq %rsi
pushq $0x1
popq %rcx
movq %rbx, %rdx
callq 0x8890
leaq 0x68(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x85b0
leaq 0x68(%rsp), %rdi
callq 0x8690
leaq 0x68(%rsp), %rdi
callq 0x8610
leaq 0x20(%rsp), %rdi
callq 0x8990
leaq 0x170(%rsp), %rdi
callq 0x8520
leaq 0x38(%rsp), %rdi
callq 0x11430
leaq 0x50(%rsp), %rdi
callq 0x1145e
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r14
retq
jmp 0x1085b
jmp 0x1083d
jmp 0x1084c
jmp 0x1085b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8990
jmp 0x1084f
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x8990
jmp 0x1087c
movq %rax, %rbx
jmp 0x1087c
movq %rax, %rbx
jmp 0x10886
movq %rax, %rbx
jmp 0x10893
movq %rax, %rbx
jmp 0x1089d
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x8610
leaq 0x20(%rsp), %rdi
callq 0x8990
leaq 0x170(%rsp), %rdi
callq 0x8520
leaq 0x38(%rsp), %rdi
callq 0x11430
leaq 0x50(%rsp), %rdi
callq 0x1145e
movq %rbx, %rdi
callq 0x8290
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::GetSelectedEntry(smooth::GUI::List*)
ListEntry *Translator::GetSelectedEntry(List *list)
{
	/* Recursively search for the list with the selected entry.
	 */
	for (Int i = list->Length() - 1; i >= 0; i--)
	{
		ListEntry	*entry = list->GetNthEntry(i);

		if (entry->GetObjectType() == Tree::classID)
		{
			ListEntry	*selected = GetSelectedEntry(((Tree *) entry)->GetList());

			if (selected != NIL) return selected;
		}
		else if (entry->IsSelected())
		{
			return entry;
		}
	}

	return NIL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x178(%rax)
movl %eax, %ebp
movq 0x8349(%rip), %rax      # 0x18f88
movswl (%rax), %r15d
testl %ebp, %ebp
jle 0x10c90
decl %ebp
movq (%rbx), %rax
movq %rbx, %rdi
movl %ebp, %esi
callq *0x180(%rax)
movq %rax, %r12
leaq 0x20(%rax), %rdi
movl %r15d, %esi
callq 0x82d0
testb %al, %al
je 0x10c83
addq $0x630, %r12            # imm = 0x630
movq %r14, %rdi
movq %r12, %rsi
callq 0x10c1c
testq %rax, %rax
je 0x10c43
jmp 0x10c95
cmpb $0x1, 0x5b9(%r12)
jne 0x10c43
jmp 0x10c98
xorl %r12d, %r12d
jmp 0x10c98
movq %rax, %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::GetEntryList(smooth::GUI::List*, int)
List *Translator::GetEntryList(List *list, Int id)
{
	/* Recursively search for the list with the requested entry.
	 */
	for (Int i = list->Length() - 1; i >= 0; i--)
	{
		ListEntry	*entry = list->GetNthEntry(i);

		if (entry->GetObjectType() == Tree::classID)
		{
			List	*selected = GetEntryList(((Tree *) entry)->GetList(), id);

			if (selected != NIL) return selected;
		}
		else if (entry->GetObjectType() == StringItem::classID)
		{
			if (((StringItem *) entry)->GetID() == id) return list;
		}
	}

	return NIL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x178(%rax)
movl %eax, %r15d
movq 0x82b6(%rip), %rax      # 0x18f88
leaq 0x8857(%rip), %rcx      # 0x19530
movswl (%rax), %r12d
movswl (%rcx), %eax
movl %eax, 0xc(%rsp)
testl %r15d, %r15d
jle 0x10d49
decl %r15d
movq (%rbx), %rax
movq %rbx, %rdi
movl %r15d, %esi
callq *0x180(%rax)
movq %rax, %r14
leaq 0x20(%rax), %r13
movq %r13, %rdi
movl %r12d, %esi
callq 0x82d0
testb %al, %al
je 0x10d2e
addq $0x630, %r14            # imm = 0x630
movq 0x10(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x10ca4
testq %rax, %rax
je 0x10ce4
jmp 0x10d4d
movq %r13, %rdi
movl 0xc(%rsp), %esi
callq 0x82d0
testb %al, %al
je 0x10ce4
cmpl %ebp, 0x630(%r14)
jne 0x10ce4
jmp 0x10d50
xorl %ebx, %ebx
jmp 0x10d50
movq %rax, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/signals/signal.h
// Function: int smooth::Signal1<void, smooth::String const&>::Connect<Translator, Translator, void>(void (Translator::*)(), Translator*)
Int Connect(slotReturnTYPE (classTYPE::*proc)(), oClassTYPE *inst)
			{
				if (slots0 == NIL)
				{
					slots0 = new Array<Void *>();
					slots0->EnableLocking();
				}

				slots0->Add(new SlotClass0<classTYPE, slotReturnTYPE>(proc, inst));

				return Success();
			}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq 0x18(%rdi), %r13
testq %r13, %r13
jne 0x10e6b
movq %rdi, %r12
pushq $0x58
popq %rdi
callq 0x8530
movq %rax, %r13
movq %rax, %rdi
callq 0xb1ce
movq %r13, 0x18(%r12)
movq %r13, %rdi
callq 0x82b0
movq 0x18(%r12), %r13
pushq $0x20
popq %rdi
callq 0x8530
leaq 0x7cb6(%rip), %rcx      # 0x18b30
movq %rcx, (%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r13, %rdi
callq 0xb4e0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r13, %rdi
callq 0x80a0
movq %rbx, %rdi
callq 0x8290
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/nonblocking/../../threads/../templates/signals/signalr.h
// Function: int smooth::SignalR0<bool>::Connect<Translator, Translator>(bool (Translator::*)(), Translator*)
Int Connect(returnTYPE (classTYPE::*proc)(SIGNALS_ARGUMENT_TYPES), oClassTYPE *inst)
			{
				if (slotsN == NIL)
				{
					slotsN = new Array<Void *>();
					slotsN->EnableLocking();
				}

				slotsN->Add(new SIGNALS_SLOT_CLASS_CLASS_NAME<classTYPE, returnTYPE SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES>(proc, inst));

				return Success();
			}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq 0x10(%rdi), %r13
testq %r13, %r13
jne 0x11a67
movq %rdi, %r12
pushq $0x58
popq %rdi
callq 0x8530
movq %rax, %r13
movq %rax, %rdi
callq 0xb1ce
movq %r13, 0x10(%r12)
movq %r13, %rdi
callq 0x82b0
movq 0x10(%r12), %r13
pushq $0x20
popq %rdi
callq 0x8530
leaq 0x728a(%rip), %rcx      # 0x18d00
movq %rcx, (%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r13, %rdi
callq 0xb4e0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r13, %rdi
callq 0x80a0
movq %rbx, %rdi
callq 0x8290
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/nonblocking/../../threads/../templates/signals/signalr.h
// Function: smooth::SignalR0<bool>::RemoveNthN(int)
Void RemoveNthN(Int n)
			{
				if (slotsN == NIL)	   return;
				if (slotsN->Length() <= n) return;

				delete (SIGNALS_SLOT_BASE_CLASS_NAME<returnTYPE SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES> *) slotsN->GetNth(n);

				slotsN->RemoveNth(n);

				if (slotsN->Length() == 0)
				{
					delete slotsN;

					slotsN = NIL;
				}
			}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x11b08
movl %esi, %ebp
cmpl %esi, 0x8(%rdi)
jle 0x11b08
movl %ebp, %esi
callq 0xa13a
movq (%rax), %rdi
testq %rdi, %rdi
je 0x11ae7
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x18(%rax)
movq 0x10(%rbx), %rdi
cmpl $0x0, 0x8(%rdi)
jne 0x11b08
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/nonblocking/../../threads/../templates/signals/signalr.h
// Function: smooth::SignalR0<bool>::RemoveNth0(int)
Void RemoveNth0(Int n)
			{
				if (slots0 == NIL)	   return;
				if (slots0->Length() <= n) return;

				delete (SlotRBase0<returnTYPE> *) slots0->GetNth(n);

				slots0->RemoveNth(n);

				if (slots0->Length() == 0)
				{
					delete slots0;

					slots0 = NIL;
				}
			}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x11b5c
movl %esi, %ebp
cmpl %esi, 0x8(%rdi)
jle 0x11b5c
movl %ebp, %esi
callq 0xa13a
movq (%rax), %rdi
testq %rdi, %rdi
je 0x11b3b
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x18(%rax)
movq 0x18(%rbx), %rdi
cmpl $0x0, 0x8(%rdi)
jne 0x11b5c
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/array/arraybackend.h
// Function: smooth::ArrayBackend<smooth::GUI::ListEntry*>::GetFirst() const
const s &GetFirst() const
			{
				ReadLock	 lock(*this);

				if (nOfEntries > 0)
				{
					const s	&entry = entries[0]->value;

					lastAccessedEntry = 0;

					return entry;
				}

				return nullValue;
			}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %rdi, (%rsp)
callq 0xa1a0
cmpl $0x0, 0x8(%r14)
jle 0x11bf4
movq 0x48(%r14), %rax
movq (%rax), %rax
movq (%rax), %rbx
andl $0x0, 0x14(%r14)
jmp 0x11bfb
leaq 0x792d(%rip), %rbx      # 0x19528
movq %rsp, %rdi
callq 0xa18c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/array/arraybackend.h
// Function: smooth::ArrayBackend<smooth::GUI::ListEntry*>::GetNext() const
const s &GetNext() const
			{
				ReadLock	 lock(*this);
				Int		 lastAccessed = lastAccessedEntry;

				if (lastAccessed < nOfEntries - 1)
				{
					const s	&entry = entries[++lastAccessed]->value;

					lastAccessedEntry = lastAccessed;

					return entry;
				}

				return nullValue;
			}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, (%rsp)
callq 0xa1a0
movslq 0x14(%rbx), %rax
movl 0x8(%rbx), %ecx
decl %ecx
cmpl %ecx, %eax
jge 0x11c81
movq 0x48(%rbx), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx,%rax,8), %r14
incq %rax
movl %eax, 0x14(%rbx)
jmp 0x11c88
leaq 0x78a0(%rip), %r14      # 0x19528
movq %rsp, %rdi
callq 0xa18c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/array/arraybackend.h
// Function: smooth::ArrayBackend<smooth::GUI::ListEntry*>::GetLast() const
const s &GetLast() const
			{
				ReadLock	 lock(*this);

				if (nOfEntries > 0)
				{
					const s	&entry = entries[nOfEntries - 1]->value;

					lastAccessedEntry = nOfEntries - 1;

					return entry;
				}

				return nullValue;
			}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, (%rsp)
callq 0xa1a0
movl 0x8(%rbx), %eax
testl %eax, %eax
jle 0x11cc5
decl %eax
movq 0x48(%rbx), %rcx
movq (%rcx), %rcx
movq (%rcx,%rax,8), %r14
movl %eax, 0x14(%rbx)
jmp 0x11ccc
leaq 0x785c(%rip), %r14      # 0x19528
movq %rsp, %rdi
callq 0xa18c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/utils.c
// Function: prepare_input
bool prepare_input(PyObject* self, PyObject* tuple, struct Input* input) {
#define automaton ((Automaton*)self)
    if (automaton->key_type == KEY_STRING) {
        input->py_word = pymod_get_string(tuple, &input->word, &input->wordlen, &input->is_copy);
        if (not input->py_word)
            return false;
    } else {
        input->is_copy = true; // we always create a copy of sequence
        input->py_word = NULL;
        if (not pymod_get_sequence(tuple, &input->word, &input->wordlen)) {
            return false;
        }
    }
#undef automaton

    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r12
cmpl $0x64, 0x18(%rdi)
jne 0x34ae
leaq 0x8(%r14), %rsi
leaq 0x18(%r14), %rcx
movq %r12, %rdi
movq %r14, %rdx
callq 0x35db
movq %rax, 0x10(%r14)
testq %rax, %rax
jne 0x3551
xorl %ebp, %ebp
jmp 0x35a4
movb $0x1, 0x18(%r14)
andq $0x0, 0x10(%r14)
movq 0x8(%r12), %rax
testb $0x4, 0xab(%rax)
je 0x35b5
movq 0x10(%r12), %r13
leaq (,%r13,4), %rdi
callq 0x3370
testq %rax, %rax
je 0x35d1
movq %rax, %rbx
movq %r14, 0x10(%rsp)
xorl %r15d, %r15d
testq %r13, %r13
movl $0x0, %r14d
movq %r13, 0x8(%rsp)
cmovgq %r13, %r14
movq 0xaa7f(%rip), %rbp      # 0xdf88
cmpq %r15, %r14
je 0x3540
movq %r12, %rdi
movq %r15, %rsi
callq 0x3140
movq (%rbp), %rsi
movq %rax, %rdi
callq 0x3060
movq %rax, %r13
cmpq $-0x1, %rax
je 0x3556
movq %r13, %rax
shrq $0x20, %rax
jne 0x3579
movl %r13d, (%rbx,%r15,4)
incq %r15
jmp 0x3509
movq 0x10(%rsp), %rax
movq %rbx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movb $0x1, %bpl
jmp 0x35a4
callq 0x31f0
testq %rax, %rax
je 0x3579
movq (%rbp), %rdi
leaq 0x4f1a(%rip), %rsi      # 0x8485
xorl %ebp, %ebp
movq %r15, %rdx
xorl %eax, %eax
callq 0x3300
jmp 0x359c
movq (%rbp), %rdi
leaq 0x4f1b(%rip), %rsi      # 0x849f
xorl %ebp, %ebp
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
movq %r15, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x3300
movq %rbx, %rdi
callq 0x3070
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xa9d4(%rip), %rax      # 0xdf90
movq (%rax), %rdi
leaq 0x4e95(%rip), %rsi      # 0x845b
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x3300
jmp 0x35a4
callq 0x30e0
jmp 0x34a7
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/utils.c
// Function: prepare_input_from_tuple
bool prepare_input_from_tuple(PyObject* self, PyObject* args, int index, struct Input* input) {
    PyObject* tuple;

    tuple = F(PyTuple_GetItem)(args, index);
    if (tuple)
        return prepare_input(self, tuple, input);
    else
        return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %rax
movq %rdi, %r14
movslq %edx, %rsi
movq %rax, %rdi
callq 0x3140
testq %rax, %rax
je 0x37a1
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x346d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/slist.c
// Function: list_delete
int
list_delete(List* list) {

    ListItem* item;
    ListItem* tmp;

    ASSERT(list);

    item = list->head;
    while (item) {
        tmp = item;
        item = item->__next;
        memory_free(tmp);
    }

    list->head = list->last = NULL;
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x384d
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x383d
movq (%rdi), %r14
callq 0x3070
movq %r14, %rdi
jmp 0x382b
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xa7a4(%rip), %rbx      # 0xdff8
movq (%rbx), %rdi
leaq 0x47d2(%rip), %rsi      # 0x8030
leaq 0x47e2(%rip), %rdx      # 0x8047
leaq 0x47e7(%rip), %rcx      # 0x8053
leaq 0x7744(%rip), %r9       # 0xafb7
pushq $0x32
popq %r8
xorl %eax, %eax
callq 0x31b0
movq (%rbx), %rdi
callq 0x3230
pushq $0x1
popq %rdi
callq 0x3310
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/slist.c
// Function: list_append
ListItem*
list_append(List* list, ListItem* item) {
    ASSERT(list);

    if (item) {
        if (list->last) {
            list->last->__next = item;  // append
            list->last = item;          // set as last node
        }
        else
            list->head = list->last = item;
    }

    return item;
}

// Assembly:
testq %rdi, %rdi
je 0x38b7
testq %rsi, %rsi
je 0x38b3
leaq 0x8(%rdi), %rax
movq 0x8(%rdi), %rcx
xorl %edx, %edx
testq %rcx, %rcx
setne %dl
cmovneq %rcx, %rax
movq %rsi, (%rax)
movq %rsi, (%rdi,%rdx,8)
movq %rsi, %rax
retq
pushq %rbx
movq 0xa739(%rip), %rbx      # 0xdff8
movq (%rbx), %rdi
leaq 0x4767(%rip), %rsi      # 0x8030
leaq 0x4777(%rip), %rdx      # 0x8047
leaq 0x4788(%rip), %rcx      # 0x805f
leaq 0x76d9(%rip), %r9       # 0xafb7
pushq $0x42
popq %r8
xorl %eax, %eax
callq 0x31b0
movq (%rbx), %rdi
callq 0x3230
pushq $0x1
popq %rdi
callq 0x3310
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/slist.c
// Function: list_push_front
ListItem*
list_push_front(List* list, ListItem* item) {
    ASSERT(list);

    if (list->head) {
        item->__next = list->head;
        list->head = item;
    }
    else
        list->head = list->last = item;

    return item;
}

// Assembly:
testq %rdi, %rdi
je 0x3916
movq (%rdi), %rax
testq %rax, %rax
je 0x390b
movq %rax, (%rsi)
jmp 0x390f
movq %rsi, 0x8(%rdi)
movq %rsi, (%rdi)
movq %rsi, %rax
retq
pushq %rbx
movq 0xa6da(%rip), %rbx      # 0xdff8
movq (%rbx), %rdi
leaq 0x4708(%rip), %rsi      # 0x8030
leaq 0x4718(%rip), %rdx      # 0x8047
leaq 0x4735(%rip), %rcx      # 0x806b
leaq 0x767a(%rip), %r9       # 0xafb7
pushq $0x53
popq %r8
xorl %eax, %eax
callq 0x31b0
movq (%rbx), %rdi
callq 0x3230
pushq $0x1
popq %rdi
callq 0x3310
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/slist.c
// Function: list_pop_first
ListItem*
list_pop_first(List* list) {
    ListItem* item;

    ASSERT(list);

    if (list->head) {
        item = list->head;
        list->head = item->__next;

        if (!list->head)
            list->last = 0;

        return item;
    }
    else
        return NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x3977
movq (%rdi), %rax
testq %rax, %rax
je 0x3970
movq (%rax), %rcx
movq %rcx, (%rdi)
testq %rcx, %rcx
je 0x3971
retq
andq $0x0, 0x8(%rdi)
retq
pushq %rbx
movq 0xa679(%rip), %rbx      # 0xdff8
movq (%rbx), %rdi
leaq 0x46a7(%rip), %rsi      # 0x8030
leaq 0x46b7(%rip), %rdx      # 0x8047
leaq 0x46e4(%rip), %rcx      # 0x807b
leaq 0x7619(%rip), %r9       # 0xafb7
pushq $0x64
popq %r8
xorl %eax, %eax
callq 0x31b0
movq (%rbx), %rdi
callq 0x3230
pushq $0x1
popq %rdi
callq 0x3310
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/custompickle/custompickle.c
// Function: custompickle_initialize_header
void custompickle_initialize_header(CustompickleHeader* header, Automaton* automaton) {

    ASSERT(header != NULL);
    ASSERT(automaton != NULL);

    memcpy(header->magick, CUSTOMPICKLE_MAGICK, sizeof(CUSTOMPICKLE_MAGICK));
    header->data.kind         = automaton->kind;
    header->data.store        = automaton->store;
    header->data.key_type     = automaton->key_type;
    header->data.words_count  = automaton->count;
    header->data.longest_word = automaton->longest_word;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x39ec
testq %rsi, %rsi
je 0x3a16
movaps 0x7a05(%rip), %xmm0     # 0xb3d0
movups %xmm0, (%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
movl 0x18(%rsi), %eax
movl %eax, 0x18(%rdi)
movslq 0x1c(%rsi), %rax
movq %rax, 0x20(%rdi)
movl 0x20(%rsi), %eax
movl %eax, 0x28(%rdi)
popq %rbx
retq
movq 0xa605(%rip), %rbx      # 0xdff8
movq (%rbx), %rdi
leaq 0x4633(%rip), %rsi      # 0x8030
leaq 0x4686(%rip), %rdx      # 0x808a
leaq 0x469f(%rip), %rcx      # 0x80aa
leaq 0x46b7(%rip), %r9       # 0x80c9
pushq $0xd
jmp 0x3a3e
movq 0xa5db(%rip), %rbx      # 0xdff8
movq (%rbx), %rdi
leaq 0x4609(%rip), %rsi      # 0x8030
leaq 0x465c(%rip), %rdx      # 0x808a
leaq 0x4675(%rip), %rcx      # 0x80aa
leaq 0x469c(%rip), %r9       # 0x80d8
pushq $0xe
popq %r8
xorl %eax, %eax
callq 0x31b0
movq (%rbx), %rdi
callq 0x3230
pushq $0x1
popq %rdi
callq 0x3310
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/custompickle/custompickle.c
// Function: custompickle_validate_header
int custompickle_validate_header(CustompickleHeader* header) {
    if (memcmp(header->magick, CUSTOMPICKLE_MAGICK, sizeof(CUSTOMPICKLE_MAGICK)) != 0)
        return false;

    if (!check_store(header->data.store))
        return false;

    if (!check_kind(header->data.kind))
        return false;

    if (!check_key_type(header->data.key_type))
        return false;

    return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movdqu (%rdi), %xmm0
pcmpeqb 0x4543(%rip), %xmm0     # 0x8000
pmovmskb %xmm0, %eax
xorl %ebx, %ebx
cmpl $0xffff, %eax           # imm = 0xFFFF
jne 0x3af2
movq %rdi, %r14
movl 0x14(%rdi), %edi
callq 0x3afc
testb %al, %al
je 0x3af2
movl 0x10(%r14), %edi
callq 0x3b2c
testb %al, %al
je 0x3af2
movl 0x18(%r14), %edi
callq 0x3b52
movzbl %al, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/custompickle/save/savebuffer.c
// Function: savebuffer_init
bool
savebuffer_init(SaveBuffer* output, PyObject* serializer, KeysStore store, const char* path, size_t capacity) {

    output->store       = store;
    output->file        = NULL;
    output->buffer      = NULL;
    output->size        = 0;
    output->capacity    = capacity;
    output->serializer  = serializer;
    output->nodes_count = 0;

    if (PICKLE_SIZE_T_SIZE < sizeof(PyObject*)) {
        // XXX: this must be reworked, likely moved to module level
        PyErr_SetString(PyExc_SystemError, "unable to save data due to technical reasons");
        return false;
    }

    if (UNLIKELY(store == STORE_ANY && serializer == NULL)) {
        PyErr_SetString(PyExc_ValueError, "for automatons with STORE_ANY serializer must be given");
        return false;
    }

    output->buffer = (char*)memory_alloc(capacity);
    if (UNLIKELY(output->buffer == NULL)) {
        PyErr_NoMemory();
        return false;
    }

    output->file = fopen(path, "wb");
    if (output->file == NULL) {
        memory_free(output->buffer);
        output->buffer = NULL;
        PyErr_SetFromErrno(PyExc_IOError);
        return false;
    }

    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movl %edx, (%rdi)
andq $0x0, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %r8, 0x20(%rdi)
movq %rsi, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
cmpl $0x1e, %edx
setne %al
testq %rsi, %rsi
setne %cl
orb %al, %cl
je 0x3d59
movq %rdi, %rbx
movq %r8, %rdi
callq 0x3370
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x3d71
leaq 0x8(%rbx), %r15
leaq 0x4542(%rip), %rsi      # 0x8261
movq %r14, %rdi
callq 0x31d0
movq %rax, %rcx
movq %rax, (%r15)
movb $0x1, %al
testq %rcx, %rcx
jne 0x3d53
movq 0x10(%rbx), %rdi
callq 0x3070
andq $0x0, 0x10(%rbx)
movq 0xa257(%rip), %rax      # 0xdfa0
movq (%rax), %rdi
callq 0x3090
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0xa228(%rip), %rax      # 0xdf88
movq (%rax), %rdi
leaq 0x44c0(%rip), %rsi      # 0x822a
callq 0x3120
jmp 0x3d51
callq 0x30e0
jmp 0x3d51
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/custompickle/save/savebuffer.c
// Function: savebuffer_acquire
char*
savebuffer_acquire(SaveBuffer* output, size_t request) {

    char* ptr;

    if (UNLIKELY(request > output->capacity)) {
        return NULL;
    }

    if (UNLIKELY(output->size + request > output->capacity)) {
        savebuffer_flush(output);
    }

    ptr = output->buffer + output->size;
    output->size += request;

    return ptr;
}

// Assembly:
movq 0x20(%rdi), %rdx
cmpq %rsi, %rdx
jb 0x3de7
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rax
leaq (%rax,%rsi), %rcx
cmpq %rdx, %rcx
ja 0x3dea
addq 0x10(%rbx), %rax
movq %rcx, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
movq %rbx, %rdi
callq 0x3d78
movq 0x18(%rbx), %rax
addq %rax, %r14
movq %r14, %rcx
jmp 0x3dd7
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/custompickle/save/savebuffer.c
// Function: savebuffer_store
void
savebuffer_store(SaveBuffer* output, const char* data, size_t size) {

    if (UNLIKELY(size > output->capacity)) {
        savebuffer_flush(output);
        if (fwrite(data, 1, size, output->file) != size) {
            PyErr_SetFromErrno(PyExc_IOError);
        }
        return;
    }

    if (UNLIKELY(output->size + size >= output->capacity)) {
        savebuffer_flush(output);
    }

    memcpy(output->buffer + output->size, data, size);
    output->size += size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rdi), %rax
cmpq %rdx, %rax
jb 0x3e3b
movq 0x18(%r14), %rdi
leaq (%rdi,%rbx), %rcx
cmpq %rax, %rcx
jae 0x3e6e
addq 0x10(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x31e0
addq %rbx, 0x18(%r14)
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x3d78
movq 0x8(%r14), %rcx
pushq $0x1
popq %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x3320
cmpq %rbx, %rax
je 0x3e35
movq 0xa13f(%rip), %rax      # 0xdfa0
movq (%rax), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3090
movq %r14, %rdi
callq 0x3d78
movq 0x18(%r14), %rdi
jmp 0x3e22
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/custompickle/save/savebuffer.c
// Function: savebuffer_finalize
void
savebuffer_finalize(SaveBuffer* output) {

    if (output->buffer != NULL && output->file != NULL && output->size > 0) {
        savebuffer_flush(output);
    }

    memory_safefree(output->buffer);

    if (output->file != NULL) {
        fclose(output->file);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x3eb6
cmpq $0x0, 0x8(%rbx)
je 0x3eb8
cmpq $0x0, 0x18(%rbx)
je 0x3eb8
movq %rbx, %rdi
callq 0x3d78
movq 0x10(%rbx), %rdi
jmp 0x3eb8
xorl %edi, %edi
callq 0x345b
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3ecc
popq %rbx
jmp 0x3100
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/custompickle/save/automaton_save.c
// Function: automaton_save
PyObject*
automaton_save(PyObject* self, PyObject* args) {

    SaveLoadParameters params;
    Automaton* automaton;
    int ret;

    automaton = (Automaton*)self;

    if (UNLIKELY(!automaton_save_load_parse_args(automaton->store, args, &params))) {
        return NULL;
    }

    ret = automaton_save_impl(automaton, PyBytes_AsString(params.path), params.callback);
    Py_DECREF(params.path);

    if (LIKELY(ret))
        Py_RETURN_NONE;
    else
        return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r14
movl 0x14(%rdi), %edi
movq %rsp, %rdx
callq 0x3b9c
testb %al, %al
je 0x3fdc
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x32d0
movq 0x8(%rsp), %rsi
movl 0x14(%r14), %edx
leaq 0x10(%rsp), %rdi
movl $0x8000, %r8d           # imm = 0x8000
movq %rax, %rcx
callq 0x3ccd
testb %al, %al
je 0x3fd4
movaps 0x74ab(%rip), %xmm0     # 0xb3d0
leaq 0x60(%rsp), %rsi
movaps %xmm0, (%rsi)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsi)
movl 0x18(%r14), %eax
movl %eax, 0x18(%rsi)
movslq 0x1c(%r14), %rax
movq %rax, 0x20(%rsi)
movl 0x20(%r14), %eax
movl %eax, 0x28(%rsi)
leaq 0x10(%rsp), %rdi
pushq $0x30
popq %rdx
callq 0x3dfe
cmpl $0x0, 0x10(%r14)
je 0x3f7e
movq 0x28(%r14), %rdi
leaq 0xb61(%rip), %rsi       # 0x4acb
leaq 0x10(%rsp), %rdx
callq 0x4a41
callq 0x31f0
testq %rax, %rax
jne 0x3fca
leaq 0x10(%rsp), %r14
movq 0x30(%r14), %rax
leaq 0x48(%rsp), %rsi
movaps 0x743d(%rip), %xmm0     # 0xb3d0
movups %xmm0, 0x8(%rsi)
movq %rax, (%rsi)
pushq $0x18
popq %rdx
movq %r14, %rdi
callq 0x3dfe
movq %r14, %rdi
callq 0x3e8d
movq %rbx, %rdi
callq 0x37d5
movq 0xa004(%rip), %rax      # 0xdfc0
incq (%rax)
addq $0x98, %rsp
popq %rbx
popq %r14
retq
leaq 0x10(%rsp), %rdi
callq 0x3e8d
movq %rbx, %rdi
callq 0x37d5
xorl %eax, %eax
jmp 0x3fbf
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/custompickle/load/loadbuffer.c
// Function: loadbuffer_open
int
loadbuffer_open(LoadBuffer* input, const char* path, PyObject* deserializer) {

    ASSERT(input != NULL);
    ASSERT(path != NULL);

    input->file         = NULL;
    input->lookup       = NULL;
    input->size         = 0;
    input->capacity     = 0;
    input->deserializer = deserializer;

    input->file = fopen(path, "rb");
    if (UNLIKELY(input->file == NULL)) {
        PyErr_SetFromErrno(PyExc_IOError);
        return 0;
    }

    return 1;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x4035
testq %rsi, %rsi
je 0x405f
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
andq $0x0, 0x28(%rdi)
movq %rdx, (%rdi)
leaq 0x42a9(%rip), %rax      # 0x82b2
movq %rsi, %rdi
movq %rax, %rsi
callq 0x31d0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x4022
pushq $0x1
popq %rax
popq %rbx
retq
movq 0x9f77(%rip), %rax      # 0xdfa0
movq (%rax), %rdi
callq 0x3090
xorl %eax, %eax
jmp 0x4020
movq 0x9fbc(%rip), %rbx      # 0xdff8
movq (%rbx), %rdi
leaq 0x3fea(%rip), %rsi      # 0x8030
leaq 0x4217(%rip), %rdx      # 0x8264
leaq 0x4233(%rip), %rcx      # 0x8287
leaq 0x423c(%rip), %r9       # 0x8297
pushq $0x7
jmp 0x4087
movq 0x9f92(%rip), %rbx      # 0xdff8
movq (%rbx), %rdi
leaq 0x3fc0(%rip), %rsi      # 0x8030
leaq 0x41ed(%rip), %rdx      # 0x8264
leaq 0x4209(%rip), %rcx      # 0x8287
leaq 0x4220(%rip), %r9       # 0x82a5
pushq $0x8
popq %r8
xorl %eax, %eax
callq 0x31b0
movq (%rbx), %rdi
callq 0x3230
pushq $0x1
popq %rdi
callq 0x3310
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/custompickle/load/loadbuffer.c
// Function: loadbuffer_load
int
loadbuffer_load(LoadBuffer* input, char* buffer, size_t size) {

    size_t read;

    ASSERT(input != NULL);
    ASSERT(buffer != NULL);

    if (UNLIKELY(size == 0)) {
        PyErr_SetString(PyExc_ValueError, "logic error: tried to read 0 bytes");
        return 0;
    }

    read = fread(buffer, 1, size, input->file);
    if (read != size) {
        PyErr_SetFromErrno(PyExc_IOError);
        return 0;
    }

    return 1;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x40fd
testq %rsi, %rsi
je 0x4127
movq %rdx, %rbx
testq %rdx, %rdx
je 0x40e5
movq 0x8(%rdi), %rcx
pushq $0x1
popq %rax
movq %rsi, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x30a0
cmpq %rbx, %rax
jne 0x40d2
pushq $0x1
popq %rax
jmp 0x40e3
movq 0x9ec7(%rip), %rax      # 0xdfa0
movq (%rax), %rdi
callq 0x3090
xorl %eax, %eax
popq %rbx
retq
movq 0x9e9c(%rip), %rax      # 0xdf88
movq (%rax), %rdi
leaq 0x41de(%rip), %rsi      # 0x82d4
callq 0x3120
jmp 0x40e1
movq 0x9ef4(%rip), %rbx      # 0xdff8
movq (%rbx), %rdi
leaq 0x3f22(%rip), %rsi      # 0x8030
leaq 0x414f(%rip), %rdx      # 0x8264
leaq 0x4199(%rip), %rcx      # 0x82b5
leaq 0x4174(%rip), %r9       # 0x8297
pushq $0x1e
jmp 0x414f
movq 0x9eca(%rip), %rbx      # 0xdff8
movq (%rbx), %rdi
leaq 0x3ef8(%rip), %rsi      # 0x8030
leaq 0x4125(%rip), %rdx      # 0x8264
leaq 0x416f(%rip), %rcx      # 0x82b5
leaq 0x4178(%rip), %r9       # 0x82c5
pushq $0x1f
popq %r8
xorl %eax, %eax
callq 0x31b0
movq (%rbx), %rdi
callq 0x3230
pushq $0x1
popq %rdi
callq 0x3310
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/custompickle/load/loadbuffer.c
// Function: loadbuffer_close
void
loadbuffer_close(LoadBuffer* input) {

    TrieNode* node;
    size_t i;

    if (input->file != NULL) {
        fclose(input->file);
    }

    if (input->lookup) {
        for (i=0; i < input->size; i++) {
            node = input->lookup[i].current;

            if (node->eow && input->store == STORE_ANY) {
                Py_DECREF(node->output.object);
            }

            trienode_free(node);
        }

        memory_free(input->lookup);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x438f
callq 0x3100
cmpq $0x0, 0x18(%rbx)
je 0x43e1
pushq $0x8
popq %r15
xorl %r12d, %r12d
movq 0x18(%rbx), %rdi
cmpq 0x20(%rbx), %r12
jae 0x43d1
movq (%rdi,%r15), %r14
cmpb $0x0, 0x14(%r14)
je 0x43c0
cmpl $0x1e, 0x10(%rbx)
jne 0x43c0
movq (%r14), %rdi
callq 0x37d5
movq %r14, %rdi
callq 0x43ed
incq %r12
addq $0x10, %r15
jmp 0x439d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3070
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq