LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/networking.c
// Function: freeClient
void freeClient(client *c) {
    listNode *ln;

    /* Free the query buffer */
    sdsfree(c->querybuf);
    c->querybuf = NULL;

    /* Deallocate structures used to block on blocking ops. */
    if (c->flags & CLIENT_BLOCKED) unblockClient(c);

    if (c->sub_counters != NULL) {
      pubsubUnsubscribeAllCounters(c,0);
      dictRelease(c->sub_counters);
      c->sub_counters = NULL;
    }

    /* Free data structures. */
    listRelease(c->reply);
    freeClientArgv(c);

    /* Unlink the client: this will close the socket, remove the I/O
     * handlers, and remove references of the client from different
     * places where active clients may be referenced. */
    unlinkClient(c);

    if (c->flags & CLIENT_MONITOR) {
        ln = listSearchKey(server.monitors,c);
        serverAssert(ln != NULL);
        listDelNode(server.monitors,ln);
    }

    /* If this client was scheduled for async freeing we need to remove it
     * from the queue. */
    if (c->flags & CLIENT_CLOSE_ASAP) {
        ln = listSearchKey(server.clients_to_close,c);
        serverAssert(ln != NULL);
        listDelNode(server.clients_to_close,ln);
    }

    /* Release other dynamically allocated client structure fields,
     * and finally release the client structure itself. */
    if (c->name) decrRefCount(c->name);
    zfree(c->argv);
    sdsfree(c->peerid);
    zfree(c);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x1ded3
movq $0x0, 0x18(%rbx)
testb $0x10, 0x88(%rbx)
je 0x22f29
movq %rbx, %rdi
callq 0x302b4
cmpq $0x0, 0xa8(%rbx)
je 0x22f54
movq %rbx, %rdi
xorl %esi, %esi
callq 0x344b5
movq 0xa8(%rbx), %rdi
callq 0x190b8
movq $0x0, 0xa8(%rbx)
movq 0x58(%rbx), %rdi
callq 0x16a50
movq %rbx, %rdi
callq 0x2303c
movq %rbx, %rdi
callq 0x22dc6
testb $0x4, 0x88(%rbx)
je 0x22fa0
leaq 0x4c10b(%rip), %r14     # 0x6f088
movq 0x1f8(%r14), %rdi
movq %rbx, %rsi
callq 0x16d75
testq %rax, %rax
je 0x23005
movq 0x1f8(%r14), %rdi
movq %rax, %rsi
callq 0x16be4
testb $0x4, 0x89(%rbx)
je 0x22fd3
leaq 0x4c0d8(%rip), %r14     # 0x6f088
movq 0x1e8(%r14), %rdi
movq %rbx, %rsi
callq 0x16d75
testq %rax, %rax
je 0x2301a
movq 0x1e8(%r14), %rdi
movq %rax, %rsi
callq 0x16be4
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x22fe1
callq 0x25d25
movq 0x30(%rbx), %rdi
callq 0x1ffff
movq 0xb0(%rbx), %rdi
callq 0x1ded3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1ffff
leaq 0x31cae(%rip), %rdi     # 0x54cba
leaq 0x31bff(%rip), %rsi     # 0x54c12
movl $0x2c8, %edx            # imm = 0x2C8
jmp 0x2302d
leaq 0x31c99(%rip), %rdi     # 0x54cba
leaq 0x31bea(%rip), %rsi     # 0x54c12
movl $0x2d0, %edx            # imm = 0x2D0
callq 0x2a9ff
movl $0x1, %edi
callq 0x12120
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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, 0x28(%rdi)
jle 0x23065
xorl %r14d, %r14d
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x25d25
incq %r14
movslq 0x28(%rbx), %rax
cmpq %rax, %r14
jl 0x2304c
movl $0x0, 0x28(%rbx)
movq $0x0, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x4bfd3(%rip), %r14     # 0x6f088
movq 0x1e8(%r14), %rax
cmpq $0x0, 0x28(%rax)
je 0x230ea
movq (%rax), %rbx
movq 0x10(%rbx), %rdi
andl $0xfffffbff, 0x88(%rdi) # imm = 0xFFFFFBFF
callq 0x22f00
movq 0x1e8(%r14), %rdi
movq %rbx, %rsi
callq 0x16be4
jmp 0x230b5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x4bd44(%rip), %r13     # 0x6f088
movq 0x1f0(%r13), %rdi
movq 0x28(%rdi), %rbx
movq %rsp, %r14
movq %r14, %rsi
callq 0x16c72
movq %r14, %rdi
callq 0x16c8f
testq %rax, %rax
je 0x23418
movq %rsp, %r14
leaq -0x54(%rip), %r15       # 0x23321
movq 0x10(%rax), %r12
andl $0xffefffff, 0x88(%r12) # imm = 0xFFEFFFFF
movq 0x1f0(%r13), %rdi
movq %rax, %rsi
callq 0x16be4
movl 0x8(%r12), %edi
movq %r12, %rsi
xorl %edx, %edx
callq 0x230f2
cmpl $-0x1, %eax
je 0x23407
cmpl $0x0, 0xb8(%r12)
jne 0x233bf
movq 0x58(%r12), %rax
cmpq $0x0, 0x28(%rax)
je 0x23407
movq 0x38(%r13), %rdi
movl 0x8(%r12), %esi
movl $0x2, %edx
movq %r15, %rcx
movq %r12, %r8
callq 0x17077
cmpl $-0x1, %eax
jne 0x23407
movl 0x88(%r12), %eax
btl $0xa, %eax
jb 0x23407
orl $0x400, %eax            # imm = 0x400
movl %eax, 0x88(%r12)
movq 0x1e8(%r13), %rdi
movq %r12, %rsi
callq 0x16aff
movq %r14, %rdi
callq 0x16c8f
testq %rax, %rax
jne 0x23375
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/networking.c
// Function: resetClient
void resetClient(client *c) {
    freeClientArgv(c);
    c->reqtype = 0;
    c->multibulklen = 0;
    c->bulklen = -1;

    /* 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 %rbx
movq %rdi, %rbx
callq 0x2303c
movq $0x0, 0x48(%rbx)
movq $-0x1, 0x50(%rbx)
movl 0x88(%rbx), %eax
movl %eax, %ecx
andl $0xff7fffff, %ecx       # imm = 0xFF7FFFFF
movl %eax, %edx
andl $0xff3fffff, %edx       # imm = 0xFF3FFFFF
orl $0x800000, %edx         # imm = 0x800000
btl $0x16, %eax
cmovael %ecx, %edx
movl %edx, 0x88(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x4ba2b(%rip), %rax     # 0x6f088
cmpl $0x1, 0x598(%rax)
jg 0x23697
callq 0x1de3f
movq %rax, %rdi
movq %r14, %rsi
callq 0x23e1d
movq %rax, %r15
leaq 0x31abe(%rip), %rsi     # 0x5513e
movl $0x1, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x19fb1
movq %r15, %rdi
callq 0x1ded3
orb $0x40, 0x88(%r14)
movq 0x18(%r14), %rdi
movl %ebx, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
jmp 0x1f352
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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_MONITOR|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 0x4b2f7(%rip), %r14     # 0x6f088
cmpl $0x0, 0x208(%r14)
je 0x23e0e
movq 0x210(%r14), %rax
cmpq 0x650(%r14), %rax
jge 0x23e0e
movl $0x0, 0x208(%r14)
movq 0x1e0(%r14), %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x16c72
movq %rbx, %rdi
callq 0x16c8f
testq %rax, %rax
je 0x23e0e
leaq 0x8(%rsp), %rbx
movq 0x10(%rax), %rsi
movl 0x88(%rsi), %eax
testb $0x14, %al
jne 0x23e01
orl $0x80, %eax
movl %eax, 0x88(%rsi)
movq 0x638(%r14), %rdi
callq 0x16aff
movq %rbx, %rdi
callq 0x16c8f
testq %rax, %rax
jne 0x23ddc
movl 0x208(%r14), %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x4afda(%rip), %rax     # 0x6f088
movq 0x1e0(%rax), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x16c72
movq %r15, %rdi
callq 0x16c8f
testq %rax, %rax
je 0x24184
xorl %ebx, %ebx
leaq 0x30ae4(%rip), %r13     # 0x54bc0
leaq 0x8(%rsp), %r15
leaq 0x30ac4(%rip), %rbp     # 0x54bac
xorl %r12d, %r12d
movq 0x10(%rax), %rcx
movq 0x18(%rcx), %rax
movq 0x58(%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 0x24138
movslq (%rbp,%rdx,4), %rsi
addq %rbp, %rsi
jmpq *%rsi
movl %ecx, %esi
shrl $0x3, %esi
jmp 0x2413a
movq -0x11(%rax), %rsi
jmp 0x2413a
movzwl -0x5(%rax), %esi
jmp 0x2413a
movl -0x9(%rax), %esi
jmp 0x2413a
movzbl -0x3(%rax), %esi
jmp 0x2413a
xorl %esi, %esi
cmpq %rbx, %rsi
jbe 0x24171
cmpl $0x4, %edx
ja 0x2416f
movl %edx, %edx
movslq (%r13,%rdx,4), %rdx
addq %r13, %rdx
jmpq *%rdx
shrl $0x3, %ecx
movq %rcx, %rbx
jmp 0x24171
movq -0x11(%rax), %rbx
jmp 0x24171
movzwl -0x5(%rax), %ebx
jmp 0x24171
movl -0x9(%rax), %ebx
jmp 0x24171
movzbl -0x3(%rax), %ebx
jmp 0x24171
xorl %ebx, %ebx
movq %r15, %rdi
callq 0x16c8f
testq %rax, %rax
jne 0x240eb
jmp 0x24189
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_O1/erikdubbelboer[P]discnt/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 %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
cmpq $0x0, 0xb0(%rdi)
jne 0x24261
movq %rsp, %r14
movl $0x4e, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x241f5
movq %r14, %rdi
callq 0x1de62
movq %rax, 0xb0(%rbx)
movq 0xb0(%rbx), %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/networking.c
// Function: getAllClientsInfoString
sds getAllClientsInfoString(void) {
    listNode *ln;
    listIter li;
    client *client;
    sds o = sdsempty();

    o = sdsMakeRoomFor(o,200*listLength(server.clients));
    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
callq 0x1de3f
leaq 0x4ade8(%rip), %r14     # 0x6f088
movq 0x1e0(%r14), %rcx
imulq $0xc8, 0x28(%rcx), %rsi
movq %rax, %rdi
callq 0x1df85
movq %rax, %rbx
movq 0x1e0(%r14), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0x16c72
movq %r14, %rdi
callq 0x16c8f
testq %rax, %rax
je 0x2430f
leaq 0x2faa8(%rip), %r14     # 0x53d88
movq %rsp, %r15
movq 0x10(%rax), %rsi
movq %rbx, %rdi
callq 0x23e1d
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1e66d
movq %rax, %rbx
movq %r15, %rdi
callq 0x16c8f
testq %rax, %rax
jne 0x242e3
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x2303c
movq 0x30(%rbx), %rdi
callq 0x1ffff
movq %r14, 0x30(%rbx)
movl %ebp, 0x28(%rbx)
movq (%r14), %rax
movq 0x8(%rax), %rdi
callq 0x1bfaa
movq %rax, 0x38(%rbx)
testq %rax, %rax
je 0x24add
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x30567(%rip), %rdx     # 0x5504b
leaq 0x30127(%rip), %rcx     # 0x54c12
movq %rbx, %rdi
xorl %esi, %esi
movl $0x5c5, %r8d            # imm = 0x5C5
callq 0x2a9bc
movl $0x1, %edi
callq 0x12120
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x24b69
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 0x1fea5
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 0x24be2
movl %ebp, %r15d
xorl %r12d, %r12d
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x24bc0
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x24bce
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdi
movq %rdi, (%r14,%r12,8)
callq 0x25b5e
incq %r12
cmpq %r12, %r15
jne 0x24ba7
cmpl $0x0, 0x28(%rbx)
jle 0x24c04
xorl %r15d, %r15d
movq 0x30(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x25d25
incq %r15
movslq 0x28(%rbx), %rax
cmpq %rax, %r15
jl 0x24beb
movq 0x30(%rbx), %rdi
callq 0x1ffff
movq %r14, 0x30(%rbx)
movl %ebp, 0x28(%rbx)
movq (%r14), %rax
movq 0x8(%rax), %rdi
callq 0x1bfaa
movq %rax, 0x38(%rbx)
testq %rax, %rax
je 0x24c39
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3040b(%rip), %rdx     # 0x5504b
leaq 0x2ffcb(%rip), %rcx     # 0x54c12
movq %rbx, %rdi
xorl %esi, %esi
movl $0x5e2, %r8d            # imm = 0x5E2
callq 0x2a9bc
movl $0x1, %edi
callq 0x12120
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/networking.c
// Function: rewriteClientCommandArgument
void rewriteClientCommandArgument(client *c, int i, robj *newval) {
    robj *oldval;

    serverAssertWithInfo(c,NULL,i < c->argc);
    oldval = c->argv[i];
    c->argv[i] = newval;
    incrRefCount(newval);
    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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl %esi, 0x28(%rdi)
jle 0x24cb1
movq 0x30(%rbx), %rax
movslq %esi, %r15
movq (%rax,%r15,8), %r14
movq %rdx, (%rax,%r15,8)
movq %rdx, %rdi
callq 0x25b5e
movq %r14, %rdi
callq 0x25d25
testl %r15d, %r15d
jne 0x24cab
movq 0x30(%rbx), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1bfaa
movq %rax, 0x38(%rbx)
testq %rax, %rax
je 0x24ccc
popq %rbx
popq %r14
popq %r15
retq
leaq 0x303a2(%rip), %rdx     # 0x5505a
leaq 0x2ff53(%rip), %rcx     # 0x54c12
movq %rbx, %rdi
xorl %esi, %esi
movl $0x5eb, %r8d            # imm = 0x5EB
jmp 0x24ce5
leaq 0x30378(%rip), %rdx     # 0x5504b
leaq 0x2ff38(%rip), %rcx     # 0x54c12
movq %rbx, %rdi
xorl %esi, %esi
movl $0x5f4, %r8d            # imm = 0x5F4
callq 0x2a9bc
movl $0x1, %edi
callq 0x12120
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/networking.c
// Function: checkClientOutputBufferLimits
int checkClientOutputBufferLimits(client *c) {
    int soft = 0, hard = 0, class;
    unsigned long used_mem = getClientOutputBufferMemoryUsage(c);

    class = getClientType(c);
    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 0x58(%rdi), %rax
movq 0x28(%rax), %rax
leaq (%rax,%rax,8), %rcx
leaq (%rcx,%rcx,2), %rcx
addq %rax, %rax
addq %rcx, %rax
addq 0x60(%rdi), %rax
movl 0x88(%rdi), %ecx
shrl $0x12, %ecx
andl $0x1, %ecx
leaq (%rcx,%rcx,2), %rdx
leaq 0x4a345(%rip), %rsi     # 0x6f088
movq 0x5c0(%rsi,%rdx,8), %rcx
movq 0x5c8(%rsi,%rdx,8), %r8
decq %r8
cmpq %rax, %r8
jae 0x24d85
movq 0x80(%rdi), %r9
movq 0x648(%rsi), %r8
testq %r9, %r9
je 0x24d92
leaq (%rsi,%rdx,8), %rdx
addq $0x5c0, %rdx            # imm = 0x5C0
subq %r9, %r8
cmpq 0x10(%rdx), %r8
setg %dl
jmp 0x24d9b
movq $0x0, 0x80(%rdi)
jmp 0x24d99
movq %r8, 0x80(%rdi)
xorl %edx, %edx
decq %rcx
cmpq %rax, %rcx
setb %al
orb %dl, %al
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x4a2c8(%rip), %r15     # 0x6f088
incl %r14d
je 0x24de2
movq 0x38(%r15), %rdi
movl $0x5, %esi
callq 0x1736f
movl %eax, %ebp
callq 0x23330
addl %ebp, %eax
addl %eax, %ebx
testl %eax, %eax
jne 0x24dc0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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:
movq %rdi, %rax
xorl %esi, %esi
movabsq $0x232f33025bd42233, %rcx # imm = 0x232F33025BD42233
cmpq $0xa, %rax
jb 0x252c8
cmpq $0x64, %rax
jb 0x252cf
cmpq $0x3e8, %rax            # imm = 0x3E8
jb 0x252d6
movq %rax, %rdx
shrq $0xc, %rdx
cmpq $0xe8d4a50, %rdx        # imm = 0xE8D4A50
jbe 0x252dd
mulq %rcx
movq %rdx, %rax
shrq $0x25, %rax
addl $0xc, %esi
jmp 0x25295
movl $0x1, %ecx
jmp 0x25343
movl $0x2, %ecx
jmp 0x25343
movl $0x3, %ecx
jmp 0x25343
cmpq $0x5f5e0ff, %rax        # imm = 0x5F5E0FF
ja 0x25307
cmpq $0xf423f, %rax          # imm = 0xF423F
ja 0x25324
movl $0x4, %ecx
cmpq $0x2710, %rax           # imm = 0x2710
jb 0x25343
cmpq $0x186a0, %rax          # imm = 0x186A0
movl $0x5, %ecx
jmp 0x25340
movq %rax, %rcx
shrq $0xa, %rcx
cmpq $0x9502f8, %rcx         # imm = 0x9502F8
ja 0x25331
cmpq $0x3b9aca00, %rax       # imm = 0x3B9ACA00
movl $0x9, %ecx
jmp 0x25340
cmpq $0x989680, %rax         # imm = 0x989680
movl $0x7, %ecx
jmp 0x25340
shrq $0xb, %rax
cmpq $0x2e90edd, %rax        # imm = 0x2E90EDD
movl $0xb, %ecx
sbbl $-0x1, %ecx
addl %esi, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x25286
movl %eax, %ecx
addl %r13d, %ecx
xorl %eax, %eax
cmpq %r12, %rcx
jae 0x25436
movb $0x0, (%rbx,%rcx)
leal -0x1(%rcx), %esi
leaq 0x2fe69(%rip), %rdi     # 0x55210
cmpq $0x64, %r15
jb 0x253f7
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 0x253b7
jmp 0x253fa
movq %r15, %rdx
cmpq $0x9, %rdx
ja 0x25405
orb $0x30, %dl
jmp 0x25427
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 0x25434
movb $0x2d, (%rbx)
movl %ecx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x2551a
cmpq $0x1, %rsi
jne 0x25465
cmpb $0x30, (%rdi)
jne 0x25465
testq %rdx, %rdx
jne 0x2550f
jmp 0x25515
movb (%rdi), %cl
movl $0x1, %r9d
cmpb $0x2d, %cl
jne 0x25485
cmpq $0x1, %rsi
je 0x2551a
incq %rdi
movl $0x2, %r9d
movb (%rdi), %r8b
leal -0x31(%r8), %r10d
cmpb $0x8, %r10b
ja 0x254f9
addb $-0x30, %r8b
movzbl %r8b, %r8d
subq %r9, %rsi
jbe 0x254db
xorl %r9d, %r9d
movabsq $0x1999999999999999, %r10 # imm = 0x1999999999999999
movb 0x1(%rdi,%r9), %r11b
leal -0x3a(%r11), %ebx
cmpb $-0xa, %bl
jb 0x2551c
cmpq %r10, %r8
ja 0x2551c
addq %r8, %r8
leaq (%r8,%r8,4), %rbx
addb $-0x30, %r11b
movzbl %r11b, %r8d
addq %rbx, %r8
jb 0x2551c
incq %r9
cmpq %r9, %rsi
jne 0x254ac
cmpb $0x2d, %cl
jne 0x25520
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmpq %rcx, %r8
ja 0x2551a
testq %rdx, %rdx
je 0x25515
negq %r8
jmp 0x25512
cmpq $0x1, %rsi
sete %cl
cmpb $0x30, %r8b
sete %sil
xorl %eax, %eax
testb %sil, %cl
je 0x2551a
xorl %r8d, %r8d
movq %r8, (%rdx)
movl $0x1, %eax
popq %rbx
retq
xorl %eax, %eax
jmp 0x2551a
testq %r8, %r8
js 0x2551a
testq %rdx, %rdx
jne 0x25512
jmp 0x25515
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x25440
testl %eax, %eax
je 0x25551
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
movl $0x1, %eax
jmp 0x25553
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x25609
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
xorpd %xmm1, %xmm1
cmpq %rcx, %rax
jne 0x2558f
ucomisd %xmm0, %xmm1
jbe 0x255b2
leaq 0x2f6c2(%rip), %rdx     # 0x54c4f
jmp 0x255f4
ucomisd %xmm1, %xmm0
jne 0x255bb
jp 0x255bb
movsd 0x2fbd1(%rip), %xmm2    # 0x55170
divsd %xmm0, %xmm2
ucomisd %xmm2, %xmm1
jbe 0x255ed
leaq 0x2fc30(%rip), %rdx     # 0x551e0
jmp 0x255f4
leaq 0x2f697(%rip), %rdx     # 0x54c50
jmp 0x255f4
ucomisd 0x2fb9d(%rip), %xmm0    # 0x55160
jbe 0x255fb
movsd 0x2fb9b(%rip), %xmm1    # 0x55168
ucomisd %xmm0, %xmm1
jbe 0x255fb
cvttsd2si %xmm0, %rdx
xorps %xmm1, %xmm1
cvtsi2sd %rdx, %xmm1
ucomisd %xmm0, %xmm1
jne 0x255fb
jp 0x255fb
jmp 0x2535e
leaq 0x32013(%rip), %rdx     # 0x57607
xorl %eax, %eax
jmp 0x122d0
leaq 0x2f652(%rip), %rdx     # 0x54c54
movb $0x1, %al
jmp 0x122d0
leaq 0x2fbcc(%rip), %rdx     # 0x551dc
jmp 0x255f4
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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;
    o->notused = 0;
    return o;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x10, %edi
callq 0x1fea5
andl $0xf, %ebp
movq %rbx, 0x8(%rax)
movl $0x1, 0x4(%rax)
movl %ebp, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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->notused = 0;

    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, %r12
leaq 0x14(%rsi), %rdi
callq 0x1fea5
movq %rax, %r14
leaq 0x13(%rax), %r15
movq %r15, 0x8(%rax)
movabsq $0x100000020, %rax      # imm = 0x100000020
movq %rax, (%r14)
movb %bl, 0x10(%r14)
movb %bl, 0x11(%r14)
movb $0x1, 0x12(%r14)
testq %r12, %r12
je 0x25ad1
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x12520
movb $0x0, (%r15,%rbx)
jmp 0x25ae1
incq %rbx
movq %r15, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x12380
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/object.c
// Function: createStringObject
robj *createStringObject(const char *ptr, size_t len) {
    if (len <= OBJ_ENCODING_EMBSTR_SIZE_LIMIT)
        return createEmbeddedStringObject(ptr,len);
    else
        return createRawStringObject(ptr,len);
}

// Assembly:
cmpq $0x2c, %rsi
jbe 0x25a7b
pushq %rbx
callq 0x1dd2c
movq %rax, %rbx
movl $0x10, %edi
callq 0x1fea5
movq %rbx, 0x8(%rax)
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rcx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x25b41
leaq 0x49c64(%rip), %rax     # 0x6f798
movq 0x148(%rax,%rbx,8), %rax
incl 0x4(%rax)
jmp 0x25b5c
movl $0x10, %edi
callq 0x1fea5
movabsq $0x100000010, %rcx      # imm = 0x100000010
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/object.c
// Function: createStringObjectFromLongDouble
robj *createStringObjectFromLongDouble(long double value) {
    char buf[256];
    int len;

    /* 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--;
    }
    return createStringObject(buf,len);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
fldt 0x130(%rsp)
fstpt (%rsp)
leaq 0x2f81b(%rip), %rdx     # 0x55398
leaq 0x10(%rsp), %r14
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
xorl %eax, %eax
callq 0x122d0
movl %eax, %ebx
movq %r14, %rdi
movl $0x2e, %esi
callq 0x122b0
testq %rax, %rax
je 0x25bbe
movslq %ebx, %rbx
movzbl 0xf(%rsp,%rbx), %eax
cmpl $0x30, %eax
jne 0x25bb7
decq %rbx
jmp 0x25ba8
cmpl $0x2e, %eax
jne 0x25bbe
decl %ebx
movslq %ebx, %rsi
leaq 0x10(%rsp), %rdi
callq 0x25af0
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x25cda
movq %rdi, %rbx
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x2, %eax
je 0x25c56
cmpl $0x1, %eax
je 0x25c2a
testl %eax, %eax
jne 0x25cf4
movq 0x8(%rbx), %rdi
movzbl -0x1(%rdi), %esi
movl %esi, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x25cb3
leaq 0x2f6d7(%rip), %rcx     # 0x552f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %esi
jmp 0x25cb5
movl $0x10, %edi
callq 0x1fea5
movq $0x0, 0x8(%rax)
movabsq $0x100000010, %rcx      # imm = 0x100000010
movq %rcx, (%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x25cd8
movq 0x8(%rbx), %rdi
movzbl -0x1(%rdi), %esi
movl %esi, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x25cab
leaq 0x2f66d(%rip), %rcx     # 0x552dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %esi
jmp 0x25cad
movq -0x11(%rdi), %rsi
jmp 0x25cad
movq -0x11(%rdi), %rsi
jmp 0x25cb5
movzwl -0x5(%rdi), %esi
jmp 0x25cad
movzwl -0x5(%rdi), %esi
jmp 0x25cb5
movl -0x9(%rdi), %esi
jmp 0x25cad
movzbl -0x3(%rdi), %esi
jmp 0x25cad
movl -0x9(%rdi), %esi
jmp 0x25cb5
movzbl -0x3(%rdi), %esi
jmp 0x25cb5
xorl %esi, %esi
popq %rbx
jmp 0x25a7b
xorl %esi, %esi
callq 0x1dd2c
movq %rax, %rbx
movl $0x10, %edi
callq 0x1fea5
movq %rbx, 0x8(%rax)
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rcx, (%rax)
popq %rbx
retq
leaq 0x2ef1b(%rip), %rdi     # 0x54bfc
leaq 0x2f6b7(%rip), %rsi     # 0x5539f
movl $0x93, %edx
callq 0x2a9ff
jmp 0x25d0c
leaq 0x2f6ad(%rip), %rdi     # 0x553a8
leaq 0x2f69d(%rip), %rsi     # 0x5539f
movl $0xa0, %edx
callq 0x2ade4
movl $0x1, %edi
callq 0x12120
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/object.c
// Function: decrRefCount
void decrRefCount(robj *o) {
    if (o->refcount <= 0) serverPanic("decrRefCount against refcount <= 0");
    if (o->refcount == 1) {
        switch(o->type) {
        case OBJ_STRING: freeStringObject(o); break;
        default: serverPanic("Unknown object type"); break;
        }
        zfree(o);
    } else {
        o->refcount--;
    }
}

// Assembly:
pushq %rbx
movl 0x4(%rdi), %eax
testl %eax, %eax
jle 0x25d58
movq %rdi, %rbx
cmpl $0x1, %eax
jne 0x25d51
movl (%rbx), %eax
testb $0xf, %al
jne 0x25d6d
testb $-0x10, %al
jne 0x25d48
movq 0x8(%rbx), %rdi
callq 0x1ded3
movq %rbx, %rdi
popq %rbx
jmp 0x1ffff
decl %eax
movl %eax, 0x4(%rbx)
popq %rbx
retq
leaq 0x2f65b(%rip), %rdi     # 0x553ba
leaq 0x2f639(%rip), %rsi     # 0x5539f
movl $0xb0, %edx
jmp 0x25d80
leaq 0x2f66b(%rip), %rdi     # 0x553df
leaq 0x2f624(%rip), %rsi     # 0x5539f
movl $0xb4, %edx
callq 0x2ade4
movl $0x1, %edi
callq 0x12120
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/object.c
// Function: isObjectRepresentableAsLongLong
int isObjectRepresentableAsLongLong(robj *o, long long *llval) {
    serverAssertWithInfo(NULL,o,o->type == OBJ_STRING);
    if (o->encoding == OBJ_ENCODING_INT) {
        if (llval) *llval = (long) o->ptr;
        return C_OK;
    } else {
        return string2ll(o->ptr,sdslen(o->ptr),llval) ? C_OK : C_ERR;
    }
}

// Assembly:
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rsi
movl (%rdi), %eax
testb $0xf, %al
jne 0x25e3c
andl $0xf0, %eax
cmpl $0x10, %eax
jne 0x25dec
xorl %ebx, %ebx
testq %rdx, %rdx
je 0x25e38
movq 0x8(%rsi), %rax
movq %rax, (%rdx)
jmp 0x25e38
movq 0x8(%rsi), %rdi
movzbl -0x1(%rdi), %esi
movl %esi, %eax
andl $0x7, %eax
xorl %ebx, %ebx
cmpl $0x4, %eax
ja 0x25e2c
leaq 0x2f4fd(%rip), %rcx     # 0x55304
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %esi
jmp 0x25e2e
movq -0x11(%rdi), %rsi
jmp 0x25e2e
movzwl -0x5(%rdi), %esi
jmp 0x25e2e
movl -0x9(%rdi), %esi
jmp 0x25e2e
movzbl -0x3(%rdi), %esi
jmp 0x25e2e
xorl %esi, %esi
callq 0x25440
cmpl $0x1, %eax
sbbl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
leaq 0x2edb9(%rip), %rdx     # 0x54bfc
leaq 0x2f555(%rip), %rcx     # 0x5539f
xorl %edi, %edi
movl $0xdd, %r8d
callq 0x2a9bc
movl $0x1, %edi
callq 0x12120
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/object.c
// Function: getDecodedObject
robj *getDecodedObject(robj *o) {
    robj *dec;

    if (sdsEncodedObject(o)) {
        incrRefCount(o);
        return o;
    }
    if (o->type == OBJ_STRING && o->encoding == OBJ_ENCODING_INT) {
        char buf[32];

        ll2string(buf,32,(long)o->ptr);
        dec = createStringObject(buf,strlen(buf));
        return dec;
    } else {
        serverPanic("Unknown encoding type");
    }
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rax
movl (%rdi), %edx
movl %edx, %ecx
shrl $0x4, %ecx
testb $0xd, %cl
jne 0x2608a
incl 0x4(%rax)
jmp 0x260be
testb $0xf, %dl
jne 0x260c4
andl $0xf, %ecx
cmpl $0x1, %ecx
jne 0x260c4
movq 0x8(%rax), %rdx
movq %rsp, %rbx
movl $0x20, %esi
movq %rbx, %rdi
callq 0x2535e
movq %rbx, %rdi
callq 0x12250
movq %rbx, %rdi
movq %rax, %rsi
callq 0x25af0
addq $0x20, %rsp
popq %rbx
retq
leaq 0x2f32a(%rip), %rdi     # 0x553f5
leaq 0x2f2cd(%rip), %rsi     # 0x5539f
movl $0x141, %edx            # imm = 0x141
callq 0x2ade4
movl $0x1, %edi
callq 0x12120
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/object.c
// Function: compareStringObjectsWithFlags
int compareStringObjectsWithFlags(robj *a, robj *b, int flags) {
    serverAssertWithInfo(NULL,a,a->type == OBJ_STRING && b->type == OBJ_STRING);
    char bufa[128], bufb[128], *astr, *bstr;
    size_t alen, blen, minlen;

    if (a == b) return 0;
    if (sdsEncodedObject(a)) {
        astr = a->ptr;
        alen = sdslen(astr);
    } else {
        alen = ll2string(bufa,sizeof(bufa),(long) a->ptr);
        astr = bufa;
    }
    if (sdsEncodedObject(b)) {
        bstr = b->ptr;
        blen = sdslen(bstr);
    } else {
        blen = ll2string(bufb,sizeof(bufb),(long) b->ptr);
        bstr = bufb;
    }
    if (flags & DISQUE_COMPARE_COLL) {
        return strcoll(astr,bstr);
    } else {
        int cmp;

        minlen = (alen < blen) ? alen : blen;
        cmp = memcmp(astr,bstr,minlen);
        if (cmp == 0) return alen-blen;
        return cmp;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %r12
movq %rdi, %rsi
movl (%rdi), %eax
testb $0xf, %al
jne 0x26245
testb $0xf, (%r12)
jne 0x26245
cmpq %r12, %rsi
je 0x26149
movl %edx, %ebx
shrl $0x4, %eax
testb $0xd, %al
jne 0x26151
movq 0x8(%rsi), %r15
movzbl -0x1(%r15), %r14d
movl %r14d, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x26189
leaq 0x2f216(%rip), %rcx     # 0x55350
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %r14d
jmp 0x2618c
xorl %r14d, %r14d
jmp 0x26231
movq 0x8(%rsi), %rdx
leaq 0x80(%rsp), %r15
movl $0x80, %esi
movq %r15, %rdi
callq 0x2535e
movslq %eax, %r14
jmp 0x2618c
movq -0x11(%r15), %r14
jmp 0x2618c
movzwl -0x5(%r15), %r14d
jmp 0x2618c
movl -0x9(%r15), %r14d
jmp 0x2618c
movzbl -0x3(%r15), %r14d
jmp 0x2618c
xorl %r14d, %r14d
movl (%r12), %eax
shrl $0x4, %eax
testb $0xd, %al
jne 0x261c3
movq 0x8(%r12), %r12
movzbl -0x1(%r12), %r13d
movl %r13d, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x261fb
leaq 0x2f1b0(%rip), %rcx     # 0x55364
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %r13d
jmp 0x261fe
movq 0x8(%r12), %rdx
movq %rsp, %r12
movl $0x80, %esi
movq %r12, %rdi
callq 0x2535e
movslq %eax, %r13
jmp 0x261fe
movq -0x11(%r12), %r13
jmp 0x261fe
movzwl -0x5(%r12), %r13d
jmp 0x261fe
movl -0x9(%r12), %r13d
jmp 0x261fe
movzbl -0x3(%r12), %r13d
jmp 0x261fe
xorl %r13d, %r13d
testb $0x2, %bl
jne 0x26223
cmpq %r13, %r14
movq %r13, %rdx
cmovbq %r14, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x12440
subl %r13d, %r14d
testl %eax, %eax
cmovnel %eax, %r14d
jmp 0x26231
movq %r15, %rdi
movq %r12, %rsi
callq 0x12630
movl %eax, %r14d
movl %r14d, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2f1c1(%rip), %rdx     # 0x5540d
leaq 0x2f14c(%rip), %rcx     # 0x5539f
xorl %edi, %edi
movl $0x151, %r8d            # imm = 0x151
callq 0x2a9bc
movl $0x1, %edi
callq 0x12120
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/object.c
// Function: equalStringObjects
int equalStringObjects(robj *a, robj *b) {
    if (a->encoding == OBJ_ENCODING_INT &&
        b->encoding == OBJ_ENCODING_INT){
        /* If both strings are integer encoded just check if the stored
         * long is the same. */
        return a->ptr == b->ptr;
    } else {
        return compareStringObjects(a,b) == 0;
    }
}

// Assembly:
movl $0xf0, %eax
movl (%rdi), %ecx
andl %eax, %ecx
cmpl $0x10, %ecx
jne 0x262a0
andl (%rsi), %eax
cmpl $0x10, %eax
jne 0x262a0
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
sete %al
jmp 0x262b4
pushq %rax
movl $0x1, %edx
callq 0x260e6
testl %eax, %eax
sete %al
addq $0x8, %rsp
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/object.c
// Function: stringObjectLen
size_t stringObjectLen(robj *o) {
    serverAssertWithInfo(NULL,o,o->type == OBJ_STRING);
    if (sdsEncodedObject(o)) {
        return sdslen(o->ptr);
    } else {
        return sdigits10((long)o->ptr);
    }
}

// Assembly:
pushq %rax
movq %rdi, %rsi
movl (%rdi), %eax
testb $0xf, %al
jne 0x26318
shrl $0x4, %eax
testb $0xd, %al
jne 0x262f0
movq 0x8(%rsi), %rcx
movzbl -0x1(%rcx), %eax
movl %eax, %edx
andl $0x7, %edx
cmpl $0x4, %edx
ja 0x26314
leaq 0x2f096(%rip), %rsi     # 0x55378
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
shrl $0x3, %eax
jmp 0x26316
movq 0x8(%rsi), %rdi
callq 0x25348
movl %eax, %eax
jmp 0x26316
movq -0x11(%rcx), %rax
jmp 0x26316
movzwl -0x5(%rcx), %eax
jmp 0x26316
movl -0x9(%rcx), %eax
jmp 0x26316
movzbl -0x3(%rcx), %eax
jmp 0x26316
xorl %eax, %eax
popq %rcx
retq
leaq 0x2e8dd(%rip), %rdx     # 0x54bfc
leaq 0x2f079(%rip), %rcx     # 0x5539f
xorl %edi, %edi
movl $0x18a, %r8d            # imm = 0x18A
callq 0x2a9bc
movl $0x1, %edi
callq 0x12120