LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x5, %eax
jne 0x66d8d
movq -0x10(%rbp), %rdi
callq 0x494f0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x41120
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x66d82
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x66320
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl %eax, %edx
movl $0x1, %ecx
callq 0x41710
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x66d80
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x41570
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x41570
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x14(%rbp)
jmp 0x66d82
movq -0x10(%rbp), %rdi
callq 0x48f70
jmp 0x66e02
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x2, %eax
jne 0x66dde
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2de50
cmpl $0x0, %eax
jne 0x66ddc
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x30420
cmpl $0x0, %eax
je 0x66dda
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2d3e0
jmp 0x66ddc
jmp 0x66e00
leaq 0xd642f(%rip), %rdi     # 0x13d214
leaq 0xd7290(%rip), %rsi     # 0x13e07c
movl $0x115, %edx            # imm = 0x115
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x66e02
movl -0x14(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x30, %edi
callq 0x3acd0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
shrl $0x4, %ecx
andl $0xf, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpl $0x5, 0x8(%rax)
jne 0x66e6c
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
jmp 0x66eb4
movq -0x10(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x66e90
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2e400
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x66eb2
leaq 0xd637d(%rip), %rdi     # 0x13d214
leaq 0xd71de(%rip), %rsi     # 0x13e07c
movl $0x135, %edx            # imm = 0x135
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x66eb4
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x5, 0x8(%rax)
jne 0x67029
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x66f84
cmpq $0x0, -0x28(%rbp)
jne 0x66f51
jmp 0x66f73
leaq 0xd715d(%rip), %rdi     # 0x13e0b5
leaq 0xd711d(%rip), %rsi     # 0x13e07c
movl $0x150, %edx            # imm = 0x150
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x41120
movq %rax, -0x20(%rbp)
jmp 0x66fc0
cmpq $0x0, -0x28(%rbp)
je 0x66f8d
jmp 0x66faf
leaq 0xd70f1(%rip), %rdi     # 0x13e085
leaq 0xd70e1(%rip), %rsi     # 0x13e07c
movl $0x154, %edx            # imm = 0x154
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x412e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x66fd3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x67084
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x412e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x66fed
jmp 0x6700f
leaq 0xd7091(%rip), %rdi     # 0x13e085
leaq 0xd7081(%rip), %rsi     # 0x13e07c
movl $0x15b, %edx            # imm = 0x15B
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x6707d
movq -0x10(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x67059
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2e4a0
movq -0x10(%rbp), %rcx
movq %rax, 0x28(%rcx)
cmpq $0x0, %rax
jne 0x67057
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x67084
jmp 0x6707b
leaq 0xd61b4(%rip), %rdi     # 0x13d214
leaq 0xd7015(%rip), %rsi     # 0x13e07c
movl $0x163, %edx            # imm = 0x163
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x6707d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x5, 0x8(%rax)
jne 0x670b7
jmp 0x670d9
leaq 0xd7004(%rip), %rdi     # 0x13e0c2
leaq 0xd6fb7(%rip), %rsi     # 0x13e07c
movl $0x171, %edx            # imm = 0x171
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x6712c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x41470
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x67108
jmp 0x6712a
leaq 0xd6f83(%rip), %rdi     # 0x13e092
leaq 0xd6f66(%rip), %rsi     # 0x13e07c
movl $0x175, %edx            # imm = 0x175
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
jmp 0x67174
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x41470
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x67150
jmp 0x67172
leaq 0xd6f3b(%rip), %rdi     # 0x13e092
leaq 0xd6f1e(%rip), %rsi     # 0x13e07c
movl $0x178, %edx            # imm = 0x178
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
jmp 0x67174
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x6719f
jmp 0x671c1
leaq 0xd6f41(%rip), %rdi     # 0x13e0e7
leaq 0xd6ecf(%rip), %rsi     # 0x13e07c
movl $0x17f, %edx            # imm = 0x17F
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x671e0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x671f3
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x5, 0x8(%rax)
jne 0x67278
movq $0x0, -0x20(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x20(%rbp), %rdx
leaq -0x24(%rbp), %rcx
leaq -0x30(%rbp), %r8
callq 0x67090
cmpq $0x0, -0x20(%rbp)
je 0x67269
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x486a0
movq %rax, -0x18(%rbp)
jmp 0x67276
movq -0x30(%rbp), %rdi
callq 0x486f0
movq %rax, -0x18(%rbp)
jmp 0x672c1
movq -0x8(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x6729d
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x18(%rbp), %rdx
callq 0x67180
movq -0x18(%rbp), %rdi
callq 0x487b0
jmp 0x672bf
leaq 0xd5f70(%rip), %rdi     # 0x13d214
leaq 0xd6dd1(%rip), %rsi     # 0x13e07c
movl $0x19d, %edx            # imm = 0x19D
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x672c1
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4a6f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6731c
callq 0x48c50
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4a7d0
jmp 0x6734a
movq -0x20(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x4, %eax
je 0x67348
movq -0x10(%rbp), %rdi
leaq 0x11190b(%rip), %rax    # 0x178c40
movq 0x70(%rax), %rsi
callq 0x42cc0
movq $0x0, -0x8(%rbp)
jmp 0x67352
jmp 0x6734a
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x672d0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x67540
jmp 0x6763c
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
movl $0x2, %edx
movl $0x3, %ecx
callq 0x66260
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
addq $0x10, %rsi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdx
addq $0x18, %rdx
callq 0x66440
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x18(%rax), %rdx
callq 0x66980
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x675bf
leaq 0x11168b(%rip), %rax    # 0x178c40
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x675ce
leaq 0x11167a(%rip), %rax    # 0x178c40
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x42cc0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x4aa60
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x30(%rax), %ecx
movl $0x40, %edi
leaq 0xd00c1(%rip), %rsi     # 0x1376d8
callq 0x9ce20
leaq 0x110bb5(%rip), %rax    # 0x1781d8
movq 0x720(%rax), %rcx
addq $0x1, %rcx
leaq 0x110ba3(%rip), %rax    # 0x1781d8
movq %rcx, 0x720(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x672d0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x67680
jmp 0x67785
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
movl $0x2, %edx
movl $0x3, %ecx
callq 0x66260
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x668b0
cmpl $0x0, %eax
je 0x676ce
movq -0x8(%rbp), %rdi
leaq 0x111580(%rip), %rax    # 0x178c40
movq 0x20(%rax), %rsi
callq 0x42cc0
jmp 0x67785
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
addq $0x10, %rsi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdx
addq $0x18, %rdx
callq 0x66440
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x18(%rax), %rdx
callq 0x66980
movq -0x8(%rbp), %rdi
leaq 0x111525(%rip), %rax    # 0x178c40
movq 0x28(%rax), %rsi
callq 0x42cc0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x4aa60
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x30(%rax), %ecx
movl $0x40, %edi
leaq 0xcff78(%rip), %rsi     # 0x1376d8
callq 0x9ce20
leaq 0x110a6c(%rip), %rax    # 0x1781d8
movq 0x720(%rax), %rcx
addq $0x1, %rcx
leaq 0x110a5a(%rip), %rax    # 0x1781d8
movq %rcx, 0x720(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x1, %edx
jne 0x677c5
movq -0x8(%rbp), %rdi
leaq 0xd698c(%rip), %rsi     # 0x13e147
callq 0x42f90
jmp 0x678fd
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x672d0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x677e9
jmp 0x678fd
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
subl $0x1, %ecx
movl $0x2, %edx
callq 0x66260
movl $0x2, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x67888
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
movslq -0xc(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdx
movl -0xc(%rbp), %eax
addl $0x1, %eax
cltq
shlq $0x3, %rax
addq %rax, %rdx
callq 0x66440
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
callq 0x66980
movl -0xc(%rbp), %eax
addl $0x2, %eax
movl %eax, -0xc(%rbp)
jmp 0x67810
movq -0x8(%rbp), %rdi
leaq 0x1113ad(%rip), %rax    # 0x178c40
movq 0x8(%rax), %rsi
callq 0x42cc0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x4aa60
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x30(%rax), %ecx
movl $0x40, %edi
leaq 0xcfe00(%rip), %rsi     # 0x1376d8
callq 0x9ce20
leaq 0x1108f4(%rip), %rax    # 0x1781d8
movq 0x720(%rax), %rcx
addq $0x1, %rcx
leaq 0x1108e2(%rip), %rax    # 0x1781d8
movq %rcx, 0x720(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x110f5d(%rip), %rax    # 0x178c40
movq 0x50(%rax), %rdx
callq 0x4a730
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x67d0d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0x67d0f
jmp 0x67d28
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rdx
callq 0x67d30
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x67d64
movq -0x8(%rbp), %rdi
leaq 0x110eea(%rip), %rax    # 0x178c40
movq 0x50(%rax), %rsi
callq 0x42cc0
jmp 0x67e6e
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x5, %eax
jne 0x67dfa
movq $0x0, -0x28(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
leaq -0x38(%rbp), %r8
callq 0x664b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x67dce
movq -0x8(%rbp), %rdi
leaq 0x110e7d(%rip), %rax    # 0x178c40
movq 0x50(%rax), %rsi
callq 0x42cc0
jmp 0x67df8
cmpq $0x0, -0x28(%rbp)
je 0x67de9
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %eax
movl %eax, %edx
callq 0x43920
jmp 0x67df6
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x439f0
jmp 0x67df8
jmp 0x67e6e
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x2, %eax
jne 0x67e4a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x66630
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x67e3b
movq -0x8(%rbp), %rdi
leaq 0x110e10(%rip), %rax    # 0x178c40
movq 0x50(%rax), %rsi
callq 0x42cc0
jmp 0x67e48
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x43630
jmp 0x67e6c
leaq 0xd53c3(%rip), %rdi     # 0x13d214
leaq 0xd6224(%rip), %rsi     # 0x13e07c
movl $0x283, %edx            # imm = 0x283
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x67e6e
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x4a6c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x67ed4
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x4, %eax
je 0x67ed4
movq -0x8(%rbp), %rdi
leaq 0x110d77(%rip), %rax    # 0x178c40
movq 0x70(%rax), %rsi
callq 0x42cc0
jmp 0x67f25
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
subl $0x2, %eax
movslq %eax, %rsi
callq 0x437f0
movl $0x2, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x67f25
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x67d30
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x67ef1
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x110cdf(%rip), %rax    # 0x178c40
movq 0x20(%rax), %rdx
callq 0x4a780
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x67f8b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0x67f90
jmp 0x680b0
movl $0x2, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x6800a
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x66cb0
cmpl $0x0, %eax
je 0x67ffd
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x66c10
cmpq $0x0, %rax
jne 0x67ffb
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x4ac10
movl $0x1, -0x1c(%rbp)
jmp 0x6800a
jmp 0x67ffd
jmp 0x67fff
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x67f97
cmpl $0x0, -0x18(%rbp)
je 0x680a3
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x4aa60
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x30(%rax), %ecx
movl $0x40, %edi
leaq 0xcf6ba(%rip), %rsi     # 0x13770a
callq 0x9ce20
cmpl $0x0, -0x1c(%rbp)
je 0x68083
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x30(%rax), %ecx
movl $0x4, %edi
leaq 0xd141a(%rip), %rsi     # 0x139498
callq 0x9ce20
movslq -0x18(%rbp), %rcx
leaq 0x11014a(%rip), %rax    # 0x1781d8
addq 0x720(%rax), %rcx
leaq 0x11013c(%rip), %rax    # 0x1781d8
movq %rcx, 0x720(%rax)
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x43780
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x110b5d(%rip), %rax    # 0x178c40
movq 0x20(%rax), %rdx
callq 0x4a730
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x6810d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0x6810f
jmp 0x6812c
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x66c10
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x43780
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hstrlenCommand
void hstrlenCommand(client *c) {
    robj *o;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x110add(%rip), %rax    # 0x178c40
movq 0x20(%rax), %rdx
callq 0x4a730
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x6818d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0x6818f
jmp 0x681b8
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x667c0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x43780
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: genericHgetallCommand
void genericHgetallCommand(client *c, int flags) {
    robj *o;
    hashTypeIterator *hi;
    int multiplier = 0;
    int length, count = 0;

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

    if (flags & OBJ_HASH_KEY) multiplier++;
    if (flags & OBJ_HASH_VALUE) multiplier++;

    length = hashTypeLength(o) * multiplier;
    addReplyMultiBulkLen(c, length);

    hi = hashTypeInitIterator(o);
    while (hashTypeNext(hi) != C_ERR) {
        if (flags & OBJ_HASH_KEY) {
            addHashIteratorCursorToReply(c, hi, OBJ_HASH_KEY);
            count++;
        }
        if (flags & OBJ_HASH_VALUE) {
            addHashIteratorCursorToReply(c, hi, OBJ_HASH_VALUE);
            count++;
        }
    }

    hashTypeReleaseIterator(hi);
    serverAssert(count == length);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x110a4c(%rip), %rax    # 0x178c40
movq 0x68(%rax), %rdx
callq 0x4a730
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x6821e
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0x68223
jmp 0x6830a
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x68237
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x6824b
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x66c10
movslq -0x24(%rbp), %rcx
imulq %rcx, %rax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x437f0
movq -0x18(%rbp), %rdi
callq 0x66e10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x66f00
cmpl $-0x1, %eax
je 0x682d5
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x682ad
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x68310
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x682d3
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x2, %edx
callq 0x68310
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x68279
movq -0x20(%rbp), %rdi
callq 0x66ec0
movl -0x2c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jne 0x682e8
jmp 0x6830a
leaq 0xd5ebe(%rip), %rdi     # 0x13e1ad
leaq 0xd5d86(%rip), %rsi     # 0x13e07c
movl $0x303, %edx            # imm = 0x303
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: addHashIteratorCursorToReply
static void addHashIteratorCursorToReply(client *c, hashTypeIterator *hi, int what) {
    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) {
            addReplyBulkCBuffer(c, vstr, vlen);
        } else {
            addReplyBulkLongLong(c, vll);
        }

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

        hashTypeCurrentFromHashTable(hi, what, &value);
        addReplyBulk(c, value);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x5, 0x8(%rax)
jne 0x6838c
movq $0x0, -0x20(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x20(%rbp), %rdx
leaq -0x24(%rbp), %rcx
leaq -0x30(%rbp), %r8
callq 0x67090
cmpq $0x0, -0x20(%rbp)
je 0x6837d
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %eax
movl %eax, %edx
callq 0x43920
jmp 0x6838a
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x439f0
jmp 0x683d9
movq -0x10(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x683b5
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x38(%rbp), %rdx
callq 0x67180
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x43630
jmp 0x683d7
leaq 0xd4e58(%rip), %rdi     # 0x13d214
leaq 0xd5cb9(%rip), %rsi     # 0x13e07c
movl $0x2e3, %edx            # imm = 0x2E3
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
jmp 0x683d9
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hexistsCommand
void hexistsCommand(client *c) {
    robj *o;
    if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL ||
        checkType(c,o,OBJ_HASH)) return;

    addReply(c, hashTypeExists(o,c->argv[2]) ? shared.cone : shared.czero);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x1107dd(%rip), %rax    # 0x178c40
movq 0x20(%rax), %rdx
callq 0x4a730
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x6848d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0x6848f
jmp 0x684de
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x668b0
cmpl $0x0, %eax
je 0x684c2
leaq 0x110788(%rip), %rax    # 0x178c40
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x684d1
leaq 0x110777(%rip), %rax    # 0x178c40
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x42cc0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/t_hash.c
// Function: hscanCommand
void hscanCommand(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_HASH)) return;
    scanGenericCommand(c,o,cursor);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rsi
leaq -0x18(%rbp), %rdx
callq 0x4b690
cmpl $-0x1, %eax
jne 0x6851c
jmp 0x68573
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x11070d(%rip), %rax    # 0x178c40
movq 0x148(%rax), %rdx
callq 0x4a730
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x68560
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0x68562
jmp 0x68573
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4b740
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/config.c
// Function: configEnumGetValue
int configEnumGetValue(configEnum *ce, char *name) {
    while(ce->name != NULL) {
        if (!strcasecmp(ce->name,name)) return ce->val;
        ce++;
    }
    return INT_MIN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x685c9
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x26300
cmpl $0x0, %eax
jne 0x685bb
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x685d0
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0x68590
movl $0x80000000, -0x4(%rbp) # imm = 0x80000000
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/config.c
// Function: configEnumGetName
const char *configEnumGetName(configEnum *ce, int val) {
    while(ce->name != NULL) {
        if (ce->val == val) return ce->name;
        ce++;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6861c
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x6860e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x68624
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0x685eb
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/config.c
// Function: appendServerSaveParams
void appendServerSaveParams(time_t seconds, int changes) {
    server.saveparams = zrealloc(server.saveparams,sizeof(struct saveparam)*(server.saveparamslen+1));
    server.saveparams[server.saveparamslen].seconds = seconds;
    server.saveparams[server.saveparamslen].changes = changes;
    server.saveparamslen++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x10fac2(%rip), %rax    # 0x1781d8
movq 0x738(%rax), %rdi
leaq 0x10fab4(%rip), %rax    # 0x1781d8
movl 0x740(%rax), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x4, %rsi
callq 0x3ae40
movq %rax, %rcx
leaq 0x10fa95(%rip), %rax    # 0x1781d8
movq %rcx, 0x738(%rax)
movq -0x8(%rbp), %rcx
leaq 0x10fa83(%rip), %rax    # 0x1781d8
movq 0x738(%rax), %rax
leaq 0x10fa75(%rip), %rdx    # 0x1781d8
movslq 0x740(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
leaq 0x10fa5a(%rip), %rax    # 0x1781d8
movq 0x738(%rax), %rax
leaq 0x10fa4c(%rip), %rdx    # 0x1781d8
movslq 0x740(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
leaq 0x10fa34(%rip), %rax    # 0x1781d8
movl 0x740(%rax), %ecx
addl $0x1, %ecx
leaq 0x10fa24(%rip), %rax    # 0x1781d8
movl %ecx, 0x740(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/config.c
// Function: loadServerConfig
void loadServerConfig(char *filename, char *options) {
    sds config = sdsempty();
    char buf[CONFIG_MAX_LINE+1];

    /* Load the file content */
    if (filename) {
        FILE *fp;

        if (filename[0] == '-' && filename[1] == '\0') {
            fp = stdin;
        } else {
            if ((fp = fopen(filename,"r")) == NULL) {
                serverLog(LL_WARNING,
                    "Fatal error, can't open config file '%s'", filename);
                exit(1);
            }
        }
        while(fgets(buf,CONFIG_MAX_LINE+1,fp) != NULL)
            config = sdscat(config,buf);
        if (fp != stdin) fclose(fp);
    }
    /* Append the additional options */
    if (options) {
        config = sdscat(config,"\n");
        config = sdscat(config,options);
    }
    loadServerConfigFromString(config);
    sdsfree(config);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x384f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6a91a
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x6a883
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x6a883
movq 0x108761(%rip), %rax    # 0x172fd8
movq (%rax), %rax
movq %rax, -0x428(%rbp)
jmp 0x6a8c3
movq -0x8(%rbp), %rdi
leaq 0xcff3b(%rip), %rsi     # 0x13a7c9
callq 0x26ae0
movq %rax, -0x428(%rbp)
cmpq $0x0, %rax
jne 0x6a8c1
movq -0x8(%rbp), %rdx
movl $0x3, %edi
leaq 0xd45ff(%rip), %rsi     # 0x13eeaf
movb $0x0, %al
callq 0x2fc60
movl $0x1, %edi
callq 0x262d0
jmp 0x6a8c3
jmp 0x6a8c5
leaq -0x420(%rbp), %rdi
movq -0x428(%rbp), %rdx
movl $0x401, %esi            # imm = 0x401
callq 0x26440
cmpq $0x0, %rax
je 0x6a8f9
movq -0x18(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x390d0
movq %rax, -0x18(%rbp)
jmp 0x6a8c5
movq -0x428(%rbp), %rax
movq 0x1086d1(%rip), %rcx    # 0x172fd8
cmpq (%rcx), %rax
je 0x6a918
movq -0x428(%rbp), %rdi
callq 0x26a10
jmp 0x6a91a
cmpq $0x0, -0x10(%rbp)
je 0x6a946
movq -0x18(%rbp), %rdi
leaq 0xcf50d(%rip), %rsi     # 0x139e39
callq 0x390d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x390d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x68800
movq -0x18(%rbp), %rdi
callq 0x38620
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/config.c
// Function: rewriteConfigAddLineNumberToOption
void rewriteConfigAddLineNumberToOption(struct rewriteConfigState *state, sds option, int linenum) {
    list *l = dictFetchValue(state->option_to_line,option);

    if (l == NULL) {
        l = listCreate();
        dictAdd(state->option_to_line,sdsdup(option),l);
    }
    listAddNodeTail(l,(void*)(long)linenum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2e280
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6e7cb
callq 0x26e20
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x38560
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x2d8c0
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x27000
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/config.c
// Function: rewriteConfigRewriteLine
void rewriteConfigRewriteLine(struct rewriteConfigState *state, const char *option, sds line, int force) {
    sds o = sdsnew(option);
    list *l = dictFetchValue(state->option_to_line,o);

    rewriteConfigMarkAsProcessed(state,option);

    if (!l && !force) {
        /* Option not used previously, and we are not forced to use it. */
        sdsfree(line);
        sdsfree(o);
        return;
    }

    if (l) {
        listNode *ln = listFirst(l);
        int linenum = (long) ln->value;

        /* There are still lines in the old configuration file we can reuse
         * for this option. Replace the line with the new one. */
        listDelNode(l,ln);
        if (listLength(l) == 0) dictDelete(state->option_to_line,o);
        sdsfree(state->lines[linenum]);
        state->lines[linenum] = line;
    } else {
        /* Append a new line. */
        if (!state->has_tail) {
            rewriteConfigAppendLine(state,
                sdsnew(REDIS_CONFIG_REWRITE_SIGNATURE));
            state->has_tail = 1;
        }
        rewriteConfigAppendLine(state,line);
    }
    sdsfree(o);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x38510
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x2e280
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6e7e0
cmpq $0x0, -0x30(%rbp)
jne 0x6eaf9
cmpl $0x0, -0x1c(%rbp)
jne 0x6eaf9
movq -0x18(%rbp), %rdi
callq 0x38620
movq -0x28(%rbp), %rdi
callq 0x38620
jmp 0x6ebb4
cmpq $0x0, -0x30(%rbp)
je 0x6eb69
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x271e0
movq -0x30(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x6eb3e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x2de50
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x38620
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x3c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x6ebab
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x6eb9e
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0xd05c9(%rip), %rdi     # 0x13f14b
callq 0x38510
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x6e700
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6e700
movq -0x28(%rbp), %rdi
callq 0x38620
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/config.c
// Function: rewriteConfigFormatMemory
int rewriteConfigFormatMemory(char *buf, size_t len, long long bytes) {
    int gb = 1024*1024*1024;
    int mb = 1024*1024;
    int kb = 1024;

    if (bytes && (bytes % gb) == 0) {
        return snprintf(buf,len,"%lldgb",bytes/gb);
    } else if (bytes && (bytes % mb) == 0) {
        return snprintf(buf,len,"%lldmb",bytes/mb);
    } else if (bytes && (bytes % kb) == 0) {
        return snprintf(buf,len,"%lldkb",bytes/kb);
    } else {
        return snprintf(buf,len,"%lld",bytes);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x40000000, -0x24(%rbp) # imm = 0x40000000
movl $0x100000, -0x28(%rbp)  # imm = 0x100000
movl $0x400, -0x2c(%rbp)     # imm = 0x400
cmpq $0x0, -0x20(%rbp)
je 0x6ec31
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x6ec31
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
cqto
idivq %rcx
movq %rax, %rcx
leaq 0xd054e(%rip), %rdx     # 0x13f170
movb $0x0, %al
callq 0x26120
movl %eax, -0x4(%rbp)
jmp 0x6ecd8
cmpq $0x0, -0x20(%rbp)
je 0x6ec76
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x6ec76
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
cqto
idivq %rcx
movq %rax, %rcx
leaq 0xd050d(%rip), %rdx     # 0x13f177
movb $0x0, %al
callq 0x26120
movl %eax, -0x4(%rbp)
jmp 0x6ecd8
cmpq $0x0, -0x20(%rbp)
je 0x6ecbb
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x6ecbb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
cqto
idivq %rcx
movq %rax, %rcx
leaq 0xd04cf(%rip), %rdx     # 0x13f17e
movb $0x0, %al
callq 0x26120
movl %eax, -0x4(%rbp)
jmp 0x6ecd8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq 0xd41bb(%rip), %rdx     # 0x142e89
movb $0x0, %al
callq 0x26120
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)