LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x64(%rbp)
leaq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x40, %esi
callq 0x6ebc0
callq 0x384f0
movq %rax, %rdi
movq -0x10(%rbp), %rdx
leaq -0x60(%rbp), %rcx
leaq 0xd8388(%rip), %rsi     # 0x1470cc
movb $0x0, %al
callq 0x395b0
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x70(%rbp), %rdx
movl -0x64(%rbp), %ecx
callq 0x6ea90
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
callq 0x384f0
movq %rax, %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %esi
leaq 0xd5721(%rip), %rcx     # 0x1444ce
leaq 0xcc041(%rip), %rax     # 0x13adf5
cmpl $0x0, %esi
cmovneq %rax, %rcx
leaq 0xd830a(%rip), %rsi     # 0x1470cc
movb $0x0, %al
callq 0x395b0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x6ea90
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6ee28
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6e7e0
jmp 0x6eeaf
cmpq $0x0, -0x20(%rbp)
je 0x6ee48
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x268f0
cmpl $0x0, %eax
jne 0x6ee48
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x38510
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0xd02e9(%rip), %rsi     # 0x13f149
movl $0x1, %edx
callq 0x39040
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x264f0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x3a2c0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x6ea90
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x68630
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x3c(%rbp)
callq 0x384f0
movq %rax, %rdi
movq -0x10(%rbp), %rdx
movq -0x38(%rbp), %rcx
leaq 0xd80d9(%rip), %rsi     # 0x1470cc
movb $0x0, %al
callq 0x395b0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl -0x3c(%rbp), %ecx
callq 0x6ea90
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1091a5(%rip), %rax    # 0x1781d8
movl 0x7b8(%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x80, -0xc(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0xcf408(%rip), %rax     # 0x13e465
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %esi
leaq 0x108015(%rip), %rdi    # 0x177080
callq 0x68630
movq %rax, -0x18(%rbp)
callq 0x384f0
movq %rax, %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0xd8041(%rip), %rsi     # 0x1470cc
movb $0x0, %al
callq 0x395b0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x10(%rbp), %ecx
callq 0x6ea90
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x10910b(%rip), %rcx    # 0x1781d8
cmpl 0x740(%rcx), %eax
jge 0x6f14e
callq 0x384f0
movq %rax, %rdi
leaq 0x1090f4(%rip), %rax    # 0x1781d8
movq 0x738(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0x1090d8(%rip), %rax    # 0x1781d8
movq 0x738(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
leaq 0xd0077(%rip), %rsi     # 0x13f193
movb $0x0, %al
callq 0x395b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xce21a(%rip), %rsi     # 0x13d350
movl $0x1, %ecx
callq 0x6ea90
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6f0c3
movq -0x8(%rbp), %rdi
leaq 0xce1f7(%rip), %rsi     # 0x13d350
callq 0x6e7e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movq %rdi, -0x8(%rbp)
leaq -0x410(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x26910
cmpq $0x0, %rax
jne 0x6f1a8
movq -0x8(%rbp), %rdi
leaq 0xcf21d(%rip), %rsi     # 0x13e3be
callq 0x6e7e0
jmp 0x6f1c3
movq -0x8(%rbp), %rdi
leaq -0x410(%rbp), %rdx
leaq 0xcf204(%rip), %rsi     # 0x13e3be
xorl %eax, %eax
movl %eax, %ecx
callq 0x6edf0
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xc862e(%rip), %rax     # 0x137811
movq %rax, -0x10(%rbp)
leaq 0x108fea(%rip), %rax    # 0x1781d8
cmpl $0x0, 0x99c(%rax)
jne 0x6f208
leaq 0x108fda(%rip), %rax    # 0x1781d8
cmpq $0x0, 0x828(%rax)
jne 0x6f21a
movq -0x8(%rbp), %rdi
leaq 0xc85fe(%rip), %rsi     # 0x137811
callq 0x6e7e0
jmp 0x6f26a
callq 0x384f0
movq %rax, %rdi
movq -0x10(%rbp), %rdx
leaq 0x108fab(%rip), %rax    # 0x1781d8
movq 0x828(%rax), %rcx
leaq 0x108f9d(%rip), %rax    # 0x1781d8
movl 0x830(%rax), %r8d
leaq 0xd6da9(%rip), %rsi     # 0x145ff2
movb $0x0, %al
callq 0x395b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x1, %ecx
callq 0x6ea90
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x108f55(%rip), %rax    # 0x1781d8
cmpl $0x0, 0x998(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
leaq 0xcfa8b(%rip), %rax     # 0x13ed27
movq %rax, -0x18(%rbp)
leaq 0x108f31(%rip), %rax    # 0x1781d8
movl 0x998(%rax), %edi
callq 0x9cc60
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x38510
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0xcfe7b(%rip), %rsi     # 0x13f149
movl $0x1, %edx
callq 0x39040
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6a970
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x3a2c0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
callq 0x38620
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0xc(%rbp), %ecx
callq 0x6ea90
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
leaq 0xcee26(%rip), %rax     # 0x13e350
movq %rax, -0x28(%rbp)
leaq 0x108ca3(%rip), %rax    # 0x1781d8
cmpl $0x0, 0x128(%rax)
jne 0x6f54d
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6e7e0
jmp 0x6f5cc
leaq 0x108c84(%rip), %rax    # 0x1781d8
movl 0x128(%rax), %esi
leaq 0x108c77(%rip), %rdi    # 0x1781d8
addq $0xa8, %rdi
leaq 0xcfbda(%rip), %rdx     # 0x13f149
callq 0x3ab30
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
callq 0x38510
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xcfbb9(%rip), %rsi     # 0x13f149
movl $0x1, %edx
callq 0x39040
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x39110
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0x38620
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0xc(%rbp), %ecx
callq 0x6ea90
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x384f0
movq %rax, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x6f683
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x6a970
cmpq $0x0, %rax
jne 0x6f63b
cmpl $0x0, -0x18(%rbp)
je 0x6f632
jmp 0x6f678
movl $0x1, -0x18(%rbp)
jmp 0x6f642
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x39110
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xca7cf(%rip), %rsi     # 0x139e39
movl $0x1, %edx
callq 0x39040
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6f603
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x3a270
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2e230
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2e230
movq -0x8(%rbp), %rdi
callq 0x3afa0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2e400
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2e4a0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x6f7bb
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x2dcb0
cmpq $0x0, %rax
jne 0x6f757
movq -0x28(%rbp), %rdx
xorl %edi, %edi
leaq 0xcfa61(%rip), %rsi     # 0x13f1af
movb $0x0, %al
callq 0x2fc60
jmp 0x6f6fc
jmp 0x6f759
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x6f7b6
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x38620
callq 0x384f0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x34(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x271e0
jmp 0x6f759
jmp 0x6f6fc
movq -0x10(%rbp), %rdi
callq 0x2e600
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/aof.c
// Function: aofRewriteBufferReset
void aofRewriteBufferReset(void) {
    if (server.aof_rewrite_buf_blocks)
        listRelease(server.aof_rewrite_buf_blocks);

    server.aof_rewrite_buf_blocks = listCreate();
    listSetFreeMethod(server.aof_rewrite_buf_blocks,zfree);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x107c2d(%rip), %rax    # 0x1781d8
cmpq $0x0, 0x6a0(%rax)
je 0x705c8
leaq 0x107c1c(%rip), %rax    # 0x1781d8
movq 0x6a0(%rax), %rdi
callq 0x26ea0
callq 0x26e20
movq %rax, %rcx
leaq 0x107c01(%rip), %rax    # 0x1781d8
movq %rcx, 0x6a0(%rax)
leaq 0x107bf3(%rip), %rax    # 0x1781d8
movq 0x6a0(%rax), %rax
leaq -0x35653(%rip), %rcx    # 0x3afa0
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/aof.c
// Function: aofRewriteBufferSize
unsigned long aofRewriteBufferSize(void) {
    listNode *ln;
    listIter li;
    unsigned long size = 0;

    listRewind(server.aof_rewrite_buf_blocks,&li);
    while((ln = listNext(&li))) {
        aofrwblock *block = listNodeValue(ln);
        size += block->used;
    }
    return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq $0x0, -0x20(%rbp)
leaq 0x107bc1(%rip), %rax    # 0x1781d8
movq 0x6a0(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x27320
leaq -0x18(%rbp), %rdi
callq 0x27380
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x70657
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x70627
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/aof.c
// Function: aofChildWriteDiffData
void aofChildWriteDiffData(aeEventLoop *el, int fd, void *privdata, int mask) {
    listNode *ln;
    aofrwblock *block;
    ssize_t nwritten;
    UNUSED(el);
    UNUSED(fd);
    UNUSED(privdata);
    UNUSED(mask);

    while(1) {
        ln = listFirst(server.aof_rewrite_buf_blocks);
        block = ln ? ln->value : NULL;
        if (server.aof_stop_sending_diff || !block) {
            aeDeleteFileEvent(server.el,server.aof_pipe_write_data_to_child,
                              AE_WRITABLE);
            return;
        }
        if (block->used > 0) {
            nwritten = write(server.aof_pipe_write_data_to_child,
                             block->buf,block->used);
            if (nwritten <= 0) return;
            memmove(block->buf,block->buf+nwritten,block->used-nwritten);
            block->used -= nwritten;
            block->free += nwritten;
        }
        if (block->used == 0) listDelNode(server.aof_rewrite_buf_blocks,ln);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq 0x107b4b(%rip), %rax    # 0x1781d8
movq 0x6a0(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x706b0
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x706b8
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x706b8
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x107b11(%rip), %rax    # 0x1781d8
cmpl $0x0, 0x710(%rax)
jne 0x706d7
cmpq $0x0, -0x30(%rbp)
jne 0x706fe
leaq 0x107afa(%rip), %rax    # 0x1781d8
movq 0x40(%rax), %rdi
leaq 0x107aef(%rip), %rax    # 0x1781d8
movl 0x6f8(%rax), %esi
movl $0x2, %edx
callq 0x2aab0
jmp 0x707a1
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jbe 0x7077b
leaq 0x107ac9(%rip), %rax    # 0x1781d8
movl 0x6f8(%rax), %edi
movq -0x30(%rbp), %rsi
addq $0x10, %rsi
movq -0x30(%rbp), %rax
movq (%rax), %rdx
callq 0x26bc0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jg 0x70736
jmp 0x707a1
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movq -0x30(%rbp), %rsi
addq $0x10, %rsi
addq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rax
movq (%rax), %rdx
subq -0x38(%rbp), %rdx
callq 0x267e0
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rax
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x7079c
leaq 0x107a4c(%rip), %rax    # 0x1781d8
movq 0x6a0(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x271e0
jmp 0x70686
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/aof.c
// Function: aofRewriteBufferWrite
ssize_t aofRewriteBufferWrite(int fd) {
    listNode *ln;
    listIter li;
    ssize_t count = 0;

    listRewind(server.aof_rewrite_buf_blocks,&li);
    while((ln = listNext(&li))) {
        aofrwblock *block = listNodeValue(ln);
        ssize_t nwritten;

        if (block->used) {
            nwritten = write(fd,block->buf,block->used);
            if (nwritten != (ssize_t)block->used) {
                if (nwritten == 0) errno = EIO;
                return -1;
            }
            count += nwritten;
        }
    }
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq $0x0, -0x30(%rbp)
leaq 0x10780e(%rip), %rax    # 0x1781d8
movq 0x6a0(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x27320
leaq -0x28(%rbp), %rdi
callq 0x27380
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x70a55
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
je 0x70a53
movl -0xc(%rbp), %edi
movq -0x38(%rbp), %rsi
addq $0x10, %rsi
movq -0x38(%rbp), %rax
movq (%rax), %rdx
callq 0x26bc0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
cmpq (%rcx), %rax
je 0x70a47
cmpq $0x0, -0x40(%rbp)
jne 0x70a3d
callq 0x26880
movl $0x5, (%rax)
movq $-0x1, -0x8(%rbp)
jmp 0x70a5d
movq -0x40(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x709da
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/aof.c
// Function: stopAppendOnly
void stopAppendOnly(void) {
    serverAssert(server.aof_state != AOF_OFF);
    flushAppendOnlyFile(1);
    aof_fsync(server.aof_fd);
    close(server.aof_fd);

    server.aof_fd = -1;
    server.aof_selected_db = -1;
    server.aof_state = AOF_OFF;
    /* rewrite operation in progress? kill it, wait child exit */
    if (server.aof_child_pid != -1) {
        int statloc;

        serverLog(LL_NOTICE,"Killing running AOF rewrite child: %ld",
            (long) server.aof_child_pid);
        if (kill(server.aof_child_pid,SIGUSR1) != -1) {
            while(wait3(&statloc,0,NULL) != server.aof_child_pid);
        }
        /* reset the buffer accumulating changes while the child saves */
        aofRewriteBufferReset();
        aofRemoveTempFile(server.aof_child_pid);
        server.aof_child_pid = -1;
        server.aof_rewrite_time_start = -1;
        /* close pipes used for IPC between the two processes. */
        aofClosePipes();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x107729(%rip), %rax    # 0x1781d8
cmpl $0x0, 0x668(%rax)
je 0x70aba
jmp 0x70adc
leaq 0xce89a(%rip), %rdi     # 0x13f35b
leaq 0xce8af(%rip), %rsi     # 0x13f377
movl $0xd1, %edx
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movl $0x1, %edi
callq 0x70c00
leaq 0x1076eb(%rip), %rax    # 0x1781d8
movl 0x6b0(%rax), %edi
callq 0x26560
leaq 0x1076d9(%rip), %rax    # 0x1781d8
movl 0x6b0(%rax), %edi
callq 0x26180
leaq 0x1076c7(%rip), %rax    # 0x1781d8
movl $0xffffffff, 0x6b0(%rax) # imm = 0xFFFFFFFF
leaq 0x1076b6(%rip), %rax    # 0x1781d8
movl $0xffffffff, 0x6b4(%rax) # imm = 0xFFFFFFFF
leaq 0x1076a5(%rip), %rax    # 0x1781d8
movl $0x0, 0x668(%rax)
leaq 0x107694(%rip), %rax    # 0x1781d8
cmpl $-0x1, 0x69c(%rax)
je 0x70bf1
leaq 0x107680(%rip), %rax    # 0x1781d8
movslq 0x69c(%rax), %rdx
movl $0x2, %edi
leaq 0xce812(%rip), %rsi     # 0x13f37d
movb $0x0, %al
callq 0x2fc60
leaq 0x10765f(%rip), %rax    # 0x1781d8
movl 0x69c(%rax), %edi
movl $0xa, %esi
callq 0x26670
cmpl $-0x1, %eax
je 0x70bb2
jmp 0x70b90
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x26870
leaq 0x107632(%rip), %rcx    # 0x1781d8
cmpl 0x69c(%rcx), %eax
je 0x70bb0
jmp 0x70b90
jmp 0x70bb2
callq 0x705a0
leaq 0x10761a(%rip), %rax    # 0x1781d8
movl 0x69c(%rax), %edi
callq 0x712c0
leaq 0x107608(%rip), %rax    # 0x1781d8
movl $0xffffffff, 0x69c(%rax) # imm = 0xFFFFFFFF
leaq 0x1075f7(%rip), %rax    # 0x1781d8
movq $-0x1, 0x6d0(%rax)
callq 0x71300
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/aof.c
// Function: aofClosePipes
void aofClosePipes(void) {
    aeDeleteFileEvent(server.el,server.aof_pipe_read_ack_from_child,AE_READABLE);
    aeDeleteFileEvent(server.el,server.aof_pipe_write_data_to_child,AE_WRITABLE);
    close(server.aof_pipe_write_data_to_child);
    close(server.aof_pipe_read_data_from_parent);
    close(server.aof_pipe_write_ack_to_parent);
    close(server.aof_pipe_read_ack_from_child);
    close(server.aof_pipe_write_ack_to_child);
    close(server.aof_pipe_read_ack_from_parent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x106ecd(%rip), %rax    # 0x1781d8
movq 0x40(%rax), %rdi
leaq 0x106ec2(%rip), %rax    # 0x1781d8
movl 0x704(%rax), %esi
movl $0x1, %edx
callq 0x2aab0
leaq 0x106eab(%rip), %rax    # 0x1781d8
movq 0x40(%rax), %rdi
leaq 0x106ea0(%rip), %rax    # 0x1781d8
movl 0x6f8(%rax), %esi
movl $0x2, %edx
callq 0x2aab0
leaq 0x106e89(%rip), %rax    # 0x1781d8
movl 0x6f8(%rax), %edi
callq 0x26180
leaq 0x106e77(%rip), %rax    # 0x1781d8
movl 0x6fc(%rax), %edi
callq 0x26180
leaq 0x106e65(%rip), %rax    # 0x1781d8
movl 0x700(%rax), %edi
callq 0x26180
leaq 0x106e53(%rip), %rax    # 0x1781d8
movl 0x704(%rax), %edi
callq 0x26180
leaq 0x106e41(%rip), %rax    # 0x1781d8
movl 0x708(%rax), %edi
callq 0x26180
leaq 0x106e2f(%rip), %rax    # 0x1781d8
movl 0x70c(%rax), %edi
callq 0x26180
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/aof.c
// Function: catAppendOnlyGenericCommand
sds catAppendOnlyGenericCommand(sds dst, int argc, robj **argv) {
    char buf[32];
    int len, j;
    robj *o;

    buf[0] = '*';
    len = 1+ll2string(buf+1,sizeof(buf)-1,argc);
    buf[len++] = '\r';
    buf[len++] = '\n';
    dst = sdscatlen(dst,buf,len);

    for (j = 0; j < argc; j++) {
        o = getDecodedObject(argv[j]);
        buf[0] = '$';
        len = 1+ll2string(buf+1,sizeof(buf)-1,sdslen(o->ptr));
        buf[len++] = '\r';
        buf[len++] = '\n';
        dst = sdscatlen(dst,buf,len);
        dst = sdscatlen(dst,o->ptr,sdslen(o->ptr));
        dst = sdscatlen(dst,"\r\n",2);
        decrRefCount(o);
    }
    return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x2a, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
addq $0x1, %rdi
movslq -0xc(%rbp), %rdx
movl $0x1f, %esi
callq 0x477e0
addl $0x1, %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x44(%rbp)
cltq
movb $0xd, -0x40(%rbp,%rax)
movl -0x44(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x44(%rbp)
cltq
movb $0xa, -0x40(%rbp,%rax)
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movslq -0x44(%rbp), %rdx
callq 0x39040
movq %rax, -0x8(%rbp)
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x71b36
movq -0x18(%rbp), %rax
movslq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x494f0
movq %rax, -0x50(%rbp)
movb $0x24, -0x40(%rbp)
leaq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x71850
movq -0x68(%rbp), %rdi
movq %rax, %rdx
movl $0x1f, %esi
callq 0x477e0
addl $0x1, %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x44(%rbp)
cltq
movb $0xd, -0x40(%rbp,%rax)
movl -0x44(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x44(%rbp)
cltq
movb $0xa, -0x40(%rbp,%rax)
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movslq -0x44(%rbp), %rdx
callq 0x39040
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x71850
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rdx
callq 0x39040
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xcc777(%rip), %rsi     # 0x13e288
movl $0x2, %edx
callq 0x39040
movq %rax, -0x8(%rbp)
movq -0x50(%rbp), %rdi
callq 0x48f70
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x71a43
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/aof.c
// Function: catAppendOnlyExpireAtCommand
sds catAppendOnlyExpireAtCommand(sds buf, struct redisCommand *cmd, robj *key, robj *seconds) {
    long long when;
    robj *argv[3];

    /* Make sure we can use strtoll */
    seconds = getDecodedObject(seconds);
    when = strtoll(seconds->ptr,NULL,10);
    /* Convert argument into milliseconds for EXPIRE, SETEX, EXPIREAT */
    if (cmd->proc == expireCommand || cmd->proc == setexCommand ||
        cmd->proc == expireatCommand)
    {
        when *= 1000;
    }
    /* Convert into absolute time for EXPIRE, PEXPIRE, SETEX, PSETEX */
    if (cmd->proc == expireCommand || cmd->proc == pexpireCommand ||
        cmd->proc == setexCommand || cmd->proc == psetexCommand)
    {
        when += mstime();
    }
    decrRefCount(seconds);

    argv[0] = createStringObject("PEXPIREAT",9);
    argv[1] = key;
    argv[2] = createStringObjectFromLongLong(when);
    buf = catAppendOnlyGenericCommand(buf, 3, argv);
    decrRefCount(argv[0]);
    decrRefCount(argv[2]);
    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x494f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x26af0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
leaq -0x250ba(%rip), %rcx    # 0x4cad0
cmpq %rcx, 0x8(%rax)
je 0x71bb2
movq -0x10(%rbp), %rax
leaq -0x19edb(%rip), %rcx    # 0x57cc0
cmpq %rcx, 0x8(%rax)
je 0x71bb2
movq -0x10(%rbp), %rax
leaq -0x250ac(%rip), %rcx    # 0x4cb00
cmpq %rcx, 0x8(%rax)
jne 0x71bbe
imulq $0x3e8, -0x28(%rbp), %rax # imm = 0x3E8
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
leaq -0x250f9(%rip), %rcx    # 0x4cad0
cmpq %rcx, 0x8(%rax)
je 0x71c02
movq -0x10(%rbp), %rax
leaq -0x250aa(%rip), %rcx    # 0x4cb30
cmpq %rcx, 0x8(%rax)
je 0x71c02
movq -0x10(%rbp), %rax
leaq -0x19f2b(%rip), %rcx    # 0x57cc0
cmpq %rcx, 0x8(%rax)
je 0x71c02
movq -0x10(%rbp), %rax
leaq -0x19ebc(%rip), %rcx    # 0x57d40
cmpq %rcx, 0x8(%rax)
jne 0x71c0f
callq 0x2ff70
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x48f70
leaq 0xcdb78(%rip), %rdi     # 0x13f797
movl $0x9, %esi
callq 0x486a0
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x486f0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rdx
movl $0x3, %esi
callq 0x719d0
movq %rax, -0x8(%rbp)
movq -0x40(%rbp), %rdi
callq 0x48f70
movq -0x30(%rbp), %rdi
callq 0x48f70
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/aof.c
// Function: createFakeClient
struct client *createFakeClient(void) {
    struct client *c = zmalloc(sizeof(*c));

    selectDb(c,0);
    c->fd = -1;
    c->name = NULL;
    c->querybuf = sdsempty();
    c->querybuf_peak = 0;
    c->argc = 0;
    c->argv = NULL;
    c->bufpos = 0;
    c->flags = 0;
    c->btype = BLOCKED_NONE;
    /* We set the fake client as a slave waiting for the synchronization
     * so that Redis will not try to send replies to this client. */
    c->replstate = SLAVE_STATE_WAIT_BGSAVE_START;
    c->reply = listCreate();
    c->reply_bytes = 0;
    c->obuf_soft_limit_reached_time = 0;
    c->watched_keys = listCreate();
    c->peerid = NULL;
    listSetFreeMethod(c->reply,decrRefCountVoid);
    listSetDupMethod(c->reply,dupClientReplyValue);
    initClientMultiState(c);
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x41c8, %edi           # imm = 0x41C8
callq 0x3acd0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x4aef0
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
callq 0x384f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1c0(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x98(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x168(%rax)
movq -0x8(%rbp), %rax
movl $0x6, 0xa0(%rax)
callq 0x26e20
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x90(%rax)
callq 0x26e20
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x1a0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x1b8(%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
leaq -0x290ff(%rip), %rcx    # 0x49060
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
leaq -0x30432(%rip), %rcx    # 0x41d40
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x75750
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/aof.c
// Function: freeFakeClientArgv
void freeFakeClientArgv(struct client *c) {
    int j;

    for (j = 0; j < c->argc; j++)
        decrRefCount(c->argv[j]);
    zfree(c->argv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x721cf
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x48f70
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x721a3
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x3afa0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/aof.c
// Function: freeFakeClient
void freeFakeClient(struct client *c) {
    sdsfree(c->querybuf);
    listRelease(c->reply);
    listRelease(c->watched_keys);
    freeClientMultiState(c);
    zfree(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x38620
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x26ea0
movq -0x8(%rbp), %rax
movq 0x1a0(%rax), %rdi
callq 0x26ea0
movq -0x8(%rbp), %rdi
callq 0x75780
movq -0x8(%rbp), %rdi
callq 0x3afa0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/aof.c
// Function: aofUpdateCurrentSize
void aofUpdateCurrentSize(void) {
    struct redis_stat sb;
    mstime_t latency;

    latencyStartMonitor(latency);
    if (redis_fstat(server.aof_fd,&sb) == -1) {
        serverLog(LL_WARNING,"Unable to obtain the AOF file length. stat: %s",
            strerror(errno));
    } else {
        server.aof_current_size = sb.st_size;
    }
    latencyEndMonitor(latency);
    latencyAddSampleIfNeeded("aof-fstat",latency);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq 0x105906(%rip), %rax    # 0x1781d8
cmpq $0x0, 0xa18(%rax)
je 0x728ea
callq 0x2ff70
movq %rax, -0x98(%rbp)
jmp 0x728f5
movq $0x0, -0x98(%rbp)
leaq 0x1058dc(%rip), %rax    # 0x1781d8
movl 0x6b0(%rax), %edi
leaq -0x90(%rbp), %rsi
callq 0x266f0
cmpl $-0x1, %eax
jne 0x72937
callq 0x26880
movl (%rax), %edi
callq 0x26690
movq %rax, %rdx
movl $0x3, %edi
leaq 0xcd5d0(%rip), %rsi     # 0x13fefe
movb $0x0, %al
callq 0x2fc60
jmp 0x72949
movq -0x60(%rbp), %rcx
leaq 0x105896(%rip), %rax    # 0x1781d8
movq %rcx, 0x690(%rax)
leaq 0x105888(%rip), %rax    # 0x1781d8
cmpq $0x0, 0xa18(%rax)
je 0x7296d
callq 0x2ff70
subq -0x98(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq 0x105864(%rip), %rax    # 0x1781d8
cmpq $0x0, 0xa18(%rax)
je 0x729a8
movq -0x98(%rbp), %rax
leaq 0x10584c(%rip), %rcx    # 0x1781d8
cmpq 0xa18(%rcx), %rax
jl 0x729a8
movq -0x98(%rbp), %rsi
leaq 0xcd58a(%rip), %rdi     # 0x13ff2d
callq 0xa1210
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/aof.c
// Function: rioWriteBulkObject
int rioWriteBulkObject(rio *r, robj *obj) {
    /* Avoid using getDecodedObject to help copy-on-write (we are often
     * in a child process when this function is called). */
    if (obj->encoding == OBJ_ENCODING_INT) {
        return rioWriteBulkLongLong(r,(long)obj->ptr);
    } else if (sdsEncodedObject(obj)) {
        return rioWriteBulkString(r,obj->ptr,sdslen(obj->ptr));
    } else {
        serverPanic("Unknown string encoding");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x1, %eax
jne 0x729f7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x8ea70
movl %eax, -0x4(%rbp)
jmp 0x72a71
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x72a19
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x72a4f
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x71850
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x8e9c0
movl %eax, -0x4(%rbp)
jmp 0x72a71
leaq 0xc8d51(%rip), %rdi     # 0x13b7a7
leaq 0xcc91a(%rip), %rsi     # 0x13f377
movl $0x31e, %edx            # imm = 0x31E
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/aof.c
// Function: rewriteHashObject
int rewriteHashObject(rio *r, robj *key, robj *o) {
    hashTypeIterator *hi;
    long long count = 0, items = hashTypeLength(o);

    hi = hashTypeInitIterator(o);
    while (hashTypeNext(hi) != C_ERR) {
        if (count == 0) {
            int cmd_items = (items > AOF_REWRITE_ITEMS_PER_CMD) ?
                AOF_REWRITE_ITEMS_PER_CMD : items;

            if (rioWriteBulkCount(r,'*',2+cmd_items*2) == 0) return 0;
            if (rioWriteBulkString(r,"HMSET",5) == 0) return 0;
            if (rioWriteBulkObject(r,key) == 0) return 0;
        }

        if (rioWriteHashIteratorCursor(r, hi, OBJ_HASH_KEY) == 0) return 0;
        if (rioWriteHashIteratorCursor(r, hi, OBJ_HASH_VALUE) == 0) return 0;
        if (++count == AOF_REWRITE_ITEMS_PER_CMD) count = 0;
        items--;
    }

    hashTypeReleaseIterator(hi);

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x66c10
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x66e10
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x66f00
cmpl $-0x1, %eax
je 0x7348b
cmpq $0x0, -0x30(%rbp)
jne 0x73420
cmpq $0x40, -0x38(%rbp)
jle 0x733a5
movl $0x40, %eax
movq %rax, -0x48(%rbp)
jmp 0x733ad
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %edx
shll %edx
addl $0x2, %edx
movl $0x2a, %esi
callq 0x8e820
cmpq $0x0, %rax
jne 0x733dc
movl $0x0, -0x4(%rbp)
jmp 0x7349b
movq -0x10(%rbp), %rdi
leaq 0xcad7e(%rip), %rsi     # 0x13e165
movl $0x5, %edx
callq 0x8e9c0
cmpq $0x0, %rax
jne 0x73403
movl $0x0, -0x4(%rbp)
jmp 0x7349b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x729c0
cmpl $0x0, %eax
jne 0x7341e
movl $0x0, -0x4(%rbp)
jmp 0x7349b
jmp 0x73420
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x734b0
cmpl $0x0, %eax
jne 0x73440
movl $0x0, -0x4(%rbp)
jmp 0x7349b
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x2, %edx
callq 0x734b0
cmpl $0x0, %eax
jne 0x73460
movl $0x0, -0x4(%rbp)
jmp 0x7349b
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
cmpq $0x40, %rax
jne 0x7347a
movq $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x73376
movq -0x28(%rbp), %rdi
callq 0x66ec0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/aof.c
// Function: rioWriteHashIteratorCursor
static int rioWriteHashIteratorCursor(rio *r, 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) {
            return rioWriteBulkString(r, (char*)vstr, vlen);
        } else {
            return rioWriteBulkLongLong(r, vll);
        }

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

        hashTypeCurrentFromHashTable(hi, what, &value);
        return rioWriteBulkObject(r, value);
    }

    serverPanic("Unknown hash encoding");
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x5, 0x8(%rax)
jne 0x73532
movq $0x0, -0x28(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
leaq -0x28(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
leaq -0x38(%rbp), %r8
callq 0x67090
cmpq $0x0, -0x28(%rbp)
je 0x73520
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %eax
movl %eax, %edx
callq 0x8e9c0
movl %eax, -0x4(%rbp)
jmp 0x73582
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x8ea70
movl %eax, -0x4(%rbp)
jmp 0x73582
movq -0x18(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x7355e
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
leaq -0x40(%rbp), %rdx
callq 0x67180
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x729c0
movl %eax, -0x4(%rbp)
jmp 0x73582
jmp 0x73560
leaq 0xc9cad(%rip), %rdi     # 0x13d214
leaq 0xcbe09(%rip), %rsi     # 0x13f377
movl $0x3d2, %edx            # imm = 0x3D2
callq 0x76d80
movl $0x1, %edi
callq 0x263c0
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/aof.c
// Function: aofReadDiffFromParent
ssize_t aofReadDiffFromParent(void) {
    char buf[65536]; /* Default pipe buffer size on most Linux systems. */
    ssize_t nread, total = 0;

    while ((nread =
            read(server.aof_pipe_read_data_from_parent,buf,sizeof(buf))) > 0) {
        server.aof_child_diff = sdscatlen(server.aof_child_diff,buf,nread);
        total += nread;
    }
    return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10010, %rsp          # imm = 0x10010
movq $0x0, -0x10010(%rbp)
leaq 0x104c2b(%rip), %rax    # 0x1781d8
movl 0x6fc(%rax), %edi
leaq -0x10000(%rbp), %rsi
movl $0x10000, %edx          # imm = 0x10000
callq 0x26340
movq %rax, -0x10008(%rbp)
cmpq $0x0, %rax
jle 0x7361a
leaq 0x104c00(%rip), %rax    # 0x1781d8
movq 0x718(%rax), %rdi
leaq -0x10000(%rbp), %rsi
movq -0x10008(%rbp), %rdx
callq 0x39040
movq %rax, %rcx
leaq 0x104bdc(%rip), %rax    # 0x1781d8
movq %rcx, 0x718(%rax)
movq -0x10008(%rbp), %rax
addq -0x10010(%rbp), %rax
movq %rax, -0x10010(%rbp)
jmp 0x735a6
movq -0x10010(%rbp), %rax
addq $0x10010, %rsp          # imm = 0x10010
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/aof.c
// Function: aofChildPipeReadable
void aofChildPipeReadable(aeEventLoop *el, int fd, void *privdata, int mask) {
    char byte;
    UNUSED(el);
    UNUSED(privdata);
    UNUSED(mask);

    if (read(fd,&byte,1) == 1 && byte == '!') {
        serverLog(LL_NOTICE,"AOF rewrite child asks to stop sending diffs.");
        server.aof_stop_sending_diff = 1;
        if (write(server.aof_pipe_write_ack_to_child,"!",1) != 1) {
            /* If we can't send the ack, inform the user, but don't try again
             * since in the other side the children will use a timeout if the
             * kernel can't buffer our write, or, the children was
             * terminated. */
            serverLog(LL_WARNING,"Can't send ACK to AOF child: %s",
                strerror(errno));
        }
    }
    /* Remove the handler since this can be called only one time during a
     * rewrite. */
    aeDeleteFileEvent(server.el,server.aof_pipe_read_ack_from_child,AE_READABLE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0xc(%rbp), %edi
leaq -0x1d(%rbp), %rsi
movl $0x1, %edx
callq 0x26340
cmpq $0x1, %rax
jne 0x74012
movsbl -0x1d(%rbp), %eax
cmpl $0x21, %eax
jne 0x74012
movl $0x2, %edi
leaq 0xcbd66(%rip), %rsi     # 0x13fd18
movb $0x0, %al
callq 0x2fc60
leaq 0x104218(%rip), %rax    # 0x1781d8
movl $0x1, 0x710(%rax)
leaq 0x104207(%rip), %rax    # 0x1781d8
movl 0x708(%rax), %edi
leaq 0xcb933(%rip), %rsi     # 0x13f911
movl $0x1, %edx
callq 0x26bc0
cmpq $0x1, %rax
je 0x74010
callq 0x26880
movl (%rax), %edi
callq 0x26690
movq %rax, %rdx
movl $0x3, %edi
leaq 0xcbd3d(%rip), %rsi     # 0x13fd46
movb $0x0, %al
callq 0x2fc60
jmp 0x74012
leaq 0x1041bf(%rip), %rax    # 0x1781d8
movq 0x40(%rax), %rdi
leaq 0x1041b4(%rip), %rax    # 0x1781d8
movl 0x704(%rax), %esi
movl $0x1, %edx
callq 0x2aab0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)