LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/object.c
// Function: getDoubleFromObject
int getDoubleFromObject(robj *o, double *target) {
    double value;
    char *eptr;

    if (o == NULL) {
        value = 0;
    } else {
        serverAssertWithInfo(NULL,o,o->type == OBJ_STRING);
        if (sdsEncodedObject(o)) {
            errno = 0;
            value = strtod(o->ptr, &eptr);
            if (isspace(((char*)o->ptr)[0]) ||
                eptr[0] != '\0' ||
                (errno == ERANGE &&
                    (value == HUGE_VAL || value == -HUGE_VAL || value == 0)) ||
                errno == EINVAL ||
                isnan(value))
                return C_ERR;
        } else if (o->encoding == OBJ_ENCODING_INT) {
            value = (long)o->ptr;
        } else {
            serverPanic("Unknown string encoding");
        }
    }
    *target = value;
    return C_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x26402
movq %rdi, %r14
movl (%rdi), %eax
testb $0xf, %al
jne 0x2641e
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x2, %eax
je 0x2637b
cmpl $0x1, %eax
je 0x26408
testl %eax, %eax
jne 0x2643e
callq 0x120d0
movq %rax, %r15
movl $0x0, (%rax)
movq 0x8(%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0x12190
movsd %xmm0, (%rsp)
callq 0x129b0
movq (%rax), %rcx
movq 0x8(%r14), %rax
movsbq (%rax), %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb $0x20, 0x1(%rcx,%rdx,2)
jne 0x26414
movq 0x8(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x26414
movl (%r15), %ecx
cmpl $0x22, %ecx
movq (%rsp), %xmm0
jne 0x263f5
movq %xmm0, %rdx
btrq $0x3f, %rdx
movabsq $0x7ff0000000000000, %rsi # imm = 0x7FF0000000000000
cmpq %rsi, %rdx
sete %sil
testq %rdx, %rdx
sete %dl
orb %sil, %dl
jne 0x26414
cmpl $0x16, %ecx
je 0x26414
ucomisd %xmm0, %xmm0
jnp 0x2640e
jmp 0x26414
xorpd %xmm0, %xmm0
jmp 0x2640e
cvtsi2sdq 0x8(%r14), %xmm0
movsd %xmm0, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2e7d7(%rip), %rdx     # 0x54bfc
leaq 0x2ef73(%rip), %rcx     # 0x5539f
xorl %edi, %edi
movq %r14, %rsi
movl $0x199, %r8d            # imm = 0x199
callq 0x2a9bc
jmp 0x26456
leaq 0x2eff7(%rip), %rdi     # 0x5543c
leaq 0x2ef53(%rip), %rsi     # 0x5539f
movl $0x1a7, %edx            # imm = 0x1A7
callq 0x2ade4
movl $0x1, %edi
callq 0x12120
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/object.c
// Function: getDoubleFromObjectOrReply
int getDoubleFromObjectOrReply(client *c, robj *o, double *target, const char *msg) {
    double value;
    if (getDoubleFromObject(o, &value) != C_OK) {
        if (msg != NULL) {
            addReplyError(c,(char*)msg);
        } else {
            addReplyError(c,"value is not a valid float");
        }
        return C_ERR;
    }
    *target = value;
    return C_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %rax
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2633d
testl %eax, %eax
je 0x26493
testq %rbx, %rbx
je 0x264a2
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x264ac
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%r15)
xorl %eax, %eax
jmp 0x264b6
leaq 0x2efad(%rip), %rsi     # 0x55456
movq %r14, %rdi
callq 0x2230a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/object.c
// Function: getLongDoubleFromObject
int getLongDoubleFromObject(robj *o, long double *target) {
    long double value;
    char *eptr;

    if (o == NULL) {
        value = 0;
    } else {
        serverAssertWithInfo(NULL,o,o->type == OBJ_STRING);
        if (sdsEncodedObject(o)) {
            errno = 0;
            value = strtold(o->ptr, &eptr);
            if (isspace(((char*)o->ptr)[0]) || eptr[0] != '\0' ||
                errno == ERANGE || isnan(value))
                return C_ERR;
        } else if (o->encoding == OBJ_ENCODING_INT) {
            value = (long)o->ptr;
        } else {
            serverPanic("Unknown string encoding");
        }
    }
    *target = value;
    return C_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
fldz
testq %rdi, %rdi
je 0x26565
movq %rdi, %r14
fstp %st(0)
movl (%rdi), %eax
testb $0xf, %al
jne 0x26577
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x2, %eax
je 0x264fe
cmpl $0x1, %eax
je 0x2655a
testl %eax, %eax
jne 0x26597
callq 0x120d0
movq %rax, %r15
movl $0x0, (%rax)
movq 0x8(%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0x12730
fstpt 0x14(%rsp)
callq 0x129b0
movq (%rax), %rcx
movq 0x8(%r14), %rax
movsbq (%rax), %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb $0x20, 0x1(%rcx,%rdx,2)
jne 0x26569
movq 0x8(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x26569
cmpl $0x22, (%r15)
sete %cl
fldt 0x14(%rsp)
fucomi %st(0), %st
setp %dl
orb %cl, %dl
je 0x26565
jmp 0x2656b
movq 0x8(%r14), %rax
movq %rax, (%rsp)
fildll (%rsp)
fstpt (%rbx)
xorl %eax, %eax
fldz
fstp %st(0)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2e67e(%rip), %rdx     # 0x54bfc
leaq 0x2ee1a(%rip), %rcx     # 0x5539f
xorl %edi, %edi
movq %r14, %rsi
movl $0x1c3, %r8d            # imm = 0x1C3
callq 0x2a9bc
jmp 0x265af
leaq 0x2ee9e(%rip), %rdi     # 0x5543c
leaq 0x2edfa(%rip), %rsi     # 0x5539f
movl $0x1cd, %edx            # imm = 0x1CD
callq 0x2ade4
movl $0x1, %edi
callq 0x12120
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/object.c
// Function: getLongDoubleFromObjectOrReply
int getLongDoubleFromObjectOrReply(client *c, robj *o, long double *target, const char *msg) {
    long double value;
    if (getLongDoubleFromObject(o, &value) != C_OK) {
        if (msg != NULL) {
            addReplyError(c,(char*)msg);
        } else {
            addReplyError(c,"value is not a valid float");
        }
        return C_ERR;
    }
    *target = value;
    return C_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %rax
movq %rdi, %r14
movq %rsp, %rsi
movq %rax, %rdi
callq 0x264c0
testl %eax, %eax
je 0x265ea
testq %rbx, %rbx
je 0x265f4
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x265fe
fldt (%rsp)
fstpt (%r15)
xorl %eax, %eax
jmp 0x26608
leaq 0x2ee5b(%rip), %rsi     # 0x55456
movq %r14, %rdi
callq 0x2230a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/object.c
// Function: getLongLongFromObject
int getLongLongFromObject(robj *o, long long *target) {
    long long value;
    char *eptr;

    if (o == NULL) {
        value = 0;
    } else {
        serverAssertWithInfo(NULL,o,o->type == OBJ_STRING);
        if (sdsEncodedObject(o)) {
            errno = 0;
            value = strtoll(o->ptr, &eptr, 10);
            if (isspace(((char*)o->ptr)[0]) || eptr[0] != '\0' ||
                errno == ERANGE)
                return C_ERR;
        } else if (o->encoding == OBJ_ENCODING_INT) {
            value = (long)o->ptr;
        } else {
            serverPanic("Unknown string encoding");
        }
    }
    if (target) *target = value;
    return C_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
xorl %r15d, %r15d
testq %rdi, %rdi
je 0x2669e
movq %rdi, %r14
movl (%rdi), %eax
testb $0xf, %al
jne 0x266b4
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x2, %eax
je 0x2664a
cmpl $0x1, %eax
je 0x2669a
testl %eax, %eax
jne 0x266d4
callq 0x120d0
movq %rax, %r12
movl $0x0, (%rax)
movq 0x8(%r14), %rdi
movq %rsp, %rsi
movl $0xa, %edx
callq 0x124c0
movq %rax, %r15
callq 0x129b0
movq (%rax), %rcx
movq 0x8(%r14), %rax
movsbq (%rax), %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb $0x20, 0x1(%rcx,%rdx,2)
jne 0x266a8
movq (%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x266a8
cmpl $0x22, (%r12)
jne 0x2669e
jmp 0x266a8
movq 0x8(%r14), %r15
testq %rbx, %rbx
je 0x266a6
movq %r15, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2e541(%rip), %rdx     # 0x54bfc
leaq 0x2ecdd(%rip), %rcx     # 0x5539f
xorl %edi, %edi
movq %r14, %rsi
movl $0x1e9, %r8d            # imm = 0x1E9
callq 0x2a9bc
jmp 0x266ec
leaq 0x2ed61(%rip), %rdi     # 0x5543c
leaq 0x2ecbd(%rip), %rsi     # 0x5539f
movl $0x1f3, %edx            # imm = 0x1F3
callq 0x2ade4
movl $0x1, %edi
callq 0x12120
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/object.c
// Function: getLongLongFromObjectOrReply
int getLongLongFromObjectOrReply(client *c, robj *o, long long *target, const char *msg) {
    long long value;
    if (getLongLongFromObject(o, &value) != C_OK) {
        if (msg != NULL) {
            addReplyError(c,(char*)msg);
        } else {
            addReplyError(c,"value is not an integer or out of range");
        }
        return C_ERR;
    }
    *target = value;
    return C_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %rax
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x26612
testl %eax, %eax
je 0x26729
testq %rbx, %rbx
je 0x26735
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x2673f
movq 0x8(%rsp), %rax
movq %rax, (%r15)
xorl %eax, %eax
jmp 0x26749
leaq 0x2ed35(%rip), %rsi     # 0x55471
movq %r14, %rdi
callq 0x2230a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/object.c
// Function: getLongFromObjectOrReply
int getLongFromObjectOrReply(client *c, robj *o, long *target, const char *msg) {
    long long value;

    if (getLongLongFromObjectOrReply(c, o, &value, msg) != C_OK) return C_ERR;
    if (value < LONG_MIN || value > LONG_MAX) {
        if (msg != NULL) {
            addReplyError(c,(char*)msg);
        } else {
            addReplyError(c,"value is out of range");
        }
        return C_ERR;
    }
    *target = value;
    return C_OK;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq 0x8(%rsp), %rdx
callq 0x266f6
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x2677a
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/object.c
// Function: parseScanCursorOrReply
int parseScanCursorOrReply(client *c, robj *o, unsigned long *cursor) {
    char *eptr;

    /* Use strtoul() because we need an *unsigned* long, so
     * getLongLongFromObject() does not cover the whole cursor space. */
    errno = 0;
    *cursor = strtoul(o->ptr, &eptr, 10);
    if (isspace(((char*)o->ptr)[0]) || eptr[0] != '\0' || errno == ERANGE)
    {
        addReplyError(c, "invalid cursor or option name");
        return C_ERR;
    }
    return C_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x120d0
movq %rax, %r14
movl $0x0, (%rax)
movq 0x8(%r12), %rdi
movq %rsp, %rsi
movl $0xa, %edx
callq 0x12800
movq %rax, (%r15)
callq 0x129b0
movq (%rax), %rax
movq 0x8(%r12), %rcx
movsbq (%rcx), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x267dd
movq (%rsp), %rax
cmpb $0x0, (%rax)
jne 0x267dd
xorl %eax, %eax
cmpl $0x22, (%r14)
jne 0x267f1
leaq 0x2ecb5(%rip), %rsi     # 0x55499
movq %rbx, %rdi
callq 0x2230a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x26856
movq %rsi, %r15
addq $0x10, %r14
movq %r15, %rsi
callq 0x12090
testl %eax, %eax
je 0x26852
movq (%r14), %rdi
addq $0x10, %r14
testq %rdi, %rdi
jne 0x26838
jmp 0x26856
movl -0x8(%r14), %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x26884
cmpl %esi, 0x8(%rdi)
je 0x26883
addq $0x18, %rdi
movq -0x8(%rdi), %rax
testq %rax, %rax
je 0x26884
leaq 0x10(%rdi), %rcx
cmpl %esi, (%rdi)
movq %rcx, %rdi
jne 0x2686f
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x48784(%rip), %r15     # 0x6f088
movq 0x6b8(%r15), %rdi
movslq 0x6c0(%r15), %rsi
shlq $0x4, %rsi
addq $0x10, %rsi
callq 0x1ff61
movq %rax, 0x6b8(%r15)
movslq 0x6c0(%r15), %rcx
leal 0x1(%rcx), %edx
shlq $0x4, %rcx
movq %r14, (%rax,%rcx)
movl %ebx, 0x8(%rax,%rcx)
movl %edx, 0x6c0(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x1de3f
movq %rax, %r14
testq %r12, %r12
je 0x276e7
cmpb $0x2d, (%r12)
jne 0x2767d
cmpb $0x0, 0x1(%r12)
je 0x27728
leaq 0x2d171(%rip), %rsi     # 0x547f5
movq %r12, %rdi
callq 0x12500
movq %rax, %r15
testq %rax, %rax
je 0x27737
movq %rsp, %rdi
movl $0x401, %esi            # imm = 0x401
movq %r15, %rdx
callq 0x12470
testq %rax, %rax
je 0x276d3
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x1e73d
movq %rax, %r14
movq %r12, %rdi
movl $0x401, %esi            # imm = 0x401
movq %r15, %rdx
callq 0x12470
testq %rax, %rax
jne 0x276b0
movq 0x468b6(%rip), %rax     # 0x6df90
cmpq (%rax), %r15
je 0x276e7
movq %r15, %rdi
callq 0x12220
testq %rbx, %rbx
je 0x27709
leaq 0x2c695(%rip), %rsi     # 0x53d88
movq %r14, %rdi
callq 0x1e73d
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1e73d
movq %rax, %r14
movq %r14, %rdi
callq 0x26974
movq %r14, %rdi
callq 0x1ded3
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x46861(%rip), %rax     # 0x6df90
movq (%rax), %r15
jmp 0x27698
leaq 0x2e417(%rip), %rsi     # 0x55b55
movl $0x3, %edi
movq %r12, %rdx
xorl %eax, %eax
callq 0x19fb1
movl $0x1, %edi
callq 0x12870
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x191a0
movq %rax, %r14
testq %rax, %rax
jne 0x28d60
callq 0x16a2c
movq %rax, %r14
movq (%r12), %r12
movq %r15, %rdi
callq 0x1de83
movq %r12, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x18b97
movslq %ebx, %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x16aff
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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(DISCNT_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 0x1de62
movq %rax, %r14
movq (%r15), %rdi
movq %rax, %rsi
callq 0x191a0
movq %rax, %r12
movq %r15, %rdi
movq %r13, %rsi
callq 0x28d76
testq %r12, %r12
setne %al
testl %ebp, %ebp
setne %cl
orb %al, %cl
je 0x2904d
testq %r12, %r12
je 0x29057
movq (%r12), %rsi
movq 0x10(%rsi), %r13
movq %r12, %rdi
callq 0x16be4
cmpq $0x0, 0x28(%r12)
jne 0x29033
movq (%r15), %rdi
movq %r14, %rsi
callq 0x18e09
movq 0x18(%r15), %rax
movslq %r13d, %r12
movq (%rax,%r12,8), %rdi
shlq $0x3, %r12
callq 0x1ded3
addq 0x18(%r15), %r12
jmp 0x290c5
movq %rbx, %rdi
callq 0x1ded3
jmp 0x290c9
cmpl $0x0, 0x20(%r15)
jne 0x2909d
leaq 0x2cd77(%rip), %rdi     # 0x55ddc
callq 0x1de62
movq %rax, %r12
movq 0x18(%r15), %rdi
movslq 0x10(%r15), %rax
leaq 0x8(,%rax,8), %rsi
callq 0x1ff61
movq %rax, 0x18(%r15)
movslq 0x10(%r15), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x10(%r15)
movq %r12, (%rax,%rcx,8)
movl $0x1, 0x20(%r15)
movq 0x18(%r15), %rdi
movslq 0x10(%r15), %rax
leaq 0x8(,%rax,8), %rsi
callq 0x1ff61
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 0x1ded3
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x29102
sarq $0x1e, %rcx
leaq 0x2cd01(%rip), %rdx     # 0x55e01
jmp 0x29149
testq %rcx, %rcx
sete %al
testl $0xfffff, %ecx          # imm = 0xFFFFF
setne %dl
orb %al, %dl
jne 0x29122
sarq $0x14, %rcx
leaq 0x2cce8(%rip), %rdx     # 0x55e08
jmp 0x29149
testq %rcx, %rcx
sete %al
testl $0x3ff, %ecx            # imm = 0x3FF
setne %dl
orb %al, %dl
jne 0x29142
sarq $0xa, %rcx
leaq 0x2cccf(%rip), %rdx     # 0x55e0f
jmp 0x29149
leaq 0x2ccd6(%rip), %rdx     # 0x55e1f
xorl %eax, %eax
jmp 0x122d0
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x290df
callq 0x1de3f
leaq 0x2cc91(%rip), %rsi     # 0x55e16
movq %rax, %rdi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1eace
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movl %ebp, %ecx
callq 0x28fc2
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x1de3f
testl %ebx, %ebx
leaq 0x2bdb7(%rip), %rdx     # 0x54f8c
leaq 0x2bdac(%rip), %rcx     # 0x54f88
cmoveq %rdx, %rcx
leaq 0x2cc2f(%rip), %rsi     # 0x55e16
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1eace
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
movl %ebp, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x28fc2
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x2923e
movq %rdx, %r15
testq %rcx, %rcx
je 0x29251
movq %r15, %rdi
movq %rcx, %rsi
callq 0x124a0
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
jmp 0x29256
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x28d76
movl $0x1, %ebp
movq %rbx, %rdi
callq 0x1de62
leaq 0x2cb75(%rip), %rsi     # 0x55dda
movl $0x1, %edx
movq %rax, %rdi
callq 0x1e66d
movq %rax, %r12
movq %r15, %rdi
callq 0x12250
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1f7c8
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movl %ebp, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x28fc2
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x293ce
cmpl %edx, 0x8(%rcx)
je 0x293d0
addq $0x18, %rcx
movq -0x8(%rcx), %rax
testq %rax, %rax
je 0x293ce
leaq 0x10(%rcx), %rsi
cmpl %edx, (%rcx)
movq %rsi, %rcx
jne 0x293b8
jmp 0x293d0
xorl %eax, %eax
testq %rax, %rax
leaq 0x2c0e8(%rip), %r15     # 0x554c2
cmovneq %rax, %r15
xorl %ebp, %ebp
cmpl %r8d, %edx
setne %bpl
callq 0x1de3f
leaq 0x2ca23(%rip), %rsi     # 0x55e16
movq %rax, %rdi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1eace
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movl %ebp, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x28fc2
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x45c5a(%rip), %rax     # 0x6f088
movl 0x608(%rax), %eax
movq 0x459d5(%rip), %rcx     # 0x6ee10
testq %rcx, %rcx
je 0x29465
cmpl %eax, 0x459d2(%rip)     # 0x6ee18
je 0x29467
leaq 0x459d9(%rip), %rdx     # 0x6ee28
movq -0x8(%rdx), %rcx
testq %rcx, %rcx
je 0x29465
leaq 0x10(%rdx), %rsi
cmpl %eax, (%rdx)
movq %rsi, %rdx
jne 0x2944f
jmp 0x29467
xorl %ecx, %ecx
xorl %ebp, %ebp
cmpl $0x80, %eax
setne %bpl
testq %rcx, %rcx
leaq 0x2c046(%rip), %r14     # 0x554c2
cmovneq %rcx, %r14
callq 0x1de3f
leaq 0x2c98a(%rip), %rsi     # 0x55e16
leaq 0x2c2e6(%rip), %r15     # 0x55779
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x1eace
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
movl %ebp, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x28fc2
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x45bb6(%rip), %r12     # 0x6f088
cmpl $0x0, 0x6c0(%r12)
jle 0x2953d
movl $0x8, %r13d
leaq 0x2c946(%rip), %r14     # 0x55e30
leaq 0x2f6ac(%rip), %r15     # 0x58b9d
xorl %ebp, %ebp
callq 0x1de3f
movq 0x6b8(%r12), %rcx
movq -0x8(%rcx,%r13), %rdx
movl (%rcx,%r13), %ecx
movq %rax, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1eace
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x28fc2
incq %rbp
movslq 0x6c0(%r12), %rax
addq $0x10, %r13
cmpq %rax, %rbp
jl 0x294f3
leaq 0x2f659(%rip), %rsi     # 0x58b9d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x28d76
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x123a0
leaq 0x2c13a(%rip), %rsi     # 0x556b3
testq %rax, %rax
je 0x2958d
movq %rsp, %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x2920e
jmp 0x29595
movq %rbx, %rdi
callq 0x28d76
addq $0x400, %rsp            # imm = 0x400
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/config.c
// Function: rewriteConfigClientoutputbufferlimitOption
void rewriteConfigClientoutputbufferlimitOption(struct rewriteConfigState *state) {
    int j;
    char *option = "client-output-buffer-limit";

    for (j = 0; j < CLIENT_TYPE_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 0x45acd(%rip), %rbx     # 0x6f088
leaq 0x59fae(%rip), %rcx     # 0x83570
xorl %r15d, %r15d
xorl %ebp, %ebp
movq 0x5c0(%rbx,%r15), %rdx
movl $0x1, %r12d
cmpq (%r15,%rcx), %rdx
jne 0x295fe
movq 0x5c8(%rbx,%r15), %rax
cmpq 0x8(%r15,%rcx), %rax
jne 0x295fe
movq 0x5d0(%rbx,%r15), %rax
xorl %r12d, %r12d
cmpq 0x10(%r15,%rcx), %rax
setne %r12b
movl $0x40, %esi
leaq 0x10(%rsp), %rdi
callq 0x290df
movq 0x5c8(%rbx,%r15), %rdx
movl $0x40, %esi
leaq 0x50(%rsp), %r13
movq %r13, %rdi
callq 0x290df
callq 0x1de3f
movq %rax, %r14
movl %ebp, %edi
callq 0x24cf4
movq 0x5d0(%rbx,%r15), %rcx
movq %rcx, (%rsp)
movq %r14, %rdi
leaq 0x2c7f0(%rip), %rsi     # 0x55e3c
leaq 0x2c392(%rip), %r14     # 0x559e5
movq %r14, %rdx
movq %rax, %rcx
leaq 0x10(%rsp), %r8
movq %r13, %r9
xorl %eax, %eax
callq 0x1eace
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rdx
movl %r12d, %ecx
callq 0x28fc2
leaq 0x59eee(%rip), %rcx     # 0x83570
incq %rbp
addq $0x18, %r15
cmpq $0x1, %rbp
je 0x295c7
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x459d1(%rip), %rax     # 0x6f088
movl 0x140(%rax), %esi
testl %esi, %esi
je 0x29732
movl $0xc0, %edi
addq 0x448eb(%rip), %rdi     # 0x6dfb8
leaq 0x2c706(%rip), %r14     # 0x55dda
movq %r14, %rdx
callq 0x1fd83
movq %rax, %r15
leaq 0x2bf5f(%rip), %r12     # 0x55645
movq %r12, %rdi
callq 0x1de62
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1e66d
movq %rax, %rdi
movq %r15, %rsi
callq 0x1e764
movq %rax, %r14
movq %r15, %rdi
callq 0x1ded3
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl $0x1, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x28fc2
leaq 0x2bf0c(%rip), %rsi     # 0x55645
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x28d76
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/config.c
// Function: rewriteConfigGetContentFromState
sds rewriteConfigGetContentFromState(struct rewriteConfigState *state) {
    sds content = sdsempty();
    int j, was_empty = 0;

    for (j = 0; j < state->numlines; j++) {
        /* Every cluster of empty lines is turned into a single empty line. */
        if (sdslen(state->lines[j]) == 0) {
            if (was_empty) continue;
            was_empty = 1;
        } else {
            was_empty = 0;
        }
        content = sdscatsds(content,state->lines[j]);
        content = sdscatlen(content,"\n",1);
    }
    return content;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x1de3f
cmpl $0x0, 0x10(%rbx)
jle 0x297ee
xorl %r15d, %r15d
leaq 0x2a618(%rip), %r14     # 0x53d88
leaq 0x2bdb1(%rip), %r12     # 0x55528
xorl %ecx, %ecx
movq 0x18(%rbx), %rdx
movq (%rdx,%r15,8), %rsi
movzbl -0x1(%rsi), %edx
movl %edx, %edi
andl $0x7, %edi
cmpl $0x4, %edi
ja 0x297b4
movslq (%r12,%rdi,4), %rdi
addq %r12, %rdi
jmpq *%rdi
shrl $0x3, %edx
jmp 0x297b6
movq -0x11(%rsi), %rdx
jmp 0x297b6
movzwl -0x5(%rsi), %edx
jmp 0x297b6
movl -0x9(%rsi), %edx
jmp 0x297b6
movzbl -0x3(%rsi), %edx
jmp 0x297b6
xorl %edx, %edx
xorl %ebp, %ebp
testq %rdx, %rdx
je 0x297d7
movq %rax, %rdi
callq 0x1e764
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1e66d
jmp 0x297e0
movl $0x1, %ebp
testl %ecx, %ecx
je 0x297bd
incq %r15
movslq 0x10(%rbx), %rdx
movl %ebp, %ecx
cmpq %rdx, %r15
jl 0x29779
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/config.c
// Function: rewriteConfigReleaseState
void rewriteConfigReleaseState(struct rewriteConfigState *state) {
    sdsfreesplitres(state->lines,state->numlines);
    dictRelease(state->option_to_line);
    dictRelease(state->rewritten);
    zfree(state);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl 0x10(%rbx), %esi
callq 0x1f796
movq (%rbx), %rdi
callq 0x190b8
movq 0x8(%rbx), %rdi
callq 0x190b8
movq %rbx, %rdi
popq %rbx
jmp 0x1ffff
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/config.c
// Function: rewriteConfigRemoveOrphaned
void rewriteConfigRemoveOrphaned(struct rewriteConfigState *state) {
    dictIterator *di = dictGetIterator(state->option_to_line);
    dictEntry *de;

    while((de = dictNext(di)) != NULL) {
        list *l = dictGetVal(de);
        sds option = dictGetKey(de);

        /* Don't blank lines about options the rewrite process
         * don't understand. */
        if (dictFind(state->rewritten,option) == NULL) {
            serverLog(LL_DEBUG,"Not rewritten option: %s", option);
            continue;
        }

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

            sdsfree(state->lines[linenum]);
            state->lines[linenum] = sdsempty();
            listDelNode(l,ln);
        }
    }
    dictReleaseIterator(di);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x19242
movq %rax, %r14
movq %rax, %rdi
callq 0x1929d
testq %rax, %rax
je 0x298b9
leaq 0x2c5fe(%rip), %r15     # 0x55e4c
movq (%rax), %r13
movq 0x8(%rax), %r12
movq 0x8(%rbx), %rdi
movq %r13, %rsi
callq 0x190de
testq %rax, %rax
jne 0x298a4
xorl %edi, %edi
movq %r15, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x19fb1
jmp 0x298ac
movq (%r12), %r13
movslq 0x10(%r13), %rbp
movq 0x18(%rbx), %rax
movq (%rax,%rbp,8), %rdi
callq 0x1ded3
callq 0x1de3f
movq 0x18(%rbx), %rcx
movq %rax, (%rcx,%rbp,8)
movq %r12, %rdi
movq %r13, %rsi
callq 0x16be4
cmpq $0x0, 0x28(%r12)
jne 0x29877
movq %r14, %rdi
callq 0x1929d
testq %rax, %rax
jne 0x2984e
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1935a
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/config.c
// Function: rewriteConfigOverwriteFile
int rewriteConfigOverwriteFile(char *configfile, sds content) {
    int retval = 0;
    int fd = open(configfile,O_RDWR|O_CREAT,0644);
    int content_size = sdslen(content), padding = 0;
    struct stat sb;
    sds content_padded;

    /* 1) Open the old file (or create a new one if it does not
     *    exist), get the size. */
    if (fd == -1) return -1; /* errno set by open(). */
    if (fstat(fd,&sb) == -1) {
        close(fd);
        return -1; /* errno set by fstat(). */
    }

    /* 2) Pad the content at least match the old file size. */
    content_padded = sdsdup(content);
    if (content_size < sb.st_size) {
        /* If the old file was bigger, pad the content with
         * a newline plus as many "#" chars as required. */
        padding = sb.st_size - content_size;
        content_padded = sdsgrowzero(content_padded,sb.st_size);
        content_padded[content_size] = '\n';
        memset(content_padded+content_size+1,'#',padding-1);
    }

    /* 3) Write the new content using a single write(2). */
    if (write(fd,content_padded,strlen(content_padded)) == -1) {
        retval = -1;
        goto cleanup;
    }

    /* 4) Truncate the file to the right length if we used padding. */
    if (padding) {
        if (ftruncate(fd,content_size) == -1) {
            /* Non critical error... */
        }
    }

cleanup:
    sdsfree(content_padded);
    close(fd);
    return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
xorl %r12d, %r12d
movl $0x42, %esi
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x126f0
movl %eax, %ebx
movzbl -0x1(%r14), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x29938
leaq 0x2bc2d(%rip), %rdx     # 0x5553c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
shrl $0x3, %eax
movq %rax, %r12
jmp 0x29938
movq -0x11(%r14), %r12
jmp 0x29938
movzwl -0x5(%r14), %r12d
jmp 0x29938
movl -0x9(%r14), %r12d
jmp 0x29938
movzbl -0x3(%r14), %r12d
cmpl $-0x1, %ebx
je 0x299e7
leaq 0x8(%rsp), %rsi
movl %ebx, %edi
callq 0x128a0
cmpl $-0x1, %eax
je 0x299ee
movq %r14, %rdi
callq 0x1de83
movq %rax, %r14
movslq %r12d, %r15
movq 0x38(%rsp), %rsi
movb $0x1, %r13b
cmpq %rsi, %r15
jge 0x299a5
movl %esi, %r13d
subl %r12d, %r13d
movq %r14, %rdi
callq 0x1e59e
movq %rax, %r14
leaq (%rax,%r15), %rdi
incq %rdi
movb $0xa, -0x1(%rdi)
leal -0x1(%r13), %eax
movslq %eax, %rdx
movl $0x23, %esi
callq 0x12380
testl %r13d, %r13d
sete %r13b
movq %r14, %rdi
callq 0x12250
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x121e0
xorl %ebp, %ebp
cmpq $-0x1, %rax
sete %bpl
negl %ebp
cmpq $-0x1, %rax
je 0x299dd
testb %r13b, %r13b
jne 0x299dd
movl %ebx, %edi
movq %r15, %rsi
callq 0x12680
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x1ded3
jmp 0x299f3
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x299fa
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebx, %edi
callq 0x123b0
movl %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/config.c
// Function: configCommand
void configCommand(client *c) {
    if (!strcasecmp(c->argv[1]->ptr,"set")) {
        if (c->argc != 4) goto badarity;
        configSetCommand(c);
    } else if (!strcasecmp(c->argv[1]->ptr,"get")) {
        if (c->argc != 3) goto badarity;
        configGetCommand(c);
    } else if (!strcasecmp(c->argv[1]->ptr,"resetstat")) {
        if (c->argc != 2) goto badarity;
        resetServerStats();
        resetCommandTableStats();
        addReply(c,shared.ok);
    } else if (!strcasecmp(c->argv[1]->ptr,"rewrite")) {
        if (c->argc != 2) goto badarity;
        if (server.configfile == NULL) {
            addReplyError(c,"The server is running without a config file");
            return;
        }
        if (rewriteConfig(server.configfile) == -1) {
            serverLog(LL_WARNING,"CONFIG REWRITE failed: %s", strerror(errno));
            addReplyErrorFormat(c,"Rewriting config file: %s", strerror(errno));
        } else {
            serverLog(LL_WARNING,"CONFIG REWRITE executed with success.");
            addReply(c,shared.ok);
        }
    } else {
        addReplyError(c,
            "CONFIG subcommand must be one of GET, SET, RESETSTAT, REWRITE");
    }
    return;

badarity:
    addReplyErrorFormat(c,"Wrong number of arguments for CONFIG %s",
        (char*) c->argv[1]->ptr);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
leaq 0x294f3(%rip), %rsi     # 0x5325d
movq %r14, %rdi
callq 0x12090
testl %eax, %eax
je 0x29dc5
leaq 0x28777(%rip), %rsi     # 0x524f4
movq %r14, %rdi
callq 0x12090
testl %eax, %eax
je 0x29dde
leaq 0x2c0d5(%rip), %rsi     # 0x55e65
movq %r14, %rdi
callq 0x12090
testl %eax, %eax
je 0x29df3
leaq 0x2c0cc(%rip), %rsi     # 0x55e6f
movq %r14, %rdi
callq 0x12090
testl %eax, %eax
je 0x29e1d
leaq 0x2c147(%rip), %rsi     # 0x55efd
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2230a
cmpl $0x4, 0x28(%rbx)
jne 0x29e52
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2778f
cmpl $0x3, 0x28(%rbx)
jne 0x29e52
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x281dd
cmpl $0x2, 0x28(%rbx)
jne 0x29e52
callq 0x1bacb
callq 0x1bf7b
leaq 0x4598e(%rip), %rax     # 0x6f798
movq 0x8(%rax), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21f58
cmpl $0x2, 0x28(%rbx)
jne 0x29e52
leaq 0x4525e(%rip), %rax     # 0x6f088
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x29e6d
callq 0x29a0e
cmpl $-0x1, %eax
je 0x29e79
leaq 0x2c093(%rip), %rsi     # 0x55ed7
movl $0x3, %edi
xorl %eax, %eax
callq 0x19fb1
jmp 0x29e03
leaq 0x2c0e2(%rip), %rsi     # 0x55f3b
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22331
leaq 0x2c003(%rip), %rsi     # 0x55e77
jmp 0x29db6
callq 0x120d0
movq %rax, %r14
movl (%rax), %edi
callq 0x128f0
leaq 0x2c014(%rip), %rsi     # 0x55ea3
movl $0x3, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x19fb1
movl (%r14), %edi
callq 0x128f0
leaq 0x2c010(%rip), %rsi     # 0x55ebd
movq %rbx, %rdi
movq %rax, %rdx
jmp 0x29e5f
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/debug.c
// Function: xorDigest
void xorDigest(unsigned char *digest, void *ptr, size_t len) {
    SHA1_CTX ctx;
    unsigned char hash[20], *s = ptr;
    int j;

    SHA1Init(&ctx);
    SHA1Update(&ctx,s,len);
    SHA1Final(hash,&ctx);

    for (j = 0; j < 20; j++)
        digest[j] ^= hash[j];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1c(%rsp), %r12
movq %r12, %rdi
callq 0x213dd
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x213f8
movq %rsp, %rdi
movq %r12, %rsi
callq 0x214bb
xorl %eax, %eax
movb (%rsp,%rax), %cl
xorb %cl, (%rbx,%rax)
incq %rax
cmpq $0x14, %rax
jne 0x29ef4
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/debug.c
// Function: mixDigest
void mixDigest(unsigned char *digest, void *ptr, size_t len) {
    SHA1_CTX ctx;
    char *s = ptr;

    xorDigest(digest,s,len);
    SHA1Init(&ctx);
    SHA1Update(&ctx,digest,20);
    SHA1Final(digest,&ctx);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
callq 0x29eb8
leaq 0xc(%rsp), %r14
movq %r14, %rdi
callq 0x213dd
movq %r14, %rdi
movq %rbx, %rsi
movl $0x14, %edx
callq 0x213f8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x214bb
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/debug.c
// Function: serverAssert
void _serverAssert(char *estr, char *file, int line) {
    bugReportStart();
    serverLog(LL_WARNING,"=== ASSERTION FAILED ===");
    serverLog(LL_WARNING,"==> %s:%d '%s' is not true",file,line,estr);
#ifdef HAVE_BACKTRACE
    server.assert_failed = estr;
    server.assert_file = file;
    server.assert_line = line;
    serverLog(LL_WARNING,"(forcing SIGSEGV to print the bug report.)");
#endif
    *((char*)-1) = 'x';
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x44672(%rip), %r12     # 0x6f088
cmpl $0x0, 0x694(%r12)
jne 0x2aa40
leaq 0x2ba0e(%rip), %rsi     # 0x56436
movl $0x3, %edi
xorl %eax, %eax
callq 0x19fb1
movl $0x1, 0x694(%r12)
leaq 0x2b79b(%rip), %rsi     # 0x561e2
movl $0x3, %edi
xorl %eax, %eax
callq 0x19fb1
leaq 0x2b7a1(%rip), %rsi     # 0x561fb
movl $0x3, %edi
movq %r14, %rdx
movl %ebx, %ecx
movq %r15, %r8
xorl %eax, %eax
callq 0x19fb1
movq %r15, 0x680(%r12)
movq %r14, 0x688(%r12)
movl %ebx, 0x690(%r12)
leaq 0x2b789(%rip), %rsi     # 0x56216
movl $0x3, %edi
xorl %eax, %eax
callq 0x19fb1
movb $0x78, -0x1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/debug.c
// Function: bugReportStart
void bugReportStart(void) {
    if (server.bug_report_start == 0) {
        serverLog(LL_WARNING,
            "\n\n=== DISCNT BUG REPORT START: Cut & paste starting from here ===");
        server.bug_report_start = 1;
    }
}

// Assembly:
pushq %rbx
leaq 0x445d3(%rip), %rbx     # 0x6f088
cmpl $0x0, 0x694(%rbx)
jne 0x2aadb
leaq 0x2b971(%rip), %rsi     # 0x56436
movl $0x3, %edi
xorl %eax, %eax
callq 0x19fb1
movl $0x1, 0x694(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/debug.c
// Function: serverAssertPrintClientInfo
void _serverAssertPrintClientInfo(client *c) {
    int j;

    bugReportStart();
    serverLog(LL_WARNING,"=== ASSERTION FAILED CLIENT CONTEXT ===");
    serverLog(LL_WARNING,"client->flags = %d", c->flags);
    serverLog(LL_WARNING,"client->fd = %d", c->fd);
    serverLog(LL_WARNING,"client->argc = %d", c->argc);
    for (j=0; j < c->argc; j++) {
        char buf[128];
        char *arg;

        if (c->argv[j]->type == OBJ_STRING && sdsEncodedObject(c->argv[j])) {
            arg = (char*) c->argv[j]->ptr;
        } else {
            snprintf(buf,sizeof(buf),"Object type: %u, encoding: %u",
                c->argv[j]->type, c->argv[j]->encoding);
            arg = buf;
        }
        serverLog(LL_WARNING,"client->argv[%d] = \"%s\" (refcount: %d)",
            j, arg, c->argv[j]->refcount);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x44591(%rip), %r14     # 0x6f088
cmpl $0x0, 0x694(%r14)
jne 0x2ab1f
leaq 0x2b92e(%rip), %rsi     # 0x56436
movl $0x3, %edi
xorl %eax, %eax
callq 0x19fb1
movl $0x1, 0x694(%r14)
leaq 0x2b71b(%rip), %rsi     # 0x56241
movl $0x3, %edi
xorl %eax, %eax
callq 0x19fb1
movl 0x88(%rbx), %edx
leaq 0x2b72a(%rip), %rsi     # 0x56269
movl $0x3, %edi
xorl %eax, %eax
callq 0x19fb1
movl 0x8(%rbx), %edx
leaq 0x2b727(%rip), %rsi     # 0x5627c
movl $0x3, %edi
xorl %eax, %eax
callq 0x19fb1
movl 0x28(%rbx), %edx
leaq 0x2b721(%rip), %rsi     # 0x5628c
movl $0x3, %edi
xorl %eax, %eax
callq 0x19fb1
cmpl $0x0, 0x28(%rbx)
jle 0x2abfc
leaq 0x2b738(%rip), %r14     # 0x562bc
leaq 0x2b713(%rip), %r15     # 0x5629e
movq %rsp, %r12
xorl %r13d, %r13d
movq 0x30(%rbx), %rax
movq (%rax,%r13,8), %rax
movl (%rax), %r8d
movl %r8d, %ecx
andl $0xf, %ecx
je 0x2abc3
shrl $0x4, %r8d
andl $0xf, %r8d
movl $0x80, %esi
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x122d0
movq %r12, %rcx
jmp 0x2abd2
movl %r8d, %edx
shrl $0x4, %edx
testb $0xd, %dl
jne 0x2aba4
movq 0x8(%rax), %rcx
movq 0x30(%rbx), %rax
movq (%rax,%r13,8), %rax
movl 0x4(%rax), %r8d
movl $0x3, %edi
movq %r14, %rsi
movl %r13d, %edx
xorl %eax, %eax
callq 0x19fb1
incq %r13
movslq 0x28(%rbx), %rax
cmpq %rax, %r13
jl 0x2ab91
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq