LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x55f5f
testq %rax, %rax
je 0x56292
movq %rax, %r14
movq 0x40(%rbx), %rsi
movq %rax, %rdi
movl $0x2, %edx
movl $0x3, %ecx
callq 0x553ec
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x557f5
testl %eax, %eax
je 0x56218
leaq 0xac10b(%rip), %rax     # 0x102310
movq 0x20(%rax), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3c854
movq 0x40(%rbx), %rdx
leaq 0x10(%rdx), %rsi
addq $0x18, %rdx
movq %r14, %rdi
callq 0x554dc
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
movq %r14, %rdi
callq 0x55875
leaq 0xac0c9(%rip), %rax     # 0x102310
movq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x3c854
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x41d90
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x8(%rcx), %rdx
movl 0x30(%rax), %ecx
leaq 0x664ee(%rip), %rsi     # 0xbc768
movl $0x40, %edi
callq 0x7c665
leaq 0xab61d(%rip), %rax     # 0x1018a8
incq 0x720(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x80000001, %eax       # imm = 0x80000001
andl 0x38(%rdi), %eax
cmpl $0x1, %eax
jne 0x562ca
leaq 0x6d993(%rip), %rsi     # 0xc3c4b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3cc06
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x55f5f
testq %rax, %rax
je 0x56397
movq %rax, %r14
movq 0x40(%rbx), %rsi
movl 0x38(%rbx), %ecx
decl %ecx
movl $0x2, %ebp
movq %rax, %rdi
movl $0x2, %edx
callq 0x553ec
cmpl $0x3, 0x38(%rbx)
jl 0x56345
movl $0x18, %r15d
movq 0x40(%rbx), %rdx
leaq (%rdx,%r15), %rsi
addq $-0x8, %rsi
addq %r15, %rdx
movq %r14, %rdi
callq 0x554dc
movq 0x40(%rbx), %rax
movq -0x8(%rax,%r15), %rsi
movq (%rax,%r15), %rdx
movq %r14, %rdi
callq 0x55875
addq $0x10, %r15
addl $0x2, %ebp
cmpl %ebp, 0x38(%rbx)
jg 0x5630d
leaq 0xabfc4(%rip), %rax     # 0x102310
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x3c854
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x41d90
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x8(%rcx), %rdx
movl 0x30(%rax), %ecx
leaq 0x663e9(%rip), %rsi     # 0xbc768
movl $0x40, %edi
callq 0x7c665
leaq 0xab518(%rip), %rax     # 0x1018a8
incq 0x720(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x18(%rax), %rsi
leaq 0x8(%rsp), %rdx
xorl %ecx, %ecx
callq 0x416bb
testl %eax, %eax
je 0x563d6
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x55f5f
testq %rax, %rax
je 0x563c9
movq %rax, %r14
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x5569d
testq %rax, %rax
je 0x5642f
movq %rax, %r15
leaq 0x6d862(%rip), %rcx     # 0xc3c6f
movq %rsp, %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x416bb
movl %eax, %ebp
movq %r15, %rdi
callq 0x40c8f
testl %ebp, %ebp
jne 0x563c9
movq (%rsp), %rax
jmp 0x56439
movq $0x0, (%rsp)
xorl %eax, %eax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
movq 0x8(%rsp), %rdi
subq %rax, %rcx
testq %rdi, %rdi
jns 0x5645e
testq %rax, %rax
jns 0x5645e
leaq 0x1(%rcx), %rdx
cmpq %rdx, %rdi
jl 0x5647c
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 0x56490
leaq 0x6cded(%rip), %rsi     # 0xc3270
movq %rbx, %rdi
callq 0x3cc06
jmp 0x563c9
addq %rax, %rdi
movq %rdi, (%rsp)
callq 0x40753
movq %rax, %r15
movl $0xf0, %eax
andl (%r14), %eax
cmpl $0x20, %eax
jne 0x564bf
movq 0x40(%rbx), %r12
movq 0x10(%r12), %rdi
callq 0x40e09
movq %rax, 0x10(%r12)
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x55875
movq %r15, %rdi
callq 0x40c8f
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x3d23f
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x41d90
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x8(%rcx), %rdx
movl 0x30(%rax), %ecx
leaq 0x66278(%rip), %rsi     # 0xbc785
movl $0x40, %edi
callq 0x7c665
leaq 0xab38a(%rip), %rax     # 0x1018a8
incq 0x720(%rax)
jmp 0x563c9
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x18(%rax), %rsi
leaq 0x20(%rsp), %rdx
xorl %ecx, %ecx
callq 0x41571
testl %eax, %eax
je 0x5655e
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x55f5f
testq %rax, %rax
je 0x56551
movq %rax, %r15
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rsi
movq %r15, %rdi
callq 0x5569d
fldz
testq %rax, %rax
je 0x565bb
movq %rax, %r14
fstp %st(0)
leaq 0x6d6f3(%rip), %rcx     # 0xc3c8c
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x41571
movl %eax, %ebp
movq %r14, %rdi
callq 0x40c8f
testl %ebp, %ebp
jne 0x56551
fldt 0x10(%rsp)
fldt 0x20(%rsp)
faddp %st, %st(1)
fld %st(0)
fstpt 0x10(%rsp)
fstpt (%rsp)
movl $0x1, %edi
callq 0x407ac
movq %rax, %r14
movl $0xf0, %eax
andl (%r15), %eax
cmpl $0x20, %eax
jne 0x565f7
movq 0x40(%rbx), %r12
movq 0x10(%r12), %rdi
callq 0x40e09
movq %rax, 0x10(%r12)
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x55875
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3d170
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x41d90
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x8(%rcx), %rdx
movl 0x30(%rax), %ecx
leaq 0x66151(%rip), %rsi     # 0xbc78d
movl $0x40, %edi
callq 0x7c665
leaq 0xab25b(%rip), %rax     # 0x1018a8
incq 0x720(%rax)
leaq 0x6d651(%rip), %rdi     # 0xc3cac
movl $0x4, %esi
callq 0x40744
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x3f7dc
movq %r15, %rdi
callq 0x40c8f
movq %rbx, %rdi
movl $0x3, %esi
movq %r14, %rdx
callq 0x3f7dc
movq %r14, %rdi
callq 0x40c8f
jmp 0x56551
// File: /workspace/github_c_makefile_star2_O3/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 0xabc60(%rip), %rax     # 0x102310
movq 0x50(%rax), %rdx
callq 0x41af9
testq %rax, %rax
je 0x566d5
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x4, %edx
callq 0x40d47
testl %eax, %eax
je 0x566dd
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 0x566f4
// File: /workspace/github_c_makefile_star2_O3/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 0x5676a
movl (%rsi), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x2, %eax
je 0x56782
cmpl $0x5, %eax
jne 0x567d0
leaq 0x8(%rsp), %rax
movq $0x0, (%rax)
leaq 0x14(%rsp), %rcx
movl $0xffffffff, (%rcx)     # imm = 0xFFFFFFFF
movabsq $0x7fffffffffffffff, %rdi # imm = 0x7FFFFFFFFFFFFFFF
leaq 0x18(%rsp), %r8
movq %rdi, (%r8)
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x5551a
testl %eax, %eax
js 0x567a8
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x567bd
movl 0x14(%rsp), %edx
movq %rbx, %rdi
callq 0x3d346
jmp 0x567ca
leaq 0xabb9f(%rip), %rax     # 0x102310
movq 0x50(%rax), %rsi
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x3c854
leaq 0x8(%rsp), %rax
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x5564b
testl %eax, %eax
js 0x567a8
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3d170
jmp 0x567ca
leaq 0xabb61(%rip), %rax     # 0x102310
movq 0x50(%rax), %rsi
movq %rbx, %rdi
callq 0x3c854
jmp 0x567ca
movq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x3d415
addq $0x20, %rsp
popq %rbx
retq
leaq 0x6c2aa(%rip), %rdi     # 0xc2a81
leaq 0x6d3a2(%rip), %rsi     # 0xc3b80
movl $0x283, %edx            # imm = 0x283
callq 0x619b4
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/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 0x41acf
movq %rax, %r14
testq %rax, %rax
je 0x5681e
movl (%r14), %eax
andl $0xf, %eax
cmpl $0x4, %eax
jne 0x5685f
movslq 0x38(%rbx), %rsi
addq $-0x2, %rsi
movq %rbx, %rdi
callq 0x3d274
cmpl $0x3, 0x38(%rbx)
jl 0x56859
movl $0x2, %r15d
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x566f4
incq %r15
movslq 0x38(%rbx), %rax
cmpq %rax, %r15
jl 0x5683a
popq %rbx
popq %r14
popq %r15
retq
leaq 0xabaaa(%rip), %rax     # 0x102310
movq 0x70(%rax), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3c854
// File: /workspace/github_c_makefile_star2_O3/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 0xaba7f(%rip), %rax     # 0x102310
movq 0x20(%rax), %rdx
callq 0x41b2b
testq %rax, %rax
je 0x568b6
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
movl $0x4, %edx
callq 0x40d47
testl %eax, %eax
je 0x568bf
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
cmpl $0x3, 0x38(%rbx)
jl 0x5698b
movl $0x2, %r12d
movq 0x40(%rbx), %rax
movq (%rax,%r12,8), %rsi
movq %r15, %rdi
callq 0x55b4a
testl %eax, %eax
je 0x568f6
incl %r14d
movq %r15, %rdi
callq 0x55afa
testq %rax, %rax
je 0x56906
incq %r12
movslq 0x38(%rbx), %rax
cmpq %rax, %r12
jl 0x568d2
xorl %ebp, %ebp
jmp 0x5691a
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x41e5f
movb $0x1, %bpl
testl %r14d, %r14d
je 0x56988
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x41d90
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x8(%rcx), %rdx
movl 0x30(%rax), %ecx
leaq 0x65e54(%rip), %rsi     # 0xbc79a
movl $0x40, %edi
callq 0x7c665
testb %bpl, %bpl
je 0x56975
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x8(%rcx), %rdx
movl 0x30(%rax), %ecx
leaq 0x67bbd(%rip), %rsi     # 0xbe528
movl $0x4, %edi
callq 0x7c665
movslq %r14d, %r14
leaq 0xaaf29(%rip), %rax     # 0x1018a8
addq %r14, 0x720(%rax)
jmp 0x5698b
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3d23f
// File: /workspace/github_c_makefile_star2_O3/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 0xab95c(%rip), %rax     # 0x102310
movq 0x20(%rax), %rdx
callq 0x41af9
testq %rax, %rax
je 0x569d9
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x4, %edx
callq 0x40d47
testl %eax, %eax
je 0x569e1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x55afa
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3d23f
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x8(%rax), %rsi
leaq 0xab8ff(%rip), %rax     # 0x102310
movq 0x20(%rax), %rdx
callq 0x41af9
testq %rax, %rax
je 0x56a36
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x4, %edx
callq 0x40d47
testl %eax, %eax
je 0x56a3e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x55754
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3d23f
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x40(%rdi), %rax
movq 0x8(%rax), %rsi
leaq 0xab891(%rip), %rax     # 0x102310
movq 0x68(%rax), %rdx
callq 0x41af9
testq %rax, %rax
je 0x56b37
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
movl $0x4, %edx
callq 0x40d47
testl %eax, %eax
jne 0x56b37
movl %ebx, %ebp
andl $0x1, %ebp
andl $0x2, %ebx
movl %ebx, %r13d
shrl %r13d
addl %ebp, %r13d
movq %r12, %rdi
callq 0x55afa
movq %rax, %r15
imull %r13d, %r15d
movslq %r15d, %rsi
movq %r14, %rdi
callq 0x3d274
movq %r12, %rdi
callq 0x55c77
movq %rax, %r12
movq %rax, %rdi
callq 0x55d03
xorl %r13d, %r13d
cmpl $-0x1, %eax
je 0x56b2a
testl %ebp, %ebp
je 0x56b09
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x56b68
incl %r13d
testl %ebx, %ebx
je 0x56b20
movq %r14, %rdi
movq %r12, %rsi
movl $0x2, %edx
callq 0x56b68
incl %r13d
movq %r12, %rdi
callq 0x55d03
jmp 0x56aed
movq %r12, %rdi
callq 0x55ce7
cmpl %r15d, %r13d
jne 0x56b46
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6d164(%rip), %rdi     # 0xc3cb1
leaq 0x6d02c(%rip), %rsi     # 0xc3b80
movl $0x303, %edx            # imm = 0x303
callq 0x61908
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x8(%rsi), %eax
cmpl $0x2, %eax
je 0x56bcf
cmpl $0x5, %eax
jne 0x56c03
leaq 0x10(%rsp), %r14
movq $0x0, (%r14)
leaq 0x4(%rsp), %rcx
movl $0xffffffff, (%rcx)     # imm = 0xFFFFFFFF
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
movq %rsi, %rdi
movl %edx, %esi
movq %r14, %rdx
callq 0x55df1
movq (%r14), %rsi
testq %rsi, %rsi
je 0x56bee
movl 0x4(%rsp), %edx
movq %rbx, %rdi
callq 0x3d346
jmp 0x56bfb
leaq 0x10(%rsp), %r14
movq %rsi, %rdi
movl %edx, %esi
movq %r14, %rdx
callq 0x55e78
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3d170
jmp 0x56bfb
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3d415
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x6be77(%rip), %rdi     # 0xc2a81
leaq 0x6cf6f(%rip), %rsi     # 0xc3b80
movl $0x2e3, %edx            # imm = 0x2E3
callq 0x619b4
movl $0x1, %edi
callq 0x263c0
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x8(%rax), %rsi
leaq 0xab6b6(%rip), %r15     # 0x102310
movq 0x20(%r15), %rdx
callq 0x41af9
testq %rax, %rax
je 0x56c7f
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x4, %edx
callq 0x40d47
testl %eax, %eax
je 0x56c85
popq %rbx
popq %r14
popq %r15
retq
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x557f5
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
movq 0x20(%r15,%rcx,8), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3c854
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x10(%rax), %rsi
movq %rsp, %rdx
callq 0x426e3
cmpl $-0x1, %eax
je 0x56d13
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
leaq 0xab637(%rip), %rax     # 0x102310
movq 0x148(%rax), %rdx
movq %rbx, %rdi
callq 0x41af9
testq %rax, %rax
je 0x56d13
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movl $0x4, %edx
callq 0x40d47
testl %eax, %eax
jne 0x56d13
movq (%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42760
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movl $0x80000000, %ebx       # imm = 0x80000000
testq %rdi, %rdi
je 0x56d56
movq %rsi, %r15
addq $0x10, %r14
movq %r15, %rsi
callq 0x262f0
testl %eax, %eax
je 0x56d52
movq (%r14), %rdi
addq $0x10, %r14
testq %rdi, %rdi
jne 0x56d38
jmp 0x56d56
movl -0x8(%r14), %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq (%rdi), %rax
testq %rax, %rax
je 0x56d84
cmpl %esi, 0x8(%rdi)
je 0x56d83
addq $0x18, %rdi
movq -0x8(%rdi), %rax
testq %rax, %rax
je 0x56d84
leaq 0x10(%rdi), %rcx
cmpl %esi, (%rdi)
movq %rcx, %rdi
jne 0x56d6f
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0xaaa55(%rip), %r15     # 0x1018a8
movq 0x738(%r15), %rdi
movslq 0x740(%r15), %rsi
shlq $0x4, %rsi
addq $0x10, %rsi
callq 0x3837d
movq %rax, 0x738(%r15)
movslq 0x740(%r15), %rcx
leal 0x1(%rcx), %edx
shlq $0x4, %rcx
movq %r14, (%rax,%rcx)
movl %ebx, 0x8(%rax,%rcx)
movl %edx, 0x740(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rsi, %rbx
movq %rdi, %r12
callq 0x3628d
movq %rax, %r14
testq %r12, %r12
je 0x585fd
cmpb $0x2d, (%r12)
jne 0x58593
cmpb $0x0, 0x1(%r12)
je 0x5863e
leaq 0x674c3(%rip), %rsi     # 0xbfa5d
movq %r12, %rdi
callq 0x26ae0
movq %rax, %r15
testq %rax, %rax
je 0x5864d
movq %rsp, %rdi
movl $0x401, %esi            # imm = 0x401
movq %r15, %rdx
callq 0x26440
testq %rax, %rax
je 0x585e9
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x36b9c
movq %rax, %r14
movq %r12, %rdi
movl $0x401, %esi            # imm = 0x401
movq %r15, %rdx
callq 0x26440
testq %rax, %rax
jne 0x585c6
movq 0xa4988(%rip), %rax     # 0xfcf78
cmpq (%rax), %r15
je 0x585fd
movq %r15, %rdi
callq 0x26a10
testq %rbx, %rbx
je 0x5861f
leaq 0x668c0(%rip), %rsi     # 0xbeec9
movq %r14, %rdi
callq 0x36b9c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x36b9c
movq %rax, %r14
movq %r14, %rdi
callq 0x56ec3
movq %r14, %rdi
callq 0x36330
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xa4933(%rip), %rax     # 0xfcf78
movq (%rax), %r15
jmp 0x585ae
leaq 0x6c3af(%rip), %rsi     # 0xc4a03
movl $0x3, %edi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2fdad
movl $0x1, %edi
callq 0x262c0
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rdi
callq 0x2ef19
movq %rax, %r14
testq %rax, %rax
jne 0x5b632
callq 0x2b17c
movq %rax, %r14
movq (%r12), %r12
movq %r15, %rdi
callq 0x362e0
movq %r12, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2e9b8
movslq %ebx, %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2b24b
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r15
movq %rsi, %rdi
callq 0x362b0
movq %rax, %r14
movq (%r15), %rdi
movq %rax, %rsi
callq 0x2ef19
movq %rax, %r12
movq %r15, %rdi
movq %r13, %rsi
callq 0x5b648
testq %r12, %r12
setne %al
testl %ebp, %ebp
setne %cl
orb %al, %cl
je 0x5b91f
testq %r12, %r12
je 0x5b929
movq (%r12), %rsi
movq 0x10(%rsi), %r13
movq %r12, %rdi
callq 0x2b331
cmpq $0x0, 0x28(%r12)
jne 0x5b905
movq (%r15), %rdi
movq %r14, %rsi
callq 0x2ecb5
movq 0x18(%r15), %rax
movslq %r13d, %r12
movq (%rax,%r12,8), %rdi
shlq $0x3, %r12
callq 0x36330
addq 0x18(%r15), %r12
jmp 0x5b99c
movq %rbx, %rdi
callq 0x36330
jmp 0x5b9a0
cmpl $0x0, 0x20(%r15)
je 0x5b936
movl 0x10(%r15), %ecx
jmp 0x5b975
leaq 0x69362(%rip), %rdi     # 0xc4c9f
callq 0x362b0
movq %rax, %r12
movq 0x18(%r15), %rdi
movslq 0x10(%r15), %rax
leaq 0x8(,%rax,8), %rsi
callq 0x3837d
movq %rax, 0x18(%r15)
movslq 0x10(%r15), %rdx
leal 0x1(%rdx), %ecx
movl %ecx, 0x10(%r15)
movq %r12, (%rax,%rdx,8)
movl $0x1, 0x20(%r15)
movq 0x18(%r15), %rdi
movslq %ecx, %rax
leaq 0x8(,%rax,8), %rsi
callq 0x3837d
movq %rax, 0x18(%r15)
movslq 0x10(%r15), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x10(%r15)
leaq (%rax,%rcx,8), %r12
movq %rbx, (%r12)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x36330
// File: /workspace/github_c_makefile_star2_O3/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:
movq %rdx, %rcx
testq %rdx, %rdx
sete %al
testl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
setne %dl
orb %al, %dl
jne 0x5b9d9
sarq $0x1e, %rcx
leaq 0x692ed(%rip), %rdx     # 0xc4cc4
jmp 0x5ba20
testq %rcx, %rcx
sete %al
testl $0xfffff, %ecx          # imm = 0xFFFFF
setne %dl
orb %al, %dl
jne 0x5b9f9
sarq $0x14, %rcx
leaq 0x692d4(%rip), %rdx     # 0xc4ccb
jmp 0x5ba20
testq %rcx, %rcx
sete %al
testl $0x3ff, %ecx            # imm = 0x3FF
setne %dl
orb %al, %dl
jne 0x5ba19
sarq $0xa, %rcx
leaq 0x692bb(%rip), %rdx     # 0xc4cd2
jmp 0x5ba20
leaq 0x6d3e8(%rip), %rdx     # 0xc8e08
xorl %eax, %eax
jmp 0x26120
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/config.c
// Function: rewriteConfigBytesOption
void rewriteConfigBytesOption(struct rewriteConfigState *state, char *option, long long value, long long defvalue) {
    char buf[64];
    int force = value != defvalue;
    sds line;

    rewriteConfigFormatMemory(buf,sizeof(buf),value);
    line = sdscatprintf(sdsempty(),"%s %s",option,buf);
    rewriteConfigRewriteLine(state,option,line,force);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
cmpq %rcx, %rdx
setne %bpl
movq %rsp, %r15
movl $0x40, %esi
movq %r15, %rdi
callq 0x5b9b6
callq 0x3628d
leaq 0x71964(%rip), %rsi     # 0xcd3c0
movq %rax, %rdi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x36f2d
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movl %ebp, %ecx
callq 0x5b894
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/config.c
// Function: rewriteConfigYesNoOption
void rewriteConfigYesNoOption(struct rewriteConfigState *state, char *option, int value, int defvalue) {
    int force = value != defvalue;
    sds line = sdscatprintf(sdsempty(),"%s %s",option,
        value ? "yes" : "no");

    rewriteConfigRewriteLine(state,option,line,force);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
cmpl %ecx, %edx
setne %bpl
callq 0x3628d
testl %ebx, %ebx
leaq 0x6eb02(%rip), %rdx     # 0xca5ae
leaq 0x64862(%rip), %rcx     # 0xc0315
cmoveq %rdx, %rcx
leaq 0x71902(%rip), %rsi     # 0xcd3c0
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x36f2d
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
movl %ebp, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5b894
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/config.c
// Function: rewriteConfigStringOption
void rewriteConfigStringOption(struct rewriteConfigState *state, char *option, char *value, char *defvalue) {
    int force = 1;
    sds line;

    /* String options set to NULL need to be not present at all in the
     * configuration file to be set to NULL again at the next reboot. */
    if (value == NULL) {
        rewriteConfigMarkAsProcessed(state,option);
        return;
    }

    /* Set force to zero if the value is set to its default. */
    if (defvalue && strcmp(value,defvalue) == 0) force = 0;

    line = sdsnew(option);
    line = sdscatlen(line, " ", 1);
    line = sdscatrepr(line, value, strlen(value));

    rewriteConfigRewriteLine(state,option,line,force);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x5bb15
movq %rdx, %r15
testq %rcx, %rcx
je 0x5bb28
movq %r15, %rdi
movq %rcx, %rsi
callq 0x268f0
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
jmp 0x5bb2d
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5b648
movl $0x1, %ebp
movq %rbx, %rdi
callq 0x362b0
leaq 0x69161(%rip), %rsi     # 0xc4c9d
movl $0x1, %edx
movq %rax, %rdi
callq 0x36ad1
movq %rax, %r12
movq %r15, %rdi
callq 0x26500
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x37c36
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movl %ebp, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5b894
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/config.c
// Function: rewriteConfigEnumOption
void rewriteConfigEnumOption(struct rewriteConfigState *state, char *option, int value, configEnum *ce, int defval) {
    sds line;
    const char *name = configEnumGetNameOrUnknown(ce,value);
    int force = value != defval;

    line = sdscatprintf(sdsempty(),"%s %s",option,name);
    rewriteConfigRewriteLine(state,option,line,force);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rcx), %rax
testq %rax, %rax
je 0x5bc49
cmpl %edx, 0x8(%rcx)
je 0x5bc4b
addq $0x18, %rcx
movq -0x8(%rcx), %rax
testq %rax, %rax
je 0x5bc49
leaq 0x10(%rcx), %rsi
cmpl %edx, (%rcx)
movq %rsi, %rcx
jne 0x5bc33
jmp 0x5bc4b
xorl %eax, %eax
testq %rax, %rax
leaq 0x6518e(%rip), %r15     # 0xc0de3
cmovneq %rax, %r15
xorl %ebp, %ebp
cmpl %r8d, %edx
setne %bpl
callq 0x3628d
leaq 0x71752(%rip), %rsi     # 0xcd3c0
movq %rax, %rdi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x36f2d
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movl %ebp, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5b894
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/config.c
// Function: rewriteConfigSyslogfacilityOption
void rewriteConfigSyslogfacilityOption(struct rewriteConfigState *state) {
    int value = server.syslog_facility;
    int force = value != LOG_LOCAL0;
    const char *name = NULL, *option = "syslog-facility";
    sds line;

    name = configEnumGetNameOrUnknown(syslog_facility_enum,value);
    line = sdscatprintf(sdsempty(),"%s %s",option,name);
    rewriteConfigRewriteLine(state,option,line,force);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa5bff(%rip), %rax     # 0x1018a8
movl 0x7b8(%rax), %eax
movq 0xa53ba(%rip), %rcx     # 0x101070
testq %rcx, %rcx
je 0x5bce0
cmpl %eax, 0xa53b7(%rip)     # 0x101078
je 0x5bce2
leaq 0xa53be(%rip), %rdx     # 0x101088
movq -0x8(%rdx), %rcx
testq %rcx, %rcx
je 0x5bce0
leaq 0x10(%rdx), %rsi
cmpl %eax, (%rdx)
movq %rsi, %rdx
jne 0x5bcca
jmp 0x5bce2
xorl %ecx, %ecx
xorl %ebp, %ebp
cmpl $0x80, %eax
setne %bpl
testq %rcx, %rcx
leaq 0x650ec(%rip), %r14     # 0xc0de3
cmovneq %rcx, %r14
callq 0x3628d
leaq 0x716b9(%rip), %rsi     # 0xcd3c0
leaq 0x682ab(%rip), %r15     # 0xc3fb9
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x36f2d
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
movl %ebp, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5b894
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/config.c
// Function: rewriteConfigSaveOption
void rewriteConfigSaveOption(struct rewriteConfigState *state) {
    int j;
    sds line;

    /* Note that if there are no save parameters at all, all the current
     * config line with "save" will be detected as orphaned and deleted,
     * resulting into no RDB persistence as expected. */
    for (j = 0; j < server.saveparamslen; j++) {
        line = sdscatprintf(sdsempty(),"save %ld %d",
            (long) server.saveparams[j].seconds, server.saveparams[j].changes);
        rewriteConfigRewriteLine(state,"save",line,1);
    }
    /* Mark "save" as processed in case server.saveparamslen is zero. */
    rewriteConfigMarkAsProcessed(state,"save");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa5b5b(%rip), %r12     # 0x1018a8
cmpl $0x0, 0x740(%r12)
jle 0x5bdb8
movl $0x8, %r13d
leaq 0x68f82(%rip), %r14     # 0xc4ce7
leaq 0x66e51(%rip), %r15     # 0xc2bbd
xorl %ebp, %ebp
callq 0x3628d
movq 0x738(%r12), %rcx
movq -0x8(%rcx,%r13), %rdx
movl (%rcx,%r13), %ecx
movq %rax, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x36f2d
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x5b894
incq %rbp
movslq 0x740(%r12), %rax
addq $0x10, %r13
cmpq %rax, %rbp
jl 0x5bd6e
leaq 0x66dfe(%rip), %rsi     # 0xc2bbd
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5b648
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/config.c
// Function: rewriteConfigDirOption
void rewriteConfigDirOption(struct rewriteConfigState *state) {
    char cwd[1024];

    if (getcwd(cwd,sizeof(cwd)) == NULL) {
        rewriteConfigMarkAsProcessed(state,"dir");
        return; /* no rewrite on error. */
    }
    rewriteConfigStringOption(state,"dir",cwd,NULL);
}

// Assembly:
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdi, %rbx
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x26910
leaq 0x6811e(%rip), %rsi     # 0xc3f12
testq %rax, %rax
je 0x5be08
movq %rsp, %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x5bae5
jmp 0x5be10
movq %rbx, %rdi
callq 0x5b648
addq $0x400, %rsp            # imm = 0x400
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/config.c
// Function: rewriteConfigSlaveofOption
void rewriteConfigSlaveofOption(struct rewriteConfigState *state) {
    char *option = "slaveof";
    sds line;

    /* If this is a master, we want all the slaveof config options
     * in the file to be removed. Note that if this is a cluster instance
     * we don't want a slaveof directive inside redis.conf. */
    if (server.cluster_enabled || server.masterhost == NULL) {
        rewriteConfigMarkAsProcessed(state,"slaveof");
        return;
    }
    line = sdscatprintf(sdsempty(),"%s %s %d", option,
        server.masterhost, server.masterport);
    rewriteConfigRewriteLine(state,option,line,1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa5a81(%rip), %r14     # 0x1018a8
cmpl $0x0, 0x99c(%r14)
jne 0x5be83
cmpq $0x0, 0x828(%r14)
je 0x5be83
callq 0x3628d
movq 0x828(%r14), %rcx
movl 0x830(%r14), %r8d
leaq 0x70491(%rip), %rsi     # 0xcc2e6
leaq 0x60a45(%rip), %r14     # 0xbc8a1
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x36f2d
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
movl $0x1, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5b894
leaq 0x60a17(%rip), %rsi     # 0xbc8a1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5b648
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/config.c
// Function: rewriteConfigNotifykeyspaceeventsOption
void rewriteConfigNotifykeyspaceeventsOption(struct rewriteConfigState *state) {
    int force = server.notify_keyspace_events != 0;
    char *option = "notify-keyspace-events";
    sds line, flags;

    flags = keyspaceEventsFlagsToString(server.notify_keyspace_events);
    line = sdsnew(option);
    line = sdscatlen(line, " ", 1);
    line = sdscatrepr(line, flags, sdslen(flags));
    sdsfree(flags);
    rewriteConfigRewriteLine(state,option,line,force);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0xa59fd(%rip), %rax     # 0x1018a8
movl 0x998(%rax), %ebp
movl %ebp, %edi
callq 0x7c547
movq %rax, %r14
leaq 0x689b9(%rip), %rdi     # 0xc487b
callq 0x362b0
leaq 0x68dcf(%rip), %rsi     # 0xc4c9d
movl $0x1, %edx
movq %rax, %rdi
callq 0x36ad1
movzbl -0x1(%r14), %edx
movl %edx, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x5bf19
leaq 0x67dfb(%rip), %rsi     # 0xc3cec
movslq (%rsi,%rcx,4), %rcx
addq %rsi, %rcx
jmpq *%rcx
shrl $0x3, %edx
jmp 0x5bf1b
movq -0x11(%r14), %rdx
jmp 0x5bf1b
movzwl -0x5(%r14), %edx
jmp 0x5bf1b
movl -0x9(%r14), %edx
jmp 0x5bf1b
movzbl -0x3(%r14), %edx
jmp 0x5bf1b
xorl %edx, %edx
xorl %r15d, %r15d
testl %ebp, %ebp
setne %r15b
movq %rax, %rdi
movq %r14, %rsi
callq 0x37c36
movq %rax, %r12
movq %r14, %rdi
callq 0x36330
leaq 0x6893a(%rip), %rsi     # 0xc487b
movq %rbx, %rdi
movq %r12, %rdx
movl %r15d, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5b894
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/config.c
// Function: rewriteConfigClientoutputbufferlimitOption
void rewriteConfigClientoutputbufferlimitOption(struct rewriteConfigState *state) {
    int j;
    char *option = "client-output-buffer-limit";

    for (j = 0; j < CLIENT_TYPE_OBUF_COUNT; j++) {
        int force = (server.client_obuf_limits[j].hard_limit_bytes !=
                    clientBufferLimitsDefaults[j].hard_limit_bytes) ||
                    (server.client_obuf_limits[j].soft_limit_bytes !=
                    clientBufferLimitsDefaults[j].soft_limit_bytes) ||
                    (server.client_obuf_limits[j].soft_limit_seconds !=
                    clientBufferLimitsDefaults[j].soft_limit_seconds);
        sds line;
        char hard[64], soft[64];

        rewriteConfigFormatMemory(hard,sizeof(hard),
                server.client_obuf_limits[j].hard_limit_bytes);
        rewriteConfigFormatMemory(soft,sizeof(soft),
                server.client_obuf_limits[j].soft_limit_bytes);

        line = sdscatprintf(sdsempty(),"%s %s %s %s %ld",
                option, getClientTypeName(j), hard, soft,
                (long) server.client_obuf_limits[j].soft_limit_seconds);
        rewriteConfigRewriteLine(state,option,line,force);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, 0x8(%rsp)
leaq 0xa5934(%rip), %rbx     # 0x1018a8
leaq 0xa5275(%rip), %rcx     # 0x1011f0
xorl %r15d, %r15d
xorl %ebp, %ebp
movq 0x620(%rbx,%r15), %rdx
movl $0x1, %r12d
cmpq (%r15,%rcx), %rdx
jne 0x5bfb7
movq 0x628(%rbx,%r15), %rax
cmpq 0x8(%r15,%rcx), %rax
jne 0x5bfb7
movq 0x630(%rbx,%r15), %rax
xorl %r12d, %r12d
cmpq 0x10(%r15,%rcx), %rax
setne %r12b
movl $0x40, %esi
leaq 0x10(%rsp), %rdi
callq 0x5b9b6
movq 0x628(%rbx,%r15), %rdx
movl $0x40, %esi
leaq 0x50(%rsp), %r13
movq %r13, %rdi
callq 0x5b9b6
callq 0x3628d
movq %rax, %r14
movl %ebp, %edi
callq 0x3f897
movq 0x630(%rbx,%r15), %rcx
movq %rcx, (%rsp)
movq %r14, %rdi
leaq 0x68cee(%rip), %rsi     # 0xc4cf3
leaq 0x686ef(%rip), %r14     # 0xc46fb
movq %r14, %rdx
movq %rax, %rcx
leaq 0x10(%rsp), %r8
movq %r13, %r9
xorl %eax, %eax
callq 0x36f2d
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rdx
movl %r12d, %ecx
callq 0x5b894
leaq 0xa51b5(%rip), %rcx     # 0x1011f0
incq %rbp
addq $0x18, %r15
cmpq $0x3, %rbp
jne 0x5bf80
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/config.c
// Function: rewriteConfigBindOption
void rewriteConfigBindOption(struct rewriteConfigState *state) {
    int force = 1;
    sds line, addresses;
    char *option = "bind";

    /* Nothing to rewrite if we don't have bind addresses. */
    if (server.bindaddr_count == 0) {
        rewriteConfigMarkAsProcessed(state,option);
        return;
    }

    /* Rewrite as bind <addr1> <addr2> ... <addrN> */
    addresses = sdsjoin(server.bindaddr,server.bindaddr_count," ");
    line = sdsnew(option);
    line = sdscatlen(line, " ", 1);
    line = sdscatsds(line, addresses);
    sdsfree(addresses);

    rewriteConfigRewriteLine(state,option,line,force);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa5838(%rip), %rax     # 0x1018a8
movl 0x128(%rax), %esi
testl %esi, %esi
je 0x5c0eb
movl $0xa8, %edi
addq 0xa0f32(%rip), %rdi     # 0xfcfb8
leaq 0x68c10(%rip), %r14     # 0xc4c9d
movq %r14, %rdx
callq 0x381a3
movq %rax, %r15
leaq 0x67e05(%rip), %r12     # 0xc3ea4
movq %r12, %rdi
callq 0x362b0
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x36ad1
movq %rax, %rdi
movq %r15, %rsi
callq 0x36bc3
movq %rax, %r14
movq %r15, %rdi
callq 0x36330
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl $0x1, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5b894
leaq 0x67db2(%rip), %rsi     # 0xc3ea4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5b648