LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x6676
movq %rsi, %rbx
movq 0x10(%rsi), %rdx
leaq -0x3(%rdx), %rax
cmpq $-0x3, %rax
ja 0x6594
movq 0x9a15(%rip), %rax      # 0xff90
movq (%rax), %rdi
leaq 0x51ed(%rip), %rsi      # 0xb772
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x3300
jmp 0x6667
movq %rdi, %r14
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3140
testq %rax, %rax
je 0x6667
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x45cd
testb %al, %al
je 0x6664
movq 0x28(%r14), %rdi
leaq 0x8(%rsp), %r12
movq (%r12), %rdx
movq 0x8(%r12), %rsi
callq 0x5759
movq %rax, %r15
movq %r12, %rdi
callq 0x48e4
testq %r15, %r15
je 0x6622
cmpb $0x0, 0x14(%r15)
je 0x6622
movl 0x14(%r14), %eax
cmpl $0xa, %eax
je 0x6606
cmpl $0x1e, %eax
je 0x664a
cmpl $0x14, %eax
jne 0x6655
movq (%r15), %rsi
leaq 0x5705(%rip), %rdi      # 0xbd15
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3330
movl $0x1, %esi
movq %rbx, %rdi
callq 0x3140
testq %rax, %rax
je 0x663c
movq %rax, %r15
incq (%rax)
jmp 0x6667
callq 0x3190
movq 0x9950(%rip), %rax      # 0xff98
jmp 0x665c
movq (%r15), %rax
incq (%rax)
movq (%r15), %r15
jmp 0x6667
movq 0x992c(%rip), %rax      # 0xff88
movq (%rax), %rdi
callq 0x3160
xorl %r15d, %r15d
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2aab(%rip), %rdi      # 0x9128
leaq 0x50ae(%rip), %rsi      # 0xb732
leaq 0x50b7(%rip), %rcx      # 0xb742
movl $0x1fd, %edx            # imm = 0x1FD
callq 0x3130
// File: /workspace/github_c_makefile_star2_O3/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 0x6e0e
movq %rbx, %rdi
callq 0x7cdc
movq 0x40(%rbx), %rdx
movq 0x48(%rbx), %r8
subq $0x8, %rsp
leaq 0x4ee3(%rip), %r10      # 0xbd04
leaq 0x4ed0(%rip), %r11      # 0xbcf8
leaq 0x4ebd(%rip), %r14      # 0xbcec
leaq 0x4e77(%rip), %rdi      # 0xbcad
leaq 0x4e8a(%rip), %rsi      # 0xbcc7
leaq 0x4e8f(%rip), %rcx      # 0xbcd3
leaq 0x4e94(%rip), %r9       # 0xbcdf
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_O3/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 0x6f25
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 0x6ee7
movq 0x28(%r14), %rdi
leaq 0xed2(%rip), %rsi       # 0x7da5
movq %rsp, %rbx
movq %rbx, %rdx
callq 0x5696
cmpb $0x0, 0x18(%rbx)
movq (%rbx), %rbx
je 0x6f31
testq %rbx, %rbx
je 0x6ef9
decq (%rbx)
jne 0x6ef9
movq %rbx, %rdi
callq 0x30d0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6f0d
decq (%rdi)
jne 0x6f0d
callq 0x30d0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x6f21
decq (%rdi)
jne 0x6f21
callq 0x30d0
xorl %eax, %eax
jmp 0x6f4c
movq 0x9094(%rip), %rax      # 0xffc0
incq (%rax)
jmp 0x6f4c
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
leaq 0x4dcd(%rip), %rdi      # 0xbd0f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3330
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7228
pushq %rbx
movq %rdi, %rbx
movl 0x38(%rdi), %eax
cmpl 0x30(%rdi), %eax
je 0x721d
movq %rbx, %rdi
callq 0x7cdc
movq 0x68(%rbx), %rsi
addq $0x70, %rsi
popq %rbx
jmp 0x722d
movl $0x70, %esi
leaq 0x4ae1(%rip), %rdi      # 0xbd15
xorl %eax, %eax
jmp 0x3330
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x76ec
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x76e6
movq 0x18(%rdi), %rax
shlq $0x2, %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %r8d, %r8d
cmpl %edx, (%rax,%r8)
je 0x76dc
addq $0xc, %r8
cmpq %r8, %rcx
jne 0x76cb
jmp 0x76e6
movq 0x4(%rax,%r8), %rax
testq %rax, %rax
jne 0x76ef
movq 0x8(%rdi), %rdi
jmp 0x76af
movq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/WojciechMula[P]pyahocorasick/src/AutomatonSearchIter.c
// Function: automaton_search_iter_next
static PyObject*
automaton_search_iter_next(PyObject* self) {
    PyObject* output;

    if (iter->version != iter->automaton->version) {
        PyErr_SetString(PyExc_ValueError, "underlaying automaton has changed, iterator is not valid anymore");
        return NULL;
    }

return_output:
    switch (automaton_build_output(self, &output)) {
        case OutputValue:
            return output;

        case OutputNone:
            break;

        case OutputError:
            return NULL;
    }

#ifdef VARIABLE_LEN_CHARCODES
    if (!automaton_search_iter_advance_index(self)) {
        return NULL;
    }
#else
    iter->index += 1;
    if (iter->ignore_white_space) {
        while ((iter->index < iter->end) and iswspace(iter->input.word[iter->index])) {
            iter->index += 1;
        }
    }
#endif
    while (iter->index < iter->end) {
        // process single char
        iter->state = ahocorasick_next(
                        iter->state,
                        iter->automaton->root,
                        iter->input.word[iter->index]
                        );

        ASSERT(iter->state);

        iter->output = iter->state;
        goto return_output;

#ifdef VARIABLE_LEN_CHARCODES
        if (!automaton_search_iter_advance_index(self)) {
            return NULL;
        }
#else
        iter->index += 1;
#endif

    } // while

    return NULL;    // StopIteration
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x18(%rdi), %eax
movq 0x10(%rdi), %r14
cmpl 0x30(%r14), %eax
jne 0x77c5
movq %rdi, %rbx
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x7756
cmpb $0x0, 0x14(%rax)
movq 0x8(%rax), %rcx
jne 0x77e5
movq %rcx, %rax
testq %rcx, %rcx
jne 0x773c
movq %rcx, 0x48(%rbx)
movq 0x50(%rbx), %rcx
movq 0x60(%rbx), %rdx
incq %rcx
movq %rcx, 0x50(%rbx)
cmpq %rdx, %rcx
setl %al
andb 0x68(%rbx), %al
cmpb $0x1, %al
jne 0x7796
movq 0x28(%rbx), %rax
movl (%rax,%rcx,4), %edi
callq 0x3290
movq 0x50(%rbx), %rcx
movq 0x60(%rbx), %rdx
testl %eax, %eax
je 0x7796
incq %rcx
movq %rcx, 0x50(%rbx)
cmpq %rdx, %rcx
jl 0x7772
cmpq %rdx, %rcx
jge 0x77db
movq 0x40(%rbx), %rdi
movq 0x10(%rbx), %r14
movq 0x28(%rbx), %rax
movq 0x28(%r14), %rsi
movl (%rax,%rcx,4), %edx
callq 0x76af
movq %rax, 0x40(%rbx)
testq %rax, %rax
je 0x783b
movq %rax, 0x48(%rbx)
jmp 0x7737
movq 0x87bc(%rip), %rax      # 0xff88
movq (%rax), %rdi
leaq 0x426a(%rip), %rsi      # 0xba40
callq 0x3120
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rcx, 0x48(%rbx)
movq 0x58(%rbx), %rsi
addq 0x50(%rbx), %rsi
movl 0x14(%r14), %ecx
cmpl $0xa, %ecx
je 0x7804
cmpl $0x1e, %ecx
je 0x7810
cmpl $0x14, %ecx
jne 0x7828
movq (%rax), %rdx
leaq 0x40e0(%rip), %rdi      # 0xb8ee
jmp 0x781a
movq (%rax), %rdx
leaq 0x4785(%rip), %rdi      # 0xbf9f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3330
movq 0x8759(%rip), %rax      # 0xff88
movq (%rax), %rdi
leaq 0x4289(%rip), %rsi      # 0xbac2
jmp 0x77d6
callq 0x43dc
// File: /workspace/github_c_makefile_star2_O3/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 0x792b
xorps %xmm0, %xmm0
movq %rsp, %rdx
movups %xmm0, 0x8(%rdx)
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x45cd
testb %al, %al
je 0x78e0
movl $0x1, %esi
movq %r14, %rdi
callq 0x3140
testq %rax, %rax
je 0x78e5
movq %rax, %rdi
callq 0x3250
testl %eax, %eax
je 0x78ea
cmpl $0x1, %eax
jne 0x78e0
leaq 0x20(%rbx), %rdi
callq 0x48e4
movq (%rsp), %rax
movq %rax, 0x20(%rbx)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x28(%rbx)
movq $-0x1, 0x50(%rbx)
movq %rax, 0x60(%rbx)
movq 0x10(%rbx), %rax
movq 0x28(%rax), %rax
movq %rax, 0x40(%rbx)
xorl %eax, %eax
movq %rax, 0x58(%rbx)
movq %rax, 0x48(%rbx)
jmp 0x7921
xorl %r15d, %r15d
jmp 0x792b
callq 0x3190
leaq 0x20(%rbx), %rdi
callq 0x48e4
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)
movq $-0x1, 0x50(%rbx)
movq %rax, 0x60(%rbx)
movq 0x8698(%rip), %r15      # 0xffc0
incq (%r15)
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
decq (%rdi)
jne 0x794a
callq 0x30d0
movq 0x20(%rbx), %rdi
decq (%rdi)
jne 0x7958
callq 0x30d0
leaq 0x28(%rbx), %rdi
callq 0x48e4
movq %rbx, %rdi
popq %rbx
jmp 0x3170
// File: /workspace/github_c_makefile_star2_O3/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 0x7ccd
movq %rax, %r14
xorps %xmm0, %xmm0
leaq 0x8(%rsp), %rdx
movups %xmm0, 0x8(%rdx)
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x45cd
testb %al, %al
je 0x7c6c
movl $0x1, %esi
movq %r15, %rdi
callq 0x3140
testq %rax, %rax
je 0x7c71
movq %rax, %rdi
callq 0x3250
testl %eax, %eax
je 0x7c76
cmpl $0x1, %eax
jne 0x7c6c
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x7c1f
decq (%rdi)
jne 0x7c1f
callq 0x30d0
incq (%r14)
movq %r14, 0x20(%rbx)
leaq 0x28(%rbx), %rdi
callq 0x48e4
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rbx)
movups 0x10(%rsp), %xmm0
movups %xmm0, 0x30(%rbx)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %ecx, 0x5c(%rbx)
movl %eax, 0x64(%rbx)
movq 0x10(%rbx), %rax
movq 0x28(%rax), %rax
movq %rax, 0x48(%rbx)
movl $0x0, 0x60(%rbx)
movq $0x0, 0x50(%rbx)
movl %ecx, 0x58(%rbx)
jmp 0x7cc2
xorl %r12d, %r12d
jmp 0x7ccd
callq 0x3190
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x7c89
decq (%rdi)
jne 0x7c89
callq 0x30d0
incq (%r14)
movq %r14, 0x20(%rbx)
leaq 0x28(%rbx), %rdi
callq 0x48e4
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)
movl $0xffffffff, 0x5c(%rbx) # imm = 0xFFFFFFFF
movl %eax, 0x64(%rbx)
movq 0x82f7(%rip), %r12      # 0xffc0
incq (%r12)
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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)
movq $0x0, 0x68(%rdi)
cmpl $0x0, 0x10(%rdi)
je 0x7d10
leaq 0x38(%rbx), %rsi
movq 0x28(%rbx), %rdi
xorl %edx, %edx
callq 0x7d18
movl 0x30(%rbx), %eax
movl %eax, 0x38(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x12f6(%rip), %xmm2     # 0x9030
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 0x7d6d
movq %rcx, 0x18(%rbx)
testl %eax, %eax
je 0x7d9a
incl %ebp
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x572c
movq %rax, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x7d18
incq %r15
movl 0x10(%r14), %eax
cmpq %rax, %r15
jb 0x7d76
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3b2d(%rip), %rdi      # 0xb8ee
movq %r14, %rsi
xorl %eax, %eax
callq 0x3330
testq %rax, %rax
je 0x7e78
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x31a0
testl %eax, %eax
js 0x7e78
cmpl $0x0, 0x10(%r14)
je 0x7e44
leaq 0x3f1e(%rip), %r15      # 0xbd13
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
callq 0x572c
movq %rax, %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0x5ff9
movq %r15, %rdi
movq %r14, %rsi
movl %eax, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x3330
testq %rax, %rax
je 0x7e78
movq 0x8(%rbx), %rdi
movq %rax, %rsi
callq 0x31a0
testl %eax, %eax
js 0x7e78
incq %r12
movl 0x10(%r14), %eax
cmpq %rax, %r12
jb 0x7df8
movq 0x8(%r14), %rdx
movl $0x1, %ebp
testq %rdx, %rdx
je 0x7e7e
leaq 0x3a95(%rip), %rdi      # 0xb8ee
movq %r14, %rsi
xorl %eax, %eax
callq 0x3330
testq %rax, %rax
je 0x7e78
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x31a0
testl %eax, %eax
jns 0x7e7e
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
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x10, %edi
callq 0x3370
testq %rax, %rax
je 0x7ed8
movq %rax, %r15
incq (%r14)
movq %rbx, %rdi
callq 0x8039
addq %rax, 0x8(%r14)
movq (%r14), %rax
movq %rax, 0x8(%r15)
movq 0x8(%rbx), %rax
movq %rax, (%r15)
movq %r15, 0x8(%rbx)
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, 0x10(%r14)
xorl %eax, %eax
jmp 0x7ed2
// File: /workspace/github_c_makefile_star2_O3/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 0x7f04
pushq %rax
movq 0x8(%rdi), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rdi)
movq %rax, %rdi
callq 0x3070
movl $0x1, %eax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/WojciechMula[P]pyahocorasick/src/Automaton_pickle.c
// Function: pickle_dump_save
static int
pickle_dump_save(TrieNode* node, const int depth, void* extra) {
#define self ((PickleData*)extra)
#define NODEID(object) ((NodeID*)((TrieNode*)object)->fail)

    TrieNode* dump;
    TrieNode* tmp;
    Pair* arr;
    unsigned i;
    size_t size;

    size = get_pickled_size(node);
    if (UNLIKELY(self->top + size > self->size)) {
        if (UNLIKELY(!pickle_data__add_next_buffer(self))) {
            self->error = true;
            return 0;
        }
    }

    dump = (TrieNode*)(self->data + self->top);

    // we do not save the last pointer in array
    arr = (Pair*)(self->data + self->top + PICKLE_TRIENODE_SIZE);

    // append the python object to the list
    if (node->eow and self->values) {
        if (PyList_Append(self->values, node->output.object) == -1) {
            self->error = true;
            return 0;
        }
    }

    // save node data
    if (self->values)
        dump->output.integer = 0;
    else
        dump->output.integer = node->output.integer;

    dump->n         = node->n;
    dump->eow       = node->eow;

    tmp = NODEID(node)->fail;
    if (tmp)
        dump->fail  = (TrieNode*)(NODEID(tmp)->id);
    else
        dump->fail  = NULL;

    // save array of pointers
    for (i=0; i < node->n; i++) {
        TrieNode* child = trienode_get_ith_unsafe(node, i);
        ASSERT(child);
        arr[i].child  = (TrieNode*)(NODEID(child)->id);    // save the id of child node
        arr[i].letter = trieletter_get_ith_unsafe(node, i);
    }

    self->top       += size;
    (*self->count)  += 1;
    return 1;
#undef NODEID
#undef self
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
callq 0x8039
movq %rax, %r15
movq 0x28(%rbx), %r12
addq %r12, %rax
cmpq 0x10(%rbx), %rax
ja 0x7ffc
movq 0x18(%rbx), %rbp
cmpb $0x0, 0x14(%r14)
je 0x7f56
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x7f56
movq (%r14), %rsi
callq 0x31a0
cmpl $-0x1, %eax
je 0x8011
cmpq $0x0, 0x30(%rbx)
je 0x7f61
xorl %eax, %eax
jmp 0x7f64
movq (%r14), %rax
movq %rax, (%rbp,%r12)
movl 0x10(%r14), %r13d
movl %r13d, 0x10(%rbp,%r12)
movb 0x14(%r14), %al
movb %al, 0x14(%rbp,%r12)
movq 0x8(%r14), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x7f91
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
jmp 0x7f93
xorl %eax, %eax
movq %rax, 0x8(%rbp,%r12)
testq %r13, %r13
je 0x7fdd
addq %r12, %rbp
addq $0x1c, %rbp
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
callq 0x572c
testq %rax, %rax
je 0x8019
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, (%rbp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x5ff9
movl %eax, -0x4(%rbp)
incq %r12
addq $0xc, %rbp
cmpq %r12, %r13
jne 0x7fa7
addq %r15, 0x28(%rbx)
movq 0x20(%rbx), %rax
incq (%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x8054
testb %al, %al
je 0x8011
movq 0x28(%rbx), %r12
jmp 0x7f31
movb $0x1, 0x38(%rbx)
xorl %eax, %eax
jmp 0x7fed
callq 0x4420
// File: /workspace/github_c_makefile_star2_O3/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 0x80d0
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x30c0
testq %rax, %rax
je 0x80b5
movq %rax, %r14
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x31a0
testl %eax, %eax
js 0x80be
movq 0x8(%r14), %rax
testb $0x8, 0xab(%rax)
je 0x80d5
movq %r14, %rax
addq $0x20, %rax
movq %rax, 0x20(%rbx)
movq $0x0, 0x20(%r14)
movq %rax, 0x18(%rbx)
movq $0x8, 0x28(%rbx)
movb $0x1, %r15b
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
decq (%r14)
jne 0x80cb
movq %r14, %rdi
callq 0x30d0
xorl %r15d, %r15d
jmp 0x80b5
callq 0x44a6
leaq 0x152f(%rip), %rdi      # 0x960b
leaq 0x3c6b(%rip), %rsi      # 0xbd4e
leaq 0x3cc8(%rip), %rcx      # 0xbdb2
movl $0x2f, %edx
callq 0x3130
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $-0x1, 0x5e4f(%rip)     # 0x70c0
jne 0x12b6
leaq 0x2d8a(%rip), %rdi      # 0x4004
xorl %esi, %esi
xorl %eax, %eax
callq 0x10f0
movl %eax, 0x5e37(%rip)      # 0x70c0
cmpl $-0x1, %eax
jne 0x12b6
leaq 0x2d6f(%rip), %r15      # 0x4004
movl $0x1, %edi
callq 0x1150
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x10f0
movl %eax, 0x5e0f(%rip)      # 0x70c0
cmpl $-0x1, %eax
je 0x1295
testq %rbx, %rbx
je 0x12fc
movl $0x100000, %r12d        # imm = 0x100000
cmpq %r12, %rbx
movl $0x100000, %r15d        # imm = 0x100000
cmovbq %rbx, %r15
movl 0x5dec(%rip), %edi      # 0x70c0
movq %r14, %rsi
movq %r15, %rdx
callq 0x1080
testl %eax, %eax
jg 0x12ef
movl $0x1, %edi
callq 0x1150
jmp 0x12ce
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, %r14
subq %rax, %rbx
jne 0x12c1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5ce0(%rip), %r14      # 0x6ff8
movq (%r14), %rcx
leaq 0x2cef(%rip), %rdi      # 0x4011
movl $0x7, %esi
movl $0x1, %edx
callq 0x1140
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x1050
movq (%r14), %rsi
movl $0xa, %edi
callq 0x1070
movl %ebp, %edi
callq 0x1130
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movq 0x5c92(%rip), %r15      # 0x6ff8
movq (%r15), %rcx
leaq 0x2ca1(%rip), %rdi      # 0x4011
movl $0x7, %esi
movl $0x1, %edx
callq 0x1140
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1090
movq (%r15), %rsi
movl $0xa, %edi
callq 0x1070
movl %ebp, %edi
callq 0x1130
// File: /workspace/github_c_makefile_star2_O3/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, %r15d
movq %rdi, %rbx
leal 0x1(,%r15,2), %eax
movslq %eax, %rdi
callq 0x10c0
testq %rax, %rax
je 0x140f
movq %rax, %r14
testl %r15d, %r15d
jle 0x13fd
movl %r15d, %r13d
leaq 0x2c4d(%rip), %r15      # 0x4028
movq %r14, %r12
xorl %ebp, %ebp
movzbl (%rbx,%rbp), %edx
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1120
incq %rbp
addq $0x2, %r12
cmpq %rbp, %r13
jne 0x13e0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2c03(%rip), %rsi      # 0x4019
movl $0x1, %edi
callq 0x1308
// File: /workspace/github_c_makefile_star2_O3/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 0x10f0
testl %eax, %eax
js 0x1448
leaq 0x2c03(%rip), %rsi      # 0x4043
movl %eax, %edi
popq %rbx
jmp 0x10e0
leaq 0x2bde(%rip), %rsi      # 0x402d
movl $0x1, %edi
movq %rbx, %rdx
callq 0x1350
// File: /workspace/github_c_makefile_star2_O3/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 0x2bbf(%rip), %rsi      # 0x4046
callq 0x1110
movq %rax, %r14
movslq %ebp, %r12
movl $0x1, %esi
movq %r15, %rdi
movq %r12, %rdx
movq %rax, %rcx
callq 0x1030
cmpq %r12, %rax
jne 0x14ba
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1040
leaq 0x2b88(%rip), %rsi      # 0x4049
movl $0x1, %edi
movq %rbx, %rdx
callq 0x1350
// File: /workspace/github_c_makefile_star2_O3/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 0x2b69(%rip), %rsi      # 0x4046
callq 0x1110
testq %rax, %rax
je 0x154c
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x10d0
movq %rbx, %rdi
callq 0x10a0
testq %rax, %rax
js 0x154c
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10d0
movq %r15, %rdi
callq 0x10c0
testq %rax, %rax
je 0x1560
movq %rax, %r14
movl $0x1, %edx
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 0x2b17(%rip), %rsi      # 0x406a
movl $0x1, %edi
movq %r14, %rdx
callq 0x1350
leaq 0x2ab2(%rip), %rsi      # 0x4019
movl $0x1, %edi
callq 0x1308
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x195b
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
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq (%rcx), %rax
movq %rax, (%rsp)
cmpq $0x40, %rdx
jb 0x1912
leaq 0x10(%rsp), %rbp
movq %rsp, %r13
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
leaq 0x27e7(%rip), %rcx      # 0x4090
xorl %r8d, %r8d
callq 0x1619
xorl %eax, %eax
testq %r14, %r14
je 0x18be
movb (%r14,%rax), %cl
jmp 0x18c0
xorl %ecx, %ecx
xorb 0x10(%rsp,%rax), %cl
movb %cl, (%r15,%rax)
incq %rax
cmpq $0x40, %rax
jne 0x18b3
movl $0x1, %ecx
xorl %eax, %eax
movzbl 0x8(%rsp,%rax), %edx
addq %rcx, %rdx
movb %dl, 0x8(%rsp,%rax)
shrq $0x8, %rdx
incq %rax
movq %rdx, %rcx
cmpq $0x8, %rax
jne 0x18d8
addq $-0x40, %rbx
addq $0x40, %r15
leaq 0x40(%r14), %rax
testq %r14, %r14
cmovneq %rax, %r14
cmpq $0x3f, %rbx
ja 0x1899
testq %rbx, %rbx
je 0x194d
leaq 0x2777(%rip), %rcx      # 0x4090
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
xorl %r13d, %r13d
movq %r12, %rdx
xorl %r8d, %r8d
callq 0x1619
testq %r14, %r14
je 0x193a
movb (%r14,%r13), %al
jmp 0x193c
xorl %eax, %eax
xorb 0x10(%rsp,%r13), %al
movb %al, (%r15,%r13)
incq %r13
cmpq %r13, %rbx
jne 0x192f
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_O3/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:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x20, %rdx
jb 0x1ddd
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x230e(%rip), %rcx      # 0x4090
movq %rsp, %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r8, %rdx
movl $0x1, %r8d
callq 0x1619
addq $0x10, %r15
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r13, %r8
callq 0x1856
leaq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rsi
addq $-0x20, %r14
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1a2c
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x58, %rsp
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpq $0x20, %rdx
jb 0x1eac
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
leaq 0x227d(%rip), %rcx      # 0x4090
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
movq %r8, %rdx
movl $0x1, %r8d
callq 0x1619
leaq 0x10(%r13), %rcx
leaq 0x30(%rsp), %rbx
movl $0x20, %edx
movq %rbx, %rdi
xorl %esi, %esi
movq %rcx, (%rsp)
leaq 0x10(%rsp), %r8
callq 0x1856
leaq 0x10(%r15), %rdi
leaq 0x20(%r15), %rsi
leaq -0x20(%r14), %rdx
movq %rbx, %rcx
callq 0x1cf6
testl %eax, %eax
jne 0x1eac
leaq 0x2227(%rip), %rcx      # 0x4090
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movl $0x1, %r8d
callq 0x1619
movq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq (%rsp), %rcx
movq %rbx, %r8
callq 0x1856
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
movups %xmm0, (%r12)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: M
sv M(gf o,const gf a,const gf b)
{
  i64 i,j,t[31];
  FOR(i,31) t[i]=0;
  FOR(i,16) FOR(j,16) t[i+j]+=a[i]*b[j];
  FOR(i,15) t[i]+=38*t[i+16];
  FOR(i,16) o[i]=t[i];
  car25519(o);
  car25519(o);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
xorl %r13d, %r13d
movl $0xf8, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x1060
movq (%r15,%r13,8), %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa %xmm0, %xmm1
psrlq $0x20, %xmm1
xorl %eax, %eax
movdqu (%r14,%rax,8), %xmm2
movdqa %xmm2, %xmm3
pmuludq %xmm1, %xmm3
movdqa %xmm2, %xmm4
psrlq $0x20, %xmm4
pmuludq %xmm0, %xmm4
paddq %xmm3, %xmm4
psllq $0x20, %xmm4
pmuludq %xmm0, %xmm2
movdqu (%r12,%rax,8), %xmm3
paddq %xmm2, %xmm3
paddq %xmm4, %xmm3
movdqu %xmm3, (%r12,%rax,8)
addq $0x2, %rax
cmpq $0x10, %rax
jne 0x23d7
incq %r13
addq $0x8, %r12
cmpq $0x10, %r13
jne 0x23c1
xorl %eax, %eax
imulq $0x26, 0x80(%rsp,%rax,8), %rcx
addq %rcx, (%rsp,%rax,8)
incq %rax
cmpq $0xf, %rax
jne 0x242c
movq %rsp, %rsi
movl $0x10, %ecx
movq %rbx, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
callq 0x3865
movq %rbx, %rdi
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3865
// File: /workspace/github_c_makefile_star2_O3/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: inv25519
sv inv25519(gf o,const gf i)
{
  gf c;
  int a;
  FOR(a,16) c[a]=i[a];
  for(a=253;a>=0;a--) {
    S(c,c);
    if(a!=2&&a!=4) M(c,c,i);
  }
  FOR(a,16) o[a]=c[a];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movl $0x10, %ecx
movq %r15, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl $0xfd, %ebp
movq %r15, %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0x2393
cmpl $0x2, %ebp
je 0x24bc
cmpl $0x4, %ebp
je 0x24bc
movq %r15, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2393
addl $-0x1, %ebp
jb 0x2496
movq %rsp, %rsi
movl $0x10, %ecx
movq %rbx, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: pack25519
sv pack25519(u8 *o,const gf n)
{
  int i,j,b;
  gf m,t;
  FOR(i,16) t[i]=n[i];
  car25519(t);
  car25519(t);
  car25519(t);
  FOR(j,2) {
    m[0]=t[0]-0xffed;
    for(i=1;i<15;i++) {
      m[i]=t[i]-0xffff-((m[i-1]>>16)&1);
      m[i-1]&=0xffff;
    }
    m[15]=t[15]-0x7fff-((m[14]>>16)&1);
    b=(m[15]>>16)&1;
    m[14]&=0xffff;
    sel25519(t,m,1-b);
  }
  FOR(i,16) {
    o[2*i]=t[i]&0xff;
    o[2*i+1]=t[i]>>8;
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
leaq 0x80(%rsp), %r14
movl $0x10, %ecx
movq %r14, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, %rdi
callq 0x3865
movq %r14, %rdi
callq 0x3865
movq %r14, %rdi
callq 0x3865
movb $0x1, %cl
movq $-0xffed, %rax          # imm = 0xFFFF0013
movq 0x80(%rsp), %rsi
addq %rax, %rsi
movq %rsi, (%rsp)
movl $0x1, %edx
movq 0x80(%rsp,%rdx,8), %rdi
movzwl %si, %r8d
shlq $0x2f, %rsi
sarq $0x3f, %rsi
addq %rdi, %rsi
addq $-0xffff, %rsi          # imm = 0xFFFF0001
movq %rsi, (%rsp,%rdx,8)
movq %r8, -0x8(%rsp,%rdx,8)
incq %rdx
cmpq $0xf, %rdx
jne 0x2532
movq 0xf8(%rsp), %rdx
movq 0x70(%rsp), %rsi
movzwl %si, %edi
shlq $0x2f, %rsi
sarq $0x3f, %rsi
addq %rsi, %rdx
addq $-0x7fff, %rdx          # imm = 0x8001
movq %rdx, 0x78(%rsp)
movq %rdi, 0x70(%rsp)
btl $0x10, %edx
movl $0x0, %edx
adcl $-0x1, %edx
movslq %edx, %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
xorl %edx, %edx
movdqa 0x80(%rsp,%rdx,8), %xmm1
movdqa (%rsp,%rdx,8), %xmm2
movdqa %xmm2, %xmm3
pxor %xmm1, %xmm3
pand %xmm0, %xmm3
pxor %xmm3, %xmm1
movdqa %xmm1, 0x80(%rsp,%rdx,8)
pxor %xmm2, %xmm3
movdqa %xmm3, (%rsp,%rdx,8)
addq $0x2, %rdx
cmpq $0x10, %rdx
jne 0x25a9
testb $0x1, %cl
movl $0x0, %ecx
jne 0x251e
xorl %eax, %eax
movzwl 0x80(%rsp,%rax,8), %ecx
movw %cx, (%rbx,%rax,2)
incq %rax
cmpq $0x10, %rax
jne 0x25f3
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: crypto_hash_sha512_tweet
int crypto_hash(u8 *out,const u8 *m,u64 n)
{
  u8 h[64],x[256];
  u64 i,b = n;

  FOR(i,64) h[i] = iv[i];

  crypto_hashblocks(h,m,n);
  m += n;
  n &= 127;
  m -= n;

  FOR(i,256) x[i] = 0;
  FOR(i,n) x[i] = m[i];
  x[n] = 128;

  n = 256-128*(n<112);
  x[n-9] = b >> 61;
  ts64(x+n-8,b<<3);
  crypto_hashblocks(h,x,n);

  FOR(i,64) out[i] = h[i];

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x140, %rsp            # imm = 0x140
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movaps 0x19b3(%rip), %xmm0     # 0x43c0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movaps 0x19b6(%rip), %xmm0     # 0x43d0
movaps %xmm0, 0x10(%rdi)
movaps 0x19bb(%rip), %xmm0     # 0x43e0
movaps %xmm0, 0x20(%rdi)
movaps 0x19c0(%rip), %xmm0     # 0x43f0
movaps %xmm0, 0x30(%rdi)
callq 0x278c
leaq 0x40(%rsp), %r15
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
xorl %esi, %esi
callq 0x1060
movq %r14, %r13
andq $0x7f, %r13
je 0x2a6c
addq %r14, %r12
subq %r13, %r12
leaq 0x40(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x10b0
movb $-0x80, 0x40(%rsp,%r13)
xorl %eax, %eax
cmpq $0x70, %r13
setae %al
shll $0x7, %eax
leaq 0x80(%rax), %rdx
movq %r14, %rcx
shrq $0x3d, %rcx
movb %cl, 0x77(%rax,%r15)
addq %rsp, %rax
addq $0xb8, %rax
shlq $0x3, %r14
movl $0x8, %ecx
movb %r14b, -0x1(%rax,%rcx)
shrq $0x8, %r14
decq %rcx
jne 0x2aa3
movq %rsp, %r14
leaq 0x40(%rsp), %rsi
movq %r14, %rdi
callq 0x278c
movaps (%r14), %xmm0
movaps 0x10(%r14), %xmm1
movaps 0x20(%r14), %xmm2
movaps 0x30(%r14), %xmm3
movups %xmm0, (%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm3, 0x30(%rbx)
xorl %eax, %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: crypto_sign_ed25519_tweet_keypair
int crypto_sign_keypair(u8 *pk, u8 *sk)
{
  u8 d[64];
  gf p[4];
  int i;

  randombytes(sk, 32);
  crypto_hash(d, sk, 32);
  d[0] &= 248;
  d[31] &= 127;
  d[31] |= 64;

  scalarbase(p,d);
  pack(pk,p);

  FOR(i,32) sk[32 + i] = pk[i];
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x440, %rsp            # imm = 0x440
movq %rsi, %rbx
movq %rdi, %r14
movl $0x20, %esi
movq %rbx, %rdi
callq 0x125c
movq %rsp, %r15
movl $0x20, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x29ed
andb $-0x8, (%r15)
movb 0x1f(%r15), %al
andb $0x3f, %al
orb $0x40, %al
movb %al, 0x1f(%r15)
leaq 0x195d(%rip), %rax      # 0x44a0
leaq 0x40(%rsp), %r12
movl $0x10, %ecx
movq %r12, %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0xc0(%rsp), %rdi
leaq 0x19bb(%rip), %rdx      # 0x4520
movl $0x10, %ecx
movq %rdx, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x140(%rsp), %rdi
leaq 0x1a21(%rip), %rsi      # 0x45a0
movl $0x10, %ecx
rep  movsq (%rsi), %es:(%rdi)
leaq 0x1c0(%rsp), %rdi
movq %rax, %rsi
callq 0x2393
leaq 0x240(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x34f0
movq %r14, %rdi
movq %r13, %rsi
callq 0x2bde
xorl %eax, %eax
movb (%r14,%rax), %cl
movb %cl, 0x20(%rbx,%rax)
incq %rax
cmpq $0x20, %rax
jne 0x2bba
xorl %eax, %eax
addq $0x440, %rsp            # imm = 0x440
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sbp[P]tweetnacl-tools/tweetnacl.c
// Function: pack
sv pack(u8 *r,gf p[4])
{
  gf tx, ty, zi;
  inv25519(zi, p[2]); 
  M(tx, p[0], zi);
  M(ty, p[1], zi);
  pack25519(r, ty);
  r[31] ^= par25519(tx) << 7;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
addq $0x100, %rsi            # imm = 0x100
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x2470
leaq 0x120(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2393
subq $-0x80, %r14
leaq 0xa0(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2393
movq %rbx, %rdi
movq %r13, %rsi
callq 0x24dd
movq %rsp, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x24dd
movb (%r14), %al
shlb $0x7, %al
xorb %al, 0x1f(%rbx)
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq