LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/redis-cli.c
// Function: cliSelect
static int cliSelect(void) {
    redisReply *reply;
    if (config.dbnum == 0) return REDIS_OK;

    reply = redisCommand(context,"SELECT %d",config.dbnum);
    if (reply != NULL) {
        int result = REDIS_OK;
        if (reply->type == REDIS_REPLY_ERROR) result = REDIS_ERR;
        freeReplyObject(reply);
        return result;
    }
    return REDIS_ERR;
}

// Assembly:
pushq %rbx
movl 0x411bc(%rip), %edx     # 0x5a430
testl %edx, %edx
je 0x192a6
movq 0x412d9(%rip), %rdi     # 0x5a558
leaq 0x2bae4(%rip), %rsi     # 0x44d6a
xorl %eax, %eax
callq 0x1d2d0
testq %rax, %rax
je 0x192aa
xorl %ebx, %ebx
cmpl $0x6, (%rax)
sete %bl
negl %ebx
movq %rax, %rdi
callq 0x1b6f0
jmp 0x192af
xorl %ebx, %ebx
jmp 0x192af
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/redis-cli.c
// Function: reconnectingRedisCommand
static redisReply *reconnectingRedisCommand(redisContext *c, const char *fmt, ...) {
    redisReply *reply = NULL;
    int tries = 0;
    va_list ap;

    assert(!c->err);
    while(reply == NULL) {
        while (c->err & (REDIS_ERR_IO | REDIS_ERR_EOF)) {
            printf("\r\x1b[0K"); /* Cursor to left edge + clear line. */
            printf("Reconnecting... %d\r", ++tries);
            fflush(stdout);

            redisFree(c);
            c = redisConnect(config.hostip,config.hostport);
            usleep(1000000);
        }

        va_start(ap,fmt);
        reply = redisvCommand(c,fmt,ap);
        va_end(ap);

        if (c->err && !(c->err & (REDIS_ERR_IO | REDIS_ERR_EOF))) {
            fprintf(stderr, "Error: %s\n", c->errstr);
            exit(1);
        } else if (tries > 0) {
            printf("\r\x1b[0K"); /* Cursor to left edge + clear line. */
        }
    }

    context = c;
    return reply;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, 0x8(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
testb %al, %al
je 0x1931b
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
cmpl $0x0, (%rdi)
jne 0x19414
movq %rdi, %r14
leaq 0x2bafd(%rip), %r12     # 0x44e2b
leaq 0x2bafc(%rip), %r13     # 0x44e31
movq 0x3ec84(%rip), %rbx     # 0x57fc0
xorl %ebp, %ebp
testb $0x3, (%r14)
je 0x1938d
movq %r12, %rdi
xorl %eax, %eax
callq 0x101f0
incl %ebp
movq %r13, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x101f0
movq (%rbx), %rdi
callq 0x10470
movq %r14, %rdi
callq 0x1c9fe
movq 0x41095(%rip), %rdi     # 0x5a408
movl 0x41097(%rip), %esi     # 0x5a410
callq 0x1ca56
movq %rax, %r14
movl $0xf4240, %edi          # imm = 0xF4240
callq 0x10720
jmp 0x1933e
leaq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x120(%rsp), %rax
movq %rax, 0x18(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x1d296
movq %rax, %r15
movl (%r14), %eax
testl %eax, %eax
sete %cl
testb $0x3, %al
setne %al
orb %cl, %al
je 0x1940c
testl %ebp, %ebp
jle 0x193e7
movq %r12, %rdi
xorl %eax, %eax
callq 0x101f0
testq %r15, %r15
je 0x1933e
movq %r14, 0x41161(%rip)     # 0x5a558
movq %r15, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x10e30
leaq 0x2b9b4(%rip), %rdi     # 0x44dcf
leaq 0x2b9b5(%rip), %rsi     # 0x44dd7
leaq 0x2b9ba(%rip), %rcx     # 0x44de3
movl $0x3b0, %edx            # imm = 0x3B0
callq 0x10250
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/redis-cli.c
// Function: cliRefreshPrompt
static void cliRefreshPrompt(void) {
    int len;

    if (config.eval_ldb) return;
    if (config.hostsocket != NULL)
        len = snprintf(config.prompt,sizeof(config.prompt),"redis %s",
                       config.hostsocket);
    else
        len = anetFormatAddr(config.prompt, sizeof(config.prompt),
                           config.hostip, config.hostport);
    /* Add [dbnum] if needed */
    if (config.dbnum != 0)
        len += snprintf(config.prompt+len,sizeof(config.prompt)-len,"[%d]",
            config.dbnum);
    snprintf(config.prompt+len,sizeof(config.prompt)-len,"> ");
}

// Assembly:
cmpl $0x0, 0x40e6d(%rip)     # 0x5a540
je 0x196d6
retq
pushq %rbx
movq 0x40d3a(%rip), %rcx     # 0x5a418
testq %rcx, %rcx
je 0x196ff
leaq 0x40dce(%rip), %rdi     # 0x5a4b8
leaq 0x2b826(%rip), %rdx     # 0x44f17
movl $0x80, %esi
xorl %eax, %eax
callq 0x10200
jmp 0x1971d
movq 0x40d02(%rip), %rdx     # 0x5a408
movl 0x40d04(%rip), %ecx     # 0x5a410
leaq 0x40da5(%rip), %rdi     # 0x5a4b8
movl $0x80, %esi
callq 0x1566f
movl %eax, %ebx
movl 0x40d0b(%rip), %ecx     # 0x5a430
testl %ecx, %ecx
je 0x19756
movslq %ebx, %rbx
leaq 0x40cd5(%rip), %rax     # 0x5a408
leaq (%rbx,%rax), %rdi
addq $0xb0, %rdi
movl $0x80, %esi
subq %rbx, %rsi
leaq 0x2b7d3(%rip), %rdx     # 0x44f20
xorl %eax, %eax
callq 0x10200
addl %eax, %ebx
movslq %ebx, %rax
leaq 0x40ca8(%rip), %rcx     # 0x5a408
leaq (%rax,%rcx), %rdi
addq $0xb0, %rdi
movl $0x80, %esi
subq %rax, %rsi
leaq 0x2bfaf(%rip), %rdx     # 0x45729
xorl %eax, %eax
popq %rbx
jmp 0x10200
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/redis-cli.c
// Function: cliFormatReplyCSV
static sds cliFormatReplyCSV(redisReply *r) {
    unsigned int i;

    sds out = sdsempty();
    switch (r->type) {
    case REDIS_REPLY_ERROR:
        out = sdscat(out,"ERROR,");
        out = sdscatrepr(out,r->str,strlen(r->str));
    break;
    case REDIS_REPLY_STATUS:
        out = sdscatrepr(out,r->str,r->len);
    break;
    case REDIS_REPLY_INTEGER:
        out = sdscatprintf(out,"%lld",r->integer);
    break;
    case REDIS_REPLY_STRING:
        out = sdscatrepr(out,r->str,r->len);
    break;
    case REDIS_REPLY_NIL:
        out = sdscat(out,"NIL");
    break;
    case REDIS_REPLY_ARRAY:
        for (i = 0; i < r->elements; i++) {
            sds tmp = cliFormatReplyCSV(r->element[i]);
            out = sdscatlen(out,tmp,sdslen(tmp));
            if (i != r->elements-1) out = sdscat(out,",");
            sdsfree(tmp);
        }
    break;
    default:
        fprintf(stderr,"Unknown reply type: %d\n", r->type);
        exit(1);
    }
    return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1d966
movq %rax, %r14
movl (%rbx), %edi
leal -0x1(%rdi), %eax
cmpl $0x5, %eax
ja 0x19c9d
leaq 0x267ae(%rip), %rcx     # 0x402fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rbx), %rsi
movslq 0x10(%rbx), %rdx
movq %r14, %rdi
jmp 0x19c8a
leaq 0x2b42b(%rip), %rsi     # 0x44f99
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1e279
cmpq $0x0, 0x20(%rbx)
je 0x19c2e
movl $0x1, %ebp
xorl %r15d, %r15d
leaq 0x26776(%rip), %r13     # 0x40314
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x19b23
movq %rax, %r12
movzbl -0x1(%rax), %edx
movl %edx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x19be9
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
shrl $0x3, %edx
jmp 0x19beb
movq -0x11(%r12), %rdx
jmp 0x19beb
movzwl -0x5(%r12), %edx
jmp 0x19beb
movl -0x9(%r12), %edx
jmp 0x19beb
movzbl -0x3(%r12), %edx
jmp 0x19beb
xorl %edx, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x1e1ae
movq %rax, %r14
movq 0x20(%rbx), %rax
decq %rax
cmpq %r15, %rax
je 0x19c17
movq %r14, %rdi
leaq 0x2b388(%rip), %rsi     # 0x44f97
callq 0x1e279
movq %rax, %r14
movq %r12, %rdi
callq 0x1da09
movl %ebp, %r15d
incl %ebp
cmpq %r15, 0x20(%rbx)
ja 0x19b9e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rdx
leaq 0x2b2e7(%rip), %rsi     # 0x44f32
movq %r14, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1e60a
leaq 0x2b328(%rip), %rsi     # 0x44f92
movq %r14, %rdi
callq 0x1e279
movq %rax, %r14
movq 0x18(%rbx), %rbx
movq %rbx, %rdi
callq 0x101c0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1f313
callq 0x10e9e
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/redis-cli.c
// Function: getLongInfoField
static long getLongInfoField(char *info, char *field) {
    char *value = getInfoField(info,field);
    long l;

    if (!value) return LONG_MIN;
    l = strtol(value,NULL,10);
    zfree(value);
    return l;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
callq 0x106c0
testq %rax, %rax
je 0x19d39
movq %rax, %r14
movq %rbx, %rdi
callq 0x101c0
leaq (%r14,%rax), %rbx
incq %rbx
movq %rbx, %rdi
movl $0xd, %esi
callq 0x101e0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2c, %esi
callq 0x101e0
cmpq %r14, %rax
movq %r14, %r15
cmovbq %rax, %r15
testq %rax, %rax
cmoveq %r14, %r15
subq %rbx, %r15
leaq 0x1(%r15), %rdi
callq 0x1a735
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x10400
movb $0x0, (%r14,%r15)
movq %r14, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x103f0
movq %rax, %rbx
movq %r14, %rdi
callq 0x1a877
movq %rbx, %rax
jmp 0x19d43
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/redis-cli.c
// Function: completionCallback
static void completionCallback(const char *buf, linenoiseCompletions *lc) {
    size_t startpos = 0;
    int mask;
    int i;
    size_t matchlen;
    sds tmp;

    if (strncasecmp(buf,"help ",5) == 0) {
        startpos = 5;
        while (isspace(buf[startpos])) startpos++;
        mask = CLI_HELP_COMMAND | CLI_HELP_GROUP;
    } else {
        mask = CLI_HELP_COMMAND;
    }

    for (i = 0; i < helpEntriesLen; i++) {
        if (!(helpEntries[i].type & mask)) continue;

        matchlen = strlen(buf+startpos);
        if (strncasecmp(buf+startpos,helpEntries[i].full,matchlen) == 0) {
            tmp = sdsnewlen(buf,startpos);
            tmp = sdscat(tmp,helpEntries[i].full);
            linenoiseAddCompletion(lc,tmp);
            sdsfree(tmp);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
leaq 0x2bad3(%rip), %rsi     # 0x45844
movl $0x5, %edx
callq 0x10460
testl %eax, %eax
movq %rbx, 0x8(%rsp)
je 0x19d91
movl $0x1, 0x4(%rsp)
xorl %r15d, %r15d
jmp 0x19db7
callq 0x10710
movq (%rax), %rax
movl $0x4, %r15d
movsbq 0x1(%rbx,%r15), %rcx
incq %r15
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x19d9f
movl $0x3, 0x4(%rsp)
movl 0x407a6(%rip), %r13d    # 0x5a564
testl %r13d, %r13d
jle 0x19e5a
movq 0x8(%rsp), %rax
leaq (%rax,%r15), %r12
movl $0x10, %ebx
movq 0x4078c(%rip), %rbp     # 0x5a568
xorl %r14d, %r14d
movl 0x4(%rsp), %eax
testl %eax, -0x10(%rbp,%rbx)
je 0x19e4b
movq %r12, %rdi
callq 0x101c0
movq (%rbp,%rbx), %rsi
movq %r12, %rdi
movq %rax, %rdx
callq 0x10460
testl %eax, %eax
jne 0x19e4b
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1d854
movq 0x4074f(%rip), %rcx     # 0x5a568
movq (%rcx,%rbx), %rsi
movq %rax, %rdi
callq 0x1e279
movq %rax, %r13
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x20215
movq %r13, %rdi
callq 0x1da09
movq 0x40724(%rip), %rbp     # 0x5a568
movl 0x40719(%rip), %r13d    # 0x5a564
incq %r14
movslq %r13d, %rax
addq $0x20, %rbx
cmpq %rax, %r14
jl 0x19ddf
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/redis-cli.c
// Function: issueCommandRepeat
static int issueCommandRepeat(int argc, char **argv, long repeat) {
    while (1) {
        config.cluster_reissue_command = 0;
        if (cliSendCommand(argc,argv,repeat) != REDIS_OK) {
            cliConnect(1);

            /* If we still cannot send the command print error.
             * We'll try to reconnect the next time. */
            if (cliSendCommand(argc,argv,repeat) != REDIS_OK) {
                cliPrintContextError();
                return REDIS_ERR;
            }
         }
         /* Issue the command again if we got redirected in cluster mode */
         if (config.cluster_mode && config.cluster_reissue_command) {
            cliConnect(1);
         } else {
             break;
        }
    }
    return REDIS_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
xorl %r15d, %r15d
movl $0x0, 0x40420(%rip)     # 0x5a464
movl %ebp, %edi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1a0ca
testl %eax, %eax
je 0x1a06e
movl $0x1, %edi
callq 0x18946
movl %ebp, %edi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1a0ca
testl %eax, %eax
jne 0x1a08c
cmpl $0x0, 0x403eb(%rip)     # 0x5a460
je 0x1a09e
cmpl $0x0, 0x403e6(%rip)     # 0x5a464
je 0x1a09e
movl $0x1, %edi
callq 0x18946
jmp 0x1a03a
movq 0x404c5(%rip), %rdx     # 0x5a558
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testq %rdx, %rdx
jne 0x1a0ac
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x3df45(%rip), %rax     # 0x57ff8
movq (%rax), %rdi
addq $0x4, %rdx
leaq 0x2ad84(%rip), %rsi     # 0x44e45
xorl %eax, %eax
callq 0x103b0
jmp 0x1a09e
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/redis-cli.c
// Function: cliOutputCommandHelp
static void cliOutputCommandHelp(struct commandHelp *help, int group) {
    printf("\r\n  \x1b[1m%s\x1b[0m \x1b[90m%s\x1b[0m\r\n", help->name, help->params);
    printf("  \x1b[33msummary:\x1b[0m %s\r\n", help->summary);
    printf("  \x1b[33msince:\x1b[0m %s\r\n", help->since);
    if (group) {
        printf("  \x1b[33mgroup:\x1b[0m %s\r\n", commandGroups[help->group]);
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
leaq 0x2b37d(%rip), %rdi     # 0x45a54
xorl %eax, %eax
callq 0x101f0
movq 0x10(%rbx), %rsi
leaq 0x2b388(%rip), %rdi     # 0x45a71
xorl %eax, %eax
callq 0x101f0
movq 0x20(%rbx), %rsi
leaq 0x2b38f(%rip), %rdi     # 0x45a8a
xorl %eax, %eax
callq 0x101f0
testl %ebp, %ebp
je 0x1a729
movslq 0x18(%rbx), %rax
leaq 0x3bc9f(%rip), %rcx     # 0x563b0
movq (%rcx,%rax,8), %rsi
leaq 0x2b385(%rip), %rdi     # 0x45aa1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x101f0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/zmalloc.c
// Function: zmalloc
void *zmalloc(size_t size) {
    void *ptr = malloc(size+PREFIX_SIZE);

    if (!ptr) zmalloc_oom_handler(size);
#ifdef HAVE_MALLOC_SIZE
    update_zmalloc_stat_alloc(zmalloc_size(ptr));
    return ptr;
#else
    *((size_t*)ptr) = size;
    update_zmalloc_stat_alloc(size+PREFIX_SIZE);
    return (char*)ptr+PREFIX_SIZE;
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x22285
movq %rax, %rbx
testq %rax, %rax
jne 0x1a752
movq %r14, %rdi
callq *0x3fbc6(%rip)          # 0x5a318
movq %rbx, %rdi
callq 0x25f7c
addq $0x7, %rax
andq $-0x8, %rax
cmpb $0x1, 0x3fe2f(%rip)     # 0x5a598
jne 0x1a775
lock
addq %rax, 0x3fe2d(%rip)     # 0x5a5a0
jmp 0x1a77c
addq %rax, 0x3fe24(%rip)     # 0x5a5a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/zmalloc.c
// Function: zcalloc
void *zcalloc(size_t size) {
    void *ptr = calloc(1, size+PREFIX_SIZE);

    if (!ptr) zmalloc_oom_handler(size);
#ifdef HAVE_MALLOC_SIZE
    update_zmalloc_stat_alloc(zmalloc_size(ptr));
    return ptr;
#else
    *((size_t*)ptr) = size;
    update_zmalloc_stat_alloc(size+PREFIX_SIZE);
    return (char*)ptr+PREFIX_SIZE;
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0x22b3e
movq %rax, %rbx
testq %rax, %rax
jne 0x1a7ac
movq %r14, %rdi
callq *0x3fb6c(%rip)          # 0x5a318
movq %rbx, %rdi
callq 0x25f7c
addq $0x7, %rax
andq $-0x8, %rax
cmpb $0x1, 0x3fdd5(%rip)     # 0x5a598
jne 0x1a7cf
lock
addq %rax, 0x3fdd3(%rip)     # 0x5a5a0
jmp 0x1a7d6
addq %rax, 0x3fdca(%rip)     # 0x5a5a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/zmalloc.c
// Function: zrealloc
void *zrealloc(void *ptr, size_t size) {
#ifndef HAVE_MALLOC_SIZE
    void *realptr;
#endif
    size_t oldsize;
    void *newptr;

    if (ptr == NULL) return zmalloc(size);
#ifdef HAVE_MALLOC_SIZE
    oldsize = zmalloc_size(ptr);
    newptr = realloc(ptr,size);
    if (!newptr) zmalloc_oom_handler(size);

    update_zmalloc_stat_free(oldsize);
    update_zmalloc_stat_alloc(zmalloc_size(newptr));
    return newptr;
#else
    realptr = (char*)ptr-PREFIX_SIZE;
    oldsize = *((size_t*)realptr);
    newptr = realloc(realptr,size+PREFIX_SIZE);
    if (!newptr) zmalloc_oom_handler(size);

    *((size_t*)newptr) = size;
    update_zmalloc_stat_free(oldsize);
    update_zmalloc_stat_alloc(size);
    return (char*)newptr+PREFIX_SIZE;
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
testq %rdi, %rdi
je 0x1a830
movq %rdi, %rbx
callq 0x25f7c
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22fd1
movq %rax, %rbx
testq %rax, %rax
jne 0x1a815
movq %r15, %rdi
callq *0x3fb03(%rip)          # 0x5a318
addq $0x7, %r14
andq $-0x8, %r14
cmpb $0x1, 0x3fd74(%rip)     # 0x5a598
jne 0x1a83d
lock
subq %r14, 0x3fd72(%rip)     # 0x5a5a0
jmp 0x1a844
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1a735
subq %r14, 0x3fd5c(%rip)     # 0x5a5a0
movq %rbx, %rdi
callq 0x25f7c
addq $0x7, %rax
andq $-0x8, %rax
cmpb $0x1, 0x3fd3d(%rip)     # 0x5a598
jne 0x1a867
lock
addq %rax, 0x3fd3b(%rip)     # 0x5a5a0
jmp 0x1a86e
addq %rax, 0x3fd32(%rip)     # 0x5a5a0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/zmalloc.c
// Function: zfree
void zfree(void *ptr) {
#ifndef HAVE_MALLOC_SIZE
    void *realptr;
    size_t oldsize;
#endif

    if (ptr == NULL) return;
#ifdef HAVE_MALLOC_SIZE
    update_zmalloc_stat_free(zmalloc_size(ptr));
    free(ptr);
#else
    realptr = (char*)ptr-PREFIX_SIZE;
    oldsize = *((size_t*)realptr);
    update_zmalloc_stat_free(oldsize+PREFIX_SIZE);
    free(realptr);
#endif
}

// Assembly:
testq %rdi, %rdi
je 0x1a8a0
pushq %rbx
movq %rdi, %rbx
callq 0x25f7c
addq $0x7, %rax
andq $-0x8, %rax
cmpb $0x1, 0x3fd04(%rip)     # 0x5a598
jne 0x1a8a1
lock
subq %rax, 0x3fd02(%rip)     # 0x5a5a0
jmp 0x1a8a8
retq
subq %rax, 0x3fcf8(%rip)     # 0x5a5a0
movq %rbx, %rdi
popq %rbx
jmp 0x23a5f
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/zmalloc.c
// Function: zstrdup
char *zstrdup(const char *s) {
    size_t l = strlen(s)+1;
    char *p = zmalloc(l);

    memcpy(p,s,l);
    return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x101c0
leaq 0x1(%rax), %r14
movq %r14, %rdi
callq 0x1a735
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10400
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/zmalloc.c
// Function: zmalloc_get_rss
size_t zmalloc_get_rss(void) {
    int page = sysconf(_SC_PAGESIZE);
    size_t rss;
    char buf[4096];
    char filename[256];
    int fd, count;
    char *p, *x;

    snprintf(filename,256,"/proc/%d/stat",getpid());
    if ((fd = open(filename,O_RDONLY)) == -1) return 0;
    if (read(fd,buf,4096) <= 0) {
        close(fd);
        return 0;
    }
    close(fd);

    p = buf;
    count = 23; /* RSS is the 24th field in /proc/<pid>/stat */
    while(p && count--) {
        p = strchr(p,' ');
        if (p) p++;
    }
    if (!p) return 0;
    x = strchr(p,' ');
    if (!x) return 0;
    *x = '\0';

    rss = strtoll(p,NULL,10);
    rss *= page;
    return rss;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1108, %rsp           # imm = 0x1108
movl $0x1e, %edi
callq 0x105c0
movq %rax, %rbx
callq 0x10180
leaq 0x2b644(%rip), %rdx     # 0x45f6c
xorl %r14d, %r14d
movq %rsp, %r15
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0x10200
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x10590
cmpl $-0x1, %eax
je 0x1a9cc
movl %eax, %ebp
leaq 0x100(%rsp), %r15
movl $0x1000, %edx           # imm = 0x1000
movl %eax, %edi
movq %r15, %rsi
callq 0x102f0
movq %rax, %r14
movl %ebp, %edi
callq 0x102a0
testq %r14, %r14
jle 0x1a9c9
movl $0xffffffe8, %ebp       # imm = 0xFFFFFFE8
xorl %r14d, %r14d
incl %ebp
je 0x1a99c
movq %r15, %rdi
movl $0x20, %esi
callq 0x101e0
leaq 0x1(%rax), %r15
testq %rax, %rax
jne 0x1a980
jmp 0x1a9cc
movq %r15, %rdi
movl $0x20, %esi
callq 0x101e0
testq %rax, %rax
je 0x1a9c9
movb $0x0, (%rax)
movq %r15, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x103a0
movslq %ebx, %r14
imulq %rax, %r14
jmp 0x1a9cc
xorl %r14d, %r14d
movq %r14, %rax
addq $0x1108, %rsp           # imm = 0x1108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/zmalloc.c
// Function: zmalloc_get_smap_bytes_by_field
size_t zmalloc_get_smap_bytes_by_field(char *field) {
    char line[1024];
    size_t bytes = 0;
    FILE *fp = fopen("/proc/self/smaps","r");
    int flen = strlen(field);

    if (!fp) return 0;
    while(fgets(line,sizeof(line),fp) != NULL) {
        if (strncmp(line,field,flen) == 0) {
            char *p = strchr(line,'k');
            if (p) {
                *p = '\0';
                bytes += strtol(line+flen,NULL,10) * 1024;
            }
        }
    }
    fclose(fp);
    return bytes;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %r14
leaq 0x2b528(%rip), %rdi     # 0x45f7a
leaq 0x2c8c4(%rip), %rsi     # 0x4731d
callq 0x105a0
movq %rax, %rbx
movq %r14, %rdi
callq 0x101c0
testq %rbx, %rbx
je 0x1aae7
movq %rax, %r15
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdx
callq 0x10330
testq %rax, %rax
je 0x1aaec
movslq %r15d, %r12
leaq (%rsp,%r12), %r13
xorl %r15d, %r15d
movq %rsp, %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x100c0
testl %eax, %eax
jne 0x1aad0
movq %rbp, %rdi
movl $0x6b, %esi
callq 0x101e0
testq %rax, %rax
je 0x1aad0
movb $0x0, (%rax)
movq %r13, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x103f0
shlq $0xa, %rax
addq %rax, %r15
movq %rbp, %rdi
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdx
callq 0x10330
testq %rax, %rax
jne 0x1aa93
jmp 0x1aaef
xorl %r15d, %r15d
jmp 0x1aaf7
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x101b0
movq %r15, %rax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/zmalloc.c
// Function: zmalloc_default_oom
static void zmalloc_default_oom(size_t size) {
    fprintf(stderr, "zmalloc: Out of memory trying to allocate %zu bytes\n",
        size);
    fflush(stderr);
    abort();
}

// Assembly:
pushq %rbx
movq %rdi, %rdx
movq 0x3d4b7(%rip), %rbx     # 0x57ff8
movq (%rbx), %rdi
leaq 0x2b44f(%rip), %rsi     # 0x45f9a
xorl %eax, %eax
callq 0x103b0
movq (%rbx), %rdi
callq 0x10470
callq 0x10090
nop
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/ae.c
// Function: aeResizeSetSize
int aeResizeSetSize(aeEventLoop *eventLoop, int setsize) {
    int i;

    if (setsize == eventLoop->setsize) return AE_OK;
    if (eventLoop->maxfd >= setsize) return AE_ERR;
    if (aeApiResize(eventLoop,setsize) == -1) return AE_ERR;

    eventLoop->events = zrealloc(eventLoop->events,sizeof(aeFileEvent)*setsize);
    eventLoop->fired = zrealloc(eventLoop->fired,sizeof(aeFiredEvent)*setsize);
    eventLoop->setsize = setsize;

    /* Make sure that if we created new slots, they are initialized with
     * an AE_NONE mask. */
    for (i = eventLoop->maxfd+1; i < setsize; i++)
        eventLoop->events[i].mask = AE_NONE;
    return AE_OK;
}

// Assembly:
xorl %eax, %eax
cmpl %esi, 0x4(%rdi)
je 0x1af38
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %esi, (%rdi)
jge 0x1af2d
movq 0x38(%r14), %r12
movq 0x8(%r12), %rdi
movslq %ebx, %r15
leaq (,%r15,4), %rax
leaq (%rax,%rax,2), %rsi
callq 0x1a7e1
movq %rax, 0x8(%r12)
movq 0x18(%r14), %rdi
movq %r15, %rsi
shlq $0x5, %rsi
callq 0x1a7e1
movq %rax, 0x18(%r14)
movq 0x20(%r14), %rdi
leaq (,%r15,8), %rsi
callq 0x1a7e1
movq %rax, 0x20(%r14)
movl %r15d, 0x4(%r14)
movslq (%r14), %rcx
leal 0x1(%rcx), %edx
movl $0x0, %eax
cmpl %r15d, %edx
jge 0x1af2d
movq 0x18(%r14), %rdx
subl %ecx, %ebx
addl $-0x2, %ebx
leaq 0x4(%rbx), %rax
andq $-0x4, %rax
movq %rbx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shlq $0x5, %rcx
addq %rdx, %rcx
addq $0x80, %rcx
xorl %edx, %edx
movdqa 0x2b1ab(%rip), %xmm1    # 0x46000
movdqa 0x2b1b3(%rip), %xmm2    # 0x46010
movdqa 0x2b1bb(%rip), %xmm3    # 0x46020
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rdx, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %esi
notl %esi
testb $0x1, %sil
je 0x1aeb7
movl $0x0, -0x60(%rcx)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x1aecd
movl $0x0, -0x40(%rcx)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %esi
testb $0x1, %sil
je 0x1af09
movl $0x0, -0x20(%rcx)
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x1af1a
movl $0x0, (%rcx)
addq $0x4, %rdx
subq $-0x80, %rcx
cmpq %rdx, %rax
jne 0x1ae6d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/ae.c
// Function: aeDeleteEventLoop
void aeDeleteEventLoop(aeEventLoop *eventLoop) {
    aeApiFree(eventLoop);
    zfree(eventLoop->events);
    zfree(eventLoop->fired);
    zfree(eventLoop);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %r14
movl (%r14), %edi
callq 0x102a0
movq 0x8(%r14), %rdi
callq 0x1a877
movq %r14, %rdi
callq 0x1a877
movq 0x18(%rbx), %rdi
callq 0x1a877
movq 0x20(%rbx), %rdi
callq 0x1a877
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1a877
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/ae.c
// Function: aeCreateFileEvent
int aeCreateFileEvent(aeEventLoop *eventLoop, int fd, int mask,
        aeFileProc *proc, void *clientData)
{
    if (fd >= eventLoop->setsize) {
        errno = ERANGE;
        return AE_ERR;
    }
    aeFileEvent *fe = &eventLoop->events[fd];

    if (aeApiAddEvent(eventLoop, fd, mask) == -1)
        return AE_ERR;
    fe->mask |= mask;
    if (mask & AE_READABLE) fe->rfileProc = proc;
    if (mask & AE_WRITABLE) fe->wfileProc = proc;
    fe->clientData = clientData;
    if (fd > eventLoop->maxfd)
        eventLoop->maxfd = fd;
    return AE_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl %esi, 0x4(%rdi)
jle 0x1b02f
movq %rcx, %r12
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
movq %r8, (%rsp)
movslq %esi, %rdx
movq %rdx, %r15
shlq $0x5, %r15
movq 0x18(%rdi), %r13
movq 0x38(%rdi), %rax
leaq 0xc(%rsp), %rcx
movl $0x0, 0x8(%rcx)
movl (%r13,%r15), %esi
movl %esi, %edi
orl %ebp, %edi
movl %edi, %r8d
andl $0x1, %r8d
andl $0x2, %edi
leal (%r8,%rdi,2), %edi
movl %edi, (%rcx)
xorl %edi, %edi
testl %esi, %esi
setne %dil
leal 0x1(,%rdi,2), %esi
movl %edx, 0x4(%rcx)
movl (%rax), %edi
callq 0x102c0
cmpl $-0x1, %eax
je 0x1b03a
addq %r15, %r13
orl %ebp, (%r13)
testb $0x1, %bpl
je 0x1b011
movq %r12, 0x8(%r13)
testb $0x2, %bpl
movq (%rsp), %rax
je 0x1b01f
movq %r12, 0x10(%r13)
movq %rax, 0x18(%r13)
xorl %eax, %eax
cmpl %ebx, (%r14)
jge 0x1b03f
movl %ebx, (%r14)
jmp 0x1b03f
callq 0x100a0
movl $0x22, (%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/ae.c
// Function: aeDeleteFileEvent
void aeDeleteFileEvent(aeEventLoop *eventLoop, int fd, int mask)
{
    if (fd >= eventLoop->setsize) return;
    aeFileEvent *fe = &eventLoop->events[fd];
    if (fe->mask == AE_NONE) return;

    aeApiDelEvent(eventLoop, fd, mask);
    fe->mask = fe->mask & (~mask);
    if (fd == eventLoop->maxfd && fe->mask == AE_NONE) {
        /* Update the max fd */
        int j;

        for (j = eventLoop->maxfd-1; j >= 0; j--)
            if (eventLoop->events[j].mask != AE_NONE) break;
        eventLoop->maxfd = j;
    }
}

// Assembly:
cmpl %esi, 0x4(%rdi)
jle 0x1b114
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x18(%rdi), %r15
movslq %esi, %rax
shlq $0x5, %rax
movl (%r15,%rax), %ecx
testl %ecx, %ecx
je 0x1b10a
movl %edx, %r14d
addq %rax, %r15
movq 0x38(%rbx), %rax
movq $0x0, 0x10(%rsp)
notl %r14d
andl %r14d, %ecx
movl %ecx, %edx
andl $0x1, %edx
movl %edx, 0xc(%rsp)
testb $0x2, %cl
jne 0x1b0b1
cmpl $0x1, %ecx
movl $0x3, %esi
sbbl $0x0, %esi
jmp 0x1b0bd
orl $0x4, %edx
movl %edx, 0xc(%rsp)
movl $0x3, %esi
leaq 0xc(%rsp), %rcx
movl %ebp, 0x4(%rcx)
movl (%rax), %edi
movl %ebp, %edx
callq 0x102c0
andl (%r15), %r14d
movl %r14d, (%r15)
cmpl %ebp, (%rbx)
jne 0x1b10a
testl %r14d, %r14d
jne 0x1b10a
movl %ebp, %eax
movl %ebp, %ecx
sarl $0x1f, %ecx
andl %ebp, %ecx
decl %ecx
decq %rax
testl %ebp, %ebp
jle 0x1b106
movq 0x18(%rbx), %rdx
movl %eax, %esi
shlq $0x5, %rsi
decl %ebp
decq %rax
cmpl $0x0, (%rdx,%rsi)
je 0x1b0eb
jmp 0x1b108
movl %ecx, %ebp
movl %ebp, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/ae.c
// Function: aeDeleteTimeEvent
int aeDeleteTimeEvent(aeEventLoop *eventLoop, long long id)
{
    aeTimeEvent *te = eventLoop->timeEventHead;
    while(te) {
        if (te->id == id) {
            te->id = AE_DELETED_EVENT_ID;
            return AE_OK;
        }
        te = te->next;
    }
    return AE_ERR; /* NO event with the specified ID found */
}

// Assembly:
movq 0x28(%rdi), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
je 0x1b24d
cmpq %rsi, (%rcx)
je 0x1b244
movq 0x30(%rcx), %rcx
jmp 0x1b234
movq $-0x1, (%rcx)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/ae.c
// Function: aeWait
int aeWait(int fd, int mask, long long milliseconds) {
    struct pollfd pfd;
    int retmask = 0, retval;

    memset(&pfd, 0, sizeof(pfd));
    pfd.fd = fd;
    if (mask & AE_READABLE) pfd.events |= POLLIN;
    if (mask & AE_WRITABLE) pfd.events |= POLLOUT;

    if ((retval = poll(&pfd, 1, milliseconds))== 1) {
        if (pfd.revents & POLLIN) retmask |= AE_READABLE;
        if (pfd.revents & POLLOUT) retmask |= AE_WRITABLE;
	if (pfd.revents & POLLERR) retmask |= AE_WRITABLE;
        if (pfd.revents & POLLHUP) retmask |= AE_WRITABLE;
        return retmask;
    } else {
        return retval;
    }
}

// Assembly:
pushq %rax
movq $0x0, (%rsp)
movl %edi, (%rsp)
movw $0x4, %ax
testb $0x1, %sil
je 0x1b646
movw $0x1, 0x4(%rsp)
movw $0x5, %ax
testb $0x2, %sil
je 0x1b651
movw %ax, 0x4(%rsp)
movq %rsp, %rdi
movl $0x1, %esi
callq 0x104e0
cmpl $0x1, %eax
jne 0x1b681
movzwl 0x6(%rsp), %ecx
movl %ecx, %eax
andl $0x1, %eax
movl %ecx, %edx
shrl %edx
andl $0x2, %edx
orl %eax, %edx
movl %edx, %eax
orl $0x2, %eax
testb $0x18, %cl
cmovel %edx, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/ae.c
// Function: aeMain
void aeMain(aeEventLoop *eventLoop) {
    eventLoop->stop = 0;
    while (!eventLoop->stop) {
        if (eventLoop->beforesleep != NULL)
            eventLoop->beforesleep(eventLoop);
        aeProcessEvents(eventLoop, AE_ALL_EVENTS);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x0, 0x30(%rdi)
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x1b69c
movq %rbx, %rdi
callq *%rax
movq %rbx, %rdi
movl $0x3, %esi
callq 0x1b24e
cmpl $0x0, 0x30(%rbx)
je 0x1b68e
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/src/crc64.c
// Function: crc64
uint64_t crc64(uint64_t crc, const unsigned char *s, uint64_t l) {
    uint64_t j;

    for (j = 0; j < l; j++) {
        uint8_t byte = s[j];
        crc = crc64_tab[(uint8_t)crc ^ byte] ^ (crc >> 8);
    }
    return crc;
}

// Assembly:
movq %rdi, %rax
testq %rdx, %rdx
je 0x1b6ed
xorl %ecx, %ecx
leaq 0x2a97f(%rip), %rdi     # 0x46050
movzbl (%rsi,%rcx), %r8d
movzbl %al, %r9d
xorl %r8d, %r9d
shrq $0x8, %rax
xorq (%rdi,%r9,8), %rax
incq %rcx
cmpq %rcx, %rdx
jne 0x1b6d1
retq
nop
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/hiredis/hiredis.c
// Function: redisReaderCreate
redisReader *redisReaderCreate(void) {
    redisReader *r;

    r = calloc(sizeof(redisReader),1);
    if (r == NULL)
        return NULL;

    r->err = 0;
    r->errstr[0] = '\0';
    r->fn = &defaultFunctions;
    r->buf = sdsempty();
    r->maxbuf = REDIS_READER_MAX_BUF;
    if (r->buf == NULL) {
        free(r);
        return NULL;
    }

    r->ridx = -1;
    return r;
}

// Assembly:
pushq %rbx
movl $0x230, %edi            # imm = 0x230
movl $0x1, %esi
callq 0x10370
testq %rax, %rax
je 0x1b7b7
movq %rax, %rbx
leaq 0x3eba0(%rip), %rax     # 0x5a320
movq %rax, 0x220(%rbx)
callq 0x1d966
movq %rax, 0x88(%rbx)
movq $0x4000, 0xa0(%rbx) # imm = 0x4000
testq %rax, %rax
je 0x1b7af
movl $0xffffffff, 0x210(%rbx) # imm = 0xFFFFFFFF
jmp 0x1b7b9
movq %rbx, %rdi
callq 0x10060
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/hiredis/hiredis.c
// Function: _redisSetError
void __redisSetError(redisContext *c, int type, const char *str) {
    size_t len;

    c->err = type;
    if (str != NULL) {
        len = strlen(str);
        len = len < (sizeof(c->errstr)-1) ? len : (sizeof(c->errstr)-1);
        memcpy(c->errstr,str,len);
        c->errstr[len] = '\0';
    } else {
        /* Only REDIS_ERR_IO may lack a description! */
        assert(type == REDIS_ERR_IO);
        strerror_r(errno,c->errstr,sizeof(c->errstr));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %esi, (%rdi)
testq %rdx, %rdx
je 0x1c9bd
movq %rdx, %r14
movq %rdx, %rdi
callq 0x101c0
cmpq $0x7f, %rax
movl $0x7f, %r15d
cmovbq %rax, %r15
leaq 0x4(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x10400
movb $0x0, 0x4(%rbx,%r15)
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x1, %esi
jne 0x1c9df
callq 0x100a0
movl (%rax), %edi
addq $0x4, %rbx
movl $0x80, %edx
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x10140
leaq 0x2a0c0(%rip), %rdi     # 0x46aa6
leaq 0x29fc1(%rip), %rsi     # 0x469ae
leaq 0x2a0c7(%rip), %rcx     # 0x46abb
movl $0x3d8, %edx            # imm = 0x3D8
callq 0x10250
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/hiredis/hiredis.c
// Function: redisFree
void redisFree(redisContext *c) {
    if (c->fd > 0)
        close(c->fd);
    if (c->obuf != NULL)
        sdsfree(c->obuf);
    if (c->reader != NULL)
        redisReaderFree(c->reader);
    free(c);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x84(%rdi), %edi
testl %edi, %edi
jle 0x1ca11
callq 0x102a0
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x1ca22
callq 0x1da09
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x1ca33
callq 0x1b7be
movq %rbx, %rdi
popq %rbx
jmp 0x10060
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/hiredis/hiredis.c
// Function: redisFreeKeepFd
int redisFreeKeepFd(redisContext *c) {
	int fd = c->fd;
	c->fd = -1;
	redisFree(c);
	return fd;
}

// Assembly:
pushq %rbx
movl 0x84(%rdi), %ebx
movl $0xffffffff, 0x84(%rdi) # imm = 0xFFFFFFFF
callq 0x1c9fe
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/hiredis/hiredis.c
// Function: redisContextInit
static redisContext *redisContextInit(void) {
    redisContext *c;

    c = calloc(1,sizeof(redisContext));
    if (c == NULL)
        return NULL;

    c->err = 0;
    c->errstr[0] = '\0';
    c->obuf = sdsempty();
    c->reader = redisReaderCreate();
    return c;
}

// Assembly:
pushq %rbx
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10370
movq %rax, %rbx
testq %rax, %rax
je 0x1caba
callq 0x1d966
movq %rax, 0x90(%rbx)
callq 0x1b761
movq %rax, 0x98(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/hiredis/hiredis.c
// Function: redisvAppendCommand
int redisvAppendCommand(redisContext *c, const char *format, va_list ap) {
    char *cmd;
    int len;

    len = redisvFormatCommand(&cmd,format,ap);
    if (len == -1) {
        __redisSetError(c,REDIS_ERR_OOM,"Out of memory");
        return REDIS_ERR;
    }

    if (__redisAppendCommand(c,cmd,len) != REDIS_OK) {
        free(cmd);
        return REDIS_ERR;
    }

    free(cmd);
    return REDIS_OK;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1bf96
cmpl $-0x1, %eax
je 0x1d10a
movq 0x8(%rsp), %rsi
movslq %eax, %rdx
movq 0x90(%rbx), %rdi
callq 0x1e1ae
testq %rax, %rax
je 0x1d132
movq %rax, 0x90(%rbx)
movq 0x8(%rsp), %rdi
callq 0x10060
xorl %eax, %eax
jmp 0x1d167
movl $0x5, (%rbx)
movabsq $0x6d20666f2074754f, %rax # imm = 0x6D20666F2074754F
movq %rax, 0x4(%rbx)
movabsq $0x79726f6d656d2066, %rax # imm = 0x79726F6D656D2066
movq %rax, 0x9(%rbx)
movb $0x0, 0x11(%rbx)
jmp 0x1d162
movl $0x5, (%rbx)
movabsq $0x6d20666f2074754f, %rax # imm = 0x6D20666F2074754F
movq %rax, 0x4(%rbx)
movabsq $0x79726f6d656d2066, %rax # imm = 0x79726F6D656D2066
movq %rax, 0x9(%rbx)
movb $0x0, 0x11(%rbx)
movq 0x8(%rsp), %rdi
callq 0x10060
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/hiredis/hiredis.c
// Function: redisAppendCommandArgv
int redisAppendCommandArgv(redisContext *c, int argc, const char **argv, const size_t *argvlen) {
    char *cmd;
    int len;

    len = redisFormatCommandArgv(&cmd,argc,argv,argvlen);
    if (len == -1) {
        __redisSetError(c,REDIS_ERR_OOM,"Out of memory");
        return REDIS_ERR;
    }

    if (__redisAppendCommand(c,cmd,len) != REDIS_OK) {
        free(cmd);
        return REDIS_ERR;
    }

    free(cmd);
    return REDIS_OK;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x1c7dd
cmpl $-0x1, %eax
je 0x1d233
movq (%rsp), %r14
movslq %eax, %rdx
movq 0x90(%rbx), %rdi
movq %r14, %rsi
callq 0x1e1ae
testq %rax, %rax
je 0x1d25b
movq %rax, 0x90(%rbx)
movq %r14, %rdi
callq 0x10060
xorl %eax, %eax
jmp 0x1d28e
movl $0x5, (%rbx)
movabsq $0x6d20666f2074754f, %rax # imm = 0x6D20666F2074754F
movq %rax, 0x4(%rbx)
movabsq $0x79726f6d656d2066, %rax # imm = 0x79726F6D656D2066
movq %rax, 0x9(%rbx)
movb $0x0, 0x11(%rbx)
jmp 0x1d289
movl $0x5, (%rbx)
movabsq $0x6d20666f2074754f, %rax # imm = 0x6D20666F2074754F
movq %rax, 0x4(%rbx)
movabsq $0x79726f6d656d2066, %rax # imm = 0x79726F6D656D2066
movq %rax, 0x9(%rbx)
movb $0x0, 0x11(%rbx)
movq %r14, %rdi
callq 0x10060
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/hiredis/sds.c
// Function: sdsnewlen
sds sdsnewlen(const void *init, size_t initlen) {
    void *sh;
    sds s;
    char type = sdsReqType(initlen);
    /* Empty strings are usually created in order to append. Use type 8
     * since type 5 is not good at this. */
    if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8;
    int hdrlen = sdsHdrSize(type);
    unsigned char *fp; /* flags pointer. */

    sh = s_malloc(hdrlen+initlen+1);
    if (!init)
        memset(sh, 0, hdrlen+initlen+1);
    if (sh == NULL) return NULL;
    s = (char*)sh+hdrlen;
    fp = ((unsigned char*)s)-1;
    switch(type) {
        case SDS_TYPE_5: {
            *fp = type | (initlen << SDS_TYPE_BITS);
            break;
        }
        case SDS_TYPE_8: {
            SDS_HDR_VAR(8,s);
            sh->len = initlen;
            sh->alloc = initlen;
            *fp = type;
            break;
        }
        case SDS_TYPE_16: {
            SDS_HDR_VAR(16,s);
            sh->len = initlen;
            sh->alloc = initlen;
            *fp = type;
            break;
        }
        case SDS_TYPE_32: {
            SDS_HDR_VAR(32,s);
            sh->len = initlen;
            sh->alloc = initlen;
            *fp = type;
            break;
        }
        case SDS_TYPE_64: {
            SDS_HDR_VAR(64,s);
            sh->len = initlen;
            sh->alloc = initlen;
            *fp = type;
            break;
        }
    }
    if (initlen && init)
        memcpy(s, init, initlen);
    s[initlen] = '\0';
    return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x20, %rsi
jae 0x1d86f
xorl %eax, %eax
jmp 0x1d891
movb $0x1, %al
cmpq $0xff, %rbx
jb 0x1d891
movb $0x2, %al
cmpq $0xffff, %rbx           # imm = 0xFFFF
jb 0x1d891
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rbx
movb $0x4, %al
sbbb $0x0, %al
testb %al, %al
movzbl %al, %eax
movl $0x1, %ecx
cmovnel %eax, %ecx
testq %rbx, %rbx
cmovnel %eax, %ecx
movzbl %cl, %r13d
leaq 0x29881(%rip), %rax     # 0x47130
movq (%rax,%r13,8), %rbp
leaq (%rbx,%rbp), %r12
incq %r12
movq %r12, %rdi
callq 0x10450
movq %rax, %r15
testq %r14, %r14
jne 0x1d8d7
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x10270
testq %r15, %r15
je 0x1d8f8
addq %rbp, %r15
leaq 0x294aa(%rip), %rax     # 0x46d90
movslq (%rax,%r13,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leal (,%rbx,8), %eax
jmp 0x1d92d
xorl %r15d, %r15d
jmp 0x1d954
movq %rbx, -0x11(%r15)
movq %rbx, -0x9(%r15)
movb $0x4, %al
jmp 0x1d92d
movw %bx, -0x5(%r15)
movw %bx, -0x3(%r15)
movb $0x2, %al
jmp 0x1d92d
movl %ebx, -0x9(%r15)
movl %ebx, -0x5(%r15)
movb $0x3, %al
jmp 0x1d92d
movb %bl, -0x3(%r15)
movb %bl, -0x2(%r15)
movb $0x1, %al
testq %r14, %r14
sete %cl
movb %al, -0x1(%r15)
testq %rbx, %rbx
sete %al
orb %cl, %al
jne 0x1d94f
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10400
movb $0x0, (%r15,%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/hiredis/./sds.h
// Function: sdsrange
static inline size_t sdslen(const sds s) {
    unsigned char flags = s[-1];
    switch(flags&SDS_TYPE_MASK) {
        case SDS_TYPE_5:
            return SDS_TYPE_5_LEN(flags);
        case SDS_TYPE_8:
            return SDS_HDR(8,s)->len;
        case SDS_TYPE_16:
            return SDS_HDR(16,s)->len;
        case SDS_TYPE_32:
            return SDS_HDR(32,s)->len;
        case SDS_TYPE_64:
            return SDS_HDR(64,s)->len;
    }
    return 0;
}

// Assembly:
movzbl -0x1(%rdi), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x1ef86
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x28169(%rip), %rdi     # 0x47018
movslq (%rdi,%rcx,4), %rcx
addq %rdi, %rcx
jmpq *%rcx
shrl $0x3, %eax
jmp 0x1eed2
movq -0x11(%rbx), %rax
jmp 0x1eed2
movzwl -0x5(%rbx), %eax
jmp 0x1eed2
movl -0x9(%rbx), %eax
jmp 0x1eed2
movzbl -0x3(%rbx), %eax
testq %rax, %rax
je 0x1ef7f
leal (%rax,%rsi), %ecx
xorl %r14d, %r14d
testl %ecx, %ecx
cmovlel %r14d, %ecx
testl %esi, %esi
cmovnsl %esi, %ecx
leal (%rax,%rdx), %esi
testl %esi, %esi
cmovlel %r14d, %esi
testl %edx, %edx
cmovnsl %edx, %esi
movl %esi, %edx
subl %ecx, %edx
leal 0x1(%rdx), %edi
cmovbl %r14d, %edi
movl %eax, %edx
subl %ecx, %edx
jle 0x1ef3d
testl %edi, %edi
je 0x1ef3d
leal -0x1(%rax), %r8d
xorl %r9d, %r9d
cmpl %r8d, %ecx
cmoval %r9d, %edx
cmpl %eax, %esi
cmovbl %edi, %edx
movslq %edx, %r14
testl %ecx, %ecx
je 0x1ef3d
testl %edx, %edx
je 0x1ef3d
movl %ecx, %esi
addq %rbx, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x10540
movb $0x0, (%rbx,%r14)
movzbl -0x1(%rbx), %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x1ef7f
leaq 0x280d7(%rip), %rcx     # 0x4702c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shlb $0x3, %r14b
movb %r14b, -0x1(%rbx)
jmp 0x1ef7f
movq %r14, -0x11(%rbx)
jmp 0x1ef7f
movw %r14w, -0x5(%rbx)
jmp 0x1ef7f
movl %r14d, -0x9(%rbx)
jmp 0x1ef7f
movb %r14b, -0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/hiredis/sds.c
// Function: sdsRemoveFreeSpace
sds sdsRemoveFreeSpace(sds s) {
    void *sh, *newsh;
    char type, oldtype = s[-1] & SDS_TYPE_MASK;
    int hdrlen;
    size_t len = sdslen(s);
    sh = (char*)s-sdsHdrSize(oldtype);

    type = sdsReqType(len);
    hdrlen = sdsHdrSize(type);
    if (oldtype==type) {
        newsh = s_realloc(sh, hdrlen+len+1);
        if (newsh == NULL) return NULL;
        s = (char*)newsh+hdrlen;
    } else {
        newsh = s_malloc(hdrlen+len+1);
        if (newsh == NULL) return NULL;
        memcpy((char*)newsh+hdrlen, s, len+1);
        s_free(sh);
        s = (char*)newsh+hdrlen;
        s[-1] = type;
        sdssetlen(s, len);
    }
    sdssetalloc(s, len);
    return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl -0x1(%rdi), %r12d
movl %r12d, %eax
andl $0x7, %eax
movl %r12d, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x1dd27
leaq 0x29126(%rip), %rdx     # 0x46e24
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
shrl $0x3, %r12d
jmp 0x1dd2a
movq -0x11(%rbx), %r12
jmp 0x1dd2a
movzwl -0x5(%rbx), %r12d
jmp 0x1dd2a
movl -0x9(%rbx), %r12d
jmp 0x1dd2a
movzbl -0x3(%rbx), %r12d
jmp 0x1dd2a
xorl %r12d, %r12d
cmpb $0x4, %al
ja 0x1dd3b
leaq 0x29423(%rip), %rcx     # 0x47158
movq (%rcx,%rax,8), %r15
jmp 0x1dd3e
xorl %r15d, %r15d
cmpq $0x20, %r12
jae 0x1dd4e
movl $0x1, %r13d
xorl %ebp, %ebp
jmp 0x1dd9a
cmpq $0xff, %r12
jae 0x1dd62
movl $0x3, %r13d
movb $0x1, %bpl
jmp 0x1dd9a
cmpq $0xffff, %r12           # imm = 0xFFFF
jae 0x1dd76
movl $0x5, %r13d
movb $0x2, %bpl
jmp 0x1dd9a
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
xorl %edx, %edx
cmpq %rcx, %r12
seta %dl
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %r12
movb $0x4, %bpl
sbbb $0x0, %bpl
leaq 0x9(,%rdx,8), %r13
addq %rbx, %r15
leaq (%r12,%r13), %rsi
incq %rsi
cmpb %bpl, %al
jne 0x1dde5
movq %r15, %rdi
callq 0x104b0
testq %rax, %rax
je 0x1de3f
movq %rax, %r14
addq %r13, %r14
movb -0x1(%rax,%r13), %al
andb $0x7, %al
movzbl %al, %eax
decl %eax
cmpl $0x3, %eax
ja 0x1de6c
leaq 0x29070(%rip), %rcx     # 0x46e4c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rsi, %rdi
callq 0x10450
testq %rax, %rax
je 0x1de3f
movq %rax, %r14
leaq 0x1(%r12), %rdx
movq %rax, (%rsp)
addq %r13, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10400
movq %r15, %rdi
callq 0x10060
movq (%rsp), %rax
movb %bpl, -0x1(%rax,%r13)
movzbl %bpl, %eax
leaq 0x29010(%rip), %rcx     # 0x46e38
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leal (,%r12,8), %eax
movb %al, -0x1(%r14)
jmp 0x1ddc5
xorl %r14d, %r14d
jmp 0x1de6c
movq %r12, -0x11(%r14)
movq %r12, -0x9(%r14)
jmp 0x1de6c
movw %r12w, -0x5(%r14)
movw %r12w, -0x3(%r14)
jmp 0x1de6c
movl %r12d, -0x9(%r14)
movl %r12d, -0x5(%r14)
jmp 0x1de6c
movb %r12b, -0x3(%r14)
movb %r12b, -0x2(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq