LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/andyfighting[P]hiredis_timer_cmpt/async.c
// Function: nextArgument
static const char *nextArgument(const char *start, const char **str, size_t *len) {
    const char *p = start;
    if (p[0] != '$') {
        p = strchr(p,'$');
        if (p == NULL) return NULL;
    }

    *len = (int)strtol(p+1,NULL,10);
    p = strchr(p,'\r');
    assert(p);
    *str = p+2;
    return p+2+(*len)+2;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
cmpb $0x24, (%rdi)
je 0x815d
movq %r15, %rdi
movl $0x24, %esi
callq 0x3170
movq %rax, %r15
testq %rax, %rax
je 0x819f
leaq 0x1(%r15), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x32e0
movslq %eax, %r12
movq %r12, (%r14)
movq %r15, %rdi
movl $0xd, %esi
callq 0x3170
testq %rax, %rax
je 0x81a3
leaq 0x2(%rax), %rcx
movq %rcx, (%rbx)
addq %r12, %rax
addq $0x4, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x8193
leaq 0x15c1(%rip), %rdi      # 0x976b
leaq 0x139c(%rip), %rsi      # 0x954d
leaq 0x15b5(%rip), %rcx      # 0x976d
movl $0x23f, %edx            # imm = 0x23F
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O1/andyfighting[P]hiredis_timer_cmpt/./dict.c
// Function: dictReplace
static int dictReplace(dict *ht, void *key, void *val) {
    dictEntry *entry, auxentry;

    /* Try to add the element. If the key
     * does not exists dictAdd will succeed. */
    if (dictAdd(ht, key, val) == DICT_OK)
        return 1;
    /* It already exists, get the entry */
    entry = dictFind(ht, key);
    /* Free the old value and set the new one */
    /* Set the new value and free the old one. Note that it is important
     * to do that in this order, as the value may just be exactly the same
     * as the previous one. In this context, think to reference counting,
     * you want to increment (set), and then decrement (free), and not the
     * reverse. */
    auxentry = *entry;
    dictSetHashVal(ht, entry, val);
    dictFreeEntryVal(ht, &auxentry);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
testq %rsi, %rsi
je 0x81ea
cmpq %rsi, 0x20(%rbx)
jne 0x8201
addq %rsi, %rsi
jmp 0x81ef
movl $0x4, %esi
movq %rbx, %rdi
callq 0x8316
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x824f
movq 0x8(%rbx), %rax
movq %r15, %rdi
callq *(%rax)
movl %eax, %r12d
andl 0x18(%rbx), %r12d
movq (%rbx), %rax
movq (%rax,%r12,8), %r13
testq %r13, %r13
je 0x824f
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x823d
movq 0x28(%rbx), %rdi
movq (%r13), %rdx
movq %r15, %rsi
callq *%rax
testl %eax, %eax
je 0x8243
jmp 0x8249
cmpq %r15, (%r13)
je 0x8249
movq 0x10(%r13), %r13
jmp 0x8218
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpl $-0x1, %r12d
je 0x82bd
movl $0x18, %edi
callq 0x3340
movq %rax, %r13
movq (%rbx), %rax
movslq %r12d, %rcx
movq (%rax,%rcx,8), %rdx
movq %rdx, 0x10(%r13)
movq %r13, (%rax,%rcx,8)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rcx
movq %r15, %rax
testq %rcx, %rcx
je 0x828d
movq 0x28(%rbx), %rdi
movq %r15, %rsi
callq *%rcx
movq %rax, (%r13)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rcx
movq %r14, %rax
testq %rcx, %rcx
je 0x82aa
movq 0x28(%rbx), %rdi
movq %r14, %rsi
callq *%rcx
movq %rax, 0x8(%r13)
incq 0x20(%rbx)
movl $0x1, %ebp
cmpl $-0x1, %r12d
jne 0x8305
movq %rbx, %rdi
movq %r15, %rsi
callq 0x80d2
movq %rax, %r12
movq 0x8(%rax), %r15
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x82e8
movq 0x28(%rbx), %rdi
movq %r14, %rsi
callq *%rax
movq %rax, %r14
movq %r14, 0x8(%r12)
movq 0x8(%rbx), %rax
movq 0x28(%rax), %rax
xorl %ebp, %ebp
testq %rax, %rax
je 0x8305
movq 0x28(%rbx), %rdi
movq %r15, %rsi
callq *%rax
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_O1/andyfighting[P]hiredis_timer_cmpt/./dict.c
// Function: dictExpand
static int dictExpand(dict *ht, unsigned long size) {
    dict n; /* the new hashtable */
    unsigned long realsize = _dictNextPower(size), i;

    /* the size is invalid if it is smaller than the number of
     * elements already inside the hashtable */
    if (ht->used > size)
        return DICT_ERR;

    _dictInit(&n, ht->type, ht->privdata);
    n.size = realsize;
    n.sizemask = realsize-1;
    n.table = calloc(realsize,sizeof(dictEntry*));

    /* Copy all the elements from the old to the new table:
     * note that if the old hash table is empty ht->size is zero,
     * so dictExpand just creates an hash table. */
    n.used = ht->used;
    for (i = 0; i < ht->size && ht->used > 0; i++) {
        dictEntry *he, *nextHe;

        if (ht->table[i] == NULL) continue;

        /* For each hash entry on this slot... */
        he = ht->table[i];
        while(he) {
            unsigned int h;

            nextHe = he->next;
            /* Get the new element index */
            h = dictHashKey(ht, he->key) & n.sizemask;
            he->next = n.table[h];
            n.table[h] = he;
            ht->used--;
            /* Pass to the next element */
            he = nextHe;
        }
    }
    assert(ht->used == 0);
    free(ht->table);

    /* Remap the new hashtable in the old */
    *ht = n;
    return DICT_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movabsq $0x7ffffffffffffffe, %r14 # imm = 0x7FFFFFFFFFFFFFFE
cmpq %r14, %rsi
jbe 0x833b
incq %r14
jmp 0x834b
movl $0x4, %eax
movq %rax, %r14
addq %rax, %rax
cmpq %rsi, %r14
jb 0x8340
movq 0x20(%rbx), %rcx
movl $0x1, %eax
cmpq %rsi, %rcx
ja 0x8419
movq %rcx, 0x18(%rsp)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq -0x1(%r14), %r13
movl $0x8, %esi
movq %r14, %rdi
callq 0x3290
movq %rax, %r15
cmpq $0x0, 0x10(%rbx)
je 0x83e2
xorl %ecx, %ecx
cmpq $0x0, 0x20(%rbx)
je 0x83e2
movq (%rbx), %rax
movq %rcx, 0x20(%rsp)
movq (%rax,%rcx,8), %r12
testq %r12, %r12
je 0x83d4
movq (%r12), %rdi
movq 0x10(%r12), %rbp
movq 0x8(%rbx), %rax
callq *(%rax)
andl %r13d, %eax
movq (%r15,%rax,8), %rcx
movq %rcx, 0x10(%r12)
movq %r12, (%r15,%rax,8)
decq 0x20(%rbx)
movq %rbp, %r12
testq %rbp, %rbp
jne 0x83a9
movq 0x20(%rsp), %rcx
incq %rcx
cmpq 0x10(%rbx), %rcx
jb 0x8391
cmpq $0x0, 0x20(%rbx)
jne 0x8428
movq (%rbx), %rdi
callq 0x3050
movq %r15, (%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq %r13, 0x18(%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rbx)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x137e(%rip), %rdi      # 0x97ad
leaq 0x1385(%rip), %rsi      # 0x97bb
leaq 0x1387(%rip), %rcx      # 0x97c4
movl $0x7e, %edx
callq 0x31b0
nop
// File: /workspace/github_c_makefile_star2_O1/andyfighting[P]hiredis_timer_cmpt/read.c
// Function: redisReaderCreateWithFunctions
redisReader *redisReaderCreateWithFunctions(redisReplyObjectFunctions *fn) {
    redisReader *r;

    r = calloc(sizeof(redisReader),1);
    if (r == NULL)
        return NULL;

    r->err = 0;
    r->errstr[0] = '\0';
    r->fn = fn;
    r->buf = sdsempty();
    r->maxbuf = REDIS_READER_MAX_BUF;
    if (r->buf == NULL) {
        free(r);
        return NULL;
    }

    r->ridx = -1;
    return r;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x230, %edi            # imm = 0x230
movl $0x1, %esi
callq 0x3290
testq %rax, %rax
je 0x84a7
movq %rax, %rbx
movl $0x0, (%rax)
movb $0x0, 0x4(%rax)
movq %r14, 0x220(%rax)
callq 0x3490
movq %rax, 0x88(%rbx)
movq $0x4000, 0xa0(%rbx) # imm = 0x4000
testq %rax, %rax
je 0x849f
movl $0xffffffff, 0x210(%rbx) # imm = 0xFFFFFFFF
jmp 0x84a9
movq %rbx, %rdi
callq 0x3050
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/andyfighting[P]hiredis_timer_cmpt/read.c
// Function: redisReaderFree
void redisReaderFree(redisReader *r) {
    if (r->reply != NULL && r->fn && r->fn->freeObject)
        r->fn->freeObject(r->reply);
    if (r->buf != NULL)
        sdsfree(r->buf);
    free(r);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x218(%rdi), %rdi
testq %rdi, %rdi
je 0x84db
movq 0x220(%rbx), %rax
testq %rax, %rax
je 0x84db
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x84db
callq *%rax
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x84ec
callq 0x3280
movq %rbx, %rdi
popq %rbx
jmp 0x3050
// File: /workspace/github_c_makefile_star2_O1/andyfighting[P]hiredis_timer_cmpt/read.c
// Function: redisReaderFeed
int redisReaderFeed(redisReader *r, const char *buf, size_t len) {
    sds newbuf;

    /* Return early when this reader is in an erroneous state. */
    if (r->err)
        return REDIS_ERR;

    /* Copy the provided buffer. */
    if (buf != NULL && len >= 1) {
        /* Destroy internal buffer when it is empty and is quite large. */
        if (r->len == 0 && r->maxbuf != 0 && sdsavail(r->buf) > r->maxbuf) {
            sdsfree(r->buf);
            r->buf = sdsempty();
            r->pos = 0;

            /* r->buf should not be NULL since we just free'd a larger one. */
            assert(r->buf != NULL);
        }

        newbuf = sdscatlen(r->buf,buf,len);
        if (newbuf == NULL) {
            __redisReaderSetErrorOOM(r);
            return REDIS_ERR;
        }

        r->buf = newbuf;
        r->len = sdslen(r->buf);
    }

    return REDIS_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x0, (%rdi)
jne 0x8555
movq %rdx, %r15
movq %rsi, %r12
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x8553
movq %rdi, %r14
cmpq $0x0, 0x98(%rdi)
je 0x8563
movq 0x88(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3420
testq %rax, %rax
je 0x85bf
movq %rax, 0x88(%r14)
movslq -0x8(%rax), %rax
movq %rax, 0x98(%r14)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xa0(%r14), %rax
testq %rax, %rax
je 0x852a
movq 0x88(%r14), %rdi
movslq -0x4(%rdi), %rcx
cmpq %rcx, %rax
jae 0x852a
callq 0x3280
callq 0x3490
movq %rax, 0x88(%r14)
movq $0x0, 0x90(%r14)
testq %rax, %rax
jne 0x852a
leaq 0x12a1(%rip), %rdi      # 0x9848
leaq 0x12a9(%rip), %rsi      # 0x9857
leaq 0x12a9(%rip), %rcx      # 0x985e
movl $0x1cd, %edx            # imm = 0x1CD
callq 0x31b0
leaq 0xcbc(%rip), %rdx       # 0x9282
movq %r14, %rdi
movl $0x5, %esi
callq 0x8ba5
jmp 0x8555
// File: /workspace/github_c_makefile_star2_O1/andyfighting[P]hiredis_timer_cmpt/read.c
// Function: _redisReaderSetError
static void __redisReaderSetError(redisReader *r, int type, const char *str) {
    size_t len;

    if (r->reply != NULL && r->fn && r->fn->freeObject) {
        r->fn->freeObject(r->reply);
        r->reply = NULL;
    }

    /* Clear input buffer on errors. */
    if (r->buf != NULL) {
        sdsfree(r->buf);
        r->buf = NULL;
        r->pos = r->len = 0;
    }

    /* Reset task stack. */
    r->ridx = -1;

    /* Set error. */
    r->err = type;
    len = strlen(str);
    len = len < (sizeof(r->errstr)-1) ? len : (sizeof(r->errstr)-1);
    memcpy(r->errstr,str,len);
    r->errstr[len] = '\0';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq 0x218(%rdi), %rdi
testq %rdi, %rdi
je 0x8be2
movq 0x220(%rbx), %rax
testq %rax, %rax
je 0x8be2
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x8be2
callq *%rax
movq $0x0, 0x218(%rbx)
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x8c09
leaq 0x88(%rbx), %r15
callq 0x3280
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movl $0xffffffff, 0x210(%rbx) # imm = 0xFFFFFFFF
movl %ebp, (%rbx)
movq %r14, %rdi
callq 0x3130
cmpq $0x7f, %rax
movl $0x7f, %r15d
cmovbq %rax, %r15
leaq 0x4(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x32f0
movb $0x0, 0x4(%rbx,%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/andyfighting[P]hiredis_timer_cmpt/read.c
// Function: readLine
static char *readLine(redisReader *r, int *_len) {
    char *p, *s;
    int len;

    p = r->buf+r->pos;
    s = seekNewline(p,(r->len-r->pos));
    if (s != NULL) {
        len = s-(r->buf+r->pos);
        r->pos += len+2; /* skip \r\n */
        if (_len) *_len = len;
        return p;
    }
    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq 0x90(%rdi), %r12
movq 0x98(%rdi), %rsi
movq 0x88(%rdi), %rbx
addq %r12, %rbx
subq %r12, %rsi
movq %rbx, %rdi
callq 0x8db7
testq %rax, %rax
je 0x8c9e
subq %rbx, %rax
leal 0x2(%rax), %ecx
movslq %ecx, %rcx
addq %r12, %rcx
movq %rcx, 0x90(%r15)
testq %r14, %r14
je 0x8ca0
movl %eax, (%r14)
jmp 0x8ca0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/andyfighting[P]hiredis_timer_cmpt/read.c
// Function: readLongLong
static long long readLongLong(char *s) {
    long long v = 0;
    int dec, mult = 1;
    char c;

    if (*s == '-') {
        mult = -1;
        s++;
    } else if (*s == '+') {
        mult = 1;
        s++;
    }

    while ((c = *(s++)) != '\r') {
        dec = c - '0';
        if (dec >= 0 && dec < 10) {
            v *= 10;
            v += dec;
        } else {
            /* Should not happen... */
            return -1;
        }
    }

    return mult*v;
}

// Assembly:
movzbl (%rdi), %eax
movl $0x1, %ecx
cmpl $0x2b, %eax
je 0x8ccd
cmpl $0x2d, %eax
jne 0x8cd0
incq %rdi
movq $-0x1, %rcx
jmp 0x8cd0
incq %rdi
movb (%rdi), %dl
cmpb $0xd, %dl
jne 0x8cdb
xorl %eax, %eax
jmp 0x8d01
incq %rdi
xorl %eax, %eax
leal -0x30(%rdx), %esi
cmpb $0x9, %sil
ja 0x8d06
leaq (%rax,%rax,4), %rax
andb $0xf, %dl
movzbl %dl, %edx
leaq (%rdx,%rax,2), %rax
movb (%rdi), %dl
incq %rdi
cmpb $0xd, %dl
jne 0x8ce0
imulq %rcx, %rax
retq
movq $-0x1, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/andyfighting[P]hiredis_timer_cmpt/read.c
// Function: moveToNextTask
static void moveToNextTask(redisReader *r) {
    redisReadTask *cur, *prv;
    while (r->ridx >= 0) {
        /* Return a.s.a.p. when the stack is now empty. */
        if (r->ridx == 0) {
            r->ridx--;
            return;
        }

        cur = &(r->rstack[r->ridx]);
        prv = &(r->rstack[r->ridx-1]);
        assert(prv->type == REDIS_REPLY_ARRAY);
        if (cur->idx == prv->elements-1) {
            r->ridx--;
        } else {
            /* Reset the type because the next item can be anything */
            assert(cur->idx < prv->elements);
            cur->type = -1;
            cur->elements = -1;
            cur->idx++;
            return;
        }
    }
}

// Assembly:
pushq %rax
movl 0x210(%rdi), %ecx
testl %ecx, %ecx
js 0x8d77
je 0x8d56
leaq 0xa8(%rdi), %rax
leal -0x1(%rcx), %edx
leaq (%rdx,%rdx,4), %rsi
cmpl $0x2, (%rax,%rsi,8)
jne 0x8d79
leaq (%rax,%rsi,8), %r8
movl %ecx, %ecx
leaq (%rcx,%rcx,4), %rsi
movl 0x8(%rax,%rsi,8), %ecx
movl 0x4(%r8), %r8d
leal -0x1(%r8), %r9d
cmpl %r9d, %ecx
jne 0x8d62
movl %edx, 0x210(%rdi)
movl %edx, %ecx
testl %edx, %edx
jne 0x8d22
movl $0xffffffff, 0x210(%rdi) # imm = 0xFFFFFFFF
jmp 0x8d77
cmpl %r8d, %ecx
jge 0x8d98
leaq (%rax,%rsi,8), %rax
movq $-0x1, (%rax)
incl %ecx
movl %ecx, 0x8(%rax)
popq %rax
retq
leaq 0xb8d(%rip), %rdi       # 0x990d
leaq 0xad0(%rip), %rsi       # 0x9857
leaq 0xb9e(%rip), %rcx       # 0x992c
movl $0xc9, %edx
callq 0x31b0
leaq 0xbb0(%rip), %rdi       # 0x994f
leaq 0xab1(%rip), %rsi       # 0x9857
leaq 0xb7f(%rip), %rcx       # 0x992c
movl $0xce, %edx
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O1/andyfighting[P]hiredis_timer_cmpt/read.c
// Function: seekNewline
static char *seekNewline(char *s, size_t len) {
    int pos = 0;
    int _len = len-1;

    /* Position should be < len-1 because the character at "pos" should be
     * followed by a \n. Note that strchr cannot be used because it doesn't
     * allow to search a limited length and the buffer that is being searched
     * might not have a trailing NULL character. */
    while (pos < _len) {
        while(pos < _len && s[pos] != '\r') pos++;
        if (s[pos] != '\r') {
            /* Not found. */
            return NULL;
        } else {
            if (s[pos+1] == '\n') {
                /* Found. */
                return s+pos;
            } else {
                /* Continue searching. */
                pos++;
            }
        }
    }
    return NULL;
}

// Assembly:
decl %esi
movslq %esi, %rcx
xorl %eax, %eax
xorl %edx, %edx
cmpl %esi, %edx
jge 0x8e06
movslq %edx, %r9
leaq (%rdi,%r9), %r8
movq %rcx, %r10
subq %r9, %r10
xorl %r9d, %r9d
cmpb $0xd, (%r8,%r9)
je 0x8de7
incq %r9
cmpq %r9, %r10
jne 0x8dd4
movl %esi, %edx
jmp 0x8dea
addl %r9d, %edx
movslq %edx, %r8
cmpb $0xd, (%rdi,%r8)
jne 0x8e06
leaq 0x1(%r8), %rdx
cmpb $0xa, 0x1(%rdi,%r8)
jne 0x8dc0
addq %r8, %rdi
movq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/scream10v3/sse/scream.c
// Function: tweak_expand
void tweak_expand(v16qi T[16], v16qi K[16], v16qi T3[48]) {
  int i;

  for (i = 0; i<16; i++)
    T3[i] = T[i];

  for (i = 0; i<8; i++) {
    T3[16+key_idx(i)]   = T[key_idx(i)] ^ T[key_idx(i+8)];
    T3[16+key_idx(i+8)] = T[key_idx(i)];
    T3[32+key_idx(i)]   = T[key_idx(i+8)];
    T3[32+key_idx(i+8)] = T[key_idx(i)] ^ T[key_idx(i+8)];
  }

  for (i = 0; i<48; i++)
    T3[i] ^= K[i%16];
}

// Assembly:
xorl %eax, %eax
vmovaps (%rdi,%rax), %xmm0
vmovaps %xmm0, (%rdx,%rax)
addq $0x10, %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x2210
pushq %r15
pushq %r14
pushq %rbx
xorl %eax, %eax
xorl %ecx, %ecx
movl %ecx, %r8d
shrl %r8d
movl %eax, %r9d
andl $0x8, %r9d
leal (%r9,%r8), %r10d
addl $0x4, %r10d
leal 0x10(%r9,%r8), %r11d
leal (%r9,%r8), %ebx
addl $0x14, %ebx
leal (%r9,%r8), %r14d
addl $0x20, %r14d
movl %r9d, %r15d
orl %r8d, %r15d
shlq $0x4, %r15
shlq $0x4, %r10
vmovaps (%rdi,%r10), %xmm0
vxorps (%rdi,%r15), %xmm0, %xmm0
addl %r9d, %r8d
addl $0x24, %r8d
shlq $0x4, %r11
vmovaps %xmm0, (%rdx,%r11)
vmovaps (%rdi,%r15), %xmm0
shlq $0x4, %rbx
vmovaps %xmm0, (%rdx,%rbx)
vmovaps (%rdi,%r10), %xmm0
shlq $0x4, %r14
vmovaps %xmm0, (%rdx,%r14)
vmovaps (%rdi,%r10), %xmm0
vxorps (%rdi,%r15), %xmm0, %xmm0
shlq $0x4, %r8
vmovaps %xmm0, (%rdx,%r8)
incl %ecx
addl $0x8, %eax
cmpl $0x8, %ecx
jne 0x222f
xorl %eax, %eax
movl %eax, %ecx
andl $0xf, %ecx
shll $0x4, %ecx
vmovaps (%rdx), %xmm0
vxorps (%rsi,%rcx), %xmm0, %xmm0
vmovaps %xmm0, (%rdx)
incq %rax
addq $0x10, %rdx
cmpq $0x30, %rax
jne 0x22c8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/scream10v3/sse/scream.c
// Function: tweakey_schedule
void tweakey_schedule(const uint8_t *restrict k,
		      const uint8_t *restrict n,
		      uint8_t ctrl,
		      v16qi *restrict TK) {
  v16qi *K = &TK[3*16];
  v16qi *T = &TK[4*16];
  v16qi C= {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
  int j;

  for (j=0; j<16; j++) {
    K[key_idx(j)] = (v16qi) CV(k[j]);
  }
  for (j=0; j<11; j++) {
    T[key_idx(j)] = (v16qi) CV(n[j]);
  }

  T[key_idx(15)] = (v16qi) CV(ctrl);
  T[key_idx(14)] = C;
  T[key_idx(13)] = (v16qi) CV(0);
  T[key_idx(12)] = (v16qi) CV(0);
  T[key_idx(11)] = (v16qi) CV(0);

  tweak_expand(T, K, TK);
}

// Assembly:
movq %rsi, %rax
leaq 0x300(%rcx), %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
vpbroadcastb (%rdi,%r9), %xmm0
movl %r9d, %r10d
shrl %r10d
movl %r8d, %r11d
andl $0x8, %r11d
orl %r10d, %r11d
shlq $0x4, %r11
vmovdqa %xmm0, (%rsi,%r11)
incq %r9
addl $0x8, %r8d
cmpq $0x10, %r9
jne 0x2300
leaq 0x400(%rcx), %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
vpbroadcastb (%rax,%r9), %xmm0
movl %r9d, %r10d
shrl %r10d
movl %r8d, %r11d
andl $0x8, %r11d
orl %r10d, %r11d
shlq $0x4, %r11
vmovdqa %xmm0, (%rdi,%r11)
incq %r9
addl $0x8, %r8d
cmpq $0xb, %r9
jne 0x233a
vpbroadcastb %edx, %xmm0
vmovdqa %xmm0, 0x4f0(%rcx)
vmovaps 0x2193(%rip), %xmm0     # 0x4510
vmovaps %xmm0, 0x470(%rcx)
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, 0x460(%rcx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x4d0(%rcx)
movq %rcx, %rdx
vzeroupper
jmp 0x10c0
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/scream10v3/sse/scream.c
// Function: tweakey_increment
void tweakey_increment(v16qi *TK, size_t idx) {
  v16qi *K = &TK[3*16];
  v16qi *T = &TK[4*16];

  T[key_idx(14)] += V(16);
  UPDATE(14);
  if (((idx+256) & 0xfff) == 0) {
    T[key_idx(13)] += V(1);
    UPDATE(13);
    if (((idx+256) & 0xfffff) == 0) {
      T[key_idx(12)] += V(1);
      UPDATE(12);
      if (((idx+256) & 0xfffffff) == 0) {
	T[key_idx(11)] += V(1);
	UPDATE(11);
      }
    }
  }
}

// Assembly:
vpbroadcastb 0x1c51(%rip), %xmm0 # 0x4002
vpaddb 0x470(%rdi), %xmm0, %xmm0
vmovdqa %xmm0, 0x470(%rdi)
vpxor 0x370(%rdi), %xmm0, %xmm1
vmovdqa %xmm1, 0x70(%rdi)
vmovdqa 0x330(%rdi), %xmm2
vmovdqa 0x430(%rdi), %xmm3
vpxor %xmm0, %xmm2, %xmm4
vpternlogq $0x96, %xmm0, %xmm3, %xmm2
vmovdqa %xmm2, 0x130(%rdi)
vmovdqa %xmm4, 0x230(%rdi)
vpxor %xmm3, %xmm1, %xmm0
vmovdqa %xmm0, 0x270(%rdi)
addq $0x100, %rsi            # imm = 0x100
testl $0xfff, %esi            # imm = 0xFFF
je 0x2415
retq
vmovdqa 0x3a0(%rdi), %xmm1
vmovdqa 0x4a0(%rdi), %xmm2
vmovdqa 0x4e0(%rdi), %xmm3
vpcmpeqd %xmm0, %xmm0, %xmm0
vpsubb %xmm0, %xmm3, %xmm3
vmovdqa %xmm3, 0x4e0(%rdi)
vpxor 0x3e0(%rdi), %xmm3, %xmm4
vmovdqa %xmm4, 0xe0(%rdi)
vpxor %xmm3, %xmm1, %xmm5
vpternlogq $0x96, %xmm3, %xmm2, %xmm1
vmovdqa %xmm1, 0x1a0(%rdi)
vmovdqa %xmm5, 0x2a0(%rdi)
vpxor %xmm2, %xmm4, %xmm1
vmovdqa %xmm1, 0x2e0(%rdi)
testl $0xff000, %esi          # imm = 0xFF000
jne 0x2414
vmovdqa 0x320(%rdi), %xmm1
vmovdqa 0x420(%rdi), %xmm2
vmovdqa 0x460(%rdi), %xmm3
vpsubb %xmm0, %xmm3, %xmm0
vmovdqa %xmm0, 0x460(%rdi)
vpxor 0x360(%rdi), %xmm0, %xmm3
vmovdqa %xmm3, 0x60(%rdi)
vpxor %xmm0, %xmm1, %xmm4
vpternlogq $0x96, %xmm0, %xmm2, %xmm1
vmovdqa %xmm1, 0x120(%rdi)
vmovdqa %xmm4, 0x220(%rdi)
vpxor %xmm2, %xmm3, %xmm0
vmovdqa %xmm0, 0x260(%rdi)
testl $0xff00000, %esi        # imm = 0xFF00000
jne 0x2414
vmovdqa 0x390(%rdi), %xmm0
vmovdqa 0x490(%rdi), %xmm1
vmovdqa 0x4d0(%rdi), %xmm2
vpcmpeqd %xmm3, %xmm3, %xmm3
vpsubb %xmm3, %xmm2, %xmm2
vmovdqa %xmm2, 0x4d0(%rdi)
vpxor 0x3d0(%rdi), %xmm2, %xmm3
vmovdqa %xmm3, 0xd0(%rdi)
vmovdqa %xmm0, %xmm4
vpternlogq $0x96, %xmm2, %xmm1, %xmm4
vmovdqa %xmm4, 0x190(%rdi)
vpxor %xmm2, %xmm0, %xmm0
vmovdqa %xmm0, 0x290(%rdi)
vpxor %xmm1, %xmm3, %xmm0
vmovdqa %xmm0, 0x2d0(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-1600-inplace32BI.c
// Function: KeccakP1600_SetBytesInLaneToZero
void KeccakP1600_SetBytesInLaneToZero(void *state, unsigned int lanePosition, unsigned int offset, unsigned int length)
{
    UINT8 laneAsBytes[8];
    UINT32 low, high;
    UINT32 temp, temp0, temp1;
    UINT32 *stateAsHalfLanes = (UINT32*)state;

    memset(laneAsBytes, 0xFF, offset);
    memset(laneAsBytes+offset, 0x00, length);
    memset(laneAsBytes+offset+length, 0xFF, 8-offset-length);
#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
    low = *((UINT32*)(laneAsBytes+0));
    high = *((UINT32*)(laneAsBytes+4));
#else
    low = laneAsBytes[0]
        | ((UINT32)(laneAsBytes[1]) << 8)
        | ((UINT32)(laneAsBytes[2]) << 16)
        | ((UINT32)(laneAsBytes[3]) << 24);
    high = laneAsBytes[4]
        | ((UINT32)(laneAsBytes[5]) << 8)
        | ((UINT32)(laneAsBytes[6]) << 16)
        | ((UINT32)(laneAsBytes[7]) << 24);
#endif
    toBitInterleavingAndAND(low, high, stateAsHalfLanes[lanePosition*2+0], stateAsHalfLanes[lanePosition*2+1], temp, temp0, temp1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movl %edx, %r12d
movl %esi, %ebx
movq %rdi, 0x8(%rsp)
movl %edx, %r13d
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movl $0xff, %esi
movq %r13, %rdx
callq 0x5080
addq %rsp, %r13
addq $0x10, %r13
movl %ebp, %r14d
movq %r13, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x5080
addq %r14, %r13
addl %ebp, %r12d
movl $0x8, %edx
subl %r12d, %edx
movq %r13, %rdi
movl $0xff, %esi
callq 0x5080
movl (%r15), %eax
movl 0x4(%r15), %ecx
movl %eax, %esi
shrl %esi
xorl %eax, %esi
movl $0x22222222, %edx       # imm = 0x22222222
andl %edx, %esi
leal (%rsi,%rsi,2), %edi
xorl %eax, %edi
movl %edi, %eax
shrl $0x2, %eax
xorl %edi, %eax
movl $0xc0c0c0c, %esi        # imm = 0xC0C0C0C
andl %esi, %eax
leal (%rax,%rax,4), %eax
xorl %edi, %eax
movl %eax, %r8d
shrl $0x4, %r8d
xorl %eax, %r8d
movl $0xf000f0, %edi         # imm = 0xF000F0
andl %edi, %r8d
movl %r8d, %r9d
shll $0x4, %r9d
orl %r8d, %r9d
xorl %eax, %r9d
movl %r9d, %r10d
shrl $0x8, %r10d
xorl %r9d, %r10d
movl $0xff00, %r8d           # imm = 0xFF00
andl %r8d, %r10d
movl %r10d, %eax
shll $0x8, %eax
orl %r10d, %eax
xorl %r9d, %eax
movl %ecx, %r9d
shrl %r9d
xorl %ecx, %r9d
andl %edx, %r9d
leal (%r9,%r9,2), %edx
xorl %ecx, %edx
movl %edx, %ecx
shrl $0x2, %ecx
xorl %edx, %ecx
andl %esi, %ecx
leal (%rcx,%rcx,4), %ecx
xorl %edx, %ecx
movl %ecx, %edx
shrl $0x4, %edx
xorl %ecx, %edx
andl %edi, %edx
movl %edx, %esi
shll $0x4, %esi
orl %edx, %esi
xorl %ecx, %esi
movl %esi, %ecx
shrl $0x8, %ecx
xorl %esi, %ecx
andl %r8d, %ecx
movl %ecx, %edx
shll $0x8, %edx
orl %ecx, %edx
xorl %esi, %edx
movzwl %ax, %ecx
movl %edx, %esi
shll $0x10, %esi
orl %ecx, %esi
addl %ebx, %ebx
movq 0x8(%rsp), %rcx
andl %esi, (%rcx,%rbx,4)
shrl $0x10, %eax
andl $0xffff0000, %edx       # imm = 0xFFFF0000
orl %eax, %edx
andl %edx, 0x4(%rcx,%rbx,4)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-1600-inplace32BI.c
// Function: KeccakP1600_AddBytesInLane
void KeccakP1600_AddBytesInLane(void *state, unsigned int lanePosition, const unsigned char *data, unsigned int offset, unsigned int length)
{
    UINT8 laneAsBytes[8];
    UINT32 low, high;
    UINT32 temp, temp0, temp1;
    UINT32 *stateAsHalfLanes = (UINT32*)state;

    memset(laneAsBytes, 0, 8);
    memcpy(laneAsBytes+offset, data, length);
#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
    low = *((UINT32*)(laneAsBytes+0));
    high = *((UINT32*)(laneAsBytes+4));
#else
    low = laneAsBytes[0]
        | ((UINT32)(laneAsBytes[1]) << 8)
        | ((UINT32)(laneAsBytes[2]) << 16)
        | ((UINT32)(laneAsBytes[3]) << 24);
    high = laneAsBytes[4]
        | ((UINT32)(laneAsBytes[5]) << 8)
        | ((UINT32)(laneAsBytes[6]) << 16)
        | ((UINT32)(laneAsBytes[7]) << 24);
#endif
    toBitInterleavingAndXOR(low, high, stateAsHalfLanes[lanePosition*2+0], stateAsHalfLanes[lanePosition*2+1], temp, temp0, temp1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq $0x0, (%rsp)
movl %ecx, %eax
leaq (%rsp,%rax), %rdi
movl %r8d, %eax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x56c0
movl (%rsp), %eax
movl 0x4(%rsp), %ecx
movl %eax, %esi
shrl %esi
xorl %eax, %esi
movl $0x22222222, %edx       # imm = 0x22222222
andl %edx, %esi
leal (%rsi,%rsi,2), %edi
xorl %eax, %edi
movl %edi, %eax
shrl $0x2, %eax
xorl %edi, %eax
movl $0xc0c0c0c, %esi        # imm = 0xC0C0C0C
andl %esi, %eax
leal (%rax,%rax,4), %eax
xorl %edi, %eax
movl %eax, %r8d
shrl $0x4, %r8d
xorl %eax, %r8d
movl $0xf000f0, %edi         # imm = 0xF000F0
andl %edi, %r8d
movl %r8d, %r9d
shll $0x4, %r9d
orl %r8d, %r9d
xorl %eax, %r9d
movl %r9d, %r10d
shrl $0x8, %r10d
xorl %r9d, %r10d
movl $0xff00, %r8d           # imm = 0xFF00
andl %r8d, %r10d
movl %r10d, %eax
shll $0x8, %eax
orl %r10d, %eax
xorl %r9d, %eax
movl %ecx, %r9d
shrl %r9d
xorl %ecx, %r9d
andl %edx, %r9d
leal (%r9,%r9,2), %edx
xorl %ecx, %edx
movl %edx, %ecx
shrl $0x2, %ecx
xorl %edx, %ecx
andl %esi, %ecx
leal (%rcx,%rcx,4), %ecx
xorl %edx, %ecx
movl %ecx, %edx
shrl $0x4, %edx
xorl %ecx, %edx
andl %edi, %edx
movl %edx, %esi
shll $0x4, %esi
orl %edx, %esi
xorl %ecx, %esi
movl %esi, %ecx
shrl $0x8, %ecx
xorl %esi, %ecx
andl %r8d, %ecx
movl %ecx, %edx
shll $0x8, %edx
orl %ecx, %edx
xorl %esi, %edx
movzwl %ax, %ecx
movl %edx, %esi
shll $0x10, %esi
orl %ecx, %esi
addl %ebx, %ebx
xorl %esi, (%r14,%rbx,4)
shrl $0x10, %eax
andl $0xffff0000, %edx       # imm = 0xFFFF0000
orl %eax, %edx
xorl %edx, 0x4(%r14,%rbx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-1600-inplace32BI.c
// Function: KeccakP1600_OverwriteWithZeroes
void KeccakP1600_OverwriteWithZeroes(void *state, unsigned int byteCount)
{
    UINT32 *stateAsHalfLanes = (UINT32*)state;
    unsigned int i;

    for(i=0; i<byteCount/8; i++) {
        stateAsHalfLanes[i*2+0] = 0;
        stateAsHalfLanes[i*2+1] = 0;
    }
    if (byteCount%8 != 0)
        KeccakP1600_SetBytesInLaneToZero(state, byteCount/8, 0, byteCount%8);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %r15d
shrl $0x3, %r15d
cmpl $0x8, %esi
jb 0x5f48
leal -0x1(%r15), %eax
leaq 0x8(,%rax,8), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x5080
andl $0x7, %ebx
je 0x5f61
movq %r14, %rdi
movl %r15d, %esi
xorl %edx, %edx
movl %ebx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x50f0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-1600-inplace32BI.c
// Function: KeccakP1600_ExtractAndAddBytesInLane
void KeccakP1600_ExtractAndAddBytesInLane(const void *state, unsigned int lanePosition, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
{
    UINT32 *stateAsHalfLanes = (UINT32*)state;
    UINT32 low, high, temp, temp0, temp1;
    UINT8 laneAsBytes[8];
    unsigned int i;

    fromBitInterleaving(stateAsHalfLanes[lanePosition*2], stateAsHalfLanes[lanePosition*2+1], low, high, temp, temp0, temp1);
#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
    *((UINT32*)(laneAsBytes+0)) = low;
    *((UINT32*)(laneAsBytes+4)) = high;
#else
    laneAsBytes[0] = low & 0xFF;
    laneAsBytes[1] = (low >> 8) & 0xFF;
    laneAsBytes[2] = (low >> 16) & 0xFF;
    laneAsBytes[3] = (low >> 24) & 0xFF;
    laneAsBytes[4] = high & 0xFF;
    laneAsBytes[5] = (high >> 8) & 0xFF;
    laneAsBytes[6] = (high >> 16) & 0xFF;
    laneAsBytes[7] = (high >> 24) & 0xFF;
#endif
    for(i=0; i<length; i++)
        output[i] = input[i] ^ laneAsBytes[offset+i];
}

// Assembly:
addl %esi, %esi
movq (%rdi,%rsi,4), %rax
vmovq %rax, %xmm0
movq %rax, %rsi
shrq $0x20, %rsi
shll $0x10, %esi
vpxor %xmm1, %xmm1, %xmm1
vpsllq $0x20, %xmm0, %xmm2
vpinsrd $0x0, %esi, %xmm2, %xmm2
vpsrlvd 0xbe1c(%rip), %xmm2, %xmm3 # 0x12000
vpsrlvd 0xbe23(%rip), %xmm2, %xmm2 # 0x12010
vpblendw $0x9, %xmm0, %xmm1, %xmm1 # xmm1 = xmm0[0],xmm1[1,2],xmm0[3],xmm1[4,5,6,7]
shrq $0x28, %rax
vpinsrd $0x1, %eax, %xmm0, %xmm0
vpternlogd $0x28, 0xbe18(%rip), %xmm3, %xmm0 # 0x12020
vpslld $0x8, %xmm0, %xmm3
vpternlogd $0x1e, %xmm1, %xmm2, %xmm3
vpxor %xmm0, %xmm3, %xmm0
vpsrld $0x4, %xmm0, %xmm1
vpternlogd $0x28, 0xbe18(%rip){1to4}, %xmm3, %xmm1 # 0x12040
vpslld $0x4, %xmm1, %xmm2
vpternlogd $0x36, %xmm1, %xmm0, %xmm2
vpsrld $0x2, %xmm2, %xmm0
vpternlogd $0x28, 0xbe00(%rip){1to4}, %xmm2, %xmm0 # 0x12044
vpslld $0x2, %xmm0, %xmm1
vpternlogd $0x36, %xmm0, %xmm2, %xmm1
vpsrld $0x1, %xmm1, %xmm0
vpternlogd $0x28, 0xbde8(%rip){1to4}, %xmm1, %xmm0 # 0x12048
vpaddd %xmm0, %xmm0, %xmm2
vpaddd %xmm2, %xmm0, %xmm0
vpxor %xmm1, %xmm0, %xmm0
vmovq %xmm0, -0x8(%rsp)
testl %r9d, %r9d
je 0x6298
movl %r9d, %eax
movl %r8d, %esi
xorl %edi, %edi
leal (%rsi,%rdi), %r8d
movb -0x8(%rsp,%r8), %r8b
xorb (%rdx,%rdi), %r8b
movb %r8b, (%rcx,%rdi)
incq %rdi
cmpq %rdi, %rax
jne 0x627f
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-200-reference.c
// Function: KeccakP200_AddBytes
void KeccakP200_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
{
    unsigned int i;

    assert(offset < 25);
    assert(offset+length <= 25);
    for(i=0; i<length; i++)
        ((unsigned char *)state)[offset+i] ^= data[i];
}

// Assembly:
pushq %rax
cmpl $0x19, %edx
jae 0x8da4
leal (%rcx,%rdx), %eax
cmpl $0x19, %eax
ja 0x8dc3
testl %ecx, %ecx
je 0x8da2
movl %ecx, %eax
movl %edx, %ecx
xorl %edx, %edx
movb (%rsi,%rdx), %r8b
leal (%rcx,%rdx), %r9d
xorb %r8b, (%rdi,%r9)
incq %rdx
cmpq %rdx, %rax
jne 0x8d8e
popq %rax
retq
leaq 0x95e9(%rip), %rdi      # 0x12394
leaq 0x95ee(%rip), %rsi      # 0x123a0
leaq 0x965e(%rip), %rcx      # 0x12417
movl $0x94, %edx
callq 0x51b0
leaq 0x96a1(%rip), %rdi      # 0x1246b
leaq 0x95cf(%rip), %rsi      # 0x123a0
leaq 0x963f(%rip), %rcx      # 0x12417
movl $0x95, %edx
callq 0x51b0
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-200-reference.c
// Function: KeccakP200_ExtractAndAddBytes
void KeccakP200_ExtractAndAddBytes(const void *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
{
    unsigned int i;

    assert(offset < 25);
    assert(offset+length <= 25);
    for(i=0; i<length; i++)
        output[i] = input[i] ^ ((unsigned char *)state)[offset+i];
}

// Assembly:
pushq %rax
cmpl $0x19, %ecx
jae 0x91d9
leal (%r8,%rcx), %eax
cmpl $0x19, %eax
ja 0x91f8
testl %r8d, %r8d
je 0x91d7
movl %r8d, %eax
movl %ecx, %ecx
xorl %r8d, %r8d
leal (%rcx,%r8), %r9d
movb (%rdi,%r9), %r9b
xorb (%rsi,%r8), %r9b
movb %r9b, (%rdx,%r8)
incq %r8
cmpq %r8, %rax
jne 0x91bf
popq %rax
retq
leaq 0x91b4(%rip), %rdi      # 0x12394
leaq 0x91b9(%rip), %rsi      # 0x123a0
leaq 0x938d(%rip), %rcx      # 0x1257b
movl $0x168, %edx            # imm = 0x168
callq 0x51b0
leaq 0x926c(%rip), %rdi      # 0x1246b
leaq 0x919a(%rip), %rsi      # 0x123a0
leaq 0x936e(%rip), %rcx      # 0x1257b
movl $0x169, %edx            # imm = 0x169
callq 0x51b0
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-200-reference.c
// Function: KeccakP200_DisplayRoundConstants
void KeccakP200_DisplayRoundConstants(FILE *f)
{
    unsigned int i;

    for(i=0; i<maxNrRounds; i++) {
        fprintf(f, "RC[%02i][0][0] = ", i);
        fprintf(f, "%02X", (unsigned int)(KeccakRoundConstants[i]));
        fprintf(f, "\n");
    }
    fprintf(f, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x93c6(%rip), %r14      # 0x125f0
leaq 0x93ef(%rip), %r13      # 0x12620
leaq 0x93ca(%rip), %r15      # 0x12602
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x56a0
movzbl (%r12,%r13), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x56a0
movl $0xa, %edi
movq %rbx, %rsi
callq 0x5370
incq %r12
cmpq $0x12, %r12
jne 0x923b
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5370
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-200-reference.c
// Function: KeccakP200_DisplayRhoOffsets
void KeccakP200_DisplayRhoOffsets(FILE *f)
{
    unsigned int x, y;

    for(y=0; y<5; y++) for(x=0; x<5; x++) {
        fprintf(f, "RhoOffset[%i][%i] = ", x, y);
        fprintf(f, "%2i", KeccakRhoOffsets[index(x, y)]);
        fprintf(f, "\n");
    }
    fprintf(f, "\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x93a2(%rip), %rbp      # 0x12640
leaq 0x9362(%rip), %r14      # 0x12607
leaq 0x9370(%rip), %r15      # 0x1261c
xorl %r12d, %r12d
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r14, %rsi
movl %r13d, %edx
movl %r12d, %ecx
xorl %eax, %eax
callq 0x56a0
movl (%rbp,%r13,4), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x56a0
movl $0xa, %edi
movq %rbx, %rsi
callq 0x5370
incq %r13
cmpq $0x5, %r13
jne 0x92b2
incq %r12
addq $0x14, %rbp
cmpq $0x5, %r12
jne 0x92af
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5370
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-400-reference.c
// Function: KeccakP400_AddBytes
void KeccakP400_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
{
    unsigned int i;

    assert(offset < 50);
    assert(offset+length <= 50);
    for(i=0; i<length; i++)
        ((unsigned char *)state)[offset+i] ^= data[i];
}

// Assembly:
pushq %rax
cmpl $0x32, %edx
jae 0x9383
leal (%rcx,%rdx), %eax
cmpl $0x32, %eax
ja 0x93a2
testl %ecx, %ecx
je 0x9381
movl %ecx, %eax
movl %edx, %ecx
xorl %edx, %edx
movb (%rsi,%rdx), %r8b
leal (%rcx,%rdx), %r9d
xorb %r8b, (%rdi,%r9)
incq %rdx
cmpq %rdx, %rax
jne 0x936d
popq %rax
retq
leaq 0x931a(%rip), %rdi      # 0x126a4
leaq 0x931f(%rip), %rsi      # 0x126b0
leaq 0x938f(%rip), %rcx      # 0x12727
movl $0x96, %edx
callq 0x51b0
leaq 0x93d2(%rip), %rdi      # 0x1277b
leaq 0x9300(%rip), %rsi      # 0x126b0
leaq 0x9370(%rip), %rcx      # 0x12727
movl $0x97, %edx
callq 0x51b0
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-400-reference.c
// Function: KeccakP400_ExtractAndAddBytes
void KeccakP400_ExtractAndAddBytes(const void *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
{
    unsigned int i;

    assert(offset < 50);
    assert(offset+length <= 50);
    for(i=0; i<length; i++)
        output[i] = input[i] ^ ((unsigned char *)state)[offset+i];
}

// Assembly:
pushq %rax
cmpl $0x32, %ecx
jae 0x97dd
leal (%r8,%rcx), %eax
cmpl $0x32, %eax
ja 0x97fc
testl %r8d, %r8d
je 0x97db
movl %r8d, %eax
movl %ecx, %ecx
xorl %r8d, %r8d
leal (%rcx,%r8), %r9d
movb (%rdi,%r9), %r9b
xorb (%rsi,%r8), %r9b
movb %r9b, (%rdx,%r8)
incq %r8
cmpq %r8, %rax
jne 0x97c3
popq %rax
retq
leaq 0x8ec0(%rip), %rdi      # 0x126a4
leaq 0x8ec5(%rip), %rsi      # 0x126b0
leaq 0x9099(%rip), %rcx      # 0x1288b
movl $0x16a, %edx            # imm = 0x16A
callq 0x51b0
leaq 0x8f78(%rip), %rdi      # 0x1277b
leaq 0x8ea6(%rip), %rsi      # 0x126b0
leaq 0x907a(%rip), %rcx      # 0x1288b
movl $0x16b, %edx            # imm = 0x16B
callq 0x51b0
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-400-reference.c
// Function: KeccakP400_DisplayRoundConstants
void KeccakP400_DisplayRoundConstants(FILE *f)
{
    unsigned int i;

    for(i=0; i<maxNrRounds; i++) {
        fprintf(f, "RC[%02i][0][0] = ", i);
        fprintf(f, "%04X", (unsigned int)(KeccakRoundConstants[i]));
        fprintf(f, "\n");
    }
    fprintf(f, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x90e2(%rip), %r13      # 0x12910
leaq 0x8dbb(%rip), %r14      # 0x125f0
leaq 0x90c4(%rip), %r15      # 0x12900
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x56a0
movzwl (%r13), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x56a0
movl $0xa, %edi
movq %rbx, %rsi
callq 0x5370
incq %r12
addq $0x2, %r13
cmpq $0x14, %r12
jne 0x983f
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5370
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-800-opt32.c
// Function: KeccakP800_AddBytes
void KeccakP800_AddBytes(void *argState, const unsigned char *data, unsigned int offset, unsigned int length)
{
#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
    unsigned int sizeLeft = length;
    unsigned int lanePosition = offset/4;
    unsigned int offsetInLane = offset%4;
    const unsigned char *curData = data;
    UINT32 *state = (UINT32*)argState;

    state += lanePosition;
    if ((sizeLeft > 0) && (offsetInLane != 0)) {
        unsigned int bytesInLane = 4 - offsetInLane;
        UINT32 lane = 0;
        if (bytesInLane > sizeLeft)
            bytesInLane = sizeLeft;
        memcpy((unsigned char*)&lane + offsetInLane, curData, bytesInLane);
        *state++ ^= lane;
        sizeLeft -= bytesInLane;
        curData += bytesInLane;
    }

    while(sizeLeft >= 4) {
        *state++ ^= READ32_UNALIGNED( curData );
        sizeLeft -= 4;
        curData += 4;
    }

    if (sizeLeft > 0) {
        UINT32 lane = 0;
        memcpy(&lane, curData, sizeLeft);
        *state ^= lane;
    }
#else
#error "Not yet implemented"
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rsi, %rbx
movl %edx, %r15d
andl $-0x4, %r15d
addq %rdi, %r15
testl %ecx, %ecx
sete %al
andl $0x3, %edx
sete %cl
orb %al, %cl
jne 0x99ad
movl $0x4, %r14d
subl %edx, %r14d
movl $0x0, (%rsp)
cmpl %ebp, %r14d
cmovael %ebp, %r14d
movl %edx, %eax
leaq (%rsp,%rax), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x56c0
movl (%rsp), %eax
xorl %eax, (%r15)
addq $0x4, %r15
subl %r14d, %ebp
addq %r14, %rbx
cmpl $0x4, %ebp
jb 0x99c7
movl (%rbx), %eax
xorl %eax, (%r15)
addq $0x4, %r15
addl $-0x4, %ebp
addq $0x4, %rbx
cmpl $0x3, %ebp
ja 0x99b2
testl %ebp, %ebp
je 0x99ea
leaq 0x4(%rsp), %r14
movl $0x0, (%r14)
movl %ebp, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x56c0
movl (%r14), %eax
xorl %eax, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-800-opt32.c
// Function: KeccakF800_FastLoop_Absorb
size_t KeccakF800_FastLoop_Absorb(void *state, unsigned int laneCount, const unsigned char *data, size_t dataByteLen)
{
    size_t originalDataByteLen = dataByteLen;
    unsigned int laneCountInBytes = laneCount*4;

    while(dataByteLen >= laneCountInBytes) {
#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
        UINT32 * pState  = (UINT32*)state;
        unsigned int lc;

        for ( lc = laneCount; lc >= 4; lc -= 4 ) {
            *pState++ ^= READ32_UNALIGNED( data );
            data += 4;
            *pState++ ^= READ32_UNALIGNED( data );
            data += 4;
            *pState++ ^= READ32_UNALIGNED( data );
            data += 4;
            *pState++ ^= READ32_UNALIGNED( data );
            data += 4;
        }
        while ( lc-- != 0 ) {
            *pState++ ^= READ32_UNALIGNED( data );
            data += 4;
        }
#else
        KeccakP800_AddBytes(state, data, 0, laneCountInBytes);
        data += laneCountInBytes;
#endif
        KeccakP800_Permute_22rounds( state );
        dataByteLen -= laneCountInBytes;
    }
    return originalDataByteLen - dataByteLen;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %esi, %r15d
leal (,%r15,4), %r13d
movq %rcx, %rbp
cmpq %rcx, %r13
ja 0xaa16
movq %rdx, %r14
movq %rdi, %r12
movq %rbx, %rbp
movq %r12, %rax
movl %r15d, %ecx
cmpl $0x4, %r15d
jb 0xa9e7
movl (%r14), %edx
xorl %edx, (%rax)
movl 0x4(%r14), %edx
xorl %edx, 0x4(%rax)
movl 0x8(%r14), %edx
xorl %edx, 0x8(%rax)
movl 0xc(%r14), %edx
xorl %edx, 0xc(%rax)
addq $0x10, %rax
addq $0x10, %r14
addl $-0x4, %ecx
cmpl $0x3, %ecx
ja 0xa9bd
testl %ecx, %ecx
je 0xaa06
movl %ecx, %ecx
xorl %edx, %edx
xorl %esi, %esi
movl (%r14,%rsi,4), %edi
xorl %edi, (%rax,%rsi,4)
incq %rsi
addq $-0x4, %rdx
cmpl %esi, %ecx
jne 0xa9f1
subq %rdx, %r14
movq %r12, %rdi
callq 0x5190
subq %r13, %rbp
cmpq %r13, %rbp
jae 0xa9b1
subq %rbp, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
    unsigned char *c,unsigned long long *clen,
    const unsigned char *m,unsigned long long mlen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *nsec,
    const unsigned char *npub,
    const unsigned char *k
    )
{
    LakeKeyak_Instance instance;

    LakeKeyak_Initialize( &instance, k, 16, npub, 150, 0, 0, 0, 0 );
    LakeKeyak_Wrap( &instance, m, c, (size_t)mlen, ad, (size_t)adlen, c+mlen, 0, 0 );
    *clen = mlen + 16;
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, 0x10(%rsp)
movq %rdi, %rbp
movq 0x140(%rsp), %rsi
movq 0x138(%rsp), %rcx
subq $0x8, %rsp
xorl %r15d, %r15d
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x10, %edx
movl $0x96, %r8d
xorl %r9d, %r9d
pushq %r15
pushq %r15
pushq $0x0
callq 0x5390
addq $0x20, %rsp
leaq (%rbx,%rbp), %rax
subq $0x8, %rsp
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
movq %r12, %r8
movq 0x10(%rsp), %r9
pushq %r15
pushq %r15
pushq %rax
callq 0x5170
addq $0x20, %rsp
addq $0x10, %rbx
movq 0x10(%rsp), %rax
movq %rbx, (%rax)
xorl %eax, %eax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
    unsigned char *m,unsigned long long *mlen,
    unsigned char *nsec,
    const unsigned char *c,unsigned long long clen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *npub,
    const unsigned char *k
    )
{
    LakeKeyak_Instance instance;
    unsigned long long mlen_;

    if (clen < 16)
        return -1;
    LakeKeyak_Initialize( &instance, k, 16, npub, 150, 0, 0, 1, 0 );
    mlen_ = clen - 16;
    *mlen = mlen_;
    if ( LakeKeyak_Wrap( &instance, c, m, (size_t)mlen_, ad, (size_t)adlen, (unsigned char *)c+mlen_, 1, 0 ) == 1 )
        return 0;
    return -1;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x10, %r8
jb 0x1161a
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r9, %rbx
movq %r8, %r12
movq %rcx, %r14
movq %rsi, %r13
movq %rdi, %r15
movq 0x130(%rsp), %rsi
movq 0x128(%rsp), %rcx
subq $0x8, %rsp
xorl %r10d, %r10d
movl $0x1, %eax
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
movl $0x10, %edx
movl $0x96, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %rax
pushq $0x0
callq 0x5390
addq $0x20, %rsp
leaq -0x10(%r12), %rcx
movq %rcx, (%r13)
leaq (%r14,%r12), %rax
addq $-0x10, %rax
subq $0x8, %rsp
movq %rbp, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %r8
movq 0x128(%rsp), %r9
xorl %r10d, %r10d
pushq %r10
movl $0x1, %ebx
pushq %rbx
pushq %rax
callq 0x5170
addq $0x20, %rsp
movl %eax, %ecx
xorl %eax, %eax
cmpl %ebx, %ecx
setne %al
negl %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/buf1024[P]mysch/dict.c
// Function: dict_int_hash_function
unsigned int dict_int_hash_function(unsigned int key)
{
    key += ~(key << 15);
    key ^= (key >> 10);
    key += (key << 3);
    key ^= (key >> 6);
    key += ~(key << 11);
    key ^= (key >> 16);
    return key;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, %eax
shll $0xf, %eax
notl %eax
addl %edi, %eax
movl %eax, %ecx
shrl $0xa, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
movl %eax, %ecx
shrl $0x6, %ecx
xorl %eax, %ecx
movl %ecx, %edx
shll $0xb, %edx
notl %edx
addl %ecx, %edx
movl %edx, %eax
shrl $0x10, %eax
xorl %edx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/buf1024[P]mysch/dict.c
// Function: dict_gen_hash_function
unsigned int dict_gen_hash_function(const unsigned char *buf, int len)
{
    unsigned int hash = 5381;

    while (len--)
        hash = ((hash << 5) + hash) + (*buf++); /* hash * 33 + c */
    return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
je 0x26ab
movl %esi, %ecx
movl $0x1505, %eax           # imm = 0x1505
xorl %edx, %edx
movl %eax, %esi
shll $0x5, %esi
addl %eax, %esi
movzbl (%rdi,%rdx), %eax
addl %esi, %eax
incq %rdx
cmpl %edx, %ecx
jne 0x2695
jmp 0x26b0
movl $0x1505, %eax           # imm = 0x1505
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/buf1024[P]mysch/dict.c
// Function: dict_gen_case_hash_function
unsigned int dict_gen_case_hash_function(const unsigned char *buf, int len)
{
    unsigned int hash = 5381;

    while (len--)
        hash = ((hash << 5) + hash) + (tolower(*buf++));        /* hash * 33 + c */
    return hash;
}

// Assembly:
testl %esi, %esi
je 0x26f1
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
callq 0x23c0
movq (%rax), %rcx
movl %r14d, %edx
movl $0x1505, %edi           # imm = 0x1505
xorl %esi, %esi
movl %edi, %eax
shll $0x5, %eax
addl %edi, %eax
movzbl (%rbx,%rsi), %edi
addl (%rcx,%rdi,4), %eax
incq %rsi
movl %eax, %edi
cmpl %esi, %edx
jne 0x26d7
popq %rbx
popq %r14
popq %rbp
retq
movl $0x1505, %eax           # imm = 0x1505
retq