LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/winton[P]redis_parse/hiredis/net.c
// Function: redisContextConnectUnix
int redisContextConnectUnix(redisContext *c, const char *path, struct timeval *timeout) {
    int s;
    int blocking = (c->flags & REDIS_BLOCK);
    struct sockaddr_un sa;

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl 0x88(%rdi), %r13d
pushq $0x1
popq %rdi
movl %edi, %esi
xorl %edx, %edx
callq 0x2490
cmpl $-0x1, %eax
je 0x2a7a
movl %eax, %r14d
pushq $-0x1
popq %rbp
testl %eax, %eax
js 0x2ac1
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x2898
testl %eax, %eax
jne 0x2ac1
leaq 0xc(%rsp), %rdi
movw $0x1, -0x2(%rdi)
pushq $0x6b
popq %rdx
movq %r12, %rsi
callq 0x2090
leaq 0xa(%rsp), %rsi
pushq $0x6e
popq %rdx
movl %r14d, %edi
callq 0x23f0
cmpl $-0x1, %eax
je 0x2a89
testb $0x1, %r13b
je 0x2ab1
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2898
testl %eax, %eax
jne 0x2ac1
jmp 0x2ab1
movq %rbx, %rdi
xorl %esi, %esi
callq 0x25eb
pushq $-0x1
popq %rbp
jmp 0x2ac1
callq 0x2080
movl (%rax), %eax
xorl $0x73, %eax
movl %r13d, %ecx
andl $0x1, %ecx
orl %eax, %ecx
je 0x2ab1
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x290c
testl %eax, %eax
jne 0x2ac1
jmp 0x2a60
movl %r14d, 0x84(%rbx)
orb $0x2, 0x88(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/winton[P]redis_parse/hiredis/hiredis.c
// Function: redisConnect
redisContext *redisConnect(const char *ip, int port) {
    redisContext *c = redisContextInit();
    c->flags |= REDIS_BLOCK;
    redisContextConnectTcp(c,ip,port,NULL);
    return c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x3b57
movq %rax, %r15
orb $0x1, 0x88(%rax)
movq %rax, %rdi
movq %r14, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x2390
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/winton[P]redis_parse/hiredis/hiredis.c
// Function: redisConnectWithTimeout
redisContext *redisConnectWithTimeout(const char *ip, int port, struct timeval tv) {
    redisContext *c = redisContextInit();
    c->flags |= REDIS_BLOCK;
    redisContextConnectTcp(c,ip,port,&tv);
    return c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %rdx, (%r15)
movq %rcx, 0x8(%r15)
callq 0x3b57
movq %rax, %r12
orb $0x1, 0x88(%rax)
movq %rax, %rdi
movq %r14, %rsi
movl %ebx, %edx
movq %r15, %rcx
callq 0x2390
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/winton[P]redis_parse/hiredis/hiredis.c
// Function: redisConnectUnix
redisContext *redisConnectUnix(const char *path) {
    redisContext *c = redisContextInit();
    c->flags |= REDIS_BLOCK;
    redisContextConnectUnix(c,path,NULL);
    return c;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3b57
movq %rax, %r14
orb $0x1, 0x88(%rax)
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2290
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/winton[P]redis_parse/hiredis/hiredis.c
// Function: redisConnectUnixWithTimeout
redisContext *redisConnectUnixWithTimeout(const char *path, struct timeval tv) {
    redisContext *c = redisContextInit();
    c->flags |= REDIS_BLOCK;
    redisContextConnectUnix(c,path,&tv);
    return c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %rsi, (%r14)
movq %rdx, 0x8(%r14)
callq 0x3b57
movq %rax, %r15
orb $0x1, 0x88(%rax)
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2290
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/winton[P]redis_parse/hiredis/hiredis.c
// Function: redisConnectUnixNonBlock
redisContext *redisConnectUnixNonBlock(const char *path) {
    redisContext *c = redisContextInit();
    c->flags &= ~REDIS_BLOCK;
    redisContextConnectUnix(c,path,NULL);
    return c;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3b57
movq %rax, %r14
andb $-0x2, 0x88(%rax)
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2290
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/winton[P]redis_parse/hiredis/hiredis.c
// Function: _redisAppendCommand
int __redisAppendCommand(redisContext *c, char *cmd, size_t len) {
    sds newbuf;

    newbuf = sdscatlen(c->obuf,cmd,len);
    if (newbuf == NULL) {
        __redisSetError(c,REDIS_ERR_OOM,"Out of memory");
        return REDIS_ERR;
    }

    c->obuf = newbuf;
    return REDIS_OK;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x90(%rdi), %rdi
callq 0x23b0
testq %rax, %rax
je 0x3ee7
movq %rax, 0x90(%rbx)
xorl %eax, %eax
jmp 0x3efc
leaq 0x3396(%rip), %rdx      # 0x7284
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x2280
pushq $-0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/winton[P]redis_parse/hiredis/sds.c
// Function: sdsnewlen
sds sdsnewlen(const void *init, size_t initlen) {
    struct sdshdr *sh;

    sh = malloc(sizeof(struct sdshdr)+initlen+1);
#ifdef SDS_ABORT_ON_OOM
    if (sh == NULL) sdsOomAbort();
#else
    if (sh == NULL) return NULL;
#endif
    sh->len = initlen;
    sh->free = 0;
    if (initlen) {
        if (init) memcpy(sh->buf, init, initlen);
        else memset(sh->buf,0,initlen);
    }
    sh->buf[initlen] = '\0';
    return (char*)sh->buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x9(%rsi), %rdi
callq 0x2300
testq %rax, %rax
je 0x45c1
movq %rax, %r14
movl %ebx, (%rax)
andl $0x0, 0x4(%rax)
testq %rbx, %rbx
je 0x45cf
leaq 0x8(%r14), %rdi
testq %r15, %r15
je 0x45c5
movq %r15, %rsi
movq %rbx, %rdx
callq 0x22c0
jmp 0x45cf
xorl %eax, %eax
jmp 0x45dc
xorl %esi, %esi
movq %rbx, %rdx
callq 0x21d0
movq %r14, %rax
addq $0x8, %rax
movb $0x0, 0x8(%r14,%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/winton[P]redis_parse/hiredis/sds.c
// Function: sdsMakeRoomFor
static sds sdsMakeRoomFor(sds s, size_t addlen) {
    struct sdshdr *sh, *newsh;
    size_t free = sdsavail(s);
    size_t len, newlen;

    if (free >= addlen) return s;
    len = sdslen(s);
    sh = (void*) (s-(sizeof(struct sdshdr)));
    newlen = (len+addlen)*2;
    newsh = realloc(sh, sizeof(struct sdshdr)+newlen+1);
#ifdef SDS_ABORT_ON_OOM
    if (newsh == NULL) sdsOomAbort();
#else
    if (newsh == NULL) return NULL;
#endif

    newsh->free = newlen - len;
    return newsh->buf;
}

// Assembly:
movq %rdi, %rax
movslq -0x4(%rdi), %rcx
cmpq %rsi, %rcx
jae 0x46ea
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq -0x8(%rax), %r14
addq $-0x8, %rax
addq %r14, %rbx
leaq 0x9(,%rbx,2), %rsi
movq %rax, %rdi
callq 0x2350
testq %rax, %rax
je 0x46e1
addq %rbx, %rbx
subl %r14d, %ebx
movl %ebx, 0x4(%rax)
addq $0x8, %rax
jmp 0x46e3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/winton[P]redis_parse/hiredis/sds.c
// Function: sdscatlen
sds sdscatlen(sds s, const void *t, size_t len) {
    struct sdshdr *sh;
    size_t curlen = sdslen(s);

    s = sdsMakeRoomFor(s,len);
    if (s == NULL) return NULL;
    sh = (void*) (s-(sizeof(struct sdshdr)));
    memcpy(s+curlen, t, len);
    sh->len = curlen+len;
    sh->free = sh->free-len;
    s[curlen+len] = '\0';
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movslq -0x8(%rdi), %r12
movq %rdx, %rsi
callq 0x469f
movq %rax, %r14
testq %rax, %rax
je 0x472e
movq %r14, %rdi
addq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x22c0
addq %rbx, %r12
movl %r12d, -0x8(%r14)
subl %ebx, -0x4(%r14)
movb $0x0, (%r14,%r12)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/winton[P]redis_parse/hiredis/sds.c
// Function: sdscatvprintf
sds sdscatvprintf(sds s, const char *fmt, va_list ap) {
    va_list cpy;
    char *buf, *t;
    size_t buflen = 16;

    while(1) {
        buf = malloc(buflen);
#ifdef SDS_ABORT_ON_OOM
        if (buf == NULL) sdsOomAbort();
#else
        if (buf == NULL) return NULL;
#endif
        buf[buflen-2] = '\0';
        va_copy(cpy,ap);
        vsnprintf(buf, buflen, fmt, cpy);
        if (buf[buflen-2] != '\0') {
            free(buf);
            buflen *= 2;
            continue;
        }
        break;
    }
    t = sdscat(s, buf);
    free(buf);
    return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
pushq $0x10
popq %r13
xorl %ebx, %ebx
leaq 0x10(%rsp), %rbp
movq %r13, %rdi
callq 0x2300
testq %rax, %rax
je 0x4891
movq %rax, %r14
movb $0x0, -0x2(%rax,%r13)
movq 0x10(%r15), %rax
movq %rax, 0x20(%rsp)
movups (%r15), %xmm0
movaps %xmm0, 0x10(%rsp)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rbp, %rcx
callq 0x20c0
cmpb $0x0, -0x2(%r14,%r13)
je 0x4879
movq %r14, %rdi
callq 0x2060
addq %r13, %r13
jmp 0x482b
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x2330
movq %rax, %rbx
movq %r14, %rdi
callq 0x2060
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/winton[P]redis_parse/hiredis/sds.c
// Function: sdstrim
sds sdstrim(sds s, const char *cset) {
    struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr)));
    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 > start && strchr(cset, *ep)) ep--;
    len = (sp > ep) ? 0 : ((ep-sp)+1);
    if (sh->buf != sp) memmove(sh->buf, sp, len);
    sh->buf[len] = '\0';
    sh->free = sh->free+(sh->len-len);
    sh->len = len;
    return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movslq -0x8(%rdi), %r14
leaq (%rdi,%r14), %rbp
decq %rbp
xorl %r13d, %r13d
leaq (%rbx,%r13), %r12
cmpq %rbp, %r12
ja 0x4966
movsbl (%r12), %esi
movq %r15, %rdi
callq 0x2170
testq %rax, %rax
je 0x4966
incq %r13
jmp 0x4946
subq %r13, %r14
cmpq %rbx, %rbp
jbe 0x4987
movsbl (%rbp), %esi
movq %r15, %rdi
callq 0x2170
testq %rax, %rax
je 0x4987
decq %rbp
decq %r14
jmp 0x4969
xorl %eax, %eax
cmpq %rbp, %r12
cmovaq %rax, %r14
testq %r13, %r13
je 0x49a3
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x23a0
movb $0x0, (%rbx,%r14)
movl -0x4(%rbx), %eax
subl %r14d, %eax
addl -0x8(%rbx), %eax
movl %eax, -0x4(%rbx)
movl %r14d, -0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/winton[P]redis_parse/hiredis/sds.c
// Function: sdsrange
sds sdsrange(sds s, int start, int end) {
    struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr)));
    size_t newlen, len = sdslen(s);

    if (len == 0) return s;
    if (start < 0) {
        start = len+start;
        if (start < 0) start = 0;
    }
    if (end < 0) {
        end = len+end;
        if (end < 0) end = 0;
    }
    newlen = (start > end) ? 0 : (end-start)+1;
    if (newlen != 0) {
        if (start >= (signed)len) {
            newlen = 0;
        } else if (end >= (signed)len) {
            end = len-1;
            newlen = (start > end) ? 0 : (end-start)+1;
        }
    } else {
        start = 0;
    }
    if (start && newlen) memmove(sh->buf, sh->buf+start, newlen);
    sh->buf[newlen] = 0;
    sh->free = sh->free+(sh->len-newlen);
    sh->len = newlen;
    return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl -0x8(%rdi), %ecx
testl %ecx, %ecx
je 0x4a4f
leal (%rcx,%rsi), %eax
xorl %r14d, %r14d
testl %eax, %eax
cmovlel %r14d, %eax
testl %esi, %esi
cmovnsl %esi, %eax
leal (%rcx,%rdx), %esi
testl %esi, %esi
cmovlel %r14d, %esi
testl %edx, %edx
cmovnsl %edx, %esi
movl %esi, %edx
subl %eax, %edx
leal 0x1(%rdx), %edi
cmovbl %r14d, %edi
movl %ecx, %edx
subl %eax, %edx
jle 0x4a3a
testl %edi, %edi
je 0x4a3a
leal -0x1(%rcx), %r8d
xorl %r9d, %r9d
cmpl %r8d, %eax
cmoval %r9d, %edx
cmpl %ecx, %esi
cmovbl %edi, %edx
movslq %edx, %r14
testl %eax, %eax
je 0x4a3a
testl %edx, %edx
je 0x4a3a
movl %eax, %esi
addq %rbx, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x23a0
movb $0x0, (%rbx,%r14)
movl -0x4(%rbx), %eax
subl %r14d, %eax
addl -0x8(%rbx), %eax
movl %eax, -0x4(%rbx)
movl %r14d, -0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/winton[P]redis_parse/hiredis/sds.c
// Function: sdscatrepr
sds sdscatrepr(sds s, char *p, size_t len) {
    s = sdscatlen(s,"\"",1);
    if (s == NULL) return NULL;

    while(len--) {
        switch(*p) {
        case '\\':
        case '"':
            s = sdscatprintf(s,"\\%c",*p);
            break;
        case '\n': s = sdscatlen(s,"\\n",2); break;
        case '\r': s = sdscatlen(s,"\\r",2); break;
        case '\t': s = sdscatlen(s,"\\t",2); break;
        case '\a': s = sdscatlen(s,"\\a",2); break;
        case '\b': s = sdscatlen(s,"\\b",2); break;
        default:
            if (isprint(*p))
                s = sdscatprintf(s,"%c",*p);
            else
                s = sdscatprintf(s,"\\x%02x",(unsigned char)*p);
            break;
        }
        p++;
        if (s == NULL) return NULL;
    }
    return sdscatlen(s,"\"",1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x270a(%rip), %rsi      # 0x745a
pushq $0x1
popq %rdx
callq 0x23b0
testq %rax, %rax
je 0x4e31
movq %rax, %r13
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x4e42
movsbl (%r14,%r12), %ebp
movzbl %bpl, %r15d
leal -0x7(%r15), %eax
cmpl $0x6, %eax
ja 0x4d9e
leaq 0x277b(%rip), %rcx      # 0x7504
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r13, %rdi
leaq 0x2791(%rip), %rsi      # 0x752d
jmp 0x4e05
cmpl $0x5c, %r15d
je 0x4daa
cmpl $0x22, %r15d
jne 0x4db6
movq %r13, %rdi
leaq 0x276c(%rip), %rsi      # 0x7520
jmp 0x4e19
callq 0x2470
movq (%rax), %rax
movslq %ebp, %rcx
testb $0x40, 0x1(%rax,%rcx,2)
jne 0x4e0f
movq %r13, %rdi
leaq 0x2761(%rip), %rsi      # 0x7533
movl %r15d, %edx
jmp 0x4e1b
movq %r13, %rdi
leaq 0x274f(%rip), %rsi      # 0x7530
jmp 0x4e05
movq %r13, %rdi
leaq 0x273d(%rip), %rsi      # 0x752a
jmp 0x4e05
movq %r13, %rdi
leaq 0x272b(%rip), %rsi      # 0x7524
jmp 0x4e05
movq %r13, %rdi
leaq 0x2722(%rip), %rsi      # 0x7527
pushq $0x2
popq %rdx
callq 0x23b0
jmp 0x4e22
movq %r13, %rdi
leaq 0x2708(%rip), %rsi      # 0x7521
movl %ebp, %edx
xorl %eax, %eax
callq 0x2140
movq %rax, %r13
incq %r12
testq %rax, %rax
jne 0x4d67
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2611(%rip), %rsi      # 0x745a
pushq $0x1
popq %rdx
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x23b0
// File: /workspace/github_c_makefile_star2_O2/winton[P]redis_parse/hiredis/async.c
// Function: redisAsyncConnect
redisAsyncContext *redisAsyncConnect(const char *ip, int port) {
    redisContext *c = redisConnectNonBlock(ip,port);
    redisAsyncContext *ac = redisAsyncInitialize(c);
    __redisAsyncCopyError(ac);
    return ac;
}

// Assembly:
pushq %rax
callq 0x2340
movq %rax, %rdi
callq 0x5053
movl (%rax), %ecx
movl %ecx, 0xa0(%rax)
leaq 0x4(%rax), %rcx
movq %rcx, 0xa8(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/winton[P]redis_parse/hiredis/async.c
// Function: redisAsyncConnectUnix
redisAsyncContext *redisAsyncConnectUnix(const char *path) {
    redisContext *c = redisConnectUnixNonBlock(path);
    redisAsyncContext *ac = redisAsyncInitialize(c);
    __redisAsyncCopyError(ac);
    return ac;
}

// Assembly:
pushq %rax
callq 0x2360
movq %rax, %rdi
callq 0x5053
movl (%rax), %ecx
movl %ecx, 0xa0(%rax)
leaq 0x4(%rax), %rcx
movq %rcx, 0xa8(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/winton[P]redis_parse/hiredis/async.c
// Function: _redisAsyncHandleConnect
static int __redisAsyncHandleConnect(redisAsyncContext *ac) {
    redisContext *c = &(ac->c);

    if (redisCheckSocketError(c,c->fd) == REDIS_ERR) {
        /* Try again later when connect(2) is still in progress. */
        if (errno == EINPROGRESS)
            return REDIS_OK;

        if (ac->onConnect) ac->onConnect(ac,REDIS_ERR);
        __redisAsyncDisconnect(ac);
        return REDIS_ERR;
    }

    /* Mark context as connected. */
    c->flags |= REDIS_CONNECTED;
    if (ac->onConnect) ac->onConnect(ac,REDIS_OK);
    return REDIS_OK;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x84(%rdi), %esi
callq 0x2150
cmpl $-0x1, %eax
je 0x5777
orb $0x2, 0x88(%rbx)
movq 0xf0(%rbx), %rax
testq %rax, %rax
je 0x5781
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq *%rax
jmp 0x57a4
callq 0x2080
cmpl $0x73, (%rax)
jne 0x5785
xorl %ebp, %ebp
jmp 0x57a4
movq 0xf0(%rbx), %rax
testq %rax, %rax
je 0x5799
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq *%rax
pushq $-0x1
popq %rbp
movq %rbx, %rdi
callq 0x5297
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cirocosta[P]stress/src/pid.c
// Function: fork_so_much
void
fork_so_much(int n)
{
	int pid;

	printf("Starting to spawn %d blocking children\n", n);
	while (--n) {
		switch (pid = fork()) {
			case -1:
				_STRESS_MUST(0, "Fork returned -1.");
				break;
			case 0:
				printf("[%d] - blocking\n", n);
				stress_wait_until_signalized();
				return;
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0xa8d(%rip), %rdi       # 0x2108
movl %ebx, %esi
xorl %eax, %eax
callq 0x1090
cmpl $0x1, %ebx
je 0x1753
callq 0x1130
decl %ebx
testl %eax, %eax
je 0x175b
cmpl $-0x1, %eax
jne 0x1684
movq 0x2950(%rip), %r14      # 0x3ff8
movq (%r14), %rcx
leaq 0x96e(%rip), %rdi       # 0x2020
pushq $0x9
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x1110
movq (%r14), %rcx
leaq 0x95c(%rip), %rdi       # 0x2026
pushq $0x3
popq %rsi
movq %rbx, %rdx
callq 0x1110
movq (%r14), %rcx
leaq 0xa51(%rip), %rdi       # 0x2130
pushq $0x11
popq %rsi
movq %rbx, %rdx
callq 0x1110
movq (%r14), %rcx
leaq 0x959(%rip), %rdi       # 0x204d
pushq $0x2
popq %rsi
movq %rbx, %rdx
callq 0x1110
movq (%r14), %rdi
leaq 0x947(%rip), %rsi       # 0x2050
leaq 0xa32(%rip), %rdx       # 0x2142
xorl %eax, %eax
callq 0x10d0
movq (%r14), %rdi
leaq 0x94b(%rip), %rsi       # 0x206c
pushq $0x15
popq %rdx
xorl %eax, %eax
callq 0x10d0
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x10b0
movq (%r14), %rcx
leaq 0x939(%rip), %rdi       # 0x2079
pushq $0xa
popq %rsi
movq %rbx, %rdx
callq 0x1110
pushq $0x1
popq %rdi
callq 0x1100
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x9ea(%rip), %rdi       # 0x214c
movl %ebx, %esi
xorl %eax, %eax
callq 0x1090
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x156e
// File: /workspace/github_c_makefile_star2_O2/cirocosta[P]stress/src/pid.c
// Function: main
int
main(int argc, char** argv)
{
	stress_args_t args = { 0 };

	stress_parse_args(argc, argv, &args);
	fork_so_much(args.n);
	stress_wait_until_signalized();

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x2010, %rsp           # imm = 0x2010
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x8(%rsp), %r14
movl $0x2008, %edx           # imm = 0x2008
movq %r14, %rdi
xorl %esi, %esi
callq 0x10a0
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x129d
movl (%r14), %edi
callq 0x166e
callq 0x156e
xorl %eax, %eax
addq $0x2010, %rsp           # imm = 0x2010
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/fsio/fsio.c
// Function: doUmount
static void doUmount(void)
{
  struct mountedFS *mount, **ptr = &mounts;

  if (checkDev(words[0]) != 0) {
    if ((mount = lookupDev(words[0])) != NULL) {
      if (mount->filesys->umount == NULL) {
        fprintf(stderr, "umount: \"%s\" may not be unmounted\n", words[0]);
        return;
      }

      for (ptr = &mounts; *ptr != NULL; ptr = &((*ptr)->next))
        if (*ptr == mount) {
          *ptr = mount->next;
          (*mount->filesys->umount)(mount);
          fclose(mount->container);
          free(mount);
          return;
        }
      fprintf(stderr, "Mounted file system list corrupted\n");
      exit(10);
    } else fprintf(stderr, "umount: \"%s\" is not mounted\n", words[0]);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x14a67(%rip), %rax     # 0x180b8
movq (%rax), %rdi
callq 0x4d45
testl %eax, %eax
je 0x36c1
movq 0x14a54(%rip), %rax     # 0x180b8
movq (%rax), %r14
movq %r14, %rdi
callq 0x4dc2
testq %rax, %rax
je 0x36c9
movq %rax, %rbx
movq 0x20(%rax), %rax
cmpq $0x0, 0x30(%rax)
je 0x36dc
leaq 0x15a37(%rip), %rax     # 0x190c0
movq %rax, %rcx
movq (%rax), %rax
testq %rax, %rax
je 0x36fe
cmpq %rbx, %rax
jne 0x3689
movq (%rbx), %rax
movq %rax, (%rcx)
movq 0x20(%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
movq 0x38(%rbx), %rdi
callq 0x3110
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3050
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x13928(%rip), %rax     # 0x16ff8
movq (%rax), %rdi
leaq 0xbb7e(%rip), %rsi      # 0xf258
jmp 0x36ed
movq 0x13915(%rip), %rax     # 0x16ff8
movq (%rax), %rdi
leaq 0xbb24(%rip), %rsi      # 0xf211
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x31e0
movq 0x138f3(%rip), %rax     # 0x16ff8
movq (%rax), %rcx
leaq 0xbb25(%rip), %rdi      # 0xf234
pushq $0x23
popq %rsi
pushq $0x1
popq %rdx
callq 0x32d0
pushq $0xa
popq %rdi
callq 0x32c0
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/fsio/fsio.c
// Function: doSet
static void doSet(void)
{
  struct mountedFS *mount;
  char *fname;
  uint8_t unit, present;

  if ((mount = findMount("set", words[0], &unit, &present, &fname)) != NULL) {
    if (*fname == '\0') {
      if (mount->filesys->set != NULL)
        (*mount->filesys->set)(mount, unit, present);
      else fprintf(stderr, "set: \"%s\" does not support \"set\" command\n",
                   mount->filesys->fstype);
    } else fprintf(stderr, "set: Does not expect a file name\n");
  }
}

// Assembly:
subq $0x18, %rsp
movq 0x147af(%rip), %rax     # 0x180b8
movq (%rax), %rsi
leaq 0xb72c(%rip), %rdi      # 0xf03f
leaq 0xf(%rsp), %rdx
leaq 0xe(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0x4e24
testq %rax, %rax
je 0x3956
movq 0x10(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x395b
movq 0x20(%rax), %rdx
movq 0x48(%rdx), %rcx
testq %rcx, %rcx
je 0x397b
movzbl 0xf(%rsp), %esi
movzbl 0xe(%rsp), %edx
movq %rax, %rdi
addq $0x18, %rsp
jmpq *%rcx
addq $0x18, %rsp
retq
movq 0x13696(%rip), %rax     # 0x16ff8
movq (%rax), %rcx
leaq 0xb9ef(%rip), %rdi      # 0xf35b
pushq $0x21
popq %rsi
pushq $0x1
popq %rdx
addq $0x18, %rsp
jmp 0x32d0
movq 0x13676(%rip), %rax     # 0x16ff8
movq (%rax), %rdi
movq 0x8(%rdx), %rdx
leaq 0xb9a1(%rip), %rsi      # 0xf331
xorl %eax, %eax
addq $0x18, %rsp
jmp 0x31e0
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/fsio/fsio.c
// Function: doInfo
static void doInfo(void)
{
  struct mountedFS *mount;
  char *fname;
  uint8_t unit, present;

  if ((mount = findMount("info", words[0], &unit, &present, &fname)) != NULL) {
    if (*fname == '\0')
      (*mount->filesys->info)(mount, unit, present);
    else fprintf(stderr, "info: Does not expect a file name\n");
  }
}

// Assembly:
subq $0x18, %rsp
movq 0x14712(%rip), %rax     # 0x180b8
movq (%rax), %rsi
leaq 0xb693(%rip), %rdi      # 0xf043
leaq 0xf(%rsp), %rdx
leaq 0xe(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0x4e24
testq %rax, %rax
je 0x39ee
movq 0x10(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x39f3
movq 0x20(%rax), %rcx
movq 0x50(%rcx), %rcx
movzbl 0xf(%rsp), %esi
movzbl 0xe(%rsp), %edx
movq %rax, %rdi
addq $0x18, %rsp
jmpq *%rcx
addq $0x18, %rsp
retq
movq 0x135fe(%rip), %rax     # 0x16ff8
movq (%rax), %rcx
leaq 0xba7a(%rip), %rdi      # 0xf47e
pushq $0x22
popq %rsi
pushq $0x1
popq %rdx
addq $0x18, %rsp
jmp 0x32d0
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/fsio/fsio.c
// Function: doType
static void doType(void)
{
  struct mountedFS *mount;
  char *fname;
  void *file;
  uint8_t unit, present;

  /*
   * Force ASCII mode
   */
  SWSET('a');

  if ((mount = findMount("type", words[0], &unit, &present, &fname)) != NULL) {
    if ((file = (*mount->filesys->openFileR)(mount, unit, fname)) != NULL) {
      char buf[BFRSIZ];
      size_t len, i;

      while ((len = (*mount->filesys->readFile)(file, buf, BFRSIZ)) != 0) {
        for (i = 0; i < len; i++)
          if (buf[i] != '\0')
            putchar(buf[i]);
      }

      /*
       * Close the file
       */
      (*mount->filesys->closeFile)(file);
    } else fprintf(stderr, "type: \"%s\" no such file\n", fname);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
orb $0x1, 0x13f93(%rip)     # 0x17fd8
movq 0x1406c(%rip), %rax     # 0x180b8
movq (%rax), %rsi
leaq 0xb013(%rip), %rdi      # 0xf069
leaq 0x6(%rsp), %rdx
leaq 0x7(%rsp), %rcx
leaq 0x8(%rsp), %r8
callq 0x4e24
testq %rax, %rax
je 0x40d9
movq %rax, %rbx
movq 0x20(%rax), %rax
movzbl 0x6(%rsp), %esi
movq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq *0x60(%rax)
testq %rax, %rax
je 0x40ea
movq %rax, %r14
leaq 0x10(%rsp), %r15
movq 0x20(%rbx), %rax
movl $0x200, %edx            # imm = 0x200
movq %r14, %rdi
movq %r15, %rsi
callq *0x80(%rax)
testq %rax, %rax
je 0x40cf
movq %rax, %r12
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x4096
movsbl 0x10(%rsp,%r13), %edi
testl %edi, %edi
je 0x40ca
callq 0x3060
incq %r13
jmp 0x40b6
movq 0x20(%rbx), %rax
movq %r14, %rdi
callq *0x78(%rax)
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x12f07(%rip), %rax     # 0x16ff8
movq (%rax), %rdi
leaq 0xb4e4(%rip), %rsi      # 0xf5df
movq %r15, %rdx
xorl %eax, %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x31e0
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/fsio/fsio.c
// Function: doDelete
static void doDelete(void)
{
  struct mountedFS *mount;
  char *fname;
  void *file;
  uint8_t unit, present;

  if ((mount = findMount("delete", words[0], &unit, &present, &fname)) != NULL) {
    if (mount->filesys->deleteFile != NULL) {
      if ((mount->flags & FS_READONLY) == 0) {
        if ((file = (*mount->filesys->openFileR)(mount, unit, fname)) != NULL)
          (*mount->filesys->deleteFile)(file, fname);
        else fprintf(stderr, "delete: \"%s\" no such file\n", fname);
      } else fprintf(stderr, "delete: \"%s\" is mounted read-only\n", mount->name);
    } else fprintf(stderr, "delete: Function not supported\n");
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0x13f95(%rip), %rax     # 0x180b8
movq (%rax), %rsi
leaq 0xaf44(%rip), %rdi      # 0xf071
leaq 0xe(%rsp), %rdx
leaq 0xf(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0x4e24
testq %rax, %rax
je 0x418f
movq %rax, %rbx
movq 0x20(%rax), %rax
cmpq $0x0, 0x90(%rax)
je 0x4197
testb $0x1, 0x30(%rbx)
jne 0x41ba
movzbl 0xe(%rsp), %esi
movq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq *0x60(%rax)
testq %rax, %rax
je 0x41d4
movq 0x20(%rbx), %rcx
movq 0x90(%rcx), %rcx
movq %rax, %rdi
movq %r14, %rsi
addq $0x18, %rsp
popq %rbx
popq %r14
jmpq *%rcx
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x12e5a(%rip), %rax     # 0x16ff8
movq (%rax), %rcx
leaq 0xb48e(%rip), %rdi      # 0xf636
pushq $0x1f
popq %rsi
pushq $0x1
popq %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x32d0
movq 0x12e37(%rip), %rax     # 0x16ff8
movq (%rax), %rdi
addq $0x8, %rbx
leaq 0xb444(%rip), %rsi      # 0xf613
movq %rbx, %rdx
jmp 0x41e8
movq 0x12e1d(%rip), %rax     # 0x16ff8
movq (%rax), %rdi
leaq 0xb413(%rip), %rsi      # 0xf5f8
movq %r14, %rdx
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x31e0
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/fsio/fsio.c
// Function: doStatus
static void doStatus(void)
{
  if (mounts != NULL) {
    struct mountedFS *mount;

    for (mount = mounts; mount != NULL; mount = mount->next)
      printf("%-20s%s\n", mount->name, mount->filesys->fstype);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x14ebf(%rip), %r14     # 0x190c0
testq %r14, %r14
je 0x422d
leaq 0xb449(%rip), %rbx      # 0xf656
testq %r14, %r14
je 0x422d
leaq 0x8(%r14), %rsi
movq 0x20(%r14), %rax
movq 0x8(%rax), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3160
movq (%r14), %r14
jmp 0x420d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/fsio/fsio.c
// Function: doDo
static void doDo(void)
{
  uint8_t noecho = SWISSET('q');
  FILE *cmdFile;
  char buf[MAX_CMDLEN];

  if ((cmdFile = fopen(words[0], "r")) != NULL) {
    for (;;) {
      int len;

      if (fgets(buf, sizeof(buf), cmdFile) == NULL) {
        fclose(cmdFile);
        return;
      }

      if (!noecho)
        printf("fsio> %s", buf);

      /*
       * Remove any trailing newline
       */
      len = strlen(buf);
      if (buf[len - 1] == '\n')
        buf[len - 1] = '\0';

      /*
       * Parse the command line and execute any command found
       */
      FSioExecute(buf);
    }
  } else fprintf(stderr, "do: failed to open \"%s\"\n", words[0]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movl 0x13d90(%rip), %ebp     # 0x17fd8
movq 0x13e69(%rip), %rax     # 0x180b8
movq (%rax), %rdi
leaq 0xc39a(%rip), %rsi      # 0x105f3
callq 0x3280
testq %rax, %rax
je 0x42ce
movq %rax, %rbx
movq %rsp, %r14
leaq 0xae75(%rip), %r15      # 0xf0e5
movq %r14, %rdi
movl $0x200, %esi            # imm = 0x200
movq %rbx, %rdx
callq 0x31b0
testq %rax, %rax
je 0x42b8
btl $0x10, %ebp
jb 0x4298
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3160
movq %r14, %rdi
callq 0x3130
decl %eax
cltq
cmpb $0xa, (%rsp,%rax)
jne 0x42ae
movb $0x0, (%rsp,%rax)
movq %r14, %rdi
callq 0x489a
jmp 0x4270
movq %rbx, %rdi
callq 0x3110
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x12d23(%rip), %rax     # 0x16ff8
movq (%rax), %rdi
movq 0x13dd9(%rip), %rax     # 0x180b8
movq (%rax), %rdx
leaq 0xb376(%rip), %rsi      # 0xf65f
xorl %eax, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x31e0
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/fsio/fsio.c
// Function: doExit
static void doExit(void)
{
  struct mountedFS *mount;

  for (mount = mounts; mount != NULL; mount = mount->next)
    if (mount != &localMount)
      fclose(mount->container);

#ifdef DEBUG
  if ((DEBUGout != NULL) && (DEBUGout != stdout))
    fclose(DEBUGout);
#endif

  exit(0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x14d7a(%rip), %rbx     # 0x190c0
leaq 0x14d7b(%rip), %r14     # 0x190c8
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x4365
cmpq %r14, %rbx
je 0x434d
movq 0x38(%rbx), %rdi
callq 0x3110
jmp 0x434d
movq 0x13c5c(%rip), %rdi     # 0x17fc8
testq %rdi, %rdi
je 0x4382
movq 0x12c48(%rip), %rax     # 0x16fc0
cmpq (%rax), %rdi
je 0x4382
callq 0x3110
xorl %edi, %edi
callq 0x32c0
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/fsio/fsio.c
// Function: doRewind
static void doRewind(void)
{
  struct mountedFS *mount;
  char *fname;
  uint8_t unit, present;

  if ((mount = findMount("rewind", words[0], &unit, &present, &fname)) != NULL) {
    if ((mount->filesys->flags & FS_TAPE) == 0) {
      fprintf(stderr, "rewind: Command only valid on magtapes\n");
      return;
    }

    if (*fname == '\0')
      (*mount->filesys->rewind)(mount);
    else fprintf(stderr, "rewind: Does not expect a file name\n");
  }
}

// Assembly:
subq $0x18, %rsp
movq 0x13d24(%rip), %rax     # 0x180b8
movq (%rax), %rsi
leaq 0xacf6(%rip), %rdi      # 0xf094
leaq 0xf(%rsp), %rdx
leaq 0xe(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0x4e24
testq %rax, %rax
je 0x43d8
movq 0x20(%rax), %rcx
testb $0x2, 0x18(%rcx)
je 0x43dd
movq 0x10(%rsp), %rdx
cmpb $0x0, (%rdx)
jne 0x43f2
movq %rax, %rdi
addq $0x18, %rsp
jmpq *0x98(%rcx)
addq $0x18, %rsp
retq
movq 0x12c14(%rip), %rax     # 0x16ff8
movq (%rax), %rcx
leaq 0xb28a(%rip), %rdi      # 0xf678
pushq $0x27
jmp 0x4405
movq 0x12bff(%rip), %rax     # 0x16ff8
movq (%rax), %rcx
leaq 0xb29d(%rip), %rdi      # 0xf6a0
pushq $0x24
popq %rsi
pushq $0x1
popq %rdx
addq $0x18, %rsp
jmp 0x32d0
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/fsio/fsio.c
// Function: doEOM
static void doEOM(void)
{
  struct mountedFS *mount;
  char *fname;
  uint8_t unit, present;

  if ((mount = findMount("eom", words[0], &unit, &present, &fname)) != NULL) {
    if ((mount->filesys->flags & FS_TAPE) == 0) {
      fprintf(stderr, "eom: Command only valid on magtapes\n");
      return;
    }

    if (*fname == '\0')
      (*mount->filesys->eom)(mount);
    else fprintf(stderr, "eom: Does not expect a file name\n");
  }
}

// Assembly:
subq $0x18, %rsp
movq 0x13c9b(%rip), %rax     # 0x180b8
movq (%rax), %rsi
leaq 0xac74(%rip), %rdi      # 0xf09b
leaq 0xf(%rsp), %rdx
leaq 0xe(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0x4e24
testq %rax, %rax
je 0x4461
movq 0x20(%rax), %rcx
testb $0x2, 0x18(%rcx)
je 0x4466
movq 0x10(%rsp), %rdx
cmpb $0x0, (%rdx)
jne 0x447b
movq %rax, %rdi
addq $0x18, %rsp
jmpq *0xa0(%rcx)
addq $0x18, %rsp
retq
movq 0x12b8b(%rip), %rax     # 0x16ff8
movq (%rax), %rcx
leaq 0xb24e(%rip), %rdi      # 0xf6c5
pushq $0x24
jmp 0x448e
movq 0x12b76(%rip), %rax     # 0x16ff8
movq (%rax), %rcx
leaq 0xb25e(%rip), %rdi      # 0xf6ea
pushq $0x21
popq %rsi
pushq $0x1
popq %rdx
addq $0x18, %rsp
jmp 0x32d0
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/fsio/fsio.c
// Function: doSkipForw
static void doSkipForw(void)
{
  struct mountedFS *mount;
  char *fname;
  uint8_t unit, present;

  if ((mount = findMount("skipf", words[0], &unit, &present, &fname)) != NULL) {
    if ((mount->filesys->flags & FS_TAPE) == 0) {
      fprintf(stderr, "skipf: Command only valid on magtapes\n");
      return;
    }

    if (*fname == '\0') {
      char *endptr;
      unsigned long count = strtoul(words[1], &endptr, 10);

      if (*endptr != '\0') {
        fprintf(stderr, "skipf: Invalid character in count\n");
        return;
      }

      if (count != 0)
        (*mount->filesys->skipforw)(mount, count);
    } else fprintf(stderr, "skipf: Does not expect a file name\n");
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0x13c0f(%rip), %rax     # 0x180b8
movq (%rax), %rsi
leaq 0xabec(%rip), %rdi      # 0xf09f
leaq 0x7(%rsp), %rdx
leaq 0x6(%rsp), %rcx
leaq 0x8(%rsp), %r8
callq 0x4e24
testq %rax, %rax
je 0x451b
movq %rax, %rbx
movq 0x20(%rax), %rax
testb $0x2, 0x18(%rax)
je 0x4523
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x4538
movq 0x13bce(%rip), %rax     # 0x180b8
movq 0x8(%rax), %rdi
leaq 0x10(%rsp), %r14
pushq $0xa
popq %rdx
movq %r14, %rsi
callq 0x32a0
movq (%r14), %rcx
cmpb $0x0, (%rcx)
jne 0x455b
testq %rax, %rax
je 0x451b
movq 0x20(%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0xa8(%rcx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x12ace(%rip), %rax     # 0x16ff8
movq (%rax), %rcx
leaq 0xb1d8(%rip), %rdi      # 0xf70c
pushq $0x26
jmp 0x454b
movq 0x12ab9(%rip), %rax     # 0x16ff8
movq (%rax), %rcx
leaq 0xb20d(%rip), %rdi      # 0xf756
pushq $0x23
popq %rsi
pushq $0x1
popq %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x32d0
movq 0x12a96(%rip), %rax     # 0x16ff8
movq (%rax), %rcx
leaq 0xb1c7(%rip), %rdi      # 0xf733
pushq $0x22
popq %rsi
pushq $0x1
popq %rdx
callq 0x32d0
jmp 0x451b
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/fsio/fsio.c
// Function: doSkipRev
static void doSkipRev(void)
{
  struct mountedFS *mount;
  char *fname;
  uint8_t unit, present;

  if ((mount = findMount("skipf", words[0], &unit, &present, &fname)) != NULL) {
    if ((mount->filesys->flags & FS_TAPE) == 0) {
      fprintf(stderr, "skipr: Command only valid on magtapes\n");
      return;
    }

    if (*fname == '\0') {
      char *endptr;
      unsigned long count = strtoul(words[1], &endptr, 10);

      if (*endptr != '\0') {
        fprintf(stderr, "skipr: Invalid character in count\n");
        return;
      }

      if (count != 0)
        (*mount->filesys->skiprev)(mount, count);
    } else fprintf(stderr, "skipr: Does not expect a file name\n");
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0x13b31(%rip), %rax     # 0x180b8
movq (%rax), %rsi
leaq 0xab0e(%rip), %rdi      # 0xf09f
leaq 0x7(%rsp), %rdx
leaq 0x6(%rsp), %rcx
leaq 0x8(%rsp), %r8
callq 0x4e24
testq %rax, %rax
je 0x45f9
movq %rax, %rbx
movq 0x20(%rax), %rax
testb $0x2, 0x18(%rax)
je 0x4601
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x4616
movq 0x13af0(%rip), %rax     # 0x180b8
movq 0x8(%rax), %rdi
leaq 0x10(%rsp), %r14
pushq $0xa
popq %rdx
movq %r14, %rsi
callq 0x32a0
movq (%r14), %rcx
cmpb $0x0, (%rcx)
jne 0x4639
testq %rax, %rax
je 0x45f9
movq 0x20(%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0xb0(%rcx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x129f0(%rip), %rax     # 0x16ff8
movq (%rax), %rcx
leaq 0xb168(%rip), %rdi      # 0xf77a
pushq $0x26
jmp 0x4629
movq 0x129db(%rip), %rax     # 0x16ff8
movq (%rax), %rcx
leaq 0xb19d(%rip), %rdi      # 0xf7c4
pushq $0x23
popq %rsi
pushq $0x1
popq %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x32d0
movq 0x129b8(%rip), %rax     # 0x16ff8
movq (%rax), %rcx
leaq 0xb157(%rip), %rdi      # 0xf7a1
pushq $0x22
popq %rsi
pushq $0x1
popq %rdx
callq 0x32d0
jmp 0x45f9
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/fsio/fsio.c
// Function: main
int main(
  int argc,
  char **argv
)
{
  FILE *commands = stdin;
  int ch;

  FSioInit();

  /*
   * Process command line switches
   */
  while ((ch = getopt(argc, argv, "qv")) != -1) {
    switch (ch) {
      case 'q':
        quiet = 1;
        break;

      case 'v':
        verbose = 1;
        break;

      default:
        Usage();
    }
  }

  argc -= optind;
  argv += optind;

#if !defined(__linux__)
  optreset = 1;
#endif
  optind = 1;

  if (argc <= 1) {
    if (argc == 1) {
      commands = fopen(argv[0], "r");
      if (commands == NULL) {
        fprintf(stderr, "Failed to open \"%s\": %s\n",
                argv[0], strerror(errno));
        exit(2);
      }
    }
    FSioCommands(commands);
  } else Usage();

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x14a37(%rip), %rax     # 0x190c8
movl $0x61636f6c, 0x8(%rax)  # imm = 0x61636F6C
movw $0x6c, 0xc(%rax)
leaq 0x13673(%rip), %rcx     # 0x17d18
movq %rcx, 0x20(%rax)
andq $0x0, 0x28(%rax)
movl %edi, %ebp
andq $0x0, 0x38(%rax)
movq 0x1290c(%rip), %rdx     # 0x16fc8
andq $0x0, (%rax)
movq (%rdx), %r14
movq %rax, 0x149f6(%rip)     # 0x190c0
movq 0x138ff(%rip), %rax     # 0x17fd0
movq %rax, (%rcx)
leaq 0x13415(%rip), %rax     # 0x17af0
movq %rcx, (%rax)
leaq 0x134c3(%rip), %rcx     # 0x17ba8
movq %rax, (%rcx)
leaq 0x13571(%rip), %rax     # 0x17c60
movq %rcx, (%rax)
leaq 0x137f7(%rip), %rcx     # 0x17ef0
movq %rax, (%rcx)
movq %rcx, 0x138cd(%rip)     # 0x17fd0
leaq 0xa9b8(%rip), %r15      # 0xf0c2
leaq 0x138b3(%rip), %r12     # 0x17fc4
leaq 0x138a8(%rip), %r13     # 0x17fc0
movl %ebp, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3290
movq %r12, %rcx
cmpl $0x71, %eax
je 0x4735
cmpl $0x76, %eax
jne 0x473d
movq %r13, %rcx
movl $0x1, (%rcx)
jmp 0x4718
cmpl $-0x1, %eax
jne 0x478d
movq 0x12887(%rip), %rax     # 0x16fd0
movslq (%rax), %r15
subl %r15d, %ebp
movl $0x1, (%rax)
cmpl $0x1, %ebp
jg 0x478d
jne 0x4774
movq (%rbx,%r15,8), %rdi
leaq 0xbe8c(%rip), %rsi      # 0x105f3
callq 0x3280
movq %rax, %r14
testq %rax, %rax
je 0x4792
movq %r14, %rdi
callq 0x47cb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4657
movq 0x1285f(%rip), %rax     # 0x16ff8
movq (%rax), %r14
movq (%rbx,%r15,8), %rbx
callq 0x3070
movl (%rax), %edi
callq 0x32e0
leaq 0xa912(%rip), %rsi      # 0xf0c5
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x31e0
pushq $0x2
popq %rdi
callq 0x32c0
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/fsio/fsio.c
// Function: FSioReadBlock
int FSioReadBlock(
  struct mountedFS *mount,
  unsigned int block,
  void *buf
)
{
  off_t offset = block * mount->blocksz;

  if (fseeko(mount->container, offset + mount->skip, SEEK_SET) == 0)
    return fread(buf, mount->blocksz, 1, mount->container);

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %esi, %esi
imulq 0x28(%rdi), %rsi
movq %rdx, %r14
movq 0x38(%rdi), %rdi
addq 0x40(%rbx), %rsi
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x3270
testl %eax, %eax
jne 0x4c61
movq 0x28(%rbx), %rsi
movq 0x38(%rbx), %rcx
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x30f0
movq %rax, %r15
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/fsio/fsio.c
// Function: FSioWriteBlock
int FSioWriteBlock(
  struct mountedFS *mount,
  unsigned int block,
  void *buf
)
{
  off_t offset = block * mount->blocksz;

  if (fseeko(mount->container, offset + mount->skip, SEEK_SET) == 0)
    return fwrite(buf, mount->blocksz, 1, mount->container);

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %esi, %esi
imulq 0x28(%rdi), %rsi
movq %rdx, %r14
movq 0x38(%rdi), %rdi
addq 0x40(%rbx), %rsi
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x3270
testl %eax, %eax
jne 0x4ca8
movq 0x28(%rbx), %rsi
movq 0x38(%rbx), %rcx
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x32d0
movq %rax, %r15
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/fsio/fsio.c
// Function: FSioReadSector
int FSioReadSector(
  struct mountedFS *mount,
  unsigned int sector,
  unsigned int size,
  void *buf
)
{
  off_t offset = sector * size;

  if (fseeko(mount->container, offset + mount->skip, SEEK_SET) == 0)
    return fread(buf, size, 1, mount->container);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r14
imull %edx, %esi
movq 0x38(%rdi), %rdi
addq 0x40(%r14), %rsi
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x3270
testl %eax, %eax
jne 0x4ced
movl %ebp, %esi
movq 0x38(%r14), %rcx
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x30f0
movq %rax, %r15
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/fsio/fsio.c
// Function: FSioWriteSector
int FSioWriteSector(
  struct mountedFS *mount,
  unsigned int sector,
  unsigned int size,
  void *buf
)
{
  off_t offset = sector * size;

  if (fseeko(mount->container, offset + mount->skip, SEEK_SET) == 0)
    return fwrite(buf, size, 1, mount->container);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r14
imull %edx, %esi
movq 0x38(%rdi), %rdi
addq 0x40(%r14), %rsi
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x3270
testl %eax, %eax
jne 0x4d37
movl %ebp, %esi
movq 0x38(%r14), %rcx
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x32d0
movq %rax, %r15
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/fsio/fsio.c
// Function: checkDev
static int checkDev(
  char *dev
)
{
  unsigned int i;

  /*
   * Remove any trailing ':' characters
   */
  while ((strlen(dev) != 0) && (dev[strlen(dev) - 1] == ':'))
    dev[strlen(dev) - 1] = '\0';

  for (i = 0; i < strlen(dev); i++)
    if (!isalpha(dev[i])) {
      fprintf(stderr,
              "%s: Device name contains non-alpha character\n", wds[0]);
      return 0;
    }
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rbx, %rdi
callq 0x3130
movq %rax, %r14
testq %rax, %rax
je 0x4d6f
cmpb $0x3a, -0x1(%rbx,%r14)
jne 0x4d6f
movb $0x0, -0x1(%rbx,%r14)
jmp 0x4d4f
xorl %eax, %eax
pushq $0x1
popq %rbp
movl %eax, %r15d
cmpq %r15, %r14
jbe 0x4db5
callq 0x3300
movq (%rax), %rcx
movsbq (%rbx,%r15), %rdx
leal 0x1(%r15), %eax
testb $0x4, 0x1(%rcx,%rdx,2)
jne 0x4d74
movq 0x1225d(%rip), %rax     # 0x16ff8
movq (%rax), %rdi
movq 0x1331b(%rip), %rdx     # 0x180c0
leaq 0xa437(%rip), %rsi      # 0xf1e3
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x31e0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/fsio/declib.c
// Function: r50Asc
void r50Asc(
  uint16_t value,
  char *outbuf
)
{
  outbuf[2] = rad50[value % 050];
  value /= 050;
  outbuf[1] = rad50[value % 050];
  outbuf[0] = rad50[value / 050];
}

// Assembly:
movw $0x28, %cx
movl %edi, %eax
xorl %edx, %edx
divw %cx
movzwl %dx, %edx
leaq 0x125a3(%rip), %r8      # 0x17620
movb (%rdx,%r8), %dl
movb %dl, 0x2(%rsi)
xorl %edx, %edx
divw %cx
movzwl %dx, %eax
movb (%rax,%r8), %al
movb %al, 0x1(%rsi)
movw $0x640, %cx             # imm = 0x640
movl %edi, %eax
xorl %edx, %edx
divw %cx
movzwl %ax, %eax
movb (%rax,%r8), %al
movb %al, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/fsio/declib.c
// Function: r50AscNoSpace
void r50AscNoSpace(
  uint16_t value,
  char *outbuf
)
{
  uint16_t value2 = value / 050;

  /*
   * The rad50 representation of ' ' is zero.
   */
  if ((value2 / 050) != 0)
    *outbuf++ = rad50[value2 / 050];
  if ((value2 % 050) != 0)
    *outbuf++ = rad50[value2 % 050];
  if ((value % 050) != 0)
    *outbuf++ = rad50[value % 050];
}

// Assembly:
movl %edi, %r8d
movw $0x28, %r9w
movl %r8d, %eax
xorl %edx, %edx
divw %r9w
movl %edx, %ecx
movl %eax, %edi
cmpw $0x640, %r8w            # imm = 0x640
jb 0x50e5
movw $0x640, %r10w           # imm = 0x640
movl %r8d, %eax
xorl %edx, %edx
divw %r10w
movzwl %ax, %eax
leaq 0x12543(%rip), %rdx     # 0x17620
movb (%rax,%rdx), %al
movb %al, (%rsi)
incq %rsi
movl %edi, %eax
xorl %edx, %edx
divw %r9w
testw %dx, %dx
je 0x5104
movzwl %dx, %eax
leaq 0x12524(%rip), %rdx     # 0x17620
movb (%rax,%rdx), %al
movb %al, (%rsi)
incq %rsi
testw %cx, %cx
je 0x5118
movzwl %cx, %eax
leaq 0x1250d(%rip), %rcx     # 0x17620
movb (%rax,%rcx), %al
movb %al, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/fsio/declib.c
// Function: ascR50
uint16_t ascR50(
  char *inbuf
)
{
  uint16_t value;
  char *ptr;

  if ((ptr = strchr(rad50, toupper(*inbuf++))) == NULL)
    ptr = strchr(rad50, '%');

  value = (ptr - rad50) * 03100;

  if ((ptr = strchr(rad50, toupper(*inbuf++))) == NULL)
    ptr = strchr(rad50, '%');

  value += (ptr - rad50) * 050;

  if ((ptr = strchr(rad50, toupper(*inbuf++))) == NULL)
    ptr = strchr(rad50, '%');

  value += ptr - rad50;

  return value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x3030
movq (%rax), %r12
movsbq (%r14), %rax
movl (%r12,%rax,4), %esi
leaq 0x124e5(%rip), %rdi     # 0x17620
callq 0x3150
movq %rax, %rbx
testq %rax, %rax
jne 0x515a
leaq 0x124d1(%rip), %rdi     # 0x17620
pushq $0x25
popq %rsi
callq 0x3150
movq %rax, %rbx
movsbq 0x1(%r14), %rax
movl (%r12,%rax,4), %esi
leaq 0x124b6(%rip), %rdi     # 0x17620
callq 0x3150
movq %rax, %r15
testq %rax, %rax
jne 0x5189
leaq 0x124a2(%rip), %rdi     # 0x17620
pushq $0x25
popq %rsi
callq 0x3150
movq %rax, %r15
movsbq 0x2(%r14), %rax
movl (%r12,%rax,4), %esi
leaq 0x12487(%rip), %rdi     # 0x17620
callq 0x3150
testq %rax, %rax
jne 0x51b2
leaq 0x12476(%rip), %rdi     # 0x17620
pushq $0x25
popq %rsi
callq 0x3150
leaq 0x12467(%rip), %rcx     # 0x17620
subl %ecx, %ebx
imull $0x640, %ebx, %edx      # imm = 0x640
subl %ecx, %r15d
imull $0x28, %r15d, %esi
subl %ecx, %edx
addl %esi, %eax
addl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq