LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xbfd0
movq -0x38(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jle 0x1c4f7
movq -0x38(%rbp), %rdi
addq $0x40, %rdi
xorl %esi, %esi
callq 0xd8c0
movq %rax, -0x40(%rbp)
jmp 0x1c4bc
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl $0x0, 0x14(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x30(%rbp)
jmp 0x1c509
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xc030
jmp 0x1c51c
leaq 0x902a(%rip), %rax      # 0x25528
movq %rax, -0x8(%rbp)
movl $0x1, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xc030
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x8290
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xbfd0
movq -0x38(%rbp), %rcx
movl 0x14(%rcx), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1c64c
movq -0x38(%rbp), %rdi
addq $0x40, %rdi
movl -0x1c(%rbp), %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
callq 0xd8c0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x14(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x2c(%rbp)
jmp 0x1c65e
leaq 0x8ed5(%rip), %rax      # 0x25528
movq %rax, -0x8(%rbp)
movl $0x1, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xc030
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xbfd0
movq -0x30(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jle 0x1c6e2
movq -0x30(%rbp), %rax
movq %rax, %rdi
addq $0x40, %rdi
movl 0x8(%rax), %esi
subl $0x1, %esi
callq 0xd8c0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x20(%rbp)
movl 0x8(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x14(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x24(%rbp)
jmp 0x1c6f4
leaq 0x8e3f(%rip), %rax      # 0x25528
movq %rax, -0x8(%rbp)
movl $0x1, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xc030
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x64, 0x18(%rax)
jne 0x3589
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
movq -0x20(%rbp), %rdx
movq -0x20(%rbp), %rcx
addq $0x18, %rcx
callq 0x35d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3587
movb $0x0, -0x1(%rbp)
jmp 0x35c2
jmp 0x35be
movq -0x20(%rbp), %rax
movb $0x1, 0x18(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
movq -0x20(%rbp), %rdx
callq 0x3970
testb $0x1, %al
jne 0x35bc
movb $0x0, -0x1(%rbp)
jmp 0x35c2
jmp 0x35be
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/utils.c
// Function: pymod_get_sequence
static bool
pymod_get_sequence(PyObject* obj, TRIE_LETTER_TYPE** word, Py_ssize_t* wordlen) {
    if (LIKELY(F(PyTuple_Check)(obj))) {
        return __read_sequence__from_tuple(obj, word, wordlen);
    } else {
        PyErr_Format(PyExc_TypeError, "argument is not a supported sequence type");
        return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x4000000, %esi        # imm = 0x4000000
callq 0x4450
cltq
cmpq $0x0, %rax
je 0x39b6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5840
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x39d2
movq 0xe5d3(%rip), %rax      # 0x11f90
movq (%rax), %rdi
leaq 0x8a74(%rip), %rsi      # 0xc43b
movb $0x0, %al
callq 0x3300
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x3140
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x3a27
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x3530
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3a2b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/slist.c
// Function: list_item_new
ListItem*
list_item_new(const size_t size) {
    ListItem* item = (ListItem*)memory_alloc(size);
    if (item) {
        item->__next = 0;
    }

    return item;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3450
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3b5b
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3c1f
movq 0xe41e(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x842c(%rip), %rsi      # 0xc010
leaq 0x843c(%rip), %rdx      # 0xc027
leaq 0x8441(%rip), %rcx      # 0xc033
movl $0x32, %r8d
leaq 0xb4b8(%rip), %r9       # 0xf0b7
movb $0x0, %al
callq 0x31b0
movq 0xe3eb(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
callq 0x3230
movl $0x1, %edi
callq 0x3310
jmp 0x3c21
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3c51
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x34b0
jmp 0x3c2c
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3cd3
movq 0xe36a(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x8378(%rip), %rsi      # 0xc010
leaq 0x8388(%rip), %rdx      # 0xc027
leaq 0x8399(%rip), %rcx      # 0xc03f
movl $0x42, %r8d
leaq 0xb404(%rip), %r9       # 0xf0b7
movb $0x0, %al
callq 0x31b0
movq 0xe337(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
callq 0x3230
movl $0x1, %edi
callq 0x3310
jmp 0x3cd5
cmpq $0x0, -0x10(%rbp)
je 0x3d19
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3d04
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3d17
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3d19
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3d93
movq 0xe2aa(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x82b8(%rip), %rsi      # 0xc010
leaq 0x82c8(%rip), %rdx      # 0xc027
leaq 0x82e5(%rip), %rcx      # 0xc04b
movl $0x53, %r8d
leaq 0xb344(%rip), %r9       # 0xf0b7
movb $0x0, %al
callq 0x31b0
movq 0xe277(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
callq 0x3230
movl $0x1, %edi
callq 0x3310
jmp 0x3d95
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3dba
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3dcd
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/slist.c
// Function: list_pop_first
ListItem*
list_pop_first(List* list) {
    ListItem* item;

    ASSERT(list);

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

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

        return item;
    }
    else
        return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3e3f
movq 0xe1fe(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x820c(%rip), %rsi      # 0xc010
leaq 0x821c(%rip), %rdx      # 0xc027
leaq 0x8249(%rip), %rcx      # 0xc05b
movl $0x64, %r8d
leaq 0xb298(%rip), %r9       # 0xf0b7
movb $0x0, %al
callq 0x31b0
movq 0xe1cb(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
callq 0x3230
movl $0x1, %edi
callq 0x3310
jmp 0x3e41
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3e84
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3e7a
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3e8c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3f03
movq 0xe13a(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x8148(%rip), %rsi      # 0xc010
leaq 0x819b(%rip), %rdx      # 0xc06a
leaq 0x81b4(%rip), %rcx      # 0xc08a
movl $0xd, %r8d
leaq 0x81c6(%rip), %r9       # 0xc0a9
movb $0x0, %al
callq 0x31b0
movq 0xe107(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
callq 0x3230
movl $0x1, %edi
callq 0x3310
jmp 0x3f05
jmp 0x3f07
cmpq $0x0, -0x10(%rbp)
jne 0x3f5a
movq 0xe0e3(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x80f1(%rip), %rsi      # 0xc010
leaq 0x8144(%rip), %rdx      # 0xc06a
leaq 0x815d(%rip), %rcx      # 0xc08a
movl $0xe, %r8d
leaq 0x817e(%rip), %r9       # 0xc0b8
movb $0x0, %al
callq 0x31b0
movq 0xe0b0(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
callq 0x3230
movl $0x1, %edi
callq 0x3310
jmp 0x3f5c
movq -0x8(%rbp), %rax
movq 0xb569(%rip), %rcx      # 0xf4d0
movq %rcx, (%rax)
movq 0xb567(%rip), %rcx      # 0xf4d8
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movslq 0x1c(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/custompickle/custompickle.c
// Function: custompickle_validate_header
int custompickle_validate_header(CustompickleHeader* header) {
    if (memcmp(header->magick, CUSTOMPICKLE_MAGICK, sizeof(CUSTOMPICKLE_MAGICK)) != 0)
        return false;

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

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

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

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movups (%rax), %xmm0
movaps 0x7f86(%rip), %xmm1     # 0xc000
pcmpeqb %xmm1, %xmm0
pmovmskb %xmm0, %eax
subl $0xffff, %eax           # imm = 0xFFFF
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x409b
movl $0x0, -0x4(%rbp)
jmp 0x40ed
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edi
callq 0x4100
testb $0x1, %al
jne 0x40b4
movl $0x0, -0x4(%rbp)
jmp 0x40ed
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x4160
testb $0x1, %al
jne 0x40cd
movl $0x0, -0x4(%rbp)
jmp 0x40ed
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
callq 0x41a0
testb $0x1, %al
jne 0x40e6
movl $0x0, -0x4(%rbp)
jmp 0x40ed
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: check_store
static bool
check_store(const int store) {
    switch (store) {
        case STORE_LENGTH:
        case STORE_INTS:
        case STORE_ANY:
            return true;

        default:
            PyErr_SetString(
                PyExc_ValueError,
                "store value must be one of ahocorasick.STORE_LENGTH, STORE_INTS or STORE_ANY"
            );
            return false;
    } // switch
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0xa, %eax
je 0x412c
jmp 0x4118
movl -0xc(%rbp), %eax
subl $0x14, %eax
je 0x412c
jmp 0x4122
movl -0xc(%rbp), %eax
subl $0x1e, %eax
jne 0x4132
jmp 0x412c
movb $0x1, -0x1(%rbp)
jmp 0x414c
movq 0xde4f(%rip), %rax      # 0x11f88
movq (%rax), %rdi
leaq 0x83c5(%rip), %rsi      # 0xc508
callq 0x3120
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: check_kind
static bool
check_kind(const int kind) {
    switch (kind) {
        case EMPTY:
        case TRIE:
        case AHOCORASICK:
            return true;

        default:
            PyErr_SetString(
                PyExc_ValueError,
                "kind value must be one of ahocorasick.EMPTY, TRIE or AHOCORASICK"
            );
            return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
subl $0x2, %eax
ja 0x417b
jmp 0x4175
movb $0x1, -0x1(%rbp)
jmp 0x4195
movq 0xde06(%rip), %rax      # 0x11f88
movq (%rax), %rdi
leaq 0x83c9(%rip), %rsi      # 0xc555
callq 0x3120
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: check_key_type
static bool
check_key_type(const int store) {
    switch (store) {
        case KEY_STRING:
        case KEY_SEQUENCE:
            return true;

        default:
            PyErr_SetString(
                PyExc_ValueError,
                "key_type must have value KEY_STRING or KEY_SEQUENCE"
            );
            return false;
    } // switch
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x64, %eax
je 0x41c4
jmp 0x41b8
movl -0xc(%rbp), %eax
subl $0xc8, %eax
jne 0x41ca
jmp 0x41c4
movb $0x1, -0x1(%rbp)
jmp 0x41e4
movq 0xddb7(%rip), %rax      # 0x11f88
movq (%rax), %rdi
leaq 0x83bb(%rip), %rsi      # 0xc596
callq 0x3120
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
xorl %eax, %eax
cmpl $0x1e, -0x1c(%rbp)
movb %al, -0x31(%rbp)
jne 0x4512
cmpq $0x0, -0x18(%rbp)
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x4541
movq 0xda5f(%rip), %rax      # 0x11f88
movq (%rax), %rdi
leaq 0x7cd7(%rip), %rsi      # 0xc20a
callq 0x3120
movb $0x0, -0x1(%rbp)
jmp 0x45d1
movq -0x30(%rbp), %rdi
callq 0x3450
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x4579
callq 0x30e0
movb $0x0, -0x1(%rbp)
jmp 0x45d1
movq -0x28(%rbp), %rdi
leaq 0x7cbd(%rip), %rsi      # 0xc241
callq 0x31d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x45cd
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x34b0
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq 0xd9e1(%rip), %rax      # 0x11fa0
movq (%rax), %rdi
callq 0x3090
movb $0x0, -0x1(%rbp)
jmp 0x45d1
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x4686
movq $0x0, -0x8(%rbp)
jmp 0x46df
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x46b3
movq -0x10(%rbp), %rdi
callq 0x45e0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x18(%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x475a
movq -0x8(%rbp), %rdi
callq 0x45e0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x1, %esi
callq 0x3320
cmpq -0x18(%rbp), %rax
je 0x4758
movq 0xd850(%rip), %rax      # 0x11fa0
movq (%rax), %rdi
callq 0x3090
jmp 0x47b4
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
setae %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x4787
movq -0x8(%rbp), %rdi
callq 0x45e0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
addq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x31e0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4836
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4836
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jbe 0x4836
movq -0x8(%rbp), %rdi
callq 0x45e0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x34d0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x485b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3100
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x14(%rax), %edi
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x4230
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x48b5
movq $0x0, -0x8(%rbp)
jmp 0x490b
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x32d0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x4920
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3a90
movslq -0x34(%rbp), %rax
cmpq $0x0, %rax
je 0x4903
movq 0xd6c8(%rip), %rdi      # 0x11fc0
callq 0x4a30
movq %rax, -0x8(%rbp)
jmp 0x490b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/custompickle/save/automaton_save.c
// Function: automaton_save_impl
static bool
automaton_save_impl(Automaton* automaton, const char* path, PyObject* serializer) {

    CustompickleHeader header;
    CustompickleFooter footer;
    SaveBuffer         output;
    int                ret;

    ret = savebuffer_init(&output,
                          serializer,
                          automaton->store,
                          path,
                          SAVEBUFFER_DEFAULT_SIZE);
    if (!ret)
        return false;

    custompickle_initialize_header(&header, automaton);

    // 1. save header
    savebuffer_store(&output, (const char*)&header, sizeof(header));

    // 2. save nodes
    if (automaton->kind != EMPTY) {
        trie_traverse(automaton->root, automaton_save_node, &output);
        if (UNLIKELY(PyErr_Occurred() != NULL)) {
            goto exception;
        }
    }

    // 3. save footer
    custompickle_initialize_footer(&footer, output.nodes_count);
    savebuffer_store(&output, (const char*)&footer, sizeof(footer));

    savebuffer_finalize(&output);

    return true;

exception:
    savebuffer_finalize(&output);

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edx
movq -0x18(%rbp), %rcx
leaq -0xa0(%rbp), %rdi
movl $0x8000, %r8d           # imm = 0x8000
callq 0x4490
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xa4(%rbp)
cmpl $0x0, -0xa4(%rbp)
jne 0x4975
movb $0x0, -0x1(%rbp)
jmp 0x4a1d
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x3ea0
leaq -0xa0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x30, %edx
callq 0x46f0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x49d9
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
leaq 0x1110(%rip), %rsi      # 0x5ac0
leaq -0xa0(%rbp), %rdx
callq 0x59e0
callq 0x31f0
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x49d7
jmp 0x4a0d
jmp 0x49d9
movq -0x70(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x3fd0
leaq -0xa0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movl $0x18, %edx
callq 0x46f0
leaq -0xa0(%rbp), %rdi
callq 0x4800
movb $0x1, -0x1(%rbp)
jmp 0x4a1d
leaq -0xa0(%rbp), %rdi
callq 0x4800
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4ab7
movq 0xd586(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x7594(%rip), %rsi      # 0xc010
leaq 0x77c1(%rip), %rdx      # 0xc244
leaq 0x77dd(%rip), %rcx      # 0xc267
movl $0x7, %r8d
leaq 0x77e0(%rip), %r9       # 0xc277
movb $0x0, %al
callq 0x31b0
movq 0xd553(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
callq 0x3230
movl $0x1, %edi
callq 0x3310
jmp 0x4ab9
jmp 0x4abb
cmpq $0x0, -0x18(%rbp)
jne 0x4b0e
movq 0xd52f(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x753d(%rip), %rsi      # 0xc010
leaq 0x776a(%rip), %rdx      # 0xc244
leaq 0x7786(%rip), %rcx      # 0xc267
movl $0x8, %r8d
leaq 0x7797(%rip), %r9       # 0xc285
movb $0x0, %al
callq 0x31b0
movq 0xd4fc(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
callq 0x3230
movl $0x1, %edi
callq 0x3310
jmp 0x4b10
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
leaq 0x773c(%rip), %rsi      # 0xc292
callq 0x31d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x4b97
movq 0xd41a(%rip), %rax      # 0x11fa0
movq (%rax), %rdi
callq 0x3090
movl $0x0, -0x4(%rbp)
jmp 0x4b9e
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4c17
movq 0xd426(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x7434(%rip), %rsi      # 0xc010
leaq 0x7661(%rip), %rdx      # 0xc244
leaq 0x76ab(%rip), %rcx      # 0xc295
movl $0x1e, %r8d
leaq 0x7680(%rip), %r9       # 0xc277
movb $0x0, %al
callq 0x31b0
movq 0xd3f3(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
callq 0x3230
movl $0x1, %edi
callq 0x3310
jmp 0x4c19
jmp 0x4c1b
cmpq $0x0, -0x18(%rbp)
jne 0x4c6e
movq 0xd3cf(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x73dd(%rip), %rsi      # 0xc010
leaq 0x760a(%rip), %rdx      # 0xc244
leaq 0x7654(%rip), %rcx      # 0xc295
movl $0x1f, %r8d
leaq 0x7657(%rip), %r9       # 0xc2a5
movb $0x0, %al
callq 0x31b0
movq 0xd39c(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
callq 0x3230
movl $0x1, %edi
callq 0x3310
jmp 0x4c70
cmpq $0x0, -0x20(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x4ca4
movq 0xd2fc(%rip), %rax      # 0x11f88
movq (%rax), %rdi
leaq 0x761e(%rip), %rsi      # 0xc2b4
callq 0x3120
movl $0x0, -0x4(%rbp)
jmp 0x4ceb
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x1, %esi
callq 0x30a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x4ce4
movq 0xd2cd(%rip), %rax      # 0x11fa0
movq (%rax), %rdi
callq 0x3090
movl $0x0, -0x4(%rbp)
jmp 0x4ceb
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5114
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3100
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x5197
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x518a
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x14(%rax), %eax
cmpl $0x0, %eax
je 0x5173
movq -0x8(%rbp), %rax
cmpl $0x1e, 0x10(%rax)
jne 0x5173
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3a90
movq -0x10(%rbp), %rdi
callq 0x51a0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5127
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x34b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x51ff
movq 0xce3e(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x6e4c(%rip), %rsi      # 0xc010
leaq 0x7421(%rip), %rdx      # 0xc5ec
leaq 0x74d8(%rip), %rcx      # 0xc6aa
movl $0x20, %r8d
leaq 0x9bb4(%rip), %r9       # 0xed93
movb $0x0, %al
callq 0x31b0
movq 0xce0b(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
callq 0x3230
movl $0x1, %edi
callq 0x3310
jmp 0x5201
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jbe 0x5218
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x34b0
movq -0x8(%rbp), %rdi
callq 0x34b0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x529c
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x7094(%rip), %rsi      # 0xc31b
movb $0x0, %al
callq 0x31b0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5248
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/custompickle/load/module_automaton_load.c
// Function: module_automaton_load
PyObject*
module_automaton_load(PyObject* module, PyObject* args) {

    SaveLoadParameters params;
    Automaton* automaton;
    int ret;

    automaton = (Automaton*)automaton_create();
    if (UNLIKELY(automaton == NULL)) {
        return NULL;
    }

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

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

    if (LIKELY(ret))
        return (PyObject*)automaton;
    else
        return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x5380
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x52eb
movq $0x0, -0x8(%rbp)
jmp 0x536f
movq -0x30(%rbp), %rax
movl 0x14(%rax), %edi
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x4230
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x5321
movq -0x30(%rbp), %rdi
callq 0x3a90
movq $0x0, -0x8(%rbp)
jmp 0x536f
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x32d0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x5430
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3a90
movslq -0x34(%rbp), %rax
cmpq $0x0, %rax
je 0x5367
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x536f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: automaton_create
static PyObject*
automaton_create() {

    Automaton* automaton;

    automaton = (Automaton*)F(PyObject_New)(Automaton, &automaton_type);
    if (UNLIKELY(automaton == NULL)) {
        return NULL;
    }

    automaton->kind = EMPTY;
    automaton->store = STORE_ANY;
    automaton->key_type = KEY_STRING;
    automaton->count = 0;
    automaton->longest_word = 0;

    automaton->version = 0;
    automaton->stats.version = -1;

    automaton->root = NULL;

    return (PyObject*)automaton;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xce41(%rip), %rdi      # 0x121d0
callq 0x32b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x53b7
movq $0x0, -0x8(%rbp)
jmp 0x5418
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x1e, 0x14(%rax)
movq -0x10(%rbp), %rax
movl $0x64, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x38(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x3530
testb $0x1, %al
jne 0x57be
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5808
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x6480
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3a40
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x41(%rbp)
je 0x57fd
movq -0x20(%rbp), %rax
movzbl 0x14(%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x28(%rbp), %rdx
callq *%rax
cmpl $0x0, %eax
jne 0x5d66
movl $0x0, -0x4(%rbp)
jmp 0x5dbf
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x5db8
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x5dd0
movq %rax, %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x5d30
cmpl $0x0, %eax
jne 0x5dab
movl $0x0, -0x4(%rbp)
jmp 0x5dbf
jmp 0x5dad
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5d6d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/custompickle/load/module_automaton_load.c
// Function: automaton_load_fixup_pointers
static TrieNode*
automaton_load_fixup_pointers(LoadBuffer* input) {

    TrieNode* root;
    TrieNode* node;
    size_t i;

    ASSERT(input != NULL);

    // 1. root is the first node stored in the array
    root = input->lookup[0].current;

    // 2. sort array to make it bsearch-able
    qsort(input->lookup, input->size, sizeof(AddressPair), addresspair_cmp);

    // 3. convert all next and fail pointers to current pointers
    for (i=0; i < input->size; i++) {
        node = input->lookup[i].current;
        if (UNLIKELY(!automaton_load_fixup_node(input, node))) {
            PyErr_Format(PyExc_ValueError, "Detected malformed pointer during unpickling node %lu", i);
            return NULL;
        }
    }

    loadbuffer_invalidate(input);

    return root;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x61bf
movq 0xbe7e(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x5e8c(%rip), %rsi      # 0xc010
leaq 0x6554(%rip), %rdx      # 0xc6df
leaq 0x65a3(%rip), %rcx      # 0xc735
movl $0x104, %r8d            # imm = 0x104
leaq 0x60d8(%rip), %r9       # 0xc277
movb $0x0, %al
callq 0x31b0
movq 0xbe4b(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
callq 0x3230
movl $0x1, %edi
callq 0x3310
jmp 0x61c1
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movl $0x10, %edx
leaq 0xa3(%rip), %rcx        # 0x6290
callq 0x3080
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x6275
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6300
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x6265
movq 0xbd42(%rip), %rax      # 0x11f88
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0x64ff(%rip), %rsi      # 0xc753
movb $0x0, %al
callq 0x3300
movq $0x0, -0x8(%rbp)
jmp 0x6286
jmp 0x6267
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x61fa
movq -0x10(%rbp), %rdi
callq 0x5070
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/custompickle/load/module_automaton_load.c
// Function: addresspair_cmp
static int
addresspair_cmp(const void* a, const void *b) {
    const TrieNode* Aptr;
    const TrieNode* Bptr;
    uintptr_t A;
    uintptr_t B;

    Aptr = ((AddressPair*)a)->original;
    Bptr = ((AddressPair*)b)->original;

    A = (uintptr_t)Aptr;
    B = (uintptr_t)Bptr;

    if (A < B) {
        return -1;
    } else if (A > B) {
        return +1;
    } else {
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x62d5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x62ef
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jbe 0x62e8
movl $0x1, -0x4(%rbp)
jmp 0x62ef
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)