LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::OnChangeEditLayerSize(smooth::GUI::Size const&)
Void Translator::OnChangeEditLayerSize(const Size &size)
{
	edit_original->SetSize(Size(size.cx - edit_original->GetX() - 7, (size.cy - 50) / 2));

	text_translated->SetY(edit_original->GetY() + edit_original->GetHeight() + 11);
	edit_translated->SetY(text_translated->GetY() - 3);

	edit_translated->SetSize(Size(edit_original->GetWidth(), edit_original->GetHeight() + (size.cy & 1)));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x658(%rdi), %rdi
movl $0xa8, %ebx
leaq (%rdi,%rbx), %rsi
movl (%r14), %eax
movl 0x4(%r14), %ecx
subl 0xa8(%rdi), %eax
addl $-0x7, %eax
movl %ecx, %edx
addl $-0x32, %edx
shrl $0x1f, %edx
addl %edx, %ecx
addl $-0x32, %ecx
sarl %ecx
leaq 0x8(%rsp), %r12
movl %eax, (%r12)
movl %ecx, 0x4(%r12)
movq (%rdi), %rax
movq %r12, %rdx
callq *0x150(%rax)
movq 0x658(%r15), %rax
movq 0x660(%r15), %rdi
movl 0xac(%rax), %ecx
movl 0xb4(%rax), %eax
leal 0xb(%rcx,%rax), %eax
movl 0xa8(%rdi), %ecx
movl %ecx, (%r12)
movl %eax, 0x4(%r12)
movl $0xb0, %r12d
leaq (%rdi,%r12), %rdx
movq (%rdi), %rax
leaq 0x8(%rsp), %r13
movq %r13, %rsi
callq *0x150(%rax)
movq 0x660(%r15), %rax
movq 0x668(%r15), %rdi
movl 0xac(%rax), %eax
addl $-0x3, %eax
movl 0xa8(%rdi), %ecx
movl %ecx, (%r13)
movl %eax, 0x4(%r13)
addq %rdi, %r12
movq (%rdi), %rax
leaq 0x8(%rsp), %r13
movq %r13, %rsi
movq %r12, %rdx
callq *0x150(%rax)
movq 0x668(%r15), %rdi
movq 0x658(%r15), %rax
movl 0xb0(%rax), %ecx
movl 0x4(%r14), %edx
andl $0x1, %edx
addl 0xb4(%rax), %edx
movl %ecx, (%r13)
movl %edx, 0x4(%r13)
addq %rdi, %rbx
movq (%rdi), %rax
leaq 0x8(%rsp), %rdx
movq %rbx, %rsi
callq *0x150(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %r14d
cmpl $0x8, 0x6c0(%rdi)
jl 0xce6a
leaq 0x6b8(%rbx), %rdi
callq 0x112e2
movq (%rax), %rax
movl 0x630(%rax), %eax
xorl %r14d, %r14d
testl %eax, %eax
cmovgl %eax, %r14d
incl %r14d
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
movl $0x2, %esi
callq *0x180(%rax)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x68(%rcx)
movq 0x5e0(%rbx), %rdi
movq (%rdi), %rax
movl $0x3, %esi
callq *0x180(%rax)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x68(%rcx)
movq 0x650(%rbx), %r15
leaq 0x54a5(%rip), %rsi      # 0x123ce
movq %rsp, %r12
movq %r12, %rdi
callq 0x77f0
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0xa0(%rax)
movq %rsp, %rdi
callq 0x7980
movq 0x660(%rbx), %r15
leaq 0x547f(%rip), %rsi      # 0x123d8
movq %rsp, %r12
movq %r12, %rdi
callq 0x77f0
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0xa0(%rax)
movq %rsp, %rdi
callq 0x7980
movq 0x648(%rbx), %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x7220
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0xa0(%rax)
movq %rsp, %rdi
callq 0x7980
movq 0x658(%rbx), %r14
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x7480
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0xa0(%rax)
movq %rsp, %rdi
callq 0x7980
movq 0x668(%rbx), %r14
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x7480
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0xa0(%rax)
movq %rsp, %rdi
callq 0x7980
movb $0x1, 0x770(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xd018
jmp 0xd018
jmp 0xd018
jmp 0xd018
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7980
movq %rbx, %rdi
callq 0x7290
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x74e0
xorb $0x1, %al
movzbl %al, %eax
movq 0x600(%rbx,%rax,8), %rsi
movq %rbx, %rdi
callq 0x10118
testq %rax, %rax
je 0xd124
movl 0x630(%rax), %ebp
movq 0x600(%rbx), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x101b6
movq %rax, %r15
leaq 0x6b8(%rbx), %r12
movq %r12, %rdi
movl %ebp, %esi
callq 0x9c50
movq (%rax), %r14
movq %r12, %rdi
movl %ebp, %esi
callq 0x7920
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x38(%rax)
leaq 0x710(%rbx), %r15
movq %r15, %rdi
movl %ebp, %esi
callq 0x9c50
cmpq $0x0, (%rax)
je 0xd0dc
movq %r14, %rdi
callq 0x7950
movq %r15, %rdi
movl %ebp, %esi
callq 0x7920
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc332
movq 0x5f0(%rbx), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
movq %rax, %rdi
xorl %esi, %esi
callq 0x76f0
testb %al, %al
je 0xd10e
movq %rbx, %rdi
callq 0xc81a
jmp 0xd11d
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_O1/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 0xe68e
testb %al, %al
je 0xe05e
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x7810
movq 0x5b8(%rbx), %rsi
movq %r14, %rdi
callq 0x70f0
leaq 0x44fc(%rip), %rsi      # 0x1247d
leaq 0x8(%rsp), %rdi
callq 0x77f0
leaq 0x44fe(%rip), %rsi      # 0x12490
leaq 0x20(%rsp), %rdi
callq 0x77f0
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x7230
leaq 0x20(%rsp), %rdi
callq 0x7980
leaq 0x8(%rsp), %rdi
callq 0x7980
leaq 0x44cb(%rip), %rsi      # 0x12496
leaq 0x8(%rsp), %rdi
callq 0x77f0
leaq 0x44c4(%rip), %rsi      # 0x124a0
leaq 0x20(%rsp), %rdi
callq 0x77f0
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x7230
leaq 0x20(%rsp), %rdi
callq 0x7980
leaq 0x8(%rsp), %rdi
callq 0x7980
leaq 0x38(%rsp), %rdi
callq 0x7370
movq 0xafb1(%rip), %rcx      # 0x18fd0
addq $0x10, %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movl $0x0, 0x8(%rsi)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
testb %al, %al
je 0xe054
leaq 0x38(%rsp), %rdi
callq 0x7100
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe832
leaq 0x38(%rsp), %rdi
callq 0x7510
addq $0x778, %rsp            # imm = 0x778
popq %rbx
popq %r14
retq
jmp 0xe091
jmp 0xe071
jmp 0xe080
jmp 0xe091
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x7980
jmp 0xe083
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7980
jmp 0xe094
jmp 0xe091
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x7510
movq %rbx, %rdi
callq 0x7290
// File: /workspace/github_c_makefile_star2_O1/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 0xe786
movq %rdi, %r14
cmpb $0x0, 0x770(%rdi)
je 0xe77e
leaq 0x3d5a(%rip), %rsi      # 0x12417
leaq 0x48(%rsp), %rdi
callq 0x77f0
leaq 0x688(%r14), %rdx
leaq 0x30(%rsp), %rdi
callq 0xf2d2
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x7170
movq %rax, %r15
leaq 0x3d46(%rip), %rsi      # 0x12437
leaq 0x18(%rsp), %rdi
callq 0x77f0
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x7170
movq %rax, %r15
leaq 0x3be5(%rip), %rsi      # 0x122f7
movq %rsp, %rdi
callq 0x77f0
movq %rsp, %rsi
movq %r15, %rdi
movl $0x3, %edx
movl $0x7f02, %ecx           # imm = 0x7F02
callq 0x7350
movl %eax, %r15d
movq %rsp, %rdi
callq 0x7980
leaq 0x18(%rsp), %rdi
callq 0x7980
leaq 0x30(%rsp), %rdi
callq 0x7980
leaq 0x48(%rsp), %rdi
callq 0x7980
addl $-0x2, %r15d
cmpl $0x6, %r15d
ja 0xe786
leaq 0x3b5f(%rip), %rax      # 0x122c8
movslq (%rax,%r15,4), %rcx
addq %rax, %rcx
jmpq *%rcx
xorl %ebx, %ebx
jmp 0xe786
movq %r14, %rdi
callq 0xe0a6
movq %r14, %rdi
callq 0xf066
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7980
jmp 0xe7a4
jmp 0xe7a1
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x7980
jmp 0xe7b5
jmp 0xe7b2
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x7980
leaq 0x48(%rsp), %rdi
callq 0x7980
movq %rbx, %rdi
callq 0x7290
movq %rax, %rbx
jmp 0xe7bf
// File: /workspace/github_c_makefile_star2_O1/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 0x7630
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 0xcac0
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x620(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x9983(%rip), %rax      # 0x18880
movq %rax, (%rdi)
callq 0xf066
movq 0x5c0(%rbx), %rdi
callq 0x7950
movq 0x5b8(%rbx), %rdi
callq 0x7950
movq 0x5c8(%rbx), %rdi
callq 0x7950
movq 0x5d8(%rbx), %rdi
callq 0x7950
movq 0x5e0(%rbx), %rdi
callq 0x7950
movq 0x5d0(%rbx), %rdi
callq 0x7950
movq 0x5e8(%rbx), %rdi
callq 0x7950
movq 0x5f0(%rbx), %rdi
callq 0x7950
movq 0x5f8(%rbx), %rdi
callq 0x7950
movq 0x600(%rbx), %rdi
callq 0x7950
movq 0x608(%rbx), %rdi
callq 0x7950
movq 0x610(%rbx), %rdi
callq 0x7950
movq 0x618(%rbx), %rdi
callq 0x7950
movq 0x630(%rbx), %rdi
callq 0x7950
movq 0x640(%rbx), %rdi
callq 0x7950
movq 0x648(%rbx), %rdi
callq 0x7950
movq 0x650(%rbx), %rdi
callq 0x7950
movq 0x658(%rbx), %rdi
callq 0x7950
movq 0x660(%rbx), %rdi
callq 0x7950
movq 0x668(%rbx), %rdi
callq 0x7950
movq 0x670(%rbx), %rdi
callq 0x7950
movq 0x678(%rbx), %rdi
callq 0x7950
movq 0x638(%rbx), %rdi
callq 0x7950
movq 0x680(%rbx), %rdi
callq 0x7950
leaq 0x710(%rbx), %rdi
callq 0x10834
leaq 0x6b8(%rbx), %rdi
callq 0x10834
leaq 0x6a0(%rbx), %rdi
callq 0x7980
leaq 0x688(%rbx), %rdi
callq 0x7980
movq %rbx, %rdi
popq %rbx
jmp 0x74a0
movq %rax, %rdi
callq 0x8ee6
// File: /workspace/github_c_makefile_star2_O1/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)
testl %eax, %eax
jle 0xf3c3
movl %eax, %r15d
movq 0x9c1c(%rip), %rax      # 0x18f88
incl %r15d
movswl (%rax), %ebp
leal -0x2(%r15), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x180(%rax)
movq %rax, %r12
leaq 0x20(%rax), %rdi
movl %ebp, %esi
callq 0x72d0
testb %al, %al
je 0xf3a4
leaq 0x630(%r12), %rsi
movq %r14, %rdi
callq 0xf344
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
callq *0x38(%rax)
movq (%r12), %rax
movq %r12, %rdi
callq *0x10(%rax)
decl %r15d
cmpl $0x1, %r15d
jg 0xf372
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7480
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x7660
leaq 0x18(%rsp), %rdi
callq 0x7730
movl %eax, %r15d
leaq 0x18(%rsp), %rdi
callq 0x7250
movq %rsp, %rdi
callq 0x7980
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testb %r15b, %r15b
je 0xf4a8
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x7310
movq %r15, %rdi
movq %r14, %rsi
callq 0x70c0
cmpl $-0x1, %eax
je 0xf499
leaq 0x18(%rsp), %rdi
callq 0x7260
movq %rax, %r14
leaq 0x304d(%rip), %rsi      # 0x124a4
movq %rsp, %rdi
callq 0x77f0
movq %rsp, %rsi
movq %r14, %rdi
callq 0x76a0
movq %rax, %r14
movq %rsp, %rdi
callq 0x7980
movq 0x600(%rbx), %rdx
movq 0x768(%rbx), %rdi
addq $0x6b8, %rbx            # imm = 0x6B8
xorl %ebp, %ebp
movq %r14, %rsi
movq %rbx, %rcx
callq 0x7fac
jmp 0xf49e
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x18(%rsp), %rdi
callq 0x7500
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7980
jmp 0xf4c9
jmp 0xf4c6
jmp 0xf4c6
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x7500
jmp 0xf4ef
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x7250
jmp 0xf4e7
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7980
movq %rbx, %rdi
callq 0x7290
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x2979(%rip), %r14      # 0x12513
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x108f8
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x10942
leaq 0x170(%rsp), %rdi
movl $0x3, %esi
movq %rbx, %rdx
movl $0x2, %ecx
callq 0x7400
cmpw $0x0, 0x178(%rsp)
je 0xfbe2
movl 0x180(%rsp), %edx
jmp 0xfbf1
movw $0x5, 0x268(%rsp)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
leaq 0x20(%rsp), %rdi
leaq 0x170(%rsp), %rsi
callq 0x78f0
leaq 0x2937(%rip), %rsi      # 0x12541
leaq 0x68(%rsp), %rdi
callq 0x77f0
leaq 0x291f(%rip), %rsi      # 0x1253a
leaq 0x8(%rsp), %rdi
callq 0x77f0
leaq 0x20(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x72e0
leaq 0x8(%rsp), %rdi
callq 0x7980
leaq 0x68(%rsp), %rdi
callq 0x7980
leaq 0x28e5(%rip), %rsi      # 0x12539
leaq 0x68(%rsp), %rdi
callq 0x77f0
leaq 0x28db(%rip), %rsi      # 0x12540
leaq 0x8(%rsp), %rdi
callq 0x77f0
leaq 0x20(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x72e0
leaq 0x8(%rsp), %rdi
callq 0x7980
leaq 0x68(%rsp), %rdi
callq 0x7980
leaq 0x68(%rsp), %rdi
movl $0x3, %esi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x7880
leaq 0x68(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x75b0
leaq 0x68(%rsp), %rdi
callq 0x7690
leaq 0x68(%rsp), %rdi
callq 0x7610
leaq 0x20(%rsp), %rdi
callq 0x7980
leaq 0x170(%rsp), %rdi
callq 0x7520
leaq 0x38(%rsp), %rdi
callq 0x1098c
leaq 0x50(%rsp), %rdi
callq 0x109ba
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r14
retq
jmp 0xfd2d
jmp 0xfd0f
jmp 0xfd1e
jmp 0xfd2d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7980
jmp 0xfd21
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x7980
jmp 0xfd4e
movq %rax, %rbx
jmp 0xfd4e
movq %rax, %rbx
jmp 0xfd58
movq %rax, %rbx
jmp 0xfd65
movq %rax, %rbx
jmp 0xfd6f
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x7610
leaq 0x20(%rsp), %rdi
callq 0x7980
leaq 0x170(%rsp), %rdi
callq 0x7520
leaq 0x38(%rsp), %rdi
callq 0x1098c
leaq 0x50(%rsp), %rdi
callq 0x109ba
movq %rbx, %rdi
callq 0x7290
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x178(%rax)
movl %eax, %ebp
movq 0x8e4a(%rip), %rax      # 0x18f88
movswl (%rax), %r15d
testl %ebp, %ebp
jle 0x101a1
decl %ebp
movq (%rbx), %rax
movq %rbx, %rdi
movl %ebp, %esi
callq *0x180(%rax)
movq %rax, %r13
leaq 0x20(%rax), %rdi
movl %r15d, %esi
callq 0x72d0
testb %al, %al
je 0x10188
addq $0x630, %r13            # imm = 0x630
movq %r14, %rdi
movq %r13, %rsi
callq 0x10118
testq %rax, %rax
cmovneq %rax, %r12
je 0x10199
xorl %eax, %eax
jmp 0x1019b
cmpb $0x0, 0x5b9(%r13)
je 0x10199
xorl %eax, %eax
movq %r13, %r12
jmp 0x1019b
movb $0x1, %al
testb %al, %al
jne 0x10142
jmp 0x101a4
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/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, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x178(%rax)
movl %eax, %ebp
movq 0x8da3(%rip), %rax      # 0x18f88
leaq 0x933c(%rip), %rcx      # 0x19528
movswl (%rax), %r12d
movswl (%rcx), %eax
movl %eax, 0xc(%rsp)
testl %ebp, %ebp
jle 0x10272
decl %ebp
movq (%r14), %rax
movq %r14, %rdi
movl %ebp, %esi
callq *0x180(%rax)
movq %rax, %r13
leaq 0x20(%rax), %rbx
movq %rbx, %rdi
movl %r12d, %esi
callq 0x72d0
testb %al, %al
je 0x10246
addq $0x630, %r13            # imm = 0x630
movq 0x10(%rsp), %rdi
movq %r13, %rsi
movl 0x8(%rsp), %edx
callq 0x101b6
testq %rax, %rax
cmovneq %rax, %r15
je 0x1026a
xorl %eax, %eax
jmp 0x1026c
movq %rbx, %rdi
movl 0xc(%rsp), %esi
callq 0x72d0
testb %al, %al
je 0x1026a
movl 0x8(%rsp), %eax
cmpl %eax, 0x630(%r13)
jne 0x1026a
xorl %eax, %eax
movq %r14, %r15
jmp 0x1026c
movb $0x1, %al
testb %al, %al
jne 0x101f7
jmp 0x10275
xorl %r15d, %r15d
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/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 %rdi, %r12
cmpq $0x0, 0x18(%rdi)
jne 0x103a6
movl $0x58, %edi
callq 0x7530
movq %rax, %r13
movq %rax, %rdi
callq 0x7130
leaq 0x833e(%rip), %rax      # 0x186c0
movq %rax, 0x40(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r13)
leaq 0x828b(%rip), %rax      # 0x18620
movq %rax, (%r13)
movq %r13, 0x18(%r12)
movq %r13, %rdi
callq 0x72b0
movq 0x18(%r12), %r12
movl $0x20, %edi
callq 0x7530
leaq 0x8774(%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 %r12, %rdi
callq 0xa67e
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x58, %esi
movq %r13, %rdi
callq 0x70a0
movq %rbx, %rdi
callq 0x7290
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rdi, %r12
cmpq $0x0, 0x10(%rdi)
jne 0x11058
movl $0x58, %edi
callq 0x7530
movq %rax, %r13
movq %rax, %rdi
callq 0x7130
leaq 0x768c(%rip), %rax      # 0x186c0
movq %rax, 0x40(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r13)
leaq 0x75d9(%rip), %rax      # 0x18620
movq %rax, (%r13)
movq %r13, 0x10(%r12)
movq %r13, %rdi
callq 0x72b0
movq 0x10(%r12), %r12
movl $0x20, %edi
callq 0x7530
leaq 0x7c92(%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 %r12, %rdi
callq 0xa67e
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x58, %esi
movq %r13, %rdi
callq 0x70a0
movq %rbx, %rdi
callq 0x7290
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x1110a
movl %esi, %ebp
cmpl %esi, 0x8(%rdi)
jle 0x1110a
movl %ebp, %esi
callq 0x9216
movq (%rax), %rdi
testq %rdi, %rdi
je 0x110e1
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 0x1110a
testq %rdi, %rdi
je 0x11102
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x11166
movl %esi, %ebp
cmpl %esi, 0x8(%rdi)
jle 0x11166
movl %ebp, %esi
callq 0x9216
movq (%rax), %rdi
testq %rdi, %rdi
je 0x1113d
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 0x11166
testq %rdi, %rdi
je 0x1115e
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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, %rbx
movq %rdi, (%rsp)
cmpb $0x1, 0x30(%rdi)
jne 0x1120a
movq 0x38(%rbx), %rdi
callq 0x7240
cmpl $0x0, 0x8(%rbx)
jle 0x11223
movq 0x48(%rbx), %rax
movq (%rax), %rax
movq (%rax), %r14
movl $0x0, 0x14(%rbx)
jmp 0x1122a
leaq 0x82f6(%rip), %r14      # 0x19520
movq %rsp, %rdi
callq 0x9272
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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)
cmpb $0x1, 0x30(%rdi)
jne 0x112a6
movq 0x38(%rbx), %rdi
callq 0x7240
movslq 0x14(%rbx), %rax
movl 0x8(%rbx), %ecx
decl %ecx
cmpl %ecx, %eax
jge 0x112c7
movq 0x48(%rbx), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx,%rax,8), %r14
incq %rax
movl %eax, 0x14(%rbx)
jmp 0x112ce
leaq 0x8252(%rip), %r14      # 0x19520
movq %rsp, %rdi
callq 0x9272
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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)
cmpb $0x1, 0x30(%rdi)
jne 0x112fc
movq 0x38(%rbx), %rdi
callq 0x7240
movslq 0x8(%rbx), %rax
testq %rax, %rax
jle 0x11319
movq 0x48(%rbx), %rcx
movq (%rcx), %rcx
movq -0x8(%rcx,%rax,8), %r14
decq %rax
movl %eax, 0x14(%rbx)
jmp 0x11320
leaq 0x8200(%rip), %r14      # 0x19520
movq %rsp, %rdi
callq 0x9272
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rax
cmpq %rsi, %rax
jb 0x33c9
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rcx
addq %rsi, %rcx
cmpq %rax, %rcx
ja 0x33cc
movq 0x18(%r14), %rcx
movq 0x10(%r14), %rax
addq %rcx, %rax
addq %rcx, %rbx
movq %rbx, 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
movq %r14, %rdi
callq 0x4de4
jmp 0x33af
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r14
movl 0x14(%rdi), %edi
leaq 0x8(%rsp), %rdx
callq 0x4c47
testb %al, %al
je 0x34de
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x32d0
movq 0x10(%rsp), %rsi
movl 0x14(%r14), %edx
leaq 0x18(%rsp), %rdi
movl $0x8000, %r8d           # imm = 0x8000
movq %rax, %rcx
callq 0x4d47
testb %al, %al
je 0x34b2
leaq 0x68(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4b59
leaq 0x18(%rsp), %rdi
pushq $0x30
popq %rdx
movq %r15, %rsi
callq 0x4e28
cmpl $0x0, 0x10(%r14)
je 0x347f
movq 0x28(%r14), %rdi
leaq 0xaf(%rip), %rsi        # 0x351a
leaq 0x18(%rsp), %rdx
callq 0x56a1
callq 0x31f0
testq %rax, %rax
jne 0x34e2
leaq 0x18(%rsp), %rdi
movq 0x30(%rdi), %rax
movaps 0x8f41(%rip), %xmm0     # 0xc3d0
leaq 0x50(%rsp), %rsi
movups %xmm0, 0x8(%rsi)
movq %rax, (%rsi)
pushq $0x18
popq %rdx
callq 0x4e28
movb $0x1, %bpl
leaq 0x18(%rsp), %rdi
callq 0x4e82
jmp 0x34b4
xorl %ebp, %ebp
decq (%rbx)
jne 0x34c1
movq %rbx, %rdi
callq 0x30d0
testb %bpl, %bpl
je 0x34de
movq 0xcaf3(%rip), %rax      # 0xffc0
incq (%rax)
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x34d0
xorl %ebp, %ebp
jmp 0x34a6
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
cmpl $0x64, 0x18(%rdi)
jne 0x475b
leaq 0x8(%r14), %rsi
leaq 0x18(%r14), %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0x4864
movq %rax, 0x10(%r14)
testq %rax, %rax
jne 0x47ea
xorl %ebp, %ebp
jmp 0x483f
movb $0x1, 0x18(%r14)
movq $0x0, 0x10(%r14)
movq 0x8(%r15), %rax
testb $0x4, 0xab(%rax)
je 0x4850
movq 0x10(%r15), %rbp
leaq (,%rbp,4), %rdi
callq 0x3370
testq %rax, %rax
je 0x485a
movq %rax, %rbx
testq %rbp, %rbp
jle 0x47e3
xorl %r12d, %r12d
movq %r15, %rdi
movq %r12, %rsi
callq 0x3140
movq 0xb7d8(%rip), %rcx      # 0xff88
movq (%rcx), %rsi
movq %rax, %rdi
callq 0x3060
movq %rax, %r13
cmpq $-0x1, %rax
jne 0x47ce
callq 0x31f0
testq %rax, %rax
jne 0x481a
movq %r13, %rax
shrq $0x20, %rax
jne 0x47ef
movl %r13d, (%rbx,%r12,4)
incq %r12
cmpq %r12, %rbp
jne 0x479e
movq %rbx, 0x8(%r14)
movq %rbp, (%r14)
movb $0x1, %bpl
jmp 0x483f
movq 0xb792(%rip), %rax      # 0xff88
movq (%rax), %rdi
leaq 0x4c9f(%rip), %rsi      # 0x949f
xorl %ebp, %ebp
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
movq %r12, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x3300
jmp 0x4837
movq 0xb767(%rip), %rax      # 0xff88
movq (%rax), %rdi
leaq 0x4c5a(%rip), %rsi      # 0x9485
xorl %ebp, %ebp
movq %r12, %rdx
xorl %eax, %eax
callq 0x3300
movq %rbx, %rdi
callq 0x3070
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x38b1
jmp 0x4754
callq 0x30e0
jmp 0x4754
// File: /workspace/github_c_makefile_star2_O1/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 0x4a22
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x471d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4ad7
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x4ac7
movq (%rdi), %r14
callq 0x3070
movq %r14, %rdi
testq %r14, %r14
jne 0x4ab7
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x38c9
// File: /workspace/github_c_makefile_star2_O1/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 0x4b05
testq %rsi, %rsi
je 0x4b01
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 %rax
callq 0x390b
// File: /workspace/github_c_makefile_star2_O1/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 0x4b28
movq (%rdi), %rax
testq %rax, %rax
je 0x4b1d
movq %rax, (%rsi)
jmp 0x4b21
movq %rsi, 0x8(%rdi)
movq %rsi, (%rdi)
movq %rsi, %rax
retq
pushq %rax
callq 0x394d
// File: /workspace/github_c_makefile_star2_O1/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 %rax
testq %rdi, %rdi
je 0x4b90
testq %rsi, %rsi
je 0x4b95
movaps 0x7865(%rip), %xmm0     # 0xc3d0
movups %xmm0, (%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x10(%rdi)
movl 0x14(%rsi), %eax
movl %eax, 0x14(%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 %rax
retq
callq 0x3a13
callq 0x39d1
// File: /workspace/github_c_makefile_star2_O1/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:
movdqu (%rdi), %xmm0
pcmpeqb 0x4440(%rip), %xmm0     # 0x9000
pmovmskb %xmm0, %ecx
xorl %eax, %eax
cmpl $0xffff, %ecx           # imm = 0xFFFF
je 0x4bcf
retq
movl 0x14(%rdi), %eax
leaq 0x48f3(%rip), %rsi      # 0x94cc
cmpl $0x1e, %eax
ja 0x4c13
movl $0x40100400, %ecx       # imm = 0x40100400
btl %eax, %ecx
jae 0x4c13
cmpl $0x2, 0x10(%rdi)
ja 0x4c0c
movl 0x18(%rdi), %ecx
movl $0x1, %eax
cmpl $0x64, %ecx
je 0x4bce
cmpl $0xc8, %ecx
je 0x4bce
leaq 0x4950(%rip), %rsi      # 0x955a
jmp 0x4c13
leaq 0x4906(%rip), %rsi      # 0x9519
pushq %rax
movq 0xb36d(%rip), %rax      # 0xff88
movq (%rax), %rdi
callq 0x3120
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/WojciechMula[P]pyahocorasick/src/custompickle/pyhelpers.c
// Function: automaton_save_load_parse_args
bool 
automaton_save_load_parse_args(KeysStore store, PyObject* args, SaveLoadParameters* result) {

    PyObject* string;

    if (store == STORE_ANY) {
        if (PyTuple_GET_SIZE(args) != 2) {
            PyErr_SetString(PyExc_ValueError, "expected exactly two arguments");
            return false;
        }
    } else {
        if (PyTuple_GET_SIZE(args) != 1) {
            PyErr_SetString(PyExc_ValueError, "expected exactly one argument");
            return false;
        }
    }

    string = F(PyTuple_GetItem)(args, 0);
    if (UNLIKELY(string == NULL)) {
        return false;
    }

#if defined(PY3K)
    if (UNLIKELY(!F(PyUnicode_Check)(string))) {
        PyErr_SetString(PyExc_TypeError, "the first argument must be a string");
        return false;
    }
#else
    if (UNLIKELY(!F(PyString_Check)(string))) {
        PyErr_SetString(PyExc_TypeError, "the first argument must be a string");
        return false;
    }
#endif

    if (store == STORE_ANY) {
        result->callback = F(PyTuple_GetItem)(args, 1);
        if (UNLIKELY(result->callback == NULL)) {
            return false;
        }

        if (UNLIKELY(!F(PyCallable_Check)(result->callback))) {
            PyErr_SetString(PyExc_TypeError, "the second argument must be a callable object");
            return false;
        }
    }

#if defined(PY3K)
    result->path = F(PyUnicode_AsUTF8String)(string);
#else
    result->path = string;
    Py_INCREF(string);
#endif
    if (UNLIKELY(result->path == NULL)) {
        return false;
    }

    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movq 0x8(%rsi), %rax
movq 0xa8(%rax), %rax
cmpl $0x1e, %edi
jne 0x4c7b
btl $0x1a, %eax
jae 0x4d09
movq %r14, %rdi
callq 0x3aeb
jmp 0x4c8d
btl $0x1a, %eax
jae 0x4d28
movq %r14, %rdi
callq 0x3ac3
testb $0x1, %al
je 0x4cfa
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
callq 0x3140
testq %rax, %rax
je 0x4cfd
movq %rax, %r12
movq 0x8(%rax), %rax
testb $0x10, 0xab(%rax)
je 0x4cee
cmpl $0x1e, %ebp
jne 0x4cda
movl $0x1, %esi
movq %r14, %rdi
callq 0x3140
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x4cfa
movq %rax, %rdi
callq 0x32a0
testl %eax, %eax
je 0x4cf5
movq %r12, %rdi
callq 0x30b0
movq %rax, (%rbx)
testq %rax, %rax
setne %r15b
jmp 0x4cfd
callq 0x3aad
jmp 0x4cfa
callq 0x3a97
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4408(%rip), %rdi      # 0x9118
leaq 0x4415(%rip), %rsi      # 0x912c
leaq 0x442b(%rip), %rcx      # 0x9149
movl $0x9, %edx
callq 0x3130
leaq 0x43e9(%rip), %rdi      # 0x9118
leaq 0x43f6(%rip), %rsi      # 0x912c
leaq 0x440c(%rip), %rcx      # 0x9149
movl $0xe, %edx
callq 0x3130
// File: /workspace/github_c_makefile_star2_O1/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)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %rsi, 0x28(%rdi)
movq %rax, 0x30(%rdi)
cmpl $0x1e, %edx
setne %al
testq %rsi, %rsi
setne %cl
orb %al, %cl
je 0x4dd6
movq %rdi, %rbx
movq %r8, %rdi
callq 0x3370
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x4ddd
leaq 0x8(%rbx), %r15
leaq 0x44c8(%rip), %rsi      # 0x9261
movq %r14, %rdi
callq 0x31d0
movq %rax, %rcx
movq %rax, (%r15)
movb $0x1, %al
testq %rcx, %rcx
jne 0x4dd0
movq 0x10(%rbx), %rdi
callq 0x3070
movq $0x0, 0x10(%rbx)
movq 0xb1da(%rip), %rax      # 0xffa0
movq (%rax), %rdi
callq 0x3090
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x3b13
jmp 0x4dce
callq 0x30e0
jmp 0x4dce
// File: /workspace/github_c_makefile_star2_O1/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 0x4e68
movq 0x18(%r14), %rcx
addq %rbx, %rcx
cmpq %rax, %rcx
jae 0x4e78
movq 0x10(%r14), %rdi
addq 0x18(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x31e0
addq %rbx, 0x18(%r14)
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3b29
jmp 0x4e62
movq %r14, %rdi
callq 0x4de4
jmp 0x4e4b
// File: /workspace/github_c_makefile_star2_O1/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
cmpq $0x0, 0x10(%rdi)
je 0x4ea3
cmpq $0x0, 0x8(%rbx)
je 0x4ea3
cmpq $0x0, 0x18(%rbx)
je 0x4ea3
movq %rbx, %rdi
callq 0x4de4
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x4eb1
callq 0x3070
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x4ec0
popq %rbx
jmp 0x3100
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4f12
testq %rsi, %rsi
je 0x4f17
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movq %rax, 0x28(%rdi)
movq %rdx, (%rdi)
leaq 0x43c7(%rip), %rax      # 0x92b2
movq %rsi, %rdi
movq %rax, %rsi
callq 0x31d0
movq %rax, %rcx
movq %rax, 0x8(%rbx)
movl $0x1, %eax
testq %rcx, %rcx
je 0x4f09
popq %rbx
retq
callq 0x3b6d
xorl %eax, %eax
jmp 0x4f07
callq 0x3bbe
callq 0x3b7c