LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zuiBufferFromValue
int zuiBufferFromValue(zsetopval *val) {
    if (val->estr == NULL) {
        if (val->ele != NULL) {
            if (val->ele->encoding == OBJ_ENCODING_INT) {
                val->elen = ll2string((char*)val->_buf,sizeof(val->_buf),(long)val->ele->ptr);
                val->estr = val->_buf;
            } else if (sdsEncodedObject(val->ele)) {
                val->elen = sdslen(val->ele->ptr);
                val->estr = val->ele->ptr;
            } else {
                serverPanic("Unsupported element encoding");
            }
        } else {
            val->elen = ll2string((char*)val->_buf,sizeof(val->_buf),val->ell);
            val->estr = val->_buf;
        }
    }
    return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x30(%rdi)
jne 0x4a794
movq %rdi, %rbx
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x4a77a
movl (%rax), %ecx
shrl $0x4, %ecx
andl $0xf, %ecx
je 0x4a76c
cmpl $0x8, %ecx
je 0x4a76c
cmpl $0x1, %ecx
jne 0x4a79f
leaq 0x4(%rbx), %r14
movq 0x8(%rax), %rdx
jmp 0x4a782
movq 0x8(%rax), %r14
movq %r14, %rdi
callq 0x482f2
jmp 0x4a78d
leaq 0x4(%rbx), %r14
movq 0x40(%rbx), %rdx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x39796
movl %eax, 0x38(%rbx)
movq %r14, 0x30(%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x6a6a6(%rip), %rdi     # 0xb4e4c
leaq 0x6a3a5(%rip), %rsi     # 0xb4b52
movl $0x736, %edx            # imm = 0x736
callq 0x57b45
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zunionInterAggregate
inline static void zunionInterAggregate(double *target, double val, int aggregate) {
    if (aggregate == REDIS_AGGR_SUM) {
        *target = *target + val;
        /* The result of adding two doubles is NaN when one variable
         * is +inf and the other is -inf. When these numbers are added,
         * we maintain the convention of the result being 0.0. */
        if (isnan(*target)) *target = 0.0;
    } else if (aggregate == REDIS_AGGR_MIN) {
        *target = val < *target ? val : *target;
    } else if (aggregate == REDIS_AGGR_MAX) {
        *target = val > *target ? val : *target;
    } else {
        /* safety net */
        serverPanic("Unknown ZUNION/INTER aggregate type");
    }
}

// Assembly:
movsd (%rdi), %xmm1
cmpl $0x2, %esi
je 0x4b0eb
cmpl $0x1, %esi
jne 0x4b0f1
addsd %xmm0, %xmm1
ucomisd %xmm1, %xmm1
jnp 0x4b0f9
xorpd %xmm1, %xmm1
jmp 0x4b0f9
minsd %xmm1, %xmm0
jmp 0x4b0f5
maxsd %xmm1, %xmm0
movapd %xmm0, %xmm1
movsd %xmm1, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zcardCommand
void zcardCommand(client *c) {
    robj *key = c->argv[1];
    robj *zobj;

    if ((zobj = lookupKeyReadOrReply(c,key,shared.czero)) == NULL ||
        checkType(c,zobj,OBJ_ZSET)) return;

    addReplyLongLong(c,zsetLength(zobj));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x8(%rax), %rsi
leaq 0xae0ee(%rip), %rax     # 0xfa310
movq 0x20(%rax), %rdx
callq 0x3aee5
testq %rax, %rax
je 0x4c245
movq %rax, %r14
pushq $0x3
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3a311
testl %eax, %eax
je 0x4c24d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x490f5
movl %eax, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x370a6
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zscoreCommand
void zscoreCommand(client *c) {
    robj *key = c->argv[1];
    robj *zobj;
    double score;

    if ((zobj = lookupKeyReadOrReply(c,key,shared.nullbulk)) == NULL ||
        checkType(c,zobj,OBJ_ZSET)) return;

    if (zsetScore(zobj,c->argv[2],&score) == C_ERR) {
        addReply(c,shared.nullbulk);
    } else {
        addReplyDouble(c,score);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x8(%rax), %rsi
leaq 0xae08f(%rip), %r15     # 0xfa310
movq 0x50(%r15), %rdx
callq 0x3aee5
testq %rax, %rax
je 0x4c2da
movq %rax, %r14
pushq $0x3
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3a311
testl %eax, %eax
jne 0x4c2da
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rsi
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x49447
cmpl $-0x1, %eax
je 0x4c2ce
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x36eb0
jmp 0x4c2da
movq 0x50(%r15), %rsi
movq %rbx, %rdi
callq 0x36987
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_zset.c
// Function: zscanCommand
void zscanCommand(client *c) {
    robj *o;
    unsigned long cursor;

    if (parseScanCursorOrReply(c,c->argv[2],&cursor) == C_ERR) return;
    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.emptyscan)) == NULL ||
        checkType(c,o,OBJ_ZSET)) return;
    scanGenericCommand(c,o,cursor);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x10(%rax), %rsi
movq %rsp, %rdx
callq 0x3b897
cmpl $-0x1, %eax
je 0x4c5be
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
leaq 0xadd8a(%rip), %rax     # 0xfa310
movq 0x148(%rax), %rdx
movq %rbx, %rdi
callq 0x3aee5
testq %rax, %rax
je 0x4c5be
movq %rax, %r14
pushq $0x3
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3a311
testl %eax, %eax
jne 0x4c5be
movq (%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b90d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hashTypeTryConversion
void hashTypeTryConversion(robj *o, robj **argv, int start, int end) {
    int i;

    if (o->encoding != OBJ_ENCODING_ZIPLIST) return;

    for (i = start; i <= end; i++) {
        if (sdsEncodedObject(argv[i]) &&
            sdslen(argv[i]->ptr) > server.hash_max_ziplist_value)
        {
            hashTypeConvert(o, OBJ_ENCODING_HT);
            break;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0xf0, %eax
andl (%rdi), %eax
cmpl $0x50, %eax
jne 0x4c61d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xad2be(%rip), %rax     # 0xf98a8
movq 0x948(%rax), %r15
movslq %edx, %r12
movslq %ecx, %r13
cmpq %r13, %r12
jg 0x4c61d
movq (%r14,%r12,8), %rax
movl (%rax), %ecx
shrl $0x4, %ecx
testb $0x7, %cl
jne 0x4c618
movq 0x8(%rax), %rdi
callq 0x4c63b
cmpq %r15, %rax
ja 0x4c627
incq %r12
jmp 0x4c5f7
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
pushq $0x2
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4c673
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hashTypeConvert
void hashTypeConvert(robj *o, int enc) {
    if (o->encoding == OBJ_ENCODING_ZIPLIST) {
        hashTypeConvertZiplist(o, enc);
    } else if (o->encoding == OBJ_ENCODING_HT) {
        serverPanic("Not implemented");
    } else {
        serverPanic("Unknown hash encoding");
    }
}

// Assembly:
pushq %rax
movl (%rdi), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x5, %eax
jne 0x4c687
popq %rax
jmp 0x4d05b
cmpl $0x2, %eax
jne 0x4c6a1
leaq 0x689aa(%rip), %rdi     # 0xb503d
leaq 0x688ea(%rip), %rsi     # 0xb4f84
movl $0x1dc, %edx            # imm = 0x1DC
jmp 0x4c6b4
leaq 0x67a99(%rip), %rdi     # 0xb4141
leaq 0x688d5(%rip), %rsi     # 0xb4f84
movl $0x1de, %edx            # imm = 0x1DE
callq 0x57b45
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hashTypeGetFromZiplist
int hashTypeGetFromZiplist(robj *o, robj *field,
                           unsigned char **vstr,
                           unsigned int *vlen,
                           long long *vll)
{
    unsigned char *zl, *fptr = NULL, *vptr = NULL;
    int ret;

    serverAssert(o->encoding == OBJ_ENCODING_ZIPLIST);

    field = getDecodedObject(field);

    zl = o->ptr;
    fptr = ziplistIndex(zl, ZIPLIST_HEAD);
    if (fptr != NULL) {
        fptr = ziplistFind(fptr, field->ptr, sdslen(field->ptr), 1);
        if (fptr != NULL) {
            /* Grab pointer to the value (fptr points to the field) */
            vptr = ziplistNext(zl, fptr);
            serverAssert(vptr != NULL);
        }
    }

    decrRefCount(field);

    if (vptr != NULL) {
        ret = ziplistGet(vptr, vstr, vlen, vll);
        serverAssert(ret);
        return 0;
    }

    return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, (%rsp)
movl $0xf0, %eax
andl (%rdi), %eax
cmpl $0x50, %eax
jne 0x4c7de
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r13
movq %rsi, %rdi
callq 0x3a57d
movq %rax, %r12
movq 0x8(%r13), %r13
xorl %ebp, %ebp
movq %r13, %rdi
xorl %esi, %esi
callq 0x35aca
testq %rax, %rax
je 0x4c793
movq %rax, %rbx
movq 0x8(%r12), %rbp
movq %rbp, %rdi
callq 0x4c63b
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %rbp, %rsi
movl %eax, %edx
callq 0x35d65
testq %rax, %rax
je 0x4c791
movq %r13, %rdi
movq %rax, %rsi
callq 0x35b60
movq %rax, %rbp
testq %rax, %rax
jne 0x4c793
leaq 0x68807(%rip), %rdi     # 0xb4f8d
leaq 0x687f7(%rip), %rsi     # 0xb4f84
pushq $0x54
jmp 0x4c7ee
xorl %ebp, %ebp
movq %r12, %rdi
callq 0x3a265
testq %rbp, %rbp
je 0x4c7cc
movq %rbp, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq (%rsp), %rcx
callq 0x35be8
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x4c7cf
leaq 0x687d9(%rip), %rdi     # 0xb4f9a
leaq 0x687bc(%rip), %rsi     # 0xb4f84
pushq $0x5c
jmp 0x4c7ee
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6877b(%rip), %rdi     # 0xb4f60
leaq 0x68798(%rip), %rsi     # 0xb4f84
pushq $0x49
popq %rdx
callq 0x57ac8
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hashTypeGetFromHashTable
int hashTypeGetFromHashTable(robj *o, robj *field, robj **value) {
    dictEntry *de;

    serverAssert(o->encoding == OBJ_ENCODING_HT);

    de = dictFind(o->ptr, field);
    if (de == NULL) return -1;
    *value = dictGetVal(de);
    return 0;
}

// Assembly:
pushq %rbx
movl $0xf0, %eax
andl (%rdi), %eax
cmpl $0x20, %eax
jne 0x4c82a
movq %rdx, %rbx
movq 0x8(%rdi), %rdi
callq 0x2a5f9
testq %rax, %rax
je 0x4c825
movq 0x8(%rax), %rax
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x4c828
pushq $-0x1
popq %rax
popq %rbx
retq
leaq 0x6876d(%rip), %rdi     # 0xb4f9e
leaq 0x6874c(%rip), %rsi     # 0xb4f84
pushq $0x68
popq %rdx
callq 0x57ac8
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hashTypeGetObject
robj *hashTypeGetObject(robj *o, robj *field) {
    robj *value = NULL;

    if (o->encoding == OBJ_ENCODING_ZIPLIST) {
        unsigned char *vstr = NULL;
        unsigned int vlen = UINT_MAX;
        long long vll = LLONG_MAX;

        if (hashTypeGetFromZiplist(o, field, &vstr, &vlen, &vll) == 0) {
            if (vstr) {
                value = createStringObject((char*)vstr, vlen);
            } else {
                value = createStringObjectFromLongLong(vll);
            }
        }
    } else if (o->encoding == OBJ_ENCODING_HT) {
        robj *aux;

        if (hashTypeGetFromHashTable(o, field, &aux) == 0) {
            incrRefCount(aux);
            value = aux;
        }
    } else {
        serverPanic("Unknown hash encoding");
    }
    return value;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl (%rdi), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x2, %eax
je 0x4c8a0
cmpl $0x5, %eax
jne 0x4c8d7
leaq 0x8(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x14(%rsp), %rcx
orl $-0x1, (%rcx)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
leaq 0x18(%rsp), %r8
movq %rax, (%r8)
callq 0x4c6ff
testl %eax, %eax
jne 0x4c8ae
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4c8c1
movl 0x14(%rsp), %esi
callq 0x39e29
jmp 0x4c8cb
leaq 0x8(%rsp), %rdx
callq 0x4c7fc
testl %eax, %eax
je 0x4c8b2
xorl %ebx, %ebx
jmp 0x4c8ce
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x39e74
jmp 0x4c8ce
movq 0x18(%rsp), %rdi
callq 0x39e38
movq %rax, %rbx
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
leaq 0x67863(%rip), %rdi     # 0xb4141
leaq 0x6869f(%rip), %rsi     # 0xb4f84
movl $0x8d, %edx
callq 0x57b45
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hashTypeGetValueLength
size_t hashTypeGetValueLength(robj *o, robj *field) {
    size_t len = 0;
    if (o->encoding == OBJ_ENCODING_ZIPLIST) {
        unsigned char *vstr = NULL;
        unsigned int vlen = UINT_MAX;
        long long vll = LLONG_MAX;

        if (hashTypeGetFromZiplist(o, field, &vstr, &vlen, &vll) == 0)
            len = vstr ? vlen : sdigits10(vll);
    } else if (o->encoding == OBJ_ENCODING_HT) {
        robj *aux;

        if (hashTypeGetFromHashTable(o, field, &aux) == 0)
            len = stringObjectLen(aux);
    } else {
        serverPanic("Unknown hash encoding");
    }
    return len;
}

// Assembly:
subq $0x18, %rsp
movl (%rdi), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x2, %eax
je 0x4c944
cmpl $0x5, %eax
jne 0x4c970
movq %rsp, %rdx
andq $0x0, (%rdx)
leaq 0xc(%rsp), %rcx
orl $-0x1, (%rcx)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
leaq 0x10(%rsp), %r8
movq %rax, (%r8)
callq 0x4c6ff
testl %eax, %eax
jne 0x4c950
cmpq $0x0, (%rsp)
je 0x4c95f
movl 0xc(%rsp), %eax
jmp 0x4c969
movq %rsp, %rdx
callq 0x4c7fc
testl %eax, %eax
je 0x4c954
xorl %eax, %eax
jmp 0x4c96b
movq (%rsp), %rdi
callq 0x3a747
jmp 0x4c96b
movq 0x10(%rsp), %rdi
callq 0x39780
movl %eax, %eax
addq $0x18, %rsp
retq
leaq 0x677ca(%rip), %rdi     # 0xb4141
leaq 0x68606(%rip), %rsi     # 0xb4f84
movl $0xa4, %edx
callq 0x57b45
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hashTypeExists
int hashTypeExists(robj *o, robj *field) {
    if (o->encoding == OBJ_ENCODING_ZIPLIST) {
        unsigned char *vstr = NULL;
        unsigned int vlen = UINT_MAX;
        long long vll = LLONG_MAX;

        if (hashTypeGetFromZiplist(o, field, &vstr, &vlen, &vll) == 0) return 1;
    } else if (o->encoding == OBJ_ENCODING_HT) {
        robj *aux;

        if (hashTypeGetFromHashTable(o, field, &aux) == 0) return 1;
    } else {
        serverPanic("Unknown hash encoding");
    }
    return 0;
}

// Assembly:
subq $0x18, %rsp
movl (%rdi), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x2, %eax
je 0x4c9ce
cmpl $0x5, %eax
jne 0x4c9e6
movq %rsp, %rdx
andq $0x0, (%rdx)
leaq 0xc(%rsp), %rcx
orl $-0x1, (%rcx)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
leaq 0x10(%rsp), %r8
movq %rax, (%r8)
callq 0x4c6ff
jmp 0x4c9d6
movq %rsp, %rdx
callq 0x4c7fc
testl %eax, %eax
je 0x4c9de
xorl %eax, %eax
jmp 0x4c9e1
pushq $0x1
popq %rax
addq $0x18, %rsp
retq
leaq 0x67754(%rip), %rdi     # 0xb4141
leaq 0x68590(%rip), %rsi     # 0xb4f84
movl $0xb7, %edx
callq 0x57b45
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hashTypeLength
unsigned long hashTypeLength(robj *o) {
    unsigned long length = ULONG_MAX;

    if (o->encoding == OBJ_ENCODING_ZIPLIST) {
        length = ziplistLen(o->ptr) / 2;
    } else if (o->encoding == OBJ_ENCODING_HT) {
        length = dictSize((dict*)o->ptr);
    } else {
        serverPanic("Unknown hash encoding");
    }

    return length;
}

// Assembly:
pushq %rax
movl (%rdi), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x2, %eax
je 0x4cc01
cmpl $0x5, %eax
jne 0x4cc0f
movq 0x8(%rdi), %rdi
callq 0x35f0c
shrl %eax
jmp 0x4cc0d
movq 0x8(%rdi), %rcx
movq 0x48(%rcx), %rax
addq 0x28(%rcx), %rax
popq %rcx
retq
leaq 0x6752b(%rip), %rdi     # 0xb4141
leaq 0x68367(%rip), %rsi     # 0xb4f84
movl $0x124, %edx            # imm = 0x124
callq 0x57b45
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hashTypeDelete
int hashTypeDelete(robj *o, robj *field) {
    int deleted = 0;

    if (o->encoding == OBJ_ENCODING_ZIPLIST) {
        unsigned char *zl, *fptr;

        field = getDecodedObject(field);

        zl = o->ptr;
        fptr = ziplistIndex(zl, ZIPLIST_HEAD);
        if (fptr != NULL) {
            fptr = ziplistFind(fptr, field->ptr, sdslen(field->ptr), 1);
            if (fptr != NULL) {
                zl = ziplistDelete(zl,&fptr);
                zl = ziplistDelete(zl,&fptr);
                o->ptr = zl;
                deleted = 1;
            }
        }

        decrRefCount(field);

    } else if (o->encoding == OBJ_ENCODING_HT) {
        if (dictDelete((dict*)o->ptr, field) == C_OK) {
            deleted = 1;

            /* Always check if the dictionary needs a resize after a delete. */
            if (htNeedsResize(o->ptr)) dictResize(o->ptr);
        }

    } else {
        serverPanic("Unknown hash encoding");
    }

    return deleted;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x2, %eax
je 0x4ccd0
cmpl $0x5, %eax
jne 0x4cd09
movq %rsi, %rdi
callq 0x3a57d
movq %rax, %r14
movq 0x8(%rbx), %r15
xorl %ebp, %ebp
movq %r15, %rdi
xorl %esi, %esi
callq 0x35aca
movq %rax, (%rsp)
testq %rax, %rax
je 0x4ccc6
movq %rax, %r13
movq 0x8(%r14), %r12
movq %r12, %rdi
callq 0x4c63b
pushq $0x1
popq %rcx
movq %r13, %rdi
movl %ecx, %r13d
movq %r12, %rsi
movl %eax, %edx
callq 0x35d65
movq %rax, (%rsp)
testq %rax, %rax
je 0x4ccc6
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x35c78
movq %rax, %rdi
movq %r12, %rsi
callq 0x35c78
movq %rax, 0x8(%rbx)
movl %r13d, %ebp
movq %r14, %rdi
callq 0x3a265
jmp 0x4ccf8
movq 0x8(%rbx), %rdi
callq 0x2a6dc
xorl %ebp, %ebp
testl %eax, %eax
jne 0x4ccf8
movq 0x8(%rbx), %rdi
callq 0x2bac1
pushq $0x1
popq %rbp
testl %eax, %eax
je 0x4ccf8
movq 0x8(%rbx), %rdi
callq 0x2a192
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x67431(%rip), %rdi     # 0xb4141
leaq 0x6826d(%rip), %rsi     # 0xb4f84
movl $0x115, %edx            # imm = 0x115
callq 0x57b45
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hashTypeInitIterator
hashTypeIterator *hashTypeInitIterator(robj *subject) {
    hashTypeIterator *hi = zmalloc(sizeof(hashTypeIterator));
    hi->subject = subject;
    hi->encoding = subject->encoding;

    if (hi->encoding == OBJ_ENCODING_ZIPLIST) {
        hi->fptr = NULL;
        hi->vptr = NULL;
    } else if (hi->encoding == OBJ_ENCODING_HT) {
        hi->di = dictGetIterator(subject->ptr);
    } else {
        serverPanic("Unknown hash encoding");
    }

    return hi;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x30
popq %rdi
callq 0x327b9
movq %rax, %rbx
movq %r14, (%rax)
movl (%r14), %eax
shrl $0x4, %eax
andl $0xf, %eax
movl %eax, 0x8(%rbx)
cmpl $0x2, %eax
je 0x4cd5d
cmpl $0x5, %eax
jne 0x4cd75
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
jmp 0x4cd6a
movq 0x8(%r14), %rdi
callq 0x2a99f
movq %rax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x673c5(%rip), %rdi     # 0xb4141
leaq 0x68201(%rip), %rsi     # 0xb4f84
movl $0x135, %edx            # imm = 0x135
callq 0x57b45
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hashTypeNext
int hashTypeNext(hashTypeIterator *hi) {
    if (hi->encoding == OBJ_ENCODING_ZIPLIST) {
        unsigned char *zl;
        unsigned char *fptr, *vptr;

        zl = hi->subject->ptr;
        fptr = hi->fptr;
        vptr = hi->vptr;

        if (fptr == NULL) {
            /* Initialize cursor */
            serverAssert(vptr == NULL);
            fptr = ziplistIndex(zl, 0);
        } else {
            /* Advance cursor */
            serverAssert(vptr != NULL);
            fptr = ziplistNext(zl, vptr);
        }
        if (fptr == NULL) return C_ERR;

        /* Grab pointer to the value (fptr points to the field) */
        vptr = ziplistNext(zl, fptr);
        serverAssert(vptr != NULL);

        /* fptr, vptr now point to the first or next pair */
        hi->fptr = fptr;
        hi->vptr = vptr;
    } else if (hi->encoding == OBJ_ENCODING_HT) {
        if ((hi->de = dictNext(hi->di)) == NULL) return C_ERR;
    } else {
        serverPanic("Unknown hash encoding");
    }
    return C_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl $0x2, %eax
je 0x4cde7
cmpl $0x5, %eax
jne 0x4ce37
movq (%rbx), %rax
movq 0x18(%rbx), %rsi
movq 0x8(%rax), %r14
cmpq $0x0, 0x10(%rbx)
je 0x4cdfb
testq %rsi, %rsi
je 0x4ce51
movq %r14, %rdi
callq 0x35b60
jmp 0x4ce0a
movq 0x20(%rbx), %rdi
callq 0x2a9d3
movq %rax, 0x28(%rbx)
testq %rax, %rax
jne 0x4ce2a
jmp 0x4ce2e
testq %rsi, %rsi
jne 0x4ce7b
movq %r14, %rdi
xorl %esi, %esi
callq 0x35aca
movq %rax, %r15
testq %rax, %rax
je 0x4ce2e
movq %r14, %rdi
movq %r15, %rsi
callq 0x35b60
testq %rax, %rax
je 0x4ce66
movq %r15, 0x10(%rbx)
movq %rax, 0x18(%rbx)
xorl %eax, %eax
jmp 0x4ce31
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x67303(%rip), %rdi     # 0xb4141
leaq 0x6813f(%rip), %rsi     # 0xb4f84
movl $0x163, %edx            # imm = 0x163
callq 0x57b45
jmp 0x4ce93
leaq 0x68135(%rip), %rdi     # 0xb4f8d
leaq 0x68125(%rip), %rsi     # 0xb4f84
movl $0x154, %edx            # imm = 0x154
jmp 0x4ce8e
leaq 0x68120(%rip), %rdi     # 0xb4f8d
leaq 0x68110(%rip), %rsi     # 0xb4f84
movl $0x15b, %edx            # imm = 0x15B
jmp 0x4ce8e
leaq 0x6813b(%rip), %rdi     # 0xb4fbd
leaq 0x680fb(%rip), %rsi     # 0xb4f84
movl $0x150, %edx            # imm = 0x150
callq 0x57ac8
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hashTypeCurrentFromZiplist
void hashTypeCurrentFromZiplist(hashTypeIterator *hi, int what,
                                unsigned char **vstr,
                                unsigned int *vlen,
                                long long *vll)
{
    int ret;

    serverAssert(hi->encoding == OBJ_ENCODING_ZIPLIST);

    if (what & OBJ_HASH_KEY) {
        ret = ziplistGet(hi->fptr, vstr, vlen, vll);
        serverAssert(ret);
    } else {
        ret = ziplistGet(hi->vptr, vstr, vlen, vll);
        serverAssert(ret);
    }
}

// Assembly:
pushq %rax
cmpl $0x5, 0x8(%rdi)
jne 0x4ceeb
testb $0x1, %sil
jne 0x4ced3
movq 0x18(%rdi), %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
callq 0x35be8
testl %eax, %eax
jne 0x4cee9
leaq 0x680d5(%rip), %rdi     # 0xb4f9a
leaq 0x680b8(%rip), %rsi     # 0xb4f84
movl $0x178, %edx            # imm = 0x178
jmp 0x4cf13
movq 0x10(%rdi), %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
callq 0x35be8
testl %eax, %eax
je 0x4cf00
popq %rax
retq
leaq 0x680d8(%rip), %rdi     # 0xb4fca
leaq 0x6808b(%rip), %rsi     # 0xb4f84
movl $0x171, %edx            # imm = 0x171
jmp 0x4cf13
leaq 0x68093(%rip), %rdi     # 0xb4f9a
leaq 0x68076(%rip), %rsi     # 0xb4f84
movl $0x175, %edx            # imm = 0x175
callq 0x57ac8
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hashTypeCurrentFromHashTable
void hashTypeCurrentFromHashTable(hashTypeIterator *hi, int what, robj **dst) {
    serverAssert(hi->encoding == OBJ_ENCODING_HT);

    if (what & OBJ_HASH_KEY) {
        *dst = dictGetKey(hi->de);
    } else {
        *dst = dictGetVal(hi->de);
    }
}

// Assembly:
cmpl $0x2, 0x8(%rdi)
jne 0x4cf3c
movq 0x28(%rdi), %rax
shll $0x3, %esi
andl $0x8, %esi
xorq $0x8, %rsi
movq (%rax,%rsi), %rax
movq %rax, (%rdx)
retq
pushq %rax
leaq 0x680ab(%rip), %rdi     # 0xb4fef
leaq 0x68039(%rip), %rsi     # 0xb4f84
movl $0x17f, %edx            # imm = 0x17F
callq 0x57ac8
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hashTypeCurrentObject
robj *hashTypeCurrentObject(hashTypeIterator *hi, int what) {
    robj *dst;

    if (hi->encoding == OBJ_ENCODING_ZIPLIST) {
        unsigned char *vstr = NULL;
        unsigned int vlen = UINT_MAX;
        long long vll = LLONG_MAX;

        hashTypeCurrentFromZiplist(hi, what, &vstr, &vlen, &vll);
        if (vstr) {
            dst = createStringObject((char*)vstr, vlen);
        } else {
            dst = createStringObjectFromLongLong(vll);
        }
    } else if (hi->encoding == OBJ_ENCODING_HT) {
        hashTypeCurrentFromHashTable(hi, what, &dst);
        incrRefCount(dst);
    } else {
        serverPanic("Unknown hash encoding");
    }
    return dst;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl 0x8(%rdi), %eax
cmpl $0x2, %eax
je 0x4cfad
cmpl $0x5, %eax
jne 0x4cfdd
leaq 0x18(%rsp), %rbx
andq $0x0, (%rbx)
leaq 0xc(%rsp), %rcx
orl $-0x1, (%rcx)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
leaq 0x10(%rsp), %r8
movq %rax, (%r8)
movq %rbx, %rdx
callq 0x4ce9b
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4cfc7
movl 0xc(%rsp), %esi
callq 0x39e29
jmp 0x4cfd1
leaq 0x18(%rsp), %rbx
movq %rbx, %rdx
callq 0x4cf20
movq (%rbx), %rbx
movq %rbx, %rdi
callq 0x39e74
jmp 0x4cfd4
movq 0x10(%rsp), %rdi
callq 0x39e38
movq %rax, %rbx
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
leaq 0x6715d(%rip), %rdi     # 0xb4141
leaq 0x67f99(%rip), %rsi     # 0xb4f84
movl $0x19d, %edx            # imm = 0x19D
callq 0x57b45
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hashTypeLookupWriteOrCreate
robj *hashTypeLookupWriteOrCreate(client *c, robj *key) {
    robj *o = lookupKeyWrite(c->db,key);
    if (o == NULL) {
        o = createHashObject();
        dbAdd(c->db,key,o);
    } else {
        if (o->type != OBJ_HASH) {
            addReply(c,shared.wrongtypeerr);
            return NULL;
        }
    }
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3aec2
testq %rax, %rax
je 0x4d03b
movq %rax, %r14
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x4, %eax
je 0x4d052
leaq 0xad2e6(%rip), %rax     # 0xfa310
movq 0x70(%rax), %rsi
movq %rbx, %rdi
callq 0x36987
xorl %r14d, %r14d
jmp 0x4d052
callq 0x3a0c0
movq %rax, %r14
movq 0x10(%rbx), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x3af45
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hashTypeConvertZiplist
void hashTypeConvertZiplist(robj *o, int enc) {
    serverAssert(o->encoding == OBJ_ENCODING_ZIPLIST);

    if (enc == OBJ_ENCODING_ZIPLIST) {
        /* Nothing to do... */

    } else if (enc == OBJ_ENCODING_HT) {
        hashTypeIterator *hi;
        dict *dict;
        int ret;

        hi = hashTypeInitIterator(o);
        dict = dictCreate(&hashDictType, NULL);

        while (hashTypeNext(hi) != C_ERR) {
            robj *field, *value;

            field = hashTypeCurrentObject(hi, OBJ_HASH_KEY);
            field = tryObjectEncoding(field);
            value = hashTypeCurrentObject(hi, OBJ_HASH_VALUE);
            value = tryObjectEncoding(value);
            ret = dictAdd(dict, field, value);
            if (ret != DICT_OK) {
                serverLogHexDump(LL_WARNING,"ziplist with dup elements dump",
                    o->ptr,ziplistBlobLen(o->ptr));
                serverAssert(ret == DICT_OK);
            }
        }

        hashTypeReleaseIterator(hi);
        zfree(o->ptr);

        o->encoding = OBJ_ENCODING_HT;
        o->ptr = dict;

    } else {
        serverPanic("Unknown hash encoding");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xf0, %eax
andl (%rdi), %eax
cmpl $0x50, %eax
jne 0x4d163
cmpl $0x5, %esi
je 0x4d154
cmpl $0x2, %esi
jne 0x4d178
movq %rdi, %rbx
callq 0x4cd29
movq %rax, %r15
leaq 0xabe36(%rip), %rdi     # 0xf8ed0
xorl %esi, %esi
callq 0x2a155
movq %rax, %r14
pushq $0x1
popq %rbp
pushq $0x2
popq %r12
movq %r15, %rdi
callq 0x4cdb1
cmpl $-0x1, %eax
je 0x4d133
movq %r15, %rdi
movl %ebp, %esi
callq 0x4cf5d
movq %rax, %rdi
callq 0x3a3ad
movq %rax, %r13
movq %r15, %rdi
movl %r12d, %esi
callq 0x4cf5d
movq %rax, %rdi
callq 0x3a3ad
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x2a3ed
testl %eax, %eax
je 0x4d0ab
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x35f52
leaq 0x67f0a(%rip), %rsi     # 0xb500f
pushq $0x3
popq %rdi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x594b8
leaq 0x67f14(%rip), %rdi     # 0xb502e
leaq 0x67e63(%rip), %rsi     # 0xb4f84
movl $0x1c9, %edx            # imm = 0x1C9
callq 0x57ac8
pushq $0x1
popq %rdi
callq 0x263c0
movq %r15, %rdi
callq 0x4cd95
movq 0x8(%rbx), %rdi
callq 0x328f9
movl $0xffffff0f, %eax       # imm = 0xFFFFFF0F
andl (%rbx), %eax
orl $0x20, %eax
movl %eax, (%rbx)
movq %r14, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x67df6(%rip), %rdi     # 0xb4f60
leaq 0x67e13(%rip), %rsi     # 0xb4f84
movl $0x1b1, %edx            # imm = 0x1B1
jmp 0x4d126
leaq 0x66fc2(%rip), %rdi     # 0xb4141
leaq 0x67dfe(%rip), %rsi     # 0xb4f84
movl $0x1d4, %edx            # imm = 0x1D4
callq 0x57b45
jmp 0x4d12b
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hsetCommand
void hsetCommand(client *c) {
    int update;
    robj *o;

    if ((o = hashTypeLookupWriteOrCreate(c,c->argv[1])) == NULL) return;
    hashTypeTryConversion(o,c->argv,2,3);
    hashTypeTryObjectEncoding(o,&c->argv[2], &c->argv[3]);
    update = hashTypeSet(o,c->argv[2],c->argv[3]);
    addReply(c, update ? shared.czero : shared.cone);
    signalModifiedKey(c->db,c->argv[1]);
    notifyKeyspaceEvent(NOTIFY_HASH,"hset",c->argv[1],c->db->id);
    server.dirty++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x8(%rax), %rsi
callq 0x4cffd
testq %rax, %rax
je 0x4d244
movq %rax, %r14
movq 0x40(%rbx), %rsi
pushq $0x2
popq %rdx
pushq $0x3
popq %rcx
movq %rax, %rdi
callq 0x4c5c8
movq 0x40(%rbx), %rdx
leaq 0x10(%rdx), %rsi
addq $0x18, %rdx
movq %r14, %rdi
callq 0x4c6c1
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
movq %r14, %rdi
callq 0x4ca06
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
leaq 0xad116(%rip), %rax     # 0xfa310
movq 0x20(%rax,%rcx,8), %rsi
movq %rbx, %rdi
callq 0x36987
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x3b125
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x8(%rcx), %rdx
movl 0x30(%rax), %ecx
leaq 0x6142a(%rip), %rsi     # 0xae658
pushq $0x40
popq %rdi
callq 0x6fb58
leaq 0xac66b(%rip), %rax     # 0xf98a8
incq 0x720(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hsetnxCommand
void hsetnxCommand(client *c) {
    robj *o;
    if ((o = hashTypeLookupWriteOrCreate(c,c->argv[1])) == NULL) return;
    hashTypeTryConversion(o,c->argv,2,3);

    if (hashTypeExists(o, c->argv[2])) {
        addReply(c, shared.czero);
    } else {
        hashTypeTryObjectEncoding(o,&c->argv[2], &c->argv[3]);
        hashTypeSet(o,c->argv[2],c->argv[3]);
        addReply(c, shared.cone);
        signalModifiedKey(c->db,c->argv[1]);
        notifyKeyspaceEvent(NOTIFY_HASH,"hset",c->argv[1],c->db->id);
        server.dirty++;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x8(%rax), %rsi
callq 0x4cffd
testq %rax, %rax
je 0x4d324
movq %rax, %r14
movq 0x40(%rbx), %rsi
pushq $0x2
popq %rdx
pushq $0x3
popq %rcx
movq %rax, %rdi
callq 0x4c5c8
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x4c990
testl %eax, %eax
je 0x4d2ac
leaq 0xad077(%rip), %rax     # 0xfa310
movq 0x20(%rax), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x36987
movq 0x40(%rbx), %rdx
leaq 0x10(%rdx), %rsi
addq $0x18, %rdx
movq %r14, %rdi
callq 0x4c6c1
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
movq %r14, %rdi
callq 0x4ca06
leaq 0xad035(%rip), %rax     # 0xfa310
movq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x36987
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x3b125
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x8(%rcx), %rdx
movl 0x30(%rax), %ecx
leaq 0x6134a(%rip), %rsi     # 0xae658
pushq $0x40
popq %rdi
callq 0x6fb58
leaq 0xac58b(%rip), %rax     # 0xf98a8
incq 0x720(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hmsetCommand
void hmsetCommand(client *c) {
    int i;
    robj *o;

    if ((c->argc % 2) == 1) {
        addReplyError(c,"wrong number of arguments for HMSET");
        return;
    }

    if ((o = hashTypeLookupWriteOrCreate(c,c->argv[1])) == NULL) return;
    hashTypeTryConversion(o,c->argv,2,c->argc-1);
    for (i = 2; i < c->argc; i += 2) {
        hashTypeTryObjectEncoding(o,&c->argv[i], &c->argv[i+1]);
        hashTypeSet(o,c->argv[i],c->argv[i+1]);
    }
    addReply(c, shared.ok);
    signalModifiedKey(c->db,c->argv[1]);
    notifyKeyspaceEvent(NOTIFY_HASH,"hset",c->argv[1],c->db->id);
    server.dirty++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x80000001, %eax       # imm = 0x80000001
andl 0x38(%rdi), %eax
cmpl $0x1, %eax
jne 0x4d35e
leaq 0x67d04(%rip), %rsi     # 0xb504f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x36b6f
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x4cffd
testq %rax, %rax
je 0x4d425
movq %rax, %r14
movq 0x40(%rbx), %rsi
movl 0x38(%rbx), %ecx
decl %ecx
pushq $0x2
popq %rdx
movq %rax, %rdi
callq 0x4c5c8
pushq $0x2
popq %r15
pushq $0x18
popq %r12
movslq 0x38(%rbx), %rax
cmpq %rax, %r15
jge 0x4d3d5
movq 0x40(%rbx), %rdx
leaq (%rdx,%r12), %rsi
addq $-0x8, %rsi
addq %r12, %rdx
movq %r14, %rdi
callq 0x4c6c1
movq 0x40(%rbx), %rax
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %r14, %rdi
callq 0x4ca06
addq $0x2, %r15
addq $0x10, %r12
jmp 0x4d396
leaq 0xacf34(%rip), %rax     # 0xfa310
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x36987
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x3b125
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x8(%rcx), %rdx
movl 0x30(%rax), %ecx
leaq 0x61249(%rip), %rsi     # 0xae658
pushq $0x40
popq %rdi
callq 0x6fb58
leaq 0xac48a(%rip), %rax     # 0xf98a8
incq 0x720(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hincrbyCommand
void hincrbyCommand(client *c) {
    long long value, incr, oldvalue;
    robj *o, *current, *new;

    if (getLongLongFromObjectOrReply(c,c->argv[3],&incr,NULL) != C_OK) return;
    if ((o = hashTypeLookupWriteOrCreate(c,c->argv[1])) == NULL) return;
    if ((current = hashTypeGetObject(o,c->argv[2])) != NULL) {
        if (getLongLongFromObjectOrReply(c,current,&value,
            "hash value is not an integer") != C_OK) {
            decrRefCount(current);
            return;
        }
        decrRefCount(current);
    } else {
        value = 0;
    }

    oldvalue = value;
    if ((incr < 0 && oldvalue < 0 && incr < (LLONG_MIN-oldvalue)) ||
        (incr > 0 && oldvalue > 0 && incr > (LLONG_MAX-oldvalue))) {
        addReplyError(c,"increment or decrement would overflow");
        return;
    }
    value += incr;
    new = createStringObjectFromLongLong(value);
    hashTypeTryObjectEncoding(o,&c->argv[2],NULL);
    hashTypeSet(o,c->argv[2],new);
    decrRefCount(new);
    addReplyLongLong(c,value);
    signalModifiedKey(c->db,c->argv[1]);
    notifyKeyspaceEvent(NOTIFY_HASH,"hincrby",c->argv[1],c->db->id);
    server.dirty++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x18(%rax), %rsi
leaq 0x10(%rsp), %rdx
xorl %ecx, %ecx
callq 0x3ab03
testl %eax, %eax
je 0x4d461
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x4cffd
testq %rax, %rax
je 0x4d456
movq %rax, %r14
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x4c848
testq %rax, %rax
je 0x4d4bd
movq %rax, %r15
leaq 0x67bdb(%rip), %rcx     # 0xb5073
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3ab03
movl %eax, %ebp
movq %r15, %rdi
callq 0x3a265
testl %ebp, %ebp
jne 0x4d456
movq 0x8(%rsp), %rax
jmp 0x4d4c5
andq $0x0, 0x8(%rsp)
xorl %eax, %eax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
movq 0x10(%rsp), %rdi
subq %rax, %rcx
testq %rdi, %rdi
jns 0x4d4ea
testq %rax, %rax
jns 0x4d4ea
leaq 0x1(%rcx), %rdx
cmpq %rdx, %rdi
jl 0x4d508
testq %rdi, %rdi
setg %dl
testq %rax, %rax
setg %sil
andb %dl, %sil
cmpq %rcx, %rdi
setg %cl
andb %sil, %cl
cmpb $0x1, %cl
jne 0x4d51c
leaq 0x67331(%rip), %rsi     # 0xb4840
movq %rbx, %rdi
callq 0x36b6f
jmp 0x4d456
addq %rax, %rdi
movq %rdi, 0x8(%rsp)
callq 0x39e38
movq %rax, %r15
movq 0x40(%rbx), %rsi
addq $0x10, %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x4c6c1
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x4ca06
movq %r15, %rdi
callq 0x3a265
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x370a6
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x3b125
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x8(%rcx), %rdx
movl 0x30(%rax), %ecx
leaq 0x610e8(%rip), %rsi     # 0xae675
pushq $0x40
popq %rdi
callq 0x6fb58
leaq 0xac30c(%rip), %rax     # 0xf98a8
incq 0x720(%rax)
jmp 0x4d456
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hincrbyfloatCommand
void hincrbyfloatCommand(client *c) {
    double long value, incr;
    robj *o, *current, *new, *aux;

    if (getLongDoubleFromObjectOrReply(c,c->argv[3],&incr,NULL) != C_OK) return;
    if ((o = hashTypeLookupWriteOrCreate(c,c->argv[1])) == NULL) return;
    if ((current = hashTypeGetObject(o,c->argv[2])) != NULL) {
        if (getLongDoubleFromObjectOrReply(c,current,&value,
            "hash value is not a valid float") != C_OK) {
            decrRefCount(current);
            return;
        }
        decrRefCount(current);
    } else {
        value = 0;
    }

    value += incr;
    new = createStringObjectFromLongDouble(value,1);
    hashTypeTryObjectEncoding(o,&c->argv[2],NULL);
    hashTypeSet(o,c->argv[2],new);
    addReplyBulk(c,new);
    signalModifiedKey(c->db,c->argv[1]);
    notifyKeyspaceEvent(NOTIFY_HASH,"hincrbyfloat",c->argv[1],c->db->id);
    server.dirty++;

    /* Always replicate HINCRBYFLOAT as an HSET command with the final value
     * in order to make sure that differences in float pricision or formatting
     * will not create differences in replicas or after an AOF restart. */
    aux = createStringObject("HSET",4);
    rewriteClientCommandArgument(c,0,aux);
    decrRefCount(aux);
    rewriteClientCommandArgument(c,3,new);
    decrRefCount(new);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x18(%rax), %rsi
leaq 0x20(%rsp), %rdx
xorl %ecx, %ecx
callq 0x3a9fe
testl %eax, %eax
je 0x4d5d8
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x4cffd
testq %rax, %rax
je 0x4d5cd
movq %rax, %r15
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rsi
movq %r15, %rdi
callq 0x4c848
fldz
testq %rax, %rax
je 0x4d635
movq %rax, %r14
fstp %st(0)
leaq 0x67a7d(%rip), %rcx     # 0xb5090
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3a9fe
movl %eax, %ebp
movq %r14, %rdi
callq 0x3a265
testl %ebp, %ebp
jne 0x4d5cd
fldt 0x10(%rsp)
fldt 0x20(%rsp)
faddp %st, %st(1)
fld %st(0)
fstpt 0x10(%rsp)
fstpt (%rsp)
pushq $0x1
popq %rdi
callq 0x39e78
movq %rax, %r14
movq 0x40(%rbx), %rsi
addq $0x10, %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x4c6c1
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x4ca06
movq %rbx, %rdi
movq %r14, %rsi
callq 0x36fd9
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x3b125
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x8(%rcx), %rdx
movl 0x30(%rax), %ecx
leaq 0x60fd7(%rip), %rsi     # 0xae67d
pushq $0x40
popq %rdi
callq 0x6fb58
leaq 0xac1f3(%rip), %rax     # 0xf98a8
incq 0x720(%rax)
leaq 0x679ed(%rip), %rdi     # 0xb50b0
pushq $0x4
popq %rsi
callq 0x39e29
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x39072
movq %r15, %rdi
callq 0x3a265
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x39072
movq %r14, %rdi
callq 0x3a265
jmp 0x4d5cd
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hgetCommand
void hgetCommand(client *c) {
    robj *o;

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

    addHashFieldToReply(c, o, c->argv[2]);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x8(%rax), %rsi
leaq 0xacbfc(%rip), %rax     # 0xfa310
movq 0x50(%rax), %rdx
callq 0x3aee5
testq %rax, %rax
je 0x4d737
movq %rax, %r14
pushq $0x4
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3a311
testl %eax, %eax
je 0x4d73f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4d756
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: addHashFieldToReply
static void addHashFieldToReply(client *c, robj *o, robj *field) {
    int ret;

    if (o == NULL) {
        addReply(c, shared.nullbulk);
        return;
    }

    if (o->encoding == OBJ_ENCODING_ZIPLIST) {
        unsigned char *vstr = NULL;
        unsigned int vlen = UINT_MAX;
        long long vll = LLONG_MAX;

        ret = hashTypeGetFromZiplist(o, field, &vstr, &vlen, &vll);
        if (ret < 0) {
            addReply(c, shared.nullbulk);
        } else {
            if (vstr) {
                addReplyBulkCBuffer(c, vstr, vlen);
            } else {
                addReplyBulkLongLong(c, vll);
            }
        }

    } else if (o->encoding == OBJ_ENCODING_HT) {
        robj *value;

        ret = hashTypeGetFromHashTable(o, field, &value);
        if (ret < 0) {
            addReply(c, shared.nullbulk);
        } else {
            addReplyBulk(c, value);
        }

    } else {
        serverPanic("Unknown hash encoding");
    }
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x4d7c6
movl (%rsi), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x2, %eax
je 0x4d7de
cmpl $0x5, %eax
jne 0x4d82c
leaq 0x8(%rsp), %rax
andq $0x0, (%rax)
leaq 0x14(%rsp), %rcx
orl $-0x1, (%rcx)
movabsq $0x7fffffffffffffff, %rdi # imm = 0x7FFFFFFFFFFFFFFF
leaq 0x18(%rsp), %r8
movq %rdi, (%r8)
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x4c6ff
testl %eax, %eax
js 0x4d804
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x4d819
movl 0x14(%rsp), %edx
movq %rbx, %rdi
callq 0x3716c
jmp 0x4d826
leaq 0xacb43(%rip), %rax     # 0xfa310
movq 0x50(%rax), %rsi
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x36987
leaq 0x8(%rsp), %rax
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x4c7fc
testl %eax, %eax
js 0x4d804
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x36fd9
jmp 0x4d826
leaq 0xacb05(%rip), %rax     # 0xfa310
movq 0x50(%rax), %rsi
movq %rbx, %rdi
callq 0x36987
jmp 0x4d826
movq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x37206
addq $0x20, %rsp
popq %rbx
retq
leaq 0x6690e(%rip), %rdi     # 0xb4141
leaq 0x6774a(%rip), %rsi     # 0xb4f84
movl $0x283, %edx            # imm = 0x283
callq 0x57b45
pushq $0x1
popq %rdi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hmgetCommand
void hmgetCommand(client *c) {
    robj *o;
    int i;

    /* Don't abort when the key cannot be found. Non-existing keys are empty
     * hashes, where HMGET should respond with a series of null bulks. */
    o = lookupKeyRead(c->db, c->argv[1]);
    if (o != NULL && o->type != OBJ_HASH) {
        addReply(c, shared.wrongtypeerr);
        return;
    }

    addReplyMultiBulkLen(c, c->argc-2);
    for (i = 2; i < c->argc; i++) {
        addHashFieldToReply(c, o, c->argv[i]);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x3aebb
movq %rax, %r14
testq %rax, %rax
je 0x4d878
movl (%r14), %eax
andl $0xf, %eax
cmpl $0x4, %eax
jne 0x4d8b3
movslq 0x38(%rbx), %rsi
addq $-0x2, %rsi
movq %rbx, %rdi
callq 0x370d9
pushq $0x2
popq %r15
movslq 0x38(%rbx), %rax
cmpq %rax, %r15
jge 0x4d8ad
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4d756
incq %r15
jmp 0x4d88c
popq %rbx
popq %r14
popq %r15
retq
leaq 0xaca56(%rip), %rax     # 0xfa310
movq 0x70(%rax), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x36987
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hdelCommand
void hdelCommand(client *c) {
    robj *o;
    int j, deleted = 0, keyremoved = 0;

    if ((o = lookupKeyWriteOrReply(c,c->argv[1],shared.czero)) == NULL ||
        checkType(c,o,OBJ_HASH)) return;

    for (j = 2; j < c->argc; j++) {
        if (hashTypeDelete(o,c->argv[j])) {
            deleted++;
            if (hashTypeLength(o) == 0) {
                dbDelete(c->db,c->argv[1]);
                keyremoved = 1;
                break;
            }
        }
    }
    if (deleted) {
        signalModifiedKey(c->db,c->argv[1]);
        notifyKeyspaceEvent(NOTIFY_HASH,"hdel",c->argv[1],c->db->id);
        if (keyremoved)
            notifyKeyspaceEvent(NOTIFY_GENERIC,"del",c->argv[1],
                                c->db->id);
        server.dirty += deleted;
    }
    addReplyLongLong(c,deleted);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x8(%rax), %rsi
leaq 0xaca2b(%rip), %rax     # 0xfa310
movq 0x20(%rax), %rdx
callq 0x3af15
testq %rax, %rax
je 0x4d908
movq %rax, %r14
pushq $0x4
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3a311
testl %eax, %eax
je 0x4d911
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
pushq $0x2
popq %r15
movslq 0x38(%rbx), %r12
cmpq %r12, %r15
jge 0x4d959
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x4cc2f
testl %eax, %eax
je 0x4d943
incl %ebp
movq %r14, %rdi
callq 0x4cbe1
testq %rax, %rax
je 0x4d948
incq %r15
jmp 0x4d917
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x3b1df
testl %ebp, %ebp
je 0x4d9c2
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x3b125
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x8(%rcx), %rdx
movl 0x30(%rax), %ecx
leaq 0x60d06(%rip), %rsi     # 0xae68a
pushq $0x40
popq %rdi
callq 0x6fb58
cmpq %r12, %r15
jge 0x4d9af
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x8(%rcx), %rdx
movl 0x30(%rax), %ecx
leaq 0x62a71(%rip), %rsi     # 0xb0418
pushq $0x4
popq %rdi
callq 0x6fb58
movslq %ebp, %rsi
leaq 0xabeef(%rip), %rax     # 0xf98a8
addq %rsi, 0x720(%rax)
jmp 0x4d9c4
xorl %esi, %esi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x370a6
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hlenCommand
void hlenCommand(client *c) {
    robj *o;

    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL ||
        checkType(c,o,OBJ_HASH)) return;

    addReplyLongLong(c,hashTypeLength(o));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x8(%rax), %rsi
leaq 0xac926(%rip), %rax     # 0xfa310
movq 0x20(%rax), %rdx
callq 0x3aee5
testq %rax, %rax
je 0x4da0d
movq %rax, %r14
pushq $0x4
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3a311
testl %eax, %eax
je 0x4da15
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x4cbe1
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x370a6