LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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)
testl %eax, %eax
jle 0x10166
movl %eax, %r15d
movq 0x8e9c(%rip), %rax      # 0x18f88
leaq 0x9435(%rip), %rcx      # 0x19528
incl %r15d
movswl (%rax), %r12d
movswl (%rcx), %eax
movl %eax, 0xc(%rsp)
leal -0x2(%r15), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x180(%rax)
movq %rax, %r14
leaq 0x20(%rax), %r13
movq %r13, %rdi
movl %r12d, %esi
callq 0x72d0
testb %al, %al
je 0x10144
addq $0x630, %r14            # imm = 0x630
movq 0x10(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x100b6
testq %rax, %rax
je 0x1015d
jmp 0x1017a
movq %r13, %rdi
movl 0xc(%rsp), %esi
callq 0x72d0
testb %al, %al
je 0x1015d
cmpl %ebp, 0x630(%r14)
je 0x10168
decl %r15d
cmpl $0x1, %r15d
ja 0x10101
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x10168
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x102a7
movq %rdi, %r12
movl $0x58, %edi
callq 0x7530
movq %rax, %r13
movq %rax, %rdi
callq 0x7130
leaq 0x8442(%rip), %rax      # 0x186c0
movq %rax, 0x40(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r13)
leaq 0x838f(%rip), %rax      # 0x18620
movq %rax, (%r13)
movq %r13, 0x18(%r12)
movq %r13, %rdi
callq 0x72b0
movq 0x18(%r12), %r13
movl $0x20, %edi
callq 0x7530
leaq 0x8878(%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 0xa62c
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_O3/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 0x10f53
movq %rdi, %r12
movl $0x58, %edi
callq 0x7530
movq %rax, %r13
movq %rax, %rdi
callq 0x7130
leaq 0x7796(%rip), %rax      # 0x186c0
movq %rax, 0x40(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r13)
leaq 0x76e3(%rip), %rax      # 0x18620
movq %rax, (%r13)
movq %r13, 0x10(%r12)
movq %r13, %rdi
callq 0x72b0
movq 0x10(%r12), %r13
movl $0x20, %edi
callq 0x7530
leaq 0x7d9c(%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 0xa62c
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_O3/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 0x10ffb
movl %esi, %ebp
cmpl %esi, 0x8(%rdi)
jle 0x10ffb
movl %ebp, %esi
callq 0x920c
movq (%rax), %rdi
testq %rdi, %rdi
je 0x10fd7
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 0x10ffb
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x11051
movl %esi, %ebp
cmpl %esi, 0x8(%rdi)
jle 0x11051
movl %ebp, %esi
callq 0x920c
movq (%rax), %rdi
testq %rdi, %rdi
je 0x1102d
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 0x11051
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x110f4
movq 0x38(%rbx), %rdi
callq 0x7240
cmpl $0x0, 0x8(%rbx)
jle 0x1110d
movq 0x48(%rbx), %rax
movq (%rax), %rax
movq (%rax), %r14
movl $0x0, 0x14(%rbx)
jmp 0x11114
leaq 0x840c(%rip), %r14      # 0x19520
movq %rsp, %rdi
callq 0x9268
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x11190
movq 0x38(%rbx), %rdi
callq 0x7240
movslq 0x14(%rbx), %rax
movl 0x8(%rbx), %ecx
decl %ecx
cmpl %ecx, %eax
jge 0x111b1
movq 0x48(%rbx), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx,%rax,8), %r14
incq %rax
movl %eax, 0x14(%rbx)
jmp 0x111b8
leaq 0x8368(%rip), %r14      # 0x19520
movq %rsp, %rdi
callq 0x9268
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x111e6
movq 0x38(%rbx), %rdi
callq 0x7240
movl 0x8(%rbx), %eax
testl %eax, %eax
jle 0x111ff
decl %eax
movq 0x48(%rbx), %rcx
movq (%rcx), %rcx
movq (%rcx,%rax,8), %r14
movl %eax, 0x14(%rbx)
jmp 0x11206
leaq 0x831a(%rip), %r14      # 0x19520
movq %rsp, %rdi
callq 0x9268
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x33c0
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rax
leaq (%rax,%rsi), %rcx
cmpq %rdx, %rcx
ja 0x33c3
addq 0x10(%rbx), %rax
movq %rcx, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
movq %rbx, %rdi
callq 0x4c8d
movq 0x18(%rbx), %rax
addq %rax, %r14
movq %r14, %rcx
jmp 0x33b0
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %r14
movl 0x14(%rdi), %edi
movq %rsp, %rdx
callq 0x4af0
testb %al, %al
je 0x34f6
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 0x4bf0
testb %al, %al
je 0x34cc
movaps 0x8fa0(%rip), %xmm0     # 0xc3e0
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 0x4cd1
cmpl $0x0, 0x10(%r14)
je 0x3499
movq 0x28(%r14), %rdi
leaq 0xa9(%rip), %rsi        # 0x352e
leaq 0x10(%rsp), %rdx
callq 0x5696
callq 0x31f0
testq %rax, %rax
jne 0x34fa
leaq 0x10(%rsp), %rdi
movq 0x30(%rdi), %rax
leaq 0x48(%rsp), %rsi
movaps 0x8f32(%rip), %xmm0     # 0xc3e0
movups %xmm0, 0x8(%rsi)
movq %rax, (%rsi)
pushq $0x18
popq %rdx
callq 0x4cd1
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0x4d2c
jmp 0x34ce
xorl %ebp, %ebp
decq (%rbx)
jne 0x34db
movq %rbx, %rdi
callq 0x30d0
testb %bpl, %bpl
je 0x34f6
movq 0xcad9(%rip), %rax      # 0xffc0
incq (%rax)
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
jmp 0x34ea
xorl %ebp, %ebp
jmp 0x34c0
// File: /workspace/github_c_makefile_star2_O3/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 0x460b
leaq 0x8(%r14), %rsi
leaq 0x18(%r14), %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0x4714
movq %rax, 0x10(%r14)
testq %rax, %rax
jne 0x4690
xorl %ebp, %ebp
jmp 0x46ef
movb $0x1, 0x18(%r14)
movq $0x0, 0x10(%r14)
movq 0x8(%r15), %rax
testb $0x4, 0xab(%rax)
je 0x4700
movq 0x10(%r15), %rbp
leaq (,%rbp,4), %rdi
callq 0x3370
testq %rax, %rax
je 0x470a
movq %rax, %rbx
testq %rbp, %rbp
jle 0x4689
xorl %r12d, %r12d
movq %r15, %rdi
movq %r12, %rsi
callq 0x3140
movq 0xb928(%rip), %rcx      # 0xff88
movq (%rcx), %rsi
movq %rax, %rdi
callq 0x3060
movq %rax, %r13
cmpq $-0x1, %rax
je 0x4695
movq %r13, %rax
shrq $0x20, %rax
jne 0x46be
movl %r13d, (%rbx,%r12,4)
incq %r12
cmpq %r12, %rbp
jne 0x464e
movq %rbx, 0x8(%r14)
movq %rbp, (%r14)
movb $0x1, %bpl
jmp 0x46ef
callq 0x31f0
testq %rax, %rax
je 0x46be
movq 0xb8e2(%rip), %rax      # 0xff88
movq (%rax), %rdi
leaq 0x4de5(%rip), %rsi      # 0x9495
xorl %ebp, %ebp
movq %r12, %rdx
xorl %eax, %eax
callq 0x3300
jmp 0x46e7
movq 0xb8c3(%rip), %rax      # 0xff88
movq (%rax), %rdi
leaq 0x4de0(%rip), %rsi      # 0x94af
xorl %ebp, %ebp
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
movq %r12, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
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 0x38cb
jmp 0x4604
callq 0x30e0
jmp 0x4604
// File: /workspace/github_c_makefile_star2_O3/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 0x48da
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x45cd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4987
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x4977
movq (%rdi), %r14
callq 0x3070
movq %r14, %rdi
testq %r14, %r14
jne 0x4967
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x38e3
// File: /workspace/github_c_makefile_star2_O3/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 0x49b5
testq %rsi, %rsi
je 0x49b1
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 0x3925
// File: /workspace/github_c_makefile_star2_O3/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 0x49d8
movq (%rdi), %rax
testq %rax, %rax
je 0x49cd
movq %rax, (%rsi)
jmp 0x49d1
movq %rsi, 0x8(%rdi)
movq %rsi, (%rdi)
movq %rsi, %rax
retq
pushq %rax
callq 0x3967
// File: /workspace/github_c_makefile_star2_O3/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 0x4a39
testq %rsi, %rsi
je 0x4a3e
movaps 0x79c8(%rip), %xmm0     # 0xc3e0
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 %rax
retq
callq 0x3a2d
callq 0x39eb
// File: /workspace/github_c_makefile_star2_O3/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 0x4597(%rip), %xmm0     # 0x9000
pmovmskb %xmm0, %ecx
xorl %eax, %eax
cmpl $0xffff, %ecx           # imm = 0xFFFF
je 0x4a78
retq
movl 0x14(%rdi), %eax
leaq 0x4a5a(%rip), %rsi      # 0x94dc
cmpl $0x1e, %eax
ja 0x4abc
movl $0x40100400, %ecx       # imm = 0x40100400
btl %eax, %ecx
jae 0x4abc
cmpl $0x2, 0x10(%rdi)
ja 0x4ab5
movl 0x18(%rdi), %ecx
movl $0x1, %eax
cmpl $0x64, %ecx
je 0x4a77
cmpl $0xc8, %ecx
je 0x4a77
leaq 0x4ab7(%rip), %rsi      # 0x956a
jmp 0x4abc
leaq 0x4a6d(%rip), %rsi      # 0x9529
pushq %rax
movq 0xb4c4(%rip), %rax      # 0xff88
movq (%rax), %rdi
callq 0x3120
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4b24
btl $0x1a, %eax
jae 0x4bb2
movq %r14, %rdi
callq 0x3b05
jmp 0x4b36
btl $0x1a, %eax
jae 0x4bd1
movq %r14, %rdi
callq 0x3add
testb $0x1, %al
je 0x4ba3
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
callq 0x3140
testq %rax, %rax
je 0x4ba6
movq %rax, %r12
movq 0x8(%rax), %rax
testb $0x10, 0xab(%rax)
je 0x4b97
cmpl $0x1e, %ebp
jne 0x4b83
movl $0x1, %esi
movq %r14, %rdi
callq 0x3140
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x4ba3
movq %rax, %rdi
callq 0x32a0
testl %eax, %eax
je 0x4b9e
movq %r12, %rdi
callq 0x30b0
movq %rax, (%rbx)
testq %rax, %rax
setne %r15b
jmp 0x4ba6
callq 0x3ac7
jmp 0x4ba3
callq 0x3ab1
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x456f(%rip), %rdi      # 0x9128
leaq 0x457c(%rip), %rsi      # 0x913c
leaq 0x4592(%rip), %rcx      # 0x9159
movl $0x9, %edx
callq 0x3130
leaq 0x4550(%rip), %rdi      # 0x9128
leaq 0x455d(%rip), %rsi      # 0x913c
leaq 0x4573(%rip), %rcx      # 0x9159
movl $0xe, %edx
callq 0x3130
// File: /workspace/github_c_makefile_star2_O3/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 0x4c7f
movq %rdi, %rbx
movq %r8, %rdi
callq 0x3370
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x4c86
leaq 0x8(%rbx), %r15
leaq 0x462f(%rip), %rsi      # 0x9271
movq %r14, %rdi
callq 0x31d0
movq %rax, %rcx
movq %rax, (%r15)
movb $0x1, %al
testq %rcx, %rcx
jne 0x4c79
movq 0x10(%rbx), %rdi
callq 0x3070
movq $0x0, 0x10(%rbx)
movq 0xb331(%rip), %rax      # 0xffa0
movq (%rax), %rdi
callq 0x3090
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x3b2d
jmp 0x4c77
callq 0x30e0
jmp 0x4c77
// File: /workspace/github_c_makefile_star2_O3/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 0x4d0e
movq 0x18(%r14), %rdi
leaq (%rdi,%rbx), %rcx
cmpq %rax, %rcx
jae 0x4d1e
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
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3b43
jmp 0x4d08
movq %r14, %rdi
callq 0x4c8d
movq 0x18(%r14), %rdi
jmp 0x4cf5
// File: /workspace/github_c_makefile_star2_O3/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 0x4d5d
cmpq $0x0, 0x8(%rbx)
je 0x4d58
cmpq $0x0, 0x18(%rbx)
je 0x4d58
movq %rbx, %rdi
callq 0x4c8d
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x4d5d
callq 0x3070
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x4d6c
popq %rbx
jmp 0x3100
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4dbe
testq %rsi, %rsi
je 0x4dc3
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 0x452b(%rip), %rax      # 0x92c2
movq %rsi, %rdi
movq %rax, %rsi
callq 0x31d0
movq %rax, %rcx
movq %rax, 0x8(%rbx)
movl $0x1, %eax
testq %rcx, %rcx
je 0x4db5
popq %rbx
retq
callq 0x3b87
xorl %eax, %eax
jmp 0x4db3
callq 0x3bd8
callq 0x3b96
// File: /workspace/github_c_makefile_star2_O3/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 0x4e19
movq %rsi, %rax
testq %rsi, %rsi
je 0x4e1e
movq %rdx, %rbx
testq %rdx, %rdx
je 0x4e12
movq 0x8(%rdi), %rcx
movl $0x1, %esi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x30a0
movq %rax, %rcx
movl $0x1, %eax
cmpq %rbx, %rcx
je 0x4e10
movq 0xb19a(%rip), %rax      # 0xffa0
movq (%rax), %rdi
callq 0x3090
xorl %eax, %eax
popq %rbx
retq
callq 0x3c1a
jmp 0x4e0e
callq 0x3c72
callq 0x3c30
// File: /workspace/github_c_makefile_star2_O3/WojciechMula[P]pyahocorasick/src/custompickle/load/loadbuffer.c
// Function: loadbuffer_init
int
loadbuffer_init(LoadBuffer* input, CustompickleHeader* header, CustompickleFooter* footer) {

    long pos;
    int ret;

    ASSERT(input != NULL);
    ASSERT(header != NULL);
    ASSERT(footer != NULL);

    ret = loadbuffer_loadinto(input, header, CustompickleHeader);
    if (UNLIKELY(!ret)) {
        return 0;
    }

    pos = ftell(input->file);
    if (UNLIKELY(pos < 0)) {
        PyErr_SetFromErrno(PyExc_IOError);
        return 0;
    }

    ret = fseek(input->file, -(long int)sizeof(CustompickleFooter), SEEK_END);
    if (UNLIKELY(ret < 0)) {
        PyErr_SetFromErrno(PyExc_IOError);
        return 0;
    }

    ret = loadbuffer_loadinto(input, footer, CustompickleFooter);
    if (UNLIKELY(!ret)) {
        return 0;
    }

    ret = fseek(input->file, pos, SEEK_SET);
    if (UNLIKELY(ret < 0)) {
        PyErr_SetFromErrno(PyExc_IOError);
        return 0;
    }

    if (UNLIKELY(!custompickle_validate_header(header))) {
        PyErr_Format(PyExc_ValueError, "invalid header");
        return 0;
    }

    if (UNLIKELY(!custompickle_validate_footer(footer))) {
        PyErr_Format(PyExc_ValueError, "invalid footer");
        return 0;
    }

    input->store    = header->data.store;
    input->kind     = header->data.kind;
    input->size     = 0;
    input->capacity = footer->nodes_count;
    input->lookup   = (AddressPair*)memory_alloc(sizeof(AddressPair) * input->capacity);
    if (UNLIKELY(input->lookup == NULL)) {
        PyErr_NoMemory();
        return 0;
    }

    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x4f52
movq %rsi, %r15
testq %rsi, %rsi
je 0x4f57
movq %rdx, %r14
testq %rdx, %rdx
je 0x4f5c
movq %rdi, %rbx
movl $0x30, %edx
movq %r15, %rsi
callq 0x4dc8
xorl %ebp, %ebp
testl %eax, %eax
je 0x4f1b
movq 0x8(%rbx), %rdi
callq 0x31c0
testq %rax, %rax
js 0x4f26
movq %rax, %r12
movq 0x8(%rbx), %rdi
movq $-0x18, %rsi
movl $0x2, %edx
callq 0x3260
testl %eax, %eax
js 0x4f2d
movl $0x18, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4dc8
testl %eax, %eax
je 0x4f1b
movq 0x8(%rbx), %rdi
xorl %ebp, %ebp
movq %r12, %rsi
xorl %edx, %edx
callq 0x3260
testl %eax, %eax
js 0x4f34
movq %r15, %rdi
callq 0x4a5d
testl %eax, %eax
je 0x4f3b
movdqu 0x8(%r14), %xmm0
pcmpeqb 0x4126(%rip), %xmm0     # 0x9000
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jne 0x4f42
movq 0x10(%r15), %xmm0
pshufd $0xe1, %xmm0, %xmm0     # xmm0 = xmm0[1,0,2,3]
movq %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
movq (%r14), %rdi
movq %rdi, 0x28(%rbx)
shlq $0x4, %rdi
callq 0x3370
movq %rax, 0x18(%rbx)
movl $0x1, %ebp
testq %rax, %rax
je 0x4f49
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x3d02
jmp 0x4f1b
callq 0x3cf3
jmp 0x4f1b
callq 0x3ce4
jmp 0x4f1b
callq 0x3ccc
jmp 0x4f4e
callq 0x3cb4
jmp 0x4f4e
callq 0x30e0
xorl %ebp, %ebp
jmp 0x4f1b
callq 0x3d95
callq 0x3d53
callq 0x3d11
// File: /workspace/github_c_makefile_star2_O3/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 0x4f8e
callq 0x3100
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x4ff2
cmpq $0x0, 0x20(%rbx)
je 0x4fe2
movl $0x8, %r15d
xorl %r12d, %r12d
movq 0x18(%rbx), %rax
movq (%rax,%r15), %r14
cmpb $0x0, 0x14(%r14)
je 0x4fc9
cmpl $0x1e, 0x10(%rbx)
jne 0x4fc9
movq (%r14), %rdi
decq (%rdi)
jne 0x4fc9
callq 0x30d0
movq %r14, %rdi
callq 0x4ffe
incq %r12
addq $0x10, %r15
cmpq 0x20(%rbx), %r12
jb 0x4fa7
movq 0x18(%rbx), %rdi
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
// File: /workspace/github_c_makefile_star2_O3/WojciechMula[P]pyahocorasick/src/trienode.c
// Function: trienode_free
static void
trienode_free(TrieNode* node) {

    ASSERT(node);

    if (node->n > 0) {
        memory_free(node->next);
    }

    memory_free(node);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x501f
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
je 0x5016
movq 0x18(%rbx), %rdi
callq 0x3070
movq %rbx, %rdi
popq %rbx
jmp 0x3070
callq 0x3e19
// File: /workspace/github_c_makefile_star2_O3/WojciechMula[P]pyahocorasick/src/custompickle/load/loadbuffer.c
// Function: loadbuffer_dump
void
loadbuffer_dump(LoadBuffer* input, FILE* out) {

    AddressPair* pair;
    size_t i;

    for (i=0; i < input->size; i++) {
        pair = &(input->lookup[i]);
        fprintf(out, "%p -> %p\n", pair->original, pair->current);
    }
}

// Assembly:
cmpq $0x0, 0x20(%rdi)
je 0x507a
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x8, %r12d
leaq 0x4304(%rip), %r15      # 0x934b
xorl %r13d, %r13d
movq 0x18(%r14), %rax
movq -0x8(%rax,%r12), %rdx
movq (%rax,%r12), %rcx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x31b0
incq %r13
addq $0x10, %r12
cmpq 0x20(%r14), %r13
jb 0x504a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: automaton_contains
static int
automaton_contains(PyObject* self, PyObject* args) {
#define automaton ((Automaton*)self)
    TrieNode* node;
    struct Input input;

    if (!prepare_input(self, args, &input)) {
        return -1;
    }

    node = trie_find(automaton->root, input.word, input.wordlen);

    destroy_input(&input);

    return (node and node->eow);
#undef automaton
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
callq 0x45cd
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %cl, %cl
je 0x568e
movq 0x28(%rbx), %rdi
leaq 0x8(%rsp), %r14
movq (%r14), %rdx
movq 0x8(%r14), %rsi
callq 0x5759
movq %rax, %rbx
movq %r14, %rdi
callq 0x48e4
xorl %eax, %eax
testq %rbx, %rbx
je 0x568e
cmpb $0x0, 0x14(%rbx)
setne %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/WojciechMula[P]pyahocorasick/src/trie.c
// Function: trie_traverse_aux
static int
trie_traverse_aux(
    TrieNode* node,
    const int depth,
    trie_traverse_callback callback,
    void *extra
) {
    unsigned i;
    if (callback(node, depth, extra) == 0)
        return 0;

    for (i=0; i < node->n; i++) {
        if (trie_traverse_aux(trienode_get_ith_unsafe(node, i), depth + 1, callback, extra) == 0)
            return 0;
    }

    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r12
movq %rcx, %rdx
callq *%r14
testl %eax, %eax
je 0x5717
movl $0x1, %r15d
cmpl $0x0, 0x10(%r12)
je 0x571a
incl %ebp
xorl %r13d, %r13d
movq %r12, %rdi
movq %r13, %rsi
callq 0x572c
movq %rax, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x56b6
testl %eax, %eax
je 0x5717
incq %r13
movl 0x10(%r12), %eax
cmpq %rax, %r13
jb 0x56e9
jmp 0x571a
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/WojciechMula[P]pyahocorasick/src/trie.c
// Function: trie_find
static TrieNode* PURE
trie_find(TrieNode* root, const TRIE_LETTER_TYPE* word, const size_t wordlen) {
    TrieNode* node;
    size_t i;

    node = root;

    if (node != NULL) {
        for (i=0; i < wordlen; i++) {
            node = trienode_get_next(node, word[i]);
            if (node == NULL)
                return NULL;
        }
    }

    return node;
}

// Assembly:
testq %rdi, %rdi
je 0x57a8
movq %rdi, %rax
testq %rdx, %rdx
je 0x57aa
xorl %ecx, %ecx
movl 0x10(%rax), %r8d
testq %r8, %r8
je 0x57a8
movl (%rsi,%rcx,4), %edi
movq 0x18(%rax), %rax
shlq $0x2, %r8
leaq (%r8,%r8,2), %r8
xorl %r9d, %r9d
cmpl %edi, (%rax,%r9)
je 0x5794
addq $0xc, %r9
cmpq %r9, %r8
jne 0x5783
jmp 0x57a8
movq 0x4(%rax,%r9), %rax
testq %rax, %rax
je 0x57a8
incq %rcx
cmpq %rdx, %rcx
jne 0x5768
jmp 0x57aa
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/WojciechMula[P]pyahocorasick/src/trienode.c
// Function: trienode_get_next
static TrieNode* PURE
trienode_get_next(TrieNode* node, const TRIE_LETTER_TYPE letter) {

    unsigned i;
    Pair* next;

    ASSERT(node);
    next = (Pair*)node->next;

    for (i=0; i < node->n; i++)
        if (next[i].letter == letter) {
            return next[i].child;
        }

    return NULL;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x57e4
movl 0x10(%rdi), %eax
testq %rax, %rax
je 0x57d9
movq 0x18(%rdi), %rcx
shlq $0x2, %rax
leaq (%rax,%rax,2), %rdx
xorl %eax, %eax
xorl %edi, %edi
cmpl %esi, (%rcx,%rdi)
je 0x57dd
addq $0xc, %rdi
cmpq %rdi, %rdx
jne 0x57c9
jmp 0x57e2
xorl %eax, %eax
jmp 0x57e2
movq 0x4(%rcx,%rdi), %rax
popq %rcx
retq
callq 0x3f63
// File: /workspace/github_c_makefile_star2_O3/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: automaton_del
static void
automaton_del(PyObject* self) {
#define automaton ((Automaton*)self)
    automaton_clear(self, NULL);
    PyObject_Del(self);
#undef automaton
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movl 0x14(%rbx), %esi
callq 0x5859
xorl %eax, %eax
movq %rax, 0x1c(%rbx)
movl $0x0, 0x10(%rbx)
movq %rax, 0x28(%rbx)
incl 0x30(%rbx)
movq 0xa7ac(%rip), %rax      # 0xffc0
incq (%rax)
movq %rbx, %rdi
popq %rbx
jmp 0x3170
// File: /workspace/github_c_makefile_star2_O3/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: automaton_clear
static PyObject*
automaton_clear(PyObject* self, PyObject* args) {
#define automaton ((Automaton*)self)
    clear_aux(automaton->root, automaton->store);
    automaton->count = 0;
    automaton->longest_word = 0;
    automaton->kind = EMPTY;
    automaton->root = NULL;
    automaton->version += 1;

    Py_RETURN_NONE;
#undef automaton
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movl 0x14(%rbx), %esi
callq 0x5859
xorl %eax, %eax
movq %rax, 0x1c(%rbx)
movl $0x0, 0x10(%rbx)
movq %rax, 0x28(%rbx)
incl 0x30(%rbx)
movq 0xa76c(%rip), %rax      # 0xffc0
incq (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: clear_aux
static void
clear_aux(TrieNode* node, KeysStore store) {

    unsigned i;

    if (node) {
        switch (store) {
            case STORE_INTS:
            case STORE_LENGTH:
                // nop
                break;

            case STORE_ANY:
                if (node->eow && node->output.object)
                    Py_DECREF(node->output.object);
                break;
        }

        for (i=0; i < node->n; i++) {
            TrieNode* child = trienode_get_ith_unsafe(node, i);
            if (child != node) // avoid self-loops!
                clear_aux(child, store);
        }

        trienode_free(node);
    }
#undef automaton
}

// Assembly:
testq %rdi, %rdi
je 0x58ce
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x1e, %esi
jne 0x5887
cmpb $0x0, 0x14(%rbx)
je 0x5887
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5887
decq (%rdi)
jne 0x5887
callq 0x30d0
movl 0x10(%rbx), %eax
testl %eax, %eax
je 0x58bc
movl $0x4, %r14d
xorl %r15d, %r15d
movq 0x18(%rbx), %rcx
movq (%rcx,%r14), %rdi
cmpq %rbx, %rdi
je 0x58ae
movl %ebp, %esi
callq 0x5859
movl 0x10(%rbx), %eax
incq %r15
movl %eax, %ecx
addq $0xc, %r14
cmpq %rcx, %r15
jb 0x5897
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4ffe
retq
// File: /workspace/github_c_makefile_star2_O3/WojciechMula[P]pyahocorasick/src/AutomatonItemsIter.c
// Function: automaton_items_iter_del
static void
automaton_items_iter_del(PyObject* self) {
    memory_safefree(iter->buffer);
    memory_safefree(iter->pattern);
#ifndef AHOCORASICK_UNICODE
    memory_safefree(iter->char_buffer);
#endif

    list_delete(&iter->stack);
    Py_DECREF(iter->automaton);

    PyObject_Del(self);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x5cc3
callq 0x3070
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x5cd1
callq 0x3070
leaq 0x30(%rbx), %r14
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x5cee
movq (%rdi), %r15
callq 0x3070
movq %r15, %rdi
testq %r15, %r15
jne 0x5cde
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq 0x10(%rbx), %rdi
decq (%rdi)
jne 0x5d03
callq 0x30d0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3170
// File: /workspace/github_c_makefile_star2_O3/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: automaton_remove_word
static PyObject*
automaton_remove_word(PyObject* self, PyObject* args) {
    PyObject* value;

    switch (automaton_remove_word_aux(self, args, &value)) {
        case FALSE:
            Py_RETURN_FALSE;
            break;

        case TRUE:
            if (automaton->store == STORE_ANY) {
                // value is meaningful
                Py_DECREF(value);
            }

            automaton->version += 1;
            automaton->count   -= 1;
            Py_RETURN_TRUE;
            break;

        case MEMORY_ERROR:
        default:
            return NULL;
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
callq 0x723b
cmpl $0x2, %eax
je 0x639f
cmpl $0x1, %eax
jne 0x63ab
cmpl $0x1e, 0x14(%rbx)
jne 0x6390
movq 0x8(%rsp), %rdi
decq (%rdi)
jne 0x6390
callq 0x30d0
incl 0x30(%rbx)
decl 0x1c(%rbx)
movq 0x9c2b(%rip), %rax      # 0xffc8
jmp 0x63a6
movq 0x9c02(%rip), %rax      # 0xffa8
incq (%rax)
jmp 0x63ad
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: automaton_pop
static PyObject*
automaton_pop(PyObject* self, PyObject* args) {
    PyObject* value;

    switch (automaton_remove_word_aux(self, args, &value)) {
        case FALSE:
            PyErr_SetNone(PyExc_KeyError);
            return NULL;

        case TRUE:
            automaton->version += 1;
            automaton->count   -= 1;
            return value; // there's no need to increase refcount, the value was removed

        case MEMORY_ERROR:
        default:
            return NULL;
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
callq 0x723b
cmpl $0x1, %eax
je 0x63e2
cmpl $0x2, %eax
jne 0x63de
movq 0x9bc2(%rip), %rax      # 0xff98
movq (%rax), %rdi
callq 0x3160
xorl %eax, %eax
jmp 0x63ed
incl 0x30(%rbx)
decl 0x1c(%rbx)
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: automaton_exists
static PyObject*
automaton_exists(PyObject* self, PyObject* args) {
    PyObject* word;

    word = F(PyTuple_GetItem)(args, 0);
    if (word)
        switch (automaton_contains(self, word)) {
            case 1:
                Py_RETURN_TRUE;

            case 0:
                Py_RETURN_FALSE;

            default:
                return NULL;
        }
    else
        return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3140
testq %rax, %rax
je 0x6436
movq %r14, %rdi
movq %rax, %rsi
callq 0x5641
cmpl $0x1, %eax
je 0x6428
testl %eax, %eax
jne 0x6434
movq 0x9b82(%rip), %rbx      # 0xffa8
jmp 0x642f
movq 0x9b99(%rip), %rbx      # 0xffc8
incq (%rbx)
jmp 0x6436
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: automaton_match
static PyObject*
automaton_match(PyObject* self, PyObject* args) {
#define automaton ((Automaton*)self)
    TrieNode* node;
    struct Input input;

    if (!prepare_input_from_tuple(self, args, 0, &input)) {
        return NULL;
    }

    node = trie_find(automaton->root, input.word, input.wordlen);;

    destroy_input(&input);

    if (node)
        Py_RETURN_TRUE;
    else
        Py_RETURN_FALSE;
#undef automaton
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3140
testq %rax, %rax
je 0x64ae
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x45cd
testb %al, %al
je 0x649f
movq 0x28(%rbx), %rdi
leaq 0x8(%rsp), %rbx
movq (%rbx), %rdx
movq 0x8(%rbx), %rsi
callq 0x5759
movq %rax, %r14
movq %rbx, %rdi
callq 0x48e4
testq %r14, %r14
jne 0x64a4
movq 0x9b0b(%rip), %r14      # 0xffa8
jmp 0x64ab
xorl %r14d, %r14d
jmp 0x64ae
movq 0x9b1d(%rip), %r14      # 0xffc8
incq (%r14)
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: automaton_longest_prefix
static PyObject*
automaton_longest_prefix(PyObject* self, PyObject* args) {
#define automaton ((Automaton*)self)
    int len;
    struct Input input;

    if (!prepare_input_from_tuple(self, args, 0, &input)) {
        return NULL;
    }

    len = trie_longest(automaton->root, input.word, input.wordlen);

    destroy_input(&input);

    return F(Py_BuildValue)("i", len);
#undef automaton
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3140
testq %rax, %rax
je 0x6518
movq %rsp, %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x45cd
testb %al, %al
je 0x6518
movq (%rsp), %r14
testq %r14, %r14
je 0x6524
movq 0x8(%rsp), %r15
movq 0x28(%rbx), %rax
xorl %ebx, %ebx
movl (%r15,%rbx,4), %esi
movq %rax, %rdi
callq 0x57ab
testq %rax, %rax
je 0x6526
incq %rbx
cmpq %rbx, %r14
jne 0x64fa
movq %r14, %rbx
jmp 0x6526
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
xorl %ebx, %ebx
movq %rsp, %rdi
callq 0x48e4
leaq 0x57e0(%rip), %rdi      # 0xbd15
movl %ebx, %esi
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3330