LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: unlinkClient
void unlinkClient(client *c) {
    listNode *ln;

    /* If this is marked as current client unset it. */
    if (server.current_client == c) server.current_client = NULL;

    /* Certain operations must be done only if the client has an active socket.
     * If the client was already unlinked or if it's a "fake client" the
     * fd is already set to -1. */
    if (c->fd != -1) {
        /* Remove from the list of active clients. */
        ln = listSearchKey(server.clients,c);
        serverAssert(ln != NULL);
        listDelNode(server.clients,ln);

        /* Unregister async I/O handlers and close the socket. */
        aeDeleteFileEvent(server.el,c->fd,AE_READABLE);
        aeDeleteFileEvent(server.el,c->fd,AE_WRITABLE);
        close(c->fd);
        c->fd = -1;
    }

    /* Remove from the list of pending writes if needed. */
    if (c->flags & CLIENT_PENDING_WRITE) {
        ln = listSearchKey(server.clients_pending_write,c);
        serverAssert(ln != NULL);
        listDelNode(server.clients_pending_write,ln);
        c->flags &= ~CLIENT_PENDING_WRITE;
    }

    /* When client was just unblocked because of a blocking operation,
     * remove it from the list of unblocked clients. */
    if (c->flags & CLIENT_UNBLOCKED) {
        ln = listSearchKey(server.unblocked_clients,c);
        serverAssert(ln != NULL);
        listDelNode(server.unblocked_clients,ln);
        c->flags &= ~CLIENT_UNBLOCKED;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xc3f19(%rip), %r14     # 0x1018a8
cmpq %rdi, 0x1f0(%r14)
jne 0x3d9a3
movq $0x0, 0x1f0(%r14)
cmpl $-0x1, 0x8(%rbx)
je 0x3da01
movq 0x1c8(%r14), %rdi
movq %rbx, %rsi
callq 0x2b470
testq %rax, %rax
je 0x3da77
movq 0x1c8(%r14), %rdi
movq %rax, %rsi
callq 0x2b331
movq 0x40(%r14), %rdi
movl 0x8(%rbx), %esi
movl $0x1, %edx
callq 0x2cf0e
movq 0x40(%r14), %rdi
movl 0x8(%rbx), %esi
movl $0x2, %edx
callq 0x2cf0e
movl 0x8(%rbx), %edi
callq 0x26180
movl $0xffffffff, 0x8(%rbx)  # imm = 0xFFFFFFFF
movl 0x98(%rbx), %eax
btl $0x15, %eax
jae 0x3da41
movq 0x1d8(%r14), %rdi
movq %rbx, %rsi
callq 0x2b470
testq %rax, %rax
je 0x3da8c
movq 0x1d8(%r14), %rdi
movq %rax, %rsi
callq 0x2b331
movl $0xffdfffff, %eax       # imm = 0xFFDFFFFF
andl 0x98(%rbx), %eax
movl %eax, 0x98(%rbx)
testb %al, %al
jns 0x3da6f
movq 0x920(%r14), %rdi
movq %rbx, %rsi
callq 0x2b470
testq %rax, %rax
je 0x3daa1
movq 0x920(%r14), %rdi
movq %rax, %rsi
callq 0x2b331
andb $0x7f, 0x98(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x82586(%rip), %rdi     # 0xc0004
leaq 0x824d1(%rip), %rsi     # 0xbff56
movl $0x2f6, %edx            # imm = 0x2F6
jmp 0x3dab4
leaq 0x82571(%rip), %rdi     # 0xc0004
leaq 0x824bc(%rip), %rsi     # 0xbff56
movl $0x303, %edx            # imm = 0x303
jmp 0x3dab4
leaq 0x8255c(%rip), %rdi     # 0xc0004
leaq 0x824a7(%rip), %rsi     # 0xbff56
movl $0x30c, %edx            # imm = 0x30C
callq 0x61908
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x38(%rdi)
jle 0x3daec
xorl %r14d, %r14d
movq 0x40(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x40c8f
incq %r14
movslq 0x38(%rbx), %rax
cmpq %rax, %r14
jl 0x3dad3
movl $0x0, 0x38(%rbx)
movq $0x0, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
leaq 0xc3d6b(%rip), %r14     # 0x1018a8
movq 0x1d0(%r14), %rax
cmpq $0x0, 0x28(%rax)
je 0x3db72
movq (%rax), %rbx
movq 0x10(%rbx), %rdi
andl $0xfffffbff, 0x98(%rdi) # imm = 0xFFFFFBFF
callq 0x3d73b
movq 0x1d0(%r14), %rdi
movq %rbx, %rsi
callq 0x2b331
jmp 0x3db3d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0xc3a80(%rip), %r13     # 0x1018a8
movq 0x1d8(%r13), %rdi
movq 0x28(%rdi), %rbx
movq %rsp, %r14
movq %r14, %rsi
callq 0x2b3b7
movq %r14, %rdi
callq 0x2b3d4
testq %rax, %rax
je 0x3defd
movq %rsp, %r14
leaq -0x54(%rip), %r15       # 0x3de05
movq 0x10(%rax), %r12
andl $0xffdfffff, 0x98(%r12) # imm = 0xFFDFFFFF
movq 0x1d8(%r13), %rdi
movq %rax, %rsi
callq 0x2b331
movl 0x8(%r12), %edi
movq %r12, %rsi
xorl %edx, %edx
callq 0x3db7a
cmpl $-0x1, %eax
je 0x3deec
cmpl $0x0, 0x1c0(%r12)
jne 0x3dea3
movq 0x68(%r12), %rax
cmpq $0x0, 0x28(%rax)
je 0x3deec
movq 0x40(%r13), %rdi
movl 0x8(%r12), %esi
movl $0x2, %edx
movq %r15, %rcx
movq %r12, %r8
callq 0x2ce46
cmpl $-0x1, %eax
jne 0x3deec
movl 0x98(%r12), %eax
testl $0x500, %eax            # imm = 0x500
jne 0x3deec
orl $0x400, %eax            # imm = 0x400
movl %eax, 0x98(%r12)
movq 0x1d0(%r13), %rdi
movq %r12, %rsi
callq 0x2b24b
movq %r14, %rdi
callq 0x2b3d4
testq %rax, %rax
jne 0x3de59
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x3df2d
movq 0x8(%rax), %rax
cmpq 0xbeff1(%rip), %rax     # 0xfcf18
setne %bpl
jmp 0x3df30
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x3dac3
movq $0x0, 0x58(%rbx)
movq $-0x1, 0x60(%rbx)
movl 0x98(%rbx), %eax
movl %eax, %ecx
andl $0xfffffdf7, %ecx       # imm = 0xFFFFFDF7
testb $0x1, %bpl
cmovel %eax, %ecx
testb $0x8, %al
cmovnel %eax, %ecx
movl %ecx, %eax
andl $0xfeffffff, %eax       # imm = 0xFEFFFFFF
movl %ecx, %edx
andl $0xfe7fffff, %edx       # imm = 0xFE7FFFFF
orl $0x1000000, %edx        # imm = 0x1000000
btl $0x17, %ecx
cmovael %eax, %edx
movl %edx, 0x98(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0xc371d(%rip), %rax     # 0x1018a8
cmpl $0x1, 0x5f8(%rax)
jg 0x3e1c5
callq 0x3628d
movq %rax, %rdi
movq %r14, %rsi
callq 0x3e908
movq %rax, %r15
leaq 0x8283f(%rip), %rsi     # 0xc09ed
movl $0x1, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2fdad
movq %r15, %rdi
callq 0x36330
orb $0x40, 0x98(%r14)
movq 0x28(%r14), %rdi
movl %ebx, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
jmp 0x377b2
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x18, %rsp
leaq 0xc3031(%rip), %r14     # 0x1018a8
movl 0x1f8(%r14), %eax
testl %eax, %eax
je 0x3e8fe
movq 0x200(%r14), %rcx
cmpq 0x980(%r14), %rcx
jge 0x3e900
movl $0x0, 0x1f8(%r14)
movq 0x1c8(%r14), %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x2b3b7
movq %rbx, %rdi
callq 0x2b3d4
testq %rax, %rax
je 0x3e8f5
leaq 0x8(%rsp), %rbx
movq 0x10(%rax), %rsi
movl 0x98(%rsi), %eax
testb $0x11, %al
jne 0x3e8e8
orl $0x80, %eax
movl %eax, 0x98(%rsi)
movq 0x920(%r14), %rdi
callq 0x2b24b
movq %rbx, %rdi
callq 0x2b3d4
testq %rax, %rax
jne 0x3e8c3
movl 0x1f8(%r14), %eax
jmp 0x3e900
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, (%rsp)
movq %rdi, %r14
leaq 0xc2c84(%rip), %rax     # 0x1018a8
movq 0x1c8(%rax), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x2b3b7
movq %r15, %rdi
callq 0x2b3d4
testq %rax, %rax
je 0x3eced
xorl %ebx, %ebx
leaq 0x8(%rsp), %r15
leaq 0x81289(%rip), %r13     # 0xbfee0
leaq 0x81296(%rip), %rbp     # 0xbfef4
xorl %r12d, %r12d
movq 0x10(%rax), %rcx
movq 0x28(%rcx), %rax
movq 0x68(%rcx), %rcx
movq 0x28(%rcx), %rcx
cmpq %r12, %rcx
cmovaq %rcx, %r12
movzbl -0x1(%rax), %ecx
movl %ecx, %edx
andl $0x7, %edx
cmpl $0x4, %edx
ja 0x3ecda
movslq (%r13,%rdx,4), %rsi
addq %r13, %rsi
jmpq *%rsi
movl %ecx, %esi
shrl $0x3, %esi
jmp 0x3ecac
movq -0x11(%rax), %rsi
jmp 0x3ecac
movzwl -0x5(%rax), %esi
jmp 0x3ecac
movl -0x9(%rax), %esi
jmp 0x3ecac
movzbl -0x3(%rax), %esi
cmpq %rbx, %rsi
jbe 0x3ecda
movl %edx, %edx
movslq (%rbp,%rdx,4), %rdx
addq %rbp, %rdx
jmpq *%rdx
shrl $0x3, %ecx
movq %rcx, %rbx
jmp 0x3ecda
movq -0x11(%rax), %rbx
jmp 0x3ecda
movzwl -0x5(%rax), %ebx
jmp 0x3ecda
movl -0x9(%rax), %ebx
jmp 0x3ecda
movzbl -0x3(%rax), %ebx
movq %r15, %rdi
callq 0x2b3d4
testq %rax, %rax
jne 0x3ec61
jmp 0x3ecf2
xorl %r12d, %r12d
xorl %ebx, %ebx
movq %r12, (%r14)
movq (%rsp), %rax
movq %rbx, (%rax)
addq $0x18, %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: 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:
movq 0x1b8(%rdi), %rax
testq %rax, %rax
je 0x3ed4e
retq
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movl $0x4e, %edx
movq %r14, %rsi
callq 0x3ed0b
movq %r14, %rdi
callq 0x362b0
movq %rax, 0x1b8(%rbx)
addq $0x58, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xc2b04(%rip), %r14     # 0x1018a8
movq 0x1c8(%r14), %rax
imulq $0xc8, 0x28(%rax), %rsi
xorl %edi, %edi
callq 0x36178
movq %rax, %rbx
movq %rax, %rdi
callq 0x3639d
movq 0x1c8(%r14), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0x2b3b7
movq %r14, %rdi
callq 0x2b3d4
testq %rax, %rax
je 0x3ee1a
leaq 0x800de(%rip), %r14     # 0xbeec9
movq %rsp, %r15
movq 0x10(%rax), %rsi
movq %rbx, %rdi
callq 0x3e908
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x36ad1
movq %rax, %rbx
movq %r15, %rdi
callq 0x2b3d4
testq %rax, %rax
jne 0x3edee
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: getClientTypeByName
int getClientTypeByName(char *name) {
    if (!strcasecmp(name,"normal")) return CLIENT_TYPE_NORMAL;
    else if (!strcasecmp(name,"slave")) return CLIENT_TYPE_SLAVE;
    else if (!strcasecmp(name,"pubsub")) return CLIENT_TYPE_PUBSUB;
    else if (!strcasecmp(name,"master")) return CLIENT_TYPE_MASTER;
    else return -1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x8e049(%rip), %rsi     # 0xcd537
callq 0x262f0
testl %eax, %eax
je 0x3f539
leaq 0x897f7(%rip), %rsi     # 0xc8cf5
movq %rbx, %rdi
callq 0x262f0
testl %eax, %eax
je 0x3f53d
leaq 0x7d3cf(%rip), %rsi     # 0xbc8e0
movq %rbx, %rdi
callq 0x262f0
testl %eax, %eax
je 0x3f544
leaq 0x8977f(%rip), %rsi     # 0xc8ca3
movq %rbx, %rdi
callq 0x262f0
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
orl $0x3, %eax
jmp 0x3f549
xorl %eax, %eax
jmp 0x3f549
movl $0x1, %eax
jmp 0x3f549
movl $0x2, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: securityWarningCommand
void securityWarningCommand(client *c) {
    static time_t logged_time;
    time_t now = time(NULL);

    if (labs(now-logged_time) > 60) {
        serverLog(LL_WARNING,"Possible SECURITY ATTACK detected. It looks like somebody is sending POST or Host: commands to Redis. This is likely due to an attacker attempting to use Cross Protocol Scripting to compromise your Redis instance. Connection aborted.");
        logged_time = now;
    }
    freeClientAsync(c);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %edi, %edi
callq 0x26cd0
movq %rax, %r14
subq 0xd6b6a(%rip), %rax     # 0x116120
movq %rax, %rcx
negq %rcx
cmovsq %rax, %rcx
cmpq $0x3d, %rcx
jb 0x3f5e0
leaq 0x80dfa(%rip), %rsi     # 0xc03c7
movl $0x3, %edi
xorl %eax, %eax
callq 0x2fdad
movq %r14, 0xd6b40(%rip)     # 0x116120
movl 0x98(%rbx), %eax
testl $0x500, %eax            # imm = 0x500
je 0x3f5f5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
orl $0x400, %eax            # imm = 0x400
movl %eax, 0x98(%rbx)
leaq 0xc22a1(%rip), %rax     # 0x1018a8
movq 0x1d0(%rax), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2b24b
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: rewriteClientCommandVector
void rewriteClientCommandVector(client *c, int argc, ...) {
    va_list ap;
    int j;
    robj **argv; /* The new argument vector */

    argv = zmalloc(sizeof(robj*)*argc);
    va_start(ap,argc);
    for (j = 0; j < argc; j++) {
        robj *a;

        a = va_arg(ap, robj*);
        argv[j] = a;
        incrRefCount(a);
    }
    /* We free the objects in the original vector at the end, so we are
     * sure that if the same objects are reused in the new vector the
     * refcount gets incremented before it gets decremented. */
    for (j = 0; j < c->argc; j++) decrRefCount(c->argv[j]);
    zfree(c->argv);
    /* Replace argv and argc with our new versions. */
    c->argv = argv;
    c->argc = argc;
    c->cmd = lookupCommandOrOriginal(c->argv[0]->ptr);
    serverAssertWithInfo(c,NULL,c->cmd != NULL);
    va_end(ap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %rdx, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
testb %al, %al
je 0x3f681
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)
movslq %esi, %r12
leaq (,%r12,8), %rdi
callq 0x382d1
movq %rax, %r14
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r15, 0x10(%rsp)
testl %r12d, %r12d
jle 0x3f6fa
movl %ebp, %r15d
xorl %r12d, %r12d
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x3f6d8
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x3f6e6
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdi
movq %rdi, (%r14,%r12,8)
callq 0x407a8
incq %r12
cmpq %r12, %r15
jne 0x3f6bf
cmpl $0x0, 0x38(%rbx)
jle 0x3f71c
xorl %r15d, %r15d
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x40c8f
incq %r15
movslq 0x38(%rbx), %rax
cmpq %rax, %r15
jl 0x3f703
movq 0x40(%rbx), %rdi
callq 0x38413
movq %r14, 0x40(%rbx)
movl %ebp, 0x38(%rbx)
movq (%r14), %rax
movq 0x8(%rax), %rdi
callq 0x32d4b
movq %rax, 0x48(%rbx)
testq %rax, %rax
je 0x3f751
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x80d59(%rip), %rdx     # 0xc04b1
leaq 0x807f7(%rip), %rcx     # 0xbff56
movq %rbx, %rdi
xorl %esi, %esi
movl $0x698, %r8d            # imm = 0x698
callq 0x627c3
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: replaceClientCommandVector
void replaceClientCommandVector(client *c, int argc, robj **argv) {
    freeClientArgv(c);
    zfree(c->argv);
    c->argv = argv;
    c->argc = argc;
    c->cmd = lookupCommandOrOriginal(c->argv[0]->ptr);
    serverAssertWithInfo(c,NULL,c->cmd != NULL);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x3dac3
movq 0x40(%rbx), %rdi
callq 0x38413
movq %r14, 0x40(%rbx)
movl %ebp, 0x38(%rbx)
movq (%r14), %rax
movq 0x8(%rax), %rdi
callq 0x32d4b
movq %rax, 0x48(%rbx)
testq %rax, %rax
je 0x3f7b4
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x80cf6(%rip), %rdx     # 0xc04b1
leaq 0x80794(%rip), %rcx     # 0xbff56
movq %rbx, %rdi
xorl %esi, %esi
movl $0x6a3, %r8d            # imm = 0x6A3
callq 0x627c3
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: rewriteClientCommandArgument
void rewriteClientCommandArgument(client *c, int i, robj *newval) {
    robj *oldval;

    if (i >= c->argc) {
        c->argv = zrealloc(c->argv,sizeof(robj*)*(i+1));
        c->argc = i+1;
        c->argv[i] = NULL;
    }
    oldval = c->argv[i];
    c->argv[i] = newval;
    incrRefCount(newval);
    if (oldval) decrRefCount(oldval);

    /* If this is the command name make sure to fix c->cmd. */
    if (i == 0) {
        c->cmd = lookupCommandOrOriginal(c->argv[0]->ptr);
        serverAssertWithInfo(c,NULL,c->cmd != NULL);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %r14d
movq %rdi, %rbx
cmpl %esi, 0x38(%rdi)
jle 0x3f7fa
movslq %r14d, %r13
jmp 0x3f821
movq 0x40(%rbx), %rdi
leal 0x1(%r14), %ebp
movslq %r14d, %r13
leaq 0x8(,%r13,8), %rsi
callq 0x3837d
movq %rax, 0x40(%rbx)
movl %ebp, 0x38(%rbx)
movq $0x0, (%rax,%r13,8)
movq 0x40(%rbx), %rax
movq (%rax,%r13,8), %r12
movq %r15, (%rax,%r13,8)
movq %r15, %rdi
callq 0x407a8
testq %r12, %r12
je 0x3f842
movq %r12, %rdi
callq 0x40c8f
testl %r14d, %r14d
jne 0x3f860
movq 0x40(%rbx), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x32d4b
movq %rax, 0x48(%rbx)
testq %rax, %rax
je 0x3f86f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x80c3b(%rip), %rdx     # 0xc04b1
leaq 0x806d9(%rip), %rcx     # 0xbff56
movq %rbx, %rdi
xorl %esi, %esi
movl $0x6c1, %r8d            # imm = 0x6C1
callq 0x627c3
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: checkClientOutputBufferLimits
int checkClientOutputBufferLimits(client *c) {
    int soft = 0, hard = 0, class;
    unsigned long used_mem = getClientOutputBufferMemoryUsage(c);

    class = getClientType(c);
    /* For the purpose of output buffer limiting, masters are handled
     * like normal clients. */
    if (class == CLIENT_TYPE_MASTER) class = CLIENT_TYPE_NORMAL;

    if (server.client_obuf_limits[class].hard_limit_bytes &&
        used_mem >= server.client_obuf_limits[class].hard_limit_bytes)
        hard = 1;
    if (server.client_obuf_limits[class].soft_limit_bytes &&
        used_mem >= server.client_obuf_limits[class].soft_limit_bytes)
        soft = 1;

    /* We need to check if the soft limit is reached continuously for the
     * specified amount of seconds. */
    if (soft) {
        if (c->obuf_soft_limit_reached_time == 0) {
            c->obuf_soft_limit_reached_time = server.unixtime;
            soft = 0; /* First time we see the soft limit reached */
        } else {
            time_t elapsed = server.unixtime - c->obuf_soft_limit_reached_time;

            if (elapsed <=
                server.client_obuf_limits[class].soft_limit_seconds) {
                soft = 0; /* The client still did not reached the max number of
                             seconds for the soft limit to be considered
                             reached. */
            }
        }
    } else {
        c->obuf_soft_limit_reached_time = 0;
    }
    return soft || hard;
}

// Assembly:
movq 0x68(%rdi), %rax
movq 0x28(%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x3, %rax
addq 0x70(%rdi), %rax
movl 0x98(%rdi), %ecx
testb $0x2, %cl
jne 0x3f8e9
movl %ecx, %esi
andl $0x5, %esi
movl $0x1, %edx
cmpl $0x1, %esi
je 0x3f8eb
shrl $0x11, %ecx
andl $0x2, %ecx
movq %rcx, %rdx
jmp 0x3f8eb
xorl %edx, %edx
leaq (%rdx,%rdx,2), %rdx
leaq 0xc1fb2(%rip), %rsi     # 0x1018a8
movq 0x620(%rsi,%rdx,8), %rcx
movq 0x628(%rsi,%rdx,8), %r8
decq %r8
cmpq %rax, %r8
jae 0x3f938
movq 0x90(%rdi), %r9
movq 0x978(%rsi), %r8
testq %r9, %r9
je 0x3f945
leaq (%rsi,%rdx,8), %rdx
addq $0x620, %rdx            # imm = 0x620
subq %r9, %r8
cmpq 0x10(%rdx), %r8
setg %dl
jmp 0x3f94e
movq $0x0, 0x90(%rdi)
jmp 0x3f94c
movq %r8, 0x90(%rdi)
xorl %edx, %edx
decq %rcx
cmpq %rax, %rcx
setb %al
orb %dl, %al
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: flushSlavesOutputBuffers
void flushSlavesOutputBuffers(void) {
    listIter li;
    listNode *ln;

    listRewind(server.slaves,&li);
    while((ln = listNext(&li))) {
        client *slave = listNodeValue(ln);
        int events;

        /* Note that the following will not flush output buffers of slaves
         * in STATE_ONLINE but having put_online_on_ack set to true: in this
         * case the writable event is never installed, since the purpose
         * of put_online_on_ack is to postpone the moment it is installed.
         * This is what we want since slaves in this state should not receive
         * writes before the first ACK. */
        events = aeGetFileEvents(server.el,slave->fd);
        if (events & AE_WRITABLE &&
            slave->replstate == SLAVE_STATE_ONLINE &&
            clientHasPendingReplies(slave))
        {
            writeToClient(slave->fd,slave,0);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xc1f3b(%rip), %r15     # 0x1018a8
movq 0x1e0(%r15), %rdi
movq %rsp, %rbx
movq %rbx, %rsi
callq 0x2b3b7
movq %rbx, %rdi
callq 0x2b3d4
testq %rax, %rax
je 0x3f9de
movq %rsp, %rbx
movq 0x10(%rax), %r14
movq 0x40(%r15), %rdi
movl 0x8(%r14), %esi
callq 0x2cfd5
testb $0x2, %al
je 0x3f9d1
cmpl $0x9, 0xa0(%r14)
jne 0x3f9d1
cmpl $0x0, 0x1c0(%r14)
jne 0x3f9c3
movq 0x68(%r14), %rax
cmpq $0x0, 0x28(%rax)
je 0x3f9d1
movl 0x8(%r14), %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3db7a
movq %rbx, %rdi
callq 0x2b3d4
testq %rax, %rax
jne 0x3f98f
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/networking.c
// Function: processEventsWhileBlocked
int processEventsWhileBlocked(void) {
    int iterations = 4; /* See the function top-comment. */
    int count = 0;
    while (iterations--) {
        int events = 0;
        events += aeProcessEvents(server.el, AE_FILE_EVENTS|AE_DONT_WAIT);
        events += handleClientsWithPendingWrites();
        if (!events) break;
        count += events;
    }
    return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
movl $0xfffffffb, %r14d      # imm = 0xFFFFFFFB
leaq 0xc1eaa(%rip), %r15     # 0x1018a8
incl %r14d
je 0x3fa20
movq 0x40(%r15), %rdi
movl $0x5, %esi
callq 0x2d10e
movl %eax, %ebp
callq 0x3de14
addl %ebp, %eax
addl %eax, %ebx
testl %eax, %eax
jne 0x3f9fe
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/util.c
// Function: digits10
uint32_t digits10(uint64_t v) {
    if (v < 10) return 1;
    if (v < 100) return 2;
    if (v < 1000) return 3;
    if (v < 1000000000000UL) {
        if (v < 100000000UL) {
            if (v < 1000000) {
                if (v < 10000) return 4;
                return 5 + (v >= 100000);
            }
            return 7 + (v >= 10000000UL);
        }
        if (v < 10000000000UL) {
            return 9 + (v >= 1000000000UL);
        }
        return 11 + (v >= 100000000000UL);
    }
    return 12 + digits10(v / 1000000000000UL);
}

// Assembly:
movl $0x1, %esi
xorl %ecx, %ecx
cmpq $0xa, %rdi
jb 0x3ff68
xorl %ecx, %ecx
movabsq $0x232f33025bd42233, %r8 # imm = 0x232F33025BD42233
cmpq $0x64, %rdi
jb 0x3feee
cmpq $0x3e8, %rdi            # imm = 0x3E8
jb 0x3fef5
movq %rdi, %rax
shrq $0xc, %rax
cmpq $0xe8d4a50, %rax        # imm = 0xE8D4A50
jbe 0x3fefc
movq %rdi, %rax
mulq %r8
shrq $0x25, %rdx
addl $0xc, %ecx
shrq $0xd, %rdi
cmpq $0x48c27394, %rdi       # imm = 0x48C27394
movq %rdx, %rdi
ja 0x3feb1
jmp 0x3ff68
movl $0x2, %esi
jmp 0x3ff68
movl $0x3, %esi
jmp 0x3ff68
cmpq $0x5f5e0ff, %rdi        # imm = 0x5F5E0FF
ja 0x3ff2a
cmpq $0xf423f, %rdi          # imm = 0xF423F
ja 0x3ff47
movl $0x4, %esi
cmpq $0x2710, %rdi           # imm = 0x2710
jb 0x3ff68
cmpq $0x186a0, %rdi          # imm = 0x186A0
movl $0x5, %esi
jmp 0x3ff65
movq %rdi, %rax
shrq $0xa, %rax
cmpq $0x9502f8, %rax         # imm = 0x9502F8
ja 0x3ff55
cmpq $0x3b9aca00, %rdi       # imm = 0x3B9ACA00
movl $0x9, %esi
jmp 0x3ff65
cmpq $0x989680, %rdi         # imm = 0x989680
movl $0x7, %esi
jmp 0x3ff65
shrq $0xb, %rdi
cmpq $0x2e90edd, %rdi        # imm = 0x2E90EDD
movl $0xb, %esi
sbbl $-0x1, %esi
addl %esi, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/util.c
// Function: ll2string
int ll2string(char* dst, size_t dstlen, long long svalue) {
    static const char digits[201] =
        "0001020304050607080910111213141516171819"
        "2021222324252627282930313233343536373839"
        "4041424344454647484950515253545556575859"
        "6061626364656667686970717273747576777879"
        "8081828384858687888990919293949596979899";
    int negative;
    unsigned long long value;

    /* The main loop works with 64bit unsigned integers for simplicity, so
     * we convert the number here and remember if it is negative. */
    if (svalue < 0) {
        if (svalue != LLONG_MIN) {
            value = -svalue;
        } else {
            value = ((unsigned long long) LLONG_MAX)+1;
        }
        negative = 1;
    } else {
        value = svalue;
        negative = 0;
    }

    /* Check length. */
    uint32_t const length = digits10(value)+negative;
    if (length >= dstlen) return 0;

    /* Null term. */
    uint32_t next = length;
    dst[next] = '\0';
    next--;
    while (value >= 100) {
        int const i = (value % 100) * 2;
        value /= 100;
        dst[next] = digits[i + 1];
        dst[next - 1] = digits[i];
        next -= 2;
    }

    /* Handle last 1-2 digits. */
    if (value < 10) {
        dst[next] = '0' + (uint32_t) value;
    } else {
        int i = (uint32_t) value * 2;
        dst[next] = digits[i + 1];
        dst[next - 1] = digits[i];
    }

    /* Add sign. */
    if (negative) dst[0] = '-';
    return length;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, %r15
negq %r15
cmovsq %rdx, %r15
movq %rdx, %r13
shrq $0x3f, %r13
movq %r15, %rdi
callq 0x3fe94
movl %eax, %ecx
addl %r13d, %ecx
xorl %eax, %eax
cmpq %r12, %rcx
jae 0x4005b
movb $0x0, (%rbx,%rcx)
leal -0x1(%rcx), %esi
leaq 0x80af4(%rip), %rdi     # 0xc0ac0
cmpq $0x64, %r15
jb 0x4001c
movabsq $0x28f5c28f5c28f5c3, %r8 # imm = 0x28F5C28F5C28F5C3
movq %r15, %rax
shrq $0x2, %rax
mulq %r8
shrq $0x2, %rdx
imull $0x64, %edx, %eax
movl %r15d, %r9d
subl %eax, %r9d
movb (%rdi,%r9,2), %al
movb 0x1(%rdi,%r9,2), %r9b
movl %esi, %r10d
movb %r9b, (%rbx,%r10)
leal -0x1(%rsi), %r9d
movb %al, (%rbx,%r9)
addl $-0x2, %esi
cmpq $0x270f, %r15           # imm = 0x270F
movq %rdx, %r15
ja 0x3ffdc
jmp 0x4001f
movq %r15, %rdx
cmpq $0x9, %rdx
ja 0x4002a
orb $0x30, %dl
jmp 0x4004c
addq %rdx, %rdx
movabsq $0x1fffffffe, %rax      # imm = 0x1FFFFFFFE
andq %rdx, %rax
movl %edx, %edx
movb 0x1(%rdx,%rdi), %dl
movl %esi, %r8d
movb %dl, (%rbx,%r8)
movb (%rax,%rdi), %dl
decl %esi
movl %esi, %eax
movb %dl, (%rbx,%rax)
testq %r14, %r14
jns 0x40059
movb $0x2d, (%rbx)
movl %ecx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/util.c
// Function: string2ll
int string2ll(const char *s, size_t slen, long long *value) {
    const char *p = s;
    size_t plen = 0;
    int negative = 0;
    unsigned long long v;

    if (plen == slen)
        return 0;

    /* Special case: first and only digit is 0. */
    if (slen == 1 && p[0] == '0') {
        if (value != NULL) *value = 0;
        return 1;
    }

    if (p[0] == '-') {
        negative = 1;
        p++; plen++;

        /* Abort on only a negative sign. */
        if (plen == slen)
            return 0;
    }

    /* First digit should be 1-9, otherwise the string should just be 0. */
    if (p[0] >= '1' && p[0] <= '9') {
        v = p[0]-'0';
        p++; plen++;
    } else if (p[0] == '0' && slen == 1) {
        *value = 0;
        return 1;
    } else {
        return 0;
    }

    while (plen < slen && p[0] >= '0' && p[0] <= '9') {
        if (v > (ULLONG_MAX / 10)) /* Overflow. */
            return 0;
        v *= 10;

        if (v > (ULLONG_MAX - (p[0]-'0'))) /* Overflow. */
            return 0;
        v += p[0]-'0';

        p++; plen++;
    }

    /* Return if not all bytes were used. */
    if (plen < slen)
        return 0;

    if (negative) {
        if (v > ((unsigned long long)(-(LLONG_MIN+1))+1)) /* Overflow. */
            return 0;
        if (value != NULL) *value = -v;
    } else {
        if (v > LLONG_MAX) /* Overflow. */
            return 0;
        if (value != NULL) *value = v;
    }
    return 1;
}

// Assembly:
pushq %rbx
xorl %eax, %eax
testq %rsi, %rsi
je 0x4016e
movb (%rdi), %cl
cmpq $0x1, %rsi
jne 0x4009c
movzbl %cl, %edi
cmpl $0x2d, %edi
je 0x4016e
cmpl $0x30, %edi
jne 0x4012e
testq %rdx, %rdx
jne 0x40157
jmp 0x40169
movl $0x1, %r9d
cmpb $0x2d, %cl
jne 0x400b6
movb 0x1(%rdi), %r8b
incq %rdi
movl $0x2, %r9d
jmp 0x400b9
movl %ecx, %r8d
leal -0x31(%r8), %r10d
cmpb $0x9, %r10b
jae 0x4016e
addb $-0x30, %r8b
movzbl %r8b, %r8d
subq %r9, %rsi
jbe 0x40110
xorl %r9d, %r9d
movabsq $0x1999999999999999, %r10 # imm = 0x1999999999999999
movb 0x1(%rdi,%r9), %r11b
leal -0x3a(%r11), %ebx
cmpb $-0xa, %bl
jb 0x4013e
cmpq %r10, %r8
ja 0x4013e
addq %r8, %r8
leaq (%r8,%r8,4), %rbx
addb $-0x30, %r11b
movzbl %r11b, %r8d
addq %rbx, %r8
jb 0x4013e
incq %r9
cmpq %r9, %rsi
jne 0x400e1
cmpb $0x2d, %cl
jne 0x4015c
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmpq %rcx, %r8
ja 0x4016e
testq %rdx, %rdx
je 0x40169
negq %r8
jmp 0x40166
leal -0x31(%rcx), %eax
cmpb $0x8, %al
ja 0x40142
addb $-0x30, %cl
movzbl %cl, %r8d
jmp 0x40161
xorl %eax, %eax
jmp 0x4016e
cmpq $0x1, %rsi
sete %sil
cmpb $0x30, %cl
sete %cl
xorl %eax, %eax
testb %cl, %sil
je 0x4016e
xorl %r8d, %r8d
jmp 0x40166
testq %r8, %r8
js 0x4016e
testq %rdx, %rdx
je 0x40169
movq %r8, (%rdx)
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/util.c
// Function: string2l
int string2l(const char *s, size_t slen, long *lval) {
    long long llval;

    if (!string2ll(s,slen,&llval))
        return 0;

    if (llval < LONG_MIN || llval > LONG_MAX)
        return 0;

    *lval = (long)llval;
    return 1;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq 0x8(%rsp), %rdx
callq 0x40065
testl %eax, %eax
je 0x40195
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
movl $0x1, %eax
jmp 0x40197
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/util.c
// Function: d2string
int d2string(char *buf, size_t len, double value) {
    if (isnan(value)) {
        len = snprintf(buf,len,"nan");
    } else if (isinf(value)) {
        if (value < 0)
            len = snprintf(buf,len,"-inf");
        else
            len = snprintf(buf,len,"inf");
    } else if (value == 0) {
        /* See: http://en.wikipedia.org/wiki/Signed_zero, "Comparisons". */
        if (1.0/value < 0)
            len = snprintf(buf,len,"-0");
        else
            len = snprintf(buf,len,"0");
    } else {
#if (DBL_MANT_DIG >= 52) && (LLONG_MAX == 0x7fffffffffffffffLL)
        /* Check if the float is in a safe range to be casted into a
         * long long. We are assuming that long long is 64 bit here.
         * Also we are assuming that there are no implementations around where
         * double has precision < 52 bit.
         *
         * Under this assumptions we test if a double is inside an interval
         * where casting to long long is safe. Then using two castings we
         * make sure the decimal part is zero. If all this is true we use
         * integer printing function that is much faster. */
        double min = -4503599627370495; /* (2^52)-1 */
        double max = 4503599627370496; /* -(2^52) */
        if (value > min && value < max && value == ((double)((long long)value)))
            len = ll2string(buf,len,(long long)value);
        else
#endif
            len = snprintf(buf,len,"%.17g",value);
    }

    return len;
}

// Assembly:
ucomisd %xmm0, %xmm0
jp 0x4024d
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
xorpd %xmm1, %xmm1
cmpq %rcx, %rax
jne 0x401d3
ucomisd %xmm0, %xmm1
jbe 0x401f6
leaq 0x7fdd9(%rip), %rdx     # 0xbffaa
jmp 0x40238
ucomisd %xmm1, %xmm0
jne 0x401ff
jp 0x401ff
movsd 0x8083d(%rip), %xmm2    # 0xc0a20
divsd %xmm0, %xmm2
ucomisd %xmm2, %xmm1
jbe 0x40231
leaq 0x8089c(%rip), %rdx     # 0xc0a90
jmp 0x40238
leaq 0x7fdae(%rip), %rdx     # 0xbffab
jmp 0x40238
ucomisd 0x80809(%rip), %xmm0    # 0xc0a10
jbe 0x4023f
movsd 0x80807(%rip), %xmm1    # 0xc0a18
ucomisd %xmm0, %xmm1
jbe 0x4023f
cvttsd2si %xmm0, %rdx
xorps %xmm1, %xmm1
cvtsi2sd %rdx, %xmm1
ucomisd %xmm0, %xmm1
jne 0x4023f
jp 0x4023f
jmp 0x3ff83
leaq 0x831ee(%rip), %rdx     # 0xc3426
xorl %eax, %eax
jmp 0x26120
leaq 0x7fd69(%rip), %rdx     # 0xbffaf
movb $0x1, %al
jmp 0x26120
leaq 0x80838(%rip), %rdx     # 0xc0a8c
jmp 0x40238
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/object.c
// Function: createObject
robj *createObject(int type, void *ptr) {
    robj *o = zmalloc(sizeof(*o));
    o->type = type;
    o->encoding = OBJ_ENCODING_RAW;
    o->ptr = ptr;
    o->refcount = 1;

    /* Set the LRU to the current lruclock (minutes resolution). */
    o->lru = LRU_CLOCK();
    return o;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x10, %edi
callq 0x382d1
andl $0xf, %ebp
movb %bpl, (%rax)
movq %rbx, 0x8(%rax)
movl $0x1, 0x4(%rax)
leaq 0xc122e(%rip), %rcx     # 0x1018a8
movl 0x48(%rcx), %ecx
shll $0x8, %ecx
orl %ebp, %ecx
movl %ecx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/object.c
// Function: createEmbeddedStringObject
robj *createEmbeddedStringObject(const char *ptr, size_t len) {
    robj *o = zmalloc(sizeof(robj)+sizeof(struct sdshdr8)+len+1);
    struct sdshdr8 *sh = (void*)(o+1);

    o->type = OBJ_STRING;
    o->encoding = OBJ_ENCODING_EMBSTR;
    o->ptr = sh+1;
    o->refcount = 1;
    o->lru = LRU_CLOCK();

    sh->len = len;
    sh->alloc = len;
    sh->flags = SDS_TYPE_8;
    if (ptr) {
        memcpy(sh->buf,ptr,len);
        sh->buf[len] = '\0';
    } else {
        memset(sh->buf,0,len+1);
    }
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x14(%rsi), %rdi
callq 0x382d1
movq %rax, %r14
movb $-0x80, (%rax)
leaq 0x13(%rax), %r12
movq %r12, 0x8(%rax)
movl $0x1, 0x4(%rax)
leaq 0xc11b8(%rip), %rax     # 0x1018a8
movl 0x48(%rax), %eax
shll $0x8, %eax
orl $0x80, %eax
movl %eax, (%r14)
movb %bl, 0x10(%r14)
movb %bl, 0x11(%r14)
movb $0x1, 0x12(%r14)
testq %r15, %r15
je 0x40725
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x26c50
movb $0x0, (%r12,%rbx)
jmp 0x40735
incq %rbx
movq %r12, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x26110
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/object.c
// Function: createStringObjectFromLongLong
robj *createStringObjectFromLongLong(long long value) {
    robj *o;
    if (value >= 0 && value < OBJ_SHARED_INTEGERS) {
        incrRefCount(shared.integers[value]);
        o = shared.integers[value];
    } else {
        if (value >= LONG_MIN && value <= LONG_MAX) {
            o = createObject(OBJ_STRING, NULL);
            o->encoding = OBJ_ENCODING_INT;
            o->ptr = (void*)((long)value);
        } else {
            o = createObject(OBJ_STRING,sdsfromlonglong(value));
        }
    }
    return o;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x270f, %rdi           # imm = 0x270F
ja 0x40774
leaq 0xc1ba9(%rip), %rax     # 0x102310
movq 0x1b0(%rax,%rbx,8), %rax
incl 0x4(%rax)
jmp 0x407a6
movl $0x10, %edi
callq 0x382d1
movb $0x0, (%rax)
movq $0x0, 0x8(%rax)
movl $0x1, 0x4(%rax)
leaq 0xc1111(%rip), %rcx     # 0x1018a8
movl 0x48(%rcx), %ecx
shll $0x8, %ecx
orl $0x10, %ecx
movl %ecx, (%rax)
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/object.c
// Function: createStringObjectFromLongDouble
robj *createStringObjectFromLongDouble(long double value, int humanfriendly) {
    char buf[256];
    int len;

    if (isinf(value)) {
        /* Libc in odd systems (Hi Solaris!) will format infinite in a
         * different way, so better to handle it in an explicit way. */
        if (value > 0) {
            memcpy(buf,"inf",3);
            len = 3;
        } else {
            memcpy(buf,"-inf",4);
            len = 4;
        }
    } else if (humanfriendly) {
        /* We use 17 digits precision since with 128 bit floats that precision
         * after rounding is able to represent most small decimal numbers in a
         * way that is "non surprising" for the user (that is, most small
         * decimal numbers will be represented in a way that when converted
         * back into a string are exactly the same as what the user typed.) */
        len = snprintf(buf,sizeof(buf),"%.17Lf", value);
        /* Now remove trailing zeroes after the '.' */
        if (strchr(buf,'.') != NULL) {
            char *p = buf+len-1;
            while(*p == '0') {
                p--;
                len--;
            }
            if (*p == '.') len--;
        }
    } else {
        len = snprintf(buf,sizeof(buf),"%.17Lg", value);
    }
    return createStringObject(buf,len);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
fldt 0x140(%rsp)
fld %st(0)
fstpt 0x10(%rsp)
movl 0x18(%rsp), %eax
notl %eax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq 0x10(%rsp), %rcx
andl $0x7fff, %eax           # imm = 0x7FFF
orq %rcx, %rax
jne 0x407ff
fldz
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jbe 0x40847
movb $0x66, 0x22(%rsp)
movw $0x6e69, 0x20(%rsp)     # imm = 0x6E69
movl $0x3, %ebx
jmp 0x4087c
testl %edi, %edi
je 0x4085f
fstpt (%rsp)
leaq 0x80457(%rip), %rdx     # 0xc0c64
leaq 0x20(%rsp), %r14
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
xorl %eax, %eax
callq 0x26120
movl %eax, %ebx
movq %r14, %rdi
movl $0x2e, %esi
callq 0x267f0
testq %rax, %rax
je 0x4087c
movslq %ebx, %rbx
movzbl 0x1f(%rsp,%rbx), %eax
cmpl $0x30, %eax
jne 0x40856
decq %rbx
jmp 0x40838
movl $0x666e692d, 0x20(%rsp) # imm = 0x666E692D
movl $0x4, %ebx
jmp 0x4087c
cmpl $0x2e, %eax
jne 0x4087c
decl %ebx
jmp 0x4087c
fstpt (%rsp)
leaq 0x80402(%rip), %rdx     # 0xc0c6b
leaq 0x20(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
xorl %eax, %eax
callq 0x26120
movl %eax, %ebx
movslq %ebx, %rsi
leaq 0x20(%rsp), %rdi
callq 0x40744
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/object.c
// Function: dupStringObject
robj *dupStringObject(robj *o) {
    robj *d;

    serverAssert(o->type == OBJ_STRING);

    switch(o->encoding) {
    case OBJ_ENCODING_RAW:
        return createRawStringObject(o->ptr,sdslen(o->ptr));
    case OBJ_ENCODING_EMBSTR:
        return createEmbeddedStringObject(o->ptr,sdslen(o->ptr));
    case OBJ_ENCODING_INT:
        d = createObject(OBJ_STRING, NULL);
        d->encoding = OBJ_ENCODING_INT;
        d->ptr = o->ptr;
        return d;
    default:
        serverPanic("Wrong encoding.");
        break;
    }
}

// Assembly:
pushq %rbx
movl (%rdi), %eax
testb $0xf, %al
jne 0x40985
movq %rdi, %rbx
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
je 0x40920
cmpl $0x1, %eax
je 0x408e8
testl %eax, %eax
jne 0x4099f
movq 0x8(%rbx), %rdi
movzbl -0x1(%rdi), %esi
movl %esi, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x4097d
leaq 0x802c9(%rip), %rcx     # 0xc0ba0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %esi
jmp 0x4097f
movl $0x10, %edi
callq 0x382d1
movb $0x0, (%rax)
movq $0x0, 0x8(%rax)
movl $0x1, 0x4(%rax)
leaq 0xc0f9d(%rip), %rcx     # 0x1018a8
movl 0x48(%rcx), %ecx
shll $0x8, %ecx
orl $0x10, %ecx
movl %ecx, (%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
popq %rbx
retq
movq 0x8(%rbx), %rdi
movzbl -0x1(%rdi), %esi
movl %esi, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x40975
leaq 0x80253(%rip), %rcx     # 0xc0b8c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %esi
jmp 0x40977
movq -0x11(%rdi), %rsi
jmp 0x40977
movq -0x11(%rdi), %rsi
jmp 0x4097f
movzwl -0x5(%rdi), %esi
jmp 0x40977
movzwl -0x5(%rdi), %esi
jmp 0x4097f
movl -0x9(%rdi), %esi
jmp 0x40977
movzbl -0x3(%rdi), %esi
jmp 0x40977
movl -0x9(%rdi), %esi
jmp 0x4097f
movzbl -0x3(%rdi), %esi
jmp 0x4097f
xorl %esi, %esi
popq %rbx
jmp 0x406bd
xorl %esi, %esi
popq %rbx
jmp 0x4068b
leaq 0x7f5b4(%rip), %rdi     # 0xbff40
leaq 0x802df(%rip), %rsi     # 0xc0c72
movl $0xa6, %edx
callq 0x61908
jmp 0x409b7
leaq 0x802d5(%rip), %rdi     # 0xc0c7b
leaq 0x802c5(%rip), %rsi     # 0xc0c72
movl $0xb3, %edx
callq 0x619b4
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/object.c
// Function: createQuicklistObject
robj *createQuicklistObject(void) {
    quicklist *l = quicklistCreate();
    robj *o = createObject(OBJ_LIST,l);
    o->encoding = OBJ_ENCODING_QUICKLIST;
    return o;
}

// Assembly:
pushq %rbx
callq 0x2b530
movq %rax, %rbx
movl $0x10, %edi
callq 0x382d1
movb $0x1, (%rax)
movq %rbx, 0x8(%rax)
movl $0x1, 0x4(%rax)
leaq 0xc0ebf(%rip), %rcx     # 0x1018a8
movl 0x48(%rcx), %ecx
shll $0x8, %ecx
orl $0x91, %ecx
movl %ecx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/object.c
// Function: createZiplistObject
robj *createZiplistObject(void) {
    unsigned char *zl = ziplistNew();
    robj *o = createObject(OBJ_LIST,zl);
    o->encoding = OBJ_ENCODING_ZIPLIST;
    return o;
}

// Assembly:
pushq %rbx
callq 0x3ae98
movq %rax, %rbx
movl $0x10, %edi
callq 0x382d1
movb $0x1, (%rax)
movq %rbx, 0x8(%rax)
movl $0x1, 0x4(%rax)
leaq 0xc0e87(%rip), %rcx     # 0x1018a8
movl 0x48(%rcx), %ecx
shll $0x8, %ecx
orl $0x51, %ecx
movl %ecx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/object.c
// Function: createSetObject
robj *createSetObject(void) {
    dict *d = dictCreate(&setDictType,NULL);
    robj *o = createObject(OBJ_SET,d);
    o->encoding = OBJ_ENCODING_HT;
    return o;
}

// Assembly:
pushq %rbx
leaq 0xc037a(%rip), %rdi     # 0x100db0
xorl %esi, %esi
callq 0x2e68c
movq %rax, %rbx
movl $0x10, %edi
callq 0x382d1
movb $0x2, (%rax)
movq %rbx, 0x8(%rax)
movl $0x1, 0x4(%rax)
leaq 0xc0e49(%rip), %rcx     # 0x1018a8
movl 0x48(%rcx), %ecx
shll $0x8, %ecx
orl $0x22, %ecx
movl %ecx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/object.c
// Function: createIntsetObject
robj *createIntsetObject(void) {
    intset *is = intsetNew();
    robj *o = createObject(OBJ_SET,is);
    o->encoding = OBJ_ENCODING_INTSET;
    return o;
}

// Assembly:
pushq %rbx
callq 0x64a04
movq %rax, %rbx
movl $0x10, %edi
callq 0x382d1
movb $0x2, (%rax)
movq %rbx, 0x8(%rax)
movl $0x1, 0x4(%rax)
leaq 0xc0e14(%rip), %rcx     # 0x1018a8
movl 0x48(%rcx), %ecx
shll $0x8, %ecx
orl $0x62, %ecx
movl %ecx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/object.c
// Function: createHashObject
robj *createHashObject(void) {
    unsigned char *zl = ziplistNew();
    robj *o = createObject(OBJ_HASH, zl);
    o->encoding = OBJ_ENCODING_ZIPLIST;
    return o;
}

// Assembly:
pushq %rbx
callq 0x3ae98
movq %rax, %rbx
movl $0x10, %edi
callq 0x382d1
movb $0x4, (%rax)
movq %rbx, 0x8(%rax)
movl $0x1, 0x4(%rax)
leaq 0xc0ddf(%rip), %rcx     # 0x1018a8
movl 0x48(%rcx), %ecx
shll $0x8, %ecx
orl $0x54, %ecx
movl %ecx, (%rax)
popq %rbx
retq