LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x10, %edi
callq 0x382d1
movq %rax, %rbx
leaq 0xc02f5(%rip), %rdi     # 0x100de0
xorl %esi, %esi
callq 0x2e68c
movq %rax, (%rbx)
callq 0x4fe06
movq %rax, 0x8(%rbx)
movl $0x10, %edi
callq 0x382d1
movb $0x3, (%rax)
movq %rbx, 0x8(%rax)
movl $0x1, 0x4(%rax)
leaq 0xc0d8b(%rip), %rcx     # 0x1018a8
movl 0x48(%rcx), %ecx
shll $0x8, %ecx
orl $0x73, %ecx
movl %ecx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
callq 0x3ae98
movq %rax, %rbx
movl $0x10, %edi
callq 0x382d1
movb $0x3, (%rax)
movq %rbx, 0x8(%rax)
movl $0x1, 0x4(%rax)
leaq 0xc0d56(%rip), %rcx     # 0x1018a8
movl 0x48(%rcx), %ecx
shll $0x8, %ecx
orl $0x53, %ecx
movl %ecx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x40b85
movq 0x8(%rdi), %rdi
jmp 0x2b658
pushq %rax
leaq 0x80100(%rip), %rdi     # 0xc0c8d
leaq 0x800de(%rip), %rsi     # 0xc0c72
movl $0xf7, %edx
callq 0x619b4
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/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 0x40bc3
cmpl $0x2, %eax
jne 0x40bcc
movq 0x8(%rdi), %rdi
jmp 0x2eef3
movq 0x8(%rdi), %rdi
jmp 0x38413
pushq %rax
leaq 0x800d6(%rip), %rdi     # 0xc0caa
leaq 0x80097(%rip), %rsi     # 0xc0c72
movl $0x104, %edx            # imm = 0x104
callq 0x619b4
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/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 0x40c1c
cmpl $0x7, %eax
jne 0x40c26
movq 0x8(%rdi), %rbx
movq (%rbx), %rdi
callq 0x2eef3
movq 0x8(%rbx), %rdi
callq 0x4fe7a
movq %rbx, %rdi
jmp 0x40c20
movq 0x8(%rdi), %rdi
popq %rbx
jmp 0x38413
leaq 0x80099(%rip), %rdi     # 0xc0cc6
leaq 0x8003e(%rip), %rsi     # 0xc0c72
movl $0x115, %edx            # imm = 0x115
callq 0x619b4
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/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 0x40c63
cmpl $0x2, %eax
jne 0x40c6c
movq 0x8(%rdi), %rdi
jmp 0x2eef3
movq 0x8(%rdi), %rdi
jmp 0x38413
pushq %rax
leaq 0x80070(%rip), %rdi     # 0xc0ce4
leaq 0x7fff7(%rip), %rsi     # 0xc0c72
movl $0x122, %edx            # imm = 0x122
callq 0x619b4
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/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 0x40d00
movq %rdi, %rbx
cmpl $0x1, %eax
jne 0x40cca
movl (%rbx), %eax
movl %eax, %ecx
andl $0xf, %ecx
cmpl $0x4, %ecx
ja 0x40d22
leaq 0x7ff02(%rip), %rdx     # 0xc0bb4
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
testb $-0x10, %al
jne 0x40cf7
movq 0x8(%rbx), %rdi
callq 0x36330
jmp 0x40cf7
decl %eax
movl %eax, 0x4(%rbx)
popq %rbx
retq
movq %rbx, %rdi
callq 0x40c48
jmp 0x40cf7
movq %rbx, %rdi
callq 0x40ba8
jmp 0x40cf7
movq %rbx, %rdi
callq 0x40bef
jmp 0x40cf7
movq %rbx, %rdi
callq 0x40b6e
movq %rbx, %rdi
popq %rbx
jmp 0x38413
leaq 0x7fffa(%rip), %rdi     # 0xc0d01
leaq 0x7ff64(%rip), %rsi     # 0xc0c72
movl $0x12c, %edx            # imm = 0x12C
callq 0x619b4
movl $0x1, %edi
callq 0x263c0
leaq 0x7fffd(%rip), %rdi     # 0xc0d26
leaq 0x7ff42(%rip), %rsi     # 0xc0c72
movl $0x134, %edx            # imm = 0x134
jmp 0x40d13
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rsi, %rdx
movq %rdi, %rsi
movl (%rdi), %eax
testb $0xf, %al
jne 0x40de4
andl $0xf0, %eax
cmpl $0x10, %eax
jne 0x40d94
xorl %ebx, %ebx
testq %rdx, %rdx
je 0x40de0
movq 0x8(%rsi), %rax
movq %rax, (%rdx)
jmp 0x40de0
movq 0x8(%rsi), %rdi
movzbl -0x1(%rdi), %esi
movl %esi, %eax
andl $0x7, %eax
xorl %ebx, %ebx
cmpl $0x4, %eax
ja 0x40dd4
leaq 0x7fe19(%rip), %rcx     # 0xc0bc8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %esi
jmp 0x40dd6
movq -0x11(%rdi), %rsi
jmp 0x40dd6
movzwl -0x5(%rdi), %esi
jmp 0x40dd6
movl -0x9(%rdi), %esi
jmp 0x40dd6
movzbl -0x3(%rdi), %esi
jmp 0x40dd6
xorl %esi, %esi
callq 0x40065
cmpl $0x1, %eax
sbbl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
leaq 0x7f155(%rip), %rdx     # 0xbff40
leaq 0x7fe80(%rip), %rcx     # 0xc0c72
xorl %edi, %edi
movl $0x15d, %r8d            # imm = 0x15D
callq 0x627c3
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/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 0x4103f
incl 0x4(%rax)
jmp 0x41073
testb $0xf, %dl
jne 0x41079
andl $0xf, %ecx
cmpl $0x1, %ecx
jne 0x41079
movq 0x8(%rax), %rdx
movq %rsp, %rbx
movl $0x20, %esi
movq %rbx, %rdi
callq 0x3ff83
movq %rbx, %rdi
callq 0x26500
movq %rbx, %rdi
movq %rax, %rsi
callq 0x40744
addq $0x20, %rsp
popq %rbx
retq
leaq 0x7fcbc(%rip), %rdi     # 0xc0d3c
leaq 0x7fbeb(%rip), %rsi     # 0xc0c72
movl $0x1c6, %edx            # imm = 0x1C6
callq 0x619b4
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %r12
movq %rdi, %rsi
movl (%rdi), %ecx
testb $0xf, %cl
jne 0x411fd
movl (%r12), %eax
testb $0xf, %al
jne 0x411fd
cmpq %r12, %rsi
je 0x41101
movl %edx, %ebx
shrl $0x4, %ecx
testb $0x7, %cl
jne 0x41109
movq 0x8(%rsi), %r15
movzbl -0x1(%r15), %r14d
movl %r14d, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x41145
leaq 0x7fb22(%rip), %rdx     # 0xc0c14
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
shrl $0x3, %r14d
jmp 0x41148
xorl %r14d, %r14d
jmp 0x411e9
movq 0x8(%rsi), %rdx
leaq 0x80(%rsp), %r15
movl $0x80, %esi
movq %r15, %rdi
callq 0x3ff83
movslq %eax, %r14
movl (%r12), %eax
jmp 0x41148
movq -0x11(%r15), %r14
jmp 0x41148
movzwl -0x5(%r15), %r14d
jmp 0x41148
movl -0x9(%r15), %r14d
jmp 0x41148
movzbl -0x3(%r15), %r14d
jmp 0x41148
xorl %r14d, %r14d
shrl $0x4, %eax
testb $0x7, %al
jne 0x4117b
movq 0x8(%r12), %r12
movzbl -0x1(%r12), %r13d
movl %r13d, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x411b3
leaq 0x7fabc(%rip), %rcx     # 0xc0c28
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %r13d
jmp 0x411b6
movq 0x8(%r12), %rdx
movq %rsp, %r12
movl $0x80, %esi
movq %r12, %rdi
callq 0x3ff83
movslq %eax, %r13
jmp 0x411b6
movq -0x11(%r12), %r13
jmp 0x411b6
movzwl -0x5(%r12), %r13d
jmp 0x411b6
movl -0x9(%r12), %r13d
jmp 0x411b6
movzbl -0x3(%r12), %r13d
jmp 0x411b6
xorl %r13d, %r13d
testb $0x2, %bl
jne 0x411db
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 0x411e9
movq %r15, %rdi
movq %r12, %rsi
callq 0x260e0
movl %eax, %r14d
movl %r14d, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x7fb50(%rip), %rdx     # 0xc0d54
leaq 0x7fa67(%rip), %rcx     # 0xc0c72
xorl %edi, %edi
movl $0x1d6, %r8d            # imm = 0x1D6
callq 0x627c3
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/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 0x41258
andl (%rsi), %eax
cmpl $0x10, %eax
jne 0x41258
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
sete %al
jmp 0x4126c
pushq %rax
movl $0x1, %edx
callq 0x4109b
testl %eax, %eax
sete %al
addq $0x8, %rsp
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x412d0
shrl $0x4, %eax
testb $0x7, %al
jne 0x412a8
movq 0x8(%rsi), %rcx
movzbl -0x1(%rcx), %eax
movl %eax, %edx
andl $0x7, %edx
cmpl $0x4, %edx
ja 0x412cc
leaq 0x7f9a2(%rip), %rsi     # 0xc0c3c
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
shrl $0x3, %eax
jmp 0x412ce
movq 0x8(%rsi), %rdi
callq 0x3ff6d
movl %eax, %eax
jmp 0x412ce
movq -0x11(%rcx), %rax
jmp 0x412ce
movzwl -0x5(%rcx), %eax
jmp 0x412ce
movl -0x9(%rcx), %eax
jmp 0x412ce
movzbl -0x3(%rcx), %eax
jmp 0x412ce
xorl %eax, %eax
popq %rcx
retq
leaq 0x7ec69(%rip), %rdx     # 0xbff40
leaq 0x7f994(%rip), %rcx     # 0xc0c72
xorl %edi, %edi
movl $0x20f, %r8d            # imm = 0x20F
callq 0x627c3
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/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 0x413ba
movq %rdi, %r14
movl (%rdi), %eax
testb $0xf, %al
jne 0x413d6
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
je 0x41333
cmpl $0x1, %eax
je 0x413c0
testl %eax, %eax
jne 0x413f6
callq 0x26880
movq %rax, %r15
movl $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
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb $0x20, 0x1(%rcx,%rdx,2)
jne 0x413cc
movq 0x8(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x413cc
movl (%r15), %ecx
cmpl $0x22, %ecx
movq (%rsp), %xmm0
jne 0x413ad
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 0x413cc
cmpl $0x16, %ecx
je 0x413cc
ucomisd %xmm0, %xmm0
jnp 0x413c6
jmp 0x413cc
xorpd %xmm0, %xmm0
jmp 0x413c6
cvtsi2sdq 0x8(%r14), %xmm0
movsd %xmm0, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x7eb63(%rip), %rdx     # 0xbff40
leaq 0x7f88e(%rip), %rcx     # 0xc0c72
xorl %edi, %edi
movq %r14, %rsi
movl $0x21e, %r8d            # imm = 0x21E
callq 0x627c3
jmp 0x4140e
leaq 0x7f986(%rip), %rdi     # 0xc0d83
leaq 0x7f86e(%rip), %rsi     # 0xc0c72
movl $0x22c, %edx            # imm = 0x22C
callq 0x619b4
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/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 0x412f5
testl %eax, %eax
je 0x4144b
testq %rbx, %rbx
je 0x4145a
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x41464
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%r15)
xorl %eax, %eax
jmp 0x4146e
leaq 0x82830(%rip), %rsi     # 0xc3c91
movq %r14, %rdi
callq 0x3cc06
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/object.c
// Function: getLongDoubleFromObject
int getLongDoubleFromObject(robj *o, long double *target) {
    long double value;
    char *eptr;

    if (o == NULL) {
        value = 0;
    } else {
        serverAssertWithInfo(NULL,o,o->type == OBJ_STRING);
        if (sdsEncodedObject(o)) {
            errno = 0;
            value = strtold(o->ptr, &eptr);
            if (isspace(((char*)o->ptr)[0]) || eptr[0] != '\0' ||
                errno == ERANGE || 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 $0x20, %rsp
movq %rsi, %rbx
fldz
testq %rdi, %rdi
je 0x4151d
movq %rdi, %r14
fstp %st(0)
movl (%rdi), %eax
testb $0xf, %al
jne 0x4152f
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
je 0x414b6
cmpl $0x1, %eax
je 0x41512
testl %eax, %eax
jne 0x4154f
callq 0x26880
movq %rax, %r15
movl $0x0, (%rax)
movq 0x8(%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0x260f0
fstpt 0x14(%rsp)
callq 0x26560
movq (%rax), %rcx
movq 0x8(%r14), %rax
movsbq (%rax), %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb $0x20, 0x1(%rcx,%rdx,2)
jne 0x41521
movq 0x8(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x41521
cmpl $0x22, (%r15)
sete %cl
fldt 0x14(%rsp)
fucomi %st(0), %st
setp %dl
orb %cl, %dl
je 0x4151d
jmp 0x41523
movq 0x8(%r14), %rax
movq %rax, (%rsp)
fildll (%rsp)
fstpt (%rbx)
xorl %eax, %eax
fldz
fstp %st(0)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x7ea0a(%rip), %rdx     # 0xbff40
leaq 0x7f735(%rip), %rcx     # 0xc0c72
xorl %edi, %edi
movq %r14, %rsi
movl $0x248, %r8d            # imm = 0x248
callq 0x627c3
jmp 0x41567
leaq 0x7f82d(%rip), %rdi     # 0xc0d83
leaq 0x7f715(%rip), %rsi     # 0xc0c72
movl $0x252, %edx            # imm = 0x252
callq 0x619b4
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/object.c
// Function: getLongDoubleFromObjectOrReply
int getLongDoubleFromObjectOrReply(client *c, robj *o, long double *target, const char *msg) {
    long double value;
    if (getLongDoubleFromObject(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
movq %rsp, %rsi
movq %rax, %rdi
callq 0x41478
testl %eax, %eax
je 0x415a2
testq %rbx, %rbx
je 0x415ac
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x415b6
fldt (%rsp)
fstpt (%r15)
xorl %eax, %eax
jmp 0x415c0
leaq 0x826de(%rip), %rsi     # 0xc3c91
movq %r14, %rdi
callq 0x3cc06
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/object.c
// Function: getLongLongFromObject
int getLongLongFromObject(robj *o, long long *target) {
    long long value;

    if (o == NULL) {
        value = 0;
    } else {
        serverAssertWithInfo(NULL,o,o->type == OBJ_STRING);
        if (sdsEncodedObject(o)) {
            if (string2ll(o->ptr,sdslen(o->ptr),&value) == 0) return C_ERR;
        } else if (o->encoding == OBJ_ENCODING_INT) {
            value = (long)o->ptr;
        } else {
            serverPanic("Unknown string encoding");
        }
    }
    if (target) *target = value;
    return C_OK;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x41623
movq %rdi, %rsi
movl (%rdi), %eax
testb $0xf, %al
jne 0x4167c
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
je 0x415fc
cmpl $0x1, %eax
je 0x4162e
testl %eax, %eax
jne 0x41699
movq 0x8(%rsi), %rdi
movzbl -0x1(%rdi), %esi
movl %esi, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x41650
leaq 0x7f63b(%rip), %rcx     # 0xc0c50
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %esi
jmp 0x41652
movq $0x0, 0x8(%rsp)
jmp 0x41660
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
jmp 0x41660
movq -0x11(%rdi), %rsi
jmp 0x41652
movzwl -0x5(%rdi), %esi
jmp 0x41652
movl -0x9(%rdi), %esi
jmp 0x41652
movzbl -0x3(%rdi), %esi
jmp 0x41652
xorl %esi, %esi
leaq 0x8(%rsp), %rdx
callq 0x40065
testl %eax, %eax
je 0x41671
xorl %eax, %eax
testq %rbx, %rbx
je 0x41676
movq 0x8(%rsp), %rcx
movq %rcx, (%rbx)
jmp 0x41676
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
retq
leaq 0x7e8bd(%rip), %rdx     # 0xbff40
leaq 0x7f5e8(%rip), %rcx     # 0xc0c72
xorl %edi, %edi
movl $0x26d, %r8d            # imm = 0x26D
callq 0x627c3
jmp 0x416b1
leaq 0x7f6e3(%rip), %rdi     # 0xc0d83
leaq 0x7f5cb(%rip), %rsi     # 0xc0c72
movl $0x273, %edx            # imm = 0x273
callq 0x619b4
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/object.c
// Function: getLongLongFromObjectOrReply
int getLongLongFromObjectOrReply(client *c, robj *o, long long *target, const char *msg) {
    long long value;
    if (getLongLongFromObject(o, &value) != C_OK) {
        if (msg != NULL) {
            addReplyError(c,(char*)msg);
        } else {
            addReplyError(c,"value is not an integer or out of range");
        }
        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 0x415ca
testl %eax, %eax
je 0x416ee
testq %rbx, %rbx
je 0x416fa
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x41704
movq 0x8(%rsp), %rax
movq %rax, (%r15)
xorl %eax, %eax
jmp 0x4170e
leaq 0x7f69c(%rip), %rsi     # 0xc0d9d
movq %r14, %rdi
callq 0x3cc06
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/object.c
// Function: getLongFromObjectOrReply
int getLongFromObjectOrReply(client *c, robj *o, long *target, const char *msg) {
    long long value;

    if (getLongLongFromObjectOrReply(c, o, &value, msg) != C_OK) return C_ERR;
    if (value < LONG_MIN || value > LONG_MAX) {
        if (msg != NULL) {
            addReplyError(c,(char*)msg);
        } else {
            addReplyError(c,"value is out of range");
        }
        return C_ERR;
    }
    *target = value;
    return C_OK;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq 0x8(%rsp), %rdx
callq 0x416bb
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x4173f
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/object.c
// Function: objectCommand
void objectCommand(client *c) {
    robj *o;

    if (!strcasecmp(c->argv[1]->ptr,"refcount") && c->argc == 3) {
        if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.nullbulk))
                == NULL) return;
        addReplyLongLong(c,o->refcount);
    } else if (!strcasecmp(c->argv[1]->ptr,"encoding") && c->argc == 3) {
        if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.nullbulk))
                == NULL) return;
        addReplyBulkCString(c,strEncoding(o->encoding));
    } else if (!strcasecmp(c->argv[1]->ptr,"idletime") && c->argc == 3) {
        if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.nullbulk))
                == NULL) return;
        addReplyLongLong(c,estimateObjectIdleTime(o)/1000);
    } else {
        addReplyError(c,"Syntax error. Try OBJECT (refcount|encoding|idletime)");
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %r15
movq 0x8(%r15), %rax
movq 0x8(%rax), %r14
leaq 0x8b520(%rip), %rsi     # 0xccd2a
movq %r14, %rdi
callq 0x262f0
testl %eax, %eax
jne 0x41848
cmpl $0x3, 0x38(%rbx)
jne 0x41848
movq 0x10(%r15), %rsi
leaq 0xc0ae9(%rip), %rax     # 0x102310
movq 0x50(%rax), %rdx
movq %rbx, %rdi
callq 0x417b2
testq %rax, %rax
je 0x41942
movslq 0x4(%rax), %rsi
movq %rbx, %rdi
jmp 0x41924
leaq 0x81b13(%rip), %rsi     # 0xc3362
movq %r14, %rdi
callq 0x262f0
testl %eax, %eax
jne 0x418a2
cmpl $0x3, 0x38(%rbx)
jne 0x418a2
movq 0x10(%r15), %rsi
leaq 0xc0aa4(%rip), %rax     # 0x102310
movq 0x50(%rax), %rdx
movq %rbx, %rdi
callq 0x417b2
testq %rax, %rax
je 0x41942
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x9, %eax
ja 0x41948
leaq 0xb83e7(%rip), %rcx     # 0xf9c80
movq (%rcx,%rax,8), %rsi
jmp 0x4194f
leaq 0x7f542(%rip), %rsi     # 0xc0deb
movq %r14, %rdi
callq 0x262f0
testl %eax, %eax
jne 0x4192e
cmpl $0x3, 0x38(%rbx)
jne 0x4192e
movq 0x10(%r15), %rsi
leaq 0xc0a4a(%rip), %rax     # 0x102310
movq 0x50(%rax), %rdx
movq %rbx, %rdi
callq 0x417b2
testq %rax, %rax
je 0x41942
leaq 0xbffca(%rip), %rcx     # 0x1018a8
movl 0x48(%rcx), %ecx
andl $0xffffff, %ecx         # imm = 0xFFFFFF
movl (%rax), %eax
shrl $0x8, %eax
movq %rcx, %rdx
subq %rax, %rdx
movl %eax, %esi
xorl $0xffffff, %esi         # imm = 0xFFFFFF
addl %ecx, %esi
cmpl %eax, %ecx
cmovaeq %rdx, %rsi
imulq $0x3e8, %rsi, %rax      # imm = 0x3E8
shrq $0x3, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
mulq %rcx
shrq $0x4, %rdx
movq %rbx, %rdi
movq %rdx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3d23f
leaq 0x7f4bf(%rip), %rsi     # 0xc0df4
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3cc06
popq %rbx
popq %r14
popq %r15
retq
leaq 0x7f494(%rip), %rsi     # 0xc0de3
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3d0f2
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/db.c
// Function: lookupKey
robj *lookupKey(redisDb *db, robj *key, int flags) {
    dictEntry *de = dictFind(db->dict,key->ptr);
    if (de) {
        robj *val = dictGetVal(de);

        /* Update the access time for the ageing algorithm.
         * Don't do it if we have a saving child, as this will trigger
         * a copy on write madness. */
        if (server.rdb_child_pid == -1 &&
            server.aof_child_pid == -1 &&
            !(flags & LOOKUP_NOTOUCH))
        {
            val->lru = LRU_CLOCK();
        }
        return val;
    } else {
        return NULL;
    }
}

// Assembly:
pushq %rbx
movl %edx, %ebx
movq (%rdi), %rdi
movq 0x8(%rsi), %rsi
callq 0x2ebca
testq %rax, %rax
je 0x419a1
movq 0x8(%rax), %rax
testb $0x1, %bl
jne 0x419a3
leaq 0xbff28(%rip), %rcx     # 0x1018a8
cmpl $-0x1, 0x730(%rcx)
jne 0x419a3
cmpl $-0x1, 0x69c(%rcx)
jne 0x419a3
movl 0x48(%rcx), %ecx
movzbl (%rax), %edx
shll $0x8, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
jmp 0x419a3
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/db.c
// Function: lookupKeyReadWithFlags
robj *lookupKeyReadWithFlags(redisDb *db, robj *key, int flags) {
    robj *val;

    if (expireIfNeeded(db,key) == 1) {
        /* Key expired. If we are in the context of a master, expireIfNeeded()
         * returns 0 only when the key does not exist at all, so it's safe
         * to return NULL ASAP. */
        if (server.masterhost == NULL) return NULL;

        /* However if we are in the context of a slave, expireIfNeeded() will
         * not really try to expire the key, it only returns information
         * about the "logical" status of the key: key expiring is up to the
         * master in order to have a consistent view of master's data set.
         *
         * However, if the command caller is not the master, and as additional
         * safety measure, the command invoked is a read-only command, we can
         * safely return NULL here, and provide a more consistent behavior
         * to clients accessign expired values in a read-only fashion, that
         * will say the key as non exisitng.
         *
         * Notably this covers GETs when slaves are used to scale reads. */
        if (server.current_client &&
            server.current_client != server.master &&
            server.current_client->cmd &&
            server.current_client->cmd->flags & CMD_READONLY)
        {
            return NULL;
        }
    }
    val = lookupKey(db,key,flags);
    if (val == NULL)
        server.stat_keyspace_misses++;
    else
        server.stat_keyspace_hits++;
    return val;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x41a1e
testl %eax, %eax
je 0x419f0
leaq 0xbfee6(%rip), %rcx     # 0x1018a8
cmpq $0x0, 0x828(%rcx)
je 0x41a16
movq 0x1f0(%rcx), %rax
testq %rax, %rax
je 0x419f0
cmpq 0x838(%rcx), %rax
je 0x419f0
movq 0x48(%rax), %rax
testq %rax, %rax
je 0x419f0
testb $0x2, 0x20(%rax)
jne 0x41a16
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x4195c
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
leaq 0xbfe9c(%rip), %rdx     # 0x1018a8
incq 0x3b0(%rdx,%rcx,8)
jmp 0x41a18
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/db.c
// Function: expireIfNeeded
int expireIfNeeded(redisDb *db, robj *key) {
    mstime_t when = getExpire(db,key);
    mstime_t now;

    if (when < 0) return 0; /* No expire for this key */

    /* Don't expire anything while loading. It will be done later. */
    if (server.loading) return 0;

    /* If we are in the context of a Lua script, we claim that time is
     * blocked to when the Lua script started. This way a key can expire
     * only the first time it is accessed and not in the middle of the
     * script execution, making propagation to slaves / AOF consistent.
     * See issue #1525 on Github for more information. */
    now = server.lua_caller ? server.lua_time_start : mstime();

    /* If we are running in the context of a slave, return ASAP:
     * the slave key expiration is controlled by the master that will
     * send us synthesized DEL operations for expired keys.
     *
     * Still we try to return the right information to the caller,
     * that is, 0 if we think the key should be still valid, 1 if
     * we think the key is expired at this time. */
    if (server.masterhost != NULL) return now > when;

    /* Return when this key has not expired */
    if (now <= when) return 0;

    /* Delete the key */
    server.stat_expiredkeys++;
    propagateExpire(db,key);
    notifyKeyspaceEvent(NOTIFY_EXPIRED,
        "expired",key,db->id);
    return dbDelete(db,key);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4302f
xorl %ebp, %ebp
testq %rax, %rax
js 0x41ac4
leaq 0xbfe65(%rip), %r12     # 0x1018a8
cmpl $0x0, 0x31c(%r12)
jne 0x41ac4
movq %rax, %r15
cmpq $0x0, 0x9d8(%r12)
je 0x41a66
movq 0x9f0(%r12), %rax
jmp 0x41a6b
callq 0x2ffce
cmpq $0x0, 0x828(%r12)
je 0x41a81
xorl %ebp, %ebp
cmpq %r15, %rax
setg %bpl
jmp 0x41ac4
cmpq %r15, %rax
jle 0x41ac4
incq 0x3a0(%r12)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x432db
movl 0x30(%r14), %ecx
leaq 0x7af87(%rip), %rsi     # 0xbca2b
movl $0x100, %edi            # imm = 0x100
movq %rbx, %rdx
callq 0x7c665
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x41e5f
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/db.c
// Function: dbAdd
void dbAdd(redisDb *db, robj *key, robj *val) {
    sds copy = sdsdup(key->ptr);
    int retval = dictAdd(db->dict, copy, val);

    serverAssertWithInfo(NULL,key,retval == DICT_OK);
    if (val->type == OBJ_LIST) signalListAsReady(db, key);
    if (server.cluster_enabled) slotToKeyAdd(key);
 }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdi
callq 0x362e0
movq (%r14), %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x2e9b8
testl %eax, %eax
jne 0x41bd9
movl (%r15), %eax
andl $0xf, %eax
cmpl $0x1, %eax
jne 0x41bb6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4d942
leaq 0xbfceb(%rip), %rax     # 0x1018a8
cmpl $0x0, 0x99c(%rax)
je 0x41bd3
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x41c01
popq %rbx
popq %r14
popq %r15
retq
leaq 0x7f350(%rip), %rdx     # 0xc0f30
leaq 0x80e28(%rip), %rcx     # 0xc2a0f
xorl %edi, %edi
movq %rbx, %rsi
movl $0xa1, %r8d
callq 0x627c3
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/db.c
// Function: setKey
void setKey(redisDb *db, robj *key, robj *val) {
    if (lookupKeyWrite(db,key) == NULL) {
        dbAdd(db,key,val);
    } else {
        dbOverwrite(db,key,val);
    }
    incrRefCount(val);
    removeExpire(db,key);
    signalModifiedKey(db,key);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x41a1e
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x4195c
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
testq %rax, %rax
je 0x41d07
callq 0x41c77
jmp 0x41d0c
callq 0x41b77
movq %r15, %rdi
callq 0x407a8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x41d2f
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x60fd1
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/db.c
// Function: removeExpire
int removeExpire(redisDb *db, robj *key) {
    /* An expire may only be removed if there is a corresponding entry in the
     * main dict. Otherwise, the key will never be freed. */
    serverAssertWithInfo(NULL,key,dictFind(db->dict,key->ptr) != NULL);
    return dictDelete(db->expires,key->ptr) == DICT_OK;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%rsi), %rsi
callq 0x2ebca
testq %rax, %rax
je 0x41d68
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x2ecb5
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x7f341(%rip), %rdx     # 0xc10b0
leaq 0x80c99(%rip), %rcx     # 0xc2a0f
xorl %edi, %edi
movq %rbx, %rsi
movl $0x34b, %r8d            # imm = 0x34B
callq 0x627c3
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/db.c
// Function: dbRandomKey
robj *dbRandomKey(redisDb *db) {
    dictEntry *de;

    while(1) {
        sds key;
        robj *keyobj;

        de = dictGetRandomKey(db->dict);
        if (de == NULL) return NULL;

        key = dictGetKey(de);
        keyobj = createStringObject(key,sdslen(key));
        if (dictFind(db->expires,key)) {
            if (expireIfNeeded(db,keyobj)) {
                decrRefCount(keyobj);
                continue; /* search for another key. This expired. */
            }
        }
        return keyobj;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2f141
testq %rax, %rax
je 0x41e4d
leaq 0x7f06f(%rip), %r12     # 0xc0e40
movq (%rax), %r14
movzbl -0x1(%r14), %esi
movl %esi, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x41e0b
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
shrl $0x3, %esi
jmp 0x41e0d
movq -0x11(%r14), %rsi
jmp 0x41e0d
movzwl -0x5(%r14), %esi
jmp 0x41e0d
movl -0x9(%r14), %esi
jmp 0x41e0d
movzbl -0x3(%r14), %esi
jmp 0x41e0d
xorl %esi, %esi
movq %r14, %rdi
callq 0x40744
movq %rax, %r15
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x2ebca
testq %rax, %rax
je 0x41e50
movq %rbx, %rdi
movq %r15, %rsi
callq 0x41a1e
testl %eax, %eax
je 0x41e50
movq %r15, %rdi
callq 0x40c8f
movq (%rbx), %rdi
callq 0x2f141
testq %rax, %rax
jne 0x41dd1
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/db.c
// Function: dbDelete
int dbDelete(redisDb *db, robj *key) {
    /* Deleting an entry from the expires dict will not free the sds of
     * the key, because it is shared with the main dictionary. */
    if (dictSize(db->expires) > 0) dictDelete(db->expires,key->ptr);
    if (dictDelete(db->dict,key->ptr) == DICT_OK) {
        if (server.cluster_enabled) slotToKeyDel(key);
        return 1;
    } else {
        return 0;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x28(%rdi), %rax
addq 0x48(%rdi), %rax
je 0x41e80
movq 0x8(%rbx), %rsi
callq 0x2ecb5
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x2ecb5
xorl %ebp, %ebp
testl %eax, %eax
jne 0x41eaf
leaq 0xbfa0f(%rip), %rax     # 0x1018a8
movl $0x1, %ebp
cmpl $0x0, 0x99c(%rax)
je 0x41eaf
movq %rbx, %rdi
callq 0x41eb6
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/db.c
// Function: dbUnshareStringValue
robj *dbUnshareStringValue(redisDb *db, robj *key, robj *o) {
    serverAssert(o->type == OBJ_STRING);
    if (o->refcount != 1 || o->encoding != OBJ_ENCODING_RAW) {
        robj *decoded = getDecodedObject(o);
        o = createRawStringObject(decoded->ptr, sdslen(decoded->ptr));
        decrRefCount(decoded);
        dbOverwrite(db,key,o);
    }
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl (%rdx), %eax
testb $0xf, %al
jne 0x41fc3
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
testb $-0x10, %al
jne 0x41f4b
cmpl $0x1, 0x4(%r12)
je 0x41fb4
movq %r12, %rdi
callq 0x41026
movq %rax, %r15
movq 0x8(%rax), %rdi
movzbl -0x1(%rdi), %esi
movl %esi, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x41f94
leaq 0x7eef9(%rip), %rcx     # 0xc0e68
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %esi
jmp 0x41f96
movq -0x11(%rdi), %rsi
jmp 0x41f96
movzwl -0x5(%rdi), %esi
jmp 0x41f96
movl -0x9(%rdi), %esi
jmp 0x41f96
movzbl -0x3(%rdi), %esi
jmp 0x41f96
xorl %esi, %esi
callq 0x4068b
movq %rax, %r12
movq %r15, %rdi
callq 0x40c8f
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x41c77
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x7df76(%rip), %rdi     # 0xbff40
leaq 0x80a3e(%rip), %rsi     # 0xc2a0f
movl $0x10a, %edx            # imm = 0x10A
callq 0x61908
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/db.c
// Function: emptyDb
long long emptyDb(void(callback)(void*)) {
    int j;
    long long removed = 0;

    for (j = 0; j < server.dbnum; j++) {
        removed += dictSize(server.db[j].dict);
        dictEmpty(server.db[j].dict,callback);
        dictEmpty(server.db[j].expires,callback);
    }
    if (server.cluster_enabled) slotToKeyFlush();
    return removed;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0xbf8b3(%rip), %r15     # 0x1018a8
cmpl $0x0, 0x610(%r15)
jle 0x42048
movq %rdi, %r14
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %ebx, %ebx
movq 0x28(%r15), %rax
movq (%rax,%r12), %rdi
addq 0x28(%rdi), %rbx
addq 0x48(%rdi), %rbx
movq %r14, %rsi
callq 0x2f51e
movq 0x28(%r15), %rax
movq 0x8(%rax,%r12), %rdi
movq %r14, %rsi
callq 0x2f51e
incq %r13
movslq 0x610(%r15), %rax
addq $0x40, %r12
cmpq %rax, %r13
jl 0x4200a
jmp 0x4204a
xorl %ebx, %ebx
cmpl $0x0, 0x99c(%r15)
je 0x4207a
movq 0x9b0(%r15), %rax
movq 0x60028(%rax), %rdi
callq 0x4fe7a
callq 0x4fe06
movq 0x9b0(%r15), %rcx
movq %rax, 0x60028(%rcx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/db.c
// Function: selectDb
int selectDb(client *c, int id) {
    if (id < 0 || id >= server.dbnum)
        return C_ERR;
    c->db = &server.db[id];
    return C_OK;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %esi, %esi
js 0x420df
leaq 0xbf7e1(%rip), %rcx     # 0x1018a8
cmpl %esi, 0x610(%rcx)
jle 0x420df
movl %esi, %eax
shlq $0x6, %rax
addq 0x28(%rcx), %rax
movq %rax, 0x10(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/db.c
// Function: flushdbCommand
void flushdbCommand(client *c) {
    server.dirty += dictSize(c->db->dict);
    signalFlushedDb(c->db->id);
    dictEmpty(c->db->dict,NULL);
    dictEmpty(c->db->expires,NULL);
    if (server.cluster_enabled) slotToKeyFlush();
    addReply(c,shared.ok);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq (%rax), %rcx
movq 0x48(%rcx), %rdx
addq 0x28(%rcx), %rdx
leaq 0xbf7a6(%rip), %r14     # 0x1018a8
addq %rdx, 0x720(%r14)
movl 0x30(%rax), %edi
callq 0x6102a
movq 0x10(%rbx), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x2f51e
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x2f51e
cmpl $0x0, 0x99c(%r14)
je 0x4215e
movq 0x9b0(%r14), %rax
movq 0x60028(%rax), %rdi
callq 0x4fe7a
callq 0x4fe06
movq 0x9b0(%r14), %rcx
movq %rax, 0x60028(%rcx)
leaq 0xc01ab(%rip), %rax     # 0x102310
movq 0x8(%rax), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3c854
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/db.c
// Function: flushallCommand
void flushallCommand(client *c) {
    signalFlushedDb(-1);
    server.dirty += emptyDb(NULL);
    addReply(c,shared.ok);
    if (server.rdb_child_pid != -1) {
        kill(server.rdb_child_pid,SIGUSR1);
        rdbRemoveTempFile(server.rdb_child_pid);
    }
    if (server.saveparamslen > 0) {
        /* Normally rdbSave() will reset dirty, but we don't want this here
         * as otherwise FLUSHALL will not be replicated nor put into the AOF. */
        int saved_dirty = server.dirty;
        rdbSave(server.rdb_filename);
        server.dirty = saved_dirty;
    }
    server.dirty++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x6102a
xorl %edi, %edi
callq 0x41fe5
leaq 0xbf711(%rip), %r14     # 0x1018a8
addq %rax, 0x720(%r14)
leaq 0xc016b(%rip), %rax     # 0x102310
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x3c854
movl 0x730(%r14), %edi
cmpl $-0x1, %edi
je 0x421d3
movl $0xa, %esi
callq 0x26660
movl 0x730(%r14), %edi
callq 0x4997e
cmpl $0x0, 0x740(%r14)
movq 0x720(%r14), %rbx
jle 0x421f3
movq 0x748(%r14), %rdi
callq 0x49593
movslq %ebx, %rbx
incq %rbx
movq %rbx, 0x720(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/db.c
// Function: delCommand
void delCommand(client *c) {
    int deleted = 0, j;

    for (j = 1; j < c->argc; j++) {
        expireIfNeeded(c->db,c->argv[j]);
        if (dbDelete(c->db,c->argv[j])) {
            signalModifiedKey(c->db,c->argv[j]);
            notifyKeyspaceEvent(NOTIFY_GENERIC,
                "del",c->argv[j],c->db->id);
            server.dirty++;
            deleted++;
        }
    }
    addReplyLongLong(c,deleted);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
cmpl $0x2, 0x38(%rdi)
jl 0x4229e
movl $0x1, %r12d
leaq 0x7c2fd(%rip), %r15     # 0xbe528
leaq 0xbf676(%rip), %r13     # 0x1018a8
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq (%rax,%r12,8), %rsi
callq 0x41a1e
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq (%rax,%r12,8), %rsi
callq 0x41e5f
testl %eax, %eax
je 0x4228f
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq (%rax,%r12,8), %rsi
callq 0x60fd1
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rcx
movq (%rcx,%r12,8), %rdx
movl 0x30(%rax), %ecx
movl $0x4, %edi
movq %r15, %rsi
callq 0x7c665
incq 0x720(%r13)
incl %r14d
incq %r12
movslq 0x38(%rbx), %rax
cmpq %rax, %r12
jl 0x42232
movslq %r14d, %r14
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3d23f
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/db.c
// Function: existsCommand
void existsCommand(client *c) {
    long long count = 0;
    int j;

    for (j = 1; j < c->argc; j++) {
        expireIfNeeded(c->db,c->argv[j]);
        if (dbExists(c->db,c->argv[j])) count++;
    }
    addReplyLongLong(c,count);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x2, 0x38(%rdi)
jl 0x42308
movl $0x1, %r15d
xorl %r14d, %r14d
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rsi
callq 0x41a1e
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movq (%rax), %rdi
movq 0x8(%rcx), %rsi
callq 0x2ebca
cmpq $0x1, %rax
sbbq $-0x1, %r14
incq %r15
movslq 0x38(%rbx), %rax
cmpq %rax, %r15
jl 0x422c9
jmp 0x4230b
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3d23f
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/db.c
// Function: selectCommand
void selectCommand(client *c) {
    long id;

    if (getLongFromObjectOrReply(c, c->argv[1], &id,
        "invalid DB index") != C_OK)
        return;

    if (server.cluster_enabled && id != 0) {
        addReplyError(c,"SELECT is not allowed in cluster mode");
        return;
    }
    if (selectDb(c,id) == C_ERR) {
        addReplyError(c,"invalid DB index");
    } else {
        addReply(c,shared.ok);
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x8(%rax), %rsi
leaq 0x7ec10(%rip), %rcx     # 0xc0f42
leaq 0x8(%rsp), %rdx
callq 0x41718
testl %eax, %eax
jne 0x423b1
leaq 0xbf561(%rip), %rax     # 0x1018a8
cmpl $0x0, 0x99c(%rax)
setne %dl
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x4236f
leaq 0x7ebe6(%rip), %rsi     # 0xc0f53
jmp 0x423a9
testl %ecx, %ecx
js 0x423a2
cmpl %ecx, 0x610(%rax)
jle 0x423a2
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
shlq $0x6, %rcx
addq 0x28(%rax), %rcx
movq %rcx, 0x10(%rbx)
leaq 0xbff7c(%rip), %rax     # 0x102310
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x3c854
jmp 0x423b1
leaq 0x7eb99(%rip), %rsi     # 0xc0f42
movq %rbx, %rdi
callq 0x3cc06
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/db.c
// Function: randomkeyCommand
void randomkeyCommand(client *c) {
    robj *key;

    if ((key = dbRandomKey(c->db)) == NULL) {
        addReply(c,shared.nullbulk);
        return;
    }

    addReplyBulk(c,key);
    decrRefCount(key);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x41dae
testq %rax, %rax
je 0x423e9
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3d170
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40c8f
leaq 0xbff20(%rip), %rax     # 0x102310
movq 0x50(%rax), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3c854