LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/scripting.c
// Function: ldbAddBreakpoint
int ldbAddBreakpoint(int line) {
    if (line <= 0 || line > ldb.lines) return 0;
    if (!ldbIsBreakpoint(line) && ldb.bpcount != LDB_BREAKPOINTS_MAX) {
        ldb.bp[ldb.bpcount++] = line;
        return 1;
    }
    return 0;
}

// Assembly:
xorl %eax, %eax
testl %edi, %edi
jle 0x74440
cmpl %edi, 0xa6f54(%rip)     # 0x11b340
jl 0x74440
movslq 0xa6f33(%rip), %rcx     # 0x11b328
leaq 0xa6e04(%rip), %rdx     # 0x11b200
testq %rcx, %rcx
jle 0x74421
leaq -0x1(%rcx), %r8
xorl %r9d, %r9d
cmpl %edi, 0x28(%rdx,%r9,4)
setne %sil
je 0x74424
leaq 0x1(%r9), %r10
cmpq %r9, %r8
movq %r10, %r9
jne 0x74408
jmp 0x74424
movb $0x1, %sil
cmpl $0x40, %ecx
je 0x74440
testb %sil, %sil
je 0x74440
leal 0x1(%rcx), %eax
movl %eax, 0xa6ef1(%rip)     # 0x11b328
movl %edi, 0x28(%rdx,%rcx,4)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/scripting.c
// Function: ldbDelBreakpoint
int ldbDelBreakpoint(int line) {
    int j;

    for (j = 0; j < ldb.bpcount; j++) {
        if (ldb.bp[j] == line) {
            ldb.bpcount--;
            memmove(ldb.bp+j,ldb.bp+j+1,ldb.bpcount-j);
            return 1;
        }
    }
    return 0;
}

// Assembly:
movslq 0xa6ee0(%rip), %rax     # 0x11b328
testq %rax, %rax
jle 0x74464
xorl %ecx, %ecx
leaq 0xa6daa(%rip), %rdx     # 0x11b200
cmpl %edi, 0x28(%rdx,%rcx,4)
je 0x74467
incq %rcx
cmpq %rcx, %rax
jne 0x74456
xorl %eax, %eax
retq
pushq %rax
decl %eax
movl %eax, 0xa6eb8(%rip)     # 0x11b328
leaq (%rdx,%rcx,4), %rdi
addq $0x28, %rdi
leaq (%rdx,%rcx,4), %rsi
addq $0x2c, %rsi
movslq %eax, %rdx
subq %rcx, %rdx
callq 0x267f0
movl $0x1, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/scripting.c
// Function: ldbLogSourceLine
void ldbLogSourceLine(int lnum) {
    char *line = ldbGetSourceLine(lnum);
    char *prefix;
    int bp = ldbIsBreakpoint(lnum);
    int current = ldb.currentline == lnum;

    if (current && bp)
        prefix = "->#";
    else if (current)
        prefix = "-> ";
    else if (bp)
        prefix = "  #";
    else
        prefix = "   ";
    sds thisline = sdscatprintf(sdsempty(),"%s%-3d %s", prefix, lnum, line);
    ldbLog(thisline);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0x59073(%rip), %r14     # 0xcd69a
testl %edi, %edi
jle 0x74641
cmpl %ebx, 0xa6d0f(%rip)     # 0x11b340
jl 0x74641
movq 0xa6cfe(%rip), %rax     # 0x11b338
movl %ebx, %ecx
movq -0x8(%rax,%rcx,8), %r14
movslq 0xa6ce0(%rip), %rax     # 0x11b328
testq %rax, %rax
jle 0x74670
decq %rax
xorl %edx, %edx
leaq 0xa6ba7(%rip), %rsi     # 0x11b200
cmpl %ebx, 0x28(%rsi,%rdx,4)
sete %cl
je 0x74672
leaq 0x1(%rdx), %rdi
cmpq %rdx, %rax
movq %rdi, %rdx
jne 0x74659
jmp 0x74672
xorl %ecx, %ecx
leaq 0x59045(%rip), %rax     # 0xcd6be
leaq 0x59042(%rip), %rdx     # 0xcd6c2
testb %cl, %cl
cmovneq %rax, %rdx
leaq 0x5902d(%rip), %rax     # 0xcd6ba
leaq 0x512a7(%rip), %r15     # 0xc593b
cmovneq %rax, %r15
cmpl %ebx, 0xa6ca6(%rip)     # 0x11b344
cmovneq %rdx, %r15
callq 0x39222
leaq 0x59018(%rip), %rsi     # 0xcd6c6
movq %rax, %rdi
movq %r15, %rdx
movl %ebx, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x39eb7
movq 0xa6b49(%rip), %rdi     # 0x11b210
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2e40f
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/scripting.c
// Function: ldbList
void ldbList(int around, int context) {
    int j;

    for (j = 1; j <= ldb.lines; j++) {
        if (around != 0 && abs(around-j) > context) continue;
        ldbLogSourceLine(j);
    }
}

// Assembly:
cmpl $0x0, 0xa6c65(%rip)     # 0x11b340
jle 0x7471f
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %r14d
leal -0x1(%r14), %r15d
xorl %ebp, %ebp
incl %ebp
testl %r14d, %r14d
je 0x74703
movl %r15d, %eax
negl %eax
cmovsl %r15d, %eax
cmpl %ebx, %eax
jg 0x7470a
movl %ebp, %edi
callq 0x74619
decl %r15d
cmpl 0xa6c2d(%rip), %ebp     # 0x11b340
jl 0x746ef
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/scripting.c
// Function: ldbRedisProtocolToHuman
char *ldbRedisProtocolToHuman(sds *o, char *reply) {
    char *p = reply;
    switch(*p) {
    case ':': p = ldbRedisProtocolToHuman_Int(o,reply); break;
    case '$': p = ldbRedisProtocolToHuman_Bulk(o,reply); break;
    case '+': p = ldbRedisProtocolToHuman_Status(o,reply); break;
    case '-': p = ldbRedisProtocolToHuman_Status(o,reply); break;
    case '*': p = ldbRedisProtocolToHuman_MultiBulk(o,reply); break;
    }
    return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rsi), %ecx
leal -0x24(%rcx), %eax
cmpl $0x9, %eax
ja 0x74b6c
leaq 0x57cc3(%rip), %rcx     # 0xcc7f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1(%rbx), %rdi
movl $0xd, %esi
callq 0x26800
movq %rax, %r15
movq (%r14), %rdi
movq %rax, %rdx
subq %rbx, %rdx
movq %rbx, %rsi
callq 0x3abb1
movq %rax, (%r14)
addq $0x2, %r15
movq %r15, %rbx
jmp 0x74ba3
cmpl $0x3a, %ecx
jne 0x74ba3
leaq 0x1(%rbx), %r15
movq %r15, %rdi
movl $0xd, %esi
callq 0x26800
movq %rax, %r12
movq (%r14), %rdi
notq %rbx
addq %rax, %rbx
movq %r15, %rsi
movq %rbx, %rdx
callq 0x39a56
movq %rax, (%r14)
addq $0x2, %r12
movq %r12, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x74c2a
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x74cf3
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/scripting.c
// Function: ldbRedisProtocolToHuman_Bulk
char *ldbRedisProtocolToHuman_Bulk(sds *o, char *reply) {
    char *p = strchr(reply+1,'\r');
    long long bulklen;

    string2ll(reply+1,p-reply-1,&bulklen);
    if (bulklen == -1) {
        *o = sdscatlen(*o,"NULL",4);
        return p+2;
    } else {
        *o = sdscatrepr(*o,p+2,bulklen);
        return p+2+bulklen+2;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x1(%rsi), %r12
movq %r12, %rdi
movl $0xd, %esi
callq 0x26800
movq %rax, %rbx
notq %r15
addq %rax, %r15
leaq 0x8(%rsp), %r13
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x434c7
movq (%r13), %rdx
movq (%r14), %rdi
cmpq $-0x1, %rdx
je 0x74c8d
addq $0x2, %rbx
movq %rbx, %rsi
callq 0x3abb1
movq %rax, (%r14)
addq 0x8(%rsp), %rbx
jmp 0x74ca1
leaq 0x51abf(%rip), %rsi     # 0xc6753
movl $0x4, %edx
callq 0x39a56
movq %rax, (%r14)
addq $0x2, %rbx
movq %rbx, %rax
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/scripting.c
// Function: ldbRedisProtocolToHuman_MultiBulk
char *ldbRedisProtocolToHuman_MultiBulk(sds *o, char *reply) {
    char *p = strchr(reply+1,'\r');
    long long mbulklen;
    int j = 0;

    string2ll(reply+1,p-reply-1,&mbulklen);
    p += 2;
    if (mbulklen == -1) {
        *o = sdscatlen(*o,"NULL",4);
        return p;
    }
    *o = sdscatlen(*o,"[",1);
    for (j = 0; j < mbulklen; j++) {
        p = ldbRedisProtocolToHuman(o,p);
        if (j != mbulklen-1) *o = sdscatlen(*o,",",1);
    }
    *o = sdscatlen(*o,"]",1);
    return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1(%rsi), %r12
movq %r12, %rdi
movl $0xd, %esi
callq 0x26800
movq %rax, %r14
notq %r15
addq %rax, %r15
leaq 0x8(%rsp), %r13
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x434c7
addq $0x2, %r14
cmpq $-0x1, (%r13)
movq (%rbx), %rdi
je 0x74db0
leaq 0x589c1(%rip), %rsi     # 0xcd709
movl $0x1, %edx
callq 0x39a56
movq %rax, (%rbx)
cmpq $0x0, 0x8(%rsp)
jle 0x74d9f
xorl %r12d, %r12d
leaq 0x575fa(%rip), %r15     # 0xcc361
movq %rbx, %rdi
movq %r14, %rsi
callq 0x74b15
movq %rax, %r14
movq 0x8(%rsp), %rax
decq %rax
cmpq %rax, %r12
je 0x74d95
movq (%rbx), %rdi
movl $0x1, %edx
movq %r15, %rsi
callq 0x39a56
movq %rax, (%rbx)
incq %r12
cmpq %r12, 0x8(%rsp)
jg 0x74d67
movq (%rbx), %rdi
leaq 0x5e6e9(%rip), %rsi     # 0xd3492
movl $0x1, %edx
jmp 0x74dbc
leaq 0x5199c(%rip), %rsi     # 0xc6753
movl $0x4, %edx
callq 0x39a56
movq %rax, (%rbx)
movq %r14, %rax
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/scripting.c
// Function: ldbPrint
void ldbPrint(lua_State *lua, char *varname) {
    lua_Debug ar;

    int l = 0; /* Stack level. */
    while (lua_getstack(lua,l,&ar) != 0) {
        l++;
        const char *name;
        int i = 1; /* Variable index. */
        while((name = lua_getlocal(lua,&ar,i)) != NULL) {
            i++;
            if (strcmp(varname,name) == 0) {
                ldbLogStackValue(lua,"<value> ");
                lua_pop(lua,1);
                return;
            } else {
                lua_pop(lua,1); /* Discard the var name on the stack. */
            }
        }
    }

    /* Let's try with global vars in two selected cases */
    if (!strcmp(varname,"ARGV") || !strcmp(varname,"KEYS")) {
        lua_getglobal(lua, varname);
        ldbLogStackValue(lua,"<value> ");
        lua_pop(lua,1);
    } else {
        ldbLog(sdsnew("No such variable."));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0x8(%rsp), %rdx
xorl %esi, %esi
callq 0x8abb9
testl %eax, %eax
je 0x74e65
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x8ac0b
testq %rax, %rax
je 0x74e52
movl $0x2, %r12d
movq %r14, %rdi
movq %rax, %rsi
callq 0x26900
testl %eax, %eax
je 0x74eb8
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x89976
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x8ac0b
incl %r12d
testq %rax, %rax
jne 0x74e1c
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x8abb9
testl %eax, %eax
jne 0x74e01
leaq 0x584f4(%rip), %rsi     # 0xcd360
movq %r14, %rdi
callq 0x26900
testl %eax, %eax
je 0x74ea8
leaq 0x584dc(%rip), %rsi     # 0xcd35b
movq %r14, %rdi
callq 0x26900
testl %eax, %eax
je 0x74ea8
leaq 0x588c5(%rip), %rdi     # 0xcd757
callq 0x39245
movq 0xa6372(%rip), %rdi     # 0x11b210
movq %rax, %rsi
callq 0x2e40f
jmp 0x74ed4
movq %rbx, %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
movq %r14, %rdx
callq 0x8a262
leaq 0x5888f(%rip), %rsi     # 0xcd74e
movq %rbx, %rdi
callq 0x74aee
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x89976
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/scripting.c
// Function: ldbPrintAll
void ldbPrintAll(lua_State *lua) {
    lua_Debug ar;
    int vars = 0;

    if (lua_getstack(lua,0,&ar) != 0) {
        const char *name;
        int i = 1; /* Variable index. */
        while((name = lua_getlocal(lua,&ar,i)) != NULL) {
            i++;
            if (!strstr(name,"(*temporary)")) {
                sds prefix = sdscatprintf(sdsempty(),"<value> %s = ",name);
                ldbLogStackValue(lua,prefix);
                sdsfree(prefix);
                vars++;
            }
            lua_pop(lua,1);
        }
    }

    if (vars == 0) {
        ldbLog(sdsnew("No local variables in the current context."));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq %rsp, %rdx
xorl %esi, %esi
callq 0x8abb9
testl %eax, %eax
je 0x74fa0
movq %rsp, %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x8ac0b
testq %rax, %rax
je 0x74fa0
movq %rax, %r13
movl $0x2, %ebp
leaq 0x5883a(%rip), %r14     # 0xcd769
movq %rsp, %r12
xorl %r15d, %r15d
movq %r13, %rdi
movq %r14, %rsi
callq 0x266c0
testq %rax, %rax
jne 0x74f77
callq 0x39222
movq %rax, %rdi
leaq 0x58822(%rip), %rsi     # 0xcd776
movq %r13, %rdx
xorl %eax, %eax
callq 0x39eb7
movq %rax, %r13
movq %rbx, %rdi
movq %rax, %rsi
callq 0x74aee
movq %r13, %rdi
callq 0x392b6
incl %r15d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x89976
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x8ac0b
movq %rax, %r13
incl %ebp
testq %rax, %rax
jne 0x74f35
testl %r15d, %r15d
jne 0x74fbb
leaq 0x587dd(%rip), %rdi     # 0xcd784
callq 0x39245
movq 0xa625d(%rip), %rdi     # 0x11b210
movq %rax, %rsi
callq 0x2e40f
addq $0x78, %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/scripting.c
// Function: ldbRedis
void ldbRedis(lua_State *lua, sds *argv, int argc) {
    int j, saved_rc = server.lua_replicate_commands;

    lua_getglobal(lua,"redis");
    lua_pushstring(lua,"call");
    lua_gettable(lua,-2);       /* Stack: redis, redis.call */
    for (j = 1; j < argc; j++)
        lua_pushlstring(lua,argv[j],sdslen(argv[j]));
    ldb.step = 1;               /* Force redis.call() to log. */
    server.lua_replicate_commands = 1;
    lua_pcall(lua,argc-1,1,0);  /* Stack: redis, result */
    ldb.step = 0;               /* Disable logging. */
    server.lua_replicate_commands = saved_rc;
    lua_pop(lua,2);             /* Discard the result and clean the stack. */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x914a5(%rip), %rax     # 0x106858
movl 0x9f0(%rax), %eax
movl %eax, 0x4(%rsp)
leaq 0x4ac92(%rip), %rdx     # 0xc0056
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x8a262
leaq 0x5f715(%rip), %rsi     # 0xd4aea
movq %rbx, %rdi
callq 0x8a02b
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8a242
cmpl $0x2, %ebp
jl 0x75448
movl %ebp, %r13d
movl $0x1, %r15d
leaq 0x5745d(%rip), %r12     # 0xcc85c
movq (%r14,%r15,8), %rsi
movzbl -0x1(%rsi), %edx
movl %edx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x75436
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
shrl $0x3, %edx
jmp 0x75438
movq -0x11(%rsi), %rdx
jmp 0x75438
movzwl -0x5(%rsi), %edx
jmp 0x75438
movl -0x9(%rsi), %edx
jmp 0x75438
movzbl -0x3(%rsi), %edx
jmp 0x75438
xorl %edx, %edx
movq %rbx, %rdi
callq 0x89fd4
incq %r15
cmpq %r15, %r13
jne 0x753ff
movl $0x1, %eax
movl %eax, 0xa5ed9(%rip)     # 0x11b32c
leaq 0x913fe(%rip), %r14     # 0x106858
movl %eax, 0x9f0(%r14)
decl %ebp
movq %rbx, %rdi
movl %ebp, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x8a6ac
movl $0x0, 0xa5eae(%rip)     # 0x11b32c
movl 0x4(%rsp), %eax
movl %eax, 0x9f0(%r14)
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x89976
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/scripting.c
// Function: ldbTrace
void ldbTrace(lua_State *lua) {
    lua_Debug ar;
    int level = 0;

    while(lua_getstack(lua,level,&ar)) {
        lua_getinfo(lua,"Snl",&ar);
        if(strstr(ar.short_src,"user_script") != NULL) {
            ldbLog(sdscatprintf(sdsempty(),"%s %s:",
                (level == 0) ? "In" : "From",
                ar.name ? ar.name : "top level"));
            ldbLogSourceLine(ar.currentline);
        }
        level++;
    }
    if (level == 0) {
        ldbLog(sdsnew("<error> Can't retrieve Lua stack."));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
xorl %esi, %esi
callq 0x8abb9
testl %eax, %eax
je 0x75583
movl %eax, 0xc(%rsp)
movl $0x1, %r14d
leaq 0x48(%rsp), %r15
leaq 0x583c1(%rip), %r12     # 0xcd8a3
leaq 0x10(%rsp), %r13
leaq 0x57ca9(%rip), %rbp     # 0xcd197
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x8ad39
movq %r15, %rdi
movq %rbp, %rsi
callq 0x266c0
testq %rax, %rax
je 0x75563
callq 0x39222
cmpl $0x1, %r14d
leaq 0x58395(%rip), %rdx     # 0xcd8b1
leaq 0x5838b(%rip), %rcx     # 0xcd8ae
cmoveq %rcx, %rdx
movq 0x18(%rsp), %rcx
testq %rcx, %rcx
leaq 0x58380(%rip), %rsi     # 0xcd8b6
cmoveq %rsi, %rcx
movq %rax, %rdi
leaq 0x58363(%rip), %rsi     # 0xcd8a7
xorl %eax, %eax
callq 0x39eb7
movq 0xa5cbe(%rip), %rdi     # 0x11b210
movq %rax, %rsi
callq 0x2e40f
movl 0x38(%rsp), %edi
callq 0x74619
movq %rbx, %rdi
movl %r14d, %esi
movq %r13, %rdx
callq 0x8abb9
incl %r14d
testl %eax, %eax
jne 0x754ee
cmpl $0x0, 0xc(%rsp)
jne 0x7559e
leaq 0x58336(%rip), %rdi     # 0xcd8c0
callq 0x39245
movq 0xa5c7a(%rip), %rdi     # 0x11b210
movq %rax, %rsi
callq 0x2e40f
addq $0x88, %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/scripting.c
// Function: ldbMaxlen
void ldbMaxlen(sds *argv, int argc) {
    if (argc == 2) {
        int newval = atoi(argv[1]);
        ldb.maxlen_hint_sent = 1; /* User knows about this command. */
        if (newval != 0 && newval <= 60) newval = 60;
        ldb.maxlen = newval;
    }
    if (ldb.maxlen) {
        ldbLog(sdscatprintf(sdsempty(),"<value> replies are truncated at %d bytes.",(int)ldb.maxlen));
    } else {
        ldbLog(sdscatprintf(sdsempty(),"<value> replies are unlimited."));
    }
}

// Assembly:
pushq %rbx
cmpl $0x2, %esi
jne 0x755e4
movq 0x8(%rdi), %rdi
callq 0x26770
movl $0x1, 0xa5d8f(%rip)     # 0x11b358
cmpl $0x3d, %eax
cltq
movl $0x3c, %ecx
cmovgeq %rax, %rcx
testl %eax, %eax
cmoveq %rax, %rcx
movq %rcx, 0xa5d6c(%rip)     # 0x11b350
movq 0xa5d65(%rip), %rbx     # 0x11b350
callq 0x39222
testq %rbx, %rbx
je 0x7560e
movl 0xa5d55(%rip), %edx     # 0x11b350
leaq 0x582e0(%rip), %rsi     # 0xcd8e2
movq %rax, %rdi
xorl %eax, %eax
callq 0x39eb7
jmp 0x7561f
leaq 0x582f8(%rip), %rsi     # 0xcd90d
movq %rax, %rdi
xorl %eax, %eax
callq 0x39eb7
movq 0xa5bea(%rip), %rdi     # 0x11b210
movq %rax, %rsi
popq %rbx
jmp 0x2e40f
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/memtest.c
// Function: memtest_addressing
int memtest_addressing(unsigned long *l, size_t bytes, int interactive) {
    unsigned long words = bytes/sizeof(unsigned long);
    unsigned long j, *p;

    /* Fill */
    p = l;
    for (j = 0; j < words; j++) {
        *p = (unsigned long)p;
        p++;
        if ((j & 0xffff) == 0 && interactive)
            memtest_progress_step(j,words*2,'A');
    }
    /* Test */
    p = l;
    for (j = 0; j < words; j++) {
        if (*p != (unsigned long)p) {
            if (interactive) {
                printf("\n*** MEMORY ADDRESSING ERROR: %p contains %lu\n",
                    (void*) p, *p);
                exit(1);
            }
            return 1;
        }
        p++;
        if ((j & 0xffff) == 0 && interactive)
            memtest_progress_step(j+words,words*2,'A');
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %r14
movq %rsi, %r13
shrq $0x3, %r13
movq %rsi, (%rsp)
cmpq $0x8, %rsi
jb 0x76a5c
leaq (,%r13,2), %r15
xorl %r12d, %r12d
movq %r14, %rbx
testl %ebp, %ebp
sete %al
movq %rbx, (%r14,%r12,8)
testw %r12w, %r12w
setne %cl
orb %al, %cl
jne 0x76a50
movq %r12, %rdi
movq %r15, %rsi
movl $0x41, %edx
callq 0x769a2
incq %r12
addq $0x8, %rbx
cmpq %r12, %r13
jne 0x76a2c
cmpq $0x8, (%rsp)
jb 0x76aaa
leaq (,%r13,2), %rbx
xorl %r15d, %r15d
movq %r14, %r12
movq (%r14), %rdx
cmpq %rdx, %r12
jne 0x76aae
testl %ebp, %ebp
sete %al
testw %r15w, %r15w
setne %cl
orb %al, %cl
jne 0x76a9a
leaq (%r15,%r13), %rdi
movq %rbx, %rsi
movl $0x41, %edx
callq 0x769a2
addq $0x8, %r14
incq %r15
addq $0x8, %r12
cmpq %r15, %r13
jne 0x76a71
xorl %eax, %eax
jmp 0x76ab7
movl $0x1, %eax
testl %ebp, %ebp
jne 0x76ac6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5775f(%rip), %rdi     # 0xce22c
movq %r14, %rsi
xorl %eax, %eax
callq 0x260a0
movl $0x1, %edi
callq 0x262d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/memtest.c
// Function: memtest_fill_random
void memtest_fill_random(unsigned long *l, size_t bytes, int interactive) {
    unsigned long step = 4096/sizeof(unsigned long);
    unsigned long words = bytes/sizeof(unsigned long)/2;
    unsigned long iwords = words/step;  /* words per iteration */
    unsigned long off, w, *l1, *l2;
    uint64_t rseed = UINT64_C(0xd13133de9afdb566); /* Just a random seed. */
    uint64_t rout = 0;

    assert((bytes & 4095) == 0);
    for (off = 0; off < step; off++) {
        l1 = l+off;
        l2 = l1+words;
        for (w = 0; w < iwords; w++) {
            xorshift64star_next();
            *l1 = *l2 = (unsigned long) rout;
            l1 += step;
            l2 += step;
            if ((w & 0xffff) == 0 && interactive)
                memtest_progress_step(w+iwords*off,words,'R');
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
testl $0xfff, %esi            # imm = 0xFFF
jne 0x76be7
movl %edx, %r13d
movq %rsi, %rbx
shrq $0x4, %rbx
movq %rsi, %r12
shrq $0xd, %r12
movabsq $-0x2ececc2165024a9a, %r14 # imm = 0xD13133DE9AFDB566
movq $0x0, 0x8(%rsp)
movabsq $0x2545f4914f6cdd1d, %rdi # imm = 0x2545F4914F6CDD1D
xorl %ecx, %ecx
movq %rsi, 0x18(%rsp)
cmpq $0x2000, %rsi           # imm = 0x2000
movq %rcx, 0x20(%rsp)
jb 0x76bb9
movq 0x10(%rsp), %rax
leaq (%rax,%rcx,8), %r15
xorl %ebp, %ebp
testl %r13d, %r13d
sete %al
movq %r14, %rcx
shrq $0xc, %rcx
xorq %r14, %rcx
movq %rcx, %rdx
shlq $0x19, %rdx
xorq %rcx, %rdx
movq %rdx, %r14
shrq $0x1b, %r14
xorq %rdx, %r14
movq %r14, %rcx
imulq %rdi, %rcx
movq %rcx, (%r15,%rbx,8)
movq %rcx, (%r15)
testw %bp, %bp
setne %cl
orb %al, %cl
jne 0x76baa
movq 0x8(%rsp), %rax
leaq (%rax,%rbp), %rdi
movq %rbx, %rsi
movl $0x52, %edx
callq 0x769a2
movabsq $0x2545f4914f6cdd1d, %rdi # imm = 0x2545F4914F6CDD1D
addq $0x1000, %r15           # imm = 0x1000
incq %rbp
cmpq %rbp, %r12
jne 0x76b4e
movq 0x20(%rsp), %rcx
incq %rcx
addq %r12, 0x8(%rsp)
cmpq $0x200, %rcx            # imm = 0x200
movq 0x18(%rsp), %rsi
jne 0x76b35
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5766d(%rip), %rdi     # 0xce25b
leaq 0x5767a(%rip), %rsi     # 0xce26f
leaq 0x5767d(%rip), %rcx     # 0xce279
movl $0x92, %edx
callq 0x262e0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/memtest.c
// Function: memtest_compare
int memtest_compare(unsigned long *l, size_t bytes, int interactive) {
    unsigned long words = bytes/sizeof(unsigned long)/2;
    unsigned long w, *l1, *l2;

    assert((bytes & 4095) == 0);
    l1 = l;
    l2 = l1+words;
    for (w = 0; w < words; w++) {
        if (*l1 != *l2) {
            if (interactive) {
                printf("\n*** MEMORY ERROR DETECTED: %p != %p (%lu vs %lu)\n",
                    (void*)l1, (void*)l2, *l1, *l2);
                exit(1);
            }
            return 1;
        }
        l1 ++;
        l2 ++;
        if ((w & 0xffff) == 0 && interactive)
            memtest_progress_step(w,words,'=');
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
testl $0xfff, %r15d           # imm = 0xFFF
jne 0x76da5
cmpq $0x10, %r15
jb 0x76d8f
movl %edx, %ebp
movq %rdi, %rbx
shrq $0x4, %r15
leaq (%rdi,%r15,8), %r14
xorl %r12d, %r12d
movq (%rbx), %rcx
movq (%r14), %r8
cmpq %r8, %rcx
jne 0x76d93
testl %ebp, %ebp
sete %al
testw %r12w, %r12w
setne %cl
orb %al, %cl
jne 0x76d7f
movq %r12, %rdi
movq %r15, %rsi
movl $0x3d, %edx
callq 0x769a2
addq $0x8, %rbx
addq $0x8, %r14
incq %r12
cmpq %r12, %r15
jne 0x76d54
xorl %eax, %eax
jmp 0x76d9c
movl $0x1, %eax
testl %ebp, %ebp
jne 0x76dc4
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x574af(%rip), %rdi     # 0xce25b
leaq 0x574bc(%rip), %rsi     # 0xce26f
leaq 0x57550(%rip), %rcx     # 0xce30a
movl $0xc6, %edx
callq 0x262e0
leaq 0x57571(%rip), %rdi     # 0xce33c
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x260a0
movl $0x1, %edi
callq 0x262d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/memtest.c
// Function: memtest_compare_times
int memtest_compare_times(unsigned long *m, size_t bytes, int pass, int times,
                          int interactive)
{
    int j;
    int errors = 0;

    for (j = 0; j < times; j++) {
        if (interactive) memtest_progress_start("Compare",pass);
        errors += memtest_compare(m,bytes,interactive);
        if (interactive) memtest_progress_end();
    }
    return errors;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, 0x4(%rsp)
testl %ecx, %ecx
jle 0x76e42
movl %r8d, %ebx
movl %ecx, %ebp
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
testl %ebx, %ebx
je 0x76e17
leaq 0x57561(%rip), %rdi     # 0xce36f
movl 0x4(%rsp), %esi
callq 0x768c8
movq %r12, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x76d2a
movl %eax, %r14d
testl %ebx, %ebx
je 0x76e39
leaq 0x57392(%rip), %rdi     # 0xce1c4
xorl %eax, %eax
callq 0x260a0
addl %r14d, %r13d
decl %ebp
jne 0x76e03
jmp 0x76e45
xorl %r13d, %r13d
movl %r13d, %eax
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/memtest.c
// Function: memtest_alloc_and_test
void memtest_alloc_and_test(size_t megabytes, int passes) {
    size_t bytes = megabytes*1024*1024;
    unsigned long *m = malloc(bytes);

    if (m == NULL) {
        fprintf(stderr,"Unable to allocate %zu megabytes: %s",
            megabytes, strerror(errno));
        exit(1);
    }
    memtest_test(m,bytes,passes,1);
    free(m);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
movq %rdi, %r14
shlq $0x14, %r14
movq %r14, %rdi
callq 0x26370
testq %rax, %rax
je 0x77240
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movl %ebx, %edx
movl $0x1, %ecx
callq 0x76e57
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x264e0
movq %r15, %rdi
callq 0x2712f
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/bitops.c
// Function: setUnsignedBitfield
void setUnsignedBitfield(unsigned char *p, uint64_t offset, uint64_t bits, uint64_t value) {
    uint64_t byte, bit, byteval, bitval, j;

    for (j = 0; j < bits; j++) {
        bitval = (value & ((uint64_t)1<<(bits-1-j))) != 0;
        byte = offset >> 3;
        bit = 7 - (offset & 0x7);
        byteval = p[byte];
        byteval &= ~(1 << bit);
        byteval |= bitval << bit;
        p[byte] = byteval & 0xff;
        offset++;
    }
}

// Assembly:
testq %rdx, %rdx
je 0x77625
movq %rcx, %rax
decq %rdx
xorl %r8d, %r8d
btq %rdx, %rax
setb %r8b
movq %rsi, %r9
shrq $0x3, %r9
movl %esi, %ecx
notb %cl
andb $0x7, %cl
movzbl (%rdi,%r9), %r10d
btrl %ecx, %r10d
shll %cl, %r8d
orl %r10d, %r8d
movb %r8b, (%rdi,%r9)
incq %rsi
addq $-0x1, %rdx
jb 0x775f0
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/bitops.c
// Function: getUnsignedBitfield
uint64_t getUnsignedBitfield(unsigned char *p, uint64_t offset, uint64_t bits) {
    uint64_t byte, bit, byteval, bitval, j, value = 0;

    for (j = 0; j < bits; j++) {
        byte = offset >> 3;
        bit = 7 - (offset & 0x7);
        byteval = p[byte];
        bitval = (byteval >> bit) & 1;
        value = (value<<1) | bitval;
        offset++;
    }
    return value;
}

// Assembly:
xorl %eax, %eax
testq %rdx, %rdx
je 0x77662
movq %rsi, %rcx
shrq $0x3, %rcx
movzbl (%rdi,%rcx), %ecx
movl %esi, %r8d
notb %r8b
movzbl %r8b, %r8d
andl $0x7, %r8d
xorl %r9d, %r9d
btl %r8d, %ecx
setb %r9b
leaq (%r9,%rax,2), %rax
incq %rsi
decq %rdx
jne 0x77632
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/bitops.c
// Function: getSignedBitfield
int64_t getSignedBitfield(unsigned char *p, uint64_t offset, uint64_t bits) {
    int64_t value;
    union {uint64_t u; int64_t i;} conv;

    /* Converting from unsigned to signed is undefined when the value does
     * not fit, however here we assume two's complement and the original value
     * was obtained from signed -> unsigned conversion, so we'll find the
     * most significant bit set if the original value was negative.
     *
     * Note that two's complement is mandatory for exact-width types
     * according to the C99 standard. */
    conv.u = getUnsignedBitfield(p,offset,bits);
    value = conv.i;

    /* If the top significant bit is 1, propagate it to all the
     * higher bits for two's complement representation of signed
     * integers. */
    if (value & ((uint64_t)1 << (bits-1)))
        value |= ((uint64_t)-1) << bits;
    return value;
}

// Assembly:
movq %rdx, %rcx
testq %rdx, %rdx
je 0x776a3
xorl %edx, %edx
movq %rcx, %rax
movq %rsi, %r8
shrq $0x3, %r8
movzbl (%rdi,%r8), %r8d
movl %esi, %r9d
notb %r9b
movzbl %r9b, %r9d
andl $0x7, %r9d
xorl %r10d, %r10d
btl %r9d, %r8d
setb %r10b
leaq (%r10,%rdx,2), %rdx
incq %rsi
decq %rax
jne 0x77670
jmp 0x776a5
xorl %edx, %edx
movq $-0x1, %rsi
shlq %cl, %rsi
leal -0x1(%rcx), %eax
movzbl %al, %ecx
xorl %eax, %eax
btq %rcx, %rdx
cmovbq %rsi, %rax
orq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/bitops.c
// Function: checkUnsignedBitfieldOverflow
int checkUnsignedBitfieldOverflow(uint64_t value, int64_t incr, uint64_t bits, int owtype, uint64_t *limit) {
    uint64_t max = (bits == 64) ? UINT64_MAX : (((uint64_t)1<<bits)-1);
    int64_t maxincr = max-value;
    int64_t minincr = -value;

    if (value > max || (incr > 0 && incr > maxincr)) {
        if (limit) {
            if (owtype == BFOVERFLOW_WRAP) {
                goto handle_wrap;
            } else if (owtype == BFOVERFLOW_SAT) {
                *limit = max;
            }
        }
        return 1;
    } else if (incr < 0 && incr < minincr) {
        if (limit) {
            if (owtype == BFOVERFLOW_WRAP) {
                goto handle_wrap;
            } else if (owtype == BFOVERFLOW_SAT) {
                *limit = 0;
            }
        }
        return -1;
    }
    return 0;

handle_wrap:
    {
        uint64_t mask = ((uint64_t)-1) << bits;
        uint64_t res = value+incr;

        res &= ~mask;
        *limit = res;
    }
    return 1;
}

// Assembly:
movl %ecx, %r9d
movq %rdx, %rcx
movq $-0x1, %rdx
shlq %cl, %rdx
movq $-0x1, %r10
cmpq $0x40, %rcx
notq %rdx
cmovneq %rdx, %r10
movq %r10, %rax
subq %rdi, %rax
jb 0x776fd
testq %rsi, %rsi
setle %cl
cmpq %rsi, %rax
setge %al
orb %cl, %al
jne 0x77713
movl $0x1, %eax
testq %r8, %r8
je 0x77712
testl %r9d, %r9d
je 0x77742
cmpl $0x1, %r9d
je 0x77751
retq
movq %rdi, %rax
negq %rax
testq %rsi, %rsi
setns %cl
cmpq %rsi, %rax
setle %r10b
xorl %eax, %eax
orb %cl, %r10b
jne 0x77712
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %r8, %r8
je 0x77712
cmpl $0x1, %r9d
je 0x77758
testl %r9d, %r9d
jne 0x77712
addq %rdi, %rsi
andq %rdx, %rsi
movl $0x1, %r9d
movq %rsi, %r10
movq %r10, (%r8)
movl %r9d, %eax
retq
xorl %r10d, %r10d
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
jmp 0x77751
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/bitops.c
// Function: checkSignedBitfieldOverflow
int checkSignedBitfieldOverflow(int64_t value, int64_t incr, uint64_t bits, int owtype, int64_t *limit) {
    int64_t max = (bits == 64) ? INT64_MAX : (((int64_t)1<<(bits-1))-1);
    int64_t min = (-max)-1;

    /* Note that maxincr and minincr could overflow, but we use the values
     * only after checking 'value' range, so when we use it no overflow
     * happens. */
    int64_t maxincr = max-value;
    int64_t minincr = min-value;

    if (value > max || (bits != 64 && incr > maxincr) || (value >= 0 && incr > 0 && incr > maxincr))
    {
        if (limit) {
            if (owtype == BFOVERFLOW_WRAP) {
                goto handle_wrap;
            } else if (owtype == BFOVERFLOW_SAT) {
                *limit = max;
            }
        }
        return 1;
    } else if (value < min || (bits != 64 && incr < minincr) || (value < 0 && incr < 0 && incr < minincr)) {
        if (limit) {
            if (owtype == BFOVERFLOW_WRAP) {
                goto handle_wrap;
            } else if (owtype == BFOVERFLOW_SAT) {
                *limit = min;
            }
        }
        return -1;
    }
    return 0;

handle_wrap:
    {
        uint64_t mask = ((uint64_t)-1) << bits;
        uint64_t msb = (uint64_t)1 << (bits-1);
        uint64_t a = value, b = incr, c;
        c = a+b; /* Perform addition as unsigned so that's defined. */

        /* If the sign bit is set, propagate to all the higher order
         * bits, to cap the negative value. If it's clear, mask to
         * the positive integer limit. */
        if (c & msb) {
            c |= mask;
        } else {
            c &= ~mask;
        }
        *limit = c;
    }
    return 1;
}

// Assembly:
movl %ecx, %r9d
leal -0x1(%rdx), %ecx
movl $0x1, %r11d
shlq %cl, %r11
leaq -0x1(%r11), %rax
cmpq $0x40, %rdx
movabsq $0x7fffffffffffffff, %r10 # imm = 0x7FFFFFFFFFFFFFFF
cmovneq %rax, %r10
movq %r10, %rax
subq %rdi, %rax
jl 0x777aa
cmpq $0x40, %rdx
je 0x7779b
cmpq %rsi, %rax
jl 0x777aa
testq %rdi, %rdi
js 0x777c0
testq %rsi, %rsi
jle 0x777c0
cmpq %rsi, %rax
jge 0x777c0
movl $0x1, %eax
testq %r8, %r8
je 0x777bf
testl %r9d, %r9d
je 0x777fa
cmpl $0x1, %r9d
je 0x77822
retq
notq %r10
cmpq %rdi, %r10
jg 0x777e5
movq %r10, %rcx
subq %rdi, %rcx
cmpq $0x40, %rdx
je 0x777d9
cmpq %rsi, %rcx
jg 0x777e5
xorl %eax, %eax
testq %rdi, %rsi
jns 0x777bf
cmpq %rsi, %rcx
jle 0x777bf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %r8, %r8
je 0x777bf
cmpl $0x1, %r9d
je 0x77829
testl %r9d, %r9d
jne 0x777bf
movq $-0x1, %r10
movl %edx, %ecx
shlq %cl, %r10
addq %rdi, %rsi
movq %r10, %rax
orq %rsi, %rax
notq %r10
andq %rsi, %r10
testq %rsi, %r11
cmovneq %rax, %r10
movl $0x1, %r9d
movq %r10, (%r8)
movl %r9d, %eax
retq
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
jmp 0x77822
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/bitops.c
// Function: printBits
void printBits(unsigned char *p, unsigned long count) {
    unsigned long j, i, byte;

    for (j = 0; j < count; j++) {
        byte = p[j];
        for (i = 0x80; i > 0; i /= 2)
            printf("%c", (byte & i) ? '1' : '0');
        printf("|");
    }
    printf("\n");
}

// Assembly:
testq %rsi, %rsi
je 0x7789c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movzbl (%r14,%r15), %r12d
movl $0x80, %r13d
movl $0x80, %ebp
movl %r13d, %eax
andl %r12d, %eax
cmpl $0x1, %eax
movl $0x31, %edi
sbbl $0x0, %edi
callq 0x26330
shrq %rbp
cmpq $0x1, %r13
movq %rbp, %r13
ja 0x7785a
movl $0x7c, %edi
callq 0x26330
incq %r15
cmpq %rbx, %r15
jne 0x7784a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0xa, %edi
jmp 0x26330
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/bitops.c
// Function: getBitOffsetFromArgument
int getBitOffsetFromArgument(client *c, robj *o, size_t *offset, int hash, int bits) {
    long long loffset;
    char *err = "bit offset is not an integer or out of range";
    char *p = o->ptr;
    size_t plen = sdslen(p);
    int usehash = 0;

    /* Handle #<offset> form. */
    if (p[0] == '#' && hash && bits > 0) usehash = 1;

    if (string2ll(p+usehash,plen-usehash,&loffset) == 0) {
        addReplyError(c,err);
        return C_ERR;
    }

    /* Adjust the offset by 'bits' for #<offset> form. */
    if (usehash) loffset *= bits;

    /* Limit offset to 512MB in bytes */
    if ((loffset < 0) || ((unsigned long long)loffset >> 3) >= (512*1024*1024))
    {
        addReplyError(c,err);
        return C_ERR;
    }

    *offset = (size_t)loffset;
    return C_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rdi
movzbl -0x1(%rdi), %esi
movl %esi, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x778f4
leaq 0x57401(%rip), %rdx     # 0xcecd0
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
shrl $0x3, %esi
jmp 0x778f6
movq -0x11(%rdi), %rsi
jmp 0x778f6
movzwl -0x5(%rdi), %esi
jmp 0x778f6
movl -0x9(%rdi), %esi
jmp 0x778f6
movzbl -0x3(%rdi), %esi
jmp 0x778f6
xorl %esi, %esi
cmpb $0x23, (%rdi)
sete %al
testl %ecx, %ecx
setne %cl
testl %ebp, %ebp
setg %r15b
andb %cl, %r15b
andb %al, %r15b
movzbl %r15b, %eax
addq %rax, %rdi
subq %rax, %rsi
movq %rsp, %rdx
callq 0x434c7
testl %eax, %eax
je 0x77940
testb %r15b, %r15b
je 0x77933
movl %ebp, %eax
imulq (%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, %rcx
shrq $0x20, %rcx
je 0x77956
leaq 0x57512(%rip), %rsi     # 0xcee59
movq %rbx, %rdi
callq 0x3ffcb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x7795b
movq %rax, (%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/bitops.c
// Function: getBitfieldTypeFromArgument
int getBitfieldTypeFromArgument(client *c, robj *o, int *sign, int *bits) {
    char *p = o->ptr;
    char *err = "Invalid bitfield type. Use something like i16 u8. Note that u64 is not supported but i64 is.";
    long long llbits;

    if (p[0] == 'i') {
        *sign = 1;
    } else if (p[0] == 'u') {
        *sign = 0;
    } else {
        addReplyError(c,err);
        return C_ERR;
    }

    if ((string2ll(p+1,strlen(p+1),&llbits)) == 0 ||
        llbits < 1 ||
        (*sign == 1 && llbits > 64) ||
        (*sign == 0 && llbits > 63))
    {
        addReplyError(c,err);
        return C_ERR;
    }
    *bits = llbits;
    return C_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %r12
movzbl (%r12), %eax
cmpl $0x69, %eax
je 0x77993
cmpl $0x75, %eax
jne 0x779f5
xorl %eax, %eax
jmp 0x77998
movl $0x1, %eax
movl %eax, (%r15)
incq %r12
movq %r12, %rdi
callq 0x26510
leaq 0x8(%rsp), %r13
movq %r12, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x434c7
testl %eax, %eax
sete %cl
movq (%r13), %rax
testq %rax, %rax
setle %dl
orb %cl, %dl
jne 0x779f5
movl (%r15), %ecx
cmpl $0x1, %ecx
sete %dl
cmpq $0x41, %rax
setge %sil
testb %sil, %dl
jne 0x779f5
testl %ecx, %ecx
sete %cl
cmpq $0x40, %rax
setge %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x77a17
leaq 0x5748a(%rip), %rsi     # 0xcee86
movq %rbx, %rdi
callq 0x3ffcb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl %eax, (%r14)
xorl %eax, %eax
jmp 0x77a09
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/bitops.c
// Function: lookupStringForBitCommand
robj *lookupStringForBitCommand(client *c, size_t maxbit) {
    size_t byte = maxbit >> 3;
    robj *o = lookupKeyWrite(c->db,c->argv[1]);

    if (o == NULL) {
        o = createObject(OBJ_STRING,sdsnewlen(NULL, byte+1));
        dbAdd(c->db,c->argv[1],o);
    } else {
        if (checkType(c,o,OBJ_STRING)) return NULL;
        o = dbUnshareStringValue(c->db,c->argv[1],o);
        o->ptr = sdsgrowzero(o->ptr,byte+1);
    }
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
shrq $0x3, %rbx
movq 0x10(%rdi), %rdi
movq 0x40(%r14), %rax
movq 0x8(%rax), %rsi
callq 0x44f66
testq %rax, %rax
je 0x77a89
movq %rax, %r12
xorl %r15d, %r15d
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x441ab
testl %eax, %eax
jne 0x77ab7
movq 0x10(%r14), %rdi
movq 0x40(%r14), %rax
movq 0x8(%rax), %rsi
movq %r12, %rdx
callq 0x453b8
movq %rax, %r15
movq 0x8(%rax), %rdi
incq %rbx
movq %rbx, %rsi
callq 0x39987
movq %rax, 0x8(%r15)
jmp 0x77ab7
incq %rbx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x3910c
xorl %edi, %edi
movq %rax, %rsi
callq 0x43ab4
movq %rax, %r15
movq 0x10(%r14), %rdi
movq 0x40(%r14), %rax
movq 0x8(%rax), %rsi
movq %r15, %rdx
callq 0x45007
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/bitops.c
// Function: getObjectReadOnlyString
unsigned char *getObjectReadOnlyString(robj *o, long *len, char *llbuf) {
    serverAssert(o->type == OBJ_STRING);
    unsigned char *p = NULL;

    /* Set the 'p' pointer to the string, that can be just a stack allocated
     * array if our string was integer encoded. */
    if (o && o->encoding == OBJ_ENCODING_INT) {
        p = (unsigned char*) llbuf;
        if (len) *len = ll2string(llbuf,LONG_STR_SIZE,(long)o->ptr);
    } else if (o) {
        p = (unsigned char*) o->ptr;
        if (len) *len = sdslen(o->ptr);
    } else {
        if (len) *len = 0;
    }
    return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl (%rdi), %eax
testb $0xf, %al
jne 0x77b4f
movq %rsi, %r14
andl $0xf0, %eax
cmpl $0x10, %eax
jne 0x77afd
movq %rdx, %rbx
testq %r14, %r14
je 0x77b29
movq 0x8(%rdi), %rdx
movl $0x15, %esi
movq %rbx, %rdi
callq 0x433e5
cltq
movq %rax, (%r14)
jmp 0x77b29
movq 0x8(%rdi), %rbx
testq %r14, %r14
je 0x77b29
movzbl -0x1(%rbx), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x77b4b
leaq 0x571c9(%rip), %rdx     # 0xcece4
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
shrl $0x3, %eax
jmp 0x77af8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq -0x11(%rbx), %rax
jmp 0x77af8
movzwl -0x5(%rbx), %eax
jmp 0x77af8
movl -0x9(%rbx), %eax
jmp 0x77af8
movzbl -0x3(%rbx), %eax
jmp 0x77af8
xorl %eax, %eax
jmp 0x77af8
leaq 0x4b3a2(%rip), %rdi     # 0xc2ef8
leaq 0x572f3(%rip), %rsi     # 0xcee50
movl $0x1f4, %edx            # imm = 0x1F4
callq 0x654e1
movl $0x1, %edi
callq 0x263d0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/bitops.c
// Function: setbitCommand
void setbitCommand(client *c) {
    robj *o;
    char *err = "bit is not an integer or out of range";
    size_t bitoffset;
    ssize_t byte, bit;
    int byteval, bitval;
    long on;

    if (getBitOffsetFromArgument(c,c->argv[2],&bitoffset,0,0) != C_OK)
        return;

    if (getLongFromObjectOrReply(c,c->argv[3],&on,err) != C_OK)
        return;

    /* Bits can only be set or cleared... */
    if (on & ~1) {
        addReplyError(c,err);
        return;
    }

    if ((o = lookupStringForBitCommand(c,bitoffset)) == NULL) return;

    /* Get current values */
    byte = bitoffset >> 3;
    byteval = ((uint8_t*)o->ptr)[byte];
    bit = 7 - (bitoffset & 0x7);
    bitval = byteval & (1 << bit);

    /* Update byte with new bit value and return original value */
    byteval &= ~(1 << bit);
    byteval |= ((on & 0x1) << bit);
    ((uint8_t*)o->ptr)[byte] = byteval;
    signalModifiedKey(c->db,c->argv[1]);
    notifyKeyspaceEvent(NOTIFY_STRING,"setbit",c->argv[1],c->db->id);
    server.dirty++;
    addReply(c, bitval ? shared.cone : shared.czero);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x10(%rax), %rsi
leaq 0x8(%rsp), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x778a6
testl %eax, %eax
jne 0x77c7e
movq 0x40(%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x57339(%rip), %rcx     # 0xceee3
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x44ba1
testl %eax, %eax
jne 0x77c7e
cmpq $0x2, (%rsp)
jae 0x77c6f
movq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x77a1e
testq %rax, %rax
je 0x77c7e
movq %r14, %rdx
shrq $0x3, %rdx
movq 0x8(%rax), %rax
movzbl (%rax,%rdx), %ebp
notb %r14b
andb $0x7, %r14b
movl %ebp, %esi
btrl %r14d, %esi
movl (%rsp), %edi
andl $0x1, %edi
movl %r14d, %ecx
shll %cl, %edi
orl %esi, %edi
movb %dil, (%rax,%rdx)
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x45220
movq 0x10(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x8(%rcx), %rdx
movl 0x30(%rax), %ecx
leaq 0x478fb(%rip), %rsi     # 0xbf530
movl $0x8, %edi
callq 0x800c9
leaq 0x8ec12(%rip), %rax     # 0x106858
incq 0x710(%rax)
movzbl %r14b, %eax
xorl %ecx, %ecx
btl %eax, %ebp
setb %cl
leaq 0x8f650(%rip), %rax     # 0x1072b0
movq 0x20(%rax,%rcx,8), %rsi
movq %rbx, %rdi
callq 0x3fc19
jmp 0x77c7e
leaq 0x5726d(%rip), %rsi     # 0xceee3
movq %rbx, %rdi
callq 0x3ffcb
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/bitops.c
// Function: getbitCommand
void getbitCommand(client *c) {
    robj *o;
    char llbuf[32];
    size_t bitoffset;
    size_t byte, bit;
    size_t bitval = 0;

    if (getBitOffsetFromArgument(c,c->argv[2],&bitoffset,0,0) != C_OK)
        return;

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

    byte = bitoffset >> 3;
    bit = 7 - (bitoffset & 0x7);
    if (sdsEncodedObject(o)) {
        if (byte < sdslen(o->ptr))
            bitval = ((uint8_t*)o->ptr)[byte] & (1 << bit);
    } else {
        if (byte < (size_t)ll2string(llbuf,sizeof(llbuf),(long)o->ptr))
            bitval = llbuf[byte] & (1 << bit);
    }

    addReply(c, bitval ? shared.cone : shared.czero);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x10(%rax), %rsi
leaq 0x8(%rsp), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x778a6
testl %eax, %eax
je 0x77cc0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
leaq 0x8f5e1(%rip), %r15     # 0x1072b0
movq 0x20(%r15), %rdx
movq %rbx, %rdi
callq 0x44f89
testq %rax, %rax
je 0x77cb2
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x441ab
testl %eax, %eax
jne 0x77cb2
movq 0x8(%rsp), %r12
movq %r12, %r13
shrq $0x3, %r13
movl (%r14), %eax
shrl $0x4, %eax
testb $0x7, %al
jne 0x77d31
movq 0x8(%r14), %rax
movzbl -0x1(%rax), %ecx
movl %ecx, %edx
andl $0x7, %edx
cmpl $0x4, %edx
ja 0x77d6e
leaq 0x56fd5(%rip), %rsi     # 0xcecf8
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
shrl $0x3, %ecx
jmp 0x77d70
movq 0x8(%r14), %rdx
leaq 0x10(%rsp), %rdi
movl $0x20, %esi
callq 0x433e5
cltq
movb $0x1, %dl
cmpq %rax, %r13
jae 0x77d8d
leaq (%rsp,%r13), %rax
addq $0x10, %rax
jmp 0x77d7a
movq -0x11(%rax), %rcx
jmp 0x77d70
movzwl -0x5(%rax), %ecx
jmp 0x77d70
movl -0x9(%rax), %ecx
jmp 0x77d70
movzbl -0x3(%rax), %ecx
jmp 0x77d70
xorl %ecx, %ecx
movb $0x1, %dl
cmpq %rcx, %r13
jae 0x77d8d
addq %r13, %rax
movzbl (%rax), %eax
notb %r12b
movzbl %r12b, %ecx
andl $0x7, %ecx
btl %ecx, %eax
setae %dl
xorb $0x1, %dl
movzbl %dl, %eax
movq 0x20(%r15,%rax,8), %rsi
movq %rbx, %rdi
callq 0x3fc19
jmp 0x77cb2
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/sentinel.c
// Function: releaseSentinelRedisInstance
void releaseSentinelRedisInstance(sentinelRedisInstance *ri) {
    /* Release all its slaves or sentinels if any. */
    dictRelease(ri->sentinels);
    dictRelease(ri->slaves);

    /* Disconnect the instance. */
    releaseInstanceLink(ri->link,ri);

    /* Free other resources. */
    sdsfree(ri->name);
    sdsfree(ri->runid);
    sdsfree(ri->notification_script);
    sdsfree(ri->client_reconfig_script);
    sdsfree(ri->slave_master_host);
    sdsfree(ri->leader);
    sdsfree(ri->auth_pass);
    sdsfree(ri->info);
    releaseSentinelAddr(ri->addr);

    /* Clear state into the master if needed. */
    if ((ri->flags & SRI_SLAVE) && (ri->flags & SRI_PROMOTED) && ri->master)
        ri->master->promoted_slave = NULL;

    zfree(ri);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x80(%rdi), %rdi
callq 0x31ff3
movq 0x88(%rbx), %rdi
callq 0x31ff3
movq 0x28(%rbx), %rdi
movq %rbx, %rsi
callq 0x7b083
movq 0x8(%rbx), %rdi
callq 0x392b6
movq 0x10(%rbx), %rdi
callq 0x392b6
movq 0x120(%rbx), %rdi
callq 0x392b6
movq 0x128(%rbx), %rdi
callq 0x392b6
movq 0xc0(%rbx), %rdi
callq 0x392b6
movq 0xd8(%rbx), %rdi
callq 0x392b6
movq 0x98(%rbx), %rdi
callq 0x392b6
movq 0x130(%rbx), %rdi
callq 0x392b6
movq 0x20(%rbx), %r14
movq (%r14), %rdi
callq 0x392b6
movq %r14, %rdi
callq 0x3b3df
movl (%rbx), %eax
notl %eax
testb $-0x7e, %al
jne 0x790b0
movq 0xb8(%rbx), %rax
testq %rax, %rax
je 0x790b0
movq $0x0, 0x118(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3b3df