LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x38f1c
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 0x327b9
movq %rax, %r14
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r15, 0x10(%rsp)
xorl %r15d, %r15d
testl %r12d, %r12d
movl $0x0, %r12d
cmovgl %ebp, %r12d
cmpq %r15, %r12
je 0x38f9c
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x38f7d
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x38f8b
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdi
movq %rdi, (%r14,%r15,8)
callq 0x39e74
incq %r15
jmp 0x38f5f
xorl %r15d, %r15d
movslq 0x38(%rbx), %rax
movq 0x40(%rbx), %rdi
cmpq %rax, %r15
jge 0x38fba
movq (%rdi,%r15,8), %rdi
callq 0x3a265
incq %r15
jmp 0x38f9f
callq 0x328f9
movq %r14, 0x40(%rbx)
movl %ebp, 0x38(%rbx)
movq (%r14), %rax
movq 0x8(%rax), %rdi
callq 0x2e105
movq %rax, 0x48(%rbx)
testq %rax, %rax
je 0x38feb
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x78e63(%rip), %rdx     # 0xb1e55
leaq 0x78901(%rip), %rcx     # 0xb18fa
movq %rbx, %rdi
xorl %esi, %esi
movl $0x698, %r8d            # imm = 0x698
callq 0x588a4
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/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 0x37899
movq 0x40(%rbx), %rdi
callq 0x328f9
movq %r14, 0x40(%rbx)
movl %ebp, 0x38(%rbx)
movq (%r14), %rax
movq 0x8(%rax), %rdi
callq 0x2e105
movq %rax, 0x48(%rbx)
testq %rax, %rax
je 0x3904c
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x78e02(%rip), %rdx     # 0xb1e55
leaq 0x788a0(%rip), %rcx     # 0xb18fa
movq %rbx, %rdi
xorl %esi, %esi
movl $0x6a3, %r8d            # imm = 0x6A3
callq 0x588a4
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/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 0x39090
movslq %r14d, %r13
jmp 0x390b4
movq 0x40(%rbx), %rdi
leal 0x1(%r14), %ebp
movslq %r14d, %r13
leaq 0x8(,%r13,8), %rsi
callq 0x32863
movq %rax, 0x40(%rbx)
movl %ebp, 0x38(%rbx)
andq $0x0, (%rax,%r13,8)
movq 0x40(%rbx), %rax
movq (%rax,%r13,8), %r12
movq %r15, (%rax,%r13,8)
movq %r15, %rdi
callq 0x39e74
testq %r12, %r12
je 0x390d5
movq %r12, %rdi
callq 0x3a265
testl %r14d, %r14d
jne 0x390f3
movq 0x40(%rbx), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x2e105
movq %rax, 0x48(%rbx)
testq %rax, %rax
je 0x39102
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x78d4c(%rip), %rdx     # 0xb1e55
leaq 0x787ea(%rip), %rcx     # 0xb18fa
movq %rbx, %rdi
xorl %esi, %esi
movl $0x6c1, %r8d            # imm = 0x6C1
callq 0x588a4
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %rax
imulq $0x28, 0x28(%rax), %r14
addq 0x70(%rdi), %r14
callq 0x38e1b
xorl %ecx, %ecx
cmpl $0x3, %eax
cmovnel %eax, %ecx
imulq $0x18, %rcx, %rcx
leaq 0xc073b(%rip), %rdx     # 0xf98a8
movq 0x620(%rdx,%rcx), %rax
movq 0x628(%rdx,%rcx), %rsi
decq %rsi
cmpq %r14, %rsi
jae 0x391ae
movq 0x90(%rbx), %rdi
movq 0x978(%rdx), %rsi
testq %rdi, %rdi
je 0x391b8
addq %rdx, %rcx
addq $0x620, %rcx            # imm = 0x620
subq %rdi, %rsi
cmpq 0x10(%rcx), %rsi
setg %cl
jmp 0x391c1
andq $0x0, 0x90(%rbx)
jmp 0x391bf
movq %rsi, 0x90(%rbx)
xorl %ecx, %ecx
decq %rax
cmpq %r14, %rax
setb %al
orb %cl, %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc06c1(%rip), %r15     # 0xf98a8
movq 0x1e0(%r15), %rdi
movq %rsp, %rbx
movq %rbx, %rsi
callq 0x2702c
movq %rbx, %rdi
callq 0x27046
testq %rax, %rax
je 0x3924a
movq 0x10(%rax), %r14
movq 0x40(%r15), %rdi
movl 0x8(%r14), %esi
callq 0x28c68
testb $0x2, %al
je 0x391f9
cmpl $0x9, 0xa0(%r14)
jne 0x391f9
cmpl $0x0, 0x1c0(%r14)
jne 0x3923a
movq 0x68(%r14), %rax
cmpq $0x0, 0x28(%rax)
je 0x391f9
movl 0x8(%r14), %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x37945
jmp 0x391f9
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
xorl %ebx, %ebx
pushq $-0x5
popq %r15
leaq 0xc063f(%rip), %r12     # 0xf98a8
pushq $0x5
popq %rbp
incl %r15d
je 0x3928e
movq 0x40(%r12), %rdi
movl %ebp, %esi
callq 0x28d8e
movl %eax, %r14d
callq 0x37b5a
addl %r14d, %eax
addl %eax, %ebx
testl %eax, %eax
jne 0x3926c
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rdi, %rax
xorl %esi, %esi
pushq $0x1
popq %rcx
pushq $0x2
popq %rdi
pushq $0x3
popq %r8
movabsq $0xe8d4a51000, %r9      # imm = 0xE8D4A51000
cmpq $0xa, %rax
jb 0x3977b
cmpq $0x64, %rax
jb 0x39717
cmpq $0x3e8, %rax            # imm = 0x3E8
jb 0x3971b
movq %rax, %rdx
shrq $0xc, %rdx
cmpq $0xe8d4a50, %rdx        # imm = 0xE8D4A50
jbe 0x39720
xorl %edx, %edx
divq %r9
addl $0xc, %esi
jmp 0x396e5
movl %edi, %ecx
jmp 0x3977b
movl %r8d, %ecx
jmp 0x3977b
cmpq $0x5f5e0ff, %rax        # imm = 0x5F5E0FF
ja 0x3973d
cmpq $0xf423f, %rax          # imm = 0xF423F
ja 0x39757
cmpq $0x2710, %rax           # imm = 0x2710
jae 0x3976f
pushq $0x4
popq %rcx
jmp 0x3977b
movq %rax, %rcx
shrq $0xa, %rcx
cmpq $0x9502f8, %rcx         # imm = 0x9502F8
ja 0x39761
cmpq $0x3b9aca00, %rax       # imm = 0x3B9ACA00
pushq $0x9
jmp 0x39777
cmpq $0x989680, %rax         # imm = 0x989680
pushq $0x7
jmp 0x39777
shrq $0xb, %rax
cmpq $0x2e90edd, %rax        # imm = 0x2E90EDD
pushq $0xb
jmp 0x39777
cmpq $0x186a0, %rax          # imm = 0x186A0
pushq $0x5
popq %rcx
sbbl $-0x1, %ecx
addl %esi, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x396cc
leal (%rax,%r13), %esi
xorl %ecx, %ecx
cmpq %r12, %rsi
jae 0x39859
movb $0x0, (%rbx,%rsi)
leal (%rax,%r13), %ecx
addl $-0x2, %ecx
pushq $0x64
popq %r9
leaq 0x78c2a(%rip), %rdi     # 0xb2410
leal 0x1(%rcx), %r8d
cmpq $0x64, %r15
jb 0x39817
movq %r15, %rax
xorl %edx, %edx
divq %r9
movl %edx, %edx
movb (%rdi,%rdx,2), %r10b
movb 0x1(%rdi,%rdx,2), %dl
movl %r8d, %r8d
movb %dl, (%rbx,%r8)
movl %ecx, %edx
movb %r10b, (%rbx,%rdx)
addl $-0x2, %ecx
movq %rax, %r15
jmp 0x397e6
cmpq $0x9, %r15
ja 0x39823
orb $0x30, %r15b
jmp 0x39848
addq %r15, %r15
movabsq $0x1fffffffe, %rax      # imm = 0x1FFFFFFFE
andq %r15, %rax
movl %r15d, %edx
movb 0x1(%rdx,%rdi), %dl
movl %r8d, %r8d
movb %dl, (%rbx,%r8)
movb (%rax,%rdi), %r15b
movl %ecx, %r8d
movl %r8d, %eax
movb %r15b, (%rbx,%rax)
testq %r14, %r14
jns 0x39857
movb $0x2d, (%rbx)
movl %esi, %ecx
movl %ecx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
xorl %eax, %eax
testq %rsi, %rsi
je 0x39947
movb (%rdi), %r10b
movl $0x1, %ecx
cmpq $0x1, %rsi
jne 0x398a3
movzbl %r10b, %r9d
xorl %r8d, %r8d
cmpl $0x2d, %r9d
je 0x398ce
cmpl $0x30, %r9d
jne 0x398d2
testq %rdx, %rdx
jne 0x3993f
jmp 0x39945
cmpb $0x2d, %r10b
jne 0x398bf
movb 0x1(%rdi), %r10b
incq %rdi
movabsq $0x2, %r9
movb $0x1, %r8b
jmp 0x398dc
movabsq $0x1, %r9
xorl %r8d, %r8d
jmp 0x398dc
xorl %eax, %eax
jmp 0x39947
movabsq $0x1, %r9
leal -0x31(%r10), %r11d
cmpb $0x8, %r11b
ja 0x39928
addb $-0x30, %r10b
movzbl %r10b, %r10d
incq %rdi
movabsq $0x1999999999999999, %r11 # imm = 0x1999999999999999
cmpq %rsi, %r9
jae 0x3994c
movb (%rdi), %bl
leal -0x3a(%rbx), %ebp
cmpb $-0xa, %bpl
jb 0x39947
cmpq %r11, %r10
ja 0x39947
imulq $0xa, %r10, %r14
addb $-0x30, %bl
movzbl %bl, %r10d
addq %r14, %r10
jb 0x39947
incq %r9
incq %rdi
jmp 0x398fb
cmpq $0x1, %rsi
sete %sil
cmpb $0x30, %r10b
sete %dil
xorl %eax, %eax
testb %dil, %sil
je 0x39947
xorl %r10d, %r10d
movq %r10, (%rdx)
movl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
testb %r8b, %r8b
je 0x3996a
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
cmpq %rsi, %r10
ja 0x39947
testq %rdx, %rdx
je 0x39945
negq %r10
jmp 0x39942
testq %r10, %r10
js 0x39947
testq %rdx, %rdx
jne 0x39942
jmp 0x39945
// File: /workspace/github_c_makefile_star2_O2/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 0x39865
testl %eax, %eax
je 0x39999
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
pushq $0x1
popq %rax
jmp 0x3999b
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x39a4e
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
xorpd %xmm1, %xmm1
cmpq %rcx, %rax
jne 0x399d7
ucomisd %xmm0, %xmm1
jbe 0x399fa
leaq 0x77f79(%rip), %rdx     # 0xb194e
jmp 0x39a39
ucomisd %xmm1, %xmm0
jne 0x39a03
jp 0x39a03
movsd 0x789d9(%rip), %xmm2    # 0xb23c0
divsd %xmm0, %xmm2
ucomisd %xmm2, %xmm1
jbe 0x39a32
leaq 0x789e8(%rip), %rdx     # 0xb23e0
jmp 0x39a39
leaq 0x77f4e(%rip), %rdx     # 0xb194f
jmp 0x39a39
ucomisd 0x789a5(%rip), %xmm0    # 0xb23b0
jbe 0x39a40
movsd 0x789a3(%rip), %xmm1    # 0xb23b8
ucomisd %xmm0, %xmm1
jbe 0x39a40
cvttsd2si %xmm0, %rdx
cvtsi2sd %rdx, %xmm1
ucomisd %xmm0, %xmm1
jne 0x39a40
jp 0x39a40
jmp 0x39796
leaq 0x7af81(%rip), %rdx     # 0xb49ba
xorl %eax, %eax
jmp 0x26120
leaq 0x77f0c(%rip), %rdx     # 0xb1953
movb $0x1, %al
jmp 0x26120
leaq 0x78987(%rip), %rdx     # 0xb23dc
jmp 0x39a39
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/util.c
// Function: getAbsolutePath
sds getAbsolutePath(char *filename) {
    char cwd[1024];
    sds abspath;
    sds relpath = sdsnew(filename);

    relpath = sdstrim(relpath," \r\n\t");
    if (relpath[0] == '/') return relpath; /* Path is already absolute. */

    /* If path is relative, join cwd and relative path. */
    if (getcwd(cwd,sizeof(cwd)) == NULL) {
        sdsfree(relpath);
        return NULL;
    }
    abspath = sdsnew(cwd);
    if (sdslen(abspath) && abspath[sdslen(abspath)-1] != '/')
        abspath = sdscat(abspath,"/");

    /* At this point we have the current path always ending with "/", and
     * the trimmed relative path. Try to normalize the obvious case of
     * trailing ../ elements at the start of the path.
     *
     * For every "../" we find in the filename, we remove it and also remove
     * the last element of the cwd, unless the current cwd is "/". */
    while (sdslen(relpath) >= 3 &&
           relpath[0] == '.' && relpath[1] == '.' && relpath[2] == '/')
    {
        sdsrange(relpath,3,-1);
        if (sdslen(abspath) > 1) {
            char *p = abspath + sdslen(abspath)-2;
            int trimlen = 1;

            while(*p != '/') {
                p--;
                trimlen++;
            }
            sdsrange(abspath,0,-(trimlen+1));
        }
    }

    /* Finally glue the two parts together. */
    abspath = sdscatsds(abspath,relpath);
    sdsfree(relpath);
    return abspath;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
callq 0x3115a
leaq 0x787fe(%rip), %rsi     # 0xb2401
movq %rax, %rdi
callq 0x31dec
movq %rax, %rbx
cmpb $0x2f, (%rax)
je 0x39cdf
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x26910
testq %rax, %rax
je 0x39cd1
movq %rsp, %rdi
callq 0x3115a
movq %rax, %r14
movq %rax, %rdi
callq 0x39cf2
testq %rax, %rax
je 0x39c5f
cmpb $0x2f, -0x1(%r14,%rax)
je 0x39c5f
leaq 0x8877e(%rip), %rsi     # 0xc23d2
movq %r14, %rdi
callq 0x317b7
movq %rax, %r14
pushq $0x3
popq %rbp
pushq $-0x1
popq %r15
pushq $-0x2
popq %r12
movq %rbx, %rdi
callq 0x39cf2
cmpq $0x3, %rax
jb 0x39cc1
cmpb $0x2e, (%rbx)
jne 0x39cc1
cmpb $0x2e, 0x1(%rbx)
jne 0x39cc1
cmpb $0x2f, 0x2(%rbx)
jne 0x39cc1
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x31e8e
movq %r14, %rdi
callq 0x39cf2
cmpq $0x2, %rax
jb 0x39c6a
addq %r14, %rax
movq %r12, %rdx
cmpb $0x2f, (%rax,%rdx)
je 0x39cb5
decq %rdx
jmp 0x39caa
movq %r14, %rdi
xorl %esi, %esi
callq 0x31e8e
jmp 0x39c6a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x317de
movq %rax, %r14
jmp 0x39cd4
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x311c8
movq %r14, %rbx
movq %rbx, %rax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x10
popq %rdi
callq 0x327b9
andl $0xf, %ebp
movb %bpl, (%rax)
movq %rbx, 0x8(%rax)
movl $0x1, 0x4(%rax)
leaq 0xbfb28(%rip), %rcx     # 0xf98a8
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_O2/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 0x327b9
movq %rax, %r14
movb $-0x80, (%rax)
leaq 0x13(%rax), %r12
movq %r12, 0x8(%rax)
movl $0x1, 0x4(%rax)
leaq 0xbfad3(%rip), %rax     # 0xf98a8
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 0x39e0a
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x26c50
movb $0x0, (%r12,%rbx)
jmp 0x39e1a
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_O2/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 0x39e59
leaq 0xc04c4(%rip), %rax     # 0xfa310
movq 0x1b0(%rax,%rbx,8), %rax
incl 0x4(%rax)
jmp 0x39e72
xorl %edi, %edi
xorl %esi, %esi
callq 0x39d58
movl $0xffffff0f, %ecx       # imm = 0xFFFFFF0F
andl (%rax), %ecx
orl $0x10, %ecx
movl %ecx, (%rax)
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x39ec8
fldz
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jbe 0x39f0e
movb $0x66, 0x22(%rsp)
movw $0x6e69, 0x20(%rsp)     # imm = 0x6E69
pushq $0x3
jmp 0x39f18
testl %edi, %edi
je 0x39f24
fstpt (%rsp)
leaq 0x78666(%rip), %rdx     # 0xb253c
leaq 0x20(%rsp), %r14
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
xorl %eax, %eax
callq 0x26120
movl %eax, %ebx
pushq $0x2e
popq %rsi
movq %r14, %rdi
callq 0x267f0
testq %rax, %rax
je 0x39f41
movslq %ebx, %rbx
movzbl 0x1f(%rsp,%rbx), %eax
cmpl $0x30, %eax
jne 0x39f1b
decq %rbx
jmp 0x39eff
movl $0x666e692d, 0x20(%rsp) # imm = 0x666E692D
pushq $0x4
popq %rbx
jmp 0x39f41
cmpl $0x2e, %eax
jne 0x39f41
decl %ebx
jmp 0x39f41
fstpt (%rsp)
leaq 0x78615(%rip), %rdx     # 0xb2543
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 0x39e29
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x39fc6
movq %rdi, %rbx
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
je 0x39fae
cmpl $0x1, %eax
je 0x39f8f
testl %eax, %eax
jne 0x39fe0
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x3a000
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x39d91
xorl %edi, %edi
xorl %esi, %esi
callq 0x39d58
movl $0xffffff0f, %ecx       # imm = 0xFFFFFF0F
andl (%rax), %ecx
orl $0x10, %ecx
movl %ecx, (%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
popq %rbx
retq
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x3a000
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x39da2
leaq 0x77917(%rip), %rdi     # 0xb18e4
leaq 0x78576(%rip), %rsi     # 0xb254a
movl $0xa6, %edx
callq 0x57ac8
jmp 0x39ff8
leaq 0x7856c(%rip), %rdi     # 0xb2553
leaq 0x7855c(%rip), %rsi     # 0xb254a
movl $0xb3, %edx
callq 0x57b45
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/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 %rax
callq 0x27178
pushq $0x1
popq %rdi
movq %rax, %rsi
callq 0x39d58
movl $0xffffff0f, %ecx       # imm = 0xFFFFFF0F
andl (%rax), %ecx
orl $0x90, %ecx
movl %ecx, (%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
callq 0x3540c
pushq $0x1
popq %rdi
movq %rax, %rsi
callq 0x39d58
movl $0xffffff0f, %ecx       # imm = 0xFFFFFF0F
andl (%rax), %ecx
orl $0x50, %ecx
movl %ecx, (%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
leaq 0xbed2f(%rip), %rdi     # 0xf8db0
xorl %esi, %esi
callq 0x2a155
pushq $0x2
popq %rdi
movq %rax, %rsi
callq 0x39d58
movl $0xffffff0f, %ecx       # imm = 0xFFFFFF0F
andl (%rax), %ecx
orl $0x20, %ecx
movl %ecx, (%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
callq 0x5a64c
pushq $0x2
popq %rdi
movq %rax, %rsi
callq 0x39d58
movl $0xffffff0f, %ecx       # imm = 0xFFFFFF0F
andl (%rax), %ecx
orl $0x60, %ecx
movl %ecx, (%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
callq 0x3540c
pushq $0x4
popq %rdi
movq %rax, %rsi
callq 0x39d58
movl $0xffffff0f, %ecx       # imm = 0xFFFFFF0F
andl (%rax), %ecx
orl $0x50, %ecx
movl %ecx, (%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/object.c
// Function: createZsetObject
robj *createZsetObject(void) {
    zset *zs = zmalloc(sizeof(*zs));
    robj *o;

    zs->dict = dictCreate(&zsetDictType,NULL);
    zs->zsl = zslCreate();
    o = createObject(OBJ_ZSET,zs);
    o->encoding = OBJ_ENCODING_SKIPLIST;
    return o;
}

// Assembly:
pushq %rbx
pushq $0x10
popq %rdi
callq 0x327b9
movq %rax, %rbx
leaq 0xbecee(%rip), %rdi     # 0xf8de0
xorl %esi, %esi
callq 0x2a155
movq %rax, (%rbx)
callq 0x478ee
movq %rax, 0x8(%rbx)
pushq $0x3
popq %rdi
movq %rbx, %rsi
callq 0x39d58
movl $0xffffff0f, %ecx       # imm = 0xFFFFFF0F
andl (%rax), %ecx
orl $0x70, %ecx
movl %ecx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/object.c
// Function: createZsetZiplistObject
robj *createZsetZiplistObject(void) {
    unsigned char *zl = ziplistNew();
    robj *o = createObject(OBJ_ZSET,zl);
    o->encoding = OBJ_ENCODING_ZIPLIST;
    return o;
}

// Assembly:
pushq %rax
callq 0x3540c
pushq $0x3
popq %rdi
movq %rax, %rsi
callq 0x39d58
movl $0xffffff0f, %ecx       # imm = 0xFFFFFF0F
andl (%rax), %ecx
orl $0x50, %ecx
movl %ecx, (%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/object.c
// Function: freeListObject
void freeListObject(robj *o) {
    if (o->encoding == OBJ_ENCODING_QUICKLIST) {
        quicklistRelease(o->ptr);
    } else {
        serverPanic("Unknown list encoding type");
    }
}

// Assembly:
movl $0xf0, %eax
andl (%rdi), %eax
cmpl $0x90, %eax
jne 0x3a163
movq 0x8(%rdi), %rdi
jmp 0x2725b
pushq %rax
leaq 0x783fa(%rip), %rdi     # 0xb2565
leaq 0x783d8(%rip), %rsi     # 0xb254a
movl $0xf7, %edx
callq 0x57b45
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/object.c
// Function: freeSetObject
void freeSetObject(robj *o) {
    switch (o->encoding) {
    case OBJ_ENCODING_HT:
        dictRelease((dict*) o->ptr);
        break;
    case OBJ_ENCODING_INTSET:
        zfree(o->ptr);
        break;
    default:
        serverPanic("Unknown set encoding type");
    }
}

// Assembly:
movl (%rdi), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x6, %eax
je 0x3a19f
cmpl $0x2, %eax
jne 0x3a1a8
movq 0x8(%rdi), %rdi
jmp 0x2a8da
movq 0x8(%rdi), %rdi
jmp 0x328f9
pushq %rax
leaq 0x783d2(%rip), %rdi     # 0xb2582
leaq 0x78393(%rip), %rsi     # 0xb254a
movl $0x104, %edx            # imm = 0x104
callq 0x57b45
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/object.c
// Function: freeZsetObject
void freeZsetObject(robj *o) {
    zset *zs;
    switch (o->encoding) {
    case OBJ_ENCODING_SKIPLIST:
        zs = o->ptr;
        dictRelease(zs->dict);
        zslFree(zs->zsl);
        zfree(zs);
        break;
    case OBJ_ENCODING_ZIPLIST:
        zfree(o->ptr);
        break;
    default:
        serverPanic("Unknown sorted set encoding");
    }
}

// Assembly:
pushq %rbx
movl (%rdi), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x5, %eax
je 0x3a1f6
cmpl $0x7, %eax
jne 0x3a200
movq 0x8(%rdi), %rbx
movq (%rbx), %rdi
callq 0x2a8da
movq 0x8(%rbx), %rdi
callq 0x47959
movq %rbx, %rdi
jmp 0x3a1fa
movq 0x8(%rdi), %rdi
popq %rbx
jmp 0x328f9
leaq 0x78397(%rip), %rdi     # 0xb259e
leaq 0x7833c(%rip), %rsi     # 0xb254a
movl $0x115, %edx            # imm = 0x115
callq 0x57b45
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/object.c
// Function: freeHashObject
void freeHashObject(robj *o) {
    switch (o->encoding) {
    case OBJ_ENCODING_HT:
        dictRelease((dict*) o->ptr);
        break;
    case OBJ_ENCODING_ZIPLIST:
        zfree(o->ptr);
        break;
    default:
        serverPanic("Unknown hash encoding type");
        break;
    }
}

// Assembly:
movl (%rdi), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x5, %eax
je 0x3a23b
cmpl $0x2, %eax
jne 0x3a244
movq 0x8(%rdi), %rdi
jmp 0x2a8da
movq 0x8(%rdi), %rdi
jmp 0x328f9
pushq %rax
leaq 0x78370(%rip), %rdi     # 0xb25bc
leaq 0x782f7(%rip), %rsi     # 0xb254a
movl $0x122, %edx            # imm = 0x122
callq 0x57b45
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/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;
        case OBJ_LIST: freeListObject(o); break;
        case OBJ_SET: freeSetObject(o); break;
        case OBJ_ZSET: freeZsetObject(o); break;
        case OBJ_HASH: freeHashObject(o); break;
        default: serverPanic("Unknown object type"); break;
        }
        zfree(o);
    } else {
        o->refcount--;
    }
}

// Assembly:
pushq %rbx
movl 0x4(%rdi), %eax
testl %eax, %eax
jle 0x3a2cf
movq %rdi, %rbx
cmpl $0x1, %eax
jne 0x3a299
movl (%rbx), %eax
andl $0xf, %eax
cmpl $0x4, %eax
ja 0x3a2ef
leaq 0x7826a(%rip), %rcx     # 0xb24f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x3a13d
jmp 0x3a2c6
decl %eax
movl %eax, 0x4(%rbx)
popq %rbx
retq
movq %rbx, %rdi
callq 0x3a220
jmp 0x3a2c6
movq %rbx, %rdi
callq 0x3a184
jmp 0x3a2c6
movq %rbx, %rdi
callq 0x3a1c9
jmp 0x3a2c6
movq %rbx, %rdi
callq 0x3a14c
movq %rbx, %rdi
popq %rbx
jmp 0x328f9
leaq 0x78303(%rip), %rdi     # 0xb25d9
leaq 0x7826d(%rip), %rsi     # 0xb254a
movl $0x12c, %edx            # imm = 0x12C
callq 0x57b45
pushq $0x1
popq %rdi
callq 0x263c0
leaq 0x78308(%rip), %rdi     # 0xb25fe
leaq 0x7824d(%rip), %rsi     # 0xb254a
movl $0x134, %edx            # imm = 0x134
jmp 0x3a2e2
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %rsi
movl (%rdi), %eax
testb $0xf, %al
jne 0x3a38a
andl $0xf0, %eax
cmpl $0x10, %eax
jne 0x3a35f
xorl %eax, %eax
testq %rbx, %rbx
je 0x3a382
movq 0x8(%rsi), %rcx
movq %rcx, (%rbx)
jmp 0x3a382
movq 0x8(%rsi), %r14
movq %r14, %rdi
callq 0x3a000
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x39865
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
sbbl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x77553(%rip), %rdx     # 0xb18e4
leaq 0x781b2(%rip), %rcx     # 0xb254a
xorl %edi, %edi
movl $0x15d, %r8d            # imm = 0x15D
callq 0x588a4
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/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 $0x7, %cl
jne 0x3a596
incl 0x4(%rax)
jmp 0x3a5c8
testb $0xf, %dl
jne 0x3a5ce
andl $0xf, %ecx
cmpl $0x1, %ecx
jne 0x3a5ce
movq 0x8(%rax), %rdx
movq %rsp, %rbx
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x39796
movq %rbx, %rdi
callq 0x26500
movq %rbx, %rdi
movq %rax, %rsi
callq 0x39e29
addq $0x20, %rsp
popq %rbx
retq
leaq 0x7803f(%rip), %rdi     # 0xb2614
leaq 0x77f6e(%rip), %rsi     # 0xb254a
movl $0x1c6, %edx            # imm = 0x1C6
callq 0x57b45
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/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 & REDIS_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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %r12
movq %rdi, %rsi
movl (%rdi), %eax
testb $0xf, %al
jne 0x3a6df
movl (%r12), %ebp
testb $0xf, %bpl
jne 0x3a6df
cmpq %r12, %rsi
je 0x3a63c
movl %edx, %ebx
shrl $0x4, %eax
testb $0x7, %al
jne 0x3a644
movq 0x8(%rsi), %r15
movq %r15, %rdi
callq 0x3a000
movq %rax, %r14
jmp 0x3a664
xorl %r14d, %r14d
jmp 0x3a6ca
movq 0x8(%rsi), %rdx
leaq 0x80(%rsp), %r15
movl $0x80, %esi
movq %r15, %rdi
callq 0x39796
movslq %eax, %r14
movl (%r12), %ebp
shrl $0x4, %ebp
testb $0x7, %bpl
jne 0x3a67f
movq 0x8(%r12), %r12
movq %r12, %rdi
callq 0x3a000
movq %rax, %r13
jmp 0x3a697
movq 0x8(%r12), %rdx
movq %rsp, %r12
movl $0x80, %esi
movq %r12, %rdi
callq 0x39796
movslq %eax, %r13
testb $0x2, %bl
jne 0x3a6bc
cmpq %r13, %r14
movq %r13, %rdx
cmovbq %r14, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x269b0
subl %r13d, %r14d
testl %eax, %eax
cmovnel %eax, %r14d
jmp 0x3a6ca
movq %r15, %rdi
movq %r12, %rsi
callq 0x260e0
movl %eax, %r14d
movl %r14d, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x77f46(%rip), %rdx     # 0xb262c
leaq 0x77e5d(%rip), %rcx     # 0xb254a
xorl %edi, %edi
movl $0x1d6, %r8d            # imm = 0x1D6
callq 0x588a4
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/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 0x3a734
andl (%rsi), %eax
cmpl $0x10, %eax
jne 0x3a734
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
sete %al
jmp 0x3a743
pushq %rax
callq 0x3a702
testl %eax, %eax
sete %al
addq $0x8, %rsp
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/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 0x3a76f
shrl $0x4, %eax
testb $0x7, %al
jne 0x3a762
movq 0x8(%rsi), %rdi
popq %rax
jmp 0x3a000
movq 0x8(%rsi), %rdi
callq 0x39780
movl %eax, %eax
popq %rcx
retq
leaq 0x7716e(%rip), %rdx     # 0xb18e4
leaq 0x77dcd(%rip), %rcx     # 0xb254a
xorl %edi, %edi
movl $0x20f, %r8d            # imm = 0x20F
callq 0x588a4
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/object.c
// Function: getDoubleFromObject
int getDoubleFromObject(robj *o, double *target) {
    double value;
    char *eptr;

    if (o == NULL) {
        value = 0;
    } else {
        serverAssertWithInfo(NULL,o,o->type == OBJ_STRING);
        if (sdsEncodedObject(o)) {
            errno = 0;
            value = strtod(o->ptr, &eptr);
            if (isspace(((char*)o->ptr)[0]) ||
                eptr[0] != '\0' ||
                (errno == ERANGE &&
                    (value == HUGE_VAL || value == -HUGE_VAL || value == 0)) ||
                errno == EINVAL ||
                isnan(value))
                return C_ERR;
        } else if (o->encoding == OBJ_ENCODING_INT) {
            value = (long)o->ptr;
        } else {
            serverPanic("Unknown string encoding");
        }
    }
    *target = value;
    return C_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x3a852
movq %rdi, %r14
movl (%rdi), %eax
testb $0xf, %al
jne 0x3a86e
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
je 0x3a7d0
cmpl $0x1, %eax
je 0x3a858
testl %eax, %eax
jne 0x3a88e
callq 0x26880
movq %rax, %r15
andl $0x0, (%rax)
movq 0x8(%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0x26cc0
movsd %xmm0, (%rsp)
callq 0x26560
movq (%rax), %rcx
movq 0x8(%r14), %rax
movsbq (%rax), %rdx
pushq $-0x1
popq %rax
testb $0x20, 0x1(%rcx,%rdx,2)
jne 0x3a864
movq 0x8(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x3a864
movl (%r15), %ecx
cmpl $0x22, %ecx
movq (%rsp), %xmm0
jne 0x3a845
movq %xmm0, %rdx
btrq $0x3f, %rdx
movabsq $0x7ff0000000000000, %rsi # imm = 0x7FF0000000000000
cmpq %rsi, %rdx
sete %sil
testq %rdx, %rdx
sete %dl
orb %sil, %dl
jne 0x3a864
cmpl $0x16, %ecx
je 0x3a864
ucomisd %xmm0, %xmm0
jnp 0x3a85e
jmp 0x3a864
xorpd %xmm0, %xmm0
jmp 0x3a85e
cvtsi2sdq 0x8(%r14), %xmm0
movsd %xmm0, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x7706f(%rip), %rdx     # 0xb18e4
leaq 0x77cce(%rip), %rcx     # 0xb254a
xorl %edi, %edi
movq %r14, %rsi
movl $0x21e, %r8d            # imm = 0x21E
callq 0x588a4
jmp 0x3a8a6
leaq 0x77dc6(%rip), %rdi     # 0xb265b
leaq 0x77cae(%rip), %rsi     # 0xb254a
movl $0x22c, %edx            # imm = 0x22C
callq 0x57b45
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/object.c
// Function: getDoubleFromObjectOrReply
int getDoubleFromObjectOrReply(client *c, robj *o, double *target, const char *msg) {
    double value;
    if (getDoubleFromObject(o, &value) != C_OK) {
        if (msg != NULL) {
            addReplyError(c,(char*)msg);
        } else {
            addReplyError(c,"value is not a valid float");
        }
        return C_ERR;
    }
    *target = value;
    return C_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %rax
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x3a792
testl %eax, %eax
je 0x3a8e1
testq %rbx, %rbx
je 0x3a8f0
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x3a8fa
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%r15)
xorl %eax, %eax
jmp 0x3a902
leaq 0x7a79e(%rip), %rsi     # 0xb5095
movq %r14, %rdi
callq 0x36b6f
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq