LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x218(%rax)
je 0xb446
movq -0x8(%rbp), %rax
cmpq $0x0, 0x220(%rax)
je 0xb446
movq -0x8(%rbp), %rax
movq 0x220(%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0xb446
movq -0x8(%rbp), %rax
movq 0x220(%rax), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x218(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0xb464
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x3280
movq -0x8(%rbp), %rdi
callq 0x3040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0xb4a9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb5cc
cmpq $0x0, -0x18(%rbp)
je 0xb5c5
cmpq $0x1, -0x20(%rbp)
jb 0xb5c5
movq -0x10(%rbp), %rax
cmpq $0x0, 0x98(%rax)
jne 0xb563
movq -0x10(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
je 0xb563
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0xb310
movq -0x10(%rbp), %rcx
cmpq 0xa0(%rcx), %rax
jbe 0xb563
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x3280
callq 0x34a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x90(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0xb542
jmp 0xb561
leaq 0x23c3(%rip), %rdi      # 0xd90c
leaq 0x23cb(%rip), %rsi      # 0xd91b
movl $0x1cd, %edx            # imm = 0x1CD
leaq 0x23c6(%rip), %rcx      # 0xd922
callq 0x31c0
jmp 0xb563
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3420
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xb598
movq -0x10(%rbp), %rdi
callq 0xb5e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb5cc
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0xb2f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x98(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x218(%rax)
je 0xb99c
movq -0x8(%rbp), %rax
cmpq $0x0, 0x220(%rax)
je 0xb99c
movq -0x8(%rbp), %rax
movq 0x220(%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0xb99c
movq -0x8(%rbp), %rax
movq 0x220(%rax), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x218(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq $0x0, 0x218(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0xb9e7
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x3280
movq -0x8(%rbp), %rax
movq $0x0, 0x88(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x98(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x90(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x210(%rax) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x3140
movq %rax, -0x20(%rbp)
cmpq $0x7f, -0x20(%rbp)
jae 0xba1c
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xba27
movl $0x7f, %eax
movq %rax, -0x28(%rbp)
jmp 0xba27
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x32f0
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, 0x4(%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/read.c
// Function: readBytes
static char *readBytes(redisReader *r, unsigned int bytes) {
    char *p;
    if (r->len-r->pos >= bytes) {
        p = r->buf+r->pos;
        r->pos += bytes;
        return p;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x90(%rcx), %rax
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jb 0xbac4
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x90(%rcx), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
addq 0x90(%rax), %rcx
movq %rcx, 0x90(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xbacc
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/read.c
// Function: _redisReaderSetErrorProtocolByte
static void __redisReaderSetErrorProtocolByte(redisReader *r, char byte) {
    char cbuf[8], sbuf[128];

    chrtos(cbuf,sizeof(cbuf),byte);
    snprintf(sbuf,sizeof(sbuf),
        "Protocol error, got %s as reply type byte", cbuf);
    __redisReaderSetError(r,REDIS_ERR_PROTOCOL,sbuf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
leaq -0x11(%rbp), %rdi
movl $0x8, %esi
movsbl -0x9(%rbp), %edx
callq 0xc1a0
leaq -0xa0(%rbp), %rdi
leaq -0x11(%rbp), %rcx
movl $0x80, %esi
leaq 0x1e5c(%rip), %rdx      # 0xd97a
movb $0x0, %al
callq 0x3190
movq -0x8(%rbp), %rdi
leaq -0xa0(%rbp), %rdx
movl $0x4, %esi
callq 0xb930
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/read.c
// Function: processLineItem
static int processLineItem(redisReader *r) {
    redisReadTask *cur = &(r->rstack[r->ridx]);
    void *obj;
    char *p;
    int len;

    if ((p = readLine(r,&len)) != NULL) {
        if (cur->type == REDIS_REPLY_INTEGER) {
            if (r->fn && r->fn->createInteger)
                obj = r->fn->createInteger(cur,readLongLong(p));
            else
                obj = (void*)REDIS_REPLY_INTEGER;
        } else {
            /* Type will be error or status. */
            if (r->fn && r->fn->createString)
                obj = r->fn->createString(cur,p,len);
            else
                obj = (void*)(size_t)(cur->type);
        }

        if (obj == NULL) {
            __redisReaderSetErrorOOM(r);
            return REDIS_ERR;
        }

        /* Set reply if this is the root object. */
        if (r->ridx == 0) r->reply = obj;
        moveToNextTask(r);
        return REDIS_OK;
    }

    return REDIS_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0xa8, %rax
movq -0x10(%rbp), %rcx
movslq 0x210(%rcx), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0xc350
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xbc97
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
jne 0xbc02
movq -0x10(%rbp), %rax
cmpq $0x0, 0x220(%rax)
je 0xbbf7
movq -0x10(%rbp), %rax
movq 0x220(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0xbbf7
movq -0x10(%rbp), %rax
movq 0x220(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0xc410
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x38(%rbp), %rax
callq *%rax
movq %rax, -0x20(%rbp)
jmp 0xbc00
movl $0x3, %eax
movq %rax, -0x20(%rbp)
jmp 0xbc50
movq -0x10(%rbp), %rax
cmpq $0x0, 0x220(%rax)
je 0xbc43
movq -0x10(%rbp), %rax
movq 0x220(%rax), %rax
cmpq $0x0, (%rax)
je 0xbc43
movq -0x10(%rbp), %rax
movq 0x220(%rax), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movslq -0x2c(%rbp), %rdx
callq *%rax
movq %rax, -0x20(%rbp)
jmp 0xbc4e
movq -0x18(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xbc50
cmpq $0x0, -0x20(%rbp)
jne 0xbc69
movq -0x10(%rbp), %rdi
callq 0xb5e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xbc9e
movq -0x10(%rbp), %rax
cmpl $0x0, 0x210(%rax)
jne 0xbc85
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x218(%rax)
movq -0x10(%rbp), %rdi
callq 0xc4e0
movl $0x0, -0x4(%rbp)
jmp 0xbc9e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/read.c
// Function: chrtos
static size_t chrtos(char *buf, size_t size, char byte) {
    size_t len = 0;

    switch(byte) {
    case '\\':
    case '"':
        len = snprintf(buf,size,"\"\\%c\"",byte);
        break;
    case '\n': len = snprintf(buf,size,"\"\\n\""); break;
    case '\r': len = snprintf(buf,size,"\"\\r\""); break;
    case '\t': len = snprintf(buf,size,"\"\\t\""); break;
    case '\a': len = snprintf(buf,size,"\"\\a\""); break;
    case '\b': len = snprintf(buf,size,"\"\\b\""); break;
    default:
        if (isprint(byte))
            len = snprintf(buf,size,"\"%c\"",byte);
        else
            len = snprintf(buf,size,"\"\\x%02x\"",(unsigned char)byte);
        break;
    }

    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq $0x0, -0x20(%rbp)
movsbl -0x11(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x7, %eax
je 0xc29f
jmp 0xc1cf
movl -0x24(%rbp), %eax
subl $0x8, %eax
je 0xc2bd
jmp 0xc1dd
movl -0x24(%rbp), %eax
subl $0x9, %eax
je 0xc27e
jmp 0xc1eb
movl -0x24(%rbp), %eax
subl $0xa, %eax
je 0xc23c
jmp 0xc1f5
movl -0x24(%rbp), %eax
subl $0xd, %eax
je 0xc25d
jmp 0xc1ff
movl -0x24(%rbp), %eax
subl $0x22, %eax
je 0xc217
jmp 0xc209
movl -0x24(%rbp), %eax
subl $0x5c, %eax
jne 0xc2db
jmp 0xc217
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsbl -0x11(%rbp), %ecx
leaq 0x177a(%rip), %rdx      # 0xd9a4
movb $0x0, %al
callq 0x3190
cltq
movq %rax, -0x20(%rbp)
jmp 0xc33c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x175f(%rip), %rdx      # 0xd9aa
movb $0x0, %al
callq 0x3190
cltq
movq %rax, -0x20(%rbp)
jmp 0xc33c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x1743(%rip), %rdx      # 0xd9af
movb $0x0, %al
callq 0x3190
cltq
movq %rax, -0x20(%rbp)
jmp 0xc33c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x1727(%rip), %rdx      # 0xd9b4
movb $0x0, %al
callq 0x3190
cltq
movq %rax, -0x20(%rbp)
jmp 0xc33c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x170b(%rip), %rdx      # 0xd9b9
movb $0x0, %al
callq 0x3190
cltq
movq %rax, -0x20(%rbp)
jmp 0xc33c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x16f2(%rip), %rdx      # 0xd9be
movb $0x0, %al
callq 0x3190
cltq
movq %rax, -0x20(%rbp)
jmp 0xc33c
callq 0x3530
movq (%rax), %rax
movsbl -0x11(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0xc31a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsbl -0x11(%rbp), %ecx
leaq 0x16b8(%rip), %rdx      # 0xd9c3
movb $0x0, %al
callq 0x3190
cltq
movq %rax, -0x20(%rbp)
jmp 0xc33a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movzbl -0x11(%rbp), %ecx
leaq 0x169b(%rip), %rdx      # 0xd9c8
movb $0x0, %al
callq 0x3190
cltq
movq %rax, -0x20(%rbp)
jmp 0xc33c
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x90(%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rsi
movq -0x10(%rbp), %rax
subq 0x90(%rax), %rsi
callq 0xc620
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xc3f9
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x88(%rcx), %rcx
movq -0x10(%rbp), %rdx
addq 0x90(%rdx), %rcx
subq %rcx, %rax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addl $0x2, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
addq 0x90(%rax), %rcx
movq %rcx, 0x90(%rax)
cmpq $0x0, -0x18(%rbp)
je 0xc3ef
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc401
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x1, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0xc448
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xc469
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0xc467
movl $0x1, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xc469
jmp 0xc46b
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl %al, %eax
cmpl $0xd, %eax
je 0xc4c0
movsbl -0x21(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0xc4b4
cmpl $0xa, -0x1c(%rbp)
jge 0xc4b4
imulq $0xa, -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movslq -0x1c(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xc4be
movq $-0x1, -0x8(%rbp)
jmp 0xc4cd
jmp 0xc46b
movslq -0x20(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x210(%rax)
jl 0xc615
movq -0x8(%rbp), %rax
cmpl $0x0, 0x210(%rax)
jne 0xc522
movq -0x8(%rbp), %rax
movl 0x210(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x210(%rax)
jmp 0xc615
movq -0x8(%rbp), %rax
addq $0xa8, %rax
movq -0x8(%rbp), %rcx
movslq 0x210(%rcx), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0xa8, %rax
movq -0x8(%rbp), %rcx
movl 0x210(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xc572
jmp 0xc591
leaq 0x1458(%rip), %rdi      # 0xd9d1
leaq 0x139b(%rip), %rsi      # 0xd91b
movl $0xc9, %edx
leaq 0x1464(%rip), %rcx      # 0xd9f0
callq 0x31c0
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0xc5bb
movq -0x8(%rbp), %rax
movl 0x210(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x210(%rax)
jmp 0xc610
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0xc5cd
jmp 0xc5ec
leaq 0x143f(%rip), %rdi      # 0xda13
leaq 0x1340(%rip), %rsi      # 0xd91b
movl $0xce, %edx
leaq 0x1409(%rip), %rcx      # 0xd9f0
callq 0x31c0
movq -0x10(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0xc615
jmp 0xc4ec
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0xc6d4
jmp 0xc64c
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x20(%rbp), %ecx
movb %al, -0x21(%rbp)
jge 0xc66e
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xc677
jmp 0xc682
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc64c
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
je 0xc69d
movq $0x0, -0x8(%rbp)
jmp 0xc6dc
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0xc6c4
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0xc6dc
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc6cf
jmp 0xc63e
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xb8, %rsp
movb %dl, %al
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movb %al, 0xa7(%rsp)
movq %rcx, 0x98(%rsp)
movq 0x98(%rsp), %rax
addq $0x300, %rax            # imm = 0x300
movq %rax, 0x90(%rsp)
movq 0x98(%rsp), %rax
addq $0x400, %rax            # imm = 0x400
movq %rax, 0x88(%rsp)
vmovdqa 0x5824(%rip), %xmm0     # 0xb010
vmovdqa %xmm0, 0x70(%rsp)
movl $0x0, 0x6c(%rsp)
cmpl $0x10, 0x6c(%rsp)
jge 0x5855
movq 0xb0(%rsp), %rax
movslq 0x6c(%rsp), %rcx
vpbroadcastb (%rax,%rcx), %xmm0
vmovdqa %xmm0, 0x50(%rsp)
vmovdqa 0x50(%rsp), %xmm0
movq 0x90(%rsp), %rax
movl 0x6c(%rsp), %ecx
sarl %ecx
movl 0x6c(%rsp), %edx
andl $0x1, %edx
shll $0x3, %edx
addl %edx, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa %xmm0, (%rax)
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0x57fa
movl $0x0, 0x6c(%rsp)
cmpl $0xb, 0x6c(%rsp)
jge 0x58b8
movq 0xa8(%rsp), %rax
movslq 0x6c(%rsp), %rcx
vpbroadcastb (%rax,%rcx), %xmm0
vmovdqa %xmm0, 0x40(%rsp)
vmovdqa 0x40(%rsp), %xmm0
movq 0x88(%rsp), %rax
movl 0x6c(%rsp), %ecx
sarl %ecx
movl 0x6c(%rsp), %edx
andl $0x1, %edx
shll $0x3, %edx
addl %edx, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa %xmm0, (%rax)
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0x585d
vpbroadcastb 0xa7(%rsp), %xmm0
vmovdqa %xmm0, 0x30(%rsp)
vmovdqa 0x30(%rsp), %xmm0
movq 0x88(%rsp), %rax
vmovdqa %xmm0, 0xf0(%rax)
vmovdqa 0x70(%rsp), %xmm0
movq 0x88(%rsp), %rax
vmovdqa %xmm0, 0x70(%rax)
vpxor %xmm0, %xmm0, %xmm0
vmovdqa %xmm0, 0x20(%rsp)
vmovdqa 0x20(%rsp), %xmm1
movq 0x88(%rsp), %rax
vmovdqa %xmm1, 0xe0(%rax)
vmovdqa %xmm0, 0x10(%rsp)
vmovdqa 0x10(%rsp), %xmm1
movq 0x88(%rsp), %rax
vmovdqa %xmm1, 0x60(%rax)
vmovdqa %xmm0, (%rsp)
vmovdqa (%rsp), %xmm0
movq 0x88(%rsp), %rax
vmovdqa %xmm0, 0xd0(%rax)
movq 0x88(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
callq 0x10e0
addq $0xb8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl 0x1c(%rsp), %ecx
shrl $0x3, %ecx
cmpl %ecx, %eax
jae 0x6679
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
shll %ecx
addl $0x0, %ecx
movl %ecx, %ecx
movl $0x0, (%rax,%rcx,4)
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
shll %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movl $0x0, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x662f
movl 0x1c(%rsp), %eax
andl $0x7, %eax
cmpl $0x0, %eax
je 0x669f
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
shrl $0x3, %esi
movl 0x1c(%rsp), %ecx
andl $0x7, %ecx
xorl %edx, %edx
callq 0x5100
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
cmpl $0x19, 0x14(%rsp)
jae 0xbeef
jmp 0xbf0e
leaq 0x101ce(%rip), %rdi     # 0x1c0c4
leaq 0x101d3(%rip), %rsi     # 0x1c0d0
movl $0x94, %edx
leaq 0x1023e(%rip), %rcx     # 0x1c147
callq 0x51c0
movl 0x14(%rsp), %eax
addl 0x10(%rsp), %eax
cmpl $0x19, %eax
ja 0xbf1d
jmp 0xbf3c
leaq 0x10277(%rip), %rdi     # 0x1c19b
leaq 0x101a5(%rip), %rsi     # 0x1c0d0
movl $0x95, %edx
leaq 0x10210(%rip), %rcx     # 0x1c147
callq 0x51c0
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x10(%rsp), %eax
jae 0xbf80
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
movzbl (%rax,%rcx), %esi
movq 0x20(%rsp), %rax
movl 0x14(%rsp), %ecx
addl 0xc(%rsp), %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xbf44
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-200-reference.c
// Function: theta
static void theta(tKeccakLane *A)
{
    unsigned int x, y;
    tKeccakLane C[5], D[5];

    for(x=0; x<5; x++) {
        C[x] = 0;
        for(y=0; y<5; y++)
            C[x] ^= A[index(x, y)];
    }
    for(x=0; x<5; x++)
        D[x] = ROL8(C[(x+1)%5], 1) ^ C[(x+4)%5];
    for(x=0; x<5; x++)
        for(y=0; y<5; y++)
            A[index(x, y)] ^= D[x];
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0x5, -0xc(%rsp)
jae 0xc1ec
movl -0xc(%rsp), %eax
movb $0x0, -0x15(%rsp,%rax)
movl $0x0, -0x10(%rsp)
cmpl $0x5, -0x10(%rsp)
jae 0xc1da
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movl -0xc(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, -0x20(%rsp)
movl -0x10(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movq -0x28(%rsp), %rax
movl %edx, %ecx
movl -0x20(%rsp), %edx
imull $0x5, %ecx, %ecx
addl %ecx, %edx
movl %edx, %ecx
movzbl (%rax,%rcx), %edx
movl -0xc(%rsp), %eax
movzbl -0x15(%rsp,%rax), %ecx
xorl %edx, %ecx
movb %cl, -0x15(%rsp,%rax)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0xc179
jmp 0xc1dc
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0xc15d
movl $0x0, -0xc(%rsp)
cmpl $0x5, -0xc(%rsp)
jae 0xc270
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %eax
movzbl -0x15(%rsp,%rax), %eax
shll %eax
movl %eax, -0x30(%rsp)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl -0x30(%rsp), %eax
movl %edx, %ecx
movzbl -0x15(%rsp,%rcx), %ecx
sarl $0x7, %ecx
xorl %ecx, %eax
movl %eax, -0x2c(%rsp)
movl -0xc(%rsp), %eax
addl $0x4, %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl -0x2c(%rsp), %eax
movl %edx, %ecx
movzbl -0x15(%rsp,%rcx), %ecx
xorl %ecx, %eax
movb %al, %cl
movl -0xc(%rsp), %eax
movb %cl, -0x1a(%rsp,%rax)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0xc1f4
movl $0x0, -0xc(%rsp)
cmpl $0x5, -0xc(%rsp)
jae 0xc2f6
movl $0x0, -0x10(%rsp)
cmpl $0x5, -0x10(%rsp)
jae 0xc2e7
movl -0xc(%rsp), %eax
movzbl -0x1a(%rsp,%rax), %esi
movq -0x8(%rsp), %rax
movq %rax, -0x40(%rsp)
movl -0xc(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, -0x34(%rsp)
movl -0x10(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movq -0x40(%rsp), %rax
movl %edx, %ecx
movl -0x34(%rsp), %edx
imull $0x5, %ecx, %ecx
addl %ecx, %edx
movl %edx, %ecx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0xc287
jmp 0xc2e9
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0xc278
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-200-reference.c
// Function: pi
static void pi(tKeccakLane *A)
{
    unsigned int x, y;
    tKeccakLane tempA[25];

    for(x=0; x<5; x++) for(y=0; y<5; y++)
        tempA[index(x, y)] = A[index(x, y)];
    for(x=0; x<5; x++) for(y=0; y<5; y++)
        A[index(0*x+1*y, 2*x+3*y)] = tempA[index(x, y)];
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0x5, -0xc(%rsp)
jae 0xc5e2
movl $0x0, -0x10(%rsp)
cmpl $0x5, -0x10(%rsp)
jae 0xc5d0
movq -0x8(%rsp), %rax
movq %rax, -0x48(%rsp)
movl -0xc(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, -0x40(%rsp)
movl -0x10(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movq -0x48(%rsp), %rax
movl %edx, %ecx
movl -0x40(%rsp), %edx
imull $0x5, %ecx, %ecx
addl %ecx, %edx
movl %edx, %ecx
movb (%rax,%rcx), %cl
movl -0xc(%rsp), %eax
movl $0x5, %esi
xorl %edx, %edx
divl %esi
movl %edx, -0x3c(%rsp)
movl -0x10(%rsp), %eax
movl $0x5, %esi
xorl %edx, %edx
divl %esi
movl %edx, %eax
movl -0x3c(%rsp), %edx
imull $0x5, %eax, %eax
addl %eax, %edx
movl %edx, %eax
movb %cl, -0x38(%rsp,%rax)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0xc550
jmp 0xc5d2
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0xc53d
movl $0x0, -0xc(%rsp)
cmpl $0x5, -0xc(%rsp)
jae 0xc6ab
movl $0x0, -0x10(%rsp)
cmpl $0x5, -0x10(%rsp)
jae 0xc699
movl -0xc(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, -0x5c(%rsp)
movl -0x10(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %eax
movl -0x5c(%rsp), %edx
imull $0x5, %eax, %eax
addl %eax, %edx
movl %edx, %eax
movb -0x38(%rsp,%rax), %al
movb %al, -0x49(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x58(%rsp)
imull $0x0, -0xc(%rsp), %eax
movl -0x10(%rsp), %ecx
shll $0x0, %ecx
addl %ecx, %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %ecx
movl -0xc(%rsp), %eax
shll %eax
imull $0x3, -0x10(%rsp), %edx
addl %edx, %eax
movl $0x5, %esi
xorl %edx, %edx
divl %esi
movq -0x58(%rsp), %rax
movl %edx, %esi
movb -0x49(%rsp), %dl
imull $0x5, %esi, %esi
addl %esi, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0xc5fd
jmp 0xc69b
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0xc5ea
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-200-reference.c
// Function: chi
static void chi(tKeccakLane *A)
{
    unsigned int x, y;
    tKeccakLane C[5];

    for(y=0; y<5; y++) {
        for(x=0; x<5; x++)
            C[x] = A[index(x, y)] ^ ((~A[index(x+1, y)]) & A[index(x+2, y)]);
        for(x=0; x<5; x++)
            A[index(x, y)] = C[x];
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0x10(%rsp)
cmpl $0x5, -0x10(%rsp)
jae 0xc833
movl $0x0, -0xc(%rsp)
cmpl $0x5, -0xc(%rsp)
jae 0xc7be
movq -0x8(%rsp), %rax
movq %rax, -0x40(%rsp)
movl -0xc(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, -0x34(%rsp)
movl -0x10(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movq -0x40(%rsp), %rax
movl %edx, %ecx
movl -0x34(%rsp), %edx
imull $0x5, %ecx, %ecx
addl %ecx, %edx
movl %edx, %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x24(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x30(%rsp)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, -0x28(%rsp)
movl -0x10(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movq -0x30(%rsp), %rax
movl %edx, %ecx
movl -0x28(%rsp), %edx
imull $0x5, %ecx, %ecx
addl %ecx, %edx
movl %edx, %ecx
movzbl (%rax,%rcx), %ecx
xorl $-0x1, %ecx
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movl -0xc(%rsp), %eax
addl $0x2, %eax
movl $0x5, %esi
xorl %edx, %edx
divl %esi
movl %edx, %esi
movl -0x10(%rsp), %eax
movl $0x5, %edi
xorl %edx, %edx
divl %edi
movl -0x24(%rsp), %eax
movl %edx, %edi
movq -0x20(%rsp), %rdx
imull $0x5, %edi, %edi
addl %edi, %esi
movl %esi, %esi
movzbl (%rdx,%rsi), %edx
andl %edx, %ecx
xorl %ecx, %eax
movb %al, %cl
movl -0xc(%rsp), %eax
movb %cl, -0x15(%rsp,%rax)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0xc6d0
movl $0x0, -0xc(%rsp)
cmpl $0x5, -0xc(%rsp)
jae 0xc821
movl -0xc(%rsp), %eax
movb -0x15(%rsp,%rax), %al
movb %al, -0x41(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x50(%rsp)
movl -0xc(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %ecx
movl -0x10(%rsp), %eax
movl $0x5, %esi
xorl %edx, %edx
divl %esi
movq -0x50(%rsp), %rax
movl %edx, %esi
movb -0x41(%rsp), %dl
imull $0x5, %esi, %esi
addl %esi, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0xc7c6
jmp 0xc823
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0xc6bd
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl %r8d, 0x8(%rsp)
cmpl $0x19, 0xc(%rsp)
jae 0xc925
jmp 0xc944
leaq 0xf798(%rip), %rdi      # 0x1c0c4
leaq 0xf79d(%rip), %rsi      # 0x1c0d0
movl $0x168, %edx            # imm = 0x168
leaq 0xf96c(%rip), %rcx      # 0x1c2ab
callq 0x51c0
movl 0xc(%rsp), %eax
addl 0x8(%rsp), %eax
cmpl $0x19, %eax
ja 0xc953
jmp 0xc972
leaq 0xf841(%rip), %rdi      # 0x1c19b
leaq 0xf76f(%rip), %rsi      # 0x1c0d0
movl $0x169, %edx            # imm = 0x169
leaq 0xf93e(%rip), %rcx      # 0x1c2ab
callq 0x51c0
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x8(%rsp), %eax
jae 0xc9c1
movq 0x18(%rsp), %rax
movl 0x4(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movq 0x20(%rsp), %rcx
movl 0xc(%rsp), %edx
addl 0x4(%rsp), %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xc97a
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x12, 0xc(%rsp)
jae 0xca43
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
leaq 0xf928(%rip), %rsi      # 0x1c320
movb $0x0, %al
callq 0x56c0
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, %ecx
leaq 0xf94f(%rip), %rax      # 0x1c360
movzbl (%rax,%rcx), %edx
leaq 0xf916(%rip), %rsi      # 0x1c332
movb $0x0, %al
callq 0x56c0
movq 0x10(%rsp), %rdi
leaq 0xf908(%rip), %rsi      # 0x1c337
movb $0x0, %al
callq 0x56c0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xc9e1
movq 0x10(%rsp), %rdi
leaq 0xf8e8(%rip), %rsi      # 0x1c337
movb $0x0, %al
callq 0x56c0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
cmpl $0x5, 0x8(%rsp)
jae 0xcb29
movl $0x0, 0xc(%rsp)
cmpl $0x5, 0xc(%rsp)
jae 0xcb17
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
leaq 0xf896(%rip), %rsi      # 0x1c339
movb $0x0, %al
callq 0x56c0
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, 0x4(%rsp)
movl 0x8(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %eax
movl 0x4(%rsp), %edx
imull $0x5, %eax, %eax
addl %eax, %edx
movl %edx, %eax
movl %eax, %ecx
leaq 0xf89d(%rip), %rax      # 0x1c380
movl (%rax,%rcx,4), %edx
leaq 0xf861(%rip), %rsi      # 0x1c34e
movb $0x0, %al
callq 0x56c0
movq 0x10(%rsp), %rdi
leaq 0xf837(%rip), %rsi      # 0x1c337
movb $0x0, %al
callq 0x56c0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xca84
jmp 0xcb19
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xca71
movq 0x10(%rsp), %rdi
leaq 0xf802(%rip), %rsi      # 0x1c337
movb $0x0, %al
callq 0x56c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
cmpl $0x32, 0x14(%rsp)
jae 0xcbef
jmp 0xcc0e
leaq 0xf7ee(%rip), %rdi      # 0x1c3e4
leaq 0xf7f3(%rip), %rsi      # 0x1c3f0
movl $0x96, %edx
leaq 0xf85e(%rip), %rcx      # 0x1c467
callq 0x51c0
movl 0x14(%rsp), %eax
addl 0x10(%rsp), %eax
cmpl $0x32, %eax
ja 0xcc1d
jmp 0xcc3c
leaq 0xf897(%rip), %rdi      # 0x1c4bb
leaq 0xf7c5(%rip), %rsi      # 0x1c3f0
movl $0x97, %edx
leaq 0xf830(%rip), %rcx      # 0x1c467
callq 0x51c0
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x10(%rsp), %eax
jae 0xcc80
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
movzbl (%rax,%rcx), %esi
movq 0x20(%rsp), %rax
movl 0x14(%rsp), %ecx
addl 0xc(%rsp), %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xcc44
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl %r8d, 0x8(%rsp)
cmpl $0x32, 0xc(%rsp)
jae 0xd635
jmp 0xd654
leaq 0xeda8(%rip), %rdi      # 0x1c3e4
leaq 0xedad(%rip), %rsi      # 0x1c3f0
movl $0x16a, %edx            # imm = 0x16A
leaq 0xef7c(%rip), %rcx      # 0x1c5cb
callq 0x51c0
movl 0xc(%rsp), %eax
addl 0x8(%rsp), %eax
cmpl $0x32, %eax
ja 0xd663
jmp 0xd682
leaq 0xee51(%rip), %rdi      # 0x1c4bb
leaq 0xed7f(%rip), %rsi      # 0x1c3f0
movl $0x16b, %edx            # imm = 0x16B
leaq 0xef4e(%rip), %rcx      # 0x1c5cb
callq 0x51c0
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x8(%rsp), %eax
jae 0xd6d1
movq 0x18(%rsp), %rax
movl 0x4(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movq 0x20(%rsp), %rcx
movl 0xc(%rsp), %edx
addl 0x4(%rsp), %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xd68a
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x14, 0xc(%rsp)
jae 0xd753
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
leaq 0xec18(%rip), %rsi      # 0x1c320
movb $0x0, %al
callq 0x56c0
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, %ecx
leaq 0xef2f(%rip), %rax      # 0x1c650
movzwl (%rax,%rcx,2), %edx
leaq 0xef14(%rip), %rsi      # 0x1c640
movb $0x0, %al
callq 0x56c0
movq 0x10(%rsp), %rdi
leaq 0xebf8(%rip), %rsi      # 0x1c337
movb $0x0, %al
callq 0x56c0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xd6f1
movq 0x10(%rsp), %rdi
leaq 0xebd8(%rip), %rsi      # 0x1c337
movb $0x0, %al
callq 0x56c0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-800-opt32.c
// Function: KeccakP800_AddByte
void KeccakP800_AddByte(void *argState, unsigned char data, unsigned int offset)
{
#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
    unsigned int lanePosition = offset/4;
    unsigned int offsetInLane = offset%4;
    UINT32 lane = (UINT32)data << (8*offsetInLane);
    ((UINT32*)argState)[lanePosition] ^= lane;
#else
#error "Not yet implemented"
#endif
}

// Assembly:
movb %sil, %al
movq %rdi, -0x8(%rsp)
movb %al, -0x9(%rsp)
movl %edx, -0x10(%rsp)
movl -0x10(%rsp), %eax
shrl $0x2, %eax
movl %eax, -0x14(%rsp)
movl -0x10(%rsp), %eax
andl $0x3, %eax
movl %eax, -0x18(%rsp)
movzbl -0x9(%rsp), %eax
movl -0x18(%rsp), %ecx
shll $0x3, %ecx
shll %cl, %eax
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %edx
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movl %ecx, 0x30(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x34(%rsp), %eax
shrl $0x2, %eax
movl %eax, 0x28(%rsp)
movl 0x34(%rsp), %eax
andl $0x3, %eax
movl %eax, 0x24(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x28(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x2c(%rsp)
jbe 0xd9be
cmpl $0x0, 0x24(%rsp)
je 0xd9be
movl $0x4, %eax
subl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jbe 0xd968
movl 0x2c(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x24(%rsp), %eax
leaq 0x8(%rsp), %rdi
addq %rax, %rdi
movq 0x18(%rsp), %rsi
movl 0xc(%rsp), %eax
movl %eax, %edx
callq 0x56e0
movl 0x8(%rsp), %ecx
movq 0x10(%rsp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, 0x10(%rsp)
xorl (%rax), %ecx
movl %ecx, (%rax)
movl 0xc(%rsp), %ecx
movl 0x2c(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x2c(%rsp)
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
jmp 0xd9c0
cmpl $0x4, 0x2c(%rsp)
jb 0xd9fe
movq 0x18(%rsp), %rax
movl (%rax), %ecx
movq 0x10(%rsp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, 0x10(%rsp)
xorl (%rax), %ecx
movl %ecx, (%rax)
movl 0x2c(%rsp), %eax
subl $0x4, %eax
movl %eax, 0x2c(%rsp)
movq 0x18(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x18(%rsp)
jmp 0xd9c0
cmpl $0x0, 0x2c(%rsp)
jbe 0xda2f
movl $0x0, 0x4(%rsp)
movq 0x18(%rsp), %rsi
movl 0x2c(%rsp), %eax
movl %eax, %edx
leaq 0x4(%rsp), %rdi
callq 0x56e0
movl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rax
xorl (%rax), %ecx
movl %ecx, (%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x3c(%rsp), %eax
shll $0x2, %eax
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movl 0x1c(%rsp), %ecx
cmpq %rcx, %rax
jb 0xf8a5
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0xc(%rsp)
cmpl $0x4, 0xc(%rsp)
jb 0xf843
movq 0x30(%rsp), %rax
movl (%rax), %ecx
movq 0x10(%rsp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, 0x10(%rsp)
xorl (%rax), %ecx
movl %ecx, (%rax)
movq 0x30(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %ecx
movq 0x10(%rsp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, 0x10(%rsp)
xorl (%rax), %ecx
movl %ecx, (%rax)
movq 0x30(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %ecx
movq 0x10(%rsp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, 0x10(%rsp)
xorl (%rax), %ecx
movl %ecx, (%rax)
movq 0x30(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %ecx
movq 0x10(%rsp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, 0x10(%rsp)
xorl (%rax), %ecx
movl %ecx, (%rax)
movq 0x30(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x30(%rsp)
movl 0xc(%rsp), %eax
subl $0x4, %eax
movl %eax, 0xc(%rsp)
jmp 0xf780
jmp 0xf845
movl 0xc(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0xc(%rsp)
cmpl $0x0, %eax
je 0xf883
movq 0x30(%rsp), %rax
movl (%rax), %ecx
movq 0x10(%rsp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, 0x10(%rsp)
xorl (%rax), %ecx
movl %ecx, (%rax)
movq 0x30(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x30(%rsp)
jmp 0xf845
movq 0x40(%rsp), %rdi
callq 0x51a0
movl 0x1c(%rsp), %eax
movl %eax, %ecx
movq 0x28(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x28(%rsp)
jmp 0xf75c
movq 0x20(%rsp), %rax
subq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop