LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: createStringObject
static void *createStringObject(const redisReadTask *task, char *str, size_t len) {
    redisReply *r, *parent;
    char *buf;

    r = createReplyObject(task->type);
    if (r == NULL)
        return NULL;

    buf = malloc(len+1);
    if (buf == NULL) {
        freeReplyObject(r);
        return NULL;
    }

    assert(task->type == REDIS_REPLY_ERROR  ||
           task->type == REDIS_REPLY_STATUS ||
           task->type == REDIS_REPLY_STRING);

    /* Copy string value */
    memcpy(buf,str,len);
    buf[len] = '\0';
    r->str = buf;
    r->len = len;

    if (task->parent) {
        parent = task->parent->obj;
        assert(parent->type == REDIS_REPLY_ARRAY);
        parent->element[task->idx] = r;
    }
    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl (%rdi), %ebp
movl $0x1, %edi
movl $0x30, %esi
callq 0x3290
testq %rax, %rax
je 0x57aa
movq %rax, %rbx
movl %ebp, (%rax)
jmp 0x57ac
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x5813
leaq 0x1(%r15), %rdi
callq 0x3340
testq %rax, %rax
je 0x580b
movq %rax, %r13
leal -0x5(%rbp), %eax
cmpl $0x2, %eax
jb 0x57cf
cmpl $0x1, %ebp
jne 0x5846
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x32f0
movb $0x0, (%r13,%r15)
movq %r13, 0x18(%rbx)
movl %r15d, 0x10(%rbx)
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x5815
movq 0x10(%rax), %rax
cmpl $0x2, (%rax)
jne 0x5827
movq 0x28(%rax), %rax
movslq 0x8(%r14), %rcx
movq %rbx, (%rax,%rcx,8)
jmp 0x5815
movq %rbx, %rdi
callq 0x33f0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3b20(%rip), %rdi      # 0x934e
leaq 0x38bd(%rip), %rsi      # 0x90f2
leaq 0x3ad2(%rip), %rcx      # 0x930e
movl $0x80, %edx
callq 0x31b0
leaq 0x3a59(%rip), %rdi      # 0x92a6
leaq 0x389e(%rip), %rsi      # 0x90f2
leaq 0x3ab3(%rip), %rcx      # 0x930e
movl $0x76, %edx
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O1/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: createArrayObject
static void *createArrayObject(const redisReadTask *task, int elements) {
    redisReply *r, *parent;

    r = createReplyObject(REDIS_REPLY_ARRAY);
    if (r == NULL)
        return NULL;

    if (elements > 0) {
        r->element = calloc(elements,sizeof(redisReply*));
        if (r->element == NULL) {
            freeReplyObject(r);
            return NULL;
        }
    }

    r->elements = elements;

    if (task->parent) {
        parent = task->parent->obj;
        assert(parent->type == REDIS_REPLY_ARRAY);
        parent->element[task->idx] = r;
    }
    return r;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x1, %edi
movl $0x30, %esi
callq 0x3290
testq %rax, %rax
je 0x588d
movq %rax, %rbx
movl $0x2, (%rax)
jmp 0x588f
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x58dc
testl %ebp, %ebp
jle 0x58ad
movl %ebp, %edi
movl $0x8, %esi
callq 0x3290
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x58d4
movslq %ebp, %rax
movq %rax, 0x20(%rbx)
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x58de
movq 0x10(%rax), %rax
cmpl $0x2, (%rax)
jne 0x58e6
movq 0x28(%rax), %rax
movslq 0x8(%r14), %rcx
movq %rbx, (%rax,%rcx,8)
jmp 0x58de
movq %rbx, %rdi
callq 0x33f0
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3a61(%rip), %rdi      # 0x934e
leaq 0x37fe(%rip), %rsi      # 0x90f2
leaq 0x3a75(%rip), %rcx      # 0x9370
movl $0x99, %edx
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O1/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: createIntegerObject
static void *createIntegerObject(const redisReadTask *task, long long value) {
    redisReply *r, *parent;

    r = createReplyObject(REDIS_REPLY_INTEGER);
    if (r == NULL)
        return NULL;

    r->integer = value;

    if (task->parent) {
        parent = task->parent->obj;
        assert(parent->type == REDIS_REPLY_ARRAY);
        parent->element[task->idx] = r;
    }
    return r;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, %edi
movl $0x30, %esi
callq 0x3290
testq %rax, %rax
je 0x592b
movl $0x3, (%rax)
jmp 0x592d
xorl %eax, %eax
testq %rax, %rax
je 0x5956
movq %r14, 0x8(%rax)
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x5958
movq 0x10(%rcx), %rcx
cmpl $0x2, (%rcx)
jne 0x5960
movq 0x28(%rcx), %rcx
movslq 0x8(%rbx), %rdx
movq %rax, (%rcx,%rdx,8)
jmp 0x5958
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x39e7(%rip), %rdi      # 0x934e
leaq 0x3784(%rip), %rsi      # 0x90f2
leaq 0x3a2f(%rip), %rcx      # 0x93a4
movl $0xaa, %edx
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O1/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: createNilObject
static void *createNilObject(const redisReadTask *task) {
    redisReply *r, *parent;

    r = createReplyObject(REDIS_REPLY_NIL);
    if (r == NULL)
        return NULL;

    if (task->parent) {
        parent = task->parent->obj;
        assert(parent->type == REDIS_REPLY_ARRAY);
        parent->element[task->idx] = r;
    }
    return r;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x30, %esi
callq 0x3290
testq %rax, %rax
je 0x599f
movl $0x4, (%rax)
jmp 0x59a1
xorl %eax, %eax
testq %rax, %rax
je 0x59c6
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x59c8
movq 0x10(%rcx), %rcx
cmpl $0x2, (%rcx)
jne 0x59ca
movq 0x28(%rcx), %rcx
movslq 0x8(%rbx), %rdx
movq %rax, (%rcx,%rdx,8)
jmp 0x59c8
xorl %eax, %eax
popq %rbx
retq
leaq 0x397d(%rip), %rdi      # 0x934e
leaq 0x371a(%rip), %rsi      # 0x90f2
leaq 0x3a01(%rip), %rcx      # 0x93e0
movl $0xb9, %edx
callq 0x31b0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x5a07
callq 0x3340
jmp 0x5a11
movl $0x1, %esi
callq 0x3290
movq %rax, %r15
testq %rax, %rax
je 0x5a4f
testq %r14, %r14
sete %al
movl %ebx, (%r15)
movl $0x0, 0x4(%r15)
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x5a43
leaq 0x8(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x32f0
movb $0x0, 0x8(%r15,%rbx)
addq $0x8, %r15
jmp 0x5a52
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3130
movl -0x8(%rbx), %ecx
subl %eax, %ecx
addl %ecx, -0x4(%rbx)
movl %eax, -0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5b39
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 0x33a0
testq %rax, %rax
je 0x5b30
subl %ebx, %r14d
movl %r14d, 0x4(%rax)
addq $0x8, %rax
jmp 0x5b32
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x33a0
movl $0x0, 0x4(%rax)
addq $0x8, %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5b8b
movslq -0x8(%rdi), %rdx
movslq %esi, %rcx
addq %rdx, %rcx
movl %ecx, -0x8(%rdi)
subl %esi, %eax
movl %eax, -0x4(%rdi)
js 0x5baa
movb $0x0, (%rdi,%rcx)
popq %rax
retq
leaq 0x3916(%rip), %rdi      # 0x94a8
leaq 0x3920(%rip), %rsi      # 0x94b9
leaq 0x391f(%rip), %rcx      # 0x94bf
movl $0xcb, %edx
callq 0x31b0
leaq 0x3928(%rip), %rdi      # 0x94d9
leaq 0x3901(%rip), %rsi      # 0x94b9
leaq 0x3900(%rip), %rcx      # 0x94bf
movl $0xce, %edx
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O1/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 0x5c1a
movq %rsi, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31c0
testq %rax, %rax
je 0x5c18
movq %rax, %rbx
addq %rax, %r12
incq %r15
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x31f0
movl -0x8(%rbx), %eax
movl %r14d, -0x8(%rbx)
subl %r14d, %eax
addl %eax, -0x4(%rbx)
jmp 0x5c1a
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/andyfighting[P]hiredis_timer_cmpt/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 0x31c0
testq %rax, %rax
je 0x5c6e
movq %rax, %r14
movq %rax, %rdi
addq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x32f0
addq %rbx, %r12
movl %r12d, -0x8(%r14)
subl %ebx, -0x4(%r14)
movb $0x0, (%r14,%r12)
jmp 0x5c71
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/andyfighting[P]hiredis_timer_cmpt/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 0x5d85
movq %r14, %rsi
subq %rax, %rsi
movq %rbx, %rdi
callq 0x31c0
testq %rax, %rax
je 0x5db4
movq %rax, %rbx
movq %rax, %r13
addq $-0x8, %r13
movl -0x8(%rax), %r12d
addl -0x4(%rax), %r12d
jmp 0x5d89
leaq -0x8(%rbx), %r13
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x32f0
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 0x5da7
// File: /workspace/github_c_makefile_star2_O1/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
movabsq $-0x3333333333333333, %r9 # imm = 0xCCCCCCCCCCCCCCCD
movq %rdi, %rcx
movq %r8, %rax
mulq %r9
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %r8d, %r10d
subl %eax, %r10d
orb $0x30, %r10b
movb %r10b, (%rcx)
incq %rcx
cmpq $0x9, %r8
movq %rdx, %r8
ja 0x5df6
testq %rsi, %rsi
jns 0x5e2a
movb $0x2d, (%rcx)
incq %rcx
movb $0x0, (%rcx)
leaq -0x1(%rcx), %rax
cmpq %rdi, %rax
jbe 0x5e57
leaq 0x1(%rdi), %rdx
movb -0x1(%rdx), %sil
movb (%rax), %r8b
movb %r8b, -0x1(%rdx)
movb %sil, (%rax)
decq %rax
leaq 0x1(%rdx), %rsi
cmpq %rax, %rdx
movq %rsi, %rdx
jb 0x5e3a
subl %edi, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rax
xorl %ecx, %ecx
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
movq %rax, %r9
movq %rsi, %rax
mulq %r8
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %esi, %r10d
subl %eax, %r10d
orb $0x30, %r10b
movb %r10b, 0x1(%r9)
leaq 0x1(%r9), %rax
incl %ecx
cmpq $0x9, %rsi
movq %rdx, %rsi
ja 0x5e6c
movb $0x0, 0x1(%rax)
cmpq %rdi, %rax
jbe 0x5ec3
decq %rax
movb (%rdi), %dl
movb 0x1(%rax), %sil
movb %sil, (%rdi)
movb %dl, 0x1(%rax)
incq %rdi
leaq -0x1(%rax), %rdx
cmpq %rax, %rdi
movq %rdx, %rax
jb 0x5ea8
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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, %rbx
movl $0x10, %r13d
movl $0x10, %edi
callq 0x3340
testq %rax, %rax
je 0x5f4f
movq %rax, %rbp
movq %rbx, 0x8(%rsp)
leaq 0x10(%rsp), %r14
xorl %ebx, %ebx
movb $0x0, -0x2(%rbp,%r13)
movq 0x10(%r15), %rax
movq %rax, 0x20(%rsp)
movups (%r15), %xmm0
movaps %xmm0, 0x10(%rsp)
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x30c0
cmpb $0x0, -0x2(%rbp,%r13)
je 0x5f53
movq %rbp, %rdi
callq 0x3050
addq %r13, %r13
movq %r13, %rdi
callq 0x3340
movq %rax, %rbp
testq %rax, %rax
jne 0x5f01
jmp 0x5f6b
xorl %ebx, %ebx
jmp 0x5f6b
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x3380
movq %rax, %rbx
movq %rbp, %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_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movslq -0x8(%rdi), %rax
leaq (%rdi,%rax), %r12
decq %r12
movq %rdi, %r14
cmpq %rdi, %r12
jb 0x645d
movq %rbx, %r14
movsbl (%r14), %esi
movq %r15, %rdi
callq 0x3170
testq %rax, %rax
je 0x645d
incq %r14
cmpq %r12, %r14
jbe 0x6444
cmpq %rbx, %r12
jbe 0x647f
movsbl (%r12), %esi
movq %r15, %rdi
callq 0x3170
testq %rax, %rax
je 0x647f
decq %r12
cmpq %rbx, %r12
ja 0x6462
movq %rbx, %r12
xorl %r15d, %r15d
subq %r14, %r12
leaq 0x1(%r12), %rax
cmovaeq %rax, %r15
cmpq %rbx, %r14
je 0x64a1
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3410
movb $0x0, (%rbx,%r15)
movl -0x4(%rbx), %eax
subl %r15d, %eax
addl -0x8(%rbx), %eax
movl %eax, -0x4(%rbx)
movl %r15d, -0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/andyfighting[P]hiredis_timer_cmpt/sds.c
// Function: sdsrange
void sdsrange(sds s, int start, int end) {
    struct sdshdr *sh = (void*) (s-sizeof *sh);
    size_t newlen, len = sdslen(s);

    if (len == 0) return;
    if (start < 0) {
        start = len+start;
        if (start < 0) start = 0;
    }
    if (end < 0) {
        end = len+end;
        if (end < 0) end = 0;
    }
    newlen = (start > end) ? 0 : (end-start)+1;
    if (newlen != 0) {
        if (start >= (signed)len) {
            newlen = 0;
        } else if (end >= (signed)len) {
            end = len-1;
            newlen = (start > end) ? 0 : (end-start)+1;
        }
    } else {
        start = 0;
    }
    if (start && newlen) memmove(sh->buf, sh->buf+start, newlen);
    sh->buf[newlen] = 0;
    sh->free = sh->free+(sh->len-newlen);
    sh->len = newlen;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl -0x8(%rdi), %edi
testl %edi, %edi
je 0x6554
leal (%rdi,%rsi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
testl %esi, %esi
cmovnsl %esi, %eax
leal (%rdi,%rdx), %esi
testl %esi, %esi
cmovlel %ecx, %esi
testl %edx, %edx
cmovnsl %edx, %esi
movl %esi, %edx
subl %eax, %edx
leal 0x1(%rdx), %edx
cmovbl %ecx, %edx
testl %edx, %edx
je 0x650d
movl %edi, %ecx
subl %eax, %ecx
jle 0x6512
cmpl %edi, %esi
jge 0x6517
movslq %edx, %r14
jmp 0x6523
xorl %r14d, %r14d
jmp 0x6525
xorl %r14d, %r14d
jmp 0x6523
decl %edi
xorl %edx, %edx
cmpl %edi, %eax
cmovgl %edx, %ecx
movslq %ecx, %r14
movl %eax, %ecx
testl %ecx, %ecx
je 0x653f
testq %r14, %r14
je 0x653f
movslq %ecx, %rsi
addq %rbx, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3410
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 %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3260
testl %eax, %eax
cmovel %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x67d5
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x67c6
movslq %esi, %r14
movq -0x8(%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x67c1
addq $-0x8, %rdi
callq 0x3050
decq %r14
jne 0x67ae
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3050
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rcx
negq %rcx
cmovsq %rdi, %rcx
movl $0x7, %r15d
xorl %r12d, %r12d
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %rax
mulq %rsi
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %ecx, %r8d
subl %eax, %r8d
orb $0x30, %r8b
movb %r8b, 0x1f(%rsp,%r12)
decq %r12
incq %r15
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0x6800
movq $-0x1, %r13
testq %rdi, %rdi
jns 0x6847
movb $0x2d, 0x1f(%rsp,%r12)
movq $-0x2, %r13
leaq (%r12,%r13), %rbx
movl $0x8, %edi
subq %rbx, %rdi
callq 0x3340
testq %rax, %rax
je 0x68a3
movq %rax, %r14
movq %r13, %rax
notq %rax
movl %r13d, %ecx
notl %ecx
subl %r12d, %ecx
movl %ecx, (%r14)
movl $0x0, 0x4(%r14)
cmpq %r12, %rax
je 0x6895
leaq (%rsp,%rbx), %rsi
addq $0x21, %rsi
notq %rbx
leaq 0x8(%r14), %rdi
movq %rbx, %rdx
callq 0x32f0
leaq 0x8(%r14), %rax
subq %r13, %r14
movb $0x0, (%r15,%r14)
jmp 0x68a5
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movslq -0x8(%rdi), %r15
movl $0x1, %esi
callq 0x31c0
testq %rax, %rax
je 0x68f1
movq %rax, %rbp
movb $0x22, (%rax,%r15)
leaq 0x1(%r15), %rax
movl %eax, -0x8(%rbp)
decl -0x4(%rbp)
movb $0x0, 0x1(%rbp,%r15)
jmp 0x68f3
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x6a52
xorl %r15d, %r15d
movsbl (%r14,%r15), %r12d
movzbl %r12b, %r13d
leal -0x7(%r13), %eax
cmpl $0x6, %eax
ja 0x694a
leaq 0x2b04(%rip), %rcx      # 0x941c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movslq -0x8(%rbp), %r12
movl $0x2, %esi
movq %rbp, %rdi
callq 0x31c0
testq %rax, %rax
je 0x6a2b
movq %rax, %rbp
movw $0x615c, (%rax,%r12)    # imm = 0x615C
jmp 0x6a17
cmpl $0x5c, %r13d
je 0x6956
cmpl $0x22, %r13d
jne 0x6965
movq %rbp, %rdi
leaq 0x2b87(%rip), %rsi      # 0x94e7
jmp 0x6a39
callq 0x3520
movq (%rax), %rax
movslq %r12d, %rcx
testb $0x40, 0x1(%rax,%rcx,2)
jne 0x6a2f
movq %rbp, %rdi
leaq 0x2b66(%rip), %rsi      # 0x94eb
movl %r13d, %edx
jmp 0x6a3c
movslq -0x8(%rbp), %r12
movl $0x2, %esi
movq %rbp, %rdi
callq 0x31c0
testq %rax, %rax
je 0x6a2b
movq %rax, %rbp
movw $0x625c, (%rax,%r12)    # imm = 0x625C
jmp 0x6a17
movslq -0x8(%rbp), %r12
movl $0x2, %esi
movq %rbp, %rdi
callq 0x31c0
testq %rax, %rax
je 0x6a2b
movq %rax, %rbp
movw $0x745c, (%rax,%r12)    # imm = 0x745C
jmp 0x6a17
movslq -0x8(%rbp), %r12
movl $0x2, %esi
movq %rbp, %rdi
callq 0x31c0
testq %rax, %rax
je 0x6a2b
movq %rax, %rbp
movw $0x6e5c, (%rax,%r12)    # imm = 0x6E5C
jmp 0x6a17
movslq -0x8(%rbp), %r12
movl $0x2, %esi
movq %rbp, %rdi
callq 0x31c0
testq %rax, %rax
je 0x6a2b
movq %rax, %rbp
movw $0x725c, (%rax,%r12)    # imm = 0x725C
leaq 0x2(%r12), %rax
movl %eax, -0x8(%rbp)
addl $-0x2, -0x4(%rbp)
movb $0x0, 0x2(%rbp,%r12)
jmp 0x6a46
xorl %ebp, %ebp
jmp 0x6a46
movq %rbp, %rdi
leaq 0x2aaf(%rip), %rsi      # 0x94e8
movl %r12d, %edx
xorl %eax, %eax
callq 0x3140
movq %rax, %rbp
incq %r15
cmpq %r15, %rbx
jne 0x68ff
movslq -0x8(%rbp), %rbx
movl $0x1, %esi
movq %rbp, %rdi
callq 0x31c0
testq %rax, %rax
je 0x6a7d
movb $0x22, (%rax,%rbx)
leaq 0x1(%rbx), %rcx
movl %ecx, -0x8(%rax)
decl -0x4(%rax)
movb $0x0, 0x1(%rax,%rbx)
jmp 0x6a7f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/andyfighting[P]hiredis_timer_cmpt/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 0x6acb
leaq 0x297c(%rip), %rdx      # 0x9438
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl $0x1, %eax
retq
addl $-0x61, %edi
cmpl $0x5, %edi
ja 0x6b06
leaq 0x29b6(%rip), %rax      # 0x9490
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0xa, %eax
retq
movl $0xd, %eax
retq
movl $0xc, %eax
retq
movl $0xe, %eax
retq
movl $0xb, %eax
retq
movl $0xf, %eax
retq
movl $0x3, %eax
retq
movl $0x5, %eax
retq
movl $0x2, %eax
retq
movl $0x9, %eax
retq
movl $0x8, %eax
retq
movl $0x7, %eax
retq
movl $0x4, %eax
retq
movl $0x6, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rdi, %rdi
je 0x6ffc
xorl %r8d, %r8d
testq %rcx, %rcx
je 0x6ff4
movb (%rax,%r8), %r9b
xorl %r10d, %r10d
cmpb (%rsi,%r10), %r9b
je 0x6fec
incq %r10
cmpq %r10, %rcx
jne 0x6fdc
jmp 0x6ff4
movb (%rdx,%r10), %r9b
movb %r9b, (%rax,%r8)
incq %r8
cmpq %rdi, %r8
jne 0x6fd0
retq
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, 0x8(%rsp)
movl %esi, %r13d
movq %rdi, %r15
movl $0x9, %edi
callq 0x3340
testq %rax, %rax
je 0x703c
movq %rax, %r12
addq $0x8, %r12
movb $0x0, 0x8(%rax)
movq $0x0, (%rax)
jmp 0x703f
xorl %r12d, %r12d
testl %r13d, %r13d
jle 0x70ce
movq %rbx, 0x10(%rsp)
leal -0x1(%r13), %ebp
movl %r13d, %r13d
xorl %r14d, %r14d
movq %r13, (%rsp)
movq 0x10(%rsp), %rbx
movq (%r15,%r14,8), %rsi
movq %r12, %rdi
callq 0x3380
movq %rax, %r12
cmpq %r14, %rbp
je 0x70c6
movq %rbp, %r13
movq %r15, %rbp
movslq -0x8(%r12), %r15
movq %r12, %rdi
movq %rbx, %rsi
callq 0x31c0
testq %rax, %rax
je 0x70b9
movq %rax, %r12
movq %rax, %rdi
addq %r15, %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0x32f0
addq %rbx, %r15
movl %r15d, -0x8(%r12)
subl %ebx, -0x4(%r12)
movb $0x0, (%r12,%r15)
jmp 0x70bc
xorl %r12d, %r12d
movq %rbp, %r15
movq %r13, %rbp
movq (%rsp), %r13
incq %r14
cmpq %r14, %r13
jne 0x7060
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/andyfighting[P]hiredis_timer_cmpt/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
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, 0x8(%rsp)
movl %esi, %r13d
movq %rdi, %r15
movl $0x9, %edi
callq 0x3340
testq %rax, %rax
je 0x711f
movq %rax, %r12
addq $0x8, %r12
movb $0x0, 0x8(%rax)
movq $0x0, (%rax)
jmp 0x7122
xorl %r12d, %r12d
testl %r13d, %r13d
jle 0x71b1
movq %rbx, 0x10(%rsp)
leal -0x1(%r13), %ebp
movl %r13d, %r13d
xorl %r14d, %r14d
movq %r13, (%rsp)
movq 0x10(%rsp), %rbx
movq (%r15,%r14,8), %rsi
movq %r12, %rdi
callq 0x3480
movq %rax, %r12
cmpq %r14, %rbp
je 0x71a9
movq %rbp, %r13
movq %r15, %rbp
movslq -0x8(%r12), %r15
movq %r12, %rdi
movq %rbx, %rsi
callq 0x31c0
testq %rax, %rax
je 0x719c
movq %rax, %r12
movq %rax, %rdi
addq %r15, %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0x32f0
addq %rbx, %r15
movl %r15d, -0x8(%r12)
subl %ebx, -0x4(%r12)
movb $0x0, (%r12,%r15)
jmp 0x719f
xorl %r12d, %r12d
movq %rbp, %r15
movq %r13, %rbp
movq (%rsp), %r13
incq %r14
cmpq %r14, %r13
jne 0x7143
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x3390
testq %rax, %rax
je 0x71ff
movq %rax, %rbx
movq %rax, %rdi
callq 0x7203
testq %rax, %rax
je 0x71f7
movl (%rax), %ecx
movl %ecx, 0xd0(%rax)
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0xd8(%rax)
jmp 0x7201
movq %rbx, %rdi
callq 0x3320
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/andyfighting[P]hiredis_timer_cmpt/async.c
// Function: redisAsyncInitialize
static redisAsyncContext *redisAsyncInitialize(redisContext *c) {
    redisAsyncContext *ac;

    ac = realloc(c,sizeof(redisAsyncContext));
    if (ac == NULL)
        return NULL;

    c = &(ac->c);

    /* The regular connect functions will always set the flag REDIS_CONNECTED.
     * For the async API, we want to wait until the first write event is
     * received up before setting this flag, so reset it here. */
    c->flags &= ~REDIS_CONNECTED;

    ac->err = 0;
    ac->errstr = NULL;
    ac->data = NULL;

    ac->ev.data = NULL;
    ac->ev.addRead = NULL;
    ac->ev.delRead = NULL;
    ac->ev.addWrite = NULL;
    ac->ev.delWrite = NULL;
    ac->ev.cleanup = NULL;

    ac->onConnect = NULL;
    ac->onDisconnect = NULL;

    ac->replies.head = NULL;
    ac->replies.tail = NULL;
    ac->sub.invalid.head = NULL;
    ac->sub.invalid.tail = NULL;
    ac->sub.channels = dictCreate(&callbackDict,NULL);
    ac->sub.patterns = dictCreate(&callbackDict,NULL);
    return ac;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl $0x158, %esi            # imm = 0x158
callq 0x33a0
testq %rax, %rax
je 0x72b2
movq %rax, %rbx
andb $-0x3, 0x88(%rax)
movl $0x0, 0xd0(%rax)
movl $0x30, %edi
callq 0x3340
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%rbx)
movups %xmm0, 0xe8(%rbx)
movups %xmm0, 0xf8(%rbx)
movups %xmm0, 0x108(%rbx)
movups %xmm0, 0x118(%rbx)
movups %xmm0, 0x128(%rbx)
movups %xmm0, 0x138(%rbx)
xorl %r14d, %r14d
movq %r14, (%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
leaq 0x605e(%rip), %r15      # 0xd2e0
movq %r15, 0x8(%rax)
movq %rax, 0x148(%rbx)
movl $0x30, %edi
callq 0x3340
movq %r14, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movq %r15, 0x8(%rax)
movq %rax, 0x150(%rbx)
jmp 0x72b4
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3330
movq %rax, %rdi
callq 0x7203
testq %rax, %rax
je 0x72e6
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_O1/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 0x3300
movq %rax, %rdi
callq 0x7203
testq %rax, %rax
je 0x7311
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_O1/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 0x33b0
testq %rax, %rax
je 0x734e
movq %rax, %rbx
movq %rax, %rdi
callq 0x7203
testq %rax, %rax
je 0x7346
movl (%rax), %ecx
movl %ecx, 0xd0(%rax)
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0xd8(%rax)
jmp 0x7350
movq %rbx, %rdi
callq 0x3320
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpq $0x0, 0x120(%rdi)
jne 0x7380
movq %rsi, 0x120(%rdi)
movq 0x100(%rdi), %rax
xorl %ebx, %ebx
testq %rax, %rax
je 0x7380
movq 0xe8(%rdi), %rdi
callq *%rax
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x75f1
movl (%rbx), %eax
movl %eax, 0xd0(%rbx)
leaq 0x4(%rbx), %rax
movq %rax, 0xd8(%rbx)
cmpl $0x0, 0xd0(%rbx)
je 0x7603
orb $0x4, 0x88(%rbx)
jmp 0x763a
movq 0x128(%rbx), %r14
testq %r14, %r14
je 0x763a
movq (%r14), %rax
movq %rax, 0x128(%rbx)
cmpq 0x130(%rbx), %r14
jne 0x762d
movq $0x0, 0x130(%rbx)
movq %r14, %rdi
callq 0x3050
testq %r14, %r14
jne 0x7649
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x73b4
leaq 0x1f35(%rip), %rdi      # 0x9585
leaq 0x1ef6(%rip), %rsi      # 0x954d
leaq 0x1f5c(%rip), %rcx      # 0x95ba
movl $0x153, %edx            # imm = 0x153
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x18, %edi
callq 0x3340
testq %rax, %rax
je 0x7b0d
testq %r14, %r14
je 0x7af4
movups (%r14), %xmm0
movups %xmm0, (%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rax)
movq $0x0, (%rax)
cmpq $0x0, (%rbx)
jne 0x7afd
movq %rax, (%rbx)
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x7b09
movq %rax, (%rcx)
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7b39
movq %rbx, %rdi
callq 0x7b6d
testl %eax, %eax
jne 0x7b37
testb $0x2, 0x88(%rbx)
jne 0x7b39
popq %rbx
retq
movq %rbx, %rdi
callq 0x3450
cmpl $-0x1, %eax
je 0x7b64
movq 0xf0(%rbx), %rax
testq %rax, %rax
je 0x7b5b
movq 0xe8(%rbx), %rdi
callq *%rax
movq %rbx, %rdi
popq %rbx
jmp 0x3210
movq %rbx, %rdi
popq %rbx
jmp 0x75d2
// File: /workspace/github_c_makefile_star2_O1/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 0x3150
cmpl $-0x1, %eax
je 0x7b9b
orb $0x2, 0x88(%rbx)
movq 0x120(%rbx), %rax
testq %rax, %rax
je 0x7ba5
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq *%rax
jmp 0x7bcc
callq 0x3080
cmpl $0x73, (%rax)
jne 0x7ba9
xorl %ebp, %ebp
jmp 0x7bcc
movq 0x120(%rbx), %rax
testq %rax, %rax
je 0x7bbf
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq *%rax
movq %rbx, %rdi
callq 0x75d2
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdi, %rbx
movl $0x0, 0xc(%rsp)
testb $0x2, 0x88(%rdi)
jne 0x7c03
movq %rbx, %rdi
callq 0x7b6d
testl %eax, %eax
jne 0x7c59
testb $0x2, 0x88(%rbx)
je 0x7c59
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x3110
cmpl $-0x1, %eax
je 0x7c25
cmpl $0x0, 0xc(%rsp)
je 0x7c2f
movq 0x108(%rbx), %rax
jmp 0x7c36
movq %rbx, %rdi
callq 0x75d2
jmp 0x7c59
movq 0x100(%rbx), %rax
testq %rax, %rax
je 0x7c44
movq 0xe8(%rbx), %rdi
callq *%rax
movq 0xf0(%rbx), %rax
testq %rax, %rax
je 0x7c59
movq 0xe8(%rbx), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x34f0
testl %eax, %eax
js 0x7ca9
movq 0x8(%rsp), %rcx
movl %eax, %r8d
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7cba
movl %eax, %ebx
movq 0x8(%rsp), %rdi
callq 0x3050
jmp 0x7cae
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/andyfighting[P]hiredis_timer_cmpt/async.c
// Function: redisAsyncCommand
int redisAsyncCommand(redisAsyncContext *ac, redisCallbackFn *fn, void *privdata, const char *format, ...) {
    va_list ap;
    int status;
    va_start(ap,format);
    status = redisvAsyncCommand(ac,fn,privdata,format,ap);
    va_end(ap);
    return status;
}

// Assembly:
subq $0xd8, %rsp
leaq 0x20(%rsp), %r10
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x7ef3
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r8
movq %r10, 0x10(%r8)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%r8)
movabsq $0x3000000020, %rax     # imm = 0x3000000020
movq %rax, (%r8)
callq 0x31e0
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x31d0
movq (%r12), %rcx
movslq %eax, %r8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7cba
movl %eax, %ebx
movq (%r12), %rdi
callq 0x3280
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x18, %edi
callq 0x3340
movups (%rbx), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpq $0x0, 0x10(%rdi)
je 0x7ffe
leaq 0x18(%rdi), %rax
jmp 0x8017
movslq 0x8(%rdi), %rax
incq %rax
movl %eax, 0x8(%rdi)
movq (%rdi), %rcx
cmpl 0x10(%rcx), %eax
jge 0x802c
shlq $0x3, %rax
addq (%rcx), %rax
movq (%rax), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x7ffe
movq 0x10(%rax), %rcx
movq %rcx, 0x18(%rdi)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8127
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rax
movq %rsi, %rdi
callq *(%rax)
andl 0x18(%r15), %eax
movq (%r15), %rcx
movq (%rcx,%rax,8), %rbx
testq %rbx, %rbx
je 0x8127
movq 0x8(%r15), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x811c
movq 0x28(%r15), %rdi
movq (%rbx), %rdx
movq %r14, %rsi
callq *%rax
testl %eax, %eax
je 0x8121
jmp 0x8129
cmpq %r14, (%rbx)
je 0x8129
movq 0x10(%rbx), %rbx
jmp 0x80f8
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq