LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/rdb.c
// Function: rdbLoadIntegerObject
robj *rdbLoadIntegerObject(rio *rdb, int enctype, int encode) {
    unsigned char enc[4];
    long long val;

    // 整数编码
    if (enctype == REDIS_RDB_ENC_INT8) {
        if (rioRead(rdb,enc,1) == 0) return NULL;
        val = (signed char)enc[0];
    } else if (enctype == REDIS_RDB_ENC_INT16) {
        uint16_t v;
        if (rioRead(rdb,enc,2) == 0) return NULL;
        v = enc[0]|(enc[1]<<8);
        val = (int16_t)v;
    } else if (enctype == REDIS_RDB_ENC_INT32) {
        uint32_t v;
        if (rioRead(rdb,enc,4) == 0) return NULL;
        v = enc[0]|(enc[1]<<8)|(enc[2]<<16)|(enc[3]<<24);
        val = (int32_t)v;
    } else {
        val = 0; /* anti-warning */
        redisPanic("Unknown RDB integer encoding type");
    }

    
    if (encode)
        // 整数编码的字符串
        return createStringObjectFromLongLong(val);
    else
        // 未编码
        return createObject(REDIS_STRING,sdsfromlonglong(val));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x434cb
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
movl $0x1, %edx
callq 0x42fc0
cmpq $0x0, %rax
jne 0x434bd
movq $0x0, -0x8(%rbp)
jmp 0x435c6
movsbq -0x1c(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x4359a
cmpl $0x1, -0x14(%rbp)
jne 0x43515
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
movl $0x2, %edx
callq 0x42fc0
cmpq $0x0, %rax
jne 0x434f6
movq $0x0, -0x8(%rbp)
jmp 0x435c6
movzbl -0x1c(%rbp), %eax
movzbl -0x1b(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movw %ax, -0x2a(%rbp)
movswq -0x2a(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x43598
cmpl $0x2, -0x14(%rbp)
jne 0x4356c
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
movl $0x4, %edx
callq 0x42fc0
cmpq $0x0, %rax
jne 0x43540
movq $0x0, -0x8(%rbp)
jmp 0x435c6
movzbl -0x1c(%rbp), %eax
movzbl -0x1b(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzbl -0x1a(%rbp), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movzbl -0x19(%rbp), %ecx
shll $0x18, %ecx
orl %ecx, %eax
movl %eax, -0x30(%rbp)
movslq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x43596
movq $0x0, -0x28(%rbp)
leaq 0x9f565(%rip), %rdi     # 0xe2ae0
leaq 0x9f582(%rip), %rsi     # 0xe2b04
movl $0x101, %edx            # imm = 0x101
callq 0x63d40
movl $0x1, %edi
callq 0x1f3b0
jmp 0x43598
jmp 0x4359a
cmpl $0x0, -0x18(%rbp)
je 0x435af
movq -0x28(%rbp), %rdi
callq 0x3a330
movq %rax, -0x8(%rbp)
jmp 0x435c6
movq -0x28(%rbp), %rdi
callq 0x2c910
movq %rax, %rsi
xorl %edi, %edi
callq 0x3a0d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/rdb.c
// Function: rdbSaveLzfStringObject
int rdbSaveLzfStringObject(rio *rdb, unsigned char *s, size_t len) {
    size_t comprlen, outlen;
    unsigned char byte;
    int n, nwritten = 0;
    void *out;

    /* We require at least four bytes compression for this to be worth it */
    // 压缩字符串
    if (len <= 4) return 0;
    outlen = len-4;
    if ((out = zmalloc(outlen+1)) == NULL) return 0;
    comprlen = lzf_compress(s, len, out, outlen);
    if (comprlen == 0) {
        zfree(out);
        return 0;
    }

    /* Data compressed! Let's save it on disk 
     *
     * 保存压缩后的字符串到 rdb 。
     */

    // 写入类型，说明这是一个 LZF 压缩字符串
    byte = (REDIS_RDB_ENCVAL<<6)|REDIS_RDB_ENC_LZF;
    if ((n = rdbWriteRaw(rdb,&byte,1)) == -1) goto writeerr;
    nwritten += n;

    // 写入字符串压缩后的长度
    if ((n = rdbSaveLen(rdb,comprlen)) == -1) goto writeerr;
    nwritten += n;
    
    // 写入字符串未压缩时的长度
    if ((n = rdbSaveLen(rdb,len)) == -1) goto writeerr;
    nwritten += n;

    // 写入压缩后的字符串
    if ((n = rdbWriteRaw(rdb,out,comprlen)) == -1) goto writeerr;
    nwritten += n;

    zfree(out);

    return nwritten;

writeerr:
    zfree(out);
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x3c(%rbp)
cmpq $0x4, -0x20(%rbp)
ja 0x4369e
movl $0x0, -0x4(%rbp)
jmp 0x437bd
movq -0x20(%rbp), %rax
subq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x1, %rdi
callq 0x2e130
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
jne 0x436cd
movl $0x0, -0x4(%rbp)
jmp 0x437bd
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
movq -0x48(%rbp), %rdx
movq -0x30(%rbp), %rax
movl %eax, %ecx
callq 0x2e8a0
movl %eax, %eax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x43708
movq -0x48(%rbp), %rdi
callq 0x2e3a0
movl $0x0, -0x4(%rbp)
jmp 0x437bd
movb $-0x3d, -0x31(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x31(%rbp), %rsi
movl $0x1, %edx
callq 0x42f30
movl %eax, -0x38(%rbp)
cmpl $-0x1, %eax
jne 0x4372b
jmp 0x437ad
movl -0x38(%rbp), %eax
addl -0x3c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movl %eax, %esi
callq 0x43150
movl %eax, -0x38(%rbp)
cmpl $-0x1, %eax
jne 0x4374d
jmp 0x437ad
movl -0x38(%rbp), %eax
addl -0x3c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
callq 0x43150
movl %eax, -0x38(%rbp)
cmpl $-0x1, %eax
jne 0x4376f
jmp 0x437ad
movl -0x38(%rbp), %eax
addl -0x3c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x42f30
movl %eax, -0x38(%rbp)
cmpl $-0x1, %eax
jne 0x43793
jmp 0x437ad
movl -0x38(%rbp), %eax
addl -0x3c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x48(%rbp), %rdi
callq 0x2e3a0
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x437bd
movq -0x48(%rbp), %rdi
callq 0x2e3a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/rdb.c
// Function: rdbLoadLzfStringObject
robj *rdbLoadLzfStringObject(rio *rdb) {
    unsigned int len, clen;
    unsigned char *c = NULL;
    sds val = NULL;

    // 读入压缩后的缓存长度
    if ((clen = rdbLoadLen(rdb,NULL)) == REDIS_RDB_LENERR) return NULL;
    // 读入字符串未压缩前的长度
    if ((len = rdbLoadLen(rdb,NULL)) == REDIS_RDB_LENERR) return NULL;
    // 压缩缓存空间
    if ((c = zmalloc(clen)) == NULL) goto err;
    // 字符串空间
    if ((val = sdsnewlen(NULL,len)) == NULL) goto err;

    // 读入压缩后的缓存
    if (rioRead(rdb,c,clen) == 0) goto err;

    // 解压缓存，得出字符串
    if (lzf_decompress(c,clen,val,len) == 0) goto err;
    zfree(c);

    // 创建字符串对象
    return createObject(REDIS_STRING,val);
err:
    zfree(c);
    sdsfree(val);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x43260
movl %eax, -0x18(%rbp)
cmpl $-0x1, %eax
jne 0x4380e
movq $0x0, -0x8(%rbp)
jmp 0x438c8
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x43260
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
jne 0x43830
movq $0x0, -0x8(%rbp)
jmp 0x438c8
movl -0x18(%rbp), %eax
movl %eax, %edi
callq 0x2e130
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x43846
jmp 0x438ae
movl -0x14(%rbp), %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edi
callq 0x2c000
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x43860
jmp 0x438ae
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x18(%rbp), %eax
movl %eax, %edx
callq 0x42fc0
cmpq $0x0, %rax
jne 0x4387a
jmp 0x438ae
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
movq -0x28(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq 0x2f3c0
cmpl $0x0, %eax
jne 0x43894
jmp 0x438ae
movq -0x20(%rbp), %rdi
callq 0x2e3a0
movq -0x28(%rbp), %rsi
xorl %edi, %edi
callq 0x3a0d0
movq %rax, -0x8(%rbp)
jmp 0x438c8
movq -0x20(%rbp), %rdi
callq 0x2e3a0
movq -0x28(%rbp), %rdi
callq 0x2c160
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/rdb.c
// Function: rdbSaveRawString
int rdbSaveRawString(rio *rdb, unsigned char *s, size_t len) {
    int enclen;
    int n, nwritten = 0;

    /* Try integer encoding 
     *
     * 尝试进行整数值编码
     */
    if (len <= 11) {
        unsigned char buf[5];
        if ((enclen = rdbTryIntegerEncoding((char*)s,len,buf)) > 0) {
            // 整数转换成功，写入
            if (rdbWriteRaw(rdb,buf,enclen) == -1) return -1;
            // 返回字节数
            return enclen;
        }
    }

    /* Try LZF compression - under 20 bytes it's unable to compress even
     * aaaaaaaaaaaaaaaaaa so skip it 
     *
     * 如果字符串长度大于 20 ，并且服务器开启了 LZF 压缩，
     * 那么在保存字符串到数据库之前，先对字符串进行 LZF 压缩。
     */
    if (server.rdb_compression && len > 20) {

        // 尝试压缩
        n = rdbSaveLzfStringObject(rdb,s,len);

        if (n == -1) return -1;
        if (n > 0) return n;
        /* Return value of 0 means data can't be compressed, save the old way */
    }

    // 执行到这里，说明值 s 既不能编码为整数
    // 也不能被压缩
    // 那么直接将它写入到 rdb 中
    /* Store verbatim */

    // 写入长度
    if ((n = rdbSaveLen(rdb,len)) == -1) return -1;
    nwritten += n;

    // 写入内容
    if (len > 0) {
        if (rdbWriteRaw(rdb,s,len) == -1) return -1;
        nwritten += len;
    }

    return nwritten;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0xb, -0x20(%rbp)
ja 0x4394a
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x31(%rbp), %rdx
callq 0x435d0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jle 0x43948
movq -0x10(%rbp), %rdi
leaq -0x31(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x42f30
cmpl $-0x1, %eax
jne 0x4393d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x439f7
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x439f7
jmp 0x4394a
leaq 0xcffa7(%rip), %rax     # 0x1138f8
cmpl $0x0, 0x590(%rax)
je 0x43994
cmpq $0x14, -0x20(%rbp)
jbe 0x43994
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x43670
movl %eax, -0x28(%rbp)
cmpl $-0x1, -0x28(%rbp)
jne 0x43984
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x439f7
cmpl $0x0, -0x28(%rbp)
jle 0x43992
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x439f7
jmp 0x43994
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
callq 0x43150
movl %eax, -0x28(%rbp)
cmpl $-0x1, %eax
jne 0x439b4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x439f7
movl -0x28(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x439f1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x42f30
cmpl $-0x1, %eax
jne 0x439e3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x439f7
movq -0x20(%rbp), %rcx
movslq -0x2c(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/rdb.c
// Function: rdbSaveLongLongAsStringObject
int rdbSaveLongLongAsStringObject(rio *rdb, long long value) {
    unsigned char buf[32];
    int n, nwritten = 0;

    // 尝试以节省空间的方式编码整数值 value 
    int enclen = rdbEncodeInteger(value,buf);

    // 编码成功，直接写入编码后的缓存
    // 比如，值 1 可以编码为 11 00 0001
    if (enclen > 0) {
        return rdbWriteRaw(rdb,buf,enclen);

    // 编码失败，将整数值转换成对应的字符串来保存
    // 比如，值 999999999 要编码成 "999999999" ，
    // 因为这个值没办法用节省空间的方式编码
    } else {
        /* Encode as string */
        // 转换成字符串表示
        enclen = ll2string((char*)buf,32,value);
        redisAssert(enclen < 32);
        // 写入字符串长度
        if ((n = rdbSaveLen(rdb,enclen)) == -1) return -1;
        nwritten += n;
        // 写入字符串
        if ((n = rdbWriteRaw(rdb,buf,enclen)) == -1) return -1;
        nwritten += n;
    }

    // 返回长度
    return nwritten;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x48(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x43360
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
jle 0x43a46
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movslq -0x4c(%rbp), %rdx
callq 0x42f30
movl %eax, -0x4(%rbp)
jmp 0x43adc
leaq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x20, %esi
callq 0x39660
movl %eax, -0x4c(%rbp)
cmpl $0x20, -0x4c(%rbp)
jge 0x43a63
jmp 0x43a85
leaq 0x9f0a0(%rip), %rdi     # 0xe2b0a
leaq 0x9f093(%rip), %rsi     # 0xe2b04
movl $0x1e0, %edx            # imm = 0x1E0
callq 0x63ca0
movl $0x1, %edi
callq 0x1f3b0
movq -0x10(%rbp), %rdi
movl -0x4c(%rbp), %esi
callq 0x43150
movl %eax, -0x44(%rbp)
cmpl $-0x1, %eax
jne 0x43aa2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x43adc
movl -0x44(%rbp), %eax
addl -0x48(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movslq -0x4c(%rbp), %rdx
callq 0x42f30
movl %eax, -0x44(%rbp)
cmpl $-0x1, %eax
jne 0x43acd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x43adc
movl -0x44(%rbp), %eax
addl -0x48(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/rdb.c
// Function: rdbSaveStringObject
int rdbSaveStringObject(rio *rdb, robj *obj) {

    /* Avoid to decode the object, then encode it again, if the
     * object is already integer encoded. */
    // 尝试对 INT 编码的字符串进行特殊编码
    if (obj->encoding == REDIS_ENCODING_INT) {
        return rdbSaveLongLongAsStringObject(rdb,(long)obj->ptr);

    // 保存 STRING 编码的字符串
    } else {
        redisAssertWithInfo(NULL,obj,sdsEncodedObject(obj));
        return rdbSaveRawString(rdb,obj->ptr,sdslen(obj->ptr));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x1, %eax
jne 0x43b2a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x43a00
movl %eax, -0x4(%rbp)
jmp 0x43bad
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x43b4c
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x43b4e
jmp 0x43b79
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
leaq 0x9efb9(%rip), %rdx     # 0xe2b16
leaq 0x9efa0(%rip), %rcx     # 0xe2b04
movl $0x1ff, %r8d            # imm = 0x1FF
callq 0x648b0
movl $0x1, %edi
callq 0x1f3b0
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x42ec0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x438e0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/rdb.c
// Function: rdbGenericLoadStringObject
robj *rdbGenericLoadStringObject(rio *rdb, int encode) {
    int isencoded;
    uint32_t len;
    sds val;

    // 长度
    len = rdbLoadLen(rdb,&isencoded);

    // 这是一个特殊编码字符串
    if (isencoded) {

        switch(len) {

        // 整数编码
        case REDIS_RDB_ENC_INT8:
        case REDIS_RDB_ENC_INT16:
        case REDIS_RDB_ENC_INT32:
            return rdbLoadIntegerObject(rdb,len,encode);

        // LZF 压缩
        case REDIS_RDB_ENC_LZF:
            return rdbLoadLzfStringObject(rdb);

        default:
            redisPanic("Unknown RDB encoding type");
        }
    }

    if (len == REDIS_RDB_LENERR) return NULL;

    // 执行到这里，说明这个字符串即没有被压缩，也不是整数
    // 那么直接从 rdb 中读入它
    val = sdsnewlen(NULL,len);
    if (len && rioRead(rdb,val,len) == 0) {
        sdsfree(val);
        return NULL;
    }

    return createObject(REDIS_STRING,val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x43260
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x43c48
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $0x3, %eax
jb 0x43bfc
jmp 0x43bf2
movl -0x2c(%rbp), %eax
subl $0x3, %eax
je 0x43c14
jmp 0x43c26
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x43480
movq %rax, -0x8(%rbp)
jmp 0x43caa
movq -0x10(%rbp), %rdi
callq 0x437d0
movq %rax, -0x8(%rbp)
jmp 0x43caa
leaq 0x9eeff(%rip), %rdi     # 0xe2b2c
leaq 0x9eed0(%rip), %rsi     # 0xe2b04
movl $0x221, %edx            # imm = 0x221
callq 0x63d40
movl $0x1, %edi
callq 0x1f3b0
cmpl $-0x1, -0x1c(%rbp)
jne 0x43c58
movq $0x0, -0x8(%rbp)
jmp 0x43caa
movl -0x1c(%rbp), %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edi
callq 0x2c000
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x43c9b
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x42fc0
cmpq $0x0, %rax
jne 0x43c9b
movq -0x28(%rbp), %rdi
callq 0x2c160
movq $0x0, -0x8(%rbp)
jmp 0x43caa
movq -0x28(%rbp), %rsi
xorl %edi, %edi
callq 0x3a0d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/rdb.c
// Function: startLoading
void startLoading(FILE *fp) {
    struct stat sb;

    /* Load the DB */

    // 正在载入
    server.loading = 1;

    // 开始进行载入的时间
    server.loading_start_time = time(NULL);

    // 文件的大小
    if (fstat(fileno(fp), &sb) == -1) {
        server.loading_total_bytes = 1; /* just to avoid division by zero */
    } else {
        server.loading_total_bytes = sb.st_size;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xcdb62(%rip), %rax     # 0x1138f8
movl $0x1, 0x2f0(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x1fc70
movq %rax, %rcx
leaq 0xcdb45(%rip), %rax     # 0x1138f8
movq %rcx, 0x308(%rax)
movq -0x8(%rbp), %rdi
callq 0x1f070
movl %eax, %edi
leaq -0x98(%rbp), %rsi
callq 0x1f690
cmpl $-0x1, %eax
jne 0x45dea
leaq 0xcdb1b(%rip), %rax     # 0x1138f8
movq $0x1, 0x2f8(%rax)
jmp 0x45dfc
movq -0x68(%rbp), %rcx
leaq 0xcdb03(%rip), %rax     # 0x1138f8
movq %rcx, 0x2f8(%rax)
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/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 == REDIS_REPL_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 0xcda4d(%rip), %rax     # 0x1138f8
cmpl $0x0, 0x594(%rax)
je 0x45ec5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x75e10
leaq 0xcda2c(%rip), %rax     # 0x1138f8
cmpq $0x0, 0x310(%rax)
je 0x45f5b
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
addq -0x18(%rbp), %rax
leaq 0xcda0b(%rip), %rcx     # 0x1138f8
xorl %edx, %edx
divq 0x310(%rcx)
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
leaq 0xcd9ef(%rip), %rcx     # 0x1138f8
xorl %edx, %edx
divq 0x310(%rcx)
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jbe 0x45f5b
callq 0x26190
leaq 0xcd9ce(%rip), %rax     # 0x1138f8
cmpq $0x0, 0x650(%rax)
je 0x45f49
leaq 0xcd9bd(%rip), %rax     # 0x1138f8
cmpl $0x4, 0x674(%rax)
jne 0x45f49
callq 0x40980
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x45e10
callq 0x38ec0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/rdb.c
// Function: backgroundSaveDoneHandler
void backgroundSaveDoneHandler(int exitcode, int bysignal) {

    // BGSAVE 成功
    if (!bysignal && exitcode == 0) {
        redisLog(REDIS_NOTICE,
            "Background saving terminated with success");
        server.dirty = server.dirty - server.dirty_before_bgsave;
        server.lastsave = time(NULL);
        server.lastbgsave_status = REDIS_OK;

    // BGSAVE 出错
    } else if (!bysignal && exitcode != 0) {
        redisLog(REDIS_WARNING, "Background saving error");
        server.lastbgsave_status = REDIS_ERR;

    // BGSAVE 被中断
    } else {
        redisLog(REDIS_WARNING,
            "Background saving terminated by signal %d", bysignal);
        // 移除临时文件
        rdbRemoveTempFile(server.rdb_child_pid);
        /* SIGUSR1 is whitelisted, so we have a way to kill a child without
         * tirggering an error conditon. */
        if (bysignal != SIGUSR1)
            server.lastbgsave_status = REDIS_ERR;
    }

    // 更新服务器状态
    server.rdb_child_pid = -1;
    server.rdb_save_time_last = time(NULL)-server.rdb_save_time_start;
    server.rdb_save_time_start = -1;

    /* Possibly there are slaves waiting for a BGSAVE in order to be served
     * (the first stage of SYNC is a bulk transfer of dump.rdb) */
    // 处理正在等待 BGSAVE 完成的那些 slave
    updateSlavesWaitingBgsave(exitcode == 0 ? REDIS_OK : REDIS_ERR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x46454
cmpl $0x0, -0x4(%rbp)
jne 0x46454
movl $0x2, %edi
leaq 0x9ca88(%rip), %rsi     # 0xe2e7e
movb $0x0, %al
callq 0x24fb0
leaq 0xcd4f4(%rip), %rax     # 0x1138f8
movq 0x560(%rax), %rcx
leaq 0xcd4e6(%rip), %rax     # 0x1138f8
subq 0x568(%rax), %rcx
leaq 0xcd4d8(%rip), %rax     # 0x1138f8
movq %rcx, 0x560(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x1fc70
movq %rax, %rcx
leaq 0xcd4be(%rip), %rax     # 0x1138f8
movq %rcx, 0x598(%rax)
leaq 0xcd4b0(%rip), %rax     # 0x1138f8
movl $0x0, 0x5b8(%rax)
jmp 0x464c9
cmpl $0x0, -0x8(%rbp)
jne 0x46486
cmpl $0x0, -0x4(%rbp)
je 0x46486
movl $0x3, %edi
leaq 0x9ca3c(%rip), %rsi     # 0xe2ea8
movb $0x0, %al
callq 0x24fb0
leaq 0xcd47e(%rip), %rax     # 0x1138f8
movl $0xffffffff, 0x5b8(%rax) # imm = 0xFFFFFFFF
jmp 0x464c7
movl -0x8(%rbp), %edx
movl $0x3, %edi
leaq 0x9ca2b(%rip), %rsi     # 0xe2ec0
movb $0x0, %al
callq 0x24fb0
leaq 0xcd455(%rip), %rax     # 0x1138f8
movl 0x570(%rax), %edi
callq 0x45090
cmpl $0xa, -0x8(%rbp)
je 0x464c5
leaq 0xcd43d(%rip), %rax     # 0x1138f8
movl $0xffffffff, 0x5b8(%rax) # imm = 0xFFFFFFFF
jmp 0x464c7
jmp 0x464c9
leaq 0xcd428(%rip), %rax     # 0x1138f8
movl $0xffffffff, 0x570(%rax) # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edi
callq 0x1fc70
movq %rax, %rcx
leaq 0xcd40b(%rip), %rax     # 0x1138f8
subq 0x5b0(%rax), %rcx
leaq 0xcd3fd(%rip), %rax     # 0x1138f8
movq %rcx, 0x5a8(%rax)
leaq 0xcd3ef(%rip), %rax     # 0x1138f8
movq $-0x1, 0x5b0(%rax)
movl -0x4(%rbp), %ecx
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %eax, %eax
cmpl $0x0, %ecx
cmovel %eax, %edi
callq 0x40640
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/rdb.c
// Function: saveCommand
void saveCommand(redisClient *c) {

    // BGSAVE 已经在执行中，不能再执行 SAVE
    // 否则将产生竞争条件
    if (server.rdb_child_pid != -1) {
        addReplyError(c,"Background save already in progress");
        return;
    }

    // 执行 
    if (rdbSave(server.rdb_filename) == REDIS_OK) {
        addReply(c,shared.ok);
    } else {
        addReply(c,shared.err);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xcd3b5(%rip), %rax     # 0x1138f8
cmpl $-0x1, 0x570(%rax)
je 0x4655e
movq -0x8(%rbp), %rdi
leaq 0x9c993(%rip), %rsi     # 0xe2eea
callq 0x35d40
jmp 0x465a0
leaq 0xcd393(%rip), %rax     # 0x1138f8
movq 0x588(%rax), %rdi
callq 0x449a0
cmpl $0x0, %eax
jne 0x4658c
movq -0x8(%rbp), %rdi
leaq 0xcdbcf(%rip), %rax     # 0x114150
movq 0x8(%rax), %rsi
callq 0x35a70
jmp 0x465a0
movq -0x8(%rbp), %rdi
leaq 0xcdbb9(%rip), %rax     # 0x114150
movq 0x10(%rax), %rsi
callq 0x35a70
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/rdb.c
// Function: bgsaveCommand
void bgsaveCommand(redisClient *c) {

    // 不能重复执行 BGSAVE
    if (server.rdb_child_pid != -1) {
        addReplyError(c,"Background save already in progress");

    // 不能在 BGREWRITEAOF 正在运行时执行
    } else if (server.aof_child_pid != -1) {
        addReplyError(c,"Can't BGSAVE while AOF log rewriting is in progress");

    // 执行 BGSAVE
    } else if (rdbSaveBackground(server.rdb_filename) == REDIS_OK) {
        addReplyStatus(c,"Background saving started");

    } else {
        addReply(c,shared.err);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xcd335(%rip), %rax     # 0x1138f8
cmpl $-0x1, 0x570(%rax)
je 0x465de
movq -0x8(%rbp), %rdi
leaq 0x9c913(%rip), %rsi     # 0xe2eea
callq 0x35d40
jmp 0x46642
leaq 0xcd313(%rip), %rax     # 0x1138f8
cmpl $-0x1, 0x504(%rax)
je 0x46600
movq -0x8(%rbp), %rdi
leaq 0x9c915(%rip), %rsi     # 0xe2f0e
callq 0x35d40
jmp 0x46640
leaq 0xcd2f1(%rip), %rax     # 0x1138f8
movq 0x588(%rax), %rdi
callq 0x44ef0
cmpl $0x0, %eax
jne 0x4662a
movq -0x8(%rbp), %rdi
leaq 0x9c91f(%rip), %rsi     # 0xe2f42
callq 0x35f30
jmp 0x4663e
movq -0x8(%rbp), %rdi
leaq 0xcdb1b(%rip), %rax     # 0x114150
movq 0x10(%rax), %rsi
callq 0x35a70
jmp 0x46640
jmp 0x46642
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/t_string.c
// Function: getGenericCommand
int getGenericCommand(redisClient *c) {
    robj *o;

    // 尝试从数据库中取出键 c->argv[1] 对应的值对象
    // 如果键不存在时，向客户端发送回复信息，并返回 NULL
    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.nullbulk)) == NULL)
        return REDIS_OK;

    // 值对象存在，检查它的类型
    if (o->type != REDIS_STRING) {
        // 类型错误
        addReply(c,shared.wrongtypeerr);
        return REDIS_ERR;
    } else {
        // 类型正确，向客户端返回对象的值
        addReplyBulk(c,o);
        return REDIS_OK;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0xcd4ad(%rip), %rax     # 0x114150
movq 0x50(%rax), %rdx
callq 0x3c0c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x46cbf
movl $0x0, -0x4(%rbp)
jmp 0x46cfe
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x46cea
movq -0x10(%rbp), %rdi
leaq 0xcd478(%rip), %rax     # 0x114150
movq 0x70(%rax), %rsi
callq 0x35a70
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x46cfe
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x36620
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/t_string.c
// Function: getsetCommand
void getsetCommand(redisClient *c) {

    // 取出并返回键的值对象
    if (getGenericCommand(c) == REDIS_ERR) return;

    // 编码键的新值 c->argv[2]
    c->argv[2] = tryObjectEncoding(c->argv[2]);

    // 将数据库中关联键 c->argv[1] 和新值对象 c->argv[2]
    setKey(c->db,c->argv[1],c->argv[2]);

    // 发送事件通知
    notifyKeyspaceEvent(REDIS_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 0x46c80
cmpl $-0x1, %eax
jne 0x46d4f
jmp 0x46ddc
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x3acc0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rdx
callq 0x3c2d0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x30(%rax), %ecx
movl $0x8, %edi
leaq 0x9879f(%rip), %rsi     # 0xdf556
callq 0x814a0
leaq 0xccb35(%rip), %rax     # 0x1138f8
movq 0x560(%rax), %rcx
addq $0x1, %rcx
leaq 0xccb23(%rip), %rax     # 0x1138f8
movq %rcx, 0x560(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/t_string.c
// Function: checkStringLength
static int checkStringLength(redisClient *c, long long size) {

    if (size > 512*1024*1024) {
        addReplyError(c,"string exceeds maximum allowed size (512MB)");
        return REDIS_ERR;
    }

    return REDIS_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 0x470e3
movq -0x10(%rbp), %rdi
leaq 0x9bf30(%rip), %rsi     # 0xe3005
callq 0x35d40
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x470ea
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/nilyang[P]redis-tdd-annotation/src/t_string.c
// Function: mgetCommand
void mgetCommand(redisClient *c) {
    int j;

    addReplyMultiBulkLen(c,c->argc-1);
    // 查找并返回所有输入键的值
    for (j = 1; j < c->argc; j++) {
        // 查找键 c->argc[j] 的值
        robj *o = lookupKeyRead(c->db,c->argv[j]);
        if (o == NULL) {
            // 值不存在，向客户端发送空回复
            addReply(c,shared.nullbulk);
        } else {
            if (o->type != REDIS_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 0x30(%rax), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x364f0
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jge 0x4734a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x3bed0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x47307
movq -0x8(%rbp), %rdi
leaq 0xcce54(%rip), %rax     # 0x114150
movq 0x50(%rax), %rsi
callq 0x35a70
jmp 0x4733a
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x4732b
movq -0x8(%rbp), %rdi
leaq 0xcce30(%rip), %rax     # 0x114150
movq 0x50(%rax), %rsi
callq 0x35a70
jmp 0x47338
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x36620
jmp 0x4733a
jmp 0x4733c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x472b9
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/t_string.c
// Function: strlenCommand
void strlenCommand(redisClient *c) {
    robj *o;

    // 取出值对象，并进行类型检查
    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL ||
        checkType(c,o,REDIS_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 0x38(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0xcc51d(%rip), %rax     # 0x114150
movq 0x20(%rax), %rdx
callq 0x3c0c0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x47c5a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3abb0
cmpl $0x0, %eax
je 0x47c5c
jmp 0x47c79
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b2c0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x36480
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/t_list.c
// Function: listTypeTryConversion
void listTypeTryConversion(robj *subject, robj *value) {

    // 确保 subject 为 ZIPLIST 编码
    if (subject->encoding != REDIS_ENCODING_ZIPLIST) return;

    if (sdsEncodedObject(value) &&
        // 看字符串是否过长
        sdslen(value->ptr) > server.list_max_ziplist_value)
            // 将编码转换为双端链表
            listTypeConvert(subject,REDIS_ENCODING_LINKEDLIST);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x5, %eax
je 0x47ce3
jmp 0x47d30
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x47d05
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x47d30
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x47c80
leaq 0xcbbdf(%rip), %rcx     # 0x1138f8
cmpq 0x770(%rcx), %rax
jbe 0x47d30
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x47d40
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/t_list.c
// Function: listTypeConvert
void listTypeConvert(robj *subject, int enc) {

    listTypeIterator *li;

    listTypeEntry entry;

    redisAssertWithInfo(NULL,subject,subject->type == REDIS_LIST);

    // 转换成双端链表
    if (enc == REDIS_ENCODING_LINKEDLIST) {

        list *l = listCreate();

        listSetFreeMethod(l,decrRefCountVoid);

        /* listTypeGet returns a robj with incremented refcount */
        // 遍历 ziplist ，并将里面的值全部添加到双端链表中
        li = listTypeInitIterator(subject,0,REDIS_TAIL);
        while (listTypeNext(li,&entry)) listAddNodeTail(l,listTypeGet(&entry));
        listTypeReleaseIterator(li);

        // 更新编码
        subject->encoding = REDIS_ENCODING_LINKEDLIST;

        // 释放原来的 ziplist
        zfree(subject->ptr);

        // 更新对象值指针
        subject->ptr = l;

    } else {
        redisPanic("Unsupported list conversion");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x1, %eax
jne 0x47d5f
jmp 0x47d8a
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
leaq 0x9b32a(%rip), %rdx     # 0xe3098
leaq 0x9b2bc(%rip), %rcx     # 0xe3031
movl $0x1c8, %r8d            # imm = 0x1C8
callq 0x648b0
movl $0x1, %edi
callq 0x1f3b0
cmpl $0x4, -0xc(%rbp)
jne 0x47e28
callq 0x1fdb0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
leaq -0xd738(%rip), %rcx     # 0x3a670
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x48180
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x48280
cmpl $0x0, %eax
je 0x47df3
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x48410
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x1ff90
jmp 0x47dc2
movq -0x18(%rbp), %rdi
callq 0x48260
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff0f, %ecx       # imm = 0xFFFFFF0F
orl $0x40, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2e3a0
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x47e4a
leaq 0x9b285(%rip), %rdi     # 0xe30b4
leaq 0x9b1fb(%rip), %rsi     # 0xe3031
movl $0x1e1, %edx            # imm = 0x1E1
callq 0x63d40
movl $0x1, %edi
callq 0x1f3b0
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/t_list.c
// Function: listTypePush
void listTypePush(robj *subject, robj *value, int where) {

    /* Check if we need to convert the ziplist */
    // 是否需要转换编码？
    listTypeTryConversion(subject,value);

    if (subject->encoding == REDIS_ENCODING_ZIPLIST &&
        ziplistLen(subject->ptr) >= server.list_max_ziplist_entries)
            listTypeConvert(subject,REDIS_ENCODING_LINKEDLIST);

    // ZIPLIST
    if (subject->encoding == REDIS_ENCODING_ZIPLIST) {
        int pos = (where == REDIS_HEAD) ? ZIPLIST_HEAD : ZIPLIST_TAIL;
        // 取出对象的值，因为 ZIPLIST 只能保存字符串或整数
        value = getDecodedObject(value);
        subject->ptr = ziplistPush(subject->ptr,value->ptr,sdslen(value->ptr),pos);
        decrRefCount(value);

    // 双端链表
    } else if (subject->encoding == REDIS_ENCODING_LINKEDLIST) {
        if (where == REDIS_HEAD) {
            listAddNodeHead(subject->ptr,value);
        } else {
            listAddNodeTail(subject->ptr,value);
        }
        incrRefCount(value);

    // 未知编码
    } else {
        redisPanic("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), %rdi
movq -0x10(%rbp), %rsi
callq 0x47cc0
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x5, %eax
jne 0x47eae
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x33f70
movl %eax, %eax
leaq 0xcba61(%rip), %rcx     # 0x1138f8
cmpq 0x768(%rcx), %rax
jb 0x47eae
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x47d40
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x5, %eax
jne 0x47f2c
movl -0x14(%rbp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3aef0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x47c80
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl %eax, %edx
movl -0x18(%rbp), %ecx
callq 0x32a60
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x3aaa0
jmp 0x47f96
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x4, %eax
jne 0x47f72
cmpl $0x0, -0x14(%rbp)
jne 0x47f56
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1fec0
jmp 0x47f67
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ff90
movq -0x10(%rbp), %rdi
callq 0x3a3f0
jmp 0x47f94
leaq 0x9abd3(%rip), %rdi     # 0xe2b4c
leaq 0x9b0b1(%rip), %rsi     # 0xe3031
movl $0x69, %edx
callq 0x63d40
movl $0x1, %edi
callq 0x1f3b0
jmp 0x47f96
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/t_list.c
// Function: listTypePop
robj *listTypePop(robj *subject, int where) {

    robj *value = NULL;

    // ZIPLIST
    if (subject->encoding == REDIS_ENCODING_ZIPLIST) {
        unsigned char *p;
        unsigned char *vstr;
        unsigned int vlen;
        long long vlong;

        // 决定弹出元素的位置
        int pos = (where == REDIS_HEAD) ? 0 : -1;

        p = ziplistIndex(subject->ptr,pos);
        if (ziplistGet(p,&vstr,&vlen,&vlong)) {
            // 为被弹出元素创建对象
            if (vstr) {
                value = createStringObject((char*)vstr,vlen);
            } else {
                value = createStringObjectFromLongLong(vlong);
            }
            /* We only need to delete an element when it exists */
            // 从 ziplist 中删除被弹出元素
            subject->ptr = ziplistDelete(subject->ptr,&p);
        }

    // 双端链表
    } else if (subject->encoding == REDIS_ENCODING_LINKEDLIST) {

        list *list = subject->ptr;

        listNode *ln;

        if (where == REDIS_HEAD) {
            ln = listFirst(list);
        } else {
            ln = listLast(list);
        }

        // 删除被弹出节点
        if (ln != NULL) {
            value = listNodeValue(ln);
            incrRefCount(value);
            listDelNode(list,ln);
        }

    // 未知编码
    } else {
        redisPanic("Unknown list encoding");
    }

    // 返回节点对象
    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x5, %eax
jne 0x48056
movl -0xc(%rbp), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x3c(%rbp), %esi
callq 0x32e50
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x33490
cmpl $0x0, %eax
je 0x48051
cmpq $0x0, -0x28(%rbp)
je 0x48028
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x3a2e0
movq %rax, -0x18(%rbp)
jmp 0x48035
movq -0x38(%rbp), %rdi
callq 0x3a330
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x33700
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x480e1
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x4, %eax
jne 0x480bd
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x48086
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x48092
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x480bb
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3a3f0
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x20170
jmp 0x480df
leaq 0x9aa88(%rip), %rdi     # 0xe2b4c
leaq 0x9af66(%rip), %rsi     # 0xe3031
movl $0xa7, %edx
callq 0x63d40
movl $0x1, %edi
callq 0x1f3b0
jmp 0x480e1
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/t_list.c
// Function: listTypeLength
unsigned long listTypeLength(robj *subject) {

    // ZIPLIST
    if (subject->encoding == REDIS_ENCODING_ZIPLIST) {
        return ziplistLen(subject->ptr);

    // 双端链表
    } else if (subject->encoding == REDIS_ENCODING_LINKEDLIST) {
        return listLength((list*)subject->ptr);

    // 未知编码
    } else {
        redisPanic("Unknown list encoding");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x5, %eax
jne 0x48122
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x33f70
movl %eax, %eax
movq %rax, -0x8(%rbp)
jmp 0x48167
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x4, %eax
jne 0x48145
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x48167
leaq 0x9aa00(%rip), %rdi     # 0xe2b4c
leaq 0x9aede(%rip), %rsi     # 0xe3031
movl $0xbd, %edx
callq 0x63d40
movl $0x1, %edi
callq 0x1f3b0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/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;

    // ZIPLIST
    if (li->encoding == REDIS_ENCODING_ZIPLIST) {
        li->zi = ziplistIndex(subject->ptr,index);

    // 双端链表
    } else if (li->encoding == REDIS_ENCODING_LINKEDLIST) {
        li->ln = listIndex(subject->ptr,index);

    // 未知编码
    } else {
        redisPanic("Unknown list encoding");
    }

    return li;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x20, %edi
callq 0x2e130
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
movzbl 0x8(%rax), %eax
cmpl $0x5, %eax
jne 0x481fa
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl %eax, %esi
callq 0x32e50
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x48249
movq -0x20(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x4, %eax
jne 0x48225
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x20530
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x48247
leaq 0x9a920(%rip), %rdi     # 0xe2b4c
leaq 0x9adfe(%rip), %rsi     # 0xe3031
movl $0xdf, %edx
callq 0x63d40
movl $0x1, %edi
callq 0x1f3b0
jmp 0x48249
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/t_list.c
// Function: listTypeGet
robj *listTypeGet(listTypeEntry *entry) {

    listTypeIterator *li = entry->li;

    robj *value = NULL;

    // 根据索引，从 ZIPLIST 中取出节点的值
    if (li->encoding == REDIS_ENCODING_ZIPLIST) {
        unsigned char *vstr;
        unsigned int vlen;
        long long vlong;
        redisAssert(entry->zi != NULL);
        if (ziplistGet(entry->zi,&vstr,&vlen,&vlong)) {
            if (vstr) {
                value = createStringObject((char*)vstr,vlen);
            } else {
                value = createStringObjectFromLongLong(vlong);
            }
        }

    // 从双端链表中取出节点的值
    } else if (li->encoding == REDIS_ENCODING_LINKEDLIST) {
        redisAssert(entry->ln != NULL);
        value = listNodeValue(entry->ln);
        incrRefCount(value);

    } else {
        redisPanic("Unknown list encoding");
    }

    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x5, %eax
jne 0x484b5
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x48449
jmp 0x4846b
leaq 0x9ac10(%rip), %rdi     # 0xe3060
leaq 0x9abda(%rip), %rsi     # 0xe3031
movl $0x133, %edx            # imm = 0x133
callq 0x63ca0
movl $0x1, %edi
callq 0x1f3b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x24(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x33490
cmpl $0x0, %eax
je 0x484b3
cmpq $0x0, -0x20(%rbp)
je 0x484a4
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x3a2e0
movq %rax, -0x18(%rbp)
jmp 0x484b1
movq -0x30(%rbp), %rdi
callq 0x3a330
movq %rax, -0x18(%rbp)
jmp 0x484b3
jmp 0x48530
movq -0x10(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x4, %eax
jne 0x4850c
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x484cf
jmp 0x484f1
leaq 0x9ab9c(%rip), %rdi     # 0xe3072
leaq 0x9ab54(%rip), %rsi     # 0xe3031
movl $0x13e, %edx            # imm = 0x13E
callq 0x63ca0
movl $0x1, %edi
callq 0x1f3b0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3a3f0
jmp 0x4852e
leaq 0x9a639(%rip), %rdi     # 0xe2b4c
leaq 0x9ab17(%rip), %rsi     # 0xe3031
movl $0x143, %edx            # imm = 0x143
callq 0x63d40
movl $0x1, %edi
callq 0x1f3b0
jmp 0x48530
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/t_list.c
// Function: listTypeEqual
int listTypeEqual(listTypeEntry *entry, robj *o) {

    listTypeIterator *li = entry->li;

    if (li->encoding == REDIS_ENCODING_ZIPLIST) {
        redisAssertWithInfo(NULL,o,sdsEncodedObject(o));
        return ziplistCompare(entry->zi,o->ptr,sdslen(o->ptr));

    } else if (li->encoding == REDIS_ENCODING_LINKEDLIST) {
        return equalStringObjects(o,listNodeValue(entry->ln));

    } else {
        redisPanic("Unknown list encoding");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x5, %eax
jne 0x487e4
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x4877e
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x48780
jmp 0x487ab
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
leaq 0x9a8f5(%rip), %rdx     # 0xe3084
leaq 0x9a89b(%rip), %rcx     # 0xe3031
movl $0x188, %r8d            # imm = 0x188
callq 0x648b0
movl $0x1, %edi
callq 0x1f3b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x47c80
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl %eax, %edx
callq 0x33a20
movl %eax, -0x4(%rbp)
jmp 0x4882d
movq -0x20(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x4, %eax
jne 0x4880b
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x3b240
movl %eax, -0x4(%rbp)
jmp 0x4882d
leaq 0x9a33a(%rip), %rdi     # 0xe2b4c
leaq 0x9a818(%rip), %rsi     # 0xe3031
movl $0x18f, %edx            # imm = 0x18F
callq 0x63d40
movl $0x1, %edi
callq 0x1f3b0
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)