LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/custompickle/load/module_automaton_load.c
// Function: automaton_load_fixup_node
static bool
automaton_load_fixup_node(LoadBuffer* input, TrieNode* node) {

    size_t i;

    if (input->kind == AHOCORASICK && node->fail != NULL) {
        node->fail = lookup_address(input, node->fail);
        if (UNLIKELY(node->fail == NULL)) {
            return false;
        }
    }

    if (node->n > 0) {
        for (i=0; i < node->n; i++) {
            node->next[i].child = lookup_address(input, node->next[i].child);
            if (UNLIKELY(node->next[i].child == NULL)) {
                return false;
            }
        }
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x14(%rax)
jne 0x6365
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6365
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x6410
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x6363
movb $0x0, -0x1(%rbp)
jmp 0x6400
jmp 0x6365
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jbe 0x63fc
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x10(%rcx), %ecx
cmpq %rcx, %rax
jae 0x63fa
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
imulq $0xc, -0x20(%rbp), %rcx
addq %rcx, %rax
movq 0x4(%rax), %rsi
callq 0x6410
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
imulq $0xc, -0x20(%rbp), %rdx
addq %rdx, %rax
movq %rcx, 0x4(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
imulq $0xc, -0x20(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, 0x4(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x63ea
movb $0x0, -0x1(%rbp)
jmp 0x6400
jmp 0x63ec
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x637b
jmp 0x63fc
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %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: lookup_address
static TrieNode*
lookup_address(LoadBuffer* input, TrieNode* original) {

    AddressPair* pair;

    pair = (AddressPair*)bsearch(&original,
                                 input->lookup,
                                 input->size,
                                 sizeof(AddressPair),
                                 addresspair_cmp);

    if (LIKELY(pair != NULL)) {
        return pair->current;
    } else {
        return NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
leaq -0x18(%rbp), %rdi
movl $0x10, %ecx
leaq -0x1b0(%rip), %r8       # 0x6290
callq 0x3340
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x646c
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6474
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x64f0
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x64ee
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x6510
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x64de
movq $0x0, -0x8(%rbp)
jmp 0x64f8
jmp 0x64e0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x64ab
jmp 0x64f0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6572
movq 0xbacb(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x5ad9(%rip), %rsi      # 0xc010
leaq 0x60ae(%rip), %rdx      # 0xc5ec
leaq 0x6244(%rip), %rcx      # 0xc789
movl $0x30, %r8d
leaq 0x8841(%rip), %r9       # 0xed93
movb $0x0, %al
callq 0x31b0
movq 0xba98(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
callq 0x3230
movl $0x1, %edi
callq 0x3310
jmp 0x6574
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x65cd
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x65c0
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq 0x4(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x65d5
jmp 0x65c2
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6587
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %esi
callq 0x6920
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movq 0xb6ab(%rip), %rdi      # 0x11fc0
callq 0x4a30
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x69d3
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0xa, %eax
je 0x695b
jmp 0x6947
movl -0x1c(%rbp), %eax
subl $0x14, %eax
je 0x695b
jmp 0x6951
movl -0x1c(%rbp), %eax
subl $0x1e, %eax
je 0x695d
jmp 0x6982
jmp 0x6982
movq -0x8(%rbp), %rax
movzbl 0x14(%rax), %eax
cmpl $0x0, %eax
je 0x6980
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6980
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3a90
jmp 0x6982
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x69ca
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x5dd0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x69bd
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x6920
jmp 0x69bf
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6989
movq -0x8(%rbp), %rdi
callq 0x51a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x34d0
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x34d0
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x3bc0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3a90
movq -0x8(%rbp), %rdi
callq 0x3170
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x8fe0
movl %eax, %ecx
movl %ecx, -0x24(%rbp)
testl %eax, %eax
je 0x77a1
jmp 0x773c
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x7762
jmp 0x7746
movl -0x24(%rbp), %eax
subl $0x2, %eax
jne 0x77a3
jmp 0x7750
movq 0xa851(%rip), %rdi      # 0x11fa8
callq 0x4a30
movq %rax, -0x8(%rbp)
jmp 0x77ab
movq -0x10(%rbp), %rax
cmpl $0x1e, 0x14(%rax)
jne 0x7775
movq -0x20(%rbp), %rdi
callq 0x3a90
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x1c(%rax)
movq 0xa832(%rip), %rdi      # 0x11fc8
callq 0x4a30
movq %rax, -0x8(%rbp)
jmp 0x77ab
jmp 0x77a3
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x8fe0
movl %eax, %ecx
movl %ecx, -0x24(%rbp)
testl %eax, %eax
je 0x783d
jmp 0x77ec
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x7819
jmp 0x77f6
movl -0x24(%rbp), %eax
subl $0x2, %eax
jne 0x783f
jmp 0x7800
movq 0xa791(%rip), %rax      # 0x11f98
movq (%rax), %rdi
callq 0x3160
movq $0x0, -0x8(%rbp)
jmp 0x7847
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x1c(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7847
jmp 0x783f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3140
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x78d8
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5790
movl %eax, %ecx
movl %ecx, -0x24(%rbp)
testl %eax, %eax
je 0x78bc
jmp 0x78a0
movl -0x24(%rbp), %eax
subl $0x1, %eax
jne 0x78ce
jmp 0x78aa
movq 0xa717(%rip), %rdi      # 0x11fc8
callq 0x4a30
movq %rax, -0x8(%rbp)
jmp 0x78e0
movq 0xa6e5(%rip), %rdi      # 0x11fa8
callq 0x4a30
movq %rax, -0x8(%rbp)
jmp 0x78e0
movq $0x0, -0x8(%rbp)
jmp 0x78e0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
leaq -0x40(%rbp), %rcx
callq 0x39e0
testb $0x1, %al
jne 0x7921
movq $0x0, -0x8(%rbp)
jmp 0x796c
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
cmpq $0x0, -0x20(%rbp)
je 0x795c
movq 0xa677(%rip), %rdi      # 0x11fc8
callq 0x4a30
movq %rax, -0x8(%rbp)
jmp 0x796c
movq 0xa645(%rip), %rdi      # 0x11fa8
callq 0x4a30
movq %rax, -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/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
leaq -0x40(%rbp), %rcx
callq 0x39e0
testb $0x1, %al
jne 0x79b1
movq $0x0, -0x8(%rbp)
jmp 0x79e7
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x9510
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3a40
movl -0x1c(%rbp), %esi
leaq 0x73cd(%rip), %rdi      # 0xeda9
movb $0x0, %al
callq 0x3330
movq %rax, -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/Automaton.c
// Function: automaton_get_stats
static PyObject*
automaton_get_stats(PyObject* self, PyObject* args) {
#define automaton ((Automaton*)self)

    PyObject* dict;

    if (automaton->stats.version != automaton->version)
        get_stats(automaton);

    dict = F(Py_BuildValue)(
        "{s:k,s:k,s:k,s:k,s:i,s:k}",
        "nodes_count",  automaton->stats.nodes_count,
        "words_count",  automaton->stats.words_count,
        "longest_word", automaton->stats.longest_word,
        "links_count",  automaton->stats.links_count,
        "sizeof_node",  automaton->stats.sizeof_node,
        "total_size",   automaton->stats.total_size
    );
    return dict;
#undef automaton
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl 0x38(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x30(%rcx), %eax
je 0x87d0
movq -0x28(%rbp), %rdi
callq 0xa4f0
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rdx
movq -0x28(%rbp), %rax
movq 0x48(%rax), %r8
movq -0x28(%rbp), %rax
movq 0x50(%rax), %r12
movq -0x28(%rbp), %rax
movq 0x58(%rax), %r14
movq -0x28(%rbp), %rax
movq 0x60(%rax), %r11
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
leaq 0x653a(%rip), %rdi      # 0xed41
leaq 0x654d(%rip), %rsi      # 0xed5b
leaq 0x6552(%rip), %rcx      # 0xed67
leaq 0x6557(%rip), %r9       # 0xed73
leaq 0x655d(%rip), %r15      # 0xed80
leaq 0x6562(%rip), %rbx      # 0xed8c
leaq 0x6567(%rip), %r10      # 0xed98
movq %r12, (%rsp)
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movq %r11, 0x20(%rsp)
movq %r10, 0x28(%rsp)
movq %rax, 0x30(%rsp)
movb $0x0, %al
callq 0x3330
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: automaton_dump
static PyObject*
automaton_dump(PyObject* self, PyObject* args) {
#define automaton ((Automaton*)self)
    DumpAux dump;

    if (automaton->kind == EMPTY)
        Py_RETURN_NONE;

    dump.nodes = 0;
    dump.edges = 0;
    dump.fail  = 0;
    dump.error = 0;

    dump.nodes = F(PyList_New)(0);
    dump.edges = F(PyList_New)(0);
    dump.fail  = F(PyList_New)(0);
    if (dump.edges == NULL or dump.fail == NULL or dump.nodes == NULL)
        goto error;

    trie_traverse(automaton->root, dump_aux, &dump);
    if (dump.error)
        goto error;
    else
        return F(Py_BuildValue)("OOO", dump.nodes, dump.edges, dump.fail);

error:
    Py_XDECREF(dump.nodes);
    Py_XDECREF(dump.edges);
    Py_XDECREF(dump.fail);
    return NULL;

#undef automaton
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x889f
movq 0x972f(%rip), %rdi      # 0x11fc0
callq 0x4a30
movq %rax, -0x8(%rbp)
jmp 0x895c
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movb $0x0, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x3030
movq %rax, -0x38(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x3030
movq %rax, -0x30(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x3030
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x88f7
cmpq $0x0, -0x28(%rbp)
je 0x88f7
cmpq $0x0, -0x38(%rbp)
jne 0x88f9
jmp 0x8939
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
leaq 0x1d48(%rip), %rsi      # 0xa650
leaq -0x38(%rbp), %rdx
callq 0x59e0
cmpb $0x0, -0x20(%rbp)
je 0x8919
jmp 0x8939
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0x6477(%rip), %rdi      # 0xeda3
movb $0x0, %al
callq 0x3330
movq %rax, -0x8(%rbp)
jmp 0x895c
movq -0x38(%rbp), %rdi
callq 0xa260
movq -0x30(%rbp), %rdi
callq 0xa260
movq -0x28(%rbp), %rdi
callq 0xa260
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/Automaton.c
// Function: automaton___sizeof__
static PyObject*
automaton___sizeof__(PyObject* self, PyObject* args) {
#define automaton ((Automaton*)self)
    Py_ssize_t size = sizeof(Automaton);

    if (automaton->kind != EMPTY) {
        if (automaton->stats.version != automaton->version) {
            get_stats(automaton);
        }

        size += automaton->stats.total_size;
    }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x70, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x8bcb
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x30(%rcx), %eax
je 0x8bbb
movq -0x8(%rbp), %rdi
callq 0xa4f0
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x61d3(%rip), %rdi      # 0xeda9
movb $0x0, %al
callq 0x3330
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/trienode.c
// Function: trienode_new
static TrieNode*
trienode_new(const char eow) {
    TrieNode* node = (TrieNode*)memory_alloc(sizeof(TrieNode));
    if (node) {
        node->output.integer = 0;
        node->output.object = NULL;
        node->fail      = NULL;

        node->n     = 0;
        node->eow       = eow;
        node->next  = NULL;
    }

    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl $0x20, %edi
callq 0x3450
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8e16
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movb -0x1(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x14(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/trienode.c
// Function: trienode_set_next
static TrieNode*
trienode_set_next(TrieNode* node, const TRIE_LETTER_TYPE letter, TrieNode* child) {

    int n;
    void* next;

    ASSERT(node);
    ASSERT(child);
    ASSERT(trienode_get_next(node, letter) == NULL);

    n = node->n;
    next = (TrieNode**)memory_realloc(node->next, (n + 1) * (sizeof(Pair)));
    if (next) {

        node->next = next;
        node->next[n].letter = letter;
        node->next[n].child = child;
        node->n += 1;

        return child;
    }
    else
        return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8e86
movq 0x91b7(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x31c5(%rip), %rsi      # 0xc010
leaq 0x379a(%rip), %rdx      # 0xc5ec
leaq 0x58b9(%rip), %rcx      # 0xe712
movl $0x82, %r8d
leaq 0x5f2d(%rip), %r9       # 0xed93
movb $0x0, %al
callq 0x31b0
movq 0x9184(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
callq 0x3230
movl $0x1, %edi
callq 0x3310
jmp 0x8e88
jmp 0x8e8a
cmpq $0x0, -0x20(%rbp)
jne 0x8edd
movq 0x9160(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x316e(%rip), %rsi      # 0xc010
leaq 0x3743(%rip), %rdx      # 0xc5ec
leaq 0x5862(%rip), %rcx      # 0xe712
movl $0x83, %r8d
leaq 0x5867(%rip), %r9       # 0xe724
movb $0x0, %al
callq 0x31b0
movq 0x912d(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
callq 0x3230
movl $0x1, %edi
callq 0x3310
jmp 0x8edf
jmp 0x8ee1
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x6510
cmpq $0x0, %rax
je 0x8f3f
movq 0x90fe(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x310c(%rip), %rsi      # 0xc010
leaq 0x36e1(%rip), %rdx      # 0xc5ec
leaq 0x5800(%rip), %rcx      # 0xe712
movl $0x84, %r8d
leaq 0x580b(%rip), %r9       # 0xe72a
movb $0x0, %al
callq 0x31b0
movq 0x90cb(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
callq 0x3230
movl $0x1, %edi
callq 0x3310
jmp 0x8f41
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x24(%rbp), %eax
addl $0x1, %eax
cltq
imulq $0xc, %rax, %rsi
callq 0x3480
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x8fc5
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x24(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x24(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8fcd
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: automaton_remove_word_aux
static TristateResult
automaton_remove_word_aux(PyObject* self, PyObject* args, PyObject** value) {
#define automaton ((Automaton*)self)
    struct Input input;

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

    if (input.wordlen == 0) {
        destroy_input(&input);
        return FALSE;
    }

    *value = trie_remove_word(automaton, input.word, input.wordlen);
    destroy_input(&input);

    if (UNLIKELY(PyErr_Occurred() != NULL)) {
        return MEMORY_ERROR;
    } else {
        return (*value != NULL) ? TRUE : FALSE;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
leaq -0x40(%rbp), %rcx
callq 0x39e0
testb $0x1, %al
jne 0x9014
movl $0x0, -0x4(%rbp)
jmp 0x908e
cmpq $0x0, -0x40(%rbp)
jne 0x902d
leaq -0x40(%rbp), %rdi
callq 0x3a40
movl $0x2, -0x4(%rbp)
jmp 0x908e
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x90a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
leaq -0x40(%rbp), %rdi
callq 0x3a40
callq 0x31f0
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x9073
movl $0x0, -0x4(%rbp)
jmp 0x908e
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movl $0x2, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/trie.c
// Function: trie_longest
static int PURE
trie_longest(TrieNode* root, const TRIE_LETTER_TYPE* word, const size_t wordlen) {
    TrieNode* node;
    int len = 0;
    size_t i;

    node = root;
    for (i=0; i < wordlen; i++) {
        node = trienode_get_next(node, word[i]);
        if (node == NULL)
            break;
        else
            len += 1;
    }

    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x957f
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x6510
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x9566
jmp 0x957f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x9571
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x953b
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/trie.c
// Function: ahocorasick_next
static TrieNode* PURE
ahocorasick_next(TrieNode* node, TrieNode* root, const TRIE_LETTER_TYPE letter) {
    TrieNode* next = node;
    TrieNode* tmp;

    while (next) {
        tmp = trienode_get_next(next, letter);
        if (tmp)
            // found link
            return tmp;
        else
            // or go back through fail edges
            next = next->fail;
    }

    // or return root node
    return root;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x9811
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x6510
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x9803
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9819
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x97db
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/AutomatonSearchIter.c
// Function: automaton_search_iter_new
static PyObject*
automaton_search_iter_new(
    Automaton* automaton,
    PyObject* object,
    int start,
    int end,
    bool ignore_white_space
) {
    AutomatonSearchIter* iter;
#ifdef VARIABLE_LEN_CHARCODES
    int tmp;
#endif

    iter = (AutomatonSearchIter*)F(PyObject_New)(AutomatonSearchIter, &automaton_search_iter_type);
    if (iter == NULL)
        return NULL;


    iter->automaton = automaton;
    iter->version   = automaton->version;

    iter->state = automaton->root;
    iter->output= NULL;
    iter->shift = 0;
    iter->ignore_white_space = ignore_white_space;

    init_input(&iter->input);

    Py_INCREF(iter->automaton);

    if (!prepare_input((PyObject*)automaton, object, &iter->input)) {
        goto error;
    }

#ifdef VARIABLE_LEN_CHARCODES
    if (automaton->key_type == KEY_STRING) {
        tmp = automaton_search_iter_substring_index(&iter->input, start);
        if (tmp >= 0) {
            iter->index    = tmp - 1;
            iter->position = start - 1;
        } else {
            goto error;
        }

        tmp = automaton_search_iter_substring_index(&iter->input, end);
        if (tmp >= 0) {
            iter->end = end;
        } else {
            goto error;
        }

        iter->expected  = pyaho_UCS2_Any;
    } else {
        iter->index = start - 1;
        iter->end   = end;
    }
#else
    // -1 because the first instruction in next() increments index
    iter->index = start - 1;
    iter->end   = end;
#endif
    return (PyObject*)iter;

error:
    Py_DECREF(iter);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
leaq 0x9053(%rip), %rdi      # 0x128a8
callq 0x32b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x9872
movq $0x0, -0x8(%rbp)
jmp 0x992e
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x58(%rax)
movb -0x21(%rbp), %cl
movq -0x30(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x68(%rax)
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0x3500
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5820
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq $0x20, %rdx
callq 0x3530
testb $0x1, %al
jne 0x98f6
jmp 0x991d
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x50(%rax)
movslq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x992e
movq -0x30(%rbp), %rdi
callq 0x3a90
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/AutomatonSearchIter.c
// Function: automaton_build_output
static int
automaton_build_output(PyObject* self, PyObject** result) {
    TrieNode* node;
    Py_ssize_t idx = 0;

    while (iter->output && !iter->output->eow) {
        iter->output = iter->output->fail;
    }

    if (iter->output) {
        node = iter->output;
        iter->output = iter->output->fail;

#ifdef VARIABLE_LEN_CHARCODES
        idx = iter->shift;
        if (iter->automaton->key_type == KEY_STRING) {
            idx += iter->position;
        } else {
            idx += iter->index;
        }
#else
        idx = iter->index + iter->shift;
#endif
        switch (iter->automaton->store) {
            case STORE_LENGTH:
            case STORE_INTS:
                *result = F(Py_BuildValue)("ii", idx, node->output.integer);
                return OutputValue;

            case STORE_ANY:
                *result = F(Py_BuildValue)("iO", idx, node->output.object);
                return OutputValue;

            default:
                PyErr_SetString(PyExc_ValueError, "inconsistent internal state!");
                return OutputError;
        }
    }

    return OutputNone;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x48(%rcx)
movb %al, -0x29(%rbp)
je 0x9bac
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
cmpb $0x0, 0x14(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x9bb5
jmp 0x9bcb
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
jmp 0x9b88
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x9ca9
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rax
movq 0x58(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x14(%rax), %eax
movl %eax, -0x30(%rbp)
subl $0xa, %eax
je 0x9c32
jmp 0x9c1e
movl -0x30(%rbp), %eax
subl $0x14, %eax
je 0x9c32
jmp 0x9c28
movl -0x30(%rbp), %eax
subl $0x1e, %eax
je 0x9c5e
jmp 0x9c8a
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
leaq 0x4d10(%rip), %rdi      # 0xe954
movb $0x0, %al
callq 0x3330
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x9cb0
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
leaq 0x541f(%rip), %rdi      # 0xf08f
movb $0x0, %al
callq 0x3330
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x9cb0
movq 0x82f7(%rip), %rax      # 0x11f88
movq (%rax), %rdi
leaq 0x4ebb(%rip), %rsi      # 0xeb56
callq 0x3120
movl $0x2, -0x4(%rbp)
jmp 0x9cb0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/AutomatonSearchIterLong.c
// Function: automaton_search_iter_long_new
static PyObject*
automaton_search_iter_long_new(
    Automaton* automaton,
    PyObject* object,
    int start,
    int end
) {
    AutomatonSearchIterLong* iter;

    iter = (AutomatonSearchIterLong*)PyObject_New(AutomatonSearchIterLong, &automaton_search_iter_long_type);
    if (iter == NULL)
        return NULL;

    iter->automaton = automaton;
    iter->version   = automaton->version;
    iter->object    = object;

    iter->state = automaton->root;
    iter->shift = 0;
    iter->index = start - 1;    // -1 because first instruction in next() increments index
    iter->end   = end;

    iter->last_index = -1;
    iter->last_node  = NULL;

    Py_INCREF(iter->automaton);
    Py_INCREF(iter->object);

    init_input(&iter->input);
    if (!prepare_input((PyObject*)automaton, object, &iter->input)) {
        goto error;
    }

    return (PyObject*)iter;
error:
    Py_DECREF(iter);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
leaq 0x8c23(%rip), %rdi      # 0x12a80
callq 0x32b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x9e7a
movq $0x0, -0x8(%rbp)
jmp 0x9f46
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x60(%rax)
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x5c(%rax)
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x64(%rax)
movq -0x28(%rbp), %rax
movl $0xffffffff, 0x58(%rax) # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5820
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x5820
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x3500
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
addq $0x28, %rdx
callq 0x3530
testb $0x1, %al
jne 0x9f2b
jmp 0x9f35
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9f46
movq -0x28(%rbp), %rdi
callq 0x3a90
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/AutomatonSearchIterLong.c
// Function: automaton_search_iter_long_del
static void
automaton_search_iter_long_del(PyObject* self) {
    Py_DECREF(iter->automaton);
    Py_DECREF(iter->object);
    destroy_input(&iter->input);
    PyObject_Del(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3a90
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3a90
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0x3a40
movq -0x8(%rbp), %rdi
callq 0x3170
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/AutomatonSearchIterLong.c
// Function: automaton_build_output_iter_long
static PyObject*
automaton_build_output_iter_long(PyObject* self) {

    switch (iter->automaton->store) {
        case STORE_LENGTH:
        case STORE_INTS:
            return Py_BuildValue("ii", iter->shift + iter->last_index, iter->last_node->output.integer);

        case STORE_ANY:
            return Py_BuildValue("iO", iter->shift + iter->last_index, iter->last_node->output.object);

        default:
            PyErr_SetString(PyExc_ValueError, "inconsistent internal state!");
            return NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x14(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0xa, %eax
je 0xa2c5
jmp 0xa2b1
movl -0x14(%rbp), %eax
subl $0x14, %eax
je 0xa2c5
jmp 0xa2bb
movl -0x14(%rbp), %eax
subl $0x1e, %eax
je 0xa2f2
jmp 0xa31f
movq -0x10(%rbp), %rax
movl 0x60(%rax), %esi
movq -0x10(%rbp), %rax
addl 0x58(%rax), %esi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rdx
leaq 0x466f(%rip), %rdi      # 0xe954
movb $0x0, %al
callq 0x3330
movq %rax, -0x8(%rbp)
jmp 0xa33d
movq -0x10(%rbp), %rax
movl 0x60(%rax), %esi
movq -0x10(%rbp), %rax
addl 0x58(%rax), %esi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rdx
leaq 0x4d7d(%rip), %rdi      # 0xf08f
movb $0x0, %al
callq 0x3330
movq %rax, -0x8(%rbp)
jmp 0xa33d
movq 0x7c62(%rip), %rax      # 0x11f88
movq (%rax), %rdi
leaq 0x4826(%rip), %rsi      # 0xeb56
callq 0x3120
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: get_stats
static void
get_stats(Automaton* automaton) {
    automaton->stats.nodes_count    = 0;
    automaton->stats.words_count    = 0;
    automaton->stats.longest_word   = 0;
    automaton->stats.links_count    = 0;
    automaton->stats.sizeof_node    = sizeof(TrieNode);
    automaton->stats.total_size     = 0;

    if (automaton->kind != EMPTY)
        get_stats_aux(automaton->root, &automaton->stats, 0);

    automaton->stats.version        = automaton->version;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x8(%rbp), %rax
movq $0x20, 0x60(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0xa565
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x38, %rsi
xorl %edx, %edx
callq 0xa580
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: get_stats_aux
static void
get_stats_aux(TrieNode* node, AutomatonStatistics* stats, int depth) {

    unsigned i;

    stats->nodes_count  += 1;
    stats->words_count  += (int)(node->eow);
    stats->links_count  += node->n;
    stats->total_size   += trienode_get_size(node);

    if (depth > stats->longest_word)
        stats->longest_word = depth;

    for (i=0; i < node->n; i++)
        get_stats_aux(trienode_get_ith_unsafe(node, i), stats, depth + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movzbl 0x14(%rax), %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x3b10
movq %rax, %rcx
movq -0x10(%rbp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
movslq -0x14(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jle 0xa601
movslq -0x14(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0xa63f
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x5dd0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0xa580
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xa608
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: dump_aux
static int
dump_aux(TrieNode* node, const int depth, void* extra) {
#define Dump ((DumpAux*)extra)
    PyObject* tuple;
    TrieNode* child;
    unsigned i;

#define append_tuple(list) \
    if (tuple == NULL) { \
        Dump->error = 1; \
        return 0; \
    } \
    else if (PyList_Append(list, tuple) < 0) { \
        Dump->error = 1; \
        return 0; \
    }


    // 1.
    tuple = F(Py_BuildValue)("ii", node, (int)(node->eow));
    append_tuple(Dump->nodes)

    // 2.
    for (i=0; i < node->n; i++) {
        child = trienode_get_ith_unsafe(node, i);
        tuple = F(Py_BuildValue)("ici", node, trieletter_get_ith_unsafe(node, i), child);
        append_tuple(Dump->edges)
    }

    // 3.
    if (node->fail) {
        tuple = F(Py_BuildValue)("ii", node, node->fail);
        append_tuple(Dump->fail);
    }

    return 1;
#undef append_tuple
#undef Dump
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movzbl 0x14(%rax), %edx
leaq 0x42de(%rip), %rdi      # 0xe954
movb $0x0, %al
callq 0x3330
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xa69c
movq -0x20(%rbp), %rax
movb $0x1, 0x18(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xa7ec
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x31a0
cmpl $0x0, %eax
jge 0xa6c5
movq -0x20(%rbp), %rax
movb $0x1, 0x18(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xa7ec
jmp 0xa6c7
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0xa779
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x5dd0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x7410
movq -0x40(%rbp), %rsi
movl %eax, %edx
movq -0x30(%rbp), %rcx
leaq 0x4690(%rip), %rdi      # 0xeda7
movb $0x0, %al
callq 0x3330
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xa73d
movq -0x20(%rbp), %rax
movb $0x1, 0x18(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xa7ec
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x31a0
cmpl $0x0, %eax
jge 0xa767
movq -0x20(%rbp), %rax
movb $0x1, 0x18(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xa7ec
jmp 0xa769
jmp 0xa76b
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xa6ce
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xa7e5
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x41bd(%rip), %rdi      # 0xe954
movb $0x0, %al
callq 0x3330
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xa7ba
movq -0x20(%rbp), %rax
movb $0x1, 0x18(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xa7ec
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x31a0
cmpl $0x0, %eax
jge 0xa7e1
movq -0x20(%rbp), %rax
movb $0x1, 0x18(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xa7ec
jmp 0xa7e3
jmp 0xa7e5
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/Automaton_pickle.c
// Function: pickle_dump_replace_fail_with_id
static int
pickle_dump_replace_fail_with_id(TrieNode* node, const int depth, void* extra) {

    NodeID* repl;

    ASSERT(sizeof(NodeID*) <= sizeof(TrieNode*));
#define state ((DumpState*)extra)
    repl = (NodeID*)memory_alloc(sizeof(NodeID));
    if (LIKELY(repl != NULL)) {
        state->id += 1;
        state->total_size += get_pickled_size(node);

        repl->id   = state->id;
        repl->fail = node->fail;

        node->fail = (TrieNode*)repl;
        return 1;
    }
    else {
        // error, revert is needed!
        state->failed_on = node;
        return 0;
    }
#undef state
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
jmp 0xa815
movl $0x10, %edi
callq 0x3450
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xa891
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0xafe0
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0xa8a4
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/WojciechMula[P]pyahocorasick/src/Automaton_pickle.c
// Function: pickle_dump_revert_replace
static int
pickle_dump_revert_replace(TrieNode* node, const int depth, void* extra) {
#define state ((DumpState*)extra)
    if (state->failed_on != node) {
        NodeID* repl = (NodeID*)(node->fail);
        node->fail = repl->fail;
        memory_free(repl);

        return 1;
    }
    else
        return 0;
#undef state
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0xa8fe
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rdi
callq 0x34b0
movl $0x1, -0x4(%rbp)
jmp 0xa905
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop