LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x20ae8
jmp 0x20b16
jmp 0x20aea
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0x20b0d
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1ee80
jmp 0x20aea
movq -0x8(%rbp), %rdi
callq 0x10050
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x1ed50
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x213ff
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1f930
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x213f2
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1f930
movq %rax, -0x20(%rbp)
jmp 0x213f4
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x213b3
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x84(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
movl $0x1, %esi
movl $0x9, %edx
leaq -0x18(%rbp), %rcx
movl $0x4, %r8d
callq 0x10100
cmpl $-0x1, %eax
jne 0x21585
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x10080
movl (%rax), %edi
callq 0x10660
movq -0x28(%rbp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x1cad0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x216a5
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %edi
movl $0x6, %esi
movl $0x4, %r8d
leaq -0x18(%rbp), %rcx
movl %r8d, %edx
callq 0x10100
cmpl $0x0, %eax
jge 0x215e1
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x10080
movl (%rax), %edi
callq 0x10660
movq -0x30(%rbp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x1cad0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x216a5
movl -0x14(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x215fc
movl $0x1, -0x18(%rbp)
movl -0x1c(%rbp), %edi
movl $0x6, %esi
movl $0x5, %edx
leaq -0x18(%rbp), %rcx
movl $0x4, %r8d
callq 0x10100
cmpl $0x0, %eax
jge 0x2164b
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x10080
movl (%rax), %edi
callq 0x10660
movq -0x38(%rbp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x1cad0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x216a5
movl $0x3, -0x18(%rbp)
movl -0x1c(%rbp), %edi
movl $0x6, %edx
leaq -0x18(%rbp), %rcx
movl $0x4, %r8d
movl %edx, %esi
callq 0x10100
cmpl $0x0, %eax
jge 0x2169e
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x10080
movl (%rax), %edi
callq 0x10660
movq -0x40(%rbp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x1cad0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x216a5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x10250
movq $0x0, -0xa8(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x217b2
leaq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x80, %esi
leaq 0x6c7c0(%rip), %rdx     # 0x8df62
movb $0x0, %al
callq 0x101e0
cltq
movq %rax, -0xa8(%rbp)
callq 0x10080
movl (%rax), %edi
leaq -0xa0(%rbp), %rsi
addq -0xa8(%rbp), %rsi
movl $0x80, %edx
subq -0xa8(%rbp), %rdx
callq 0x10120
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0xa0(%rbp), %rdx
callq 0x1cad0
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x88(%rax), %eax
andl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x21e30
cmpl $0x0, %eax
jge 0x21d56
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x21e21
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x21eb0
cmpl $0x0, %eax
je 0x21d72
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x21e21
movw $0x1, -0x92(%rbp)
leaq -0x92(%rbp), %rdi
addq $0x2, %rdi
movq -0x18(%rbp), %rsi
movl $0x6b, %edx
callq 0x10090
movq -0x10(%rbp), %rax
movl 0x84(%rax), %edi
leaq -0x92(%rbp), %rsi
movl $0x6e, %edx
callq 0x10610
cmpl $-0x1, %eax
jne 0x21de5
callq 0x10080
cmpl $0x73, (%rax)
jne 0x21dc6
cmpl $0x0, -0x24(%rbp)
jne 0x21dc6
jmp 0x21de3
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x21f80
cmpl $0x0, %eax
je 0x21de1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x21e21
jmp 0x21de3
jmp 0x21de5
cmpl $0x0, -0x24(%rbp)
je 0x21e07
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x21eb0
cmpl $0x0, %eax
je 0x21e07
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x21e21
movq -0x10(%rbp), %rax
movl 0x88(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x88(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x101a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x10410
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x22357
jmp 0x223cb
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x1, %rdx
callq 0x103b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
addq $0x1, %rsi
shlq $0x3, %rsi
callq 0x10460
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x2239e
movq -0x20(%rbp), %rdi
callq 0x10050
jmp 0x223cb
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rsi
movq (%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, (%rsi)
movq %rdx, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, 0x7f23a(%rip)     # 0xa1638
je 0x2253f
movslq -0x14(%rbp), %rax
movq -0x10(%rbp), %rcx
addq 0x38(%rcx), %rax
movq -0x10(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x2253f
movl $0xffffffff, -0x64(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x68(%rbp)
movq 0x7f205(%rip), %rax     # 0xa1638
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
leaq -0x64(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq *%rax
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x70(%rbp)
je 0x2253d
movq -0x70(%rbp), %rdi
callq 0x101a0
movl %eax, -0x74(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x14(%rbp), %rcx
movq -0x10(%rbp), %rdx
addq 0x38(%rdx), %rcx
subq %rcx, %rax
movl %eax, -0x78(%rbp)
movl -0x74(%rbp), %eax
cmpl -0x78(%rbp), %eax
jle 0x22488
movl -0x78(%rbp), %eax
movl %eax, -0x74(%rbp)
cmpl $0x1, -0x68(%rbp)
jne 0x2249b
cmpl $-0x1, -0x64(%rbp)
jne 0x2249b
movl $0x25, -0x64(%rbp)
cmpl $-0x1, -0x64(%rbp)
jne 0x224a7
cmpl $0x0, -0x68(%rbp)
je 0x224c5
leaq -0x60(%rbp), %rdi
movl -0x68(%rbp), %ecx
movl -0x64(%rbp), %r8d
movl $0x40, %esi
leaq 0x6bd4e(%rip), %rdx     # 0x8e20c
movb $0x0, %al
callq 0x101e0
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x60(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x101a0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movl %eax, %edx
callq 0x22550
movq -0x8(%rbp), %rdi
movq -0x70(%rbp), %rsi
movl -0x74(%rbp), %edx
callq 0x22550
cmpl $-0x1, -0x64(%rbp)
jne 0x2250f
cmpl $0x0, -0x68(%rbp)
je 0x22524
movq -0x8(%rbp), %rdi
leaq 0x686e3(%rip), %rsi     # 0x8abfd
movl $0x4, %edx
callq 0x22550
cmpq $0x0, 0x7f114(%rip)     # 0xa1640
je 0x2253b
movq 0x7f10b(%rip), %rax     # 0xa1640
movq -0x70(%rbp), %rdi
callq *%rax
jmp 0x2253d
jmp 0x2253f
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: abAppend
static void abAppend(struct abuf *ab, const char *s, int len) {
    char *new = realloc(ab->b,ab->len+len);

    if (new == NULL) return;
    memcpy(new+ab->len,s,len);
    ab->b = new;
    ab->len += len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
addl -0x14(%rbp), %eax
movslq %eax, %rsi
callq 0x10460
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x22589
jmp 0x225bd
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x103b0
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x2274a
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jne 0x226bc
movb -0x11(%rbp), %dl
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
movb $0x0, (%rax,%rcx)
cmpl $0x0, 0x7efc9(%rip)     # 0xa1628
jne 0x226ae
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x38(%rcx), %rax
movq -0x10(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x226ae
cmpq $0x0, 0x7efb5(%rip)     # 0xa1638
jne 0x226ae
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
callq 0x10150
cmpq $-0x1, %rax
jne 0x226ac
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x22751
jmp 0x226b7
movq -0x10(%rbp), %rdi
callq 0x22760
jmp 0x22748
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
addq 0x28(%rax), %rdi
addq $0x1, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
addq 0x28(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdx
movq -0x10(%rbp), %rax
subq 0x28(%rax), %rdx
callq 0x10500
movb -0x11(%rbp), %dl
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
callq 0x22760
jmp 0x2274a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: refreshLine
static void refreshLine(struct linenoiseState *l) {
    if (mlmode)
        refreshMultiLine(l);
    else
        refreshSingleLine(l);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x7eeb5(%rip)     # 0xa1628
je 0x22780
movq -0x8(%rbp), %rdi
callq 0x23640
jmp 0x22789
movq -0x8(%rbp), %rdi
callq 0x23a00
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x1, 0x7eda2(%rip)     # 0xa1648
jle 0x229cb
movq 0x7ed9d(%rip), %rax     # 0xa1650
movl 0x7ed8f(%rip), %ecx     # 0xa1648
subl $0x1, %ecx
movq -0x8(%rbp), %rdx
subl 0x50(%rdx), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10050
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10650
movq %rax, %rdx
movq 0x7ed6a(%rip), %rax     # 0xa1650
movl 0x7ed5c(%rip), %ecx     # 0xa1648
subl $0x1, %ecx
movq -0x8(%rbp), %rsi
subl 0x50(%rsi), %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0x1, %eax
cmpl $0x1, %edx
cmovel %eax, %ecx
movq -0x8(%rbp), %rax
addl 0x50(%rax), %ecx
movl %ecx, 0x50(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x50(%rax)
jge 0x22934
movq -0x8(%rbp), %rax
movl $0x0, 0x50(%rax)
jmp 0x229cb
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
cmpl 0x7ed07(%rip), %eax     # 0xa1648
jl 0x22955
movl 0x7ecff(%rip), %ecx     # 0xa1648
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x50(%rax)
jmp 0x229cb
jmp 0x22957
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x7ecea(%rip), %rax     # 0xa1650
movl 0x7ecdc(%rip), %ecx     # 0xa1648
subl $0x1, %ecx
movq -0x8(%rbp), %rdx
subl 0x50(%rdx), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x10090
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x101a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rdi
callq 0x22760
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jbe 0x22a73
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jae 0x22a73
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
addq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
addq 0x28(%rax), %rsi
addq $0x1, %rsi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdx
movq -0x8(%rbp), %rax
subq 0x28(%rax), %rdx
subq $0x1, %rdx
callq 0x10500
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rdi
callq 0x22760
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jbe 0x22b1c
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jbe 0x22b1c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
addq 0x28(%rax), %rdi
addq $-0x1, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
addq 0x28(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdx
movq -0x8(%rbp), %rax
subq 0x28(%rax), %rdx
callq 0x10500
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rdi
callq 0x22760
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x28(%rcx)
movb %al, -0x19(%rbp)
jbe 0x22b79
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x22b82
jmp 0x22b94
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x28(%rax)
jmp 0x22b48
jmp 0x22b96
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x28(%rcx)
movb %al, -0x1a(%rbp)
jbe 0x22bc7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
setne %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0x22bd0
jmp 0x22be2
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x28(%rax)
jmp 0x22b96
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq 0x28(%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
addq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
addq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdx
subq -0x10(%rbp), %rdx
addq $0x1, %rdx
callq 0x10500
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rdi
callq 0x22760
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x6b5b9(%rip), %rdi     # 0x8e218
movb $0x0, %al
callq 0x101d0
xorl %edi, %edi
callq 0x22d60
cmpl $-0x1, %eax
jne 0x22c77
jmp 0x22d4d
leaq -0x4(%rbp), %rdi
movl $0x20, %esi
movl $0x4, %edx
callq 0x10250
xorl %edi, %edi
leaq -0x5(%rbp), %rsi
movl $0x1, %edx
callq 0x102b0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jg 0x22ca5
jmp 0x22c8a
leaq -0x4(%rbp), %rax
leaq -0x4(%rbp), %rdx
addq $0x1, %rdx
movw (%rdx), %cx
movb 0x2(%rdx), %dl
movb %dl, 0x2(%rax)
movw %cx, (%rax)
movb -0x5(%rbp), %al
movb %al, -0x1(%rbp)
leaq -0x4(%rbp), %rax
movl (%rax), %eax
subl $0x74697571, %eax       # imm = 0x74697571
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x22cdb
jmp 0x22d46
callq 0x106e0
movq (%rax), %rax
movsbl -0x5(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x22d01
movsbl -0x5(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x22d0b
movl $0x3f, %eax
movl %eax, -0x10(%rbp)
jmp 0x22d0b
movl -0x10(%rbp), %esi
movsbl -0x5(%rbp), %edx
movsbl -0x5(%rbp), %ecx
leaq 0x6b55f(%rip), %rdi     # 0x8e27c
movb $0x0, %al
callq 0x101d0
leaq 0x690fc(%rip), %rdi     # 0x8be27
movb $0x0, %al
callq 0x101d0
movq 0x7c287(%rip), %rax     # 0x9efc0
movq (%rax), %rdi
callq 0x10430
jmp 0x22c8a
xorl %edi, %edi
callq 0x22e40
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
xorl %edi, %edi
callq 0x100d0
cmpl $0x0, %eax
jne 0x22d7c
jmp 0x22e21
cmpl $0x0, 0x7e8d5(%rip)     # 0xa1658
jne 0x22d9b
leaq 0xec4(%rip), %rdi       # 0x23c50
callq 0x86750
movl $0x1, 0x7e8bd(%rip)     # 0xa1658
movl -0x8(%rbp), %edi
leaq 0x7e8b7(%rip), %rsi     # 0xa165c
callq 0x10530
cmpl $-0x1, %eax
jne 0x22db1
jmp 0x22e21
leaq -0x44(%rbp), %rdi
leaq 0x7e8a0(%rip), %rsi     # 0xa165c
movl $0x3c, %edx
callq 0x103b0
movl -0x44(%rbp), %eax
andl $0xfffffacd, %eax       # imm = 0xFFFFFACD
movl %eax, -0x44(%rbp)
movl -0x40(%rbp), %eax
andl $-0x2, %eax
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %eax
orl $0x30, %eax
movl %eax, -0x3c(%rbp)
movl -0x38(%rbp), %eax
andl $0xffff7ff4, %eax       # imm = 0xFFFF7FF4
movl %eax, -0x38(%rbp)
movb $0x1, -0x2d(%rbp)
movb $0x0, -0x2e(%rbp)
movl -0x8(%rbp), %edi
movl $0x2, %esi
leaq -0x44(%rbp), %rdx
callq 0x10540
cmpl $0x0, %eax
jge 0x22e0e
jmp 0x22e21
movl $0x1, 0x7e880(%rip)     # 0xa1698
movl $0x0, -0x4(%rbp)
jmp 0x22e33
callq 0x10080
movl $0x19, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: linenoise
char *linenoise(const char *prompt) {
    char buf[LINENOISE_MAX_LINE];
    int count;

    if (!isatty(STDIN_FILENO)) {
        /* Not a tty: read from file / pipe. In this mode we don't want any
         * limit to the line size, so we call a function to handle that. */
        return linenoiseNoTTY();
    } else if (isUnsupportedTerm()) {
        size_t len;

        printf("%s",prompt);
        fflush(stdout);
        if (fgets(buf,LINENOISE_MAX_LINE,stdin) == NULL) return NULL;
        len = strlen(buf);
        while(len && (buf[len-1] == '\n' || buf[len-1] == '\r')) {
            len--;
            buf[len] = '\0';
        }
        return strdup(buf);
    } else {
        count = linenoiseRaw(buf,LINENOISE_MAX_LINE,prompt);
        if (count == -1) return NULL;
        return strdup(buf);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x10(%rbp)
xorl %edi, %edi
callq 0x100d0
cmpl $0x0, %eax
jne 0x22ea9
callq 0x23010
movq %rax, -0x8(%rbp)
jmp 0x22ff8
callq 0x23110
cmpl $0x0, %eax
je 0x22fba
movq -0x10(%rbp), %rsi
leaq 0x64170(%rip), %rdi     # 0x87032
movb $0x0, %al
callq 0x101d0
movq 0x7c0f0(%rip), %rax     # 0x9efc0
movq (%rax), %rdi
callq 0x10430
leaq -0x1010(%rbp), %rdi
movq 0x7c0e2(%rip), %rax     # 0x9efc8
movq (%rax), %rdx
movl $0x1000, %esi           # imm = 0x1000
callq 0x102f0
cmpq $0x0, %rax
jne 0x22f06
movq $0x0, -0x8(%rbp)
jmp 0x22ff8
leaq -0x1010(%rbp), %rdi
callq 0x101a0
movq %rax, -0x1020(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x1020(%rbp)
movb %al, -0x1021(%rbp)
je 0x22f76
movq -0x1020(%rbp), %rax
subq $0x1, %rax
movsbl -0x1010(%rbp,%rax), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x1022(%rbp)
je 0x22f6a
movq -0x1020(%rbp), %rax
subq $0x1, %rax
movsbl -0x1010(%rbp,%rax), %eax
cmpl $0xd, %eax
sete %al
movb %al, -0x1022(%rbp)
movb -0x1022(%rbp), %al
movb %al, -0x1021(%rbp)
movb -0x1021(%rbp), %al
testb $0x1, %al
jne 0x22f82
jmp 0x22fa8
movq -0x1020(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x1020(%rbp)
movq -0x1020(%rbp), %rax
movb $0x0, -0x1010(%rbp,%rax)
jmp 0x22f19
leaq -0x1010(%rbp), %rdi
callq 0x10650
movq %rax, -0x8(%rbp)
jmp 0x22ff8
leaq -0x1010(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x1000, %esi           # imm = 0x1000
callq 0x231a0
movl %eax, -0x1014(%rbp)
cmpl $-0x1, -0x1014(%rbp)
jne 0x22fe8
movq $0x0, -0x8(%rbp)
jmp 0x22ff8
leaq -0x1010(%rbp), %rdi
callq 0x10650
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: linenoiseNoTTY
static char *linenoiseNoTTY(void) {
    char *line = NULL;
    size_t len = 0, maxlen = 0;

    while(1) {
        if (len == maxlen) {
            if (maxlen == 0) maxlen = 16;
            maxlen *= 2;
            char *oldval = line;
            line = realloc(line,maxlen);
            if (line == NULL) {
                if (oldval) free(oldval);
                return NULL;
            }
        }
        int c = fgetc(stdin);
        if (c == EOF || c == '\n') {
            if (c == EOF && len == 0) {
                free(line);
                return NULL;
            } else {
                line[len] = '\0';
                return line;
            }
        } else {
            line[len] = c;
            len++;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x23090
cmpq $0x0, -0x20(%rbp)
jne 0x23049
movq $0x10, -0x20(%rbp)
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x10460
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2308e
cmpq $0x0, -0x28(%rbp)
je 0x23084
movq -0x28(%rbp), %rdi
callq 0x10050
movq $0x0, -0x8(%rbp)
jmp 0x23105
jmp 0x23090
movq 0x7bf31(%rip), %rax     # 0x9efc8
movq (%rax), %rdi
callq 0x10270
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
je 0x230ae
cmpl $0xa, -0x2c(%rbp)
jne 0x230e4
cmpl $-0x1, -0x2c(%rbp)
jne 0x230ce
cmpq $0x0, -0x18(%rbp)
jne 0x230ce
movq -0x10(%rbp), %rdi
callq 0x10050
movq $0x0, -0x8(%rbp)
jmp 0x23105
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x23105
movl -0x2c(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x23030
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: isUnsupportedTerm
static int isUnsupportedTerm(void) {
    char *term = getenv("TERM");
    int j;

    if (term == NULL) return 0;
    for (j = 0; unsupported_term[j]; j++)
        if (!strcasecmp(term,unsupported_term[j])) return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x67a99(%rip), %rdi     # 0x8abb8
callq 0x10040
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x23138
movl $0x0, -0x4(%rbp)
jmp 0x2318b
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x7e266(%rip), %rax     # 0xa13b0
cmpq $0x0, (%rax,%rcx,8)
je 0x23184
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x7e250(%rip), %rax     # 0xa13b0
movq (%rax,%rcx,8), %rsi
callq 0x10060
cmpl $0x0, %eax
jne 0x23177
movl $0x1, -0x4(%rbp)
jmp 0x2318b
jmp 0x23179
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2313f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: linenoiseRaw
static int linenoiseRaw(char *buf, size_t buflen, const char *prompt) {
    int count;

    if (buflen == 0) {
        errno = EINVAL;
        return -1;
    }

    if (enableRawMode(STDIN_FILENO) == -1) return -1;
    count = linenoiseEdit(STDIN_FILENO, STDOUT_FILENO, buf, buflen, prompt);
    disableRawMode(STDIN_FILENO);
    printf("\n");
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x231cf
callq 0x10080
movl $0x16, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2321a
xorl %edi, %edi
callq 0x22d60
cmpl $-0x1, %eax
jne 0x231e4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2321a
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
xorl %edi, %edi
movl $0x1, %esi
callq 0x23cd0
movl %eax, -0x24(%rbp)
xorl %edi, %edi
callq 0x22e40
leaq 0x6918e(%rip), %rdi     # 0x8c39b
movb $0x0, %al
callq 0x101d0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpl $0x0, 0x7e13d(%rip)     # 0xa13a0
jne 0x23271
movl $0x0, -0x4(%rbp)
jmp 0x23397
cmpq $0x0, 0x7e3d7(%rip)     # 0xa1650
jne 0x232c1
movslq 0x7e11e(%rip), %rdi     # 0xa13a0
shlq $0x3, %rdi
callq 0x10410
movq %rax, 0x7e3be(%rip)     # 0xa1650
cmpq $0x0, 0x7e3b6(%rip)     # 0xa1650
jne 0x232a8
movl $0x0, -0x4(%rbp)
jmp 0x23397
movq 0x7e3a1(%rip), %rdi     # 0xa1650
movslq 0x7e0ea(%rip), %rdx     # 0xa13a0
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x10250
cmpl $0x0, 0x7e380(%rip)     # 0xa1648
je 0x232fb
movq 0x7e37f(%rip), %rax     # 0xa1650
movl 0x7e371(%rip), %ecx     # 0xa1648
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x10330
cmpl $0x0, %eax
jne 0x232fb
movl $0x0, -0x4(%rbp)
jmp 0x23397
movq -0x10(%rbp), %rdi
callq 0x10650
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x23318
movl $0x0, -0x4(%rbp)
jmp 0x23397
movl 0x7e32a(%rip), %eax     # 0xa1648
cmpl 0x7e07c(%rip), %eax     # 0xa13a0
jne 0x2336b
movq 0x7e323(%rip), %rax     # 0xa1650
movq (%rax), %rdi
callq 0x10050
movq 0x7e314(%rip), %rdi     # 0xa1650
movq 0x7e30d(%rip), %rsi     # 0xa1650
addq $0x8, %rsi
movl 0x7e053(%rip), %eax     # 0xa13a0
subl $0x1, %eax
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0x10500
movl 0x7e2e6(%rip), %eax     # 0xa1648
addl $-0x1, %eax
movl %eax, 0x7e2dd(%rip)     # 0xa1648
movq -0x18(%rbp), %rdx
movq 0x7e2da(%rip), %rax     # 0xa1650
movslq 0x7e2cb(%rip), %rcx     # 0xa1648
movq %rdx, (%rax,%rcx,8)
movl 0x7e2c1(%rip), %eax     # 0xa1648
addl $0x1, %eax
movl %eax, 0x7e2b8(%rip)     # 0xa1648
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x1, -0x8(%rbp)
jge 0x233bd
movl $0x0, -0x4(%rbp)
jmp 0x234b7
cmpq $0x0, 0x7e28b(%rip)     # 0xa1650
je 0x2348d
movl 0x7e277(%rip), %eax     # 0xa1648
movl %eax, -0x14(%rbp)
movslq -0x8(%rbp), %rdi
shlq $0x3, %rdi
callq 0x10410
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x233f8
movl $0x0, -0x4(%rbp)
jmp 0x234b7
movl -0x8(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x23439
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
subl -0x8(%rbp), %ecx
cmpl %ecx, %eax
jge 0x23433
movq 0x7e235(%rip), %rax     # 0xa1650
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10050
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x23407
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x8(%rbp), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x10250
movq -0x10(%rbp), %rdi
movq 0x7e1f9(%rip), %rsi     # 0xa1650
movl 0x7e1eb(%rip), %eax     # 0xa1648
subl -0x14(%rbp), %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
movslq -0x14(%rbp), %rdx
shlq $0x3, %rdx
callq 0x103b0
movq 0x7e1d3(%rip), %rdi     # 0xa1650
callq 0x10050
movq -0x10(%rbp), %rax
movq %rax, 0x7e1c3(%rip)     # 0xa1650
movl -0x8(%rbp), %eax
movl %eax, 0x7df0a(%rip)     # 0xa13a0
movl 0x7e1ac(%rip), %eax     # 0xa1648
cmpl 0x7defe(%rip), %eax     # 0xa13a0
jle 0x234b0
movl 0x7def6(%rip), %eax     # 0xa13a0
movl %eax, 0x7e198(%rip)     # 0xa1648
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x7f, %edi
callq 0x10380
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x67a04(%rip), %rsi     # 0x8aee8
callq 0x10560
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edi
callq 0x10380
cmpq $0x0, -0x20(%rbp)
jne 0x23505
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x23561
movq -0x10(%rbp), %rdi
movl $0x180, %esi            # imm = 0x180
callq 0x104b0
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl 0x7e125(%rip), %eax     # 0xa1648
jge 0x23551
movq -0x20(%rbp), %rdi
movq 0x7e120(%rip), %rax     # 0xa1650
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x689fc(%rip), %rsi     # 0x8bf3b
movb $0x0, %al
callq 0x10360
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2351a
movq -0x20(%rbp), %rdi
callq 0x10190
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6794f(%rip), %rsi     # 0x8aed9
callq 0x10560
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x235a6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2362f
jmp 0x235a8
leaq -0x1020(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x1000, %esi           # imm = 0x1000
callq 0x102f0
cmpq $0x0, %rax
je 0x2361f
leaq -0x1020(%rbp), %rdi
movl $0xd, %esi
callq 0x101c0
movq %rax, -0x1028(%rbp)
cmpq $0x0, -0x1028(%rbp)
jne 0x235fd
leaq -0x1020(%rbp), %rdi
movl $0xa, %esi
callq 0x101c0
movq %rax, -0x1028(%rbp)
cmpq $0x0, -0x1028(%rbp)
je 0x23611
movq -0x1028(%rbp), %rax
movb $0x0, (%rax)
leaq -0x1020(%rbp), %rdi
callq 0x23250
jmp 0x235a8
movq -0x18(%rbp), %rdi
callq 0x10190
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: freeHistory
static void freeHistory(void) {
    if (history) {
        int j;

        for (j = 0; j < history_len; j++)
            free(history[j]);
        free(history);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x7d9d0(%rip)     # 0xa1650
je 0x23cbf
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x7d9b6(%rip), %eax     # 0xa1648
jge 0x23cb3
movq 0x7d9b5(%rip), %rax     # 0xa1650
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10050
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x23c89
movq 0x7d996(%rip), %rdi     # 0xa1650
callq 0x10050
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/linenoise/linenoise.c
// Function: getColumns
static int getColumns(int ifd, int ofd) {
    struct winsize ws;

    if (ioctl(1, TIOCGWINSZ, &ws) == -1 || ws.ws_col == 0) {
        /* ioctl() failed. Try to query the terminal itself. */
        int start, cols;

        /* Get the initial position so we can restore it later. */
        start = getCursorPosition(ifd,ofd);
        if (start == -1) goto failed;

        /* Go to right margin and get position. */
        if (write(ofd,"\x1b[999C",6) != 6) goto failed;
        cols = getCursorPosition(ifd,ofd);
        if (cols == -1) goto failed;

        /* Restore position. */
        if (cols > start) {
            char seq[32];
            snprintf(seq,32,"\x1b[%dD",cols-start);
            if (write(ofd,seq,strlen(seq)) == -1) {
                /* Can't recover... */
            }
        }
        return cols;
    } else {
        return ws.ws_col;
    }

failed:
    return 80;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, %edi
movl $0x5413, %esi           # imm = 0x5413
leaq -0x14(%rbp), %rdx
movb $0x0, %al
callq 0x10260
cmpl $-0x1, %eax
je 0x24245
movzwl -0x12(%rbp), %eax
cmpl $0x0, %eax
jne 0x242ed
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x24520
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x2425e
jmp 0x242f6
movl -0xc(%rbp), %edi
leaq 0x6a067(%rip), %rsi     # 0x8e2cf
movl $0x6, %edx
callq 0x10150
cmpq $0x6, %rax
je 0x2427a
jmp 0x242f6
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x24520
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x24290
jmp 0x242f6
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x242e5
leaq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %ecx
subl -0x18(%rbp), %ecx
movl $0x20, %esi
leaq 0x6a028(%rip), %rdx     # 0x8e2d6
movb $0x0, %al
callq 0x101e0
movl -0xc(%rbp), %eax
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x101a0
movl -0x4c(%rbp), %edi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x10150
cmpq $-0x1, %rax
jne 0x242e3
jmp 0x242e3
jmp 0x242e5
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x242fd
movzwl -0x12(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x242fd
movl $0x50, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)