LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/server.c
// Function: databasesCron
void databasesCron(void) {
    /* Expire keys by random sampling. Not required for slaves
     * as master will synthesize DELs for us. */
    if (server.active_expire_enabled && server.masterhost == NULL)
        activeExpireCycle(ACTIVE_EXPIRE_CYCLE_SLOW);

    /* Perform hash tables rehashing if needed, but only if there are no
     * other processes saving the DB on disk. Otherwise rehashing is bad
     * as will cause a lot of copy-on-write of memory pages. */
    if (server.rdb_child_pid == -1 && server.aof_child_pid == -1) {
        /* We use global counters so if we stop the computation at a given
         * DB we'll be able to start from the successive in the next
         * cron loop iteration. */
        static unsigned int resize_db = 0;
        static unsigned int rehash_db = 0;
        int dbs_per_call = CRON_DBS_PER_CALL;
        int j;

        /* Don't test more DBs than we have. */
        if (dbs_per_call > server.dbnum) dbs_per_call = server.dbnum;

        /* Resize */
        for (j = 0; j < dbs_per_call; j++) {
            tryResizeHashTables(resize_db % server.dbnum);
            resize_db++;
        }

        /* Rehash */
        if (server.activerehashing) {
            for (j = 0; j < dbs_per_call; j++) {
                int work_done = incrementallyRehash(rehash_db % server.dbnum);
                rehash_db++;
                if (work_done) {
                    /* If the function did some work, stop here, we'll do
                     * more at the next cron loop. */
                    break;
                }
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x0, 0xd3198(%rip)     # 0x106e4c
je 0x33cc7
cmpq $0x0, 0xd33b2(%rip)     # 0x107070
jne 0x33cc7
xorl %edi, %edi
callq 0x335df
cmpl $-0x1, 0xd32aa(%rip)    # 0x106f78
jne 0x33d4f
cmpl $-0x1, 0xd320d(%rip)    # 0x106ee4
jne 0x33d4f
movl 0xd3179(%rip), %ebp     # 0x106e58
cmpl $0x10, %ebp
movl $0x10, %ebx
cmovll %ebp, %ebx
testl %ebp, %ebp
jle 0x33d11
movl %ebx, %r14d
movl 0xd35b1(%rip), %eax     # 0x1072a8
xorl %edx, %edx
divl 0xd3159(%rip)           # 0x106e58
movl %edx, %edi
callq 0x33468
incl 0xd359c(%rip)           # 0x1072a8
decl %r14d
jne 0x33cf1
cmpl $0x0, 0xd2b90(%rip)     # 0x1068a8
sete %al
testl %ebp, %ebp
setle %cl
orb %al, %cl
jne 0x33d4f
decl %ebx
movl 0xd3580(%rip), %eax     # 0x1072ac
xorl %edx, %edx
divl 0xd3124(%rip)           # 0x106e58
movl %edx, %edi
callq 0x334de
incl 0xd356b(%rip)           # 0x1072ac
subl $0x1, %ebx
setb %cl
testl %eax, %eax
jne 0x33d4f
testb %cl, %cl
je 0x33d26
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/server.c
// Function: beforeSleep
void beforeSleep(struct aeEventLoop *eventLoop) {
    UNUSED(eventLoop);

    /* Call the Redis Cluster before sleep function. Note that this function
     * may change the state of Redis Cluster (from ok to fail or vice versa),
     * so it's a good idea to call it before serving the unblocked clients
     * later in this function. */
    if (server.cluster_enabled) clusterBeforeSleep();

    /* Run a fast expire cycle (the called function will return
     * ASAP if a fast cycle is not needed). */
    if (server.active_expire_enabled && server.masterhost == NULL)
        activeExpireCycle(ACTIVE_EXPIRE_CYCLE_FAST);

    /* Send all the slaves an ACK request if at least one client blocked
     * during the previous event loop iteration. */
    if (server.get_ack_from_slaves) {
        robj *argv[3];

        argv[0] = createStringObject("REPLCONF",8);
        argv[1] = createStringObject("GETACK",6);
        argv[2] = createStringObject("*",1); /* Not used argument. */
        replicationFeedSlaves(server.slaves, server.slaveseldb, argv, 3);
        decrRefCount(argv[0]);
        decrRefCount(argv[1]);
        decrRefCount(argv[2]);
        server.get_ack_from_slaves = 0;
    }

    /* Unblock all the clients blocked for synchronous replication
     * in WAIT. */
    if (listLength(server.clients_waiting_acks))
        processClientsWaitingReplicas();

    /* Try to process pending commands for clients that were just unblocked. */
    if (listLength(server.unblocked_clients))
        processUnblockedClients();

    /* Write the AOF buffer on disk */
    flushAppendOnlyFile(0);

    /* Handle writes with pending output buffers. */
    handleClientsWithPendingWrites();

#ifdef AOF_NO_COW
    if(server.aof_child_pid != -1 && server.aof_no_cow.enable)
        aofNoCowSlowDown();
#endif
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
cmpl $0x0, 0xd2e24(%rip)     # 0x1071e4
je 0x343c7
callq 0x6dbc8
cmpl $0x0, 0xd2a7e(%rip)     # 0x106e4c
je 0x343e4
cmpq $0x0, 0xd2c98(%rip)     # 0x107070
jne 0x343e4
movl $0x1, %edi
callq 0x335df
cmpl $0x0, 0xd2d5d(%rip)     # 0x107148
je 0x3446c
leaq 0x8b785(%rip), %rdi     # 0xbfb79
movl $0x8, %esi
callq 0x43ba8
movq %rsp, %rbx
movq %rax, (%rbx)
leaq 0x8b777(%rip), %rdi     # 0xbfb82
movl $0x6, %esi
callq 0x43ba8
movq %rax, 0x8(%rbx)
leaq 0x8b769(%rip), %rdi     # 0xbfb89
movl $0x1, %esi
callq 0x43ba8
movq %rax, 0x10(%rbx)
movq 0xd2603(%rip), %rdi     # 0x106a38
movl 0xd2bc9(%rip), %esi     # 0x107004
movq %rbx, %rdx
movl $0x3, %ecx
callq 0x47393
movq (%rbx), %rdi
callq 0x440f3
movq 0x8(%rbx), %rdi
callq 0x440f3
movq 0x10(%rbx), %rdi
callq 0x440f3
movl $0x0, 0xd2cdc(%rip)     # 0x107148
movq 0xd2ccd(%rip), %rax     # 0x107140
cmpq $0x0, 0x28(%rax)
je 0x3447f
callq 0x4a731
movq 0xd2ce2(%rip), %rax     # 0x107168
cmpq $0x0, 0x28(%rax)
je 0x34492
callq 0x8061b
xorl %edi, %edi
callq 0x60d6c
callq 0x411b0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/server.c
// Function: resetServerStats
void resetServerStats(void) {
    int j;

    server.stat_numcommands = 0;
    server.stat_numconnections = 0;
    server.stat_expiredkeys = 0;
    server.stat_evictedkeys = 0;
    server.stat_keyspace_misses = 0;
    server.stat_keyspace_hits = 0;
    server.stat_fork_time = 0;
    server.stat_fork_rate = 0;
    server.stat_rejected_conn = 0;
    server.stat_sync_full = 0;
    server.stat_sync_partial_ok = 0;
    server.stat_sync_partial_err = 0;
    for (j = 0; j < STATS_METRIC_COUNT; j++) {
        server.inst_metric[j].idx = 0;
        server.inst_metric[j].last_sample_time = mstime();
        server.inst_metric[j].last_sample_count = 0;
        memset(server.inst_metric[j].samples,0,
            sizeof(server.inst_metric[j].samples));
    }
    server.stat_net_input_bytes = 0;
    server.stat_net_output_bytes = 0;
    server.aof_delayed_fsync = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
xorps %xmm0, %xmm0
movups %xmm0, 0xd15f9(%rip)    # 0x106bf8
movups %xmm0, 0xd15e2(%rip)    # 0x106be8
movups %xmm0, 0xd15cb(%rip)    # 0x106bd8
movups %xmm0, 0xd15fc(%rip)    # 0x106c10
movups %xmm0, 0xd1605(%rip)    # 0x106c20
movups %xmm0, 0xd160e(%rip)    # 0x106c30
xorl %r15d, %r15d
leaq 0xd122c(%rip), %r12     # 0x106858
movq %rsp, %rbx
movabsq $0x20c49ba5e353f7cf, %r13 # imm = 0x20C49BA5E353F7CF
leaq (%r15,%r12), %r14
addq $0x428, %r14            # imm = 0x428
movl $0x0, 0x88(%r14)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x26310
imulq $0xf4240, (%rsp), %rax  # imm = 0xF4240
addq 0x8(%rsp), %rax
imulq %r13
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
movq %rdx, -0x8(%r14)
movl $0x88, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x26110
addq $0x98, %r15
cmpq $0x1c8, %r15            # imm = 0x1C8
jne 0x35639
movq $0x0, 0xd1883(%rip) # 0x106f28
xorps %xmm0, %xmm0
movups %xmm0, 0xd15b9(%rip)    # 0x106c68
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/server.c
// Function: propagate
void propagate(struct redisCommand *cmd, int dbid, robj **argv, int argc,
               int flags)
{
    if (server.aof_state != AOF_OFF && flags & PROPAGATE_AOF)
        feedAppendOnlyFile(cmd,dbid,argv,argc);
    if (flags & PROPAGATE_REPL)
        replicationFeedSlaves(server.slaves,dbid,argv,argc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %r15d
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %ebp
testb $0x1, %r15b
je 0x35e27
cmpl $0x0, 0xd1097(%rip)     # 0x106eb0
je 0x35e27
movl %ebp, %esi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x61947
testb $0x2, %r15b
jne 0x35e38
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xd0bf9(%rip), %rdi     # 0x106a38
movl %ebp, %esi
movq %r14, %rdx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x47393
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/server.c
// Function: alsoPropagate
void alsoPropagate(struct redisCommand *cmd, int dbid, robj **argv, int argc,
                   int target)
{
    robj **argvcopy;
    int j;

    if (server.loading) return; /* No propagation during loading. */

    argvcopy = zmalloc(sizeof(robj*)*argc);
    for (j = 0; j < argc; j++) {
        argvcopy[j] = argv[j];
        incrRefCount(argv[j]);
    }
    redisOpArrayAppend(&server.also_propagate,cmd,dbid,argvcopy,argc,target);
}

// Assembly:
cmpl $0x0, 0xd0d18(%rip)     # 0x106b74
je 0x35e5f
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r13
movq %rdi, %r15
movl %esi, (%rsp)
movl %r8d, 0x4(%rsp)
movslq %ecx, %rbx
leaq (,%rbx,8), %rdi
callq 0x3b29d
movq %rax, %r12
testl %ebx, %ebx
jle 0x35eb1
movl %ebp, %ebx
xorl %r14d, %r14d
movq (%r13,%r14,8), %rax
movq %rax, (%r12,%r14,8)
movq (%r13,%r14,8), %rdi
callq 0x43c0c
incq %r14
cmpq %r14, %rbx
jne 0x35e96
movq 0xd1120(%rip), %rdi     # 0x106fd8
movslq 0xd1121(%rip), %rsi     # 0x106fe0
shlq $0x5, %rsi
addq $0x20, %rsi
callq 0x3b349
movq %rax, 0xd1105(%rip)     # 0x106fd8
movslq 0xd1106(%rip), %rcx     # 0x106fe0
leal 0x1(%rcx), %edx
shlq $0x5, %rcx
movq %r15, 0x18(%rax,%rcx)
movl (%rsp), %esi
movl %esi, 0xc(%rax,%rcx)
movq %r12, (%rax,%rcx)
movl %ebp, 0x8(%rax,%rcx)
movl 0x4(%rsp), %esi
movl %esi, 0x10(%rax,%rcx)
movl %edx, 0xd10dd(%rip)     # 0x106fe0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/server.c
// Function: linuxMemoryWarnings
void linuxMemoryWarnings(void) {
    if (linuxOvercommitMemoryValue() == 0) {
        serverLog(LL_WARNING,"WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.");
    }
    if (THPIsEnabled()) {
        serverLog(LL_WARNING,"WARNING you have Transparent Huge Pages (THP) support enabled in your kernel. This will create latency and memory usage issues with Redis. To fix this issue run the command 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' as root, and add it to your /etc/rc.local in order to retain the setting after a reboot. Redis must be restarted after THP is disabled.");
    }
}

// Assembly:
pushq %rax
callq 0x38307
testl %eax, %eax
jne 0x38383
leaq 0x89179(%rip), %rsi     # 0xc14f0
movl $0x3, %edi
xorl %eax, %eax
callq 0x32ea6
callq 0x82543
testl %eax, %eax
je 0x383a0
leaq 0x8925a(%rip), %rsi     # 0xc15ed
movl $0x3, %edi
xorl %eax, %eax
popq %rcx
jmp 0x32ea6
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/server.c
// Function: createPidFile
void createPidFile(void) {
    /* If pidfile requested, but no pidfile defined, use
     * default pidfile path */
    if (!server.pidfile) server.pidfile = zstrdup(CONFIG_DEFAULT_PID_FILE);

    /* Try to write the pid file in a best-effort way. */
    FILE *fp = fopen(server.pidfile,"w");
    if (fp) {
        fprintf(fp,"%d\n",(int)getpid());
        fclose(fp);
    }
}

// Assembly:
pushq %rbx
cmpq $0x0, 0xce50d(%rip)     # 0x1068b8
jne 0x383c0
leaq 0x893a9(%rip), %rdi     # 0xc175d
callq 0x3b419
movq %rax, 0xce4f8(%rip)     # 0x1068b8
movq 0xce4f1(%rip), %rdi     # 0x1068b8
leaq 0x8b9a9(%rip), %rsi     # 0xc3d77
callq 0x26af0
testq %rax, %rax
je 0x383fc
movq %rax, %rbx
callq 0x26430
leaq 0x9d027(%rip), %rsi     # 0xd540e
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x26ba0
movq %rbx, %rdi
popq %rbx
jmp 0x26a20
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/server.c
// Function: redisAsciiArt
void redisAsciiArt(void) {
#include "asciilogo.h"
    char *buf = zmalloc(1024*16);
    char *mode;

    if (server.cluster_enabled) mode = "cluster";
    else if (server.sentinel_mode) mode = "sentinel";
    else mode = "standalone";

    if (server.syslog_enabled) {
        serverLog(LL_NOTICE,
            "Redis %s (%s/%d) %s bit, %s mode, port %d, pid %ld ready to start.",
            REDIS_VERSION,
            redisGitSHA1(),
            strtol(redisGitDirty(),NULL,10) > 0,
            (sizeof(long) == 8) ? "64" : "32",
            mode, server.port,
            (long) getpid()
        );
    } else {
        snprintf(buf,1024*16,ascii_logo,
            REDIS_VERSION,
            redisGitSHA1(),
            strtol(redisGitDirty(),NULL,10) > 0,
            (sizeof(long) == 8) ? "64" : "32",
            mode, server.port,
            (long) getpid()
        );
        serverLogRaw(LL_NOTICE|LL_RAW,buf);
    }
    zfree(buf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x4000, %edi           # imm = 0x4000
callq 0x3b29d
movq %rax, %rbx
cmpl $0x0, 0xce2c7(%rip)     # 0x1068f4
leaq 0x88335(%rip), %rax     # 0xc0969
leaq 0x9748b(%rip), %rcx     # 0xcfac6
cmoveq %rax, %rcx
cmpl $0x0, 0xceb9e(%rip)     # 0x1071e4
leaq 0x87257(%rip), %r15     # 0xbf8a4
cmoveq %rcx, %r15
movl 0xce998(%rip), %r13d    # 0x106ff0
callq 0x3f0d8
movq %rax, %r14
callq 0x3f0e0
movq %rax, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x26730
xorl %ebp, %ebp
testq %rax, %rax
setg %bpl
movl 0xce274(%rip), %r12d    # 0x1068f8
callq 0x26430
movslq %eax, %r10
testl %r13d, %r13d
je 0x386c8
subq $0x8, %rsp
leaq 0x897bd(%rip), %rsi     # 0xc1e59
leaq 0x89bdd(%rip), %rdx     # 0xc2280
leaq 0x897f2(%rip), %r9      # 0xc1e9c
movl $0x2, %edi
movq %r14, %rcx
movl %ebp, %r8d
xorl %eax, %eax
pushq %r10
pushq %r12
pushq %r15
callq 0x32ea6
addq $0x20, %rsp
jmp 0x3870b
leaq 0x897cd(%rip), %r11     # 0xc1e9c
leaq 0x89316(%rip), %rdx     # 0xc19ec
leaq 0x89ba3(%rip), %rcx     # 0xc2280
movl $0x4000, %esi           # imm = 0x4000
movq %rbx, %rdi
movq %r14, %r8
movl %ebp, %r9d
xorl %eax, %eax
pushq %r10
pushq %r12
pushq %r15
pushq %r11
callq 0x26120
addq $0x20, %rsp
movl $0x402, %edi            # imm = 0x402
movq %rbx, %rsi
callq 0x32d0c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3b3df
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/server.c
// Function: loadDataFromDisk
void loadDataFromDisk(void) {
    long long start = ustime();
    if (server.aof_state == AOF_ON) {
        if (loadAppendOnlyFile(server.aof_filename) == C_OK)
            serverLog(LL_NOTICE,"DB loaded from append only file: %.3f seconds",(float)(ustime()-start)/1000000);
    } else {
        if (rdbLoad(server.rdb_filename) == C_OK) {
            serverLog(LL_NOTICE,"DB loaded from disk: %.3f seconds",
                (float)(ustime()-start)/1000000);
        } else if (errno != ENOENT) {
            serverLog(LL_WARNING,"Fatal error loading the DB: %s. Exiting.",strerror(errno));
            exit(1);
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x26310
imulq $-0xf4240, (%rbx), %r14 # imm = 0xFFF0BDC0
subq 0x8(%rbx), %r14
cmpl $0x1, 0xce67f(%rip)     # 0x106eb0
jne 0x38862
movq 0xce67e(%rip), %rdi     # 0x106eb8
callq 0x61c46
testl %eax, %eax
jne 0x3887e
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x26310
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
leaq 0x89659(%rip), %rsi     # 0xc1eb9
jmp 0x388a3
movq 0xce727(%rip), %rdi     # 0x106f90
callq 0x4da84
testl %eax, %eax
je 0x38886
callq 0x26890
movl (%rax), %edi
cmpl $0x2, %edi
jne 0x388d4
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x26310
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
leaq 0x89644(%rip), %rsi     # 0xc1ee7
imulq $0xf4240, %rcx, %rcx    # imm = 0xF4240
addq %rax, %rcx
addq %r14, %rcx
cvtsi2ss %rcx, %xmm0
divss 0x86c57(%rip), %xmm0    # 0xbf514
cvtss2sd %xmm0, %xmm0
movl $0x2, %edi
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x32ea6
callq 0x26690
leaq 0x89629(%rip), %rsi     # 0xc1f09
movl $0x3, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x32ea6
movl $0x1, %edi
callq 0x262d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/server.c
// Function: redisSupervisedUpstart
int redisSupervisedUpstart(void) {
    const char *upstart_job = getenv("UPSTART_JOB");

    if (!upstart_job) {
        serverLog(LL_WARNING,
                "upstart supervision requested, but UPSTART_JOB not found");
        return 0;
    }

    serverLog(LL_NOTICE, "supervised by upstart, will stop to signal readiness");
    raise(SIGSTOP);
    unsetenv("UPSTART_JOB");
    return 1;
}

// Assembly:
pushq %rbx
leaq 0x89606(%rip), %rdi     # 0xc1f9b
callq 0x26860
testq %rax, %rax
je 0x389cf
leaq 0x8963a(%rip), %rsi     # 0xc1fe0
movl $0x2, %edi
xorl %eax, %eax
callq 0x32ea6
movl $0x13, %edi
callq 0x267c0
leaq 0x895d8(%rip), %rdi     # 0xc1f9b
callq 0x26a90
movl $0x1, %ebx
jmp 0x389e4
leaq 0x895d1(%rip), %rsi     # 0xc1fa7
xorl %ebx, %ebx
movl $0x3, %edi
xorl %eax, %eax
callq 0x32ea6
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/server.c
// Function: redisIsSupervised
int redisIsSupervised(int mode) {
    if (mode == SUPERVISED_AUTODETECT) {
        const char *upstart_job = getenv("UPSTART_JOB");
        const char *notify_socket = getenv("NOTIFY_SOCKET");

        if (upstart_job) {
            redisSupervisedUpstart();
        } else if (notify_socket) {
            redisSupervisedSystemd();
        }
    } else if (mode == SUPERVISED_UPSTART) {
        return redisSupervisedUpstart();
    } else if (mode == SUPERVISED_SYSTEMD) {
        return redisSupervisedSystemd();
    }

    return 0;
}

// Assembly:
cmpl $0x3, %edi
je 0x3898d
cmpl $0x2, %edi
je 0x389e8
cmpl $0x1, %edi
jne 0x38bf6
pushq %rbx
leaq 0x893d0(%rip), %rdi     # 0xc1f9b
callq 0x26860
movq %rax, %rbx
leaq 0x8943b(%rip), %rdi     # 0xc2015
callq 0x26860
testq %rbx, %rbx
je 0x38beb
callq 0x3898d
jmp 0x38bf5
testq %rax, %rax
je 0x38bf5
callq 0x389e8
popq %rbx
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/ziplist.c
// Function: zipEncodeLength
unsigned int zipEncodeLength(unsigned char *p, unsigned char encoding, unsigned int rawlen) {
    unsigned char len = 1, buf[5];

    if (ZIP_IS_STR(encoding)) {
        /* Although encoding is given it may not be set for strings,
         * so we determine it here using the raw length. */
        if (rawlen <= 0x3f) {
            if (!p) return len;
            buf[0] = ZIP_STR_06B | rawlen;
        } else if (rawlen <= 0x3fff) {
            len += 1;
            if (!p) return len;
            buf[0] = ZIP_STR_14B | ((rawlen >> 8) & 0x3f);
            buf[1] = rawlen & 0xff;
        } else {
            len += 4;
            if (!p) return len;
            buf[0] = ZIP_STR_32B;
            buf[1] = (rawlen >> 24) & 0xff;
            buf[2] = (rawlen >> 16) & 0xff;
            buf[3] = (rawlen >> 8) & 0xff;
            buf[4] = rawlen & 0xff;
        }
    } else {
        /* Implies integer encoding, so length is always 1. */
        if (!p) return len;
        buf[0] = encoding;
    }

    /* Store this length at p */
    memcpy(p,buf,len);
    return len;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
cmpb $-0x41, %sil
jbe 0x3de70
testq %rdi, %rdi
je 0x3de92
movb %sil, 0xb(%rsp)
jmp 0x3de7e
cmpl $0x3f, %edx
ja 0x3de9f
testq %rdi, %rdi
je 0x3de92
movb %dl, 0xb(%rsp)
movb $0x1, %al
movzbl %al, %ebx
leaq 0xb(%rsp), %rsi
movq %rbx, %rdx
callq 0x26c60
jmp 0x3de97
movl $0x1, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
cmpl $0x3fff, %edx           # imm = 0x3FFF
ja 0x3debf
testq %rdi, %rdi
je 0x3dee7
movl %edx, %eax
shrl $0x8, %eax
orb $0x40, %al
movb %al, 0xb(%rsp)
movb %dl, 0xc(%rsp)
movb $0x2, %al
jmp 0x3de80
testq %rdi, %rdi
je 0x3deee
movb $-0x80, 0xb(%rsp)
movl %edx, %eax
shrl $0x18, %eax
movb %al, 0xc(%rsp)
movl %edx, %eax
shrl $0x10, %eax
movb %al, 0xd(%rsp)
movb %dh, 0xe(%rsp)
movb %dl, 0xf(%rsp)
movb $0x5, %al
jmp 0x3de80
movl $0x2, %ebx
jmp 0x3de97
movl $0x5, %ebx
jmp 0x3de97
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/ziplist.c
// Function: zipPrevEncodeLength
unsigned int zipPrevEncodeLength(unsigned char *p, unsigned int len) {
    if (p == NULL) {
        return (len < ZIP_BIGLEN) ? 1 : sizeof(len)+1;
    } else {
        if (len < ZIP_BIGLEN) {
            p[0] = len;
            return 1;
        } else {
            p[0] = ZIP_BIGLEN;
            memcpy(p+1,&len,sizeof(len));
            memrev32ifbe(p+1);
            return 1+sizeof(len);
        }
    }
}

// Assembly:
testq %rdi, %rdi
je 0x3df0b
cmpl $0xfd, %esi
ja 0x3df1e
movb %sil, (%rdi)
movl $0x1, %eax
retq
xorl %eax, %eax
cmpl $0xfe, %esi
setae %al
leal 0x1(,%rax,4), %eax
retq
movb $-0x2, (%rdi)
movl %esi, 0x1(%rdi)
movl $0x5, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/ziplist.c
// Function: zipSaveInteger
void zipSaveInteger(unsigned char *p, int64_t value, unsigned char encoding) {
    int16_t i16;
    int32_t i32;
    int64_t i64;
    if (encoding == ZIP_INT_8B) {
        ((int8_t*)p)[0] = (int8_t)value;
    } else if (encoding == ZIP_INT_16B) {
        i16 = value;
        memcpy(p,&i16,sizeof(i16));
        memrev16ifbe(p);
    } else if (encoding == ZIP_INT_24B) {
        i32 = value<<8;
        memrev32ifbe(&i32);
        memcpy(p,((uint8_t*)&i32)+1,sizeof(i32)-sizeof(uint8_t));
    } else if (encoding == ZIP_INT_32B) {
        i32 = value;
        memcpy(p,&i32,sizeof(i32));
        memrev32ifbe(p);
    } else if (encoding == ZIP_INT_64B) {
        i64 = value;
        memcpy(p,&i64,sizeof(i64));
        memrev64ifbe(p);
    } else if (encoding >= ZIP_INT_IMM_MIN && encoding <= ZIP_INT_IMM_MAX) {
        /* Nothing to do, the value is stored in the encoding itself. */
    } else {
        assert(NULL);
    }
}

// Assembly:
cmpl $0xdf, %edx
jle 0x3e0e8
cmpl $0xe0, %edx
je 0x3e0fb
cmpl $0xf0, %edx
je 0x3e0ff
cmpl $0xfe, %edx
jne 0x3e10e
movb %sil, (%rdi)
retq
cmpl $0xc0, %edx
je 0x3e10a
cmpl $0xd0, %edx
jne 0x3e10e
movl %esi, (%rdi)
retq
movq %rsi, (%rdi)
retq
movw %si, (%rdi)
shrl $0x10, %esi
movb %sil, 0x2(%rdi)
retq
movw %si, (%rdi)
retq
addb $0xf, %dl
cmpb $0xe, %dl
jae 0x3e117
retq
pushq %rax
leaq 0x88634(%rip), %rdi     # 0xc6753
leaq 0x84a1a(%rip), %rsi     # 0xc2b40
movl $0x17c, %edx            # imm = 0x17C
callq 0x654e1
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/ziplist.c
// Function: zipEntry
void zipEntry(unsigned char *p, zlentry *e) {

    ZIP_DECODE_PREVLEN(p, e->prevrawlensize, e->prevrawlen);
    ZIP_DECODE_LENGTH(p + e->prevrawlensize, e->encoding, e->lensize, e->len);
    e->headersize = e->prevrawlensize + e->lensize;
    e->p = p;
}

// Assembly:
movb (%rdi), %al
xorl %ecx, %ecx
cmpb $-0x2, %al
setae %cl
leal 0x1(,%rcx,4), %eax
movl %eax, (%rsi)
jb 0x3e1db
movl 0x1(%rdi), %ecx
jmp 0x3e1de
movzbl (%rdi), %ecx
movl %ecx, 0x4(%rsi)
movl %eax, %ecx
movzbl (%rdi,%rcx), %r8d
movl %r8d, %edx
andb $-0x40, %dl
movzbl %dl, %edx
cmpb $-0x40, %r8b
cmovael %r8d, %edx
movb %dl, 0x14(%rsi)
jae 0x3e22a
cmpb $-0x80, %dl
je 0x3e28c
movzbl %dl, %edx
cmpl $0x40, %edx
je 0x3e272
testl %edx, %edx
jne 0x3e2c0
movl $0x1, 0x8(%rsi)
movzbl (%rdi,%rcx), %ecx
andl $0x3f, %ecx
jmp 0x3e2b2
movl $0x1, 0x8(%rsi)
movzbl %dl, %edx
cmpl $0xdf, %edx
jle 0x3e25b
cmpl $0xe0, %edx
je 0x3e29b
cmpl $0xf0, %edx
je 0x3e2a2
movl $0x1, %ecx
cmpl $0xfe, %edx
je 0x3e2b2
jmp 0x3e2b0
cmpl $0xc0, %edx
je 0x3e2a9
cmpl $0xd0, %edx
jne 0x3e2b0
movl $0x4, %ecx
jmp 0x3e2b2
movl $0x2, 0x8(%rsi)
movzbl (%rdi,%rcx), %edx
andl $0x3f, %edx
shll $0x8, %edx
movzbl 0x1(%rdi,%rcx), %ecx
orl %edx, %ecx
jmp 0x3e2b2
movl $0x5, 0x8(%rsi)
movl 0x1(%rdi,%rcx), %ecx
bswapl %ecx
jmp 0x3e2b2
movl $0x8, %ecx
jmp 0x3e2b2
movl $0x3, %ecx
jmp 0x3e2b2
movl $0x2, %ecx
jmp 0x3e2b2
xorl %ecx, %ecx
movl %ecx, 0xc(%rsi)
addl 0x8(%rsi), %eax
movl %eax, 0x10(%rsi)
movq %rdi, 0x18(%rsi)
retq
pushq %rax
leaq 0x8848b(%rip), %rdi     # 0xc6753
leaq 0x84871(%rip), %rsi     # 0xc2b40
movl $0x1a4, %edx            # imm = 0x1A4
callq 0x654e1
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/ziplist.c
// Function: ziplistResize
unsigned char *ziplistResize(unsigned char *zl, unsigned int len) {
    zl = zrealloc(zl,len);
    ZIPLIST_BYTES(zl) = intrev32ifbe(len);
    zl[len-1] = ZIP_END;
    return zl;
}

// Assembly:
pushq %rbx
movl %esi, %ebx
movl %esi, %esi
callq 0x3b349
movl %ebx, (%rax)
decl %ebx
movb $-0x1, (%rax,%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/ziplist.c
// Function: ziplistIndex
unsigned char *ziplistIndex(unsigned char *zl, int index) {
    unsigned char *p;
    unsigned int prevlensize, prevlen = 0;
    if (index < 0) {
        index = (-index)-1;
        p = ZIPLIST_ENTRY_TAIL(zl);
        if (p[0] != ZIP_END) {
            ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);
            while (prevlen > 0 && index--) {
                p -= prevlen;
                ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);
            }
        }
    } else {
        p = ZIPLIST_ENTRY_HEAD(zl);
        while (p[0] != ZIP_END && index--) {
            p += zipRawEntryLength(p);
        }
    }
    return (p[0] == ZIP_END || index > 0) ? NULL : p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
testl %esi, %esi
js 0x3ea73
leaq 0xa(%rdi), %r14
cmpb $-0x1, 0xa(%rdi)
je 0x3ea95
subl $0x1, %ebx
jb 0x3ea90
movq %r14, %rdi
callq 0x3df51
movl %eax, %eax
leaq (%r14,%rax), %rcx
cmpb $-0x1, (%r14,%rax)
movq %rcx, %r14
jne 0x3ea54
jmp 0x3ea98
notl %ebx
movl 0x4(%rdi), %eax
leaq (%rdi,%rax), %rcx
movzbl (%rdi,%rax), %eax
cmpl $0xfe, %eax
je 0x3eaca
cmpl $0xff, %eax
je 0x3ea98
jmp 0x3eab2
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %r14, %rcx
xorl %edx, %edx
testl %ebx, %ebx
movq %rcx, %rax
cmovgq %rdx, %rax
cmpb $-0x1, (%rcx)
cmoveq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testl %eax, %eax
je 0x3ea98
subl $0x1, %ebx
jb 0x3eacf
movl %eax, %eax
subq %rax, %rcx
movzbl (%rcx), %eax
cmpl $0xfd, %eax
jbe 0x3eab2
movl 0x1(%rcx), %eax
jmp 0x3eab2
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x3ea98
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/ziplist.c
// Function: ziplistPrev
unsigned char *ziplistPrev(unsigned char *zl, unsigned char *p) {
    unsigned int prevlensize, prevlen = 0;

    /* Iterating backwards from ZIP_END should return the tail. When "p" is
     * equal to the first element of the list, we're already at the head,
     * and should return NULL. */
    if (p[0] == ZIP_END) {
        p = ZIPLIST_ENTRY_TAIL(zl);
        return (p[0] == ZIP_END) ? NULL : p;
    } else if (p == ZIPLIST_ENTRY_HEAD(zl)) {
        return NULL;
    } else {
        ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);
        assert(prevlen > 0);
        return p-prevlen;
    }
}

// Assembly:
movzbl (%rsi), %eax
cmpl $0xff, %eax
je 0x3eb24
addq $0xa, %rdi
cmpq %rsi, %rdi
je 0x3eb37
cmpl $0xfe, %eax
jne 0x3eb19
movl 0x1(%rsi), %eax
testl %eax, %eax
je 0x3eb3d
movl %eax, %eax
subq %rax, %rsi
jmp 0x3eb39
movl 0x4(%rdi), %eax
leaq (%rdi,%rax), %rcx
xorl %esi, %esi
cmpb $-0x1, (%rdi,%rax)
cmovneq %rcx, %rsi
jmp 0x3eb39
xorl %esi, %esi
movq %rsi, %rax
retq
pushq %rax
leaq 0x84005(%rip), %rdi     # 0xc2b4a
leaq 0x83ff4(%rip), %rsi     # 0xc2b40
movl $0x364, %edx            # imm = 0x364
callq 0x654e1
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/ziplist.c
// Function: ziplistGet
unsigned int ziplistGet(unsigned char *p, unsigned char **sstr, unsigned int *slen, long long *sval) {
    zlentry entry;
    if (p == NULL || p[0] == ZIP_END) return 0;
    if (sstr) *sstr = NULL;

    zipEntry(p, &entry);
    if (ZIP_IS_STR(entry.encoding)) {
        if (sstr) {
            *slen = entry.len;
            *sstr = p+entry.headersize;
        }
    } else {
        if (sval) {
            *sval = zipLoadInteger(p+entry.headersize,entry.encoding);
        }
    }
    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x3ebe0
movq %rdi, %r14
cmpb $-0x1, (%rdi)
je 0x3ebe0
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r12
testq %rsi, %rsi
je 0x3eb92
movq $0x0, (%r12)
movq %rsp, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3e1c2
movb 0x14(%rbx), %al
movl $0x1, %ebx
cmpb $-0x41, %al
jbe 0x3ebc8
testq %r15, %r15
je 0x3ebe0
movl 0x10(%rsp), %ecx
addq %rcx, %r14
movzbl %al, %esi
movq %r14, %rdi
callq 0x3e13a
movq %rax, (%r15)
jmp 0x3ebe0
testq %r12, %r12
je 0x3ebe0
movl 0xc(%rsp), %eax
movl %eax, (%r13)
movl 0x10(%rsp), %eax
addq %rax, %r14
movq %r14, (%r12)
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/networking.c
// Function: prepareClientToWrite
int prepareClientToWrite(client *c) {
    /* If it's the Lua client we always return ok without installing any
     * handler since there is no socket at all. */
    if (c->flags & CLIENT_LUA) return C_OK;

    /* CLIENT REPLY OFF / SKIP handling: don't send replies. */
    if (c->flags & (CLIENT_REPLY_OFF|CLIENT_REPLY_SKIP)) return C_ERR;

    /* Masters don't receive replies, unless CLIENT_MASTER_FORCE_REPLY flag
     * is set. */
    if ((c->flags & CLIENT_MASTER) &&
        !(c->flags & CLIENT_MASTER_FORCE_REPLY)) return C_ERR;

    if (c->fd <= 0) return C_ERR; /* Fake client for AOF loading. */

    /* Schedule the client to write the output buffers to the socket only
     * if not already done (there were no pending writes already and the client
     * was yet not flagged), and, for slaves, if the slave can actually
     * receive writes at this stage. */
    if (!clientHasPendingReplies(c) &&
        !(c->flags & CLIENT_PENDING_WRITE) &&
        (c->replstate == REPL_STATE_NONE ||
         (c->replstate == SLAVE_STATE_ONLINE && !c->repl_put_online_on_ack)))
    {
        /* Here instead of installing the write handler, we just flag the
         * client and put it into a list of clients that have something
         * to write to the socket. This way before re-entering the event
         * loop, we can try to directly write to the client sockets avoiding
         * a system call. We'll only really install the write handler if
         * we'll not be able to write the whole reply at once. */
        c->flags |= CLIENT_PENDING_WRITE;
        listAddNodeHead(server.clients_pending_write,c);
    }

    /* Authorize the caller to queue in the output buffer of this client. */
    return C_OK;
}

// Assembly:
pushq %rbx
movl 0x98(%rdi), %eax
xorl %ebx, %ebx
btl $0x8, %eax
jb 0x3f661
testl $0x1400000, %eax        # imm = 0x1400000
setne %cl
movl %eax, %edx
andl $0x2002, %edx           # imm = 0x2002
cmpl $0x2, %edx
sete %dl
orb %cl, %dl
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jne 0x3f661
movq %rdi, %rsi
cmpl $0x0, 0x8(%rdi)
jle 0x3f661
xorl %ebx, %ebx
cmpl $0x0, 0x1c0(%rsi)
movl $0x0, %ecx
jne 0x3f621
movq 0x68(%rsi), %rcx
cmpq $0x0, 0x28(%rcx)
sete %cl
btl $0x15, %eax
jb 0x3f661
testb %cl, %cl
je 0x3f661
movl 0xa0(%rsi), %ecx
testl %ecx, %ecx
je 0x3f643
cmpl $0x9, %ecx
jne 0x3f661
cmpl $0x0, 0xa4(%rsi)
jne 0x3f661
orl $0x200000, %eax         # imm = 0x200000
movl %eax, 0x98(%rsi)
leaq 0xc7203(%rip), %rax     # 0x106858
movq 0x1d8(%rax), %rdi
callq 0x2e3b0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/networking.c
// Function: addReplyObjectToList
void _addReplyObjectToList(client *c, robj *o) {
    robj *tail;

    if (c->flags & CLIENT_CLOSE_AFTER_REPLY) return;

    if (listLength(c->reply) == 0) {
        incrRefCount(o);
        listAddNodeTail(c->reply,o);
        c->reply_bytes += getStringObjectSdsUsedMemory(o);
    } else {
        tail = listNodeValue(listLast(c->reply));

        /* Append to this object when possible. */
        if (tail->ptr != NULL &&
            tail->encoding == OBJ_ENCODING_RAW &&
            sdslen(tail->ptr)+sdslen(o->ptr) <= PROTO_REPLY_CHUNK_BYTES)
        {
            c->reply_bytes -= sdsZmallocSize(tail->ptr);
            tail = dupLastObjectIfNeeded(c->reply);
            tail->ptr = sdscatlen(tail->ptr,o->ptr,sdslen(o->ptr));
            c->reply_bytes += sdsZmallocSize(tail->ptr);
        } else {
            incrRefCount(o);
            listAddNodeTail(c->reply,o);
            c->reply_bytes += getStringObjectSdsUsedMemory(o);
        }
    }
    asyncCloseClientOnOutputBufferLimitReached(c);
}

// Assembly:
testb $0x40, 0x98(%rdi)
jne 0x3f7a7
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x68(%rdi), %rax
cmpq $0x0, 0x28(%rax)
je 0x3f855
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x3f855
testb $-0x10, (%rax)
jne 0x3f855
movzbl -0x1(%rdi), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x3f7bf
leaq 0x834bf(%rip), %rdx     # 0xc2c58
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
shrl $0x3, %eax
jmp 0x3f7c1
retq
movq -0x11(%rdi), %rax
jmp 0x3f7c1
movzwl -0x5(%rdi), %eax
jmp 0x3f7c1
movl -0x9(%rdi), %eax
jmp 0x3f7c1
movzbl -0x3(%rdi), %eax
jmp 0x3f7c1
xorl %eax, %eax
movq 0x8(%r14), %rdx
movzbl -0x1(%rdx), %ecx
movl %ecx, %esi
andl $0x7, %esi
cmpl $0x4, %esi
ja 0x3f7ff
leaq 0x83492(%rip), %r8      # 0xc2c6c
movslq (%r8,%rsi,4), %rsi
addq %r8, %rsi
jmpq *%rsi
shrl $0x3, %ecx
jmp 0x3f801
movq -0x11(%rdx), %rcx
jmp 0x3f801
movzwl -0x5(%rdx), %ecx
jmp 0x3f801
movl -0x9(%rdx), %ecx
jmp 0x3f801
movzbl -0x3(%rdx), %ecx
jmp 0x3f801
xorl %ecx, %ecx
addq %rax, %rcx
cmpq $0x4000, %rcx           # imm = 0x4000
ja 0x3f855
callq 0x39791
movq %rax, %rdi
callq 0xa6f90
subq %rax, 0x70(%rbx)
movq 0x68(%rbx), %rdi
callq 0x3f683
movq %rax, %r15
movq 0x8(%rax), %rdi
movq 0x8(%r14), %rsi
movzbl -0x1(%rsi), %edx
movl %edx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x3f899
leaq 0x83439(%rip), %rcx     # 0xc2c80
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %edx
jmp 0x3f89b
movq %r14, %rdi
callq 0x43c0c
movq 0x68(%rbx), %rdi
movq %r14, %rsi
callq 0x2e40f
movq %r14, %rdi
callq 0x3f10b
addq %rax, 0x70(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3f8b6
movq -0x11(%rsi), %rdx
jmp 0x3f89b
movzwl -0x5(%rsi), %edx
jmp 0x3f89b
movl -0x9(%rsi), %edx
jmp 0x3f89b
movzbl -0x3(%rsi), %edx
jmp 0x3f89b
xorl %edx, %edx
callq 0x39a56
movq %rax, 0x8(%r15)
movq %rax, %rdi
callq 0x39791
movq %rax, %rdi
callq 0xa6f90
jmp 0x3f871
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/networking.c
// Function: addReplySdsToList
void _addReplySdsToList(client *c, sds s) {
    robj *tail;

    if (c->flags & CLIENT_CLOSE_AFTER_REPLY) {
        sdsfree(s);
        return;
    }

    if (listLength(c->reply) == 0) {
        listAddNodeTail(c->reply,createObject(OBJ_STRING,s));
        c->reply_bytes += sdsZmallocSize(s);
    } else {
        tail = listNodeValue(listLast(c->reply));

        /* Append to this object when possible. */
        if (tail->ptr != NULL && tail->encoding == OBJ_ENCODING_RAW &&
            sdslen(tail->ptr)+sdslen(s) <= PROTO_REPLY_CHUNK_BYTES)
        {
            c->reply_bytes -= sdsZmallocSize(tail->ptr);
            tail = dupLastObjectIfNeeded(c->reply);
            tail->ptr = sdscatlen(tail->ptr,s,sdslen(s));
            c->reply_bytes += sdsZmallocSize(tail->ptr);
            sdsfree(s);
        } else {
            listAddNodeTail(c->reply,createObject(OBJ_STRING,s));
            c->reply_bytes += sdsZmallocSize(s);
        }
    }
    asyncCloseClientOnOutputBufferLimitReached(c);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
testb $0x40, 0x98(%rdi)
jne 0x3f9db
movq %rdi, %rbx
movq 0x68(%rdi), %r15
cmpq $0x0, 0x28(%r15)
je 0x3fa92
movq 0x8(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x3fa92
testb $-0x10, (%rax)
jne 0x3fa92
movzbl -0x1(%rdi), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x3f9ff
leaq 0x832c7(%rip), %rdx     # 0xc2c94
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
shrl $0x3, %eax
jmp 0x3fa01
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x392b6
movq -0x11(%rdi), %rax
jmp 0x3fa01
movzwl -0x5(%rdi), %eax
jmp 0x3fa01
movl -0x9(%rdi), %eax
jmp 0x3fa01
movzbl -0x3(%rdi), %eax
jmp 0x3fa01
xorl %eax, %eax
movzbl -0x1(%r14), %ecx
movl %ecx, %edx
andl $0x7, %edx
cmpl $0x4, %edx
ja 0x3fa3f
leaq 0x83291(%rip), %rsi     # 0xc2ca8
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
shrl $0x3, %ecx
jmp 0x3fa41
movq -0x11(%r14), %rcx
jmp 0x3fa41
movzwl -0x5(%r14), %ecx
jmp 0x3fa41
movl -0x9(%r14), %ecx
jmp 0x3fa41
movzbl -0x3(%r14), %ecx
jmp 0x3fa41
xorl %ecx, %ecx
addq %rax, %rcx
cmpq $0x4000, %rcx           # imm = 0x4000
ja 0x3fa92
callq 0x39791
movq %rax, %rdi
callq 0xa6f90
subq %rax, 0x70(%rbx)
movq 0x68(%rbx), %rdi
callq 0x3f683
movq %rax, %r15
movq 0x8(%rax), %rdi
movzbl -0x1(%r14), %edx
movl %edx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x3fae2
leaq 0x83238(%rip), %rcx     # 0xc2cbc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %edx
jmp 0x3fae4
xorl %edi, %edi
movq %r14, %rsi
callq 0x43ab4
movq %r15, %rdi
movq %rax, %rsi
callq 0x2e40f
movq %r14, %rdi
callq 0x39791
movq %rax, %rdi
callq 0xa6f90
addq %rax, 0x70(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3f8b6
movq -0x11(%r14), %rdx
jmp 0x3fae4
movzwl -0x5(%r14), %edx
jmp 0x3fae4
movl -0x9(%r14), %edx
jmp 0x3fae4
movzbl -0x3(%r14), %edx
jmp 0x3fae4
xorl %edx, %edx
movq %r14, %rsi
callq 0x39a56
movq %rax, 0x8(%r15)
movq %rax, %rdi
callq 0x39791
movq %rax, %rdi
callq 0xa6f90
addq %rax, 0x70(%rbx)
movq %r14, %rdi
callq 0x392b6
jmp 0x3fabb
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/networking.c
// Function: addReplyStringToList
void _addReplyStringToList(client *c, const char *s, size_t len) {
    robj *tail;

    if (c->flags & CLIENT_CLOSE_AFTER_REPLY) return;

    if (listLength(c->reply) == 0) {
        robj *o = createStringObject(s,len);

        listAddNodeTail(c->reply,o);
        c->reply_bytes += getStringObjectSdsUsedMemory(o);
    } else {
        tail = listNodeValue(listLast(c->reply));

        /* Append to this object when possible. */
        if (tail->ptr != NULL && tail->encoding == OBJ_ENCODING_RAW &&
            sdslen(tail->ptr)+len <= PROTO_REPLY_CHUNK_BYTES)
        {
            c->reply_bytes -= sdsZmallocSize(tail->ptr);
            tail = dupLastObjectIfNeeded(c->reply);
            tail->ptr = sdscatlen(tail->ptr,s,len);
            c->reply_bytes += sdsZmallocSize(tail->ptr);
        } else {
            robj *o = createStringObject(s,len);

            listAddNodeTail(c->reply,o);
            c->reply_bytes += getStringObjectSdsUsedMemory(o);
        }
    }
    asyncCloseClientOnOutputBufferLimitReached(c);
}

// Assembly:
testb $0x40, 0x98(%rdi)
jne 0x3fb78
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x68(%rdi), %rax
cmpq $0x0, 0x28(%rax)
je 0x3fbe0
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x3fbe0
testb $-0x10, (%rax)
jne 0x3fbe0
movzbl -0x1(%rdi), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x3fb90
leaq 0x83166(%rip), %rdx     # 0xc2cd0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
shrl $0x3, %eax
jmp 0x3fb92
retq
movq -0x11(%rdi), %rax
jmp 0x3fb92
movzwl -0x5(%rdi), %eax
jmp 0x3fb92
movl -0x9(%rdi), %eax
jmp 0x3fb92
movzbl -0x3(%rdi), %eax
jmp 0x3fb92
xorl %eax, %eax
addq %r14, %rax
cmpq $0x4000, %rax           # imm = 0x4000
ja 0x3fbe0
callq 0x39791
movq %rax, %rdi
callq 0xa6f90
subq %rax, 0x70(%rbx)
movq 0x68(%rbx), %rdi
callq 0x3f683
movq %rax, %r12
movq 0x8(%rax), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x39a56
movq %rax, 0x8(%r12)
movq %rax, %rdi
callq 0x39791
movq %rax, %rdi
callq 0xa6f90
jmp 0x3fc02
movq %r15, %rdi
movq %r14, %rsi
callq 0x43ba8
movq %rax, %r14
movq 0x68(%rbx), %rdi
movq %rax, %rsi
callq 0x2e40f
movq %r14, %rdi
callq 0x3f10b
addq %rax, 0x70(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3f8b6
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/networking.c
// Function: addDeferredMultiBulkLength
void *addDeferredMultiBulkLength(client *c) {
    /* Note that we install the write event here even if the object is not
     * ready to be sent, since we are sure that before returning to the
     * event loop setDeferredMultiBulkLength() will be called. */
    if (prepareClientToWrite(c) != C_OK) return NULL;
    listAddNodeTail(c->reply,createObject(OBJ_STRING,NULL));
    return listLast(c->reply);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3f5ca
testl %eax, %eax
je 0x402c4
xorl %eax, %eax
jmp 0x402e4
movq 0x68(%rbx), %r14
xorl %edi, %edi
xorl %esi, %esi
callq 0x43ab4
movq %r14, %rdi
movq %rax, %rsi
callq 0x2e40f
movq 0x68(%rbx), %rax
movq 0x8(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/networking.c
// Function: setDeferredMultiBulkLength
void setDeferredMultiBulkLength(client *c, void *node, long length) {
    listNode *ln = (listNode*)node;
    robj *len, *next;

    /* Abort when *node is NULL (see addDeferredMultiBulkLength). */
    if (node == NULL) return;

    len = listNodeValue(ln);
    len->ptr = sdscatprintf(sdsempty(),"*%ld\r\n",length);
    len->encoding = OBJ_ENCODING_RAW; /* in case it was an EMBSTR. */
    c->reply_bytes += sdsZmallocSize(len->ptr);
    if (ln->next != NULL) {
        next = listNodeValue(ln->next);

        /* Only glue when the next node is non-NULL (an sds in this case) */
        if (next->ptr != NULL) {
            c->reply_bytes -= sdsZmallocSize(len->ptr);
            c->reply_bytes -= getStringObjectSdsUsedMemory(next);
            len->ptr = sdscatlen(len->ptr,next->ptr,sdslen(next->ptr));
            c->reply_bytes += sdsZmallocSize(len->ptr);
            listDelNode(c->reply,ln->next);
        }
    }
    asyncCloseClientOnOutputBufferLimitReached(c);
}

// Assembly:
testq %rsi, %rsi
je 0x403ab
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r12
callq 0x39222
leaq 0x82c45(%rip), %rsi     # 0xc2f5b
movq %rax, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x39eb7
movq %rax, 0x8(%r12)
andb $0xf, (%r12)
movq %rax, %rdi
callq 0x39791
movq %rax, %rdi
callq 0xa6f90
addq %rax, 0x70(%rbx)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x403f0
movq 0x10(%rax), %r15
cmpq $0x0, 0x8(%r15)
je 0x403f0
movq 0x8(%r12), %rdi
callq 0x39791
movq %rax, %rdi
callq 0xa6f90
subq %rax, 0x70(%rbx)
movq %r15, %rdi
callq 0x3f10b
subq %rax, 0x70(%rbx)
movq 0x8(%r12), %rdi
movq 0x8(%r15), %rsi
movzbl -0x1(%rsi), %edx
movl %edx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x403c3
leaq 0x829bf(%rip), %rcx     # 0xc2d5c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %edx
jmp 0x403c5
retq
movq -0x11(%rsi), %rdx
jmp 0x403c5
movzwl -0x5(%rsi), %edx
jmp 0x403c5
movl -0x9(%rsi), %edx
jmp 0x403c5
movzbl -0x3(%rsi), %edx
jmp 0x403c5
xorl %edx, %edx
callq 0x39a56
movq %rax, 0x8(%r12)
movq %rax, %rdi
callq 0x39791
movq %rax, %rdi
callq 0xa6f90
addq %rax, 0x70(%rbx)
movq 0x68(%rbx), %rdi
movq 0x8(%r14), %rsi
callq 0x2e4f4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3f8b6
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/networking.c
// Function: resetClient
void resetClient(client *c) {
    redisCommandProc *prevcmd = c->cmd ? c->cmd->proc : NULL;

    freeClientArgv(c);
    c->reqtype = 0;
    c->multibulklen = 0;
    c->bulklen = -1;

    /* We clear the ASKING flag as well if we are not inside a MULTI, and
     * if what we just executed is not the ASKING command itself. */
    if (!(c->flags & CLIENT_MULTI) && prevcmd != askingCommand)
        c->flags &= ~CLIENT_ASKING;

    /* Remove the CLIENT_REPLY_SKIP flag if any so that the reply
     * to the next command will be sent, but set the flag if the command
     * we just processed was "CLIENT REPLY SKIP". */
    c->flags &= ~CLIENT_REPLY_SKIP;
    if (c->flags & CLIENT_REPLY_SKIP_NEXT) {
        c->flags |= CLIENT_REPLY_SKIP;
        c->flags &= ~CLIENT_REPLY_SKIP_NEXT;
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x412c9
movq 0x8(%rax), %rax
cmpq 0xc0c55(%rip), %rax     # 0x101f18
setne %bpl
jmp 0x412cc
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x40e7f
movq $0x0, 0x58(%rbx)
movq $-0x1, 0x60(%rbx)
movl 0x98(%rbx), %eax
testb $0x8, %al
jne 0x412fe
testb %bpl, %bpl
je 0x412fe
andl $0xfffffdf7, %eax       # imm = 0xFFFFFDF7
movl %eax, 0x98(%rbx)
movl 0x98(%rbx), %eax
movl %eax, %ecx
andl $0xfeffffff, %ecx       # imm = 0xFEFFFFFF
movl %eax, %edx
andl $0xfe7fffff, %edx       # imm = 0xFE7FFFFF
orl $0x1000000, %edx        # imm = 0x1000000
btl $0x17, %eax
cmovael %ecx, %edx
movl %edx, 0x98(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/networking.c
// Function: getAllClientsInfoString
sds getAllClientsInfoString(void) {
    listNode *ln;
    listIter li;
    client *client;
    sds o = sdsnewlen(NULL,200*listLength(server.clients));
    sdsclear(o);
    listRewind(server.clients,&li);
    while ((ln = listNext(&li)) != NULL) {
        client = listNodeValue(ln);
        o = catClientInfoString(o,client);
        o = sdscatlen(o,"\n",1);
    }
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xc46e1(%rip), %r14     # 0x106858
movq 0x1c8(%r14), %rax
imulq $0xc8, 0x28(%rax), %rsi
xorl %edi, %edi
callq 0x3910c
movq %rax, %rbx
movq %rax, %rdi
callq 0x39323
movq 0x1c8(%r14), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0x2e582
movq %r14, %rdi
callq 0x2e59f
testq %rax, %rax
je 0x421ed
leaq 0x7fc99(%rip), %r14     # 0xc1e57
movq %rsp, %r15
movq 0x10(%rax), %rsi
movq %rbx, %rdi
callq 0x41cda
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x39a56
movq %rax, %rbx
movq %r15, %rdi
callq 0x2e59f
testq %rax, %rax
jne 0x421c1
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/networking.c
// Function: getClientTypeByName
int getClientTypeByName(char *name) {
    if (!strcasecmp(name,"normal")) return CLIENT_TYPE_NORMAL;
    else if (!strcasecmp(name,"slave")) return CLIENT_TYPE_SLAVE;
    else if (!strcasecmp(name,"pubsub")) return CLIENT_TYPE_PUBSUB;
    else if (!strcasecmp(name,"master")) return CLIENT_TYPE_MASTER;
    else return -1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x8daf7(%rip), %rsi     # 0xd0437
callq 0x26300
testl %eax, %eax
je 0x4298b
leaq 0x8931d(%rip), %rsi     # 0xcbc6d
movq %rbx, %rdi
callq 0x26300
testl %eax, %eax
je 0x4298f
leaq 0x7cf2d(%rip), %rsi     # 0xbf890
movq %rbx, %rdi
callq 0x26300
testl %eax, %eax
je 0x42996
leaq 0x892a5(%rip), %rsi     # 0xcbc1b
movq %rbx, %rdi
callq 0x26300
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
orl $0x3, %eax
jmp 0x4299b
xorl %eax, %eax
jmp 0x4299b
movl $0x1, %eax
jmp 0x4299b
movl $0x2, %eax
popq %rbx
retq