LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsnewlen
sds sdsnewlen(const void *init, size_t initlen) {
    struct sdshdr *sh;

    if (init) {
        sh = malloc(sizeof *sh+initlen+1);
    } else {
        sh = calloc(sizeof *sh+initlen+1,1);
    }
    if (sh == NULL) return NULL;
    sh->len = initlen;
    sh->free = 0;
    if (initlen && init)
        memcpy(sh->buf, init, initlen);
    sh->buf[initlen] = '\0';
    return (char*)sh->buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9(%rsi), %rdi
testq %r14, %r14
je 0x540f
callq 0x3350
jmp 0x5417
pushq $0x1
popq %rsi
callq 0x32a0
movq %rax, %r15
testq %rax, %rax
je 0x5452
testq %r14, %r14
sete %al
movl %ebx, (%r15)
andl $0x0, 0x4(%r15)
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x5446
leaq 0x8(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3300
movb $0x0, 0x8(%r15,%rbx)
addq $0x8, %r15
jmp 0x5455
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsupdatelen
void sdsupdatelen(sds s) {
    struct sdshdr *sh = (void*) (s-sizeof *sh);
    int reallen = strlen(s);
    sh->free += (sh->len-reallen);
    sh->len = reallen;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x3140
movl -0x8(%rbx), %ecx
subl %eax, %ecx
addl %ecx, -0x4(%rbx)
movl %eax, -0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsMakeRoomFor
sds sdsMakeRoomFor(sds s, size_t addlen) {
    struct sdshdr *sh, *newsh;
    size_t free = sdsavail(s);
    size_t len, newlen;

    if (free >= addlen) return s;
    len = sdslen(s);
    sh = (void*) (s-sizeof *sh);
    newlen = (len+addlen);
    if (newlen < SDS_MAX_PREALLOC)
        newlen *= 2;
    else
        newlen += SDS_MAX_PREALLOC;
    newsh = realloc(sh, sizeof *newsh+newlen+1);
    if (newsh == NULL) return NULL;

    newsh->free = newlen - len;
    return newsh->buf;
}

// Assembly:
movq %rdi, %rax
movslq -0x4(%rdi), %rcx
cmpq %rsi, %rcx
jae 0x551f
pushq %r14
pushq %rbx
pushq %rax
movslq -0x8(%rax), %rbx
addq $-0x8, %rax
addq %rbx, %rsi
leaq (%rsi,%rsi), %rcx
movl $0x100000, %edx         # imm = 0x100000
leaq (%rsi,%rdx), %r14
cmpq %rdx, %rsi
cmovbq %rcx, %r14
leaq 0x9(%r14), %rsi
movq %rax, %rdi
callq 0x33b0
testq %rax, %rax
je 0x5516
subl %ebx, %r14d
movl %r14d, 0x4(%rax)
addq $0x8, %rax
jmp 0x5518
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsRemoveFreeSpace
sds sdsRemoveFreeSpace(sds s) {
    struct sdshdr *sh;

    sh = (void*) (s-sizeof *sh);
    sh = realloc(sh, sizeof *sh+sh->len+1);
    sh->free = 0;
    return sh->buf;
}

// Assembly:
pushq %rax
movslq -0x8(%rdi), %rsi
addq $-0x8, %rdi
addq $0x9, %rsi
callq 0x33b0
andl $0x0, 0x4(%rax)
addq $0x8, %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsIncrLen
void sdsIncrLen(sds s, int incr) {
    struct sdshdr *sh = (void*) (s-sizeof *sh);

    assert(sh->free >= incr);
    sh->len += incr;
    sh->free -= incr;
    assert(sh->free >= 0);
    s[sh->len] = '\0';
}

// Assembly:
pushq %rax
movl -0x4(%rdi), %eax
cmpl %esi, %eax
jl 0x556e
movslq -0x8(%rdi), %rdx
movslq %esi, %rcx
addq %rdx, %rcx
movl %ecx, -0x8(%rdi)
subl %esi, %eax
movl %eax, -0x4(%rdi)
js 0x558d
movb $0x0, (%rdi,%rcx)
popq %rax
retq
leaq 0x3f47(%rip), %rdi      # 0x94bc
leaq 0x3f51(%rip), %rsi      # 0x94cd
leaq 0x3f50(%rip), %rcx      # 0x94d3
movl $0xcb, %edx
callq 0x31c0
leaq 0x3f59(%rip), %rdi      # 0x94ed
leaq 0x3f32(%rip), %rsi      # 0x94cd
leaq 0x3f31(%rip), %rcx      # 0x94d3
movl $0xce, %edx
callq 0x31c0
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsgrowzero
sds sdsgrowzero(sds s, size_t len) {
    struct sdshdr *sh = (void*) (s-sizeof *sh);
    size_t totlen, curlen = sh->len;

    if (len <= curlen) return s;
    s = sdsMakeRoomFor(s,len-curlen);
    if (s == NULL) return NULL;

    /* Make sure added region doesn't contain garbage */
    sh = (void*)(s-sizeof *sh);
    memset(s+curlen,0,(len-curlen+1)); /* also set trailing \0 byte */
    totlen = sh->len+sh->free;
    sh->len = len;
    sh->free = totlen-sh->len;
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq -0x8(%rdi), %r12
movq %rsi, %r15
subq %r12, %r15
jbe 0x55fd
movq %rsi, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31d0
testq %rax, %rax
je 0x55fb
movq %rax, %rbx
addq %rax, %r12
incq %r15
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3200
movl -0x8(%rbx), %eax
movl %r14d, -0x8(%rbx)
subl %r14d, %eax
addl %eax, -0x4(%rbx)
jmp 0x55fd
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdscatlen
sds sdscatlen(sds s, const void *t, size_t len) {
    struct sdshdr *sh;
    size_t curlen = sdslen(s);

    s = sdsMakeRoomFor(s,len);
    if (s == NULL) return NULL;
    sh = (void*) (s-sizeof *sh);
    memcpy(s+curlen, t, len);
    sh->len = curlen+len;
    sh->free = sh->free-len;
    s[curlen+len] = '\0';
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movslq -0x8(%rdi), %r12
movq %rdx, %rsi
callq 0x31d0
movq %rax, %r14
testq %rax, %rax
je 0x564f
movq %r14, %rdi
addq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3300
addq %rbx, %r12
movl %r12d, -0x8(%r14)
subl %ebx, -0x4(%r14)
movb $0x0, (%r14,%r12)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdscpylen
sds sdscpylen(sds s, const char *t, size_t len) {
    struct sdshdr *sh = (void*) (s-sizeof *sh);
    size_t totlen = sh->free+sh->len;

    if (totlen < len) {
        s = sdsMakeRoomFor(s,len-sh->len);
        if (s == NULL) return NULL;
        sh = (void*) (s-sizeof *sh);
        totlen = sh->free+sh->len;
    }
    memcpy(s, t, len);
    s[len] = '\0';
    sh->len = len;
    sh->free = totlen-len;
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movslq -0x4(%rdi), %r12
movslq -0x8(%rdi), %rax
addq %rax, %r12
cmpq %rdx, %r12
jae 0x56d7
movq %r14, %rsi
subq %rax, %rsi
movq %rbx, %rdi
callq 0x31d0
testq %rax, %rax
je 0x5706
movq %rax, %rbx
movq %rax, %r13
addq $-0x8, %r13
movl -0x8(%rax), %r12d
addl -0x4(%rax), %r12d
jmp 0x56db
leaq -0x8(%rbx), %r13
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3300
movb $0x0, (%rbx,%r14)
movl %r14d, -0x8(%rbx)
subl %r14d, %r12d
movl %r12d, 0x4(%r13)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %ebx, %ebx
jmp 0x56f9
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsll2str
int sdsll2str(char *s, long long value) {
    char *p, aux;
    unsigned long long v;
    size_t l;

    /* Generate the string representation, this method produces
     * an reversed string. */
    v = (value < 0) ? -value : value;
    p = s;
    do {
        *p++ = '0'+(v%10);
        v /= 10;
    } while(v);
    if (value < 0) *p++ = '-';

    /* Compute length and add null term. */
    l = p-s;
    *p = '\0';

    /* Reverse the string. */
    p--;
    while(s < p) {
        aux = *s;
        *s = *p;
        *p = aux;
        s++;
        p--;
    }
    return l;
}

// Assembly:
movq %rsi, %r8
negq %r8
cmovsq %rsi, %r8
pushq $0xa
popq %r9
movq %rdi, %rcx
movq %r8, %rax
xorl %edx, %edx
divq %r9
orb $0x30, %dl
movb %dl, (%rcx)
incq %rcx
cmpq $0x9, %r8
movq %rax, %r8
ja 0x5742
testq %rsi, %rsi
jns 0x5766
movb $0x2d, (%rcx)
incq %rcx
movb $0x0, (%rcx)
leaq -0x1(%rcx), %rax
movq %rdi, %rdx
cmpq %rax, %rdx
jae 0x5789
movb (%rdx), %sil
movb (%rax), %r8b
movb %r8b, (%rdx)
movb %sil, (%rax)
incq %rdx
decq %rax
jmp 0x5770
subl %edi, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsull2str
int sdsull2str(char *s, unsigned long long v) {
    char *p, aux;
    size_t l;

    /* Generate the string representation, this method produces
     * an reversed string. */
    p = s;
    do {
        *p++ = '0'+(v%10);
        v /= 10;
    } while(v);

    /* Compute length and add null term. */
    l = p-s;
    *p = '\0';

    /* Reverse the string. */
    p--;
    while(s < p) {
        aux = *s;
        *s = *p;
        *p = aux;
        s++;
        p--;
    }
    return l;
}

// Assembly:
leaq -0x1(%rdi), %r8
xorl %ecx, %ecx
pushq $0xa
popq %r9
movq %rsi, %rax
xorl %edx, %edx
divq %r9
orb $0x30, %dl
movb %dl, 0x1(%r8)
incq %r8
incl %ecx
cmpq $0x9, %rsi
movq %rax, %rsi
ja 0x5798
movb $0x0, 0x1(%r8)
cmpq %r8, %rdi
jae 0x57d1
movb (%rdi), %al
movb (%r8), %dl
movb %dl, (%rdi)
movb %al, (%r8)
incq %rdi
decq %r8
jmp 0x57ba
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdscatvprintf
sds sdscatvprintf(sds s, const char *fmt, va_list ap) {
    va_list cpy;
    char *buf, *t;
    size_t buflen = 16;

    while(1) {
        buf = malloc(buflen);
        if (buf == NULL) return NULL;
        buf[buflen-2] = '\0';
        va_copy(cpy,ap);
        vsnprintf(buf, buflen, fmt, cpy);
        if (buf[buflen-2] != '\0') {
            free(buf);
            buflen *= 2;
            continue;
        }
        break;
    }
    t = sdscat(s, buf);
    free(buf);
    return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
pushq $0x10
popq %r13
xorl %ebx, %ebx
leaq 0x10(%rsp), %rbp
movq %r13, %rdi
callq 0x3350
testq %rax, %rax
je 0x585e
movq %rax, %r14
movb $0x0, -0x2(%rax,%r13)
movq 0x10(%r15), %rax
movq %rax, 0x20(%rsp)
movups (%r15), %xmm0
movaps %xmm0, 0x10(%rsp)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rbp, %rcx
callq 0x30d0
cmpb $0x0, -0x2(%r14,%r13)
je 0x5846
movq %r14, %rdi
callq 0x3050
addq %r13, %r13
jmp 0x57f8
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x3390
movq %rax, %rbx
movq %r14, %rdi
callq 0x3050
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdstrim
void sdstrim(sds s, const char *cset) {
    struct sdshdr *sh = (void*) (s-sizeof *sh);
    char *start, *end, *sp, *ep;
    size_t len;

    sp = start = s;
    ep = end = s+sdslen(s)-1;
    while(sp <= end && strchr(cset, *sp)) sp++;
    while(ep > start && strchr(cset, *ep)) ep--;
    len = (sp > ep) ? 0 : ((ep-sp)+1);
    if (sh->buf != sp) memmove(sh->buf, sp, len);
    sh->buf[len] = '\0';
    sh->free = sh->free+(sh->len-len);
    sh->len = len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movslq -0x8(%rdi), %r14
leaq (%rdi,%r14), %rbp
decq %rbp
xorl %r13d, %r13d
leaq (%rbx,%r13), %r12
cmpq %rbp, %r12
ja 0x5c12
movsbl (%r12), %esi
movq %r15, %rdi
callq 0x3180
testq %rax, %rax
je 0x5c12
incq %r13
jmp 0x5bf2
subq %r13, %r14
cmpq %rbx, %rbp
jbe 0x5c33
movsbl (%rbp), %esi
movq %r15, %rdi
callq 0x3180
testq %rax, %rax
je 0x5c33
decq %rbp
decq %r14
jmp 0x5c15
xorl %eax, %eax
cmpq %rbp, %r12
cmovaq %rax, %r14
testq %r13, %r13
je 0x5c4f
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x3420
movb $0x0, (%rbx,%r14)
movl -0x4(%rbx), %eax
subl %r14d, %eax
addl -0x8(%rbx), %eax
movl %eax, -0x4(%rbx)
movl %r14d, -0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdscmp
int sdscmp(const sds s1, const sds s2) {
    size_t l1, l2, minlen;
    int cmp;

    l1 = sdslen(s1);
    l2 = sdslen(s2);
    minlen = (l1 < l2) ? l1 : l2;
    cmp = memcmp(s1,s2,minlen);
    if (cmp == 0) return l1-l2;
    return cmp;
}

// Assembly:
pushq %rbx
movl -0x8(%rdi), %eax
movl -0x8(%rsi), %ecx
movl %eax, %ebx
subl %ecx, %ebx
cmovbl %eax, %ecx
movslq %ecx, %rdx
callq 0x3270
testl %eax, %eax
cmovel %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsfreesplitres
void sdsfreesplitres(sds *tokens, int count) {
    if (!tokens) return;
    while(count--)
        sdsfree(tokens[count]);
    free(tokens);
}

// Assembly:
testq %rdi, %rdi
je 0x5f85
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %r14
decq %r14
cmpq $-0x1, %r14
je 0x5f76
movq (%rbx,%r14,8), %rdi
callq 0x3290
jmp 0x5f62
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3050
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsfromlonglong
sds sdsfromlonglong(long long value) {
    char buf[32], *p;
    unsigned long long v;

    v = (value < 0) ? -value : value;
    p = buf+31; /* point to the last character */
    do {
        *p-- = '0'+(v%10);
        v /= 10;
    } while(v);
    if (value < 0) *p-- = '-';
    p++;
    return sdsnewlen(p,32-(p-buf));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, %rcx
movq %rdi, %r8
negq %r8
cmovsq %rdi, %r8
pushq $0x1
popq %rsi
leaq 0x21(%rsp), %rdi
pushq $0xa
popq %r9
movq %r8, %rax
xorl %edx, %edx
divq %r9
orb $0x30, %dl
movb %dl, -0x2(%rdi)
decq %rsi
decq %rdi
cmpq $0x9, %r8
movq %rax, %r8
ja 0x5fa3
testq %rcx, %rcx
js 0x5fc9
pushq $-0x1
jmp 0x5fcf
movb $0x2d, -0x2(%rdi)
pushq $-0x2
popq %rax
addq %rax, %rdi
addq %rax, %rsi
negq %rsi
callq 0x32d0
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdscatrepr
sds sdscatrepr(sds s, const char *p, size_t len) {
    s = sdscatlen(s,"\"",1);
    while(len--) {
        switch(*p) {
        case '\\':
        case '"':
            s = sdscatprintf(s,"\\%c",*p);
            break;
        case '\n': s = sdscatlen(s,"\\n",2); break;
        case '\r': s = sdscatlen(s,"\\r",2); break;
        case '\t': s = sdscatlen(s,"\\t",2); break;
        case '\a': s = sdscatlen(s,"\\a",2); break;
        case '\b': s = sdscatlen(s,"\\b",2); break;
        default:
            if (isprint(*p))
                s = sdscatprintf(s,"%c",*p);
            else
                s = sdscatprintf(s,"\\x%02x",(unsigned char)*p);
            break;
        }
        p++;
    }
    return sdscatlen(s,"\"",1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x3905(%rip), %rsi      # 0x9900
pushq $0x1
popq %rdx
callq 0x3430
movq %rax, %r13
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x60cf
movsbl (%r14,%r12), %ebp
movzbl %bpl, %r15d
leal -0x7(%r15), %eax
cmpl $0x6, %eax
ja 0x6040
leaq 0x3405(%rip), %rcx      # 0x9430
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r13, %rdi
leaq 0x34ca(%rip), %rsi      # 0x9508
jmp 0x60a7
cmpl $0x5c, %r15d
je 0x604c
cmpl $0x22, %r15d
jne 0x6058
movq %r13, %rdi
leaq 0x34a5(%rip), %rsi      # 0x94fb
jmp 0x60bb
callq 0x3540
movq (%rax), %rax
movslq %ebp, %rcx
testb $0x40, 0x1(%rax,%rcx,2)
jne 0x60b1
movq %r13, %rdi
leaq 0x349a(%rip), %rsi      # 0x950e
movl %r15d, %edx
jmp 0x60bd
movq %r13, %rdi
leaq 0x3488(%rip), %rsi      # 0x950b
jmp 0x60a7
movq %r13, %rdi
leaq 0x3476(%rip), %rsi      # 0x9505
jmp 0x60a7
movq %r13, %rdi
leaq 0x3464(%rip), %rsi      # 0x94ff
jmp 0x60a7
movq %r13, %rdi
leaq 0x345b(%rip), %rsi      # 0x9502
pushq $0x2
popq %rdx
callq 0x3430
jmp 0x60c4
movq %r13, %rdi
leaq 0x3441(%rip), %rsi      # 0x94fc
movl %ebp, %edx
xorl %eax, %eax
callq 0x3150
movq %rax, %r13
incq %r12
jmp 0x6009
leaq 0x382a(%rip), %rsi      # 0x9900
pushq $0x1
popq %rdx
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3430
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: hex_digit_to_int
int hex_digit_to_int(char c) {
    switch(c) {
    case '0': return 0;
    case '1': return 1;
    case '2': return 2;
    case '3': return 3;
    case '4': return 4;
    case '5': return 5;
    case '6': return 6;
    case '7': return 7;
    case '8': return 8;
    case '9': return 9;
    case 'a': case 'A': return 10;
    case 'b': case 'B': return 11;
    case 'c': case 'C': return 12;
    case 'd': case 'D': return 13;
    case 'e': case 'E': return 14;
    case 'f': case 'F': return 15;
    default: return 0;
    }
}

// Assembly:
xorl %eax, %eax
leal -0x31(%rdi), %ecx
cmpl $0x15, %ecx
ja 0x612a
leaq 0x332f(%rip), %rdx      # 0x944c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
pushq $0x1
jmp 0x6178
addl $-0x61, %edi
cmpl $0x5, %edi
ja 0x6159
leaq 0x336b(%rip), %rax      # 0x94a4
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
pushq $0xa
jmp 0x6178
pushq $0xd
jmp 0x6178
pushq $0xc
jmp 0x6178
pushq $0xe
jmp 0x6178
pushq $0xb
jmp 0x6178
pushq $0xf
popq %rax
retq
pushq $0x3
jmp 0x6178
pushq $0x5
jmp 0x6178
pushq $0x2
jmp 0x6178
pushq $0x9
jmp 0x6178
pushq $0x8
jmp 0x6178
pushq $0x7
jmp 0x6178
pushq $0x4
jmp 0x6178
pushq $0x6
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsmapchars
sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen) {
    size_t j, i, l = sdslen(s);

    for (j = 0; j < l; j++) {
        for (i = 0; i < setlen; i++) {
            if (s[j] == from[i]) {
                s[j] = to[i];
                break;
            }
        }
    }
    return s;
}

// Assembly:
movq %rdi, %rax
movslq -0x8(%rdi), %rdi
xorl %r8d, %r8d
cmpq %rdi, %r8
je 0x64c3
xorl %r9d, %r9d
cmpq %r9, %rcx
je 0x64be
movb (%rax,%r8), %r10b
cmpb (%rsi,%r9), %r10b
je 0x64b6
incq %r9
jmp 0x64a2
movb (%rdx,%r9), %r9b
movb %r9b, (%rax,%r8)
incq %r8
jmp 0x649a
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsjoin
sds sdsjoin(char **argv, int argc, char *sep, size_t seplen) {
    sds join = sdsempty();
    int j;

    for (j = 0; j < argc; j++) {
        join = sdscat(join, argv[j]);
        if (j != argc-1) join = sdscatlen(join,sep,seplen);
    }
    return join;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
callq 0x34a0
leal -0x1(%r15), %r13d
xorl %ebp, %ebp
testl %r15d, %r15d
cmovlel %ebp, %r15d
cmpq %rbp, %r15
je 0x6516
movq (%r12,%rbp,8), %rsi
movq %rax, %rdi
callq 0x3390
cmpq %rbp, %r13
je 0x6511
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3430
incq %rbp
jmp 0x64ed
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsjoinsds
sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen) {
    sds join = sdsempty();
    int j;

    for (j = 0; j < argc; j++) {
        join = sdscatsds(join, argv[j]);
        if (j != argc-1) join = sdscatlen(join,sep,seplen);
    }
    return join;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
callq 0x34a0
leal -0x1(%r15), %r13d
xorl %ebp, %ebp
testl %r15d, %r15d
cmovlel %ebp, %r15d
cmpq %rbp, %r15
je 0x6577
movq (%r12,%rbp,8), %rsi
movq %rax, %rdi
callq 0x3490
cmpq %rbp, %r13
je 0x6572
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3430
incq %rbp
jmp 0x654e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/async.c
// Function: redisAsyncConnect
redisAsyncContext *redisAsyncConnect(const char *ip, int port) {
    redisContext *c;
    redisAsyncContext *ac;

    c = redisConnectNonBlock(ip,port);
    if (c == NULL)
        return NULL;

    ac = redisAsyncInitialize(c);
    if (ac == NULL) {
        redisFree(c);
        return NULL;
    }

    __redisAsyncCopyError(ac);
    return ac;
}

// Assembly:
pushq %rbx
callq 0x33a0
testq %rax, %rax
je 0x65c3
movq %rax, %rbx
movq %rax, %rdi
callq 0x65c7
testq %rax, %rax
je 0x65bb
movl (%rax), %ecx
movl %ecx, 0xd0(%rax)
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0xd8(%rax)
jmp 0x65c5
movq %rbx, %rdi
callq 0x3330
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/async.c
// Function: redisAsyncConnectBind
redisAsyncContext *redisAsyncConnectBind(const char *ip, int port,
                                         const char *source_addr) {
    redisContext *c = redisConnectBindNonBlock(ip,port,source_addr);
    redisAsyncContext *ac = redisAsyncInitialize(c);
    __redisAsyncCopyError(ac);
    return ac;
}

// Assembly:
pushq %rax
callq 0x3340
movq %rax, %rdi
callq 0x65c7
testq %rax, %rax
je 0x6662
movl (%rax), %ecx
movl %ecx, 0xd0(%rax)
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0xd8(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/async.c
// Function: redisAsyncConnectBindWithReuse
redisAsyncContext *redisAsyncConnectBindWithReuse(const char *ip, int port,
                                                  const char *source_addr) {
    redisContext *c = redisConnectBindNonBlockWithReuse(ip,port,source_addr);
    redisAsyncContext *ac = redisAsyncInitialize(c);
    __redisAsyncCopyError(ac);
    return ac;
}

// Assembly:
pushq %rax
callq 0x3310
movq %rax, %rdi
callq 0x65c7
testq %rax, %rax
je 0x668d
movl (%rax), %ecx
movl %ecx, 0xd0(%rax)
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0xd8(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/async.c
// Function: redisAsyncConnectUnix
redisAsyncContext *redisAsyncConnectUnix(const char *path) {
    redisContext *c;
    redisAsyncContext *ac;

    c = redisConnectUnixNonBlock(path);
    if (c == NULL)
        return NULL;

    ac = redisAsyncInitialize(c);
    if (ac == NULL) {
        redisFree(c);
        return NULL;
    }

    __redisAsyncCopyError(ac);
    return ac;
}

// Assembly:
pushq %rbx
callq 0x33c0
testq %rax, %rax
je 0x66ca
movq %rax, %rbx
movq %rax, %rdi
callq 0x65c7
testq %rax, %rax
je 0x66c2
movl (%rax), %ecx
movl %ecx, 0xd0(%rax)
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0xd8(%rax)
jmp 0x66cc
movq %rbx, %rdi
callq 0x3330
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/async.c
// Function: redisAsyncSetConnectCallback
int redisAsyncSetConnectCallback(redisAsyncContext *ac, redisConnectCallback *fn) {
    if (ac->onConnect == NULL) {
        ac->onConnect = fn;

        /* The common way to detect an established connection is to wait for
         * the first write event to be fired. This assumes the related event
         * library functions are already set. */
        _EL_ADD_WRITE(ac);
        return REDIS_OK;
    }
    return REDIS_ERR;
}

// Assembly:
pushq %rbx
cmpq $0x0, 0x120(%rdi)
je 0x66de
pushq $-0x1
popq %rbx
jmp 0x66fc
movq %rsi, 0x120(%rdi)
movq 0x100(%rdi), %rax
xorl %ebx, %ebx
testq %rax, %rax
je 0x66fc
movq 0xe8(%rdi), %rdi
callq *%rax
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/async.c
// Function: _redisAsyncFree
static void __redisAsyncFree(redisAsyncContext *ac) {
    redisContext *c = &(ac->c);
    redisCallback cb;
    dictIterator *it;
    dictEntry *de;

    /* Execute pending callbacks with NULL reply. */
    while (__redisShiftCallback(&ac->replies,&cb) == REDIS_OK)
        __redisRunCallback(ac,&cb,NULL);

    /* Execute callbacks for invalid commands */
    while (__redisShiftCallback(&ac->sub.invalid,&cb) == REDIS_OK)
        __redisRunCallback(ac,&cb,NULL);

    /* Run subscription callbacks callbacks with NULL reply */
    it = dictGetIterator(ac->sub.channels);
    while ((de = dictNext(it)) != NULL)
        __redisRunCallback(ac,dictGetEntryVal(de),NULL);
    dictReleaseIterator(it);
    dictRelease(ac->sub.channels);

    it = dictGetIterator(ac->sub.patterns);
    while ((de = dictNext(it)) != NULL)
        __redisRunCallback(ac,dictGetEntryVal(de),NULL);
    dictReleaseIterator(it);
    dictRelease(ac->sub.patterns);

    /* Signal event lib to clean up */
    _EL_CLEANUP(ac);

    /* Execute disconnect callback. When redisAsyncFree() initiated destroying
     * this context, the status will always be REDIS_OK. */
    if (ac->onDisconnect && (c->flags & REDIS_CONNECTED)) {
        if (c->flags & REDIS_FREEING) {
            ac->onDisconnect(ac,REDIS_OK);
        } else {
            ac->onDisconnect(ac,(ac->err == 0) ? REDIS_OK : REDIS_ERR);
        }
    }

    /* Cleanup self */
    redisFree(c);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x128(%rdi), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x6d1a
testl %eax, %eax
jne 0x6764
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x6d5a
jmp 0x6746
leaq 0x138(%rbx), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x6d1a
testl %eax, %eax
jne 0x678e
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x6d5a
jmp 0x6770
movq 0x148(%rbx), %rdi
callq 0x7247
movq %rax, %r14
movq %r14, %rdi
callq 0x7263
testq %rax, %rax
je 0x67ba
movq 0x8(%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6d5a
jmp 0x679d
movq %r14, %rdi
callq 0x3050
movq 0x148(%rbx), %rdi
callq 0x72a1
movq 0x150(%rbx), %rdi
callq 0x7247
movq %rax, %r14
movq %r14, %rdi
callq 0x7263
testq %rax, %rax
je 0x67fa
movq 0x8(%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6d5a
jmp 0x67dd
movq %r14, %rdi
callq 0x3050
movq 0x150(%rbx), %rdi
callq 0x72a1
movq 0x110(%rbx), %rax
testq %rax, %rax
je 0x6823
movq 0xe8(%rbx), %rdi
callq *%rax
movq 0x118(%rbx), %rax
testq %rax, %rax
je 0x6850
movl 0x88(%rbx), %ecx
testb $0x2, %cl
je 0x6850
xorl %esi, %esi
testb $0x8, %cl
jne 0x684b
xorl %esi, %esi
cmpl 0xd0(%rbx), %esi
sbbl %esi, %esi
movq %rbx, %rdi
callq *%rax
movq %rbx, %rdi
callq 0x3330
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/async.c
// Function: _redisAsyncDisconnect
static void __redisAsyncDisconnect(redisAsyncContext *ac) {
    redisContext *c = &(ac->c);

    /* Make sure error is accessible if there is any */
    __redisAsyncCopyError(ac);

    if (ac->err == 0) {
        /* For clean disconnects, there should be no pending callbacks. */
        assert(__redisShiftCallback(&ac->replies,NULL) == REDIS_ERR);
    } else {
        /* Disconnection is caused by an error, make sure that pending
         * callbacks cannot call new commands. */
        c->flags |= REDIS_DISCONNECTING;
    }

    /* For non-clean disconnects, __redisAsyncFree() will execute pending
     * callbacks with a NULL-reply. */
    __redisAsyncFree(ac);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x68a0
movl (%rbx), %eax
movl %eax, 0xd0(%rbx)
leaq 0x4(%rbx), %rcx
movq %rcx, 0xd8(%rbx)
jmp 0x68a7
movl 0xd0, %eax
testl %eax, %eax
je 0x68b4
orb $0x4, 0x88(%rbx)
jmp 0x68c7
leaq 0x128(%rbx), %rdi
xorl %esi, %esi
callq 0x6d1a
cmpl $-0x1, %eax
jne 0x68d0
movq %rbx, %rdi
popq %rbx
jmp 0x672e
leaq 0x2cb5(%rip), %rdi      # 0x958c
leaq 0x2c76(%rip), %rsi      # 0x9554
leaq 0x2cdc(%rip), %rcx      # 0x95c1
movl $0x153, %edx            # imm = 0x153
callq 0x31c0
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/async.c
// Function: _redisPushCallback
static int __redisPushCallback(redisCallbackList *list, redisCallback *source) {
    redisCallback *cb;

    /* Copy callback from stack to heap */
    cb = malloc(sizeof(*cb));
    if (cb == NULL)
        return REDIS_ERR_OOM;

    if (source != NULL) {
        memcpy(cb,source,sizeof(*cb));
        cb->next = NULL;
    }

    /* Store callback in list */
    if (list->head == NULL)
        list->head = cb;
    if (list->tail != NULL)
        list->tail->next = cb;
    list->tail = cb;
    return REDIS_OK;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0x3350
testq %rax, %rax
je 0x6d12
testq %r14, %r14
je 0x6cf9
movups (%r14), %xmm0
movups %xmm0, (%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rax)
andq $0x0, (%rax)
cmpq $0x0, (%rbx)
jne 0x6d02
movq %rax, (%rbx)
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x6d0e
movq %rax, (%rcx)
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/async.c
// Function: _redisShiftCallback
static int __redisShiftCallback(redisCallbackList *list, redisCallback *target) {
    redisCallback *cb = list->head;
    if (cb != NULL) {
        list->head = cb->next;
        if (cb == list->tail)
            list->tail = NULL;

        /* Copy callback from heap to stack */
        if (target != NULL)
            memcpy(target,cb,sizeof(*cb));
        free(cb);
        return REDIS_OK;
    }
    return REDIS_ERR;
}

// Assembly:
movq %rdi, %rax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x6d56
movq (%rdi), %rcx
movq %rcx, (%rax)
cmpq 0x8(%rax), %rdi
jne 0x6d36
andq $0x0, 0x8(%rax)
testq %rsi, %rsi
je 0x6d49
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rsi)
movups (%rdi), %xmm0
movups %xmm0, (%rsi)
pushq %rax
callq 0x3050
xorl %eax, %eax
addq $0x8, %rsp
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/async.c
// Function: _redisRunCallback
static void __redisRunCallback(redisAsyncContext *ac, redisCallback *cb, redisReply *reply) {
    redisContext *c = &(ac->c);
    if (cb->fn != NULL) {
        c->flags |= REDIS_IN_CALLBACK;
        cb->fn(ac,reply,cb->privdata);
        c->flags &= ~REDIS_IN_CALLBACK;
    }
}

// Assembly:
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x6d82
pushq %rbx
movq %rdi, %rbx
orb $0x10, 0x88(%rdi)
movq 0x10(%rsi), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq *%rcx
andb $-0x11, 0x88(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/async.c
// Function: redisAsyncHandleRead
void redisAsyncHandleRead(redisAsyncContext *ac) {
    redisContext *c = &(ac->c);

    if (!(c->flags & REDIS_CONNECTED)) {
        /* Abort connect was not successful. */
        if (__redisAsyncHandleConnect(ac) != REDIS_OK)
            return;
        /* Try again later when the context is still not connected. */
        if (!(c->flags & REDIS_CONNECTED))
            return;
    }

    if (redisBufferRead(c) == REDIS_ERR) {
        __redisAsyncDisconnect(ac);
    } else {
        /* Always re-schedule reads */
        _EL_ADD_READ(ac);
        redisProcessCallbacks(ac);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testb $0x2, 0x88(%rdi)
jne 0x6da7
movq %rbx, %rdi
callq 0x6ddb
testl %eax, %eax
jne 0x6da5
testb $0x2, 0x88(%rbx)
jne 0x6da7
popq %rbx
retq
movq %rbx, %rdi
callq 0x3460
cmpl $-0x1, %eax
je 0x6dd2
movq 0xf0(%rbx), %rax
testq %rax, %rax
je 0x6dc9
movq 0xe8(%rbx), %rdi
callq *%rax
movq %rbx, %rdi
popq %rbx
jmp 0x3220
movq %rbx, %rdi
popq %rbx
jmp 0x6882
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/async.c
// Function: _redisAsyncHandleConnect
static int __redisAsyncHandleConnect(redisAsyncContext *ac) {
    redisContext *c = &(ac->c);

    if (redisCheckSocketError(c) == REDIS_ERR) {
        /* Try again later when connect(2) is still in progress. */
        if (errno == EINPROGRESS)
            return REDIS_OK;

        if (ac->onConnect) ac->onConnect(ac,REDIS_ERR);
        __redisAsyncDisconnect(ac);
        return REDIS_ERR;
    }

    /* Mark context as connected. */
    c->flags |= REDIS_CONNECTED;
    if (ac->onConnect) ac->onConnect(ac,REDIS_OK);
    return REDIS_OK;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3160
cmpl $-0x1, %eax
je 0x6e09
orb $0x2, 0x88(%rbx)
movq 0x120(%rbx), %rax
testq %rax, %rax
je 0x6e13
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq *%rax
jmp 0x6e36
callq 0x3080
cmpl $0x73, (%rax)
jne 0x6e17
xorl %ebp, %ebp
jmp 0x6e36
movq 0x120(%rbx), %rax
testq %rax, %rax
je 0x6e2b
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq *%rax
pushq $-0x1
popq %rbp
movq %rbx, %rdi
callq 0x6882
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/async.c
// Function: redisAsyncHandleWrite
void redisAsyncHandleWrite(redisAsyncContext *ac) {
    redisContext *c = &(ac->c);
    int done = 0;

    if (!(c->flags & REDIS_CONNECTED)) {
        /* Abort connect was not successful. */
        if (__redisAsyncHandleConnect(ac) != REDIS_OK)
            return;
        /* Try again later when the context is still not connected. */
        if (!(c->flags & REDIS_CONNECTED))
            return;
    }

    if (redisBufferWrite(c,&done) == REDIS_ERR) {
        __redisAsyncDisconnect(ac);
    } else {
        /* Continue writing when not done, stop writing otherwise */
        if (!done)
            _EL_ADD_WRITE(ac);
        else
            _EL_DEL_WRITE(ac);

        /* Always schedule reads after writes */
        _EL_ADD_READ(ac);
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
andl $0x0, 0xc(%rsp)
movq %rdi, %rbx
testb $0x2, 0x88(%rdi)
jne 0x6e6a
movq %rbx, %rdi
callq 0x6ddb
testl %eax, %eax
jne 0x6ec0
testb $0x2, 0x88(%rbx)
je 0x6ec0
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x3120
cmpl $-0x1, %eax
je 0x6e8c
cmpl $0x0, 0xc(%rsp)
je 0x6e96
movq 0x108(%rbx), %rax
jmp 0x6e9d
movq %rbx, %rdi
callq 0x6882
jmp 0x6ec0
movq 0x100(%rbx), %rax
testq %rax, %rax
je 0x6eab
movq 0xe8(%rbx), %rdi
callq *%rax
movq 0xf0(%rbx), %rax
testq %rax, %rax
je 0x6ec0
movq 0xe8(%rbx), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/async.c
// Function: redisvAsyncCommand
int redisvAsyncCommand(redisAsyncContext *ac, redisCallbackFn *fn, void *privdata, const char *format, va_list ap) {
    char *cmd;
    int len;
    int status;
    len = redisvFormatCommand(&cmd,format,ap);

    /* We don't want to pass -1 or -2 to future functions as a length. */
    if (len < 0)
        return REDIS_ERR;

    status = __redisAsyncCommand(ac,fn,privdata,cmd,len);
    free(cmd);
    return status;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
movq %rcx, %rsi
movq %r8, %rdx
callq 0x3500
testl %eax, %eax
js 0x6f10
movq 0x8(%rsp), %rcx
movl %eax, %r8d
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6f1f
movl %eax, %ebx
movq 0x8(%rsp), %rdi
callq 0x3050
jmp 0x6f13
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/async.c
// Function: redisAsyncCommandArgv
int redisAsyncCommandArgv(redisAsyncContext *ac, redisCallbackFn *fn, void *privdata, int argc, const char **argv, const size_t *argvlen) {
    sds cmd;
    int len;
    int status;
    len = redisFormatSdsCommandArgv(&cmd,argc,argv,argvlen);
    status = __redisAsyncCommand(ac,fn,privdata,cmd,len);
    sdsfree(cmd);
    return status;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %r12
movq %r12, %rdi
movl %ecx, %esi
movq %r8, %rdx
movq %r9, %rcx
callq 0x31e0
movq (%r12), %rcx
movslq %eax, %r8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6f1f
movl %eax, %ebx
movq (%r12), %rdi
callq 0x3290
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/async.c
// Function: callbackValDup
static void *callbackValDup(void *privdata, const void *src) {
    ((void) privdata);
    redisCallback *dup = malloc(sizeof(*dup));
    memcpy(dup,src,sizeof(*dup));
    return dup;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
pushq $0x18
popq %rdi
callq 0x3350
movups (%rbx), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/./dict.c
// Function: dictGetIterator
static dictIterator *dictGetIterator(dict *ht) {
    dictIterator *iter = malloc(sizeof(*iter));

    iter->ht = ht;
    iter->index = -1;
    iter->entry = NULL;
    iter->nextEntry = NULL;
    return iter;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq 0x3350
movq %rbx, (%rax)
orl $-0x1, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/./dict.c
// Function: dictNext
static dictEntry *dictNext(dictIterator *iter) {
    while (1) {
        if (iter->entry == NULL) {
            iter->index++;
            if (iter->index >=
                    (signed)iter->ht->size) break;
            iter->entry = iter->ht->table[iter->index];
        } else {
            iter->entry = iter->nextEntry;
        }
        if (iter->entry) {
            /* We need to save the 'next' here, the iterator user
             * may delete the entry we are returning. */
            iter->nextEntry = iter->entry->next;
            return iter->entry;
        }
    }
    return NULL;
}

// Assembly:
leaq 0x18(%rdi), %rcx
cmpq $0x0, 0x10(%rdi)
movq %rcx, %rax
jne 0x728a
movslq 0x8(%rdi), %rax
incq %rax
movl %eax, 0x8(%rdi)
movq (%rdi), %rdx
cmpl 0x10(%rdx), %eax
jge 0x729e
shlq $0x3, %rax
addq (%rdx), %rax
movq (%rax), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x7271
movq 0x10(%rax), %rdx
movq %rdx, (%rcx)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/./dict.c
// Function: dictFind
static dictEntry *dictFind(dict *ht, const void *key) {
    dictEntry *he;
    unsigned int h;

    if (ht->size == 0) return NULL;
    h = dictHashKey(ht, key) & ht->sizemask;
    he = ht->table[h];
    while(he) {
        if (dictCompareHashKeys(ht, key, he->key))
            return he;
        he = he->next;
    }
    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x0, 0x10(%rdi)
je 0x7389
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rax
movq %rsi, %rdi
callq *(%rax)
movl %eax, %ebx
andl 0x18(%r15), %ebx
shlq $0x3, %rbx
addq (%r15), %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x7389
movq 0x8(%r15), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x737e
movq 0x28(%r15), %rdi
movq (%rbx), %rdx
movq %r14, %rsi
callq *%rax
testl %eax, %eax
je 0x7383
jmp 0x738b
cmpq %r14, (%rbx)
je 0x738b
addq $0x10, %rbx
jmp 0x7357
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x73bd
pushq $0x24
popq %rsi
movq %r15, %rdi
callq 0x3180
movq %rax, %r15
testq %rax, %rax
je 0x73fb
leaq 0x1(%r15), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x32f0
movslq %eax, %r12
movq %r12, (%r14)
pushq $0xd
popq %rsi
movq %r15, %rdi
callq 0x3180
testq %rax, %rax
je 0x73ff
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 0x73ef
leaq 0x236c(%rip), %rdi      # 0x9772
leaq 0x2147(%rip), %rsi      # 0x9554
leaq 0x2360(%rip), %rcx      # 0x9774
movl $0x23f, %edx            # imm = 0x23F
callq 0x31c0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
movl $0x230, %edi            # imm = 0x230
callq 0x32a0
testq %rax, %rax
je 0x76e0
movq %rax, %rbx
movq %r14, 0x220(%rax)
callq 0x34a0
movq %rax, 0x88(%rbx)
movq $0x4000, 0xa0(%rbx) # imm = 0x4000
testq %rax, %rax
je 0x76d8
orl $-0x1, 0x210(%rbx)
jmp 0x76e2
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_O2/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 0x7714
movq 0x220(%rbx), %rax
testq %rax, %rax
je 0x7714
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x7714
callq *%rax
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x7725
callq 0x3290
movq %rbx, %rdi
popq %rbx
jmp 0x3050
// File: /workspace/github_c_makefile_star2_O2/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
pushq $-0x1
popq %rbx
cmpl $0x0, (%rdi)
jne 0x778c
movq %rdx, %r15
movq %rsi, %r12
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x778a
movq %rdi, %r14
cmpq $0x0, 0x98(%rdi)
je 0x779a
movq 0x88(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3430
testq %rax, %rax
je 0x77f3
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 0x7761
movq 0x88(%r14), %rdi
movslq -0x4(%rdi), %rcx
cmpq %rcx, %rax
jae 0x7761
callq 0x3290
callq 0x34a0
movq %rax, 0x88(%r14)
andq $0x0, 0x90(%r14)
testq %rax, %rax
jne 0x7761
leaq 0x2075(%rip), %rdi      # 0x9850
leaq 0x207d(%rip), %rsi      # 0x985f
leaq 0x207d(%rip), %rcx      # 0x9866
movl $0x1cd, %edx            # imm = 0x1CD
callq 0x31c0
movq %r14, %rdi
callq 0x77fd
jmp 0x778c
// File: /workspace/github_c_makefile_star2_O2/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 0x7e0b
movq 0x220(%rbx), %rax
testq %rax, %rax
je 0x7e0b
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x7e0b
callq *%rax
andq $0x0, 0x218(%rbx)
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x7e2f
leaq 0x88(%rbx), %r15
callq 0x3290
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
andq $0x0, 0x10(%r15)
orl $-0x1, 0x210(%rbx)
movl %ebp, (%rbx)
movq %r14, %rdi
callq 0x3140
cmpq $0x7f, %rax
pushq $0x7f
popq %r15
cmovbq %rax, %r15
leaq 0x4(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3300
movb $0x0, 0x4(%rbx,%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7fbd
testq %rax, %rax
je 0x7ebf
subq %rbx, %rax
leal 0x2(%rax), %ecx
movslq %ecx, %rcx
addq %r12, %rcx
movq %rcx, 0x90(%r15)
testq %r14, %r14
je 0x7ec1
movl %eax, (%r14)
jmp 0x7ec1
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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), %edx
pushq $0x1
popq %rcx
pushq $-0x1
popq %rax
cmpl $0x2b, %edx
je 0x7eeb
cmpl $0x2d, %edx
jne 0x7eee
incq %rdi
movq %rax, %rcx
jmp 0x7eee
incq %rdi
xorl %edx, %edx
movzbl (%rdi), %esi
cmpq $0xd, %rsi
je 0x7f15
leal -0x30(%rsi), %r8d
cmpb $0x9, %r8b
ja 0x7f1c
incq %rdi
imulq $0xa, %rdx, %rdx
andl $0xf, %esi
addq %rdx, %rsi
movq %rsi, %rdx
jmp 0x7ef0
imulq %rcx, %rdx
movq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0xa8(%rdi), %rax
testl %ecx, %ecx
js 0x7f7d
je 0x7f63
leal -0x1(%rcx), %edx
imulq $0x28, %rdx, %r8
cmpl $0x2, (%rax,%r8)
jne 0x7f7f
addq %rax, %r8
movl %ecx, %ecx
imulq $0x28, %rcx, %rsi
movl 0x8(%rax,%rsi), %ecx
movl 0x4(%r8), %r8d
leal -0x1(%r8), %r9d
cmpl %r9d, %ecx
jne 0x7f6c
movl %edx, 0x210(%rdi)
movl %edx, %ecx
jmp 0x7f2b
orl $-0x1, 0x210(%rdi)
jmp 0x7f7d
cmpl %r8d, %ecx
jge 0x7f9e
addq %rsi, %rax
orq $-0x1, (%rax)
incl %ecx
movl %ecx, 0x8(%rax)
popq %rax
retq
leaq 0x198f(%rip), %rdi      # 0x9915
leaq 0x18d2(%rip), %rsi      # 0x985f
leaq 0x19a0(%rip), %rcx      # 0x9934
movl $0xc9, %edx
callq 0x31c0
leaq 0x19b2(%rip), %rdi      # 0x9957
leaq 0x18b3(%rip), %rsi      # 0x985f
leaq 0x1981(%rip), %rcx      # 0x9934
movl $0xce, %edx
callq 0x31c0