LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/rdb.c
// Function: rdbSaveInfoAuxFields
int rdbSaveInfoAuxFields(rio *rdb) {
    int redis_bits = (sizeof(void*) == 8) ? 64 : 32;

    /* Add a few fields about the state when the RDB was created. */
    if (rdbSaveAuxFieldStrStr(rdb,"redis-ver",REDIS_VERSION) == -1) return -1;
    if (rdbSaveAuxFieldStrInt(rdb,"redis-bits",redis_bits) == -1) return -1;
    if (rdbSaveAuxFieldStrInt(rdb,"ctime",time(NULL)) == -1) return -1;
    if (rdbSaveAuxFieldStrInt(rdb,"used-mem",zmalloc_used_memory()) == -1) return -1;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x40, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xe87c8(%rip), %rsi     # 0x13d236
leaq 0xe57ed(%rip), %rdx     # 0x13a262
callq 0x54990
cmpl $-0x1, %eax
jne 0x54a8b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x54b14
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rdx
leaq 0xe87a6(%rip), %rsi     # 0x13d240
callq 0x549f0
cmpl $-0x1, %eax
jne 0x54aad
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x54b14
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x26ce0
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0xe877f(%rip), %rsi     # 0x13d24b
callq 0x549f0
cmpl $-0x1, %eax
jne 0x54adf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x54b14
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x3b090
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0xe8757(%rip), %rsi     # 0x13d251
callq 0x549f0
cmpl $-0x1, %eax
jne 0x54b0d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x54b14
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/./rio.h
// Function: rioWrite
static inline size_t rioWrite(rio *r, const void *buf, size_t len) {
    while (len) {
        size_t bytes_to_write = (r->max_processing_chunk && r->max_processing_chunk < len) ? r->max_processing_chunk : len;
        if (r->update_cksum) r->update_cksum(r,buf,bytes_to_write);
        if (r->write(r,buf,bytes_to_write) == 0)
            return 0;
        buf = (char*)buf + bytes_to_write;
        len -= bytes_to_write;
        r->processed_bytes += bytes_to_write;
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x54f4d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x54ec6
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpq -0x20(%rbp), %rax
jae 0x54ec6
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x54ece
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x54ef7
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq *%rax
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq *%rax
cmpq $0x0, %rax
jne 0x54f1d
movq $0x0, -0x8(%rbp)
jmp 0x54f55
movq -0x18(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
jmp 0x54e94
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/rdb.c
// Function: rdbSaveRioWithEOFMark
int rdbSaveRioWithEOFMark(rio *rdb, int *error) {
    char eofmark[RDB_EOF_MARK_SIZE];

    getRandomHexChars(eofmark,RDB_EOF_MARK_SIZE);
    if (error) *error = 0;
    if (rioWrite(rdb,"$EOF:",5) == 0) goto werr;
    if (rioWrite(rdb,eofmark,RDB_EOF_MARK_SIZE) == 0) goto werr;
    if (rioWrite(rdb,"\r\n",2) == 0) goto werr;
    if (rdbSaveRio(rdb,error) == C_ERR) goto werr;
    if (rioWrite(rdb,eofmark,RDB_EOF_MARK_SIZE) == 0) goto werr;
    return C_OK;

werr: /* Write error. */
    /* Set 'error' only if not already set by rdbSaveRio() call. */
    if (error && *error == 0) *error = errno;
    return C_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
movl $0x28, %esi
callq 0x47e40
cmpq $0x0, -0x18(%rbp)
je 0x54f8f
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
leaq 0xe82ca(%rip), %rsi     # 0x13d264
movl $0x5, %edx
callq 0x54e80
cmpq $0x0, %rax
jne 0x54fac
jmp 0x5501a
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x28, %edx
callq 0x54e80
cmpq $0x0, %rax
jne 0x54fc6
jmp 0x5501a
movq -0x10(%rbp), %rdi
leaq 0xe92b7(%rip), %rsi     # 0x13e288
movl $0x2, %edx
callq 0x54e80
cmpq $0x0, %rax
jne 0x54fe3
jmp 0x5501a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x54b20
cmpl $-0x1, %eax
jne 0x54ff7
jmp 0x5501a
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x28, %edx
callq 0x54e80
cmpq $0x0, %rax
jne 0x55011
jmp 0x5501a
movl $0x0, -0x4(%rbp)
jmp 0x5503e
cmpq $0x0, -0x18(%rbp)
je 0x55037
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x55037
callq 0x26880
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/rdb.c
// Function: startLoading
void startLoading(FILE *fp) {
    struct stat sb;

    /* Load the DB */
    server.loading = 1;
    server.loading_start_time = time(NULL);
    server.loading_loaded_bytes = 0;
    if (fstat(fileno(fp), &sb) == -1) {
        server.loading_total_bytes = 0;
    } else {
        server.loading_total_bytes = sb.st_size;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x121f52(%rip), %rax    # 0x1781d8
movl $0x1, 0x31c(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x26ce0
movq %rax, %rcx
leaq 0x121f35(%rip), %rax    # 0x1781d8
movq %rcx, 0x330(%rax)
leaq 0x121f27(%rip), %rax    # 0x1781d8
movq $0x0, 0x328(%rax)
movq -0x8(%rbp), %rdi
callq 0x26070
movl %eax, %edi
leaq -0x98(%rbp), %rsi
callq 0x266f0
cmpl $-0x1, %eax
jne 0x562ec
leaq 0x121ef9(%rip), %rax    # 0x1781d8
movq $0x0, 0x320(%rax)
jmp 0x562fe
movq -0x68(%rbp), %rcx
leaq 0x121ee1(%rip), %rax    # 0x1781d8
movq %rcx, 0x320(%rax)
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/rdb.c
// Function: rdbLoadProgressCallback
void rdbLoadProgressCallback(rio *r, const void *buf, size_t len) {
    if (server.rdb_checksum)
        rioGenericUpdateChecksum(r, buf, len);
    if (server.loading_process_events_interval_bytes &&
        (r->processed_bytes + len)/server.loading_process_events_interval_bytes > r->processed_bytes/server.loading_process_events_interval_bytes)
    {
        /* The DB can take some non trivial amount of time to load. Update
         * our cached time since it is used to create and update the last
         * interaction time with clients and for other important things. */
        updateCachedTime();
        if (server.masterhost && server.repl_state == REPL_STATE_TRANSFER)
            replicationSendNewlineToMaster();
        loadingProgress(r->processed_bytes);
        processEventsWhileBlocked();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x121e2d(%rip), %rax    # 0x1781d8
cmpl $0x0, 0x754(%rax)
je 0x563c5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x8e780
leaq 0x121e0c(%rip), %rax    # 0x1781d8
cmpq $0x0, 0x338(%rax)
je 0x5645b
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
addq -0x18(%rbp), %rax
leaq 0x121deb(%rip), %rcx    # 0x1781d8
xorl %edx, %edx
divq 0x338(%rcx)
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
leaq 0x121dcf(%rip), %rcx    # 0x1781d8
xorl %edx, %edx
divq 0x338(%rcx)
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jbe 0x5645b
callq 0x310e0
leaq 0x121dae(%rip), %rax    # 0x1781d8
cmpq $0x0, 0x828(%rax)
je 0x56449
leaq 0x121d9d(%rip), %rax    # 0x1781d8
cmpl $0xe, 0x84c(%rax)
jne 0x56449
callq 0x4f940
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x56310
callq 0x46e80
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/rdb.c
// Function: backgroundSaveDoneHandler
void backgroundSaveDoneHandler(int exitcode, int bysignal) {
    switch(server.rdb_child_type) {
    case RDB_CHILD_TYPE_DISK:
        backgroundSaveDoneHandlerDisk(exitcode,bysignal);
        break;
    case RDB_CHILD_TYPE_SOCKET:
        backgroundSaveDoneHandlerSocket(exitcode,bysignal);
        break;
    default:
        serverPanic("Unknown RDB child type.");
        break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0x121273(%rip), %rax    # 0x1781d8
movl 0x77c(%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x1, %eax
je 0x56f7f
jmp 0x56f75
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x56f8c
jmp 0x56f99
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x56a30
jmp 0x56fbb
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x56c40
jmp 0x56fbb
leaq 0xe67d1(%rip), %rdi     # 0x13d771
leaq 0xe61fa(%rip), %rsi     # 0x13d1a1
movl $0x624, %edx            # imm = 0x624
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/rdb.c
// Function: saveCommand
void saveCommand(client *c) {
    if (server.rdb_child_pid != -1) {
        addReplyError(c,"Background save already in progress");
        return;
    }
    if (rdbSave(server.rdb_filename) == C_OK) {
        addReply(c,shared.ok);
    } else {
        addReply(c,shared.err);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x120bf5(%rip), %rax    # 0x1781d8
cmpl $-0x1, 0x730(%rax)
je 0x575fe
movq -0x8(%rbp), %rdi
leaq 0xe61d2(%rip), %rsi     # 0x13d7c9
callq 0x42f90
jmp 0x57640
leaq 0x120bd3(%rip), %rax    # 0x1781d8
movq 0x748(%rax), %rdi
callq 0x55050
cmpl $0x0, %eax
jne 0x5762c
movq -0x8(%rbp), %rdi
leaq 0x12161f(%rip), %rax    # 0x178c40
movq 0x8(%rax), %rsi
callq 0x42cc0
jmp 0x57640
movq -0x8(%rbp), %rdi
leaq 0x121609(%rip), %rax    # 0x178c40
movq 0x10(%rax), %rsi
callq 0x42cc0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/rdb.c
// Function: bgsaveCommand
void bgsaveCommand(client *c) {
    int schedule = 0;

    /* The SCHEDULE option changes the behavior of BGSAVE when an AOF rewrite
     * is in progress. Instead of returning an error a BGSAVE gets scheduled. */
    if (c->argc > 1) {
        if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr,"schedule")) {
            schedule = 1;
        } else {
            addReply(c,shared.syntaxerr);
            return;
        }
    }

    if (server.rdb_child_pid != -1) {
        addReplyError(c,"Background save already in progress");
    } else if (server.aof_child_pid != -1) {
        if (schedule) {
            server.rdb_bgsave_scheduled = 1;
            addReplyStatus(c,"Background saving scheduled");
        } else {
            addReplyError(c,
                "An AOF log rewriting in progress: can't BGSAVE right now. "
                "Use BGSAVE SCHEDULE in order to schedule a BGSAVE whenver "
                "possible.");
        }
    } else if (rdbSaveBackground(server.rdb_filename) == C_OK) {
        addReplyStatus(c,"Background saving started");
    } else {
        addReply(c,shared.err);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x38(%rax)
jle 0x576bf
movq -0x8(%rbp), %rax
cmpl $0x2, 0x38(%rax)
jne 0x576a1
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xe615f(%rip), %rsi     # 0x13d7ed
callq 0x26300
cmpl $0x0, %eax
jne 0x576a1
movl $0x1, -0xc(%rbp)
jmp 0x576bd
movq -0x8(%rbp), %rdi
leaq 0x121594(%rip), %rax    # 0x178c40
movq 0x80(%rax), %rsi
callq 0x42cc0
jmp 0x57771
jmp 0x576bf
leaq 0x120b12(%rip), %rax    # 0x1781d8
cmpl $-0x1, 0x730(%rax)
je 0x576e4
movq -0x8(%rbp), %rdi
leaq 0xe60ef(%rip), %rsi     # 0x13d7c9
callq 0x42f90
jmp 0x57771
leaq 0x120aed(%rip), %rax    # 0x1781d8
cmpl $-0x1, 0x69c(%rax)
je 0x5772f
cmpl $0x0, -0xc(%rbp)
je 0x5771d
leaq 0x120ad7(%rip), %rax    # 0x1781d8
movl $0x1, 0x778(%rax)
movq -0x8(%rbp), %rdi
leaq 0xe60e0(%rip), %rsi     # 0x13d7f6
callq 0x43180
jmp 0x5772d
movq -0x8(%rbp), %rdi
leaq 0xe60ea(%rip), %rsi     # 0x13d812
callq 0x42f90
jmp 0x5776f
leaq 0x120aa2(%rip), %rax    # 0x1781d8
movq 0x748(%rax), %rdi
callq 0x55360
cmpl $0x0, %eax
jne 0x57759
movq -0x8(%rbp), %rdi
leaq 0xe613e(%rip), %rsi     # 0x13d890
callq 0x43180
jmp 0x5776d
movq -0x8(%rbp), %rdi
leaq 0x1214dc(%rip), %rax    # 0x178c40
movq 0x10(%rax), %rsi
callq 0x42cc0
jmp 0x5776f
jmp 0x57771
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_string.c
// Function: getGenericCommand
int getGenericCommand(client *c) {
    robj *o;

    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk)) == NULL)
        return C_OK;

    if (o->type != OBJ_STRING) {
        addReply(c,shared.wrongtypeerr);
        return C_ERR;
    } else {
        addReplyBulk(c,o);
        return C_OK;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x120e5d(%rip), %rax    # 0x178c40
movq 0x50(%rax), %rdx
callq 0x4a730
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x57dff
movl $0x0, -0x4(%rbp)
jmp 0x57e3e
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x57e2a
movq -0x10(%rbp), %rdi
leaq 0x120e28(%rip), %rax    # 0x178c40
movq 0x70(%rax), %rsi
callq 0x42cc0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x57e3e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x43630
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_string.c
// Function: getsetCommand
void getsetCommand(client *c) {
    if (getGenericCommand(c) == C_ERR) return;
    c->argv[2] = tryObjectEncoding(c->argv[2]);
    setKey(c->db,c->argv[1],c->argv[2]);
    notifyKeyspaceEvent(NOTIFY_STRING,"set",c->argv[1],c->db->id);
    server.dirty++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x57dc0
cmpl $-0x1, %eax
jne 0x57e8f
jmp 0x57f1c
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x491b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rdx
callq 0x4a960
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x30(%rax), %ecx
movl $0x8, %edi
leaq 0xe093e(%rip), %rsi     # 0x138835
callq 0x9ce20
leaq 0x1202d5(%rip), %rax    # 0x1781d8
movq 0x720(%rax), %rcx
addq $0x1, %rcx
leaq 0x1202c3(%rip), %rax    # 0x1781d8
movq %rcx, 0x720(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_string.c
// Function: checkStringLength
static int checkStringLength(client *c, long long size) {
    if (size > 512*1024*1024) {
        addReplyError(c,"string exceeds maximum allowed size (512MB)");
        return C_ERR;
    }
    return C_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x20000000, -0x18(%rbp) # imm = 0x20000000
jle 0x582d3
movq -0x10(%rbp), %rdi
leaq 0xe569d(%rip), %rsi     # 0x13d962
callq 0x42f90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x582da
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_string.c
// Function: mgetCommand
void mgetCommand(client *c) {
    int j;

    addReplyMultiBulkLen(c,c->argc-1);
    for (j = 1; j < c->argc; j++) {
        robj *o = lookupKeyRead(c->db,c->argv[j]);
        if (o == NULL) {
            addReply(c,shared.nullbulk);
        } else {
            if (o->type != OBJ_STRING) {
                addReply(c,shared.nullbulk);
            } else {
                addReplyBulk(c,o);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x437f0
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x5857a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x4a6c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x58537
movq -0x8(%rbp), %rdi
leaq 0x120714(%rip), %rax    # 0x178c40
movq 0x50(%rax), %rsi
callq 0x42cc0
jmp 0x5856a
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x5855b
movq -0x8(%rbp), %rdi
leaq 0x1206f0(%rip), %rax    # 0x178c40
movq 0x50(%rax), %rsi
callq 0x42cc0
jmp 0x58568
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x43630
jmp 0x5856a
jmp 0x5856c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x584e9
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_string.c
// Function: strlenCommand
void strlenCommand(client *c) {
    robj *o;
    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL ||
        checkType(c,o,OBJ_STRING)) return;
    addReplyLongLong(c,stringObjectLen(o));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x11fd6d(%rip), %rax    # 0x178c40
movq 0x20(%rax), %rdx
callq 0x4a730
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x58efa
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0x58efc
jmp 0x58f19
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x498c0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x43780
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_list.c
// Function: listTypePush
void listTypePush(robj *subject, robj *value, int where) {
    if (subject->encoding == OBJ_ENCODING_QUICKLIST) {
        int pos = (where == LIST_HEAD) ? QUICKLIST_HEAD : QUICKLIST_TAIL;
        value = getDecodedObject(value);
        size_t len = sdslen(value->ptr);
        quicklistPush(subject->ptr, value->ptr, len, pos);
        decrRefCount(value);
    } else {
        serverPanic("Unknown list encoding");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x9, %eax
jne 0x58f9c
movl -0x14(%rbp), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x494f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x58fd0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
movl -0x18(%rbp), %ecx
callq 0x2a490
movq -0x10(%rbp), %rdi
callq 0x48f70
jmp 0x58fbe
leaq 0xe4242(%rip), %rdi     # 0x13d1e5
leaq 0xe49fa(%rip), %rsi     # 0x13d9a4
movl $0x31, %edx
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_list.c
// Function: listTypePop
robj *listTypePop(robj *subject, int where) {
    long long vlong;
    robj *value = NULL;

    int ql_where = where == LIST_HEAD ? QUICKLIST_HEAD : QUICKLIST_TAIL;
    if (subject->encoding == OBJ_ENCODING_QUICKLIST) {
        if (quicklistPopCustom(subject->ptr, ql_where, (unsigned char **)&value,
                               NULL, &vlong, listPopSaver)) {
            if (!value)
                value = createStringObjectFromLongLong(vlong);
        }
    } else {
        serverPanic("Unknown list encoding");
    }
    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x20(%rbp)
movl -0xc(%rbp), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x9, %eax
jne 0x5910b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x24(%rbp), %esi
leaq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
leaq -0x18(%rbp), %r8
leaq -0x89(%rip), %r9        # 0x59060
callq 0x2a210
cmpl $0x0, %eax
je 0x59109
cmpq $0x0, -0x20(%rbp)
jne 0x59107
movq -0x18(%rbp), %rdi
callq 0x486f0
movq %rax, -0x20(%rbp)
jmp 0x59109
jmp 0x5912d
leaq 0xe40d3(%rip), %rdi     # 0x13d1e5
leaq 0xe488b(%rip), %rsi     # 0x13d9a4
movl $0x45, %edx
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_list.c
// Function: listTypeLength
unsigned long listTypeLength(robj *subject) {
    if (subject->encoding == OBJ_ENCODING_QUICKLIST) {
        return quicklistCount(subject->ptr);
    } else {
        serverPanic("Unknown list encoding");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x9, %eax
jne 0x59172
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x278c0
movl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
leaq 0xe406c(%rip), %rdi     # 0x13d1e5
leaq 0xe4824(%rip), %rsi     # 0x13d9a4
movl $0x4e, %edx
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_list.c
// Function: listTypeInitIterator
listTypeIterator *listTypeInitIterator(robj *subject, long index,
                                       unsigned char direction) {
    listTypeIterator *li = zmalloc(sizeof(listTypeIterator));
    li->subject = subject;
    li->encoding = subject->encoding;
    li->direction = direction;
    li->iter = NULL;
    /* LIST_HEAD means start at TAIL and move *towards* head.
     * LIST_TAIL means start at HEAD and move *towards tail. */
    int iter_direction =
        direction == LIST_HEAD ? AL_START_TAIL : AL_START_HEAD;
    if (li->encoding == OBJ_ENCODING_QUICKLIST) {
        li->iter = quicklistGetIteratorAtIdx(li->subject->ptr,
                                             iter_direction, index);
    } else {
        serverPanic("Unknown list encoding");
    }
    return li;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x18, %edi
callq 0x3acd0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x8(%rax)
movb -0x11(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x9(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movzbl -0x11(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x9, %eax
jne 0x5923e
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
movl -0x24(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x29ba0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x59260
leaq 0xe3fa0(%rip), %rdi     # 0x13d1e5
leaq 0xe4758(%rip), %rsi     # 0x13d9a4
movl $0x62, %edx
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_list.c
// Function: listTypeNext
int listTypeNext(listTypeIterator *li, listTypeEntry *entry) {
    /* Protect from converting when iterating */
    serverAssert(li->subject->encoding == li->encoding);

    entry->li = li;
    if (li->encoding == OBJ_ENCODING_QUICKLIST) {
        return quicklistNext(li->iter, &entry->entry);
    } else {
        serverPanic("Unknown list encoding");
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
movq -0x8(%rbp), %rcx
movzbl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jne 0x592cd
jmp 0x592ef
leaq 0xe46d9(%rip), %rdi     # 0x13d9ad
leaq 0xe46c9(%rip), %rsi     # 0x13d9a4
movl $0x72, %edx
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x9, %eax
jne 0x59322
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x29cb0
addq $0x10, %rsp
popq %rbp
retq
leaq 0xe3ebc(%rip), %rdi     # 0x13d1e5
leaq 0xe4674(%rip), %rsi     # 0x13d9a4
movl $0x78, %edx
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_list.c
// Function: listTypeGet
robj *listTypeGet(listTypeEntry *entry) {
    robj *value = NULL;
    if (entry->li->encoding == OBJ_ENCODING_QUICKLIST) {
        if (entry->entry.value) {
            value = createStringObject((char *)entry->entry.value,
                                       entry->entry.sz);
        } else {
            value = createStringObjectFromLongLong(entry->entry.longval);
        }
    } else {
        serverPanic("Unknown list encoding");
    }
    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzbl 0x8(%rax), %eax
cmpl $0x9, %eax
jne 0x593ae
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x5939b
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, %esi
callq 0x486a0
movq %rax, -0x10(%rbp)
jmp 0x593ac
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x486f0
movq %rax, -0x10(%rbp)
jmp 0x593d0
leaq 0xe3e30(%rip), %rdi     # 0x13d1e5
leaq 0xe45e8(%rip), %rsi     # 0x13d9a4
movl $0x88, %edx
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_list.c
// Function: listTypeInsert
void listTypeInsert(listTypeEntry *entry, robj *value, int where) {
    if (entry->li->encoding == OBJ_ENCODING_QUICKLIST) {
        value = getDecodedObject(value);
        sds str = value->ptr;
        size_t len = sdslen(str);
        if (where == LIST_TAIL) {
            quicklistInsertAfter((quicklist *)entry->entry.quicklist,
                                 &entry->entry, str, len);
        } else if (where == LIST_HEAD) {
            quicklistInsertBefore((quicklist *)entry->entry.quicklist,
                                  &entry->entry, str, len);
        }
        decrRefCount(value);
    } else {
        serverPanic("Unknown list encoding");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzbl 0x8(%rax), %eax
cmpl $0x9, %eax
jne 0x5947e
movq -0x10(%rbp), %rdi
callq 0x494f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x58fd0
movq %rax, -0x28(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x5944e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x297c0
jmp 0x59473
cmpl $0x0, -0x14(%rbp)
jne 0x59471
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x29780
jmp 0x59473
movq -0x10(%rbp), %rdi
callq 0x48f70
jmp 0x594a0
leaq 0xe3d60(%rip), %rdi     # 0x13d1e5
leaq 0xe4518(%rip), %rsi     # 0x13d9a4
movl $0x9b, %edx
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_list.c
// Function: listTypeEqual
int listTypeEqual(listTypeEntry *entry, robj *o) {
    if (entry->li->encoding == OBJ_ENCODING_QUICKLIST) {
        serverAssertWithInfo(NULL,o,sdsEncodedObject(o));
        return quicklistCompare(entry->entry.zi,o->ptr,sdslen(o->ptr));
    } else {
        serverPanic("Unknown list encoding");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzbl 0x8(%rax), %eax
cmpl $0x9, %eax
jne 0x5955d
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x594f6
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x594f8
jmp 0x59523
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
leaq 0xe44cc(%rip), %rdx     # 0x13d9d3
leaq 0xe4496(%rip), %rcx     # 0x13d9a4
movl $0xa2, %r8d
callq 0x78360
movl $0x1, %edi
callq 0x263c0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x58fd0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl %eax, %edx
callq 0x29ae0
addq $0x20, %rsp
popq %rbp
retq
leaq 0xe3c81(%rip), %rdi     # 0x13d1e5
leaq 0xe4439(%rip), %rsi     # 0x13d9a4
movl $0xa5, %edx
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_list.c
// Function: listTypeDelete
void listTypeDelete(listTypeIterator *iter, listTypeEntry *entry) {
    if (entry->li->encoding == OBJ_ENCODING_QUICKLIST) {
        quicklistDelEntry(iter->iter, &entry->entry);
    } else {
        serverPanic("Unknown list encoding");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl 0x8(%rax), %eax
cmpl $0x9, %eax
jne 0x595b7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x286f0
jmp 0x595d9
leaq 0xe3c27(%rip), %rdi     # 0x13d1e5
leaq 0xe43df(%rip), %rsi     # 0x13d9a4
movl $0xae, %edx
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_list.c
// Function: listTypeConvert
void listTypeConvert(robj *subject, int enc) {
    serverAssertWithInfo(NULL,subject,subject->type==OBJ_LIST);
    serverAssertWithInfo(NULL,subject,subject->encoding==OBJ_ENCODING_ZIPLIST);

    if (enc == OBJ_ENCODING_QUICKLIST) {
        size_t zlen = server.list_max_ziplist_size;
        int depth = server.list_compress_depth;
        subject->ptr = quicklistCreateFromZiplist(zlen, depth, subject->ptr);
        subject->encoding = OBJ_ENCODING_QUICKLIST;
    } else {
        serverPanic("Unsupported list conversion");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x1, %eax
jne 0x595ff
jmp 0x5962a
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
leaq 0xe43d9(%rip), %rdx     # 0x13d9e7
leaq 0xe438f(%rip), %rcx     # 0x13d9a4
movl $0xb4, %r8d
callq 0x78360
movl $0x1, %edi
callq 0x263c0
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x5, %eax
jne 0x5963d
jmp 0x59668
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
leaq 0xe43b3(%rip), %rdx     # 0x13d9ff
leaq 0xe4351(%rip), %rcx     # 0x13d9a4
movl $0xb5, %r8d
callq 0x78360
movl $0x1, %edi
callq 0x263c0
cmpl $0x9, -0xc(%rbp)
jne 0x596c7
leaq 0x11eb63(%rip), %rax    # 0x1781d8
movslq 0x970(%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0x11eb51(%rip), %rax    # 0x1781d8
movl 0x974(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %edi
movl -0x1c(%rbp), %esi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x28510
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff0f, %ecx       # imm = 0xFFFFFF0F
orl $0x90, %ecx
movl %ecx, (%rax)
jmp 0x596e9
leaq 0xe4359(%rip), %rdi     # 0x13da27
leaq 0xe42cf(%rip), %rsi     # 0x13d9a4
movl $0xbd, %edx
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_list.c
// Function: linsertCommand
void linsertCommand(client *c) {
    c->argv[4] = tryObjectEncoding(c->argv[4]);
    if (strcasecmp(c->argv[2]->ptr,"after") == 0) {
        pushxGenericCommand(c,c->argv[3],c->argv[4],LIST_TAIL);
    } else if (strcasecmp(c->argv[2]->ptr,"before") == 0) {
        pushxGenericCommand(c,c->argv[3],c->argv[4],LIST_HEAD);
    } else {
        addReply(c,shared.syntaxerr);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x20(%rax), %rdi
callq 0x491b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xe3e22(%rip), %rsi     # 0x13da45
callq 0x26300
cmpl $0x0, %eax
jne 0x59c55
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x18(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x20(%rax), %rdx
movl $0x1, %ecx
callq 0x59930
jmp 0x59cb4
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xe3ddf(%rip), %rsi     # 0x13da4b
callq 0x26300
cmpl $0x0, %eax
jne 0x59c9b
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x18(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x20(%rax), %rdx
xorl %ecx, %ecx
callq 0x59930
jmp 0x59cb2
movq -0x8(%rbp), %rdi
leaq 0x11ef9a(%rip), %rax    # 0x178c40
movq 0x80(%rax), %rsi
callq 0x42cc0
jmp 0x59cb4
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_list.c
// Function: lindexCommand
void lindexCommand(client *c) {
    robj *o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk);
    if (o == NULL || checkType(c,o,OBJ_LIST)) return;
    long index;
    robj *value = NULL;

    if ((getLongFromObjectOrReply(c, c->argv[2], &index, NULL) != C_OK))
        return;

    if (o->encoding == OBJ_ENCODING_QUICKLIST) {
        quicklistEntry entry;
        if (quicklistIndex(o->ptr, index, &entry)) {
            if (entry.value) {
                value = createStringObject((char*)entry.value,entry.sz);
            } else {
                value = createStringObjectFromLongLong(entry.longval);
            }
            addReplyBulk(c,value);
            decrRefCount(value);
        } else {
            addReply(c,shared.nullbulk);
        }
    } else {
        serverPanic("Unknown list encoding");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x11eedd(%rip), %rax    # 0x178c40
movq 0x50(%rax), %rdx
callq 0x4a730
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x59d8e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0x59d93
jmp 0x59e65
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rsi
leaq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x49f20
cmpl $0x0, %eax
je 0x59dc2
jmp 0x59e65
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x9, %eax
jne 0x59e43
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x288a0
cmpl $0x0, %eax
je 0x59e2d
cmpq $0x0, -0x38(%rbp)
je 0x59e08
movq -0x38(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x486a0
movq %rax, -0x20(%rbp)
jmp 0x59e15
movq -0x30(%rbp), %rdi
callq 0x486f0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x43630
movq -0x20(%rbp), %rdi
callq 0x48f70
jmp 0x59e41
movq -0x8(%rbp), %rdi
leaq 0x11ee08(%rip), %rax    # 0x178c40
movq 0x50(%rax), %rsi
callq 0x42cc0
jmp 0x59e65
leaq 0xe339b(%rip), %rdi     # 0x13d1e5
leaq 0xe3b53(%rip), %rsi     # 0x13d9a4
movl $0x148, %edx            # imm = 0x148
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_list.c
// Function: lsetCommand
void lsetCommand(client *c) {
    robj *o = lookupKeyWriteOrReply(c,c->argv[1],shared.nokeyerr);
    if (o == NULL || checkType(c,o,OBJ_LIST)) return;
    long index;
    robj *value = c->argv[3];

    if ((getLongFromObjectOrReply(c, c->argv[2], &index, NULL) != C_OK))
        return;

    if (o->encoding == OBJ_ENCODING_QUICKLIST) {
        quicklist *ql = o->ptr;
        int replaced = quicklistReplaceAtIndex(ql, index,
                                               value->ptr, sdslen(value->ptr));
        if (!replaced) {
            addReply(c,shared.outofrangeerr);
        } else {
            addReply(c,shared.ok);
            signalModifiedKey(c->db,c->argv[1]);
            notifyKeyspaceEvent(NOTIFY_LIST,"lset",c->argv[1],c->db->id);
            server.dirty++;
        }
    } else {
        serverPanic("Unknown list encoding");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x11edad(%rip), %rax    # 0x178c40
movq 0x78(%rax), %rdx
callq 0x4a780
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x59ebe
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0x59ec3
jmp 0x5a012
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rsi
leaq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x49f20
cmpl $0x0, %eax
je 0x59efa
jmp 0x5a012
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x9, %eax
jne 0x59ff0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x58fd0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movl %eax, %ecx
callq 0x287a0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x59f79
movq -0x8(%rbp), %rdi
leaq 0x11ecd5(%rip), %rax    # 0x178c40
movq 0x90(%rax), %rsi
callq 0x42cc0
jmp 0x59fee
movq -0x8(%rbp), %rdi
leaq 0x11ecbc(%rip), %rax    # 0x178c40
movq 0x8(%rax), %rsi
callq 0x42cc0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x4aa60
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x30(%rax), %ecx
movl $0x10, %edi
leaq 0xdd5a5(%rip), %rsi     # 0x13756e
callq 0x9ce20
leaq 0x11e203(%rip), %rax    # 0x1781d8
movq 0x720(%rax), %rcx
addq $0x1, %rcx
leaq 0x11e1f1(%rip), %rax    # 0x1781d8
movq %rcx, 0x720(%rax)
jmp 0x5a012
leaq 0xe31ee(%rip), %rdi     # 0x13d1e5
leaq 0xe39a6(%rip), %rsi     # 0x13d9a4
movl $0x162, %edx            # imm = 0x162
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_list.c
// Function: popGenericCommand
void popGenericCommand(client *c, int where) {
    robj *o = lookupKeyWriteOrReply(c,c->argv[1],shared.nullbulk);
    if (o == NULL || checkType(c,o,OBJ_LIST)) return;

    robj *value = listTypePop(o,where);
    if (value == NULL) {
        addReply(c,shared.nullbulk);
    } else {
        char *event = (where == LIST_HEAD) ? "lpop" : "rpop";

        addReplyBulk(c,value);
        decrRefCount(value);
        notifyKeyspaceEvent(NOTIFY_LIST,event,c->argv[1],c->db->id);
        if (listTypeLength(o) == 0) {
            notifyKeyspaceEvent(NOTIFY_GENERIC,"del",
                                c->argv[1],c->db->id);
            dbDelete(c->db,c->argv[1]);
        }
        signalModifiedKey(c->db,c->argv[1]);
        server.dirty++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x11ebfa(%rip), %rax    # 0x178c40
movq 0x50(%rax), %rdx
callq 0x4a780
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5a071
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0x5a076
jmp 0x5a186
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x59090
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5a0a6
movq -0x8(%rbp), %rdi
leaq 0x11eba8(%rip), %rax    # 0x178c40
movq 0x50(%rax), %rsi
callq 0x42cc0
jmp 0x5a186
movl -0xc(%rbp), %edx
leaq 0xdd495(%rip), %rax     # 0x137545
leaq 0xdd4a6(%rip), %rcx     # 0x13755d
cmpl $0x0, %edx
cmoveq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x43630
movq -0x20(%rbp), %rdi
callq 0x48f70
movq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x30(%rax), %ecx
movl $0x10, %edi
callq 0x9ce20
movq -0x18(%rbp), %rdi
callq 0x59140
cmpq $0x0, %rax
jne 0x5a14d
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x30(%rax), %ecx
movl $0x4, %edi
leaq 0xdf369(%rip), %rsi     # 0x139498
callq 0x9ce20
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x4ac10
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x4aa60
leaq 0x11e06b(%rip), %rax    # 0x1781d8
movq 0x720(%rax), %rcx
addq $0x1, %rcx
leaq 0x11e059(%rip), %rax    # 0x1781d8
movq %rcx, 0x720(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_list.c
// Function: rpoplpushHandlePush
void rpoplpushHandlePush(client *c, robj *dstkey, robj *dstobj, robj *value) {
    /* Create the list if the key does not exist */
    if (!dstobj) {
        dstobj = createQuicklistObject();
        quicklistSetOptions(dstobj->ptr, server.list_max_ziplist_size,
                            server.list_compress_depth);
        dbAdd(c->db,dstkey,dstobj);
    }
    signalModifiedKey(c->db,dstkey);
    listTypePush(dstobj,value,LIST_HEAD);
    notifyKeyspaceEvent(NOTIFY_LIST,"lpush",dstkey,c->db->id);
    /* Always send the pushed value to the client. */
    addReplyBulk(c,value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5a8a4
callq 0x48b30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x11d961(%rip), %rax    # 0x1781d8
movl 0x970(%rax), %esi
leaq 0x11d954(%rip), %rax    # 0x1781d8
movl 0x974(%rax), %edx
callq 0x277c0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4a7d0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4aa60
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x58f20
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x30(%rax), %ecx
movl $0x10, %edi
leaq 0xdcc73(%rip), %rsi     # 0x137552
callq 0x9ce20
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x43630
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_list.c
// Function: blockForKeys
void blockForKeys(client *c, robj **keys, int numkeys, mstime_t timeout, robj *target) {
    dictEntry *de;
    list *l;
    int j;

    c->bpop.timeout = timeout;
    c->bpop.target = target;

    if (target != NULL) incrRefCount(target);

    for (j = 0; j < numkeys; j++) {
        /* If the key already exists in the dict ignore it. */
        if (dictAdd(c->bpop.keys,keys[j],NULL) != DICT_OK) continue;
        incrRefCount(keys[j]);

        /* And in the other "side", to map keys -> clients */
        de = dictFind(c->db->blocking_keys,keys[j]);
        if (de == NULL) {
            int retval;

            /* For every key we take a list of clients blocked for it */
            l = listCreate();
            retval = dictAdd(c->db->blocking_keys,keys[j],l);
            incrRefCount(keys[j]);
            serverAssertWithInfo(c,keys[j],retval == DICT_OK);
        } else {
            l = dictGetVal(de);
        }
        listAddNodeTail(l,c);
    }
    blockClient(c,BLOCKED_LIST);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x170(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x180(%rax)
cmpq $0x0, -0x28(%rbp)
je 0x5aaf9
movq -0x28(%rbp), %rdi
callq 0x487b0
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5ac11
movq -0x8(%rbp), %rax
movq 0x178(%rax), %rdi
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2d8c0
cmpl $0x0, %eax
je 0x5ab36
jmp 0x5ac03
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x487b0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x2dcb0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x5abea
callq 0x26e20
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x38(%rbp), %rdx
callq 0x2d8c0
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x487b0
cmpl $0x0, -0x40(%rbp)
jne 0x5abb5
jmp 0x5abe8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xe0cc0(%rip), %rdx     # 0x13b88c
leaq 0xe2dd1(%rip), %rcx     # 0x13d9a4
movl $0x280, %r8d            # imm = 0x280
callq 0x78360
movl $0x1, %edi
callq 0x263c0
jmp 0x5abf6
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x27000
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x5ab00
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x9d770
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)