LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/trienode.c
// Function: trienode_free
static void
trienode_free(TrieNode* node) {

    ASSERT(node);

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

    memory_free(node);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x440e
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
je 0x4405
movq 0x18(%rbx), %rdi
callq 0x3070
movq %rbx, %rdi
popq %rbx
jmp 0x3070
movq 0x9be3(%rip), %rbx      # 0xdff8
movq (%rbx), %rdi
leaq 0x3c11(%rip), %rsi      # 0x8030
leaq 0x418a(%rip), %rdx      # 0x85b0
leaq 0x4241(%rip), %rcx      # 0x866e
leaq 0x68bb(%rip), %r9       # 0xacef
pushq $0x20
popq %r8
xorl %eax, %eax
callq 0x31b0
movq (%rbx), %rdi
callq 0x3230
pushq $0x1
popq %rdi
callq 0x3310
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/custompickle/load/loadbuffer.c
// Function: loadbuffer_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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x8
popq %r12
leaq 0x3ed2(%rip), %r15      # 0x833b
xorl %r13d, %r13d
cmpq 0x20(%r14), %r13
jae 0x4495
movq 0x18(%r14), %rax
movq -0x8(%rax,%r12), %rdx
movq (%rax,%r12), %rcx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x31b0
incq %r13
addq $0x10, %r12
jmp 0x446c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: automaton_contains
static int
automaton_contains(PyObject* self, PyObject* args) {
#define automaton ((Automaton*)self)
    TrieNode* node;
    struct Input input;

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

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

    destroy_input(&input);

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
callq 0x346d
testb %al, %al
je 0x4a36
movq 0x28(%rbx), %rdi
leaq 0x8(%rsp), %r14
movq (%r14), %rdx
movq 0x8(%r14), %rsi
callq 0x4d19
movq %rax, %rbx
movq %r14, %rdi
callq 0x37ab
xorl %eax, %eax
testq %rbx, %rbx
je 0x4a39
cmpb $0x0, 0x14(%rbx)
setne %al
jmp 0x4a39
pushq $-0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/trie.c
// Function: trie_traverse_aux
static int
trie_traverse_aux(
    TrieNode* node,
    const int depth,
    trie_traverse_callback callback,
    void *extra
) {
    unsigned i;
    if (callback(node, depth, extra) == 0)
        return 0;

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

    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq %rcx, %rdx
callq *%r14
testl %eax, %eax
je 0x4c6d
incl %ebp
xorl %r13d, %r13d
pushq $0x1
popq %r12
movl 0x10(%r15), %eax
cmpq %rax, %r13
jae 0x4c70
movq %r15, %rdi
movq %r13, %rsi
callq 0x4c82
movq %rax, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x4c19
incq %r13
testl %eax, %eax
jne 0x4c42
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
movq %rsp, %rax
movq %rsi, (%rax)
movq 0x18(%rdi), %rsi
movq 0x20(%rdi), %rdx
leaq -0x28(%rip), %r8        # 0x4cd7
pushq $0x10
popq %rcx
movq %rax, %rdi
callq 0x3340
testq %rax, %rax
je 0x4d15
movq 0x8(%rax), %rax
popq %rcx
retq
xorl %eax, %eax
jmp 0x4d13
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/trie.c
// Function: trie_find
static TrieNode* PURE
trie_find(TrieNode* root, const TRIE_LETTER_TYPE* word, const size_t wordlen) {
    TrieNode* node;
    size_t i;

    node = root;

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

    return node;
}

// Assembly:
testq %rdi, %rdi
je 0x4d50
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rax
xorl %r15d, %r15d
cmpq %r15, %rbx
je 0x4d4a
movl (%r14,%r15,4), %esi
movq %rax, %rdi
callq 0x4d53
incq %r15
testq %rax, %rax
jne 0x4d2f
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
testq %rdi, %rdi
je 0x4d84
movq 0x18(%rdi), %rcx
movl 0x10(%rdi), %eax
imulq $0xc, %rax, %rdx
addq $0xc, %rdx
xorl %eax, %eax
xorl %edi, %edi
leaq 0xc(%rdi), %r8
cmpq %r8, %rdx
je 0x4d82
cmpl %esi, (%rcx,%rdi)
movq %r8, %rdi
jne 0x4d6c
movq -0x8(%rcx,%r8), %rax
popq %rbx
retq
movq 0x926d(%rip), %rbx      # 0xdff8
movq (%rbx), %rdi
leaq 0x329b(%rip), %rsi      # 0x8030
leaq 0x3814(%rip), %rdx      # 0x85b0
leaq 0x398c(%rip), %rcx      # 0x872f
leaq 0x5f45(%rip), %r9       # 0xacef
pushq $0x30
popq %r8
xorl %eax, %eax
callq 0x31b0
movq (%rbx), %rdi
callq 0x3230
pushq $0x1
popq %rdi
callq 0x3310
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: automaton_clear
static PyObject*
automaton_clear(PyObject* self, PyObject* args) {
#define automaton ((Automaton*)self)
    clear_aux(automaton->root, automaton->store);
    automaton->count = 0;
    automaton->longest_word = 0;
    automaton->kind = EMPTY;
    automaton->root = NULL;
    automaton->version += 1;

    Py_RETURN_NONE;
#undef automaton
}

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

    unsigned i;

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

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

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

        trienode_free(node);
    }
#undef automaton
}

// Assembly:
testq %rdi, %rdi
je 0x553c
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x1e, %esi
jne 0x54fe
cmpb $0x0, 0x14(%rbx)
je 0x54fe
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x54fe
callq 0x37d5
pushq $0x4
popq %r14
xorl %r15d, %r15d
movl 0x10(%rbx), %eax
cmpq %rax, %r15
jae 0x552a
movq 0x18(%rbx), %rax
movq (%rax,%r14), %rdi
cmpq %rbx, %rdi
je 0x5521
movl %ebp, %esi
callq 0x54d5
incq %r15
addq $0xc, %r14
jmp 0x5505
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x43ed
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
callq 0x345b
movq 0x58(%rbx), %rdi
callq 0x345b
leaq 0x30(%rbx), %rdi
callq 0x381c
movq 0x10(%rbx), %rdi
callq 0x37d5
movq %rbx, %rdi
popq %rbx
jmp 0x3170
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: automaton_remove_word
static PyObject*
automaton_remove_word(PyObject* self, PyObject* args) {
    PyObject* value;

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

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

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

        case MEMORY_ERROR:
        default:
            return NULL;
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
callq 0x6ec6
cmpl $0x2, %eax
je 0x5fd6
cmpl $0x1, %eax
jne 0x5fe2
cmpl $0x1e, 0x14(%rbx)
jne 0x5fc7
movq 0x8(%rsp), %rdi
callq 0x37d5
incl 0x30(%rbx)
decl 0x1c(%rbx)
movq 0x7ff4(%rip), %rax      # 0xdfc8
jmp 0x5fdd
movq 0x7fcb(%rip), %rax      # 0xdfa8
incq (%rax)
jmp 0x5fe4
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: automaton_pop
static PyObject*
automaton_pop(PyObject* self, PyObject* args) {
    PyObject* value;

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

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

        case MEMORY_ERROR:
        default:
            return NULL;
    }
}

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

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

            case 0:
                Py_RETURN_FALSE;

            default:
                return NULL;
        }
    else
        return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3140
testq %rax, %rax
je 0x606d
movq %r14, %rdi
movq %rax, %rsi
callq 0x49ee
cmpl $0x1, %eax
je 0x605f
testl %eax, %eax
jne 0x606b
movq 0x7f4b(%rip), %rbx      # 0xdfa8
jmp 0x6066
movq 0x7f62(%rip), %rbx      # 0xdfc8
incq (%rbx)
jmp 0x606d
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: automaton_match
static PyObject*
automaton_match(PyObject* self, PyObject* args) {
#define automaton ((Automaton*)self)
    TrieNode* node;
    struct Input input;

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

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

    destroy_input(&input);

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
xorl %ebx, %ebx
leaq 0x8(%rsp), %rcx
xorl %edx, %edx
callq 0x376f
testb %al, %al
je 0x60cc
movq 0x28(%r14), %rdi
leaq 0x8(%rsp), %rbx
movq (%rbx), %rdx
movq 0x8(%rbx), %rsi
callq 0x4d19
movq %rax, %r14
movq %rbx, %rdi
callq 0x37ab
testq %r14, %r14
jne 0x60c2
movq 0x7ee8(%rip), %rbx      # 0xdfa8
jmp 0x60c9
movq 0x7eff(%rip), %rbx      # 0xdfc8
incq (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: automaton_longest_prefix
static PyObject*
automaton_longest_prefix(PyObject* self, PyObject* args) {
#define automaton ((Automaton*)self)
    int len;
    struct Input input;

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

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

    destroy_input(&input);

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %rcx
xorl %edx, %edx
callq 0x376f
testb %al, %al
je 0x611c
movq 0x28(%rbx), %rax
movq (%rsp), %rbx
movq 0x8(%rsp), %r15
xorl %r14d, %r14d
cmpq %r14, %rbx
je 0x612b
movl (%r15,%r14,4), %esi
movq %rax, %rdi
callq 0x4d53
testq %rax, %rax
je 0x6128
incq %r14
jmp 0x6101
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rbx
movq %rsp, %rdi
callq 0x37ab
leaq 0x4bcb(%rip), %rdi      # 0xad05
movl %ebx, %esi
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3330
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/Automaton.c
// Function: automaton_get
static PyObject*
automaton_get(PyObject* self, PyObject* args) {
#define automaton ((Automaton*)self)
    struct Input input;
    PyObject* py_def;
    Py_ssize_t k;
    TrieNode* node;

    k = PyTuple_GET_SIZE(args);

    if (k < 1 || k > 2) {
        PyErr_Format(PyExc_TypeError, "get() takes one or two arguments (%ld given)", k);
        return NULL;
    }

    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 and node->eow) {
        switch (automaton->store) {
            case STORE_INTS:
            case STORE_LENGTH:
                return F(Py_BuildValue)("i", node->output.integer);

            case STORE_ANY:
                Py_INCREF(node->output.object);
                return node->output.object;

            default:
                PyErr_SetNone(PyExc_ValueError);
                return NULL;
        }
    }
    else {
        py_def = F(PyTuple_GetItem)(args, 1);
        if (py_def) {
            Py_INCREF(py_def);
            return py_def;
        }
        else {
            PyErr_Clear();
            PyErr_SetNone(PyExc_KeyError);
            return NULL;
        }
    }
#undef automaton
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x8(%rsi), %rax
testb $0x4, 0xab(%rax)
je 0x6265
movq %rsi, %rbx
movq 0x10(%rsi), %rdx
leaq -0x3(%rdx), %rax
cmpq $-0x3, %rax
ja 0x6199
movq 0x7e10(%rip), %rax      # 0xdf90
movq (%rax), %rdi
leaq 0x45d8(%rip), %rsi      # 0xa762
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x3300
jmp 0x6256
movq %rdi, %r14
xorl %r15d, %r15d
leaq 0x8(%rsp), %rcx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x376f
testb %al, %al
je 0x6256
movq 0x28(%r14), %rdi
leaq 0x8(%rsp), %r12
movq (%r12), %rdx
movq 0x8(%r12), %rsi
callq 0x4d19
movq %rax, %r15
movq %r12, %rdi
callq 0x37ab
testq %r15, %r15
je 0x6213
cmpb $0x0, 0x14(%r15)
je 0x6213
movl 0x14(%r14), %eax
cmpl $0xa, %eax
je 0x61f7
cmpl $0x1e, %eax
je 0x6239
cmpl $0x14, %eax
jne 0x6244
movq (%r15), %rsi
leaq 0x4b04(%rip), %rdi      # 0xad05
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3330
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3140
testq %rax, %rax
je 0x622b
movq %rax, %r15
incq (%rax)
jmp 0x6256
callq 0x3190
movq 0x7d61(%rip), %rax      # 0xdf98
jmp 0x624b
movq (%r15), %rax
incq (%rax)
movq (%r15), %r15
jmp 0x6256
movq 0x7d3d(%rip), %rax      # 0xdf88
movq (%rax), %rdi
callq 0x3160
xorl %r15d, %r15d
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1eac(%rip), %rdi      # 0x8118
leaq 0x44af(%rip), %rsi      # 0xa722
leaq 0x44b8(%rip), %rcx      # 0xa732
movl $0x1fd, %edx            # imm = 0x1FD
callq 0x3130
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x38(%rdi), %eax
cmpl 0x30(%rdi), %eax
je 0x6a3e
movq %rbx, %rdi
callq 0x7897
movq 0x40(%rbx), %rdx
movq 0x48(%rbx), %r8
subq $0x8, %rsp
leaq 0x42a3(%rip), %r10      # 0xacf4
leaq 0x4290(%rip), %r11      # 0xace8
leaq 0x427d(%rip), %r14      # 0xacdc
leaq 0x4237(%rip), %rdi      # 0xac9d
leaq 0x424a(%rip), %rsi      # 0xacb7
leaq 0x424f(%rip), %rcx      # 0xacc3
leaq 0x4254(%rip), %r9       # 0xaccf
xorl %eax, %eax
pushq 0x68(%rbx)
pushq %r10
pushq 0x60(%rbx)
pushq %r11
pushq 0x58(%rbx)
pushq %r14
pushq 0x50(%rbx)
callq 0x3330
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpl $0x0, 0x10(%rdi)
je 0x6b37
movq %rdi, %r14
movb $0x0, 0x18(%rsp)
xorl %edi, %edi
callq 0x3030
movq %rax, %rbx
movq %rax, (%rsp)
xorl %edi, %edi
callq 0x3030
movq %rax, %r15
movq %rax, 0x8(%rsp)
xorl %edi, %edi
callq 0x3030
movq %rax, 0x10(%rsp)
testq %r15, %r15
sete %cl
testq %rax, %rax
sete %al
orb %cl, %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x6b17
movq 0x28(%r14), %rdi
leaq 0xe5a(%rip), %rsi       # 0x795d
movq %rsp, %rbx
movq %rbx, %rdx
callq 0x4a41
cmpb $0x0, 0x18(%rbx)
movq (%rbx), %rbx
je 0x6b43
movq %rbx, %rdi
callq 0x7776
movq 0x8(%rsp), %rdi
callq 0x7776
movq 0x10(%rsp), %rdi
callq 0x7776
xorl %eax, %eax
jmp 0x6b5e
movq 0x7482(%rip), %rax      # 0xdfc0
incq (%rax)
jmp 0x6b5e
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
leaq 0x41ab(%rip), %rdi      # 0xacff
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3330
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x0, 0x10(%rdi)
je 0x6e95
pushq %rbx
movq %rdi, %rbx
movl 0x38(%rdi), %eax
cmpl 0x30(%rdi), %eax
je 0x6e8a
movq %rbx, %rdi
callq 0x7897
movq 0x68(%rbx), %rsi
addq $0x70, %rsi
popq %rbx
jmp 0x6e98
pushq $0x70
popq %rsi
leaq 0x3e66(%rip), %rdi      # 0xad05
xorl %eax, %eax
jmp 0x3330
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testq %r14, %r14
je 0x7301
movq %r14, %rdi
movl %ebp, %esi
callq 0x4d53
testq %rax, %rax
jne 0x72fe
movq 0x8(%r14), %r14
jmp 0x72e4
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/AutomatonSearchIter.c
// Function: automaton_search_iter_set
static PyObject*
automaton_search_iter_set(PyObject* self, PyObject* args) {
    PyObject* object;
    PyObject* flag;
    Py_ssize_t position;
    bool reset;
    struct Input new_input;

    // first argument - required string or buffer
    object = F(PyTuple_GetItem)(args, 0);
    if (object) {
        init_input(&new_input);
        if (!prepare_input((PyObject*)iter->automaton, object, &new_input)) {
            return NULL;
        }
    }
    else
        return NULL;

    // second argument - optional bool
    flag = F(PyTuple_GetItem)(args, 1);
    if (flag) {
        switch (PyObject_IsTrue(flag)) {
            case 0:
                reset = false;
                break;
            case 1:
                reset = true;
                break;
            default:
                return NULL;
        }
    }
    else {
        PyErr_Clear();
        reset = false;
    }

    destroy_input(&iter->input);
    assign_input(&iter->input, &new_input);

    if (!reset) {
        position = iter->index;
#ifdef VARIABLE_LEN_CHARCODES
        if (iter->automaton->key_type == KEY_STRING) {
            position = iter->position;
        }
#endif
        iter->shift += (position >= 0) ? position : 0;
    }

    iter->index     = -1;
    iter->end       = new_input.wordlen;

    if (reset) {
        iter->state  = iter->automaton->root;
        iter->shift  = 0;
        iter->output = NULL;
#ifdef VARIABLE_LEN_CHARCODES
        iter->position = -1;
        iter->expected = pyaho_UCS2_Any;
#endif
    }

    Py_RETURN_NONE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3140
testq %rax, %rax
je 0x755f
xorps %xmm0, %xmm0
movq %rsp, %rdx
movups %xmm0, 0x8(%rdx)
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x346d
testb %al, %al
je 0x7517
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3140
testq %rax, %rax
je 0x751c
movq %rax, %rdi
callq 0x3250
testl %eax, %eax
je 0x7521
cmpl $0x1, %eax
jne 0x7517
leaq 0x20(%rbx), %rdi
callq 0x37ab
movq (%rsp), %rax
movq %rax, 0x20(%rbx)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x28(%rbx)
orq $-0x1, 0x50(%rbx)
movq %rax, 0x60(%rbx)
movq 0x10(%rbx), %rax
movq 0x28(%rax), %rax
movq %rax, 0x40(%rbx)
andq $0x0, 0x58(%rbx)
andq $0x0, 0x48(%rbx)
jmp 0x7555
xorl %r15d, %r15d
jmp 0x755f
callq 0x3190
leaq 0x20(%rbx), %rdi
callq 0x37ab
movq (%rsp), %rax
movq %rax, 0x20(%rbx)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x28(%rbx)
movq 0x50(%rbx), %rcx
xorl %edx, %edx
testq %rcx, %rcx
cmovgq %rcx, %rdx
addq %rdx, 0x58(%rbx)
orq $-0x1, 0x50(%rbx)
movq %rax, 0x60(%rbx)
movq 0x6a64(%rip), %r15      # 0xdfc0
incq (%r15)
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x37d5
movq 0x20(%rbx), %rdi
callq 0x37d5
leaq 0x28(%rbx), %rdi
callq 0x37ab
movq %rbx, %rdi
popq %rbx
jmp 0x3170
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/AutomatonSearchIterLong.c
// Function: automaton_search_iter_long_set
static PyObject*
automaton_search_iter_long_set(PyObject* self, PyObject* args) {
    PyObject* object;
    PyObject* flag;
    bool reset;
    struct Input new_input;

    // first argument - required string or buffer
    object = PyTuple_GetItem(args, 0);
    if (object) {
        init_input(&new_input);
        if (!prepare_input((PyObject*)iter->automaton, object, &new_input)) {
            return NULL;
        }
    }
    else
        return NULL;

    // second argument - optional bool
    flag = PyTuple_GetItem(args, 1);
    if (flag) {
        switch (PyObject_IsTrue(flag)) {
            case 0:
                reset = false;
                break;
            case 1:
                reset = true;
                break;
            default:
                return NULL;
        }
    }
    else {
        PyErr_Clear();
        reset = false;
    }

    // update internal state
    Py_XDECREF(iter->object);
    Py_INCREF(object);
    iter->object    = object;

    destroy_input(&iter->input);
    assign_input(&iter->input, &new_input);

    if (!reset)
        iter->shift += (iter->index >= 0) ? iter->index : 0;

    iter->index     = -1;
    iter->end       = new_input.wordlen;

    if (reset) {
        iter->state  = iter->automaton->root;
        iter->shift  = 0;

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

    Py_RETURN_NONE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorl %r12d, %r12d
movq %rsi, %rdi
xorl %esi, %esi
callq 0x3140
testq %rax, %rax
je 0x7888
movq %rax, %r14
xorps %xmm0, %xmm0
leaq 0x8(%rsp), %rdx
movups %xmm0, 0x8(%rdx)
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x346d
testb %al, %al
je 0x7834
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x3140
testq %rax, %rax
je 0x7839
movq %rax, %rdi
callq 0x3250
testl %eax, %eax
je 0x783e
cmpl $0x1, %eax
jne 0x7834
movq 0x20(%rbx), %rdi
callq 0x7776
incq (%r14)
movq %r14, 0x20(%rbx)
leaq 0x28(%rbx), %rdi
callq 0x37ab
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rbx)
movups 0x10(%rsp), %xmm0
movups %xmm0, 0x30(%rbx)
orl $-0x1, 0x5c(%rbx)
movl %eax, 0x64(%rbx)
movq 0x10(%rbx), %rax
movq 0x28(%rax), %rax
movq %rax, 0x48(%rbx)
andl $0x0, 0x60(%rbx)
andq $0x0, 0x50(%rbx)
orl $-0x1, 0x58(%rbx)
jmp 0x787d
xorl %r12d, %r12d
jmp 0x7888
callq 0x3190
movq 0x20(%rbx), %rdi
callq 0x7776
incq (%r14)
movq %r14, 0x20(%rbx)
leaq 0x28(%rbx), %rdi
callq 0x37ab
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rbx)
movups 0x10(%rsp), %xmm0
movups %xmm0, 0x30(%rbx)
movl 0x5c(%rbx), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovgl %ecx, %edx
addl %edx, 0x60(%rbx)
orl $-0x1, 0x5c(%rbx)
movl %eax, 0x64(%rbx)
movq 0x673c(%rip), %r12      # 0xdfc0
incq (%r12)
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movq $0x20, 0x60(%rdi)
andq $0x0, 0x68(%rdi)
cmpl $0x0, 0x10(%rdi)
je 0x78c8
leaq 0x38(%rbx), %rsi
movq 0x28(%rbx), %rdi
xorl %edx, %edx
callq 0x78d0
movl 0x30(%rbx), %eax
movl %eax, 0x38(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzbl 0x14(%rdi), %eax
movdqu 0x8(%rsi), %xmm0
movd %eax, %xmm1
movdqa 0x72e(%rip), %xmm2      # 0x8020
punpcklqdq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0]
paddq %xmm0, %xmm2
movdqu %xmm2, 0x8(%rsi)
movl 0x10(%rdi), %eax
addq %rax, 0x20(%rsi)
movl %edx, %ebp
movq 0x30(%rsi), %rcx
leaq (%rcx,%rax,8), %rcx
addq $0x20, %rcx
movq %rcx, 0x30(%rsi)
movslq %edx, %rcx
cmpq %rcx, 0x18(%rsi)
jge 0x7925
movq %rcx, 0x18(%rbx)
incl %ebp
xorl %r15d, %r15d
movl %eax, %eax
cmpq %rax, %r15
jae 0x7952
movq %r14, %rdi
movq %r15, %rsi
callq 0x4c82
movq %rax, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x78d0
incq %r15
movl 0x10(%r14), %eax
jmp 0x792a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movzbl 0x14(%rdi), %edx
leaq 0x2f65(%rip), %rdi      # 0xa8de
movq %r14, %rsi
xorl %eax, %eax
callq 0x3330
testq %rax, %rax
je 0x79ed
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x31a0
testl %eax, %eax
js 0x79ed
leaq 0x3365(%rip), %r15      # 0xad03
xorl %r12d, %r12d
movl 0x10(%r14), %eax
cmpq %rax, %r12
jae 0x7a04
movq %r14, %rdi
movq %r12, %rsi
callq 0x4c82
movq %rax, %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0x5bef
movq %r15, %rdi
movq %r14, %rsi
movl %eax, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x3330
testq %rax, %rax
je 0x79ed
movq 0x8(%rbx), %rdi
movq %rax, %rsi
callq 0x31a0
incq %r12
testl %eax, %eax
jns 0x79a1
movb $0x1, 0x18(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %rdx
pushq $0x1
popq %rbp
testq %rdx, %rdx
je 0x79f3
leaq 0x2ec7(%rip), %rdi      # 0xa8de
movq %r14, %rsi
xorl %eax, %eax
callq 0x3330
testq %rax, %rax
je 0x79ed
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x31a0
testl %eax, %eax
jns 0x79f3
jmp 0x79ed
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x3370
testq %rax, %rax
je 0x7a7d
movq %rax, %r15
incq (%r14)
movq %rbx, %rdi
callq 0x7c12
addq %rax, 0x8(%r14)
movq (%r14), %rax
movq %rax, 0x8(%r15)
movq 0x8(%rbx), %rax
movq %rax, (%r15)
movq %r15, 0x8(%rbx)
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, 0x10(%r14)
xorl %eax, %eax
jmp 0x7a77
// File: /workspace/github_c_makefile_star2_O2/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:
cmpq %rdi, 0x10(%rdx)
je 0x7aa7
pushq %rax
movq 0x8(%rdi), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rdi)
movq %rax, %rdi
callq 0x3070
pushq $0x1
popq %rax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/Automaton_pickle.c
// Function: pickle_dump_undo_replace
static int
pickle_dump_undo_replace(TrieNode* node, const int depth, void* extra) {
#define state ((DumpState*)extra)
    NodeID* repl = (NodeID*)(node->fail);
    node->fail = repl->fail;
    memory_free(repl);

    return 1;
#undef state
}

// Assembly:
pushq %rax
movq 0x8(%rdi), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rdi)
movq %rax, %rdi
callq 0x3070
pushq $0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/WojciechMula[P]pyahocorasick/src/pickle/pickle_data.c
// Function: pickle_data__add_next_buffer
static bool
pickle_data__add_next_buffer(PickleData* data) {

	PyObject* bytes;
	void* raw;

	ASSERT(data != NULL);

	bytes = F(PyBytes_FromStringAndSize)(NULL, data->size);
	if (UNLIKELY(bytes == NULL)) {
		return false;
	}

	if (UNLIKELY(F(PyList_Append)(data->bytes_list, bytes) < 0)) {
		Py_DECREF(bytes);
		return false;
	}

	raw = PyBytes_AS_STRING(bytes);

	data->count 	= (Py_ssize_t*)raw;
	(*data->count)	= 0;

	data->data  	= (uint8_t*)raw;
	data->top   	= PICKLE_CHUNK_COUNTER_SIZE;

	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x7cd9
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x30c0
testq %rax, %rax
je 0x7cc3
movq %rax, %r14
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x31a0
testl %eax, %eax
js 0x7ccc
movq 0x8(%r14), %rax
testb $0x8, 0xab(%rax)
je 0x7d1a
movq %r14, %rax
addq $0x20, %rax
movq %rax, 0x20(%rbx)
andq $0x0, 0x20(%r14)
movq %rax, 0x18(%rbx)
movq $0x8, 0x28(%rbx)
movb $0x1, %r15b
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x37d5
xorl %r15d, %r15d
jmp 0x7cc3
movq 0x6318(%rip), %rbx      # 0xdff8
movq (%rbx), %rdi
leaq 0x346(%rip), %rsi       # 0x8030
leaq 0x304d(%rip), %rdx      # 0xad3e
leaq 0x308d(%rip), %rcx      # 0xad85
leaq 0x3079(%rip), %r9       # 0xad78
pushq $0x23
popq %r8
xorl %eax, %eax
callq 0x31b0
movq (%rbx), %rdi
callq 0x3230
pushq $0x1
popq %rdi
callq 0x3310
leaq 0x8da(%rip), %rdi       # 0x85fb
leaq 0x3016(%rip), %rsi      # 0xad3e
leaq 0x3073(%rip), %rcx      # 0xada2
pushq $0x2f
popq %rdx
callq 0x3130
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/randombytes.c
// Function: randombytes
void randombytes(unsigned char *x,unsigned long long xlen)
{
  int i;

  if (fd == -1) {
    for (;;) {
      fd = open("/dev/urandom",O_RDONLY);
      if (fd != -1) break;
      sleep(1);
    }
  }

  while (xlen > 0) {
    if (xlen < 1048576) i = xlen; else i = 1048576;

    i = read(fd,x,i);
    if (i < 1) {
      sleep(1);
      continue;
    }

    x += i;
    xlen -= i;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $-0x1, 0x5e60(%rip)     # 0x70b0
jne 0x12a4
leaq 0x2dab(%rip), %r15      # 0x4004
pushq $0x1
popq %rbp
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x10d0
movl %eax, 0x5e42(%rip)      # 0x70b0
cmpl $-0x1, %eax
jne 0x12a4
movl %ebp, %edi
callq 0x1130
jmp 0x125c
pushq $0x1
popq %rdi
callq 0x1130
movl 0x5e26(%rip), %edi      # 0x70b0
movq %r14, %rsi
movq %r15, %rdx
callq 0x1070
testl %eax, %eax
jle 0x127c
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, %r14
subq %rax, %rbx
movl $0x100000, %r15d        # imm = 0x100000
cmpq %r15, %rbx
cmovbq %rbx, %r15
testq %rbx, %rbx
jne 0x1284
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tools.c
// Function: error
void error(int code, char message[]) {
    fprintf(stderr, "Error: ");
    fputs(message, stderr);
    fprintf(stderr, "\n");
    exit(code);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movq 0x5d24(%rip), %r14      # 0x6ff8
movq (%r14), %rcx
leaq 0x2d33(%rip), %rdi      # 0x4011
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x1120
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x1050
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x1060
movl %ebp, %edi
callq 0x1110
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tools.c
// Function: errorf
void errorf(int code, char message[], char arg[]) {
    fprintf(stderr, "Error: ");
    fprintf(stderr, message, arg);
    fprintf(stderr, "\n");
    exit(code);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebx
movq 0x5cdb(%rip), %r12      # 0x6ff8
movq (%r12), %rcx
leaq 0x2ce9(%rip), %rdi      # 0x4011
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x1120
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1080
movq (%r12), %rsi
pushq $0xa
popq %rdi
callq 0x1060
movl %ebx, %edi
callq 0x1110
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tools.c
// Function: bytes_to_hex
char * bytes_to_hex(unsigned char bytes[], int size) {
    char *hex = malloc((size * 2) + 1);
    if (hex == NULL) error(1, "Malloc failed!");
    for (int i = 0; i < size; i++) {
        sprintf(hex + (i * 2), "%02x", bytes[i]);
    }
    return hex;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leal 0x1(,%rbx,2), %eax
movslq %eax, %rdi
callq 0x10a0
testq %rax, %rax
je 0x13c3
movq %rax, %r15
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
leaq 0x2c9c(%rip), %r12      # 0x4028
movq %r15, %r13
xorl %ebp, %ebp
cmpq %rbp, %rbx
je 0x13b1
movzbl (%r14,%rbp), %edx
movq %r13, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x1100
incq %rbp
addq $0x2, %r13
jmp 0x1391
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2c4f(%rip), %rsi      # 0x4019
pushq $0x1
popq %rdi
callq 0x12c4
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tools.c
// Function: create_file
FILE * create_file(char filename[]) {
    // http://stackoverflow.com/a/230581
    int fd = open(filename, O_CREAT | O_WRONLY | O_EXCL, S_IRUSR | S_IWUSR);
    if (fd < 0) errorf(1, "Could not write to %s", filename);
    // http://stackoverflow.com/a/1941472
    return fdopen(fd, "wb");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0xc1, %esi
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x10d0
testl %eax, %eax
js 0x13fa
leaq 0x2c51(%rip), %rsi      # 0x4043
movl %eax, %edi
popq %rbx
jmp 0x10c0
leaq 0x2c2c(%rip), %rsi      # 0x402d
pushq $0x1
popq %rdi
movq %rbx, %rdx
callq 0x1306
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tools.c
// Function: read_key
void read_key(char filename[], unsigned char key[], int key_size) {
    FILE *f = fopen(filename, "rb");
    if (fread(key, 1, key_size, f) != key_size)
        errorf(1, "Could not read the key from <%s>", filename);
    fclose(f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x2c0f(%rip), %rsi      # 0x4046
callq 0x10f0
movq %rax, %r14
movslq %ebp, %r12
pushq $0x1
popq %rsi
movq %r15, %rdi
movq %r12, %rdx
movq %rax, %rcx
callq 0x1030
cmpq %r12, %rax
jne 0x1468
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1040
leaq 0x2bda(%rip), %rsi      # 0x4049
pushq $0x1
popq %rdi
movq %rbx, %rdx
callq 0x1306
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tools.c
// Function: read_file
Content read_file(char filename[]) {
    FILE *f = fopen(filename, "rb");
    Content c;
    if (f == 0) errorf(1, "Could not read <%s>", filename);
    fseek(f, 0, SEEK_END);
    long size = ftell(f);
    if (size < 0) errorf(1, "Could not read <%s>", filename);
    c.size = (size_t)size;
    fseek(f, 0, SEEK_SET);
    c.bytes = malloc(c.size);
    if (c.bytes == NULL) error(1, "Malloc failed!");
    fread(c.bytes, c.size, 1, f);
    fclose(f);
    return c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x2bbd(%rip), %rsi      # 0x4046
callq 0x10f0
testq %rax, %rax
je 0x14f4
movq %rax, %rbx
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x10b0
movq %rbx, %rdi
callq 0x1090
testq %rax, %rax
js 0x14f4
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10b0
movq %r15, %rdi
callq 0x10a0
testq %rax, %rax
je 0x1506
movq %rax, %r14
pushq $0x1
popq %rdx
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x1030
movq %rbx, %rdi
callq 0x1040
movq %r15, %rax
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2b6f(%rip), %rsi      # 0x406a
pushq $0x1
popq %rdi
movq %r14, %rdx
callq 0x1306
leaq 0x2b0c(%rip), %rsi      # 0x4019
pushq $0x1
popq %rdi
callq 0x12c4
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: crypto_stream_salsa20_tweet_xor
int crypto_stream_salsa20_xor(u8 *c,const u8 *m,u64 b,const u8 *n,const u8 *k)
{
  u8 z[16],x[64];
  u32 u,i;
  if (!b) return 0;
  FOR(i,16) z[i] = 0;
  FOR(i,8) z[i] = n[i];
  while (b >= 64) {
    crypto_core_salsa20(x,z,k,sigma);
    FOR(i,64) c[i] = (m?m[i]:0) ^ x[i];
    u = 1;
    for (i = 8;i < 16;++i) {
      u += (u32) z[i];
      z[i] = u;
      u >>= 8;
    }
    b -= 64;
    c += 64;
    if (m) m += 64;
  }
  if (b) {
    crypto_core_salsa20(x,z,k,sigma);
    FOR(i,b) c[i] = (m?m[i]:0) ^ x[i];
  }
  return 0;
}

// Assembly:
testq %rdx, %rdx
je 0x1887
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %eax, %eax
cmpq $0x10, %rax
je 0x17af
movb $0x0, (%rsp,%rax)
incq %rax
jmp 0x17a0
xorl %eax, %eax
cmpq $0x8, %rax
je 0x17c2
movb (%rcx,%rax), %dl
movb %dl, (%rsp,%rax)
incq %rax
jmp 0x17b1
movq %rsp, %r13
pushq $0x1
popq %rbp
cmpq $0x40, %rbx
jb 0x183c
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
leaq 0x28b0(%rip), %rcx      # 0x4090
callq 0x154d
xorl %eax, %eax
cmpq $0x40, %rax
je 0x1807
testq %r14, %r14
je 0x17f8
movb (%r14,%rax), %cl
jmp 0x17fa
xorl %ecx, %ecx
xorb 0x10(%rsp,%rax), %cl
movb %cl, (%r15,%rax)
incq %rax
jmp 0x17e7
xorl %eax, %eax
movq %rbp, %rcx
cmpq $0x8, %rax
je 0x1827
movzbl 0x8(%rsp,%rax), %edx
addq %rdx, %rcx
movb %cl, 0x8(%rsp,%rax)
shrq $0x8, %rcx
incq %rax
jmp 0x180c
addq $-0x40, %rbx
addq $0x40, %r15
leaq 0x40(%r14), %rax
testq %r14, %r14
cmovneq %rax, %r14
jmp 0x17c8
testq %rbx, %rbx
je 0x1879
leaq 0x2848(%rip), %rcx      # 0x4090
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
movq %r12, %rdx
callq 0x154d
xorl %eax, %eax
cmpq %rbx, %rax
jae 0x1879
testq %r14, %r14
je 0x186a
movb (%r14,%rax), %cl
jmp 0x186c
xorl %ecx, %ecx
xorb 0x10(%rsp,%rax), %cl
movb %cl, (%r15,%rax)
incq %rax
jmp 0x185a
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: add1305
sv add1305(u32 *h,const u32 *c)
{
  u32 j,u = 0;
  FOR(j,17) {
    u += h[j] + c[j];
    h[j] = u & 255;
    u >>= 8;
  }
}

// Assembly:
xorl %eax, %eax
xorl %ecx, %ecx
cmpq $0x11, %rax
je 0x1bdf
addq (%rdi,%rax,8), %rcx
addq (%rsi,%rax,8), %rcx
movzbl %cl, %edx
movq %rdx, (%rdi,%rax,8)
shrq $0x8, %rcx
incq %rax
jmp 0x1bc1
retq
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: crypto_secretbox_xsalsa20poly1305_tweet
int crypto_secretbox(u8 *c,const u8 *m,u64 d,const u8 *n,const u8 *k)
{
  int i;
  if (d < 32) return -1;
  crypto_stream_xor(c,m,d,n,k);
  crypto_onetimeauth(c + 16,c + 32,d - 32,c);
  FOR(i,16) c[i] = 0;
  return 0;
}

// Assembly:
cmpq $0x20, %rdx
jae 0x1c12
pushq $-0x1
popq %rax
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
callq 0x18f1
leaq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rsi
addq $-0x20, %r14
movq %r14, %rdx
movq %rbx, %rcx
callq 0x194a
xorl %eax, %eax
xorl %ecx, %ecx
cmpq $0x10, %rcx
je 0x1c4b
movb $0x0, (%rbx,%rcx)
incq %rcx
jmp 0x1c3c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: crypto_secretbox_xsalsa20poly1305_tweet_open
int crypto_secretbox_open(u8 *m,const u8 *c,u64 d,const u8 *n,const u8 *k)
{
  int i;
  u8 x[32];
  if (d < 32) return -1;
  crypto_stream(x,32,n,k);
  if (crypto_onetimeauth_verify(c + 16,c + 32,d - 32,x) != 0) return -1;
  crypto_stream_xor(m,c,d,n,k);
  FOR(i,32) m[i] = 0;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
pushq $-0x1
popq %r14
cmpq $0x20, %rdx
jb 0x1ca3
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq %rsp, %rdi
pushq $0x20
popq %rsi
movq %rcx, %rdx
movq %r8, %rcx
callq 0x189f
leaq 0x10(%rbp), %rdi
leaq 0x20(%rbp), %rsi
leaq -0x20(%r13), %rdx
movq %rsp, %rcx
callq 0x1be0
testl %eax, %eax
je 0x1cb5
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0x18f1
xorl %r14d, %r14d
xorl %eax, %eax
cmpq $0x20, %rax
je 0x1ca3
movb $0x0, (%rbx,%rax)
incq %rax
jmp 0x1cce
// File: /workspace/github_c_makefile_star2_O2/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: sel25519
sv sel25519(gf p,gf q,int b)
{
  i64 t,i,c=~(b-1);
  FOR(i,16) {
    t= c&(p[i]^q[i]);
    p[i]^=t;
    q[i]^=t;
  }
}

// Assembly:
negl %edx
movslq %edx, %rax
xorl %ecx, %ecx
cmpq $0x10, %rcx
je 0x1fe5
movq (%rdi,%rcx,8), %rdx
movq (%rsi,%rcx,8), %r8
xorq %rdx, %r8
andq %rax, %r8
xorq %r8, %rdx
movq %rdx, (%rdi,%rcx,8)
xorq %r8, (%rsi,%rcx,8)
incq %rcx
jmp 0x1fc1
retq