LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/hiredis/./sds.h
// Function: sdsAllocSize
static inline size_t sdsalloc(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)->alloc;
        case SDS_TYPE_16:
            return SDS_HDR(16,s)->alloc;
        case SDS_TYPE_32:
            return SDS_HDR(32,s)->alloc;
        case SDS_TYPE_64:
            return SDS_HDR(64,s)->alloc;
    }
    return 0;
}

// Assembly:
movzbl -0x1(%rdi), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x1deba
leaq 0x28fc9(%rip), %rdx     # 0x46e5c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl %eax, %ecx
shrl $0x3, %ecx
jmp 0x1debc
movq -0x9(%rdi), %rcx
jmp 0x1debc
movzwl -0x3(%rdi), %ecx
jmp 0x1debc
movl -0x5(%rdi), %ecx
jmp 0x1debc
movzbl -0x2(%rdi), %ecx
jmp 0x1debc
xorl %ecx, %ecx
andb $0x7, %al
cmpb $0x4, %al
ja 0x1ded2
movzbl %al, %eax
leaq 0x29264(%rip), %rdx     # 0x47130
movq (%rdx,%rax,8), %rax
jmp 0x1ded4
xorl %eax, %eax
addq %rcx, %rax
incq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/hiredis/sds.c
// Function: sdsgrowzero
sds sdsgrowzero(sds s, size_t len) {
    size_t curlen = sdslen(s);

    if (len <= curlen) return s;
    s = sdsMakeRoomFor(s,len-curlen);
    if (s == NULL) return NULL;

    /* Make sure added region doesn't contain garbage */
    memset(s+curlen,0,(len-curlen+1)); /* also set trailing \0 byte */
    sdssetlen(s, len);
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzbl -0x1(%rdi), %r15d
movl %r15d, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x1e12d
leaq 0x28d80(%rip), %rcx     # 0x46e84
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %r15d
jmp 0x1e130
movq -0x11(%rbx), %r15
jmp 0x1e130
movzwl -0x5(%rbx), %r15d
jmp 0x1e130
movl -0x9(%rbx), %r15d
jmp 0x1e130
movzbl -0x3(%rbx), %r15d
jmp 0x1e130
xorl %r15d, %r15d
movq %r14, %r12
subq %r15, %r12
jbe 0x1e19f
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1dabb
testq %rax, %rax
je 0x1e184
movq %rax, %rbx
addq %rax, %r15
incq %r12
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x10270
movzbl -0x1(%rbx), %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x1e19f
leaq 0x28d27(%rip), %rcx     # 0x46e98
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shlb $0x3, %r14b
movb %r14b, -0x1(%rbx)
jmp 0x1e19f
xorl %ebx, %ebx
jmp 0x1e19f
movq %r14, -0x11(%rbx)
jmp 0x1e19f
movw %r14w, -0x5(%rbx)
jmp 0x1e19f
movl %r14d, -0x9(%rbx)
jmp 0x1e19f
movb %r14b, -0x3(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/hiredis/sds.c
// Function: sdscatlen
sds sdscatlen(sds s, const void *t, size_t len) {
    size_t curlen = sdslen(s);

    s = sdsMakeRoomFor(s,len);
    if (s == NULL) return NULL;
    memcpy(s+curlen, t, len);
    sdssetlen(s, curlen+len);
    s[curlen+len] = '\0';
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movzbl -0x1(%rdi), %r12d
movl %r12d, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x1e1fc
leaq 0x28cd9(%rip), %rcx     # 0x46eac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %r12d
jmp 0x1e1ff
movq -0x11(%rdi), %r12
jmp 0x1e1ff
movzwl -0x5(%rdi), %r12d
jmp 0x1e1ff
movl -0x9(%rdi), %r12d
jmp 0x1e1ff
movzbl -0x3(%rdi), %r12d
jmp 0x1e1ff
xorl %r12d, %r12d
movq %rbx, %rsi
callq 0x1dabb
movq %rax, %r15
testq %rax, %rax
je 0x1e26a
movq %r15, %rdi
addq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10400
addq %rbx, %r12
movzbl -0x1(%r15), %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x1e265
leaq 0x28c89(%rip), %rcx     # 0x46ec0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leal (,%r12,8), %eax
movb %al, -0x1(%r15)
jmp 0x1e265
movq %r12, -0x11(%r15)
jmp 0x1e265
movw %r12w, -0x5(%r15)
jmp 0x1e265
movl %r12d, -0x9(%r15)
jmp 0x1e265
movb %r12b, -0x3(%r15)
movb $0x0, (%r15,%r12)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/hiredis/sds.c
// Function: sdscpylen
sds sdscpylen(sds s, const char *t, size_t len) {
    if (sdsalloc(s) < len) {
        s = sdsMakeRoomFor(s,len-sdslen(s));
        if (s == NULL) return NULL;
    }
    memcpy(s, t, len);
    s[len] = '\0';
    sdssetlen(s, len);
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movzbl -0x1(%rdi), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x1e33a
leaq 0x28bd5(%rip), %rdx     # 0x46ee8
movslq (%rdx,%rcx,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
movl %eax, %edx
shrl $0x3, %edx
jmp 0x1e33c
movq -0x9(%rbx), %rdx
jmp 0x1e33c
movzwl -0x3(%rbx), %edx
jmp 0x1e33c
movl -0x5(%rbx), %edx
jmp 0x1e33c
movzbl -0x2(%rbx), %edx
jmp 0x1e33c
xorl %edx, %edx
cmpq %r14, %rdx
jae 0x1e38c
cmpl $0x4, %ecx
ja 0x1e374
movl %ecx, %ecx
leaq 0x28bad(%rip), %rdx     # 0x46efc
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
shrl $0x3, %eax
jmp 0x1e376
movq -0x11(%rbx), %rax
jmp 0x1e376
movzwl -0x5(%rbx), %eax
jmp 0x1e376
movl -0x9(%rbx), %eax
jmp 0x1e376
movzbl -0x3(%rbx), %eax
jmp 0x1e376
xorl %eax, %eax
movq %r14, %rsi
subq %rax, %rsi
movq %rbx, %rdi
callq 0x1dabb
movq %rax, %rbx
testq %rax, %rax
je 0x1e3c5
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x10400
movb $0x0, (%rbx,%r14)
movzbl -0x1(%rbx), %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x1e3e0
leaq 0x28b5e(%rip), %rcx     # 0x46f10
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shlb $0x3, %r14b
movb %r14b, -0x1(%rbx)
jmp 0x1e3e0
xorl %ebx, %ebx
jmp 0x1e3e0
movq %r14, -0x11(%rbx)
jmp 0x1e3e0
movw %r14w, -0x5(%rbx)
jmp 0x1e3e0
movl %r14d, -0x9(%rbx)
jmp 0x1e3e0
movb %r14b, -0x3(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/hiredis/sds.c
// Function: sdscatvprintf
sds sdscatvprintf(sds s, const char *fmt, va_list ap) {
    va_list cpy;
    char staticbuf[1024], *buf = staticbuf, *t;
    size_t buflen = strlen(fmt)*2;

    /* We try to start using a static buffer for speed.
     * If not possible we revert to heap allocation. */
    if (buflen > sizeof(staticbuf)) {
        buf = s_malloc(buflen);
        if (buf == NULL) return NULL;
    } else {
        buflen = sizeof(staticbuf);
    }

    /* Try with buffers two times bigger every time we fail to
     * fit the string in the current buffer size. */
    while(1) {
        buf[buflen-2] = '\0';
        va_copy(cpy,ap);
        vsnprintf(buf, buflen, fmt, cpy);
        va_end(cpy);
        if (buf[buflen-2] != '\0') {
            if (buf != staticbuf) s_free(buf);
            buflen *= 2;
            buf = s_malloc(buflen);
            if (buf == NULL) return NULL;
            continue;
        }
        break;
    }

    /* Finally concat the obtained string to the SDS string and return it. */
    t = sdscat(s, buf);
    if (buf != staticbuf) s_free(buf);
    return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x438, %rsp            # imm = 0x438
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
movq %rsi, %rdi
callq 0x101c0
movq %rax, %rbx
addq %rax, %rbx
movl $0x400, %ebp            # imm = 0x400
leaq 0x30(%rsp), %r13
movq %r13, %r12
cmpq $0x401, %rbx            # imm = 0x401
jb 0x1e56e
movq %rbx, %rdi
callq 0x10450
movq %rax, %r12
movq %rbx, %rbp
testq %rax, %rax
je 0x1e5c4
leaq 0x10(%rsp), %rbx
movb $0x0, -0x2(%rbp,%r12)
movq 0x10(%r14), %rax
movq %rax, 0x20(%rsp)
movups (%r14), %xmm0
movaps %xmm0, 0x10(%rsp)
movq %r12, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x10110
cmpb $0x0, -0x2(%rbp,%r12)
je 0x1e5c8
cmpq %r13, %r12
je 0x1e5b1
movq %r12, %rdi
callq 0x10060
addq %rbp, %rbp
movq %rbp, %rdi
callq 0x10450
movq %rax, %r12
testq %rax, %rax
jne 0x1e573
xorl %ebx, %ebx
jmp 0x1e5f5
movq %r12, %rdi
callq 0x101c0
movq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1e1ae
movq %rax, %rbx
leaq 0x30(%rsp), %rax
cmpq %rax, %r12
je 0x1e5f5
movq %r12, %rdi
callq 0x10060
movq %rbx, %rax
addq $0x438, %rsp            # imm = 0x438
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.c
// Function: sdstrim
sds sdstrim(sds s, const char *cset) {
    char *start, *end, *sp, *ep;
    size_t len;

    sp = start = s;
    ep = end = s+sdslen(s)-1;
    while(sp <= end && strchr(cset, *sp)) sp++;
    while(ep > sp && strchr(cset, *ep)) ep--;
    len = (sp > ep) ? 0 : ((ep-sp)+1);
    if (s != sp) memmove(s, sp, len);
    s[len] = '\0';
    sdssetlen(s,len);
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzbl -0x1(%rdi), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x1edc9
leaq 0x2824c(%rip), %rdx     # 0x46ff0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
shrl $0x3, %eax
jmp 0x1edcb
movq -0x11(%rbx), %rax
jmp 0x1edcb
movzwl -0x5(%rbx), %eax
jmp 0x1edcb
movl -0x9(%rbx), %eax
jmp 0x1edcb
movzbl -0x3(%rbx), %eax
jmp 0x1edcb
xorl %eax, %eax
leaq (%rbx,%rax), %r12
decq %r12
movq %rbx, %r15
cmpq %rbx, %r12
jb 0x1edf6
movq %rbx, %r15
movsbl (%r15), %esi
movq %r14, %rdi
callq 0x101e0
testq %rax, %rax
je 0x1edf6
incq %r15
cmpq %r12, %r15
jbe 0x1eddd
cmpq %r15, %r12
jbe 0x1ee18
movsbl (%r12), %esi
movq %r14, %rdi
callq 0x101e0
testq %rax, %rax
je 0x1ee18
decq %r12
cmpq %r15, %r12
ja 0x1edfb
movq %r15, %r12
movq %r12, %rax
subq %r15, %rax
incq %rax
xorl %r14d, %r14d
cmpq %r12, %r15
cmovbeq %rax, %r14
cmpq %rbx, %r15
je 0x1ee3e
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x10540
movb $0x0, (%rbx,%r14)
movzbl -0x1(%rbx), %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x1ee80
leaq 0x281ae(%rip), %rcx     # 0x47004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shlb $0x3, %r14b
movb %r14b, -0x1(%rbx)
jmp 0x1ee80
movq %r14, -0x11(%rbx)
jmp 0x1ee80
movw %r14w, -0x5(%rbx)
jmp 0x1ee80
movl %r14d, -0x9(%rbx)
jmp 0x1ee80
movb %r14b, -0x3(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/hiredis/sds.c
// Function: sdsfreesplitres
void sdsfreesplitres(sds *tokens, int count) {
    if (!tokens) return;
    while(count--)
        sdsfree(tokens[count]);
    s_free(tokens);
}

// Assembly:
testq %rdi, %rdi
je 0x1f312
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x1f303
movslq %esi, %r14
movq -0x8(%rbx,%r14,8), %rdi
callq 0x1da09
decq %r14
jne 0x1f2f4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10060
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/hiredis/sds.c
// Function: sdsjoin
sds sdsjoin(char **argv, int argc, char *sep) {
    sds join = sdsempty();
    int j;

    for (j = 0; j < argc; j++) {
        join = sdscat(join, argv[j]);
        if (j != argc-1) join = sdscat(join,sep);
    }
    return join;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movl %esi, %r12d
movq %rdi, %r14
movl $0x4, %edi
callq 0x10450
testq %rax, %rax
je 0x1f8ae
movq %rax, %r15
addq $0x3, %r15
movl $0x10000, (%rax)        # imm = 0x10000
jmp 0x1f8b1
xorl %r15d, %r15d
testl %r12d, %r12d
jle 0x1f907
leal -0x1(%r12), %r13d
movl %r12d, %ebp
xorl %ebx, %ebx
movq (%r14,%rbx,8), %r12
movq %r12, %rdi
callq 0x101c0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1e1ae
movq %rax, %r15
cmpq %rbx, %r13
je 0x1f8ff
movq (%rsp), %r12
movq %r12, %rdi
callq 0x101c0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1e1ae
movq %rax, %r15
incq %rbx
cmpq %rbx, %rbp
jne 0x1f8c0
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/net.c
// Function: redisKeepAlive
int redisKeepAlive(redisContext *c, int interval) {
    int val = 1;
    int fd = c->fd;

    if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &val, sizeof(val)) == -1){
        __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));
        return REDIS_ERR;
    }

    val = interval;

#ifdef _OSX
    if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPALIVE, &val, sizeof(val)) < 0) {
        __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));
        return REDIS_ERR;
    }
#else
#ifndef __sun
    val = interval;
    if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &val, sizeof(val)) < 0) {
        __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));
        return REDIS_ERR;
    }

    val = interval/3;
    if (val == 0) val = 1;
    if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, &val, sizeof(val)) < 0) {
        __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));
        return REDIS_ERR;
    }

    val = 3;
    if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, &val, sizeof(val)) < 0) {
        __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));
        return REDIS_ERR;
    }
#endif
#endif

    return REDIS_OK;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0xc(%rsp), %rcx
movl $0x1, (%rcx)
movl 0x84(%rdi), %ebp
movl %ebp, %edi
movl $0x1, %esi
movl $0x9, %edx
movl $0x4, %r8d
callq 0x10120
cmpl $-0x1, %eax
je 0x1fa79
leaq 0xc(%rsp), %rcx
movl %r14d, (%rcx)
movl %ebp, %edi
movl $0x6, %esi
movl $0x4, %edx
movl $0x4, %r8d
callq 0x10120
testl %eax, %eax
js 0x1fa79
movslq %r14d, %rax
imulq $0x55555556, %rax, %rax # imm = 0x55555556
movq %rax, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rax
addl %ecx, %eax
addl $0x2, %r14d
cmpl $0x5, %r14d
movl $0x1, %edx
cmovael %eax, %edx
leaq 0xc(%rsp), %rcx
movl %edx, (%rcx)
movl %ebp, %edi
movl $0x6, %esi
movl $0x5, %edx
movl $0x4, %r8d
callq 0x10120
testl %eax, %eax
js 0x1fa79
leaq 0xc(%rsp), %rcx
movl $0x3, (%rcx)
movl %ebp, %edi
movl $0x6, %esi
movl $0x6, %edx
movl $0x4, %r8d
callq 0x10120
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jns 0x1fa9a
callq 0x100a0
movl (%rax), %edi
callq 0x10690
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x1c97a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/hiredis/net.c
// Function: _redisSetErrorFromErrno
static void __redisSetErrorFromErrno(redisContext *c, int type, const char *prefix) {
    char buf[128] = { 0 };
    size_t len = 0;

    if (prefix != NULL)
        len = snprintf(buf,sizeof(buf),"%s: ",prefix);
    strerror_r(errno,buf+len,sizeof(buf)-len);
    __redisSetError(c,type,buf);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
testq %rsi, %rsi
je 0x1fb66
movq %rsi, %rcx
leaq 0x2784b(%rip), %rdx     # 0x4739d
movq %rsp, %rdi
movl $0x80, %esi
xorl %eax, %eax
callq 0x10200
movslq %eax, %r14
jmp 0x1fb69
xorl %r14d, %r14d
callq 0x100a0
movl (%rax), %edi
leaq (%rsp,%r14), %rsi
movl $0x80, %edx
subq %r14, %rdx
callq 0x10140
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1c97a
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/hiredis/net.c
// Function: redisContextConnectUnix
int redisContextConnectUnix(redisContext *c, const char *path, const struct timeval *timeout) {
    int blocking = (c->flags & REDIS_BLOCK);
    struct sockaddr_un sa;

    if (redisCreateSocket(c,AF_LOCAL) < 0)
        return REDIS_ERR;
    if (redisSetBlocking(c,0) != REDIS_OK)
        return REDIS_ERR;

    sa.sun_family = AF_LOCAL;
    strncpy(sa.sun_path,path,sizeof(sa.sun_path)-1);
    if (connect(c->fd, (struct sockaddr*)&sa, sizeof(sa)) == -1) {
        if (errno == EINPROGRESS && !blocking) {
            /* This is ok. */
        } else {
            if (redisContextWaitReady(c,timeout) != REDIS_OK)
                return REDIS_ERR;
        }
    }

    /* Reset socket to be blocking after connect(2). */
    if (blocking && redisSetBlocking(c,1) != REDIS_OK)
        return REDIS_ERR;

    c->flags |= REDIS_CONNECTED;
    return REDIS_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x88(%rdi), %r12d
movl $0x1, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x10740
cmpl $-0x1, %eax
je 0x20005
movl %eax, 0x84(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x20053
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x20044
leaq 0x4(%rsp), %rdi
movw $0x1, -0x2(%rdi)
movl $0x6b, %edx
movq %r15, %rsi
callq 0x100b0
movl 0x84(%rbx), %edi
leaq 0x2(%rsp), %rsi
movl $0x6e, %edx
callq 0x10640
cmpl $-0x1, %eax
je 0x20016
testb $0x1, %r12b
je 0x2003b
movq %rbx, %rdi
movl $0x1, %esi
callq 0x20053
testl %eax, %eax
jne 0x20044
jmp 0x2003b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1fb0c
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x20044
callq 0x100a0
movl (%rax), %eax
xorl $0x73, %eax
movl %r12d, %ecx
andl $0x1, %ecx
orl %eax, %ecx
je 0x2003b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x200dc
testl %eax, %eax
jne 0x20044
jmp 0x1ffec
orb $0x2, 0x88(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: linenoiseAddCompletion
void linenoiseAddCompletion(linenoiseCompletions *lc, const char *str) {
    size_t len = strlen(str);
    char *copy, **cvec;

    copy = malloc(len+1);
    if (copy == NULL) return;
    memcpy(copy,str,len+1);
    cvec = realloc(lc->cvec,sizeof(char*)*(lc->len+1));
    if (cvec == NULL) {
        free(copy);
        return;
    }
    lc->cvec = cvec;
    lc->cvec[lc->len++] = copy;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x101c0
movq %rax, %r12
incq %r12
movq %r12, %rdi
callq 0x10450
testq %rax, %rax
je 0x2027a
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x10400
movq (%rbx), %rax
movq 0x8(%rbx), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x104b0
testq %rax, %rax
je 0x20286
movq %rax, 0x8(%rbx)
movq (%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
movq %r14, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10060
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: refreshShowHints
void refreshShowHints(struct abuf *ab, struct linenoiseState *l, int plen) {
    char seq[64];
    if (hintsCallback && plen+l->len < l->cols) {
        int color = -1, bold = 0;
        char *hint = hintsCallback(l->buf,&color,&bold);
        if (hint) {
            int hintlen = strlen(hint);
            int hintmaxlen = l->cols-(plen+l->len);
            if (hintlen > hintmaxlen) hintlen = hintmaxlen;
            if (bold == 1 && color == -1) color = 37;
            if (color != -1 || bold != 0)
                snprintf(seq,64,"\033[%d;%d;49m",bold,color);
            abAppend(ab,seq,strlen(seq));
            abAppend(ab,hint,hintlen);
            if (color != -1 || bold != 0)
                abAppend(ab,"\033[0m",4);
            /* Call the function to free the hint returned. */
            if (freeHintsCallback) freeHintsCallback(hint);
        }
    }
}

// Assembly:
movq 0x3a318(%rip), %rax     # 0x5a5b8
testq %rax, %rax
je 0x203bb
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %edx, %r15d
movq %rsi, %r12
movslq %edx, %rcx
addq 0x38(%rsi), %rcx
cmpq 0x40(%rsi), %rcx
jae 0x203af
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movl $0xffffffff, (%rsi)     # imm = 0xFFFFFFFF
leaq 0xc(%rsp), %rdx
movl $0x0, (%rdx)
movq 0x8(%r12), %rdi
callq *%rax
testq %rax, %rax
je 0x203af
movq %rax, %r14
movq %rax, %rdi
callq 0x101c0
movl 0x40(%r12), %ebp
addl 0x38(%r12), %r15d
subl %r15d, %ebp
cmpl %ebp, %eax
cmovll %eax, %ebp
movl 0xc(%rsp), %ecx
movl %ecx, %edx
xorl $0x1, %edx
movl 0x8(%rsp), %r8d
movl %r8d, %eax
notl %eax
orl %eax, %edx
jne 0x20339
movl $0x25, 0x8(%rsp)
movl $0x25, %r8d
jmp 0x2033d
orl %ecx, %eax
je 0x20355
leaq 0x271b0(%rip), %rdx     # 0x474f4
leaq 0x10(%rsp), %rdi
movl $0x40, %esi
xorl %eax, %eax
callq 0x10200
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x101c0
movq %rbx, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x203bc
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x203bc
cmpl $-0x1, 0x8(%rsp)
jne 0x2038a
cmpl $0x0, 0xc(%rsp)
je 0x2039e
leaq 0x25866(%rip), %rsi     # 0x45bf7
movq %rbx, %rdi
movl $0x4, %edx
callq 0x203bc
movq 0x3a21b(%rip), %rax     # 0x5a5c0
testq %rax, %rax
je 0x203af
movq %r14, %rdi
callq *%rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: linenoiseEditInsert
int linenoiseEditInsert(struct linenoiseState *l, char c) {
    if (l->len < l->buflen) {
        if (l->len == l->pos) {
            l->buf[l->pos] = c;
            l->pos++;
            l->len++;
            l->buf[l->len] = '\0';
            if ((!mlmode && l->plen+l->len < l->cols && !hintsCallback)) {
                /* Avoid a full update of the line in the
                 * trivial case. */
                if (write(l->ofd,&c,1) == -1) return -1;
            } else {
                refreshLine(l);
            }
        } else {
            memmove(l->buf+l->pos+1,l->buf+l->pos,l->len-l->pos);
            l->buf[l->pos] = c;
            l->len++;
            l->pos++;
            l->buf[l->len] = '\0';
            refreshLine(l);
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movb %bpl, 0x7(%rsp)
movq 0x38(%rdi), %rax
cmpq 0x10(%rdi), %rax
jae 0x204d2
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movq 0x28(%rdi), %rdi
movq %rax, %rdx
subq %rdi, %rdx
jne 0x20496
movb %bpl, (%rcx,%rax)
incq 0x28(%rbx)
movq 0x8(%rbx), %rax
movq 0x38(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x38(%rbx)
movb $0x0, 0x1(%rax,%rcx)
cmpl $0x0, 0x3a14b(%rip)     # 0x5a5a8
jne 0x204ca
movq 0x38(%rbx), %rax
addq 0x20(%rbx), %rax
cmpq 0x40(%rbx), %rax
jae 0x204ca
cmpq $0x0, 0x3a143(%rip)     # 0x5a5b8
jne 0x204ca
movl 0x4(%rbx), %edi
leaq 0x7(%rsp), %rsi
movl $0x1, %edx
callq 0x10170
cmpq $-0x1, %rax
jne 0x204d2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x204d4
leaq (%rcx,%rdi), %rsi
addq %rcx, %rdi
incq %rdi
callq 0x10540
movq 0x8(%rbx), %rax
movq 0x28(%rbx), %rcx
movb %bpl, (%rax,%rcx)
movq 0x8(%rbx), %rax
movq 0x38(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x38(%rbx)
incq 0x28(%rbx)
movb $0x0, 0x1(%rax,%rcx)
movq %rbx, %rdi
callq 0x204db
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: linenoiseEditHistoryNext
void linenoiseEditHistoryNext(struct linenoiseState *l, int dir) {
    if (history_len > 1) {
        /* Update the current history entry before to
         * overwrite it with the next one. */
        free(history[history_len - 1 - l->history_index]);
        history[history_len - 1 - l->history_index] = strdup(l->buf);
        /* Show the new entry */
        l->history_index += (dir == LINENOISE_HISTORY_PREV) ? 1 : -1;
        if (l->history_index < 0) {
            l->history_index = 0;
            return;
        } else if (l->history_index >= history_len) {
            l->history_index = history_len-1;
            return;
        }
        strncpy(l->buf,history[history_len - 1 - l->history_index],l->buflen);
        l->buf[l->buflen-1] = '\0';
        l->len = l->pos = strlen(l->buf);
        refreshLine(l);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x39a33(%rip), %r14d    # 0x5a5c8
cmpl $0x2, %r14d
jl 0x20c4c
movl %esi, %ebp
movq %rdi, %rbx
movq 0x39a25(%rip), %r15     # 0x5a5d0
movl 0x50(%rdi), %eax
notl %eax
addl %r14d, %eax
cltq
movq (%r15,%rax,8), %rdi
callq 0x10060
movq 0x8(%rbx), %rdi
callq 0x10680
movl 0x50(%rbx), %ecx
movl %ecx, %edx
notl %edx
addl %r14d, %edx
movslq %edx, %rdx
movq %rax, (%r15,%rdx,8)
xorl %eax, %eax
cmpl $0x1, %ebp
sete %al
leal -0x1(,%rax,2), %eax
addl %ecx, %eax
movl %eax, 0x50(%rbx)
js 0x20c3c
cmpl %r14d, %eax
jae 0x20c45
notl %eax
addl %eax, %r14d
movslq %r14d, %rax
movq (%r15,%rax,8), %rsi
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rdx
callq 0x100b0
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movb $0x0, -0x1(%rax,%rcx)
movq 0x8(%rbx), %rdi
callq 0x101c0
movq %rax, 0x28(%rbx)
movq %rax, 0x38(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x204db
movl $0x0, 0x50(%rbx)
jmp 0x20c4c
decl %r14d
movl %r14d, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: linenoiseEditDelete
void linenoiseEditDelete(struct linenoiseState *l) {
    if (l->len > 0 && l->pos < l->len) {
        memmove(l->buf+l->pos,l->buf+l->pos+1,l->len-l->pos-1);
        l->len--;
        l->buf[l->len] = '\0';
        refreshLine(l);
    }
}

// Assembly:
pushq %rbx
movq 0x38(%rdi), %rdx
testq %rdx, %rdx
je 0x20ca4
movq %rdi, %rbx
movq 0x28(%rdi), %rax
cmpq %rdx, %rax
jae 0x20ca4
movq 0x8(%rbx), %rdi
leaq (%rdi,%rax), %rsi
incq %rsi
addq %rax, %rdi
notq %rax
addq %rax, %rdx
callq 0x10540
movq 0x8(%rbx), %rax
movq 0x38(%rbx), %rcx
leaq -0x1(%rcx), %rdx
movq %rdx, 0x38(%rbx)
movb $0x0, -0x1(%rax,%rcx)
movq %rbx, %rdi
popq %rbx
jmp 0x204db
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: linenoiseEditBackspace
void linenoiseEditBackspace(struct linenoiseState *l) {
    if (l->pos > 0 && l->len > 0) {
        memmove(l->buf+l->pos-1,l->buf+l->pos,l->len-l->pos);
        l->pos--;
        l->len--;
        l->buf[l->len] = '\0';
        refreshLine(l);
    }
}

// Assembly:
pushq %rbx
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x20cf4
movq %rdi, %rbx
movq 0x38(%rdi), %rdx
testq %rdx, %rdx
je 0x20cf4
movq 0x8(%rbx), %rsi
leaq (%rsi,%rax), %rdi
decq %rdi
addq %rax, %rsi
subq %rax, %rdx
callq 0x10540
decq 0x28(%rbx)
movq 0x8(%rbx), %rax
movq 0x38(%rbx), %rcx
leaq -0x1(%rcx), %rdx
movq %rdx, 0x38(%rbx)
movb $0x0, -0x1(%rax,%rcx)
movq %rbx, %rdi
popq %rbx
jmp 0x204db
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: linenoiseEditDeletePrevWord
void linenoiseEditDeletePrevWord(struct linenoiseState *l) {
    size_t old_pos = l->pos;
    size_t diff;

    while (l->pos > 0 && l->buf[l->pos-1] == ' ')
        l->pos--;
    while (l->pos > 0 && l->buf[l->pos-1] != ' ')
        l->pos--;
    diff = old_pos - l->pos;
    memmove(l->buf+l->pos,l->buf+old_pos,l->len-old_pos+1);
    l->len -= diff;
    refreshLine(l);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x20d1e
movq 0x8(%rbx), %rcx
movq %rax, %r14
cmpb $0x20, -0x1(%rcx,%r14)
jne 0x20d51
decq %r14
movq %r14, 0x28(%rbx)
jne 0x20d0d
movq 0x8(%rbx), %rsi
xorl %r14d, %r14d
leaq (%rsi,%r14), %rdi
subq %rax, %r14
addq %rax, %rsi
movq 0x38(%rbx), %rdx
subq %rax, %rdx
incq %rdx
callq 0x10540
addq %r14, 0x38(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x204db
movq 0x8(%rbx), %rsi
cmpb $0x20, -0x1(%rsi,%r14)
je 0x20d25
decq %r14
movq %r14, 0x28(%rbx)
jne 0x20d55
jmp 0x20d22
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: linenoisePrintKeyCodes
void linenoisePrintKeyCodes(void) {
    char quit[4];

    printf("Linenoise key codes debugging mode.\n"
            "Press keys to see scan codes. Type 'quit' at any time to exit.\n");
    if (enableRawMode(STDIN_FILENO) == -1) return;
    memset(quit,' ',4);
    while(1) {
        char c;
        int nread;

        nread = read(STDIN_FILENO,&c,1);
        if (nread <= 0) continue;
        memmove(quit,quit+1,sizeof(quit)-1); /* shift string to left. */
        quit[sizeof(quit)-1] = c; /* Insert current char on the right. */
        if (memcmp(quit,"quit",sizeof(quit)) == 0) break;

        printf("'%c' %02x (%d) (type quit to exit)\n",
            isprint(c) ? c : '?', (int)c, (int)c);
        printf("\r"); /* Go left edge manually, we are in raw mode. */
        fflush(stdout);
    }
    disableRawMode(STDIN_FILENO);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x267f0(%rip), %rdi     # 0x4756b
callq 0x100e0
callq 0x20e5a
cmpl $-0x1, %eax
je 0x20e4d
leaq 0xd(%rsp), %r15
movl $0x20202020, -0x1(%r15) # imm = 0x20202020
leaq 0xb(%rsp), %rbx
leaq 0x26759(%rip), %r14     # 0x47500
movq 0x37212(%rip), %r12     # 0x57fc0
movl $0x1, %edx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x102f0
testl %eax, %eax
jle 0x20dae
movzwl (%r15), %eax
movb 0x2(%r15), %cl
movb %cl, 0xe(%rsp)
movw %ax, 0xc(%rsp)
movsbl 0xb(%rsp), %ebp
movb %bpl, 0xf(%rsp)
cmpl $0x74697571, 0xc(%rsp)  # imm = 0x74697571
je 0x20e25
callq 0x10710
movq (%rax), %rax
movslq %ebp, %rcx
movzwl (%rax,%rcx,2), %eax
btl $0xe, %eax
movl $0x3f, %esi
jae 0x20e02
movl %ebp, %esi
movq %r14, %rdi
movl %ebp, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x101f0
movl $0xd, %edi
callq 0x10070
movq (%r12), %rdi
callq 0x10470
jmp 0x20dae
cmpb $0x1, 0x397ec(%rip)     # 0x5a618
jne 0x20e4d
leaq 0x397a7(%rip), %rdx     # 0x5a5dc
xorl %edi, %edi
movl $0x2, %esi
callq 0x10580
cmpl $-0x1, %eax
je 0x20e4d
movb $0x0, 0x397cb(%rip)     # 0x5a618
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: enableRawMode
static int enableRawMode(int fd) {
    struct termios raw;

    if (!isatty(STDIN_FILENO)) goto fatal;
    if (!atexit_registered) {
        atexit(linenoiseAtExit);
        atexit_registered = 1;
    }
    if (tcgetattr(fd,&orig_termios) == -1) goto fatal;

    raw = orig_termios;  /* modify the original mode */
    /* input modes: no break, no CR to NL, no parity check, no strip char,
     * no start/stop output control. */
    raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
    /* output modes - disable post processing */
    raw.c_oflag &= ~(OPOST);
    /* control modes - set 8 bit chars */
    raw.c_cflag |= (CS8);
    /* local modes - choing off, canonical off, no extended functions,
     * no signal chars (^Z,^C) */
    raw.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
    /* control chars - set return condition: min number of bytes and timer.
     * We want read to return every single byte, without timeout. */
    raw.c_cc[VMIN] = 1; raw.c_cc[VTIME] = 0; /* 1 byte, no timer */

    /* put terminal in raw mode after flushing */
    if (tcsetattr(fd,TCSAFLUSH,&raw) < 0) goto fatal;
    rawmode = 1;
    return 0;

fatal:
    errno = ENOTTY;
    return -1;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
xorl %edi, %edi
callq 0x100f0
testl %eax, %eax
je 0x20f0b
cmpb $0x0, 0x39763(%rip)     # 0x5a5d8
jne 0x20e8a
leaq 0xbb5(%rip), %rdi       # 0x21a33
callq 0x3f4d0
movb $0x1, 0x3974e(%rip)     # 0x5a5d8
leaq 0x3974b(%rip), %rsi     # 0x5a5dc
xorl %edi, %edi
callq 0x10570
cmpl $-0x1, %eax
je 0x20f0b
movups 0x39738(%rip), %xmm0    # 0x5a5dc
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movups 0x3973b(%rip), %xmm0    # 0x5a5ec
movaps %xmm0, 0x10(%rdx)
movups 0x3974c(%rip), %xmm0    # 0x5a608
movups %xmm0, 0x2c(%rdx)
movups 0x39735(%rip), %xmm0    # 0x5a5fc
movaps %xmm0, 0x20(%rdx)
movaps (%rdx), %xmm0
movaps 0x2655b(%rip), %xmm1    # 0x47430
andps %xmm0, %xmm1
orps 0x26561(%rip), %xmm0    # 0x47440
shufps $0x32, %xmm1, %xmm0     # xmm0 = xmm0[2,0],xmm1[3,0]
shufps $0x84, %xmm0, %xmm1     # xmm1 = xmm1[0,1],xmm0[0,2]
movaps %xmm1, (%rdx)
movw $0x100, 0x16(%rdx)      # imm = 0x100
xorl %ebx, %ebx
xorl %edi, %edi
movl $0x2, %esi
callq 0x10580
testl %eax, %eax
js 0x20f0b
movb $0x1, 0x3970f(%rip)     # 0x5a618
jmp 0x20f1b
callq 0x100a0
movl $0x19, (%rax)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: linenoiseHistoryAdd
int linenoiseHistoryAdd(const char *line) {
    char *linecopy;

    if (history_max_len == 0) return 0;

    /* Initialization on first call. */
    if (history == NULL) {
        history = malloc(sizeof(char*)*history_max_len);
        if (history == NULL) return 0;
        memset(history,0,(sizeof(char*)*history_max_len));
    }

    /* Don't add duplicated lines. */
    if (history_len && !strcmp(history[history_len-1], line)) return 0;

    /* Add an heap allocated copy of the line in the history.
     * If we reached the max length, remove the older line. */
    linecopy = strdup(line);
    if (!linecopy) return 0;
    if (history_len == history_max_len) {
        free(history[0]);
        memmove(history,history+1,sizeof(char*)*(history_max_len-1));
        history_len--;
    }
    history[history_len] = linecopy;
    history_len++;
    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x38bd4(%rip), %r15d    # 0x5a348
movq 0x38e55(%rip), %rbx     # 0x5a5d0
testq %rbx, %rbx
jne 0x217a1
leaq (,%r15,8), %rsi
movl $0x1, %edi
callq 0x10370
movq %rax, %rbx
movq %rax, 0x38e34(%rip)     # 0x5a5d0
testq %rax, %rax
je 0x2180b
movslq 0x38e20(%rip), %r12     # 0x5a5c8
testq %r12, %r12
je 0x217be
movq -0x8(%rbx,%r12,8), %rdi
movq %r14, %rsi
callq 0x10380
testl %eax, %eax
je 0x2180b
movq %r14, %rdi
callq 0x10680
testq %rax, %rax
je 0x2180b
movq %rax, %r14
cmpl %r15d, %r12d
jne 0x217f5
movq (%rbx), %rdi
callq 0x10060
leaq 0x8(%rbx), %rsi
decl %r15d
leaq (,%r15,8), %rdx
movq %rbx, %rdi
callq 0x10540
movl %r15d, %r12d
movslq %r12d, %rax
movq %r14, (%rbx,%rax,8)
incl %eax
movl %eax, 0x38dc4(%rip)     # 0x5a5c8
movl $0x1, %eax
jmp 0x2180d
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/deps/linenoise/linenoise.c
// Function: linenoiseHistorySetMaxLen
int linenoiseHistorySetMaxLen(int len) {
    char **new;

    if (len < 1) return 0;
    if (history) {
        int tocopy = history_len;

        new = malloc(sizeof(char*)*len);
        if (new == NULL) return 0;

        /* If we can't copy everything, free the elements we'll not use. */
        if (len < tocopy) {
            int j;

            for (j = 0; j < tocopy-len; j++) free(history[j]);
            tocopy = len;
        }
        memset(new,0,sizeof(char*)*len);
        memcpy(new,history+(history_len-tocopy), sizeof(char*)*tocopy);
        free(history);
        history = new;
    }
    history_max_len = len;
    if (history_len > history_max_len)
        history_len = history_max_len;
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %ebp, %ebp
testl %edi, %edi
jle 0x218f5
movl %edi, %ebx
movq 0x38d96(%rip), %r14     # 0x5a5d0
movl 0x38d87(%rip), %r15d    # 0x5a5c8
testq %r14, %r14
je 0x218df
movl %ebx, %r12d
shlq $0x3, %r12
movq %r12, %rdi
callq 0x10450
testq %rax, %rax
je 0x218f5
movq %rax, %r13
xorl %eax, %eax
movl %r15d, %ebp
movl %r15d, %ecx
subl %ebx, %ebp
jle 0x218a8
jle 0x218a4
movq %r13, 0x10(%rsp)
movl %r15d, 0xc(%rsp)
movl %ebp, %r13d
xorl %r15d, %r15d
movq (%r14,%r15,8), %rdi
callq 0x10060
incq %r15
cmpq %r15, %r13
jne 0x21883
movl %ebp, %eax
movl %ebx, %ecx
movl 0xc(%rsp), %r15d
movq 0x10(%rsp), %r13
jmp 0x218a8
movl %ebp, %eax
movl %ebx, %ecx
movq %r13, %rdi
xorl %esi, %esi
movq %r12, %rdx
movl %eax, %ebp
movl %ecx, %r12d
callq 0x10270
movslq %ebp, %rax
leaq (%r14,%rax,8), %rsi
movslq %r12d, %rdx
shlq $0x3, %rdx
movq %r13, %rdi
callq 0x10400
movq %r14, %rdi
callq 0x10060
movq %r13, 0x38cf1(%rip)     # 0x5a5d0
movl %ebx, 0x38a63(%rip)     # 0x5a348
movl $0x1, %ebp
cmpl %ebx, %r15d
jle 0x218f5
movl %ebx, 0x38cd3(%rip)     # 0x5a5c8
movl %ebp, %eax
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/deps/linenoise/linenoise.c
// Function: linenoiseHistorySave
int linenoiseHistorySave(const char *filename) {
    mode_t old_umask = umask(S_IXUSR|S_IRWXG|S_IRWXO);
    FILE *fp;
    int j;

    fp = fopen(filename,"w");
    umask(old_umask);
    if (fp == NULL) return -1;
    chmod(filename,S_IRUSR|S_IWUSR);
    for (j = 0; j < history_len; j++)
        fprintf(fp,"%s\n",history[j]);
    fclose(fp);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x7f, %edi
callq 0x103d0
movl %eax, %ebp
leaq 0x225ea(%rip), %rsi     # 0x43f0d
movq %r14, %rdi
callq 0x105a0
movq %rax, %rbx
movl %ebp, %edi
callq 0x103d0
testq %rbx, %rbx
je 0x2198d
movq %r14, %rdi
movl $0x180, %esi            # imm = 0x180
callq 0x104f0
cmpl $0x0, 0x38c7a(%rip)     # 0x5a5c8
jle 0x21981
leaq 0x23600(%rip), %r14     # 0x44f57
xorl %r15d, %r15d
movq 0x38c6f(%rip), %rax     # 0x5a5d0
movq (%rax,%r15,8), %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x103b0
incq %r15
movslq 0x38c4c(%rip), %rax     # 0x5a5c8
cmpq %rax, %r15
jl 0x2195a
movq %rbx, %rdi
callq 0x101b0
xorl %eax, %eax
jmp 0x21992
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: linenoiseHistoryLoad
int linenoiseHistoryLoad(const char *filename) {
    FILE *fp = fopen(filename,"r");
    char buf[LINENOISE_MAX_LINE];

    if (fp == NULL) return -1;

    while (fgets(buf,LINENOISE_MAX_LINE,fp) != NULL) {
        char *p;

        p = strchr(buf,'\r');
        if (!p) p = strchr(buf,'\n');
        if (p) *p = '\0';
        linenoiseHistoryAdd(buf);
    }
    fclose(fp);
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
leaq 0x2596f(%rip), %rsi     # 0x4731d
callq 0x105a0
testq %rax, %rax
je 0x21a23
movq %rax, %rbx
movq %rsp, %rdi
movl $0x1000, %esi           # imm = 0x1000
movq %rax, %rdx
callq 0x10330
testq %rax, %rax
je 0x21a17
movq %rsp, %r14
movq %r14, %rdi
movl $0xd, %esi
callq 0x101e0
testq %rax, %rax
jne 0x219f7
movq %r14, %rdi
movl $0xa, %esi
callq 0x101e0
testq %rax, %rax
je 0x219fa
movb $0x0, (%rax)
movq %r14, %rdi
callq 0x21762
movq %r14, %rdi
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdx
callq 0x10330
testq %rax, %rax
jne 0x219d3
movq %rbx, %rdi
callq 0x101b0
xorl %eax, %eax
jmp 0x21a28
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: getCursorPosition
static int getCursorPosition(int ifd, int ofd) {
    char buf[32];
    int cols, rows;
    unsigned int i = 0;

    /* Report cursor location */
    if (write(ofd, "\x1b[6n", 4) != 4) return -1;

    /* Read the response: ESC [ rows ; cols R */
    while (i < sizeof(buf)-1) {
        if (read(ifd,buf+i,1) != 1) break;
        if (buf[i] == 'R') break;
        i++;
    }
    buf[i] = '\0';

    /* Parse it. */
    if (buf[0] != ESC || buf[1] != '[') return -1;
    if (sscanf(buf+2,"%d;%d",&rows,&cols) != 2) return -1;
    return cols;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x25ab1(%rip), %rsi     # 0x47560
movl $0x4, %edx
movl $0x1, %edi
callq 0x10170
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpq $0x4, %rax
jne 0x21b3d
xorl %r15d, %r15d
leaq (%rsp,%r15), %r14
addq $0x10, %r14
movl $0x1, %edx
xorl %edi, %edi
movq %r14, %rsi
callq 0x102f0
cmpq $0x1, %rax
jne 0x21afe
cmpb $0x52, (%r14)
je 0x21afe
incq %r15
cmpq $0x1f, %r15
jne 0x21acc
movl $0x1f, %r15d
movb $0x0, 0x10(%rsp,%r15)
cmpb $0x1b, 0x10(%rsp)
jne 0x21b3d
cmpb $0x5b, 0x11(%rsp)
jne 0x21b3d
leaq 0x12(%rsp), %rdi
leaq 0x25a47(%rip), %rsi     # 0x47565
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %rcx
xorl %eax, %eax
callq 0x10480
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x2, %eax
jne 0x21b3d
movl 0x8(%rsp), %ebx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: je_arena_init
arena_t *
arena_init(unsigned ind)
{
	arena_t *arena;

	malloc_mutex_lock(&arenas_lock);
	arena = arena_init_locked(ind);
	malloc_mutex_unlock(&arenas_lock);
	return (arena);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x38834(%rip), %r14     # 0x5a648
movq %r14, %rdi
callq 0x106d0
movl %ebx, %edi
callq 0x21e39
movq %rax, %rbx
movq %r14, %rdi
callq 0x10440
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: arena_init_locked
static arena_t *
arena_init_locked(unsigned ind)
{
	arena_t *arena;

	/* Expand arenas if necessary. */
	assert(ind <= narenas_total);
	if (ind > MALLOCX_ARENA_MAX)
		return (NULL);
	if (ind == narenas_total) {
		unsigned narenas_new = narenas_total + 1;
		arena_t **arenas_new =
		    (arena_t **)a0malloc(CACHELINE_CEILING(narenas_new *
		    sizeof(arena_t *)));
		if (arenas_new == NULL)
			return (NULL);
		memcpy(arenas_new, arenas, narenas_total * sizeof(arena_t *));
		arenas_new[ind] = NULL;
		/*
		 * Deallocate only if arenas came from a0malloc() (not
		 * base_alloc()).
		 */
		if (narenas_total != narenas_auto)
			a0dalloc(arenas);
		arenas = arenas_new;
		narenas_total = narenas_new;
	}

	/*
	 * Another thread may have already initialized arenas[ind] if it's an
	 * auto arena.
	 */
	arena = arenas[ind];
	if (arena != NULL) {
		assert(ind < narenas_auto);
		return (arena);
	}

	/* Actually initialize the arena. */
	arena = arenas[ind] = arena_new(ind);
	return (arena);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0xffe, %edi            # imm = 0xFFE
jbe 0x21e54
xorl %r15d, %r15d
jmp 0x21efd
movl %edi, %ebx
cmpl %edi, 0x38814(%rip)     # 0x5a670
jne 0x21ed5
leal 0x47(,%rbx,8), %edi
andl $0x1ffc0, %edi          # imm = 0x1FFC0
xorl %r15d, %r15d
xorl %esi, %esi
movl $0x1, %edx
callq 0x21b5d
testq %rax, %rax
je 0x21efd
movq %rax, %r14
leal 0x1(%rbx), %ebp
movq 0x387ec(%rip), %r15     # 0x5a678
movl 0x387dd(%rip), %r13d    # 0x5a670
movq %r13, %rdx
shlq $0x3, %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x10400
movl %ebx, %r12d
movq $0x0, (%r14,%r12,8)
cmpl 0x387c9(%rip), %r13d    # 0x5a680
je 0x21ec6
movq %r15, %rdi
movl $0x1, %esi
callq 0x21cca
movq %r14, 0x387ab(%rip)     # 0x5a678
movl %ebp, 0x3879d(%rip)     # 0x5a670
jmp 0x21edf
movq 0x3879c(%rip), %r14     # 0x5a678
movl %ebx, %r12d
movq (%r14,%r12,8), %r15
testq %r15, %r15
jne 0x21efd
movl %ebx, %edi
callq 0x2ab4d
movq %rax, %r15
movq 0x3877f(%rip), %rax     # 0x5a678
movq %r15, (%rax,%r12,8)
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/jemalloc/src/jemalloc.c
// Function: je_narenas_total_get
unsigned
narenas_total_get(void)
{
	unsigned narenas;

	malloc_mutex_lock(&arenas_lock);
	narenas = narenas_total;
	malloc_mutex_unlock(&arenas_lock);

	return (narenas);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x3872f(%rip), %rbx     # 0x5a648
movq %rbx, %rdi
callq 0x106d0
movl 0x38749(%rip), %ebp     # 0x5a670
movq %rbx, %rdi
callq 0x10440
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: je_arena_migrate
void
arena_migrate(tsd_t *tsd, unsigned oldind, unsigned newind)
{
	arena_t *oldarena, *newarena;

	malloc_mutex_lock(&arenas_lock);
	oldarena = arenas[oldind];
	newarena = arenas[newind];
	oldarena->nthreads--;
	newarena->nthreads++;
	malloc_mutex_unlock(&arenas_lock);
	tsd_arena_set(tsd, newarena);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x386fb(%rip), %r15     # 0x5a648
movq %r15, %rdi
callq 0x106d0
movq 0x3871c(%rip), %rax     # 0x5a678
movl %ebp, %ecx
movq (%rax,%rcx,8), %rcx
movl %ebx, %edx
movq (%rax,%rdx,8), %rbx
decl 0x4(%rcx)
incl 0x4(%rbx)
movq %r15, %rdi
callq 0x10440
movq %rbx, 0x28(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: je_arena_nbound
unsigned
arena_nbound(unsigned ind)
{
	unsigned nthreads;

	malloc_mutex_lock(&arenas_lock);
	nthreads = arenas[ind]->nthreads;
	malloc_mutex_unlock(&arenas_lock);
	return (nthreads);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x386b6(%rip), %r14     # 0x5a648
movq %r14, %rdi
callq 0x106d0
movq 0x386d7(%rip), %rax     # 0x5a678
movl %ebx, %ecx
movq (%rax,%rcx,8), %rax
movl 0x4(%rax), %ebx
movq %r14, %rdi
callq 0x10440
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: je_arena_choose_hard
arena_t *
arena_choose_hard(tsd_t *tsd)
{
	arena_t *ret;

	if (narenas_auto > 1) {
		unsigned i, choose, first_null;

		choose = 0;
		first_null = narenas_auto;
		malloc_mutex_lock(&arenas_lock);
		assert(a0get() != NULL);
		for (i = 1; i < narenas_auto; i++) {
			if (arenas[i] != NULL) {
				/*
				 * Choose the first arena that has the lowest
				 * number of threads assigned to it.
				 */
				if (arenas[i]->nthreads <
				    arenas[choose]->nthreads)
					choose = i;
			} else if (first_null == narenas_auto) {
				/*
				 * Record the index of the first uninitialized
				 * arena, in case all extant arenas are in use.
				 *
				 * NB: It is possible for there to be
				 * discontinuities in terms of initialized
				 * versus uninitialized arenas, due to the
				 * "thread.arena" mallctl.
				 */
				first_null = i;
			}
		}

		if (arenas[choose]->nthreads == 0
		    || first_null == narenas_auto) {
			/*
			 * Use an unloaded arena, or the least loaded arena if
			 * all arenas are already initialized.
			 */
			ret = arenas[choose];
		} else {
			/* Initialize a new arena. */
			choose = first_null;
			ret = arena_init_locked(choose);
			if (ret == NULL) {
				malloc_mutex_unlock(&arenas_lock);
				return (NULL);
			}
		}
		arena_bind_locked(tsd, choose);
		malloc_mutex_unlock(&arenas_lock);
	} else {
		ret = a0get();
		arena_bind(tsd, 0);
	}

	return (ret);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x3853e(%rip), %ebp     # 0x5a680
cmpl $0x2, %ebp
jb 0x221d9
leaq 0x384f6(%rip), %rdi     # 0x5a648
callq 0x106d0
movl 0x38523(%rip), %eax     # 0x5a680
xorl %edx, %edx
movq 0x38512(%rip), %rcx     # 0x5a678
cmpq $0x2, %rax
jb 0x221a1
movl $0x1, %esi
movq (%rcx,%rsi,8), %rdi
testq %rdi, %rdi
je 0x22192
movl 0x4(%rdi), %r8d
movl %edx, %edi
movq (%rcx,%rdi,8), %r9
movl %esi, %edi
cmpl 0x4(%r9), %r8d
jb 0x2218e
movl %edx, %edi
movl %edi, %edx
jmp 0x22197
cmpl %eax, %ebp
cmovel %esi, %ebp
incq %rsi
cmpq %rsi, %rax
jne 0x22171
movl %edx, %edx
movq (%rcx,%rdx,8), %rcx
movl 0x4(%rcx), %edx
movq %rcx, %r14
testl %edx, %edx
je 0x221d2
cmpl %eax, %ebp
je 0x221d2
movl %ebp, %edi
callq 0x21e39
testq %rax, %rax
je 0x22216
movq %rax, %r14
movq 0x384af(%rip), %rax     # 0x5a678
movl %ebp, %ecx
movq (%rax,%rcx,8), %rcx
movl 0x4(%rcx), %edx
incl %edx
movl %edx, 0x4(%rcx)
jmp 0x221f9
movq 0x38460(%rip), %r14     # 0x5a640
leaq 0x38461(%rip), %rdi     # 0x5a648
callq 0x106d0
movq 0x38485(%rip), %rax     # 0x5a678
movq (%rax), %rcx
incl 0x4(%rcx)
cmpl $0x1, (%rbx)
jne 0x22202
movq %rcx, 0x28(%rbx)
leaq 0x3843f(%rip), %rdi     # 0x5a648
callq 0x10440
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
xorl %r14d, %r14d
jmp 0x22202