LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/ziplist.c
// Function: zipEntry
void zipEntry(unsigned char *p, zlentry *e) {

    ZIP_DECODE_PREVLEN(p, e->prevrawlensize, e->prevrawlen);
    ZIP_DECODE_LENGTH(p + e->prevrawlensize, e->encoding, e->lensize, e->len);
    e->headersize = e->prevrawlensize + e->lensize;
    e->p = p;
}

// Assembly:
movb (%rdi), %al
xorl %ecx, %ecx
cmpb $-0x2, %al
setae %cl
leal 0x1(,%rcx,4), %eax
movl %eax, (%rsi)
jb 0x3ad7b
movl 0x1(%rdi), %ecx
jmp 0x3ad7e
movzbl (%rdi), %ecx
movl %ecx, 0x4(%rsi)
movl %eax, %ecx
movzbl (%rdi,%rcx), %edx
movl %edx, %r8d
andb $-0x40, %r8b
movzbl %r8b, %r8d
cmpl $0xc0, %edx
cmovael %edx, %r8d
movb %r8b, 0x14(%rsi)
jae 0x3adcf
shrl $0x6, %edx
xorl $0x2, %edx
leaq 0x84e01(%rip), %r8      # 0xbfbb0
movslq (%r8,%rdx,4), %rdx
addq %r8, %rdx
jmpq *%rdx
movl $0x5, 0x8(%rsi)
movl 0x1(%rdi,%rcx), %edx
bswapl %edx
movl $0x5, %ecx
jmp 0x3ae68
movl $0x1, 0x8(%rsi)
movl $0x1, %ecx
cmpl $0xdf, %edx
jle 0x3ae02
cmpl $0xe0, %edx
je 0x3ae51
cmpl $0xf0, %edx
je 0x3ae58
cmpl $0xfe, %edx
jne 0x3ae66
movl $0x1, %edx
jmp 0x3ae68
cmpl $0xc0, %edx
je 0x3ae5f
cmpl $0xd0, %edx
jne 0x3ae66
movl $0x4, %edx
jmp 0x3ae68
movl $0x1, 0x8(%rsi)
movzbl (%rdi,%rcx), %edx
andl $0x3f, %edx
movl $0x1, %ecx
jmp 0x3ae68
movl $0x2, 0x8(%rsi)
movzbl (%rdi,%rcx), %r8d
andl $0x3f, %r8d
shll $0x8, %r8d
movzbl 0x1(%rdi,%rcx), %edx
orl %r8d, %edx
movl $0x2, %ecx
jmp 0x3ae68
movl $0x8, %edx
jmp 0x3ae68
movl $0x3, %edx
jmp 0x3ae68
movl $0x2, %edx
jmp 0x3ae68
xorl %edx, %edx
movl %edx, 0xc(%rsi)
addl %eax, %ecx
movl %ecx, 0x10(%rsi)
movq %rdi, 0x18(%rsi)
retq
pushq %rax
leaq 0x88956(%rip), %rdi     # 0xc37d3
leaq 0x84d3c(%rip), %rsi     # 0xbfbc0
movl $0x1a4, %edx            # imm = 0x1A4
callq 0x61908
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/ziplist.c
// Function: ziplistNew
unsigned char *ziplistNew(void) {
    unsigned int bytes = ZIPLIST_HEADER_SIZE+1;
    unsigned char *zl = zmalloc(bytes);
    ZIPLIST_BYTES(zl) = intrev32ifbe(bytes);
    ZIPLIST_TAIL_OFFSET(zl) = intrev32ifbe(ZIPLIST_HEADER_SIZE);
    ZIPLIST_LENGTH(zl) = 0;
    zl[bytes-1] = ZIP_END;
    return zl;
}

// Assembly:
pushq %rax
movl $0xb, %edi
callq 0x382d1
movabsq $0xa0000000b, %rcx      # imm = 0xA0000000B
movq %rcx, (%rax)
movw $0x0, 0x8(%rax)
movb $-0x1, 0xa(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/ziplist.c
// Function: ziplistResize
unsigned char *ziplistResize(unsigned char *zl, unsigned int len) {
    zl = zrealloc(zl,len);
    ZIPLIST_BYTES(zl) = intrev32ifbe(len);
    zl[len-1] = ZIP_END;
    return zl;
}

// Assembly:
pushq %rbx
movl %esi, %ebx
movl %esi, %esi
callq 0x3837d
movl %ebx, (%rax)
decl %ebx
movb $-0x1, (%rax,%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/ziplist.c
// Function: ziplistIndex
unsigned char *ziplistIndex(unsigned char *zl, int index) {
    unsigned char *p;
    unsigned int prevlensize, prevlen = 0;
    if (index < 0) {
        index = (-index)-1;
        p = ZIPLIST_ENTRY_TAIL(zl);
        if (p[0] != ZIP_END) {
            ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);
            while (prevlen > 0 && index--) {
                p -= prevlen;
                ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);
            }
        }
    } else {
        p = ZIPLIST_ENTRY_HEAD(zl);
        while (p[0] != ZIP_END && index--) {
            p += zipRawEntryLength(p);
        }
    }
    return (p[0] == ZIP_END || index > 0) ? NULL : p;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %rax
testl %esi, %esi
js 0x3b6ce
movb 0xa(%rax), %cl
addq $0xa, %rax
movb $-0x1, %bpl
cmpb $-0x1, %cl
je 0x3b730
testl %ebx, %ebx
je 0x3b6c5
decl %ebx
movq %rax, %r14
movq %rax, %rdi
callq 0x3aaf1
movl %eax, %ecx
leaq (%r14,%rcx), %rax
movb (%r14,%rcx), %cl
cmpb $-0x1, %cl
je 0x3b730
addl $-0x1, %ebx
jb 0x3b6a6
movl %ecx, %ebp
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x3b730
movl %ebx, %edx
notl %edx
movl 0x4(%rax), %esi
leaq (%rax,%rsi), %rcx
movzbl (%rax,%rsi), %ebp
cmpl $0xfe, %ebp
je 0x3b6f1
movl %ebp, %eax
cmpl $0xff, %ebp
je 0x3b72b
jmp 0x3b6f4
movl 0x1(%rcx), %eax
testl %eax, %eax
je 0x3b72b
cmpl $-0x1, %ebx
je 0x3b724
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
subl %ebx, %edx
movl %edx, %ebx
movl %eax, %eax
subq %rax, %rcx
movzbl (%rcx), %ebp
movl %ebp, %eax
cmpl $0xfd, %ebp
jbe 0x3b71b
movl 0x1(%rcx), %eax
testl %eax, %eax
je 0x3b72d
addl $-0x1, %ebx
jb 0x3b706
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x3b72d
movl %edx, %ebx
movq %rcx, %rax
xorl %ecx, %ecx
testl %ebx, %ebx
cmovgq %rcx, %rax
cmpb $-0x1, %bpl
cmoveq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/ziplist.c
// Function: ziplistPrev
unsigned char *ziplistPrev(unsigned char *zl, unsigned char *p) {
    unsigned int prevlensize, prevlen = 0;

    /* Iterating backwards from ZIP_END should return the tail. When "p" is
     * equal to the first element of the list, we're already at the head,
     * and should return NULL. */
    if (p[0] == ZIP_END) {
        p = ZIPLIST_ENTRY_TAIL(zl);
        return (p[0] == ZIP_END) ? NULL : p;
    } else if (p == ZIPLIST_ENTRY_HEAD(zl)) {
        return NULL;
    } else {
        ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);
        assert(prevlen > 0);
        return p-prevlen;
    }
}

// Assembly:
movzbl (%rsi), %eax
cmpl $0xff, %eax
je 0x3b793
addq $0xa, %rdi
cmpq %rsi, %rdi
je 0x3b7a6
cmpl $0xfe, %eax
jne 0x3b788
movl 0x1(%rsi), %eax
testl %eax, %eax
je 0x3b7ac
movl %eax, %eax
subq %rax, %rsi
jmp 0x3b7a8
movl 0x4(%rdi), %eax
leaq (%rdi,%rax), %rcx
xorl %esi, %esi
cmpb $-0x1, (%rdi,%rax)
cmovneq %rcx, %rsi
jmp 0x3b7a8
xorl %esi, %esi
movq %rsi, %rax
retq
pushq %rax
leaq 0x84416(%rip), %rdi     # 0xbfbca
leaq 0x84405(%rip), %rsi     # 0xbfbc0
movl $0x364, %edx            # imm = 0x364
callq 0x61908
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/ziplist.c
// Function: ziplistGet
unsigned int ziplistGet(unsigned char *p, unsigned char **sstr, unsigned int *slen, long long *sval) {
    zlentry entry;
    if (p == NULL || p[0] == ZIP_END) return 0;
    if (sstr) *sstr = NULL;

    zipEntry(p, &entry);
    if (ZIP_IS_STR(entry.encoding)) {
        if (sstr) {
            *slen = entry.len;
            *sstr = p+entry.headersize;
        }
    } else {
        if (sval) {
            *sval = zipLoadInteger(p+entry.headersize,entry.encoding);
        }
    }
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x3b876
movq %rdi, %r14
cmpb $-0x1, (%rdi)
je 0x3b876
movq %rcx, %rbx
movq %rsi, %r15
testq %rsi, %rsi
je 0x3b83a
movq %rdx, %r12
movq $0x0, (%r15)
leaq 0x8(%rsp), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x3ad62
movb 0x14(%r13), %al
cmpb $-0x41, %al
ja 0x3b857
movl 0x14(%rsp), %eax
movl %eax, (%r12)
movl 0x18(%rsp), %eax
addq %rax, %r14
movq %r14, (%r15)
movl $0x1, %ebp
jmp 0x3b876
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3ad62
movb 0x14(%r15), %al
movl $0x1, %ebp
cmpb $-0x41, %al
jbe 0x3b876
movl $0x1, %ebp
testq %rbx, %rbx
je 0x3b876
movl 0x18(%rsp), %ecx
addq %rcx, %r14
movzbl %al, %esi
movq %r14, %rdi
callq 0x3acda
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/ziplist.c
// Function: ziplistDelete
unsigned char *ziplistDelete(unsigned char *zl, unsigned char **p) {
    size_t offset = *p-zl;
    zl = __ziplistDelete(zl,*p,1);

    /* Store pointer to current element in p, because ziplistDelete will
     * do a realloc which might result in a different "zl"-pointer.
     * When the delete direction is back to front, we might delete the last
     * entry and end up with "p" pointing to ZIP_END, so check this. */
    *p = zl+offset;
    return zl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rsi
movq %rsi, %r14
subq %rdi, %r14
movl $0x1, %edx
callq 0x3b04c
addq %rax, %r14
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/ziplist.c
// Function: ziplistCompare
unsigned int ziplistCompare(unsigned char *p, unsigned char *sstr, unsigned int slen) {
    zlentry entry;
    unsigned char sencoding;
    long long zval, sval;
    if (p[0] == ZIP_END) return 0;

    zipEntry(p, &entry);
    if (ZIP_IS_STR(entry.encoding)) {
        /* Raw compare */
        if (entry.len == slen) {
            return memcmp(p+entry.headersize,sstr,slen) == 0;
        } else {
            return 0;
        }
    } else {
        /* Try to compare encoded values. Don't compare encoding because
         * different implementations may encoded integers differently. */
        if (zipTryEncoding(sstr,slen,&sval,&sencoding)) {
          zval = zipLoadInteger(p+entry.headersize,entry.encoding);
          return zval == sval;
        }
    }
    return 0;
}

// Assembly:
cmpb $-0x1, (%rdi)
je 0x3b946
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, %rsi
callq 0x3ad62
movb 0x14(%r15), %r15b
cmpb $-0x41, %r15b
jbe 0x3b94a
leaq 0x10(%rsp), %rdx
leaq 0xf(%rsp), %rcx
movq %r14, %rdi
movl %ebp, %esi
callq 0x3abdf
testl %eax, %eax
je 0x3b96b
movl 0x28(%rsp), %eax
addq %rax, %rbx
movzbl %r15b, %esi
movq %rbx, %rdi
callq 0x3acda
cmpq 0x10(%rsp), %rax
jmp 0x3b966
xorl %eax, %eax
jmp 0x3b977
cmpl %ebp, 0x24(%rsp)
jne 0x3b96b
movl 0x28(%rsp), %eax
addq %rax, %rbx
movl %ebp, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x266f0
testl %eax, %eax
sete %al
jmp 0x3b96d
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/ziplist.c
// Function: ziplistLen
unsigned int ziplistLen(unsigned char *zl) {
    unsigned int len = 0;
    if (intrev16ifbe(ZIPLIST_LENGTH(zl)) < UINT16_MAX) {
        len = intrev16ifbe(ZIPLIST_LENGTH(zl));
    } else {
        unsigned char *p = zl+ZIPLIST_HEADER_SIZE;
        while (*p != ZIP_END) {
            p += zipRawEntryLength(p);
            len++;
        }

        /* Re-store length if small enough */
        if (len < UINT16_MAX) ZIPLIST_LENGTH(zl) = intrev16ifbe(len);
    }
    return len;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movzwl 0x8(%rdi), %ebp
cmpl $0xffff, %ebp           # imm = 0xFFFF
jne 0x3bbbe
movq %rdi, %rbx
cmpb $-0x1, 0xa(%rdi)
je 0x3bbb8
leaq 0xa(%rbx), %r14
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x3aaf1
movl %eax, %eax
incl %ebp
cmpb $-0x1, (%r14,%rax)
leaq (%r14,%rax), %r14
jne 0x3bb97
cmpl $0xfffe, %ebp           # imm = 0xFFFE
jbe 0x3bbba
jmp 0x3bbbe
xorl %ebp, %ebp
movw %bp, 0x8(%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: getStringObjectSdsUsedMemory
size_t getStringObjectSdsUsedMemory(robj *o) {
    serverAssertWithInfo(NULL,o,o->type == OBJ_STRING);
    switch(o->encoding) {
    case OBJ_ENCODING_RAW: return sdsZmallocSize(o->ptr);
    case OBJ_ENCODING_EMBSTR: return zmalloc_size(o)-sizeof(robj);
    default: return 0; /* Just integer encoding for now. */
    }
}

// Assembly:
pushq %rax
movq %rdi, %rsi
movl (%rdi), %eax
testb $0xf, %al
jne 0x3bd9c
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
je 0x3bd8a
testl %eax, %eax
jne 0x3bd98
movq 0x8(%rsi), %rdi
callq 0x367fe
movq %rax, %rdi
popq %rax
jmp 0xa28e0
movq %rsi, %rdi
callq 0xa28e0
addq $-0x10, %rax
jmp 0x3bd9a
xorl %eax, %eax
popq %rcx
retq
leaq 0x8419d(%rip), %rdx     # 0xbff40
leaq 0x841ac(%rip), %rcx     # 0xbff56
xorl %edi, %edi
movl $0x2f, %r8d
callq 0x627c3
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: prepareClientToWrite
int prepareClientToWrite(client *c) {
    /* If it's the Lua client we always return ok without installing any
     * handler since there is no socket at all. */
    if (c->flags & CLIENT_LUA) return C_OK;

    /* CLIENT REPLY OFF / SKIP handling: don't send replies. */
    if (c->flags & (CLIENT_REPLY_OFF|CLIENT_REPLY_SKIP)) return C_ERR;

    /* Masters don't receive replies, unless CLIENT_MASTER_FORCE_REPLY flag
     * is set. */
    if ((c->flags & CLIENT_MASTER) &&
        !(c->flags & CLIENT_MASTER_FORCE_REPLY)) return C_ERR;

    if (c->fd <= 0) return C_ERR; /* Fake client for AOF loading. */

    /* Schedule the client to write the output buffers to the socket only
     * if not already done (there were no pending writes already and the client
     * was yet not flagged), and, for slaves, if the slave can actually
     * receive writes at this stage. */
    if (!clientHasPendingReplies(c) &&
        !(c->flags & CLIENT_PENDING_WRITE) &&
        (c->replstate == REPL_STATE_NONE ||
         (c->replstate == SLAVE_STATE_ONLINE && !c->repl_put_online_on_ack)))
    {
        /* Here instead of installing the write handler, we just flag the
         * client and put it into a list of clients that have something
         * to write to the socket. This way before re-entering the event
         * loop, we can try to directly write to the client sockets avoiding
         * a system call. We'll only really install the write handler if
         * we'll not be able to write the whole reply at once. */
        c->flags |= CLIENT_PENDING_WRITE;
        listAddNodeHead(server.clients_pending_write,c);
    }

    /* Authorize the caller to queue in the output buffer of this client. */
    return C_OK;
}

// Assembly:
movl 0x98(%rdi), %ecx
btl $0x8, %ecx
jb 0x3c24b
testl $0x1400000, %ecx        # imm = 0x1400000
setne %al
movl %ecx, %edx
andl $0x2002, %edx           # imm = 0x2002
cmpl $0x2, %edx
sete %dl
orb %al, %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x3c29d
movq %rdi, %rsi
cmpl $0x0, 0x8(%rdi)
jle 0x3c29d
cmpl $0x0, 0x1c0(%rsi)
je 0x3c24e
xorl %eax, %eax
retq
btl $0x15, %ecx
jb 0x3c24b
movq 0x68(%rsi), %rax
cmpq $0x0, 0x28(%rax)
jne 0x3c24b
movl 0xa0(%rsi), %eax
testl %eax, %eax
je 0x3c277
cmpl $0x9, %eax
jne 0x3c24b
cmpl $0x0, 0xa4(%rsi)
jne 0x3c24b
pushq %rax
orl $0x200000, %ecx         # imm = 0x200000
movl %ecx, 0x98(%rsi)
leaq 0xc561d(%rip), %rax     # 0x1018a8
movq 0x1d8(%rax), %rdi
callq 0x2b1ec
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: dupLastObjectIfNeeded
robj *dupLastObjectIfNeeded(list *reply) {
    robj *new, *cur;
    listNode *ln;
    serverAssert(listLength(reply) > 0);
    ln = listLast(reply);
    cur = listNodeValue(ln);
    if (cur->refcount > 1) {
        new = dupStringObject(cur);
        decrRefCount(cur);
        listNodeValue(ln) = new;
    }
    return listNodeValue(ln);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x0, 0x28(%rdi)
je 0x3c2f9
movq 0x8(%rdi), %r15
movq 0x10(%r15), %rbx
cmpl $0x2, 0x4(%rbx)
jl 0x3c2f0
movq %rbx, %rdi
callq 0x40894
movq %rax, %r14
movq %rbx, %rdi
callq 0x40c8f
movq %r14, 0x10(%r15)
movq %r14, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x83c63(%rip), %rdi     # 0xbff63
leaq 0x83c4f(%rip), %rsi     # 0xbff56
movl $0xc6, %edx
callq 0x61908
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: addReplyToBuffer
int _addReplyToBuffer(client *c, const char *s, size_t len) {
    size_t available = sizeof(c->buf)-c->bufpos;

    if (c->flags & CLIENT_CLOSE_AFTER_REPLY) return C_OK;

    /* If there already are entries in the reply list, we cannot
     * add anything more to the static buffer. */
    if (listLength(c->reply) > 0) return C_ERR;

    /* Check that the buffer has enough space available for this string. */
    if (len > available) return C_ERR;

    memcpy(c->buf+c->bufpos,s,len);
    c->bufpos+=len;
    return C_OK;
}

// Assembly:
xorl %eax, %eax
testb $0x40, 0x98(%rdi)
jne 0x3c37d
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movslq 0x1c0(%rdi), %rcx
movl $0x4000, %eax           # imm = 0x4000
subq %rcx, %rax
movq 0x68(%rdi), %rdx
cmpq $0x0, 0x28(%rdx)
setne %dl
cmpq %rbx, %rax
setb %al
orb %dl, %al
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x3c376
leaq (%r14,%rcx), %rdi
addq $0x1c4, %rdi            # imm = 0x1C4
movq %rbx, %rdx
callq 0x26c50
addl %ebx, 0x1c0(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: addReplyObjectToList
void _addReplyObjectToList(client *c, robj *o) {
    robj *tail;

    if (c->flags & CLIENT_CLOSE_AFTER_REPLY) return;

    if (listLength(c->reply) == 0) {
        incrRefCount(o);
        listAddNodeTail(c->reply,o);
        c->reply_bytes += getStringObjectSdsUsedMemory(o);
    } else {
        tail = listNodeValue(listLast(c->reply));

        /* Append to this object when possible. */
        if (tail->ptr != NULL &&
            tail->encoding == OBJ_ENCODING_RAW &&
            sdslen(tail->ptr)+sdslen(o->ptr) <= PROTO_REPLY_CHUNK_BYTES)
        {
            c->reply_bytes -= sdsZmallocSize(tail->ptr);
            tail = dupLastObjectIfNeeded(c->reply);
            tail->ptr = sdscatlen(tail->ptr,o->ptr,sdslen(o->ptr));
            c->reply_bytes += sdsZmallocSize(tail->ptr);
        } else {
            incrRefCount(o);
            listAddNodeTail(c->reply,o);
            c->reply_bytes += getStringObjectSdsUsedMemory(o);
        }
    }
    asyncCloseClientOnOutputBufferLimitReached(c);
}

// Assembly:
testb $0x40, 0x98(%rdi)
jne 0x3c3e2
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x68(%rdi), %rax
cmpq $0x0, 0x28(%rax)
je 0x3c490
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x3c490
testb $-0x10, (%rax)
jne 0x3c490
movzbl -0x1(%rdi), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x3c3fa
leaq 0x83908(%rip), %rdx     # 0xbfcdc
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
shrl $0x3, %eax
jmp 0x3c3fc
retq
movq -0x11(%rdi), %rax
jmp 0x3c3fc
movzwl -0x5(%rdi), %eax
jmp 0x3c3fc
movl -0x9(%rdi), %eax
jmp 0x3c3fc
movzbl -0x3(%rdi), %eax
jmp 0x3c3fc
xorl %eax, %eax
movq 0x8(%r14), %rdx
movzbl -0x1(%rdx), %ecx
movl %ecx, %esi
andl $0x7, %esi
cmpl $0x4, %esi
ja 0x3c43a
leaq 0x838db(%rip), %r8      # 0xbfcf0
movslq (%r8,%rsi,4), %rsi
addq %r8, %rsi
jmpq *%rsi
shrl $0x3, %ecx
jmp 0x3c43c
movq -0x11(%rdx), %rcx
jmp 0x3c43c
movzwl -0x5(%rdx), %ecx
jmp 0x3c43c
movl -0x9(%rdx), %ecx
jmp 0x3c43c
movzbl -0x3(%rdx), %ecx
jmp 0x3c43c
xorl %ecx, %ecx
addq %rax, %rcx
cmpq $0x4000, %rcx           # imm = 0x4000
ja 0x3c490
callq 0x367fe
movq %rax, %rdi
callq 0xa28e0
subq %rax, 0x70(%rbx)
movq 0x68(%rbx), %rdi
callq 0x3c2bc
movq %rax, %r15
movq 0x8(%rax), %rdi
movq 0x8(%r14), %rsi
movzbl -0x1(%rsi), %edx
movl %edx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x3c4d4
leaq 0x83882(%rip), %rcx     # 0xbfd04
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %edx
jmp 0x3c4d6
movq %r14, %rdi
callq 0x407a8
movq 0x68(%rbx), %rdi
movq %r14, %rsi
callq 0x2b24b
movq %r14, %rdi
callq 0x3bd5f
addq %rax, 0x70(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3c4f1
movq -0x11(%rsi), %rdx
jmp 0x3c4d6
movzwl -0x5(%rsi), %edx
jmp 0x3c4d6
movl -0x9(%rsi), %edx
jmp 0x3c4d6
movzbl -0x3(%rsi), %edx
jmp 0x3c4d6
xorl %edx, %edx
callq 0x36ad1
movq %rax, 0x8(%r15)
movq %rax, %rdi
callq 0x367fe
movq %rax, %rdi
callq 0xa28e0
jmp 0x3c4ac
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: asyncCloseClientOnOutputBufferLimitReached
void asyncCloseClientOnOutputBufferLimitReached(client *c) {
    serverAssert(c->reply_bytes < SIZE_MAX-(1024*64));
    if (c->reply_bytes == 0 || c->flags & CLIENT_CLOSE_ASAP) return;
    if (checkClientOutputBufferLimits(c)) {
        sds client = catClientInfoString(sdsempty(),c);

        freeClientAsync(c);
        serverLog(LL_WARNING,"Client %s scheduled to be closed ASAP for overcoming of output buffer limits.", client);
        sdsfree(client);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x70(%rdi), %rax
cmpq $-0x10001, %rax         # imm = 0xFFFEFFFF
jae 0x3c590
testq %rax, %rax
je 0x3c588
movq %rdi, %rbx
testb $0x4, 0x99(%rdi)
jne 0x3c588
movq %rbx, %rdi
callq 0x3f8b0
testl %eax, %eax
je 0x3c588
callq 0x3628d
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3e908
movq %rax, %r14
movl 0x98(%rbx), %eax
testl $0x500, %eax            # imm = 0x500
jne 0x3c563
orl $0x400, %eax            # imm = 0x400
movl %eax, 0x98(%rbx)
leaq 0xc5354(%rip), %rax     # 0x1018a8
movq 0x1d0(%rax), %rdi
movq %rbx, %rsi
callq 0x2b24b
leaq 0x83f7a(%rip), %rsi     # 0xc04e4
movl $0x3, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2fdad
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x36330
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x83f29(%rip), %rdi     # 0xc04c0
leaq 0x839b8(%rip), %rsi     # 0xbff56
movl $0x72f, %edx            # imm = 0x72F
callq 0x61908
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: addReplySdsToList
void _addReplySdsToList(client *c, sds s) {
    robj *tail;

    if (c->flags & CLIENT_CLOSE_AFTER_REPLY) {
        sdsfree(s);
        return;
    }

    if (listLength(c->reply) == 0) {
        listAddNodeTail(c->reply,createObject(OBJ_STRING,s));
        c->reply_bytes += sdsZmallocSize(s);
    } else {
        tail = listNodeValue(listLast(c->reply));

        /* Append to this object when possible. */
        if (tail->ptr != NULL && tail->encoding == OBJ_ENCODING_RAW &&
            sdslen(tail->ptr)+sdslen(s) <= PROTO_REPLY_CHUNK_BYTES)
        {
            c->reply_bytes -= sdsZmallocSize(tail->ptr);
            tail = dupLastObjectIfNeeded(c->reply);
            tail->ptr = sdscatlen(tail->ptr,s,sdslen(s));
            c->reply_bytes += sdsZmallocSize(tail->ptr);
            sdsfree(s);
        } else {
            listAddNodeTail(c->reply,createObject(OBJ_STRING,s));
            c->reply_bytes += sdsZmallocSize(s);
        }
    }
    asyncCloseClientOnOutputBufferLimitReached(c);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
testb $0x40, 0x98(%rdi)
jne 0x3c616
movq %rdi, %rbx
movq 0x68(%rdi), %r15
cmpq $0x0, 0x28(%r15)
je 0x3c6cd
movq 0x8(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x3c6cd
testb $-0x10, (%rax)
jne 0x3c6cd
movzbl -0x1(%rdi), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x3c63a
leaq 0x83710(%rip), %rdx     # 0xbfd18
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
shrl $0x3, %eax
jmp 0x3c63c
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x36330
movq -0x11(%rdi), %rax
jmp 0x3c63c
movzwl -0x5(%rdi), %eax
jmp 0x3c63c
movl -0x9(%rdi), %eax
jmp 0x3c63c
movzbl -0x3(%rdi), %eax
jmp 0x3c63c
xorl %eax, %eax
movzbl -0x1(%r14), %ecx
movl %ecx, %edx
andl $0x7, %edx
cmpl $0x4, %edx
ja 0x3c67a
leaq 0x836da(%rip), %rsi     # 0xbfd2c
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
shrl $0x3, %ecx
jmp 0x3c67c
movq -0x11(%r14), %rcx
jmp 0x3c67c
movzwl -0x5(%r14), %ecx
jmp 0x3c67c
movl -0x9(%r14), %ecx
jmp 0x3c67c
movzbl -0x3(%r14), %ecx
jmp 0x3c67c
xorl %ecx, %ecx
addq %rax, %rcx
cmpq $0x4000, %rcx           # imm = 0x4000
ja 0x3c6cd
callq 0x367fe
movq %rax, %rdi
callq 0xa28e0
subq %rax, 0x70(%rbx)
movq 0x68(%rbx), %rdi
callq 0x3c2bc
movq %rax, %r15
movq 0x8(%rax), %rdi
movzbl -0x1(%r14), %edx
movl %edx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x3c71d
leaq 0x83681(%rip), %rcx     # 0xbfd40
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %edx
jmp 0x3c71f
xorl %edi, %edi
movq %r14, %rsi
callq 0x40650
movq %r15, %rdi
movq %rax, %rsi
callq 0x2b24b
movq %r14, %rdi
callq 0x367fe
movq %rax, %rdi
callq 0xa28e0
addq %rax, 0x70(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3c4f1
movq -0x11(%r14), %rdx
jmp 0x3c71f
movzwl -0x5(%r14), %edx
jmp 0x3c71f
movl -0x9(%r14), %edx
jmp 0x3c71f
movzbl -0x3(%r14), %edx
jmp 0x3c71f
xorl %edx, %edx
movq %r14, %rsi
callq 0x36ad1
movq %rax, 0x8(%r15)
movq %rax, %rdi
callq 0x367fe
movq %rax, %rdi
callq 0xa28e0
addq %rax, 0x70(%rbx)
movq %r14, %rdi
callq 0x36330
jmp 0x3c6f6
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: addReplyStringToList
void _addReplyStringToList(client *c, const char *s, size_t len) {
    robj *tail;

    if (c->flags & CLIENT_CLOSE_AFTER_REPLY) return;

    if (listLength(c->reply) == 0) {
        robj *o = createStringObject(s,len);

        listAddNodeTail(c->reply,o);
        c->reply_bytes += getStringObjectSdsUsedMemory(o);
    } else {
        tail = listNodeValue(listLast(c->reply));

        /* Append to this object when possible. */
        if (tail->ptr != NULL && tail->encoding == OBJ_ENCODING_RAW &&
            sdslen(tail->ptr)+len <= PROTO_REPLY_CHUNK_BYTES)
        {
            c->reply_bytes -= sdsZmallocSize(tail->ptr);
            tail = dupLastObjectIfNeeded(c->reply);
            tail->ptr = sdscatlen(tail->ptr,s,len);
            c->reply_bytes += sdsZmallocSize(tail->ptr);
        } else {
            robj *o = createStringObject(s,len);

            listAddNodeTail(c->reply,o);
            c->reply_bytes += getStringObjectSdsUsedMemory(o);
        }
    }
    asyncCloseClientOnOutputBufferLimitReached(c);
}

// Assembly:
testb $0x40, 0x98(%rdi)
jne 0x3c7b3
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x68(%rdi), %rax
cmpq $0x0, 0x28(%rax)
je 0x3c81b
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x3c81b
testb $-0x10, (%rax)
jne 0x3c81b
movzbl -0x1(%rdi), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x3c7cb
leaq 0x835af(%rip), %rdx     # 0xbfd54
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
shrl $0x3, %eax
jmp 0x3c7cd
retq
movq -0x11(%rdi), %rax
jmp 0x3c7cd
movzwl -0x5(%rdi), %eax
jmp 0x3c7cd
movl -0x9(%rdi), %eax
jmp 0x3c7cd
movzbl -0x3(%rdi), %eax
jmp 0x3c7cd
xorl %eax, %eax
addq %r14, %rax
cmpq $0x4000, %rax           # imm = 0x4000
ja 0x3c81b
callq 0x367fe
movq %rax, %rdi
callq 0xa28e0
subq %rax, 0x70(%rbx)
movq 0x68(%rbx), %rdi
callq 0x3c2bc
movq %rax, %r12
movq 0x8(%rax), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x36ad1
movq %rax, 0x8(%r12)
movq %rax, %rdi
callq 0x367fe
movq %rax, %rdi
callq 0xa28e0
jmp 0x3c83d
movq %r15, %rdi
movq %r14, %rsi
callq 0x40744
movq %rax, %r14
movq 0x68(%rbx), %rdi
movq %rax, %rsi
callq 0x2b24b
movq %r14, %rdi
callq 0x3bd5f
addq %rax, 0x70(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3c4f1
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: addReplySds
void addReplySds(client *c, sds s) {
    if (prepareClientToWrite(c) != C_OK) {
        /* The caller expects the sds to be free'd. */
        sdsfree(s);
        return;
    }
    if (_addReplyToBuffer(c,s,sdslen(s)) == C_OK) {
        sdsfree(s);
    } else {
        /* This method free's the sds when it is no longer needed. */
        _addReplySdsToList(c,s);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3c20d
testl %eax, %eax
jne 0x3cb27
movzbl -0x1(%rbx), %r15d
movl %r15d, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x3cade
leaq 0x832db(%rip), %rcx     # 0xbfd90
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %r15d
jmp 0x3cae1
movq -0x11(%rbx), %r15
jmp 0x3cae1
movzwl -0x5(%rbx), %r15d
jmp 0x3cae1
movl -0x9(%rbx), %r15d
jmp 0x3cae1
movzbl -0x3(%rbx), %r15d
jmp 0x3cae1
xorl %r15d, %r15d
testb $0x40, 0x98(%r14)
jne 0x3cb27
movq 0x68(%r14), %rax
cmpq $0x0, 0x28(%rax)
jne 0x3cb34
movslq 0x1c0(%r14), %rax
movl $0x4000, %ecx           # imm = 0x4000
subq %rax, %rcx
cmpq %r15, %rcx
jb 0x3cb34
leaq (%r14,%rax), %rdi
addq $0x1c4, %rdi            # imm = 0x1C4
movq %rbx, %rsi
movq %r15, %rdx
callq 0x26c50
addl %r15d, 0x1c0(%r14)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x36330
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3c5b2
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: addReplyErrorFormat
void addReplyErrorFormat(client *c, const char *fmt, ...) {
    size_t l, j;
    va_list ap;
    va_start(ap,fmt);
    sds s = sdscatvprintf(sdsempty(),fmt,ap);
    va_end(ap);
    /* Make sure there are no newlines in the string, otherwise invalid protocol
     * is emitted. */
    l = sdslen(s);
    for (j = 0; j < l; j++) {
        if (s[j] == '\r' || s[j] == '\n') s[j] = ' ';
    }
    addReplyErrorLength(c,s,sdslen(s));
    sdsfree(s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x3cc8f
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, %r15
movq %rsi, 0x10(%r15)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r15)
callq 0x3628d
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x36e3e
movq %rax, %r14
movzbl -0x1(%rax), %edx
movl %edx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x3cd2a
leaq 0x830ca(%rip), %rcx     # 0xbfda4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl %edx, %eax
shrl $0x3, %eax
jmp 0x3cd02
movq -0x11(%r14), %rax
jmp 0x3cd02
movzwl -0x5(%r14), %eax
jmp 0x3cd02
movl -0x9(%r14), %eax
jmp 0x3cd02
movzbl -0x3(%r14), %eax
testq %rax, %rax
je 0x3cd2a
xorl %ecx, %ecx
movzbl (%r14,%rcx), %edx
cmpl $0xd, %edx
je 0x3cd18
cmpl $0xa, %edx
jne 0x3cd1d
movb $0x20, (%r14,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x3cd09
movzbl -0x1(%r14), %edx
movl %edx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x3cd63
leaq 0x8307d(%rip), %rcx     # 0xbfdb8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %edx
jmp 0x3cd65
movq -0x11(%r14), %rdx
jmp 0x3cd65
movzwl -0x5(%r14), %edx
jmp 0x3cd65
movl -0x9(%r14), %edx
jmp 0x3cd65
movzbl -0x3(%r14), %edx
jmp 0x3cd65
xorl %edx, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3cbc0
movq %r14, %rdi
callq 0x36330
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: addReplyStatusFormat
void addReplyStatusFormat(client *c, const char *fmt, ...) {
    va_list ap;
    va_start(ap,fmt);
    sds s = sdscatvprintf(sdsempty(),fmt,ap);
    va_end(ap);
    addReplyStatusLength(c,s,sdslen(s));
    sdsfree(s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x3ce54
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, %r15
movq %rsi, 0x10(%r15)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r15)
callq 0x3628d
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x36e3e
movq %rax, %r14
movzbl -0x1(%rax), %edx
movl %edx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x3cec7
leaq 0x82f2d(%rip), %rcx     # 0xbfdcc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %edx
jmp 0x3cec9
movq -0x11(%r14), %rdx
jmp 0x3cec9
movzwl -0x5(%r14), %edx
jmp 0x3cec9
movl -0x9(%r14), %edx
jmp 0x3cec9
movzbl -0x3(%r14), %edx
jmp 0x3cec9
xorl %edx, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3cd85
movq %r14, %rdi
callq 0x36330
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: addDeferredMultiBulkLength
void *addDeferredMultiBulkLength(client *c) {
    /* Note that we install the write event here even if the object is not
     * ready to be sent, since we are sure that before returning to the
     * event loop setDeferredMultiBulkLength() will be called. */
    if (prepareClientToWrite(c) != C_OK) return NULL;
    listAddNodeTail(c->reply,createObject(OBJ_STRING,NULL));
    return listLast(c->reply);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3c20d
testl %eax, %eax
je 0x3cefd
xorl %eax, %eax
jmp 0x3cf1d
movq 0x68(%rbx), %r14
xorl %edi, %edi
xorl %esi, %esi
callq 0x40650
movq %r14, %rdi
movq %rax, %rsi
callq 0x2b24b
movq 0x68(%rbx), %rax
movq 0x8(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: setDeferredMultiBulkLength
void setDeferredMultiBulkLength(client *c, void *node, long length) {
    listNode *ln = (listNode*)node;
    robj *len, *next;

    /* Abort when *node is NULL (see addDeferredMultiBulkLength). */
    if (node == NULL) return;

    len = listNodeValue(ln);
    len->ptr = sdscatprintf(sdsempty(),"*%ld\r\n",length);
    len->encoding = OBJ_ENCODING_RAW; /* in case it was an EMBSTR. */
    c->reply_bytes += sdsZmallocSize(len->ptr);
    if (ln->next != NULL) {
        next = listNodeValue(ln->next);

        /* Only glue when the next node is non-NULL (an sds in this case) */
        if (next->ptr != NULL) {
            c->reply_bytes -= sdsZmallocSize(len->ptr);
            c->reply_bytes -= getStringObjectSdsUsedMemory(next);
            len->ptr = sdscatlen(len->ptr,next->ptr,sdslen(next->ptr));
            c->reply_bytes += sdsZmallocSize(len->ptr);
            listDelNode(c->reply,ln->next);
        }
    }
    asyncCloseClientOnOutputBufferLimitReached(c);
}

// Assembly:
testq %rsi, %rsi
je 0x3cfe4
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r12
callq 0x3628d
leaq 0x83054(%rip), %rsi     # 0xbffa3
movq %rax, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x36f2d
movq %rax, 0x8(%r12)
andb $0xf, (%r12)
movq %rax, %rdi
callq 0x367fe
movq %rax, %rdi
callq 0xa28e0
addq %rax, 0x70(%rbx)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x3d029
movq 0x10(%rax), %r15
cmpq $0x0, 0x8(%r15)
je 0x3d029
movq 0x8(%r12), %rdi
callq 0x367fe
movq %rax, %rdi
callq 0xa28e0
subq %rax, 0x70(%rbx)
movq %r15, %rdi
callq 0x3bd5f
subq %rax, 0x70(%rbx)
movq 0x8(%r12), %rdi
movq 0x8(%r15), %rsi
movzbl -0x1(%rsi), %edx
movl %edx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x3cffc
leaq 0x82e0a(%rip), %rcx     # 0xbfde0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %edx
jmp 0x3cffe
retq
movq -0x11(%rsi), %rdx
jmp 0x3cffe
movzwl -0x5(%rsi), %edx
jmp 0x3cffe
movl -0x9(%rsi), %edx
jmp 0x3cffe
movzbl -0x3(%rsi), %edx
jmp 0x3cffe
xorl %edx, %edx
callq 0x36ad1
movq %rax, 0x8(%r12)
movq %rax, %rdi
callq 0x367fe
movq %rax, %rdi
callq 0xa28e0
addq %rax, 0x70(%rbx)
movq 0x68(%rbx), %rdi
movq 0x8(%r14), %rsi
callq 0x2b331
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3c4f1
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: addReplyDouble
void addReplyDouble(client *c, double d) {
    char dbuf[128], sbuf[128];
    int dlen, slen;
    if (isinf(d)) {
        /* Libc in odd systems (Hi Solaris!) will format infinite in a
         * different way, so better to handle it in an explicit way. */
        addReplyBulkCString(c, d > 0 ? "inf" : "-inf");
    } else {
        dlen = snprintf(dbuf,sizeof(dbuf),"%.17g",d);
        slen = snprintf(sbuf,sizeof(sbuf),"$%d\r\n%s\r\n",dlen,dbuf);
        addReplyString(c,sbuf,slen);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %rbx
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jne 0x3d09b
xorpd %xmm1, %xmm1
xorl %edx, %edx
ucomisd %xmm1, %xmm0
leaq 0x82f36(%rip), %rax     # 0xbffab
leaq 0x82f2e(%rip), %rsi     # 0xbffaa
cmovaq %rax, %rsi
setbe %dl
addq $0x3, %rdx
movq %rbx, %rdi
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
jmp 0x3d346
leaq 0x82f0d(%rip), %rdx     # 0xbffaf
leaq 0x80(%rsp), %r14
movl $0x80, %esi
movq %r14, %rdi
movb $0x1, %al
callq 0x26120
leaq 0x7ff64(%rip), %rdx     # 0xbd024
movq %rsp, %r15
movl $0x80, %esi
movq %r15, %rdi
movl %eax, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x26120
movslq %eax, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3cb44
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: addReplyBulkCString
void addReplyBulkCString(client *c, const char *s) {
    if (s == NULL) {
        addReply(c,shared.nullbulk);
    } else {
        addReplyBulkCBuffer(c,s,strlen(s));
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x3d11e
movq %rsi, %r14
movq %rsi, %rdi
callq 0x26500
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3d346
leaq 0xc51eb(%rip), %rax     # 0x102310
movq 0x50(%rax), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3c854
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: addReplyLongLongWithPrefix
void addReplyLongLongWithPrefix(client *c, long long ll, char prefix) {
    char buf[128];
    int len;

    /* Things like $3\r\n or *2\r\n are emitted very often by the protocol
     * so we have a few shared objects to use if the integer is small
     * like it is most of the times. */
    if (prefix == '*' && ll < OBJ_SHARED_BULKHDR_LEN && ll >= 0) {
        addReply(c,shared.mbulkhdr[ll]);
        return;
    } else if (prefix == '$' && ll < OBJ_SHARED_BULKHDR_LEN && ll >= 0) {
        addReply(c,shared.bulkhdr[ll]);
        return;
    }

    buf[0] = prefix;
    len = ll2string(buf+1,sizeof(buf)-1,ll);
    buf[len+1] = '\r';
    buf[len+2] = '\n';
    addReplyString(c,buf,len+3);
}

// Assembly:
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rax
movq %rdi, %rbx
cmpb $0x2a, %dl
setne %cl
cmpq $0x20, %rsi
setae %sil
orb %cl, %sil
jne 0x3d1d5
leaq 0xc5145(%rip), %rcx     # 0x102310
movq 0x13a30(%rcx,%rax,8), %rsi
jmp 0x3d1f7
cmpq $0x20, %rax
setae %cl
cmpb $0x24, %dl
setne %sil
orb %cl, %sil
jne 0x3d207
leaq 0xc5121(%rip), %rcx     # 0x102310
movq 0x13b30(%rcx,%rax,8), %rsi
movq %rbx, %rdi
addq $0x80, %rsp
popq %rbx
jmp 0x3c854
leaq 0x1(%rsp), %rdi
movb %dl, -0x1(%rdi)
movl $0x7f, %esi
movq %rax, %rdx
callq 0x3ff83
cltq
movq %rsp, %rsi
movw $0xa0d, 0x1(%rax,%rsi)  # imm = 0xA0D
addl $0x3, %eax
movslq %eax, %rdx
movq %rbx, %rdi
callq 0x3cb44
addq $0x80, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: addReplyLongLong
void addReplyLongLong(client *c, long long ll) {
    if (ll == 0)
        addReply(c,shared.czero);
    else if (ll == 1)
        addReply(c,shared.cone);
    else
        addReplyLongLongWithPrefix(c,ll,':');
}

// Assembly:
cmpq $0x1, %rsi
je 0x3d25a
testq %rsi, %rsi
jne 0x3d26a
leaq 0xc50bf(%rip), %rax     # 0x102310
movq 0x20(%rax), %rsi
jmp 0x3c854
leaq 0xc50af(%rip), %rax     # 0x102310
movq 0x28(%rax), %rsi
jmp 0x3c854
movl $0x3a, %edx
jmp 0x3d1a3
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: addReplyBulkLen
void addReplyBulkLen(client *c, robj *obj) {
    size_t len;

    if (sdsEncodedObject(obj)) {
        len = sdslen(obj->ptr);
    } else {
        long n = (long)obj->ptr;

        /* Compute how many bytes will take this integer as a radix 10 string */
        len = 1;
        if (n < 0) {
            len++;
            n = -n;
        }
        while((n = n/10) != 0) {
            len++;
        }
    }

    if (len < OBJ_SHARED_BULKHDR_LEN)
        addReply(c,shared.bulkhdr[len]);
    else
        addReplyLongLongWithPrefix(c,len,'$');
}

// Assembly:
movl (%rsi), %eax
shrl $0x4, %eax
testb $0x7, %al
jne 0x3d2c8
movq 0x8(%rsi), %rax
movzbl -0x1(%rax), %esi
movl %esi, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x3d330
leaq 0x82b3a(%rip), %rdx     # 0xbfdf4
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
shrl $0x3, %esi
jmp 0x3d332
movq 0x8(%rsi), %rax
movq %rax, %rcx
negq %rcx
movq %rax, %rsi
shrq $0x3f, %rsi
incq %rsi
testq %rax, %rax
cmovnsq %rax, %rcx
cmpq $0xa, %rcx
jb 0x3d332
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %rax
mulq %r8
shrq $0x3, %rdx
incq %rsi
cmpq $0x63, %rcx
movq %rdx, %rcx
ja 0x3d2f3
jmp 0x3d320
movq -0x11(%rax), %rsi
jmp 0x3d320
movzwl -0x5(%rax), %esi
jmp 0x3d320
movl -0x9(%rax), %esi
jmp 0x3d320
movzbl -0x3(%rax), %esi
cmpq $0x1f, %rsi
jbe 0x3d332
movl $0x24, %edx
jmp 0x3d1a3
xorl %esi, %esi
leaq 0xc4fd7(%rip), %rax     # 0x102310
movq 0x13b30(%rax,%rsi,8), %rsi
jmp 0x3c854
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: addReplyBulkSds
void addReplyBulkSds(client *c, sds s)  {
    addReplySds(c,sdscatfmt(sdsempty(),"$%u\r\n",
        (unsigned long)sdslen(s)));
    addReplySds(c,s);
    addReply(c,shared.crlf);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3628d
movzbl -0x1(%r14), %edx
movl %edx, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x3d3d3
leaq 0x82a5d(%rip), %rsi     # 0xbfe08
movslq (%rsi,%rcx,4), %rcx
addq %rsi, %rcx
jmpq *%rcx
shrl $0x3, %edx
jmp 0x3d3d5
movq -0x11(%r14), %rdx
jmp 0x3d3d5
movzwl -0x5(%r14), %edx
jmp 0x3d3d5
movl -0x9(%r14), %edx
jmp 0x3d3d5
movzbl -0x3(%r14), %edx
jmp 0x3d3d5
xorl %edx, %edx
leaq 0x82bd9(%rip), %rsi     # 0xbffb5
movq %rax, %rdi
xorl %eax, %eax
callq 0x36fb1
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3ca86
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ca86
leaq 0xc4f0d(%rip), %rax     # 0x102310
movq (%rax), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3c854
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: copyClientOutputBuffer
void copyClientOutputBuffer(client *dst, client *src) {
    listRelease(dst->reply);
    dst->reply = listDup(src->reply);
    memcpy(dst->buf,src->buf,src->bufpos);
    dst->bufpos = src->bufpos;
    dst->reply_bytes = src->reply_bytes;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x68(%rdi), %rdi
callq 0x2b19c
movq 0x68(%rbx), %rdi
callq 0x2b3ed
movq %rax, 0x68(%r14)
movl $0x1c4, %esi            # imm = 0x1C4
leaq (%r14,%rsi), %rdi
addq %rbx, %rsi
movslq 0x1c0(%rbx), %rdx
callq 0x26c50
movl 0x1c0(%rbx), %eax
movl %eax, 0x1c0(%r14)
movq 0x70(%rbx), %rax
movq %rax, 0x70(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: acceptTcpHandler
void acceptTcpHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
    int cport, cfd, max = MAX_ACCEPTS_PER_CALL;
    char cip[NET_IP_STR_LEN];
    UNUSED(el);
    UNUSED(mask);
    UNUSED(privdata);

    while(max--) {
        cfd = anetTcpAccept(server.neterr, fd, cip, sizeof(cip), &cport);
        if (cfd == ANET_ERR) {
            if (errno != EWOULDBLOCK)
                serverLog(LL_WARNING,
                    "Accepting client connection: %s", server.neterr);
            return;
        }
        serverLog(LL_VERBOSE,"Accepted %s:%d", cip, cport);
        acceptCommonHandler(cfd,0,cip);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebx
movl $0x208, %r14d           # imm = 0x208
addq 0xbfafe(%rip), %r14     # 0xfcfb8
movl $0xfffffc18, %r13d      # imm = 0xFFFFFC18
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
movl $0x2e, %ecx
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
movq %r12, %r8
callq 0x2e17c
cmpl $-0x1, %eax
je 0x3d513
movl %eax, %ebp
movl 0xc(%rsp), %ecx
movl $0x1, %edi
leaq 0x82ae5(%rip), %rsi     # 0xbffdb
movq %r15, %rdx
xorl %eax, %eax
callq 0x2fdad
movl %ebp, %edi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3d54b
incl %r13d
jne 0x3d4ca
jmp 0x3d53c
callq 0x26880
cmpl $0xb, (%rax)
je 0x3d53c
movl $0x208, %edx            # imm = 0x208
addq 0xbfa8f(%rip), %rdx     # 0xfcfb8
leaq 0x82a8b(%rip), %rsi     # 0xbffbb
movl $0x3, %edi
xorl %eax, %eax
callq 0x2fdad
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: acceptUnixHandler
void acceptUnixHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
    int cfd, max = MAX_ACCEPTS_PER_CALL;
    UNUSED(el);
    UNUSED(mask);
    UNUSED(privdata);

    while(max--) {
        cfd = anetUnixAccept(server.neterr, fd);
        if (cfd == ANET_ERR) {
            if (errno != EWOULDBLOCK)
                serverLog(LL_WARNING,
                    "Accepting client connection: %s", server.neterr);
            return;
        }
        serverLog(LL_VERBOSE,"Accepted connection to %s", server.unixsocket);
        acceptCommonHandler(cfd,CLIENT_UNIX_SOCKET,NULL);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movl $0xfffffc18, %r12d      # imm = 0xFFFFFC18
movl $0x208, %r14d           # imm = 0x208
addq 0xbf933(%rip), %r14     # 0xfcfb8
leaq 0xc421c(%rip), %r13     # 0x1018a8
leaq 0x82957(%rip), %r15     # 0xbffea
movq %r14, %rdi
movl %ebx, %esi
callq 0x2e25b
cmpl $-0x1, %eax
je 0x3d6cf
movl %eax, %ebp
movq 0x130(%r13), %rdx
movl $0x1, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2fdad
movl %ebp, %edi
movl $0x800, %esi            # imm = 0x800
xorl %edx, %edx
callq 0x3d54b
incl %r12d
jne 0x3d693
jmp 0x3d6d9
callq 0x26880
cmpl $0xb, (%rax)
jne 0x3d6e8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x208, %edx            # imm = 0x208
addq 0xbf8c4(%rip), %rdx     # 0xfcfb8
leaq 0x828c0(%rip), %rsi     # 0xbffbb
movl $0x3, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2fdad