LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
jne 0x4165d
movl $0x0, -0x4(%rbp)
jmp 0x41701
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x40400
movzbl -0x2c(%rbp), %eax
andl $0xc0, %eax
cmpl $0xc0, %eax
jge 0x416b3
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x416aa
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %eax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x269b0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x41701
movl $0x0, -0x4(%rbp)
jmp 0x41701
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
leaq -0x58(%rbp), %rdx
leaq -0x41(%rbp), %rcx
callq 0x40090
cmpl $0x0, %eax
je 0x416f8
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %eax
addq %rax, %rdi
movzbl -0x2c(%rbp), %esi
callq 0x402c0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x58(%rbp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x41701
jmp 0x416fa
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x8(%rax), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jge 0x419ef
movq -0x8(%rbp), %rax
movzwl 0x8(%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0x41a45
movq -0x8(%rbp), %rax
addq $0xa, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
je 0x41a2c
movq -0x18(%rbp), %rdi
callq 0x3ff20
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x419fb
cmpl $0xffff, -0xc(%rbp)     # imm = 0xFFFF
jae 0x41a43
movl -0xc(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x8(%rax)
jmp 0x41a45
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0x41cbc
jmp 0x41ce7
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
leaq 0xf8d55(%rip), %rdx     # 0x13aa20
leaq 0xf8d64(%rip), %rcx     # 0x13aa36
movl $0x2f, %r8d
callq 0x78360
movl $0x1, %edi
callq 0x263c0
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
movl %eax, -0x14(%rbp)
je 0x41d04
jmp 0x41cfa
movl -0x14(%rbp), %eax
subl $0x8, %eax
je 0x41d17
jmp 0x41d2a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x41c70
movq %rax, -0x8(%rbp)
jmp 0x41d32
movq -0x10(%rbp), %rdi
callq 0xea4d0
subq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x41d32
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jbe 0x42529
jmp 0x4254b
leaq 0xf8513(%rip), %rdi     # 0x13aa43
leaq 0xf84ff(%rip), %rsi     # 0x13aa36
movl $0xc6, %edx
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jle 0x4258f
movq -0x18(%rbp), %rdi
callq 0x48970
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x48f70
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq 0x1c0(%rax), %rcx
movl $0x4000, %eax           # imm = 0x4000
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x98(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x425e6
movl $0x0, -0x4(%rbp)
jmp 0x42656
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
cmpq $0x0, 0x28(%rax)
jbe 0x425fe
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x42656
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0x42611
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x42656
movq -0x10(%rbp), %rdi
addq $0x1c4, %rdi            # imm = 0x1C4
movq -0x10(%rbp), %rax
movslq 0x1c0(%rax), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x26c60
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq 0x1c0(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x1c0(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $-0x10001, 0x70(%rax)   # imm = 0xFFFEFFFF
jae 0x428bc
jmp 0x428de
leaq 0xf86dd(%rip), %rdi     # 0x13afa0
leaq 0xf816c(%rip), %rsi     # 0x13aa36
movl $0x72f, %edx            # imm = 0x72F
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x428fd
movq -0x8(%rbp), %rax
movl 0x98(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x428ff
jmp 0x4294b
movq -0x8(%rbp), %rdi
callq 0x46c50
cmpl $0x0, %eax
je 0x4294b
callq 0x384f0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x455c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x44460
movq -0x10(%rbp), %rdx
movl $0x3, %edi
leaq 0xf8689(%rip), %rsi     # 0x13afc4
movb $0x0, %al
callq 0x2fc60
movq -0x10(%rbp), %rdi
callq 0x38620
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x98(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x42b5b
jmp 0x42cad
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
cmpq $0x0, 0x28(%rax)
jne 0x42ba9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x486a0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x27000
movq -0x28(%rbp), %rdi
callq 0x41ca0
movq %rax, %rcx
movq -0x8(%rbp), %rax
addq 0x70(%rax), %rcx
movq %rcx, 0x70(%rax)
jmp 0x42ca4
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x42c68
movq -0x20(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0x42c68
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x42810
addq -0x18(%rbp), %rax
cmpq $0x4000, %rax           # imm = 0x4000
ja 0x42c68
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x41c70
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x70(%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x42510
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x39040
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x41c70
movq %rax, %rcx
movq -0x8(%rbp), %rax
addq 0x70(%rax), %rcx
movq %rcx, 0x70(%rax)
jmp 0x42ca2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x486a0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x27000
movq -0x30(%rbp), %rdi
callq 0x41ca0
movq %rax, %rcx
movq -0x8(%rbp), %rax
addq 0x70(%rax), %rcx
movq %rcx, 0x70(%rax)
jmp 0x42ca4
movq -0x8(%rbp), %rdi
callq 0x428a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x423b0
cmpl $0x0, %eax
je 0x42e79
movq -0x10(%rbp), %rdi
callq 0x38620
jmp 0x42ebf
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42810
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
callq 0x425a0
cmpl $0x0, %eax
jne 0x42eb2
movq -0x10(%rbp), %rdi
callq 0x38620
jmp 0x42ebf
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x42960
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0x4300e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x40(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
callq 0x384f0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x39420
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rax
movq -0x48(%rbp), %rdi
callq 0x42810
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x430d0
movq -0x48(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
je 0x430b4
movq -0x48(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x430c0
movq -0x48(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x20, (%rax,%rcx)
jmp 0x430c2
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x43088
movq -0x8(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0x48(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x42810
movq -0x110(%rbp), %rdi
movq -0x108(%rbp), %rsi
movq %rax, %rdx
callq 0x42f30
movq -0x48(%rbp), %rdi
callq 0x38620
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x431fb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xf0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
callq 0x384f0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x39420
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x38(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x42810
movq -0x100(%rbp), %rdi
movq -0xf8(%rbp), %rsi
movq %rax, %rdx
callq 0x43120
movq -0x38(%rbp), %rdi
callq 0x38620
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x423b0
cmpl $0x0, %eax
je 0x432c4
movq $0x0, -0x8(%rbp)
jmp 0x432f7
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x18(%rbp)
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x48480
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x27000
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x43338
jmp 0x4347a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x384f0
movq %rax, %rdi
movq -0x18(%rbp), %rdx
leaq 0xf772c(%rip), %rsi     # 0x13aa83
movb $0x0, %al
callq 0x395b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff0f, %ecx       # imm = 0xFFFFFF0F
orl $0x0, %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x41c70
movq %rax, %rcx
movq -0x8(%rbp), %rax
addq 0x70(%rax), %rcx
movq %rcx, 0x70(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x43471
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4346f
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x41c70
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x70(%rax)
movq -0x30(%rbp), %rdi
callq 0x41ca0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x70(%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x42810
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x39040
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x41c70
movq %rax, %rcx
movq -0x8(%rbp), %rax
addq 0x70(%rax), %rcx
movq %rcx, 0x70(%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x271e0
jmp 0x43471
movq -0x8(%rbp), %rdi
callq 0x428a0
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm1
movaps %xmm1, %xmm0
movaps 0xf756d(%rip), %xmm2    # 0x13aa10
pand %xmm2, %xmm0
movq %xmm1, %rdx
movl $0x1, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovll %eax, %ecx
movsd 0xf753b(%rip), %xmm1    # 0x13aa00
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setnp %sil
sete %dl
testb %sil, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
je 0x43506
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
leaq 0xf759a(%rip), %rsi     # 0x13aa8a
leaq 0xf7594(%rip), %rax     # 0x13aa8b
ucomisd %xmm1, %xmm0
cmovaq %rax, %rsi
callq 0x43580
jmp 0x4356f
leaq -0x90(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movl $0x80, %esi
leaq 0xf7571(%rip), %rdx     # 0x13aa8f
movb $0x1, %al
callq 0x26120
movl %eax, -0x114(%rbp)
leaq -0x110(%rbp), %rdi
movl -0x114(%rbp), %ecx
leaq -0x90(%rbp), %r8
movl $0x80, %esi
leaq 0xf4a49(%rip), %rdx     # 0x137f94
movb $0x0, %al
callq 0x26120
movl %eax, -0x118(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x110(%rbp), %rsi
movslq -0x118(%rbp), %rdx
callq 0x42ed0
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x435ad
movq -0x8(%rbp), %rdi
leaq 0x13569e(%rip), %rax    # 0x178c40
movq 0x50(%rax), %rsi
callq 0x42cc0
jmp 0x435d6
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x264f0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
callq 0x43920
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x2a, %eax
jne 0x436d0
cmpq $0x20, -0x10(%rbp)
jge 0x436d0
cmpq $0x0, -0x10(%rbp)
jl 0x436d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
leaq 0x135582(%rip), %rax    # 0x178c40
movq 0x13a30(%rax,%rcx,8), %rsi
callq 0x42cc0
jmp 0x43771
movsbl -0x11(%rbp), %eax
cmpl $0x24, %eax
jne 0x43705
cmpq $0x20, -0x10(%rbp)
jge 0x43705
cmpq $0x0, -0x10(%rbp)
jl 0x43705
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
leaq 0x13554a(%rip), %rax    # 0x178c40
movq 0x13b30(%rax,%rcx,8), %rsi
callq 0x42cc0
jmp 0x43771
jmp 0x43707
movb -0x11(%rbp), %al
movb %al, -0xa0(%rbp)
leaq -0xa0(%rbp), %rdi
addq $0x1, %rdi
movq -0x10(%rbp), %rdx
movl $0x7f, %esi
callq 0x477e0
movl %eax, -0xa4(%rbp)
movl -0xa4(%rbp), %eax
addl $0x1, %eax
cltq
movb $0xd, -0xa0(%rbp,%rax)
movl -0xa4(%rbp), %eax
addl $0x2, %eax
cltq
movb $0xa, -0xa0(%rbp,%rax)
movq -0x8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
movl -0xa4(%rbp), %eax
addl $0x3, %eax
movslq %eax, %rdx
callq 0x42ed0
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x437ad
movq -0x8(%rbp), %rdi
leaq 0x13549e(%rip), %rax    # 0x178c40
movq 0x20(%rax), %rsi
callq 0x42cc0
jmp 0x437de
cmpq $0x1, -0x10(%rbp)
jne 0x437ca
movq -0x8(%rbp), %rdi
leaq 0x135481(%rip), %rax    # 0x178c40
movq 0x28(%rax), %rsi
callq 0x42cc0
jmp 0x437dc
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x3a, %edx
callq 0x43680
jmp 0x437de
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/networking.c
// Function: addReplyMultiBulkLen
void addReplyMultiBulkLen(client *c, long length) {
    if (length < OBJ_SHARED_BULKHDR_LEN)
        addReply(c,shared.mbulkhdr[length]);
    else
        addReplyLongLongWithPrefix(c,length,'*');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x20, -0x10(%rbp)
jge 0x43825
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
leaq 0x13542a(%rip), %rax    # 0x178c40
movq 0x13a30(%rax,%rcx,8), %rsi
callq 0x42cc0
jmp 0x43837
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x2a, %edx
callq 0x43680
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x43872
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x43885
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x42810
movq %rax, -0x18(%rbp)
jmp 0x438e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x1, -0x18(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x438b6
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
subq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x438b8
movq -0x20(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x438de
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x438b8
jmp 0x438e0
cmpq $0x20, -0x18(%rbp)
jae 0x43905
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
leaq 0x13534a(%rip), %rax    # 0x178c40
movq 0x13b30(%rax,%rcx,8), %rsi
callq 0x42cc0
jmp 0x43917
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x24, %edx
callq 0x43680
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x384f0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42810
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0xf70ed(%rip), %rsi     # 0x13aa95
movb $0x0, %al
callq 0x39660
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x42e50
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x42e50
movq -0x8(%rbp), %rdi
leaq 0x13526d(%rip), %rax    # 0x178c40
movq (%rax), %rsi
callq 0x42cc0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x26ea0
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x273d0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rdi
addq $0x1c4, %rdi            # imm = 0x1C4
movq -0x10(%rbp), %rsi
addq $0x1c4, %rsi            # imm = 0x1C4
movq -0x10(%rbp), %rax
movslq 0x1c0(%rax), %rdx
callq 0x26c60
movq -0x10(%rbp), %rax
movl 0x1c0(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c0(%rax)
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x70(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x3e8, -0x28(%rbp)     # imm = 0x3E8
movl -0x28(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x28(%rbp)
cmpl $0x0, %eax
je 0x43b77
movl -0xc(%rbp), %esi
leaq -0x60(%rbp), %rdx
leaq 0x1346d9(%rip), %rdi    # 0x1781d8
addq $0x208, %rdi            # imm = 0x208
movl $0x2e, %ecx
leaq -0x20(%rbp), %r8
callq 0x2c9e0
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x43b4a
callq 0x26880
cmpl $0xb, (%rax)
je 0x43b48
movl $0x3, %edi
leaq 0xf6f68(%rip), %rsi     # 0x13aa9b
leaq 0x13469e(%rip), %rdx    # 0x1781d8
addq $0x208, %rdx            # imm = 0x208
movb $0x0, %al
callq 0x2fc60
jmp 0x43b77
leaq -0x60(%rbp), %rdx
movl -0x20(%rbp), %ecx
movl $0x1, %edi
leaq 0xf6f5e(%rip), %rsi     # 0x13aabb
movb $0x0, %al
callq 0x2fc60
movl -0x24(%rbp), %edi
leaq -0x60(%rbp), %rdx
xorl %esi, %esi
callq 0x43b80
jmp 0x43add
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x3e8, -0x24(%rbp)     # imm = 0x3E8
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x24(%rbp)
cmpl $0x0, %eax
je 0x43e44
movl -0xc(%rbp), %esi
leaq 0x13440d(%rip), %rdi    # 0x1781d8
addq $0x208, %rdi            # imm = 0x208
callq 0x2cb90
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0x43e0d
callq 0x26880
cmpl $0xb, (%rax)
je 0x43e0b
movl $0x3, %edi
leaq 0xf6ca5(%rip), %rsi     # 0x13aa9b
leaq 0x1343db(%rip), %rdx    # 0x1781d8
addq $0x208, %rdx            # imm = 0x208
movb $0x0, %al
callq 0x2fc60
jmp 0x43e44
leaq 0x1343c4(%rip), %rax    # 0x1781d8
movq 0x130(%rax), %rdx
movl $0x1, %edi
leaq 0xf6ca3(%rip), %rsi     # 0x13aaca
movb $0x0, %al
callq 0x2fc60
movl -0x20(%rbp), %edi
movl $0x800, %esi            # imm = 0x800
xorl %eax, %eax
movl %eax, %edx
callq 0x43b80
jmp 0x43dad
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/networking.c
// Function: freeClientArgv
static void freeClientArgv(client *c) {
    int j;
    for (j = 0; j < c->argc; j++)
        decrRefCount(c->argv[j]);
    c->argc = 0;
    c->cmd = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x4443f
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x48f70
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x44413
movq -0x8(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/networking.c
// Function: freeClientsInAsyncFreeQueue
void freeClientsInAsyncFreeQueue(void) {
    while (listLength(server.clients_to_close)) {
        listNode *ln = listFirst(server.clients_to_close);
        client *c = listNodeValue(ln);

        c->flags &= ~CLIENT_CLOSE_ASAP;
        freeClient(c);
        listDelNode(server.clients_to_close,ln);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x133cf9(%rip), %rax    # 0x1781d8
movq 0x1d0(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x44546
leaq 0x133ce4(%rip), %rax    # 0x1781d8
movq 0x1d0(%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x98(%rax), %ecx
andl $0xfffffbff, %ecx       # imm = 0xFFFFFBFF
movl %ecx, 0x98(%rax)
movq -0x10(%rbp), %rdi
callq 0x43ea0
leaq 0x133ca4(%rip), %rax    # 0x1781d8
movq 0x1d0(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x271e0
jmp 0x444d8
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/networking.c
// Function: handleClientsWithPendingWrites
int handleClientsWithPendingWrites(void) {
    listIter li;
    listNode *ln;
    int processed = listLength(server.clients_pending_write);

    listRewind(server.clients_pending_write,&li);
    while((ln = listNext(&li))) {
        client *c = listNodeValue(ln);
        c->flags &= ~CLIENT_PENDING_WRITE;
        listDelNode(server.clients_pending_write,ln);

        /* Try to write buffers to the client socket. */
        if (writeToClient(c->fd,c,0) == C_ERR) continue;

        /* If there is nothing left, do nothing. Otherwise install
         * the write handler. */
        if (clientHasPendingReplies(c) &&
            aeCreateFileEvent(server.el, c->fd, AE_WRITABLE,
                sendReplyToClient, c) == AE_ERR)
        {
            freeClientAsync(c);
        }
    }
    return processed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x133919(%rip), %rax    # 0x1781d8
movq 0x1d8(%rax), %rax
movq 0x28(%rax), %rax
movl %eax, -0x1c(%rbp)
leaq 0x133904(%rip), %rax    # 0x1781d8
movq 0x1d8(%rax), %rdi
leaq -0x10(%rbp), %rsi
callq 0x27320
leaq -0x10(%rbp), %rdi
callq 0x27380
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x44995
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x98(%rax), %ecx
andl $0xffdfffff, %ecx       # imm = 0xFFDFFFFF
movl %ecx, 0x98(%rax)
leaq 0x1338b4(%rip), %rax    # 0x1781d8
movq 0x1d8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x271e0
movq -0x28(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x44550
cmpl $-0x1, %eax
jne 0x4494d
jmp 0x448e4
movq -0x28(%rbp), %rdi
callq 0x424d0
cmpl $0x0, %eax
je 0x44990
leaq 0x133876(%rip), %rax    # 0x1781d8
movq 0x40(%rax), %rdi
movq -0x28(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x28(%rbp), %r8
movl $0x2, %edx
leaq -0xfd(%rip), %rcx       # 0x44880
callq 0x2a8f0
cmpl $-0x1, %eax
jne 0x44990
movq -0x28(%rbp), %rdi
callq 0x44460
jmp 0x448e4
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/networking.c
// Function: resetClient
void resetClient(client *c) {
    redisCommandProc *prevcmd = c->cmd ? c->cmd->proc : NULL;

    freeClientArgv(c);
    c->reqtype = 0;
    c->multibulklen = 0;
    c->bulklen = -1;

    /* We clear the ASKING flag as well if we are not inside a MULTI, and
     * if what we just executed is not the ASKING command itself. */
    if (!(c->flags & CLIENT_MULTI) && prevcmd != askingCommand)
        c->flags &= ~CLIENT_ASKING;

    /* Remove the CLIENT_REPLY_SKIP flag if any so that the reply
     * to the next command will be sent, but set the flag if the command
     * we just processed was "CLIENT REPLY SKIP". */
    c->flags &= ~CLIENT_REPLY_SKIP;
    if (c->flags & CLIENT_REPLY_SKIP_NEXT) {
        c->flags |= CLIENT_REPLY_SKIP;
        c->flags &= ~CLIENT_REPLY_SKIP_NEXT;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x449c9
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x449d1
xorl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0x449d1
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x44400
movq -0x8(%rbp), %rax
movl $0x0, 0x58(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x5c(%rax)
movq -0x8(%rbp), %rax
movq $-0x1, 0x60(%rax)
movq -0x8(%rbp), %rax
movl 0x98(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x44a39
leaq 0x422f3(%rip), %rax     # 0x86d10
cmpq %rax, -0x10(%rbp)
je 0x44a39
movq -0x8(%rbp), %rax
movl 0x98(%rax), %ecx
andl $0xfffffdff, %ecx       # imm = 0xFFFFFDFF
movl %ecx, 0x98(%rax)
movq -0x8(%rbp), %rax
movl 0x98(%rax), %ecx
andl $0xfeffffff, %ecx       # imm = 0xFEFFFFFF
movl %ecx, 0x98(%rax)
movq -0x8(%rbp), %rax
movl 0x98(%rax), %eax
andl $0x800000, %eax         # imm = 0x800000
cmpl $0x0, %eax
je 0x44a8f
movq -0x8(%rbp), %rax
movl 0x98(%rax), %ecx
orl $0x1000000, %ecx        # imm = 0x1000000
movl %ecx, 0x98(%rax)
movq -0x8(%rbp), %rax
movl 0x98(%rax), %ecx
andl $0xff7fffff, %ecx       # imm = 0xFF7FFFFF
movl %ecx, 0x98(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/networking.c
// Function: setProtocolError
static void setProtocolError(client *c, int pos) {
    if (server.verbosity <= LL_VERBOSE) {
        sds client = catClientInfoString(sdsempty(),c);
        serverLog(LL_VERBOSE,
            "Protocol error from client: %s", client);
        sdsfree(client);
    }
    c->flags |= CLIENT_CLOSE_AFTER_REPLY;
    sdsrange(c->querybuf,pos,-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x1334f2(%rip), %rax    # 0x1781d8
cmpl $0x1, 0x5f8(%rax)
jg 0x44d24
callq 0x384f0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x455c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
movl $0x1, %edi
leaq 0xf67b9(%rip), %rsi     # 0x13b4cd
movb $0x0, %al
callq 0x2fc60
movq -0x18(%rbp), %rdi
callq 0x38620
movq -0x8(%rbp), %rax
movl 0x98(%rax), %ecx
orl $0x40, %ecx
movl %ecx, 0x98(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movl -0xc(%rbp), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x39db0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/networking.c
// Function: clientsArePaused
int clientsArePaused(void) {
    if (server.clients_paused &&
        server.clients_pause_end_time < server.mstime)
    {
        listNode *ln;
        listIter li;
        client *c;

        server.clients_paused = 0;

        /* Put all the clients in the unblocked clients queue in order to
         * force the re-processing of the input buffer if any. */
        listRewind(server.clients,&li);
        while ((ln = listNext(&li)) != NULL) {
            c = listNodeValue(ln);

            /* Don't touch slaves and blocked clients. The latter pending
             * requests be processed when unblocked. */
            if (c->flags & (CLIENT_SLAVE|CLIENT_BLOCKED)) continue;
            c->flags |= CLIENT_UNBLOCKED;
            listAddNodeTail(server.unblocked_clients,c);
        }
    }
    return server.clients_paused;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x132ce9(%rip), %rax    # 0x1781d8
cmpl $0x0, 0x1f8(%rax)
je 0x455aa
leaq 0x132cd5(%rip), %rax    # 0x1781d8
movq 0x200(%rax), %rax
leaq 0x132cc7(%rip), %rcx    # 0x1781d8
cmpq 0x980(%rcx), %rax
jge 0x455aa
leaq 0x132cb3(%rip), %rax    # 0x1781d8
movl $0x0, 0x1f8(%rax)
leaq 0x132ca2(%rip), %rax    # 0x1781d8
movq 0x1c8(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x27320
leaq -0x18(%rbp), %rdi
callq 0x27380
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x455a8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x98(%rax), %eax
andl $0x11, %eax
cmpl $0x0, %eax
je 0x45579
jmp 0x45546
movq -0x20(%rbp), %rax
movl 0x98(%rax), %ecx
orl $0x80, %ecx
movl %ecx, 0x98(%rax)
leaq 0x132c42(%rip), %rax    # 0x1781d8
movq 0x920(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x27000
jmp 0x45546
jmp 0x455aa
leaq 0x132c27(%rip), %rax    # 0x1781d8
movl 0x1f8(%rax), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/networking.c
// Function: getClientsMaxBuffers
void getClientsMaxBuffers(unsigned long *longest_output_list,
                          unsigned long *biggest_input_buffer) {
    client *c;
    listNode *ln;
    listIter li;
    unsigned long lol = 0, bib = 0;

    listRewind(server.clients,&li);
    while ((ln = listNext(&li)) != NULL) {
        c = listNodeValue(ln);

        if (listLength(c->reply) > lol) lol = listLength(c->reply);
        if (sdslen(c->querybuf) > bib) bib = sdslen(c->querybuf);
    }
    *longest_output_list = lol;
    *biggest_input_buffer = bib;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
leaq 0x1326d1(%rip), %rax    # 0x1781d8
movq 0x1c8(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x27320
leaq -0x30(%rbp), %rdi
callq 0x27380
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x45b7e
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq 0x28(%rax), %rax
cmpq -0x38(%rbp), %rax
jbe 0x45b58
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x42810
cmpq -0x40(%rbp), %rax
jbe 0x45b7c
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x42810
movq %rax, -0x40(%rbp)
jmp 0x45b17
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/networking.c
// Function: genClientPeerId
void genClientPeerId(client *client, char *peerid,
                            size_t peerid_len) {
    if (client->flags & CLIENT_UNIX_SOCKET) {
        /* Unix socket client. */
        snprintf(peerid,peerid_len,"%s:0",server.unixsocket);
    } else {
        /* TCP client. */
        anetFormatPeer(client->fd,peerid,peerid_len);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x98(%rax), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x45bee
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x132601(%rip), %rax    # 0x1781d8
movq 0x130(%rax), %rcx
leaq 0xf514f(%rip), %rdx     # 0x13ad34
movb $0x0, %al
callq 0x26120
jmp 0x45c02
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2ce30
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/networking.c
// Function: getClientPeerId
char *getClientPeerId(client *c) {
    char peerid[NET_PEER_ID_LEN];

    if (c->peerid == NULL) {
        genClientPeerId(c,peerid,sizeof(peerid));
        c->peerid = sdsnew(peerid);
    }
    return c->peerid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x1b8(%rax)
jne 0x45c53
movq -0x8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x4e, %edx
callq 0x45ba0
leaq -0x60(%rbp), %rdi
callq 0x38510
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x1b8(%rax)
movq -0x8(%rbp), %rax
movq 0x1b8(%rax), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/networking.c
// Function: getAllClientsInfoString
sds getAllClientsInfoString(void) {
    listNode *ln;
    listIter li;
    client *client;
    sds o = sdsnewlen(NULL,200*listLength(server.clients));
    sdsclear(o);
    listRewind(server.clients,&li);
    while ((ln = listNext(&li)) != NULL) {
        client = listNodeValue(ln);
        o = catClientInfoString(o,client);
        o = sdscatlen(o,"\n",1);
    }
    return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x132439(%rip), %rax    # 0x1781d8
movq 0x1c8(%rax), %rax
imulq $0xc8, 0x28(%rax), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x38230
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x38740
leaq 0x13240d(%rip), %rax    # 0x1781d8
movq 0x1c8(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x27320
leaq -0x18(%rbp), %rdi
callq 0x27380
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x45e26
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x455c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0xf4023(%rip), %rsi     # 0x139e39
movl $0x1, %edx
callq 0x39040
movq %rax, -0x28(%rbp)
jmp 0x45ddb
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq