LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x3a9ac
movq %rdi, %r14
fstp %st(0)
movl (%rdi), %eax
testb $0xf, %al
jne 0x3a9be
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
je 0x3a94a
cmpl $0x1, %eax
je 0x3a9a1
testl %eax, %eax
jne 0x3a9de
callq 0x26880
movq %rax, %r15
andl $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
pushq $-0x1
popq %rax
testb $0x20, 0x1(%rcx,%rdx,2)
jne 0x3a9b0
movq 0x8(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x3a9b0
cmpl $0x22, (%r15)
sete %cl
fldt 0x14(%rsp)
fucomi %st(0), %st
setp %dl
orb %cl, %dl
je 0x3a9ac
jmp 0x3a9b2
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 0x76f1f(%rip), %rdx     # 0xb18e4
leaq 0x77b7e(%rip), %rcx     # 0xb254a
xorl %edi, %edi
movq %r14, %rsi
movl $0x248, %r8d            # imm = 0x248
callq 0x588a4
jmp 0x3a9f6
leaq 0x77c76(%rip), %rdi     # 0xb265b
leaq 0x77b5e(%rip), %rsi     # 0xb254a
movl $0x252, %edx            # imm = 0x252
callq 0x57b45
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/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 0x3a90c
testl %eax, %eax
je 0x3aa2f
testq %rbx, %rbx
je 0x3aa39
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x3aa43
fldt (%rsp)
fstpt (%r15)
xorl %eax, %eax
jmp 0x3aa4b
leaq 0x7a655(%rip), %rsi     # 0xb5095
movq %r14, %rdi
callq 0x36b6f
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x3aaa1
movq %rdi, %rsi
movl (%rdi), %eax
testb $0xf, %al
jne 0x3aac6
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
je 0x3aa7e
cmpl $0x1, %eax
je 0x3aaa8
testl %eax, %eax
jne 0x3aae3
movq 0x8(%rsi), %r14
movq %r14, %rdi
callq 0x3a000
movq %rsp, %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x39865
testl %eax, %eax
jne 0x3aab0
pushq $-0x1
popq %rax
jmp 0x3aabe
andq $0x0, (%rsp)
jmp 0x3aab0
movq 0x8(%rsi), %rax
movq %rax, (%rsp)
xorl %eax, %eax
testq %rbx, %rbx
je 0x3aabe
movq (%rsp), %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x76e17(%rip), %rdx     # 0xb18e4
leaq 0x77a76(%rip), %rcx     # 0xb254a
xorl %edi, %edi
movl $0x26d, %r8d            # imm = 0x26D
callq 0x588a4
jmp 0x3aafb
leaq 0x77b71(%rip), %rdi     # 0xb265b
leaq 0x77a59(%rip), %rsi     # 0xb254a
movl $0x273, %edx            # imm = 0x273
callq 0x57b45
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/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 0x3aa55
testl %eax, %eax
je 0x3ab36
testq %rbx, %rbx
je 0x3ab42
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x3ab4c
movq 0x8(%rsp), %rax
movq %rax, (%r15)
xorl %eax, %eax
jmp 0x3ab54
leaq 0x77b2c(%rip), %rsi     # 0xb2675
movq %r14, %rdi
callq 0x36b6f
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3ab03
testl %eax, %eax
je 0x3ab79
pushq $-0x1
popq %rax
jmp 0x3ab83
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x82d36(%rip), %rsi     # 0xbd976
movq %r14, %rdi
callq 0x262f0
testl %eax, %eax
jne 0x3ac7e
cmpl $0x3, 0x38(%rbx)
jne 0x3ac7e
movq 0x10(%r15), %rsi
leaq 0xbf6b3(%rip), %rax     # 0xfa310
movq 0x50(%rax), %rdx
movq %rbx, %rdi
callq 0x3abf9
testq %rax, %rax
je 0x3ad3f
movslq 0x4(%rax), %rsi
movq %rbx, %rdi
jmp 0x3ad21
leaq 0x79c71(%rip), %rsi     # 0xb48f6
movq %r14, %rdi
callq 0x262f0
testl %eax, %eax
jne 0x3acd4
cmpl $0x3, 0x38(%rbx)
jne 0x3acd4
movq 0x10(%r15), %rsi
leaq 0xbf66e(%rip), %rax     # 0xfa310
movq 0x50(%rax), %rdx
movq %rbx, %rdi
callq 0x3abf9
testq %rax, %rax
je 0x3ad3f
movl (%rax), %edi
shrl $0x4, %edi
andl $0xf, %edi
callq 0x3ab89
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x36f5d
leaq 0x779e8(%rip), %rsi     # 0xb26c3
movq %r14, %rdi
callq 0x262f0
testl %eax, %eax
jne 0x3ad2b
cmpl $0x3, 0x38(%rbx)
jne 0x3ad2b
movq 0x10(%r15), %rsi
leaq 0xbf618(%rip), %rax     # 0xfa310
movq 0x50(%rax), %rdx
movq %rbx, %rdi
callq 0x3abf9
testq %rax, %rax
je 0x3ad3f
movq %rax, %rdi
callq 0x3aba7
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divq %rcx
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x370a6
leaq 0x7799a(%rip), %rsi     # 0xb26cc
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x36b6f
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x2a5f9
testq %rax, %rax
je 0x3ad8d
movq 0x8(%rax), %rax
testb $0x1, %bl
jne 0x3ad8f
leaq 0xbeb3c(%rip), %rcx     # 0xf98a8
cmpl $-0x1, 0x730(%rcx)
jne 0x3ad8f
cmpl $-0x1, 0x69c(%rcx)
jne 0x3ad8f
movl 0x48(%rcx), %ecx
movzbl (%rax), %edx
shll $0x8, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
jmp 0x3ad8f
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3ae0a
testl %eax, %eax
je 0x3addc
leaq 0xbeafa(%rip), %rcx     # 0xf98a8
cmpq $0x0, 0x828(%rcx)
je 0x3ae02
movq 0x1f0(%rcx), %rax
testq %rax, %rax
je 0x3addc
cmpq 0x838(%rcx), %rax
je 0x3addc
movq 0x48(%rax), %rax
testq %rax, %rax
je 0x3addc
testb $0x2, 0x20(%rax)
jne 0x3ae02
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x3ad48
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
leaq 0xbeab0(%rip), %rdx     # 0xf98a8
incq 0x3b0(%rdx,%rcx,8)
jmp 0x3ae04
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3c0d3
xorl %ebp, %ebp
testq %rax, %rax
js 0x3aeb0
leaq 0xbea79(%rip), %r12     # 0xf98a8
cmpl $0x0, 0x31c(%r12)
jne 0x3aeb0
movq %rax, %r15
cmpq $0x0, 0x9d8(%r12)
je 0x3ae52
movq 0x9f0(%r12), %rax
jmp 0x3ae57
callq 0x2b8ae
cmpq $0x0, 0x828(%r12)
je 0x3ae6d
xorl %ebp, %ebp
cmpq %r15, %rax
setg %bpl
jmp 0x3aeb0
cmpq %r15, %rax
jle 0x3aeb0
incq 0x3a0(%r12)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3c34a
movl 0x30(%r14), %ecx
leaq 0x73a8b(%rip), %rsi     # 0xae91b
movl $0x100, %edi            # imm = 0x100
movq %rbx, %rdx
callq 0x6fb58
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3b1df
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3117b
movq (%r14), %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x2a3ed
testl %eax, %eax
jne 0x3afa7
movl (%r15), %eax
andl $0xf, %eax
cmpl $0x1, %eax
jne 0x3af84
movq %r14, %rdi
movq %rbx, %rsi
callq 0x455db
leaq 0xbe91d(%rip), %rax     # 0xf98a8
cmpl $0x0, 0x99c(%rax)
je 0x3afa1
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3afcd
popq %rbx
popq %r14
popq %r15
retq
leaq 0x7777e(%rip), %rdx     # 0xb272c
leaq 0x7911a(%rip), %rcx     # 0xb40cf
xorl %edi, %edi
movq %rbx, %rsi
movl $0xa1, %r8d
callq 0x588a4
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/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 0x3aec2
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
testq %rax, %rax
je 0x3b09e
callq 0x3b01d
jmp 0x3b0a3
callq 0x3af45
movq %r15, %rdi
callq 0x39e74
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b0c6
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x572df
// File: /workspace/github_c_makefile_star2_O2/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 0x2a5f9
testq %rax, %rax
je 0x3b0ff
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x2a6dc
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x777a6(%rip), %rdx     # 0xb28ac
leaq 0x78fc2(%rip), %rcx     # 0xb40cf
xorl %edi, %edi
movq %rbx, %rsi
movl $0x34b, %r8d            # imm = 0x34B
callq 0x588a4
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq (%rbx), %rdi
callq 0x2aaf6
testq %rax, %rax
je 0x3b19b
movq (%rax), %r15
movq %r15, %rdi
callq 0x3b1a7
movq %r15, %rdi
movq %rax, %rsi
callq 0x39e29
movq %rax, %r14
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x2a5f9
testq %rax, %rax
je 0x3b19e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ae0a
testl %eax, %eax
je 0x3b19e
movq %r14, %rdi
callq 0x3a265
jmp 0x3b14b
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3b200
movq 0x8(%rbx), %rsi
callq 0x2a6dc
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x2a6dc
xorl %ebp, %ebp
testl %eax, %eax
jne 0x3b22d
leaq 0xbe68f(%rip), %rax     # 0xf98a8
pushq $0x1
popq %rbp
cmpl $0x0, 0x99c(%rax)
je 0x3b22d
movq %rbx, %rdi
callq 0x3b234
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3b2e8
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testb $-0x10, %al
jne 0x3b29e
cmpl $0x1, 0x4(%r15)
je 0x3b2d9
movq %r15, %rdi
callq 0x3a57d
movq %rax, %r12
movq 0x8(%rax), %r15
movq %r15, %rdi
callq 0x3b1a7
movq %r15, %rdi
movq %rax, %rsi
callq 0x39d91
movq %rax, %r15
movq %r12, %rdi
callq 0x3a265
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3b01d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x765f5(%rip), %rdi     # 0xb18e4
leaq 0x78dd9(%rip), %rsi     # 0xb40cf
movl $0x10a, %edx            # imm = 0x10A
callq 0x57ac8
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %r14
xorl %r15d, %r15d
leaq 0xbe58a(%rip), %r12     # 0xf98a8
xorl %r13d, %r13d
xorl %ebx, %ebx
movslq 0x610(%r12), %rax
cmpq %rax, %r13
jge 0x3b364
movq 0x28(%r12), %rax
movq (%rax,%r15), %rdi
addq 0x28(%rdi), %rbx
addq 0x48(%rdi), %rbx
movq %r14, %rsi
callq 0x2ae99
movq 0x28(%r12), %rax
movq 0x8(%rax,%r15), %rdi
movq %r14, %rsi
callq 0x2ae99
incq %r13
addq $0x40, %r15
jmp 0x3b323
cmpl $0x0, 0x99c(%r12)
je 0x3b374
callq 0x3b381
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq $-0x1
popq %rax
testl %esi, %esi
js 0x3b3d7
leaq 0xbe4e9(%rip), %rcx     # 0xf98a8
cmpl %esi, 0x610(%rcx)
jle 0x3b3d7
movl %esi, %eax
shlq $0x6, %rax
addq 0x28(%rcx), %rax
movq %rax, 0x10(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xbe4ae(%rip), %r14     # 0xf98a8
addq %rdx, 0x720(%r14)
movl 0x30(%rax), %edi
callq 0x5732a
movq 0x10(%rbx), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x2ae99
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x2ae99
cmpl $0x0, 0x99c(%r14)
je 0x3b435
callq 0x3b381
leaq 0xbeed4(%rip), %rax     # 0xfa310
movq 0x8(%rax), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x36987
// File: /workspace/github_c_makefile_star2_O2/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
pushq $-0x1
popq %rdi
callq 0x5732a
xorl %edi, %edi
callq 0x3b308
leaq 0xbe43c(%rip), %r14     # 0xf98a8
addq %rax, 0x720(%r14)
leaq 0xbee96(%rip), %rax     # 0xfa310
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x36987
movl 0x730(%r14), %edi
cmpl $-0x1, %edi
je 0x3b4a6
pushq $0xa
popq %rsi
callq 0x26660
movl 0x730(%r14), %edi
callq 0x41d27
cmpl $0x0, 0x740(%r14)
movq 0x720(%r14), %rbx
jle 0x3b4c6
movq 0x748(%r14), %rdi
callq 0x41971
movslq %ebx, %rbx
incq %rbx
movq %rbx, 0x720(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
pushq $0x1
popq %r12
leaq 0x74f24(%rip), %r14     # 0xb0418
pushq $0x4
popq %rbp
leaq 0xbe3aa(%rip), %r13     # 0xf98a8
movslq 0x38(%rbx), %rax
cmpq %rax, %r12
jge 0x3b566
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq (%rax,%r12,8), %rsi
callq 0x3ae0a
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq (%rax,%r12,8), %rsi
callq 0x3b1df
testl %eax, %eax
je 0x3b561
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq (%rax,%r12,8), %rsi
callq 0x572df
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rcx
movq (%rcx,%r12,8), %rdx
movl 0x30(%rax), %ecx
movl %ebp, %edi
movq %r14, %rsi
callq 0x6fb58
incq 0x720(%r13)
incl %r15d
incq %r12
jmp 0x3b4fe
movslq %r15d, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x370a6
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %r15
xorl %r14d, %r14d
movslq 0x38(%rbx), %rax
cmpq %rax, %r15
jge 0x3b5c3
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rsi
callq 0x3ae0a
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rsi
callq 0x3b12a
movl %eax, %eax
addq %rax, %r14
incq %r15
jmp 0x3b58e
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x370a6
// File: /workspace/github_c_makefile_star2_O2/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 0x77154(%rip), %rcx     # 0xb273e
leaq 0x8(%rsp), %rdx
callq 0x3ab5e
testl %eax, %eax
jne 0x3b669
leaq 0xbe2a9(%rip), %rax     # 0xf98a8
cmpl $0x0, 0x99c(%rax)
setne %dl
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x3b627
leaq 0x7712a(%rip), %rsi     # 0xb274f
jmp 0x3b661
testl %ecx, %ecx
js 0x3b65a
cmpl %ecx, 0x610(%rax)
jle 0x3b65a
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
shlq $0x6, %rcx
addq 0x28(%rax), %rcx
movq %rcx, 0x10(%rbx)
leaq 0xbecc4(%rip), %rax     # 0xfa310
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x36987
jmp 0x3b669
leaq 0x770dd(%rip), %rsi     # 0xb273e
movq %rbx, %rdi
callq 0x36b6f
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3b143
testq %rax, %rax
je 0x3b6a1
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36fd9
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3a265
leaq 0xbec68(%rip), %rax     # 0xfa310
movq 0x50(%rax), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x36987
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/db.c
// Function: keysCommand
void keysCommand(client *c) {
    dictIterator *di;
    dictEntry *de;
    sds pattern = c->argv[1]->ptr;
    int plen = sdslen(pattern), allkeys;
    unsigned long numkeys = 0;
    void *replylen = addDeferredMultiBulkLength(c);

    di = dictGetSafeIterator(c->db->dict);
    allkeys = (pattern[0] == '*' && pattern[1] == '\0');
    while((de = dictNext(di)) != NULL) {
        sds key = dictGetKey(de);
        robj *keyobj;

        if (allkeys || stringmatchlen(pattern,plen,key,sdslen(key),0)) {
            keyobj = createStringObject(key,sdslen(key));
            if (expireIfNeeded(c->db,keyobj) == 0) {
                addReplyBulk(c,keyobj);
                numkeys++;
            }
            decrRefCount(keyobj);
        }
    }
    dictReleaseIterator(di);
    setDeferredMultiBulkLength(c,replylen,numkeys);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
movq %r14, %rdi
callq 0x3b1a7
movq %rax, %r12
movq %rbx, %rdi
callq 0x36dad
movq %rax, 0x10(%rsp)
movq 0x10(%rbx), %rax
movq (%rax), %rdi
callq 0x2a9c4
movq %rax, %r13
cmpb $0x2a, (%r14)
jne 0x3b710
cmpb $0x0, 0x1(%r14)
sete %bpl
jmp 0x3b712
xorl %ebp, %ebp
movq $0x0, 0x8(%rsp)
movq %r13, %rdi
callq 0x2a9d3
testq %rax, %rax
je 0x3b78f
movq (%rax), %r15
testb %bpl, %bpl
jne 0x3b74f
movq %r15, %rdi
callq 0x3b1a7
movq %r14, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x3929c
testl %eax, %eax
je 0x3b71b
movq %r15, %rdi
callq 0x3b1a7
movq %r15, %rdi
movq %rax, %rsi
callq 0x39e29
movq %rax, %r15
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x3ae0a
testl %eax, %eax
jne 0x3b785
movq %rbx, %rdi
movq %r15, %rsi
callq 0x36fd9
incq 0x8(%rsp)
movq %r15, %rdi
callq 0x3a265
jmp 0x3b71b
movq %r13, %rdi
callq 0x2aa94
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x36de9
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/db.c
// Function: scanCallback
void scanCallback(void *privdata, const dictEntry *de) {
    void **pd = (void**) privdata;
    list *keys = pd[0];
    robj *o = pd[1];
    robj *key, *val = NULL;

    if (o == NULL) {
        sds sdskey = dictGetKey(de);
        key = createStringObject(sdskey, sdslen(sdskey));
    } else if (o->type == OBJ_SET) {
        key = dictGetKey(de);
        incrRefCount(key);
    } else if (o->type == OBJ_HASH) {
        key = dictGetKey(de);
        incrRefCount(key);
        val = dictGetVal(de);
        incrRefCount(val);
    } else if (o->type == OBJ_ZSET) {
        key = dictGetKey(de);
        incrRefCount(key);
        val = createStringObjectFromLongDouble(*(double*)dictGetVal(de),0);
    } else {
        serverPanic("Type not handled in SCAN callback.");
    }

    listAddNodeTail(keys, key);
    if (val) listAddNodeTail(keys, val);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq (%rdi), %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x3b7f4
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x4, %eax
je 0x3b832
cmpl $0x3, %eax
je 0x3b812
cmpl $0x2, %eax
jne 0x3b877
movq (%r15), %r14
movq %r14, %rdi
callq 0x39e74
jmp 0x3b80d
movq (%r15), %r14
movq %r14, %rdi
callq 0x3b1a7
movq %r14, %rdi
movq %rax, %rsi
callq 0x39e29
movq %rax, %r14
xorl %r15d, %r15d
jmp 0x3b849
movq (%r15), %r14
movq %r14, %rdi
callq 0x39e74
movq 0x8(%r15), %rax
fldl (%rax)
fstpt (%rsp)
xorl %edi, %edi
callq 0x39e78
movq %rax, %r15
jmp 0x3b849
movq (%r15), %r14
movq %r14, %rdi
callq 0x39e74
movq 0x8(%r15), %r15
movq %r15, %rdi
callq 0x39e74
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26ecc
testq %r15, %r15
je 0x3b86d
movq %rbx, %rdi
movq %r15, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x26ecc
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x76ef7(%rip), %rdi     # 0xb2775
leaq 0x7884a(%rip), %rsi     # 0xb40cf
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/db.c
// Function: parseScanCursorOrReply
int parseScanCursorOrReply(client *c, robj *o, unsigned long *cursor) {
    char *eptr;

    /* Use strtoul() because we need an *unsigned* long, so
     * getLongLongFromObject() does not cover the whole cursor space. */
    errno = 0;
    *cursor = strtoul(o->ptr, &eptr, 10);
    if (isspace(((char*)o->ptr)[0]) || eptr[0] != '\0' || errno == ERANGE)
    {
        addReplyError(c, "invalid cursor");
        return C_ERR;
    }
    return C_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x26880
movq %rax, %r14
andl $0x0, (%rax)
movq 0x8(%r12), %rdi
movq %rsp, %rsi
pushq $0xa
popq %rdx
callq 0x26c20
movq %rax, (%r15)
callq 0x26560
movq (%rax), %rax
movq 0x8(%r12), %rcx
movsbq (%rcx), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x3b8ef
movq (%rsp), %rax
cmpb $0x0, (%rax)
jne 0x3b8ef
xorl %eax, %eax
cmpl $0x22, (%r14)
jne 0x3b901
leaq 0x76ea4(%rip), %rsi     # 0xb279a
movq %rbx, %rdi
callq 0x36b6f
pushq $-0x1
popq %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/db.c
// Function: typeCommand
void typeCommand(client *c) {
    robj *o;
    char *type;

    o = lookupKeyReadWithFlags(c->db,c->argv[1],LOOKUP_NOTOUCH);
    if (o == NULL) {
        type = "none";
    } else {
        switch(o->type) {
        case OBJ_STRING: type = "string"; break;
        case OBJ_LIST: type = "list"; break;
        case OBJ_SET: type = "set"; break;
        case OBJ_ZSET: type = "zset"; break;
        case OBJ_HASH: type = "hash"; break;
        default: type = "unknown"; break;
        }
    }
    addReplyStatus(c,type);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
pushq $0x1
popq %rdx
callq 0x3ad91
testq %rax, %rax
je 0x3be7e
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x4, %eax
ja 0x3be87
leaq 0x768a3(%rip), %rcx     # 0xb2718
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
jmp 0x3be8e
leaq 0x769b5(%rip), %rsi     # 0xb283a
jmp 0x3be8e
leaq 0x7682d(%rip), %rsi     # 0xb26bb
movq %rbx, %rdi
popq %rbx
jmp 0x36cc3
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/db.c
// Function: shutdownCommand
void shutdownCommand(client *c) {
    int flags = 0;

    if (c->argc > 2) {
        addReply(c,shared.syntaxerr);
        return;
    } else if (c->argc == 2) {
        if (!strcasecmp(c->argv[1]->ptr,"nosave")) {
            flags |= SHUTDOWN_NOSAVE;
        } else if (!strcasecmp(c->argv[1]->ptr,"save")) {
            flags |= SHUTDOWN_SAVE;
        } else {
            addReply(c,shared.syntaxerr);
            return;
        }
    }
    /* When SHUTDOWN is called while the server is loading a dataset in
     * memory we need to make sure no attempt is performed to save
     * the dataset on shutdown (otherwise it could overwrite the current DB
     * with half-read data).
     *
     * Also when in Sentinel mode clear the SAVE flag and force NOSAVE. */
    if (server.loading || server.sentinel_mode)
        flags = (flags & ~SHUTDOWN_SAVE) | SHUTDOWN_NOSAVE;
    if (prepareForShutdown(flags) == C_OK) exit(0);
    addReplyError(c,"Errors trying to SHUTDOWN. Check logs.");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x38(%rdi), %eax
cmpl $0x3, %eax
jl 0x3bec0
leaq 0xbe463(%rip), %rax     # 0xfa310
movq 0x80(%rax), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x36987
xorl %edi, %edi
pushq $0x2
popq %rbp
cmpl $0x2, %eax
jne 0x3bf01
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
leaq 0x76967(%rip), %rsi     # 0xb2844
movq %r14, %rdi
callq 0x262f0
movl %ebp, %edi
testl %eax, %eax
je 0x3bf01
leaq 0x7838b(%rip), %rsi     # 0xb427d
movq %r14, %rdi
callq 0x262f0
testl %eax, %eax
jne 0x3bea6
pushq $0x1
popq %rdi
leaq 0xbd9a0(%rip), %rax     # 0xf98a8
movl 0x9c(%rax), %ecx
orl 0x31c(%rax), %ecx
cmovnel %ebp, %edi
xorl %eax, %eax
callq 0x2ee95
testl %eax, %eax
je 0x3bf35
leaq 0x76922(%rip), %rsi     # 0xb284b
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x36b6f
xorl %edi, %edi
callq 0x262c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/db.c
// Function: getExpire
long long getExpire(redisDb *db, robj *key) {
    dictEntry *de;

    /* No expire? return ASAP */
    if (dictSize(db->expires) == 0 ||
       (de = dictFind(db->expires,key->ptr)) == NULL) return -1;

    /* The entry was found in the expire dict, this means it should also
     * be present in the main dict (safety check). */
    serverAssertWithInfo(NULL,key,dictFind(db->dict,key->ptr) != NULL);
    return dictGetSignedIntegerVal(de);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movq 0x28(%rdi), %rax
pushq $-0x1
popq %r14
addq 0x48(%rdi), %rax
je 0x3c11a
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
callq 0x2a5f9
testq %rax, %rax
je 0x3c11a
movq %rax, %r12
movq (%r15), %rdi
movq 0x8(%rbx), %rsi
callq 0x2a5f9
testq %rax, %rax
je 0x3c129
movq 0x8(%r12), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x7677c(%rip), %rdx     # 0xb28ac
leaq 0x77f98(%rip), %rcx     # 0xb40cf
xorl %edi, %edi
movq %rbx, %rsi
movl $0x364, %r8d            # imm = 0x364
callq 0x588a4
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/db.c
// Function: setExpire
void setExpire(redisDb *db, robj *key, long long when) {
    dictEntry *kde, *de;

    /* Reuse the sds from the main dict in the expire dict */
    kde = dictFind(db->dict,key->ptr);
    serverAssertWithInfo(NULL,key,kde != NULL);
    de = dictReplaceRaw(db->expires,dictGetKey(kde));
    dictSetSignedIntegerVal(de,when);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
movq 0x8(%rsi), %rsi
callq 0x2a5f9
testq %rax, %rax
je 0x3c184
movq 0x8(%r15), %rdi
movq (%rax), %rsi
callq 0x2a6ae
movq %rbx, 0x8(%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x76745(%rip), %rdx     # 0xb28d0
leaq 0x77f3d(%rip), %rcx     # 0xb40cf
xorl %edi, %edi
movq %r14, %rsi
movl $0x354, %r8d            # imm = 0x354
callq 0x588a4
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/db.c
// Function: propagateExpire
void propagateExpire(redisDb *db, robj *key) {
    robj *argv[2];

    argv[0] = shared.del;
    argv[1] = key;
    incrRefCount(argv[0]);
    incrRefCount(argv[1]);

    if (server.aof_state != AOF_OFF)
        feedAppendOnlyFile(server.delCommand,db->id,argv,2);
    replicationFeedSlaves(server.slaves,db->id,argv,2);

    decrRefCount(argv[0]);
    decrRefCount(argv[1]);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xbdfb2(%rip), %rax     # 0xfa310
movq 0x128(%rax), %rdi
movq %rdi, (%rsp)
movq %rsi, 0x8(%rsp)
callq 0x39e74
movq %r14, %rdi
callq 0x39e74
leaq 0xbd526(%rip), %r14     # 0xf98a8
cmpl $0x0, 0x668(%r14)
je 0x3c3a1
movq 0x340(%r14), %rdi
movl 0x30(%rbx), %esi
movq %rsp, %rdx
pushq $0x2
popq %rcx
callq 0x545f2
movq 0x1e0(%r14), %rdi
movl 0x30(%rbx), %esi
movq %rsp, %rbx
pushq $0x2
popq %rcx
movq %rbx, %rdx
callq 0x3cf58
movq (%rbx), %rdi
callq 0x3a265
movq 0x8(%rbx), %rdi
callq 0x3a265
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/db.c
// Function: ttlGenericCommand
void ttlGenericCommand(client *c, int output_ms) {
    long long expire, ttl = -1;

    /* If the key does not exist at all, return -2 */
    if (lookupKeyReadWithFlags(c->db,c->argv[1],LOOKUP_NOTOUCH) == NULL) {
        addReplyLongLong(c,-2);
        return;
    }
    /* The key exists. Return -1 if it has no expire, or the actual
     * TTL value otherwise. */
    expire = getExpire(c->db,c->argv[1]);
    if (expire != -1) {
        ttl = expire-mstime();
        if (ttl < 0) ttl = 0;
    }
    if (ttl == -1) {
        addReplyLongLong(c,-1);
    } else {
        addReplyLongLong(c,output_ms ? ttl : ((ttl+500)/1000));
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
pushq $0x1
popq %rdx
callq 0x3ad91
testq %rax, %rax
je 0x3c626
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x3c0d3
cmpq $-0x1, %rax
je 0x3c62a
movq %rax, %r14
callq 0x2b8ae
subq %rax, %r14
xorl %esi, %esi
testq %r14, %r14
cmovgq %r14, %rsi
testl %ebp, %ebp
jne 0x3c62d
addq $0x1f4, %rsi            # imm = 0x1F4
movl $0x3e8, %ecx            # imm = 0x3E8
movq %rsi, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rsi
jmp 0x3c62d
pushq $-0x2
jmp 0x3c62c
pushq $-0x1
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x370a6
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/db.c
// Function: persistCommand
void persistCommand(client *c) {
    if (lookupKeyWrite(c->db,c->argv[1])) {
        if (removeExpire(c->db,c->argv[1])) {
            addReply(c,shared.cone);
            server.dirty++;
        } else {
            addReply(c,shared.czero);
        }
    } else {
        addReply(c,shared.czero);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x3aec2
testq %rax, %rax
je 0x3c69a
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x3b0c6
testl %eax, %eax
je 0x3c69a
leaq 0xbdc92(%rip), %rax     # 0xfa310
movq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x36987
leaq 0xbd217(%rip), %rax     # 0xf98a8
incq 0x720(%rax)
popq %rbx
retq
leaq 0xbdc6f(%rip), %rax     # 0xfa310
movq 0x20(%rax), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x36987
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/db.c
// Function: touchCommand
void touchCommand(client *c) {
    int touched = 0;
    for (int j = 1; j < c->argc; j++)
        if (lookupKeyRead(c->db,c->argv[j]) != NULL) touched++;
    addReplyLongLong(c,touched);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
pushq $0x1
popq %r14
movslq 0x38(%rbx), %rax
cmpq %rax, %r14
jge 0x3c6e1
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq (%rax,%r14,8), %rsi
callq 0x3aebb
cmpq $0x1, %rax
sbbl $-0x1, %ebp
incq %r14
jmp 0x3c6bb
movl %ebp, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x370a6
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/db.c
// Function: getKeysUsingCommandTable
int *getKeysUsingCommandTable(struct redisCommand *cmd,robj **argv, int argc, int *numkeys) {
    int j, i = 0, last, *keys;
    UNUSED(argv);

    if (cmd->firstkey == 0) {
        *numkeys = 0;
        return NULL;
    }
    last = cmd->lastkey;
    if (last < 0) last = argc+last;
    keys = zmalloc(sizeof(int)*((last - cmd->firstkey)+1));
    for (j = cmd->firstkey; j <= last; j += cmd->keystep) {
        serverAssert(j < argc);
        keys[i++] = j;
    }
    *numkeys = i;
    return keys;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl 0x30(%rdi), %eax
testl %eax, %eax
je 0x3c743
movl %edx, %ebp
movq %rdi, %r14
movl 0x34(%rdi), %ecx
movl %ecx, %r15d
sarl $0x1f, %r15d
andl %edx, %r15d
addl %ecx, %r15d
movl %r15d, %ecx
subl %eax, %ecx
incl %ecx
movslq %ecx, %rdi
shlq $0x2, %rdi
callq 0x327b9
movl 0x30(%r14), %edx
xorl %ecx, %ecx
cmpl %r15d, %edx
jg 0x3c747
cmpl %ebp, %edx
jge 0x3c754
movl %edx, (%rax,%rcx,4)
incq %rcx
addl 0x38(%r14), %edx
jmp 0x3c72e
xorl %ecx, %ecx
xorl %eax, %eax
movl %ecx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x76195(%rip), %rdi     # 0xb28f0
leaq 0x7796d(%rip), %rsi     # 0xb40cf
movl $0x432, %edx            # imm = 0x432
callq 0x57ac8
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/db.c
// Function: zunionInterGetKeys
int *zunionInterGetKeys(struct redisCommand *cmd, robj **argv, int argc, int *numkeys) {
    int i, num, *keys;
    UNUSED(cmd);

    num = atoi(argv[2]->ptr);
    /* Sanity check. Don't return any key if the command is going to
     * reply with syntax error. */
    if (num > (argc-3)) {
        *numkeys = 0;
        return NULL;
    }

    /* Keys in z{union,inter}store come from two places:
     * argv[1] = storage key,
     * argv[3...n] = keys to intersect */
    keys = zmalloc(sizeof(int)*(num+1));

    /* Add all key positions for argv[3...n] to keys[] */
    for (i = 0; i < num; i++) keys[i] = 3+i;

    /* Finally add the argv[1] key position (the storage key target). */
    keys[num] = 1;
    *numkeys = num+1;  /* Total keys = {union,inter} keys + storage key */
    return keys;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rdi
callq 0x26760
addl $-0x3, %ebp
cmpl %ebp, %eax
jle 0x3c7b0
xorl %r15d, %r15d
xorl %eax, %eax
jmp 0x3c7e8
movl %eax, %r14d
leal 0x1(%r14), %r15d
movslq %eax, %r12
leaq 0x4(,%r12,4), %rdi
callq 0x327b9
xorl %ecx, %ecx
testl %r14d, %r14d
cmovlel %ecx, %r14d
cmpq %rcx, %r14
je 0x3c7e0
leal 0x3(%rcx), %edx
movl %edx, (%rax,%rcx,4)
incq %rcx
jmp 0x3c7d0
movl $0x1, (%rax,%r12,4)
movl %r15d, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/db.c
// Function: evalGetKeys
int *evalGetKeys(struct redisCommand *cmd, robj **argv, int argc, int *numkeys) {
    int i, num, *keys;
    UNUSED(cmd);

    num = atoi(argv[2]->ptr);
    /* Sanity check. Don't return any key if the command is going to
     * reply with syntax error. */
    if (num > (argc-3)) {
        *numkeys = 0;
        return NULL;
    }

    keys = zmalloc(sizeof(int)*num);
    *numkeys = num;

    /* Add all key positions for argv[3...n] to keys[] */
    for (i = 0; i < num; i++) keys[i] = 3+i;

    return keys;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
movl %edx, %ebp
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rdi
callq 0x26760
addl $-0x3, %ebp
cmpl %ebp, %eax
jle 0x3c81c
andl $0x0, (%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl %eax, %ebx
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x327b9
movl %ebx, (%r14)
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
cmpq %rcx, %rbx
je 0x3c817
leal 0x3(%rcx), %edx
movl %edx, (%rax,%rcx,4)
incq %rcx
jmp 0x3c834