LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: aio_cmd_seek
static int aio_cmd_seek(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    AioFile *af = Jim_CmdPrivData(interp);
    int orig = SEEK_SET;
    jim_wide offset;

    if (argc == 2) {
        if (Jim_CompareStringImmediate(interp, argv[1], "start"))
            orig = SEEK_SET;
        else if (Jim_CompareStringImmediate(interp, argv[1], "current"))
            orig = SEEK_CUR;
        else if (Jim_CompareStringImmediate(interp, argv[1], "end"))
            orig = SEEK_END;
        else {
            return -1;
        }
    }
    if (Jim_GetWide(interp, argv[0], &offset) != JIM_OK) {
        return JIM_ERR;
    }
    if (orig != SEEK_CUR || offset != 0) {

        aio_flush(interp, af);
    }
    if (Jim_Lseek(af->fd, offset, orig) == -1) {
        JimAioSetError(interp, af->filename);
        return JIM_ERR;
    }
    if (af->readbuf) {
        Jim_FreeNewObj(interp, af->readbuf);
        af->readbuf = NULL;
    }
    af->flags &= ~AIO_EOF;
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rdi, %r14
movq 0x1b8(%rdi), %rax
movq %rax, -0x30(%rbp)
xorl %r15d, %r15d
movb $0x1, %bl
cmpl $0x2, %esi
jne 0x129ba
movq 0x8(%r12), %rsi
leaq 0x14118(%rip), %rdx     # 0x26a86
movq %r14, %rdi
callq 0x7223
testl %eax, %eax
jne 0x129ba
movq 0x8(%r12), %rsi
leaq 0x14bdf(%rip), %rdx     # 0x27565
movq %r14, %rdi
callq 0x7223
testl %eax, %eax
je 0x1299a
pushq $0x1
popq %r15
xorl %ebx, %ebx
jmp 0x129ba
movq 0x8(%r12), %rsi
leaq 0x15995(%rip), %rdx     # 0x2833b
movq %r14, %rdi
callq 0x7223
testl %eax, %eax
je 0x12a42
pushq $0x2
popq %r15
pushq $0x1
popq %r13
movq (%r12), %rsi
leaq -0x38(%rbp), %rdx
movq %r14, %rdi
callq 0xc979
testl %eax, %eax
jne 0x12a30
movq -0x38(%rbp), %r12
testq %r12, %r12
setne %al
orb %al, %bl
cmpb $0x1, %bl
movq -0x30(%rbp), %rbx
jne 0x129f2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x130af
movl 0x18(%rbx), %edi
movq %r12, %rsi
movl %r15d, %edx
callq 0x64a0
cmpq $-0x1, %rax
je 0x12a25
movq 0x30(%rbx), %rsi
testq %rsi, %rsi
je 0x12a1c
movq %r14, %rdi
callq 0x73bf
andq $0x0, 0x30(%rbx)
andb $-0x5, 0xc(%rbx)
xorl %r13d, %r13d
jmp 0x12a30
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x12fac
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %r13
jmp 0x12a30
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: aio_cmd_ndelay
static int aio_cmd_ndelay(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    AioFile *af = Jim_CmdPrivData(interp);

    if (argc) {
        long nb;

        if (Jim_GetLong(interp, argv[0], &nb) != JIM_OK) {
            return JIM_ERR;
        }
        aio_set_nonblocking(af, nb);
    }
    Jim_SetResultInt(interp, (af->flags & AIO_NONBLOCK) ? 1 : 0);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x1b8(%rdi), %r14
testl %esi, %esi
je 0x12b11
movq (%rdx), %rsi
leaq -0x18(%rbp), %rdx
movq %rbx, %rdi
callq 0xc8cb
testl %eax, %eax
je 0x12b06
pushq $0x1
popq %rax
jmp 0x12b47
movl -0x18(%rbp), %esi
movq %r14, %rdi
callq 0x12e9b
movl 0xc(%r14), %esi
shrl $0x4, %esi
andl $0x1, %esi
movq %rbx, %rdi
callq 0x8212
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x12b42
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: aio_cmd_buffering
static int aio_cmd_buffering(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    AioFile *af = Jim_CmdPrivData(interp);
    Jim_Obj *resultObj;

    static const char * const options[] = {
        "none",
        "line",
        "full",
        NULL
    };

    if (argc) {
        if (Jim_GetEnum(interp, argv[0], options, &af->wbuft, NULL, JIM_ERRMSG) != JIM_OK) {
            return JIM_ERR;
        }

        if (af->wbuft == WBUF_OPT_FULL && argc == 2) {
            long l;
            if (Jim_GetLong(interp, argv[1], &l) != JIM_OK || l <= 0) {
                return JIM_ERR;
            }
            af->wbuf_limit = l;
        }

        if (af->wbuft == WBUF_OPT_NONE) {
            if (aio_flush(interp, af) != JIM_OK) {
                return JIM_ERR;
            }
        }

    }

    resultObj = Jim_NewListObj(interp, NULL, 0);
    Jim_ListAppendElement(interp, resultObj, Jim_NewStringObj(interp, options[af->wbuft], -1));
    if (af->wbuft == WBUF_OPT_FULL) {
        Jim_ListAppendElement(interp, resultObj, Jim_NewIntObj(interp, af->wbuf_limit));
    }
    Jim_SetResult(interp, resultObj);

    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x1b8(%rdi), %r12
testl %esi, %esi
je 0x12c02
movl %esi, %r13d
movq (%rdx), %rsi
leaq 0x8(%r12), %r14
movq %rdx, -0x38(%rbp)
leaq 0x1f077(%rip), %rdx     # 0x31c00
pushq $0x1
popq %r15
movq %rbx, %rdi
movq %r14, %rcx
xorl %r8d, %r8d
movl %r15d, %r9d
callq 0x7b44
testl %eax, %eax
jne 0x12c80
movq -0x38(%rbp), %rdx
movq %r12, -0x30(%rbp)
movl (%r14), %eax
movl %eax, %ecx
xorl $0x2, %ecx
xorl $0x2, %r13d
orl %ecx, %r13d
jne 0x12bf6
movq 0x8(%rdx), %rsi
leaq -0x40(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0xc8cb
testl %eax, %eax
sete %cl
movq (%r14), %rax
testq %rax, %rax
setg %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x12c80
movq -0x30(%rbp), %rcx
movq %rax, 0x50(%rcx)
movl 0x8(%rcx), %eax
testl %eax, %eax
movq -0x30(%rbp), %r12
je 0x12c92
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x745b
movq %rax, %r15
movslq 0x8(%r12), %rax
leaq 0x1efe3(%rip), %rcx     # 0x31c00
movq (%rcx,%rax,8), %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x7363
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x74ad
cmpl $0x2, 0x8(%r12)
jne 0x12c5d
movq 0x50(%r12), %rsi
movq %rbx, %rdi
callq 0x8212
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x74ad
incl 0x10(%r15)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x12c7a
movq %rbx, %rdi
callq 0x73bf
movq %r15, (%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r12, %rsi
callq 0x130af
testl %eax, %eax
jne 0x12c80
jmp 0x12c02
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: aio_cmd_readsize
static int aio_cmd_readsize(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    AioFile *af = Jim_CmdPrivData(interp);

    if (argc) {
        long l;
        if (Jim_GetLong(interp, argv[0], &l) != JIM_OK || l <= 0) {
            return JIM_ERR;
        }
        af->rbuf_len = l;
        if (af->rbuf) {
            af->rbuf = Jim_Realloc(af->rbuf, af->rbuf_len);
        }
    }
    Jim_SetResultInt(interp, af->rbuf_len);

    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1b8(%rdi), %r15
testl %esi, %esi
je 0x12d24
movq (%rdx), %rsi
leaq -0x20(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0xc8cb
testl %eax, %eax
sete %al
movq (%r14), %rsi
testq %rsi, %rsi
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x12d56
movq %rsi, 0x48(%r15)
movq 0x40(%r15), %rdi
testq %rdi, %rdi
je 0x12d24
callq *0x20568(%rip)          # 0x33288
movq %rax, 0x40(%r15)
movq 0x48(%r15), %rsi
movq %rbx, %rdi
callq 0x8212
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x12d4f
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %eax, %eax
jmp 0x12d59
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: aio_start_nonblocking
static int aio_start_nonblocking(AioFile *af)
{
    int old = !!(af->flags & AIO_NONBLOCK);
    if (af->timeout) {
        aio_set_nonblocking(af, 1);
    }
    return old;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0xc(%rdi), %ebx
cmpq $0x0, 0x10(%rdi)
je 0x12d7c
pushq $0x1
popq %rsi
callq 0x12e9b
shrl $0x4, %ebx
andl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: aio_read_len
static int aio_read_len(Jim_Interp *interp, AioFile *af, unsigned flags, int neededLen)
{
    if (!af->readbuf) {
        af->readbuf = Jim_NewStringObj(interp, NULL, 0);
    }

    if (neededLen >= 0) {
        neededLen -= Jim_Length(af->readbuf);
        if (neededLen <= 0) {
            return JIM_OK;
        }
    }

    while (neededLen && !aio_eof(af)) {
        int retval;
        int readlen;

        if (neededLen == -1) {
            readlen = af->rbuf_len;
        }
        else {
            readlen = (neededLen > af->rbuf_len ? af->rbuf_len : neededLen);
        }

        if (!af->rbuf) {
            af->rbuf = Jim_Alloc(af->rbuf_len);
        }
        retval = af->fops->reader(af, af->rbuf, readlen, flags & AIO_NONBLOCK);
        if (retval > 0) {
            if (retval) {
                Jim_AppendString(interp, af->readbuf, af->rbuf, retval);
            }
            if (neededLen != -1) {
                neededLen -= retval;
            }
            if (flags & AIO_ONEREAD) {
                return JIM_OK;
            }
            continue;
        }
        if ((flags & AIO_ONEREAD) || JimCheckStreamError(interp, af)) {
            return JIM_ERR;
        }
        break;
    }

    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r12d
movl %edx, %r13d
movq %rsi, %rbx
movq %rdi, -0x30(%rbp)
movq 0x30(%rsi), %rdi
testq %rdi, %rdi
jne 0x12dc3
movq -0x30(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7363
movq %rax, %rdi
movq %rax, 0x30(%rbx)
testl %r12d, %r12d
js 0x12dd6
callq 0xa61a
subl %eax, %r12d
jle 0x12e68
movl %r13d, %r15d
andl $0x10, %r15d
testl %r12d, %r12d
je 0x12e68
testb $0x4, 0xc(%rbx)
jne 0x12e68
cmpl $-0x1, %r12d
je 0x12e06
movslq %r12d, %rax
movq 0x48(%rbx), %rsi
movl %esi, %r14d
cmpq %rax, %rsi
jb 0x12e0d
movl %r12d, %r14d
jmp 0x12e0d
movq 0x48(%rbx), %rsi
movl %esi, %r14d
movq 0x40(%rbx), %rax
testq %rax, %rax
jne 0x12e22
xorl %edi, %edi
callq *0x2046a(%rip)          # 0x33288
movq %rax, 0x40(%rbx)
movq 0x28(%rbx), %r8
movq %rbx, %rdi
movq %rax, %rsi
movl %r14d, %edx
movl %r15d, %ecx
callq *0x8(%r8)
testl %eax, %eax
jle 0x12e7b
movl %eax, %r14d
movq 0x30(%rbx), %rsi
movq 0x40(%rbx), %rdx
movq -0x30(%rbp), %rdi
movl %eax, %ecx
callq 0x823a
movl %r12d, %eax
subl %r14d, %eax
cmpl $-0x1, %r12d
cmovnel %eax, %r12d
testb $0x20, %r13b
je 0x12ddd
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testb $0x20, %r13b
jne 0x12e96
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x12f69
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
jmp 0x12e6a
pushq $0x1
popq %rcx
jmp 0x12e6a
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: aio_set_nonblocking
static void aio_set_nonblocking(AioFile *af, int nb)
{
#ifdef O_NDELAY
    int old = !!(af->flags & AIO_NONBLOCK);
    if (old != nb) {
        int fmode = fcntl(af->fd, F_GETFL);
        if (nb) {
            fmode |= O_NDELAY;
            af->flags |= AIO_NONBLOCK;
        }
        else {
            fmode &= ~O_NDELAY;
            af->flags &= ~AIO_NONBLOCK;
        }
        (void)fcntl(af->fd, F_SETFL, fmode);
    }
#endif
}

// Assembly:
movl 0xc(%rdi), %eax
shrl $0x4, %eax
andl $0x1, %eax
cmpl %esi, %eax
jne 0x12ea9
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movl 0x18(%rdi), %edi
pushq $0x3
popq %rsi
xorl %eax, %eax
callq 0x63f0
xorl %edx, %edx
testl %r14d, %r14d
setne %dl
andl $0xfffff7ff, %eax       # imm = 0xFFFFF7FF
movl 0xc(%rbx), %ecx
movl 0x18(%rbx), %edi
andl $-0x11, %ecx
movl %edx, %esi
shll $0x4, %esi
orl %ecx, %esi
shll $0xb, %edx
orl %eax, %edx
movl %esi, 0xc(%rbx)
pushq $0x4
popq %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x63f0
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: aio_read_consume
static Jim_Obj *aio_read_consume(Jim_Interp *interp, AioFile *af, int neededLen)
{
    Jim_Obj *objPtr = NULL;

    if (neededLen < 0 || af->readbuf == NULL || Jim_Length(af->readbuf) <= neededLen) {
        objPtr = af->readbuf;
        af->readbuf = NULL;
    }
    else if (af->readbuf) {

        int len;
        const char *pt = Jim_GetString(af->readbuf, &len);

        objPtr  = Jim_NewStringObj(interp, pt, neededLen);
        aio_consume(af->readbuf, neededLen);
    }

    return objPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
testl %edx, %edx
js 0x12f4d
movq %rdi, %r15
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x12f4d
movl %edx, %ebx
callq 0xa61a
cmpl %ebx, %eax
jle 0x12f4d
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x12f64
leaq -0x1c(%rbp), %rsi
callq 0x7fc7
movq %r15, %rdi
movq %rax, %rsi
movl %ebx, %edx
callq 0x7363
movq %rax, %r15
movq 0x30(%r14), %rdi
movl %ebx, %esi
callq 0x1303c
jmp 0x12f56
movq 0x30(%r14), %r15
andq $0x0, 0x30(%r14)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
jmp 0x12f56
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: JimCheckStreamError
static int JimCheckStreamError(Jim_Interp *interp, AioFile *af)
{
    int ret = 0;
    if (!aio_eof(af)) {
        ret = af->fops->error(af);
        if (ret) {
            JimAioSetError(interp, af->filename);
        }
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebx, %ebx
testb $0x4, 0xc(%rsi)
jne 0x12fa1
movq %rsi, %r15
movq %rdi, %r14
movq 0x28(%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
testl %eax, %eax
je 0x12fa1
movl %eax, %r12d
movq (%r15), %rsi
movq %r14, %rdi
callq 0x12fac
movl %r12d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: JimAioSetError
static void JimAioSetError(Jim_Interp *interp, Jim_Obj *name)
{
    AioFile *af = Jim_CmdPrivData(interp);

    if (name) {
        Jim_SetResultFormatted(interp, "%#s: %s", name, JimAioErrorString(af));
    }
    else {
        Jim_SetResultString(interp, JimAioErrorString(af), -1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x1b8(%rdi), %rdi
callq 0x1301a
testq %r14, %r14
je 0x12fe5
leaq 0x14535(%rip), %rsi     # 0x27506
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x68a7
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7363
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x13012
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: aio_consume
static void aio_consume(Jim_Obj *objPtr, int n)
{
    assert(objPtr->bytes);
    assert(n <= objPtr->length);


    memmove(objPtr->bytes, objPtr->bytes + n, objPtr->length - n + 1);
    objPtr->length -= n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x13071
movl %esi, %ebx
movl 0x14(%r14), %eax
subl %esi, %eax
jl 0x13090
movslq %ebx, %rsi
addq %rdi, %rsi
incl %eax
movslq %eax, %rdx
callq 0x6400
subl %ebx, 0x14(%r14)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x14496(%rip), %rdi     # 0x2750e
leaq 0x13b7c(%rip), %rsi     # 0x26bfb
leaq 0x14496(%rip), %rcx     # 0x2751c
movl $0x8f2, %edx            # imm = 0x8F2
callq 0x6220
leaq 0x144a6(%rip), %rdi     # 0x2753d
leaq 0x13b5d(%rip), %rsi     # 0x26bfb
leaq 0x14477(%rip), %rcx     # 0x2751c
movl $0x8f3, %edx            # imm = 0x8F3
callq 0x6220
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: aio_flush
static int aio_flush(Jim_Interp *interp, AioFile *af)
{
    int len;
    const char *pt = Jim_GetString(af->writebuf, &len);
    if (len) {
        int ret = af->fops->writer(af, pt, len);
        if (ret > 0) {

            aio_consume(af->writebuf, ret);
        }
        if (ret < 0) {
            return JimCheckStreamError(interp, af);
        }
        if (Jim_Length(af->writebuf)) {
#ifdef jim_ext_eventloop
            void *handler = Jim_FindFileHandler(interp, af->fd, JIM_EVENT_WRITABLE);
            if (handler == NULL) {
                Jim_CreateFileHandler(interp, af->fd, JIM_EVENT_WRITABLE, aio_autoflush, af, NULL);
                return JIM_OK;
            }
            else if (handler == af) {

                return JIM_OK;
            }
#endif

            Jim_SetResultString(interp, "send buffer is full", -1);
            return JIM_ERR;
        }
    }
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x38(%rsi), %rdi
leaq -0x1c(%rbp), %r14
movq %r14, %rsi
callq 0x7fc7
movl (%r14), %edx
xorl %r14d, %r14d
testl %edx, %edx
je 0x1314d
movq 0x28(%r15), %rcx
movq %r15, %rdi
movq %rax, %rsi
callq *(%rcx)
testl %eax, %eax
jle 0x130f6
movq 0x38(%r15), %rdi
movl %eax, %esi
callq 0x1303c
jmp 0x130f8
js 0x1313f
movq 0x38(%r15), %rdi
callq 0xa61a
testl %eax, %eax
je 0x1314d
leaq 0x14445(%rip), %rsi     # 0x27551
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x7363
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x13136
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
pushq $0x1
popq %r14
jmp 0x1314d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x12f69
movl %eax, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: stdio_writer
static int stdio_writer(struct AioFile *af, const char *buf, int len)
{
    int ret = write(af->fd, buf, len);
    if (ret < 0 && errno == EPIPE) {
        aio_consume(af->writebuf, Jim_Length(af->writebuf));
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl 0x18(%rdi), %edi
movslq %edx, %rdx
callq 0x6130
movq %rax, %rbx
testl %ebx, %ebx
jns 0x13219
callq 0x6080
cmpl $0x20, (%rax)
jne 0x13219
movq 0x38(%r14), %r14
movq %r14, %rdi
callq 0xa61a
movq %r14, %rdi
movl %eax, %esi
callq 0x1303c
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: stdio_reader
static int stdio_reader(struct AioFile *af, char *buf, int len, int nb)
{
    if (nb || af->timeout == 0 || JimReadableTimeout(af->fd, af->timeout) == JIM_OK) {

        int ret;

        errno = 0;
        ret = read(af->fd, buf, len);
        if (ret <= 0 && errno != EAGAIN && errno != EINTR) {
            af->flags |= AIO_EOF;
        }
        return ret;
    }
    errno = ETIMEDOUT;
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
callq 0x6080
movq %rax, %r14
andl $0x0, (%rax)
movl 0x18(%rbx), %edi
movslq %r15d, %rdx
movq %r12, %rsi
callq 0x62a0
testl %eax, %eax
jle 0x1325a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl (%r14), %ecx
cmpl $0x4, %ecx
je 0x13251
cmpl $0xb, %ecx
je 0x13251
orb $0x4, 0xc(%rbx)
jmp 0x13251
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: file_cmd_mtime
static int file_cmd_mtime(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    jim_stat_t sb;

    if (argc == 2) {
        jim_wide secs;
        if (Jim_GetWide(interp, argv[1], &secs) != JIM_OK) {
            return JIM_ERR;
        }
        return JimSetFileTimes(interp, Jim_String(argv[0]), secs * 1000000);
    }
    if (file_stat(interp, argv[0], &sb) != JIM_OK) {
        return JIM_ERR;
    }
    Jim_SetResultInt(interp, sb.st_mtime);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x2, %esi
jne 0x133b5
movq 0x8(%r14), %rsi
leaq -0xa0(%rbp), %rdx
movq %rbx, %rdi
callq 0xc979
testl %eax, %eax
jne 0x133cb
movq (%r14), %rdi
callq 0x7340
leaq 0x143ed(%rip), %rsi     # 0x27773
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x7363
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x133b0
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
jmp 0x133cb
movq (%r14), %rsi
leaq -0xa0(%rbp), %rdx
movq %rbx, %rdi
callq 0x13eb7
testl %eax, %eax
je 0x133da
pushq $0x1
popq %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x8212
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x13405
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %eax, %eax
jmp 0x133ce
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: file_cmd_dirname
static int file_cmd_dirname(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *objPtr = JimStripTrailingSlashes(interp, argv[0]);
    const char *path = Jim_String(objPtr);
    const char *p = strrchr(path, '/');

    if (!p) {
        Jim_SetResultString(interp, ".", -1);
    }
    else if (p[1] == 0) {

        Jim_SetResult(interp, objPtr);
    }
    else if (p == path) {
        Jim_SetResultString(interp, "/", -1);
    }
    else if (ISWINDOWS && p[-1] == ':') {

        Jim_SetResultString(interp, path, p - path + 1);
    }
    else {

        int len = JimPathLenNoTrailingSlashes(path, p - path);
        Jim_SetResultString(interp, path, len);
    }
    Jim_DecrRefCount(interp, objPtr);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdx), %rsi
callq 0x13f17
movq %rax, %r14
movq %rax, %rdi
callq 0x7340
movq %rax, %r15
pushq $0x2f
popq %rsi
movq %rax, %rdi
callq 0x61f0
testq %rax, %rax
je 0x134ba
cmpb $0x0, 0x1(%rax)
je 0x134c3
cmpq %r15, %rax
je 0x134d8
subl %r15d, %eax
movq %r15, %rdi
movl %eax, %esi
callq 0x13f6d
movq %rbx, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x7363
movq %rax, %r15
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jle 0x13501
jmp 0x13509
leaq 0x1424a(%rip), %rsi     # 0x2770b
jmp 0x134df
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
movq %r14, %r15
jmp 0x134fc
leaq 0x13e2e(%rip), %rsi     # 0x2730d
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x7363
movq %rax, %r15
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x2, %eax
jge 0x13509
movq %rbx, %rdi
callq 0x73bf
movq %r15, (%rbx)
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0x13527
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73bf
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: file_cmd_rootname
static int file_cmd_rootname(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    const char *path = Jim_String(argv[0]);
    const char *lastSlash = strrchr(path, '/');
    const char *p = strrchr(path, '.');

    if (p == NULL || (lastSlash != NULL && lastSlash > p)) {
        Jim_SetResult(interp, argv[0]);
    }
    else {
        Jim_SetResultString(interp, path, p - path);
    }
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rdi, %rbx
movq (%rdx), %rdi
callq 0x7340
movq %rax, %r14
pushq $0x2f
popq %rsi
movq %rax, %rdi
callq 0x61f0
movq %rax, %r12
pushq $0x2e
popq %rsi
movq %r14, %rdi
callq 0x61f0
testq %rax, %rax
je 0x1359c
cmpq %rax, %r12
ja 0x1359c
subl %r14d, %eax
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x7363
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jle 0x135b4
jmp 0x135bc
movq (%r15), %r14
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x2, %eax
jge 0x135bc
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: file_cmd_extension
static int file_cmd_extension(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *objPtr = JimStripTrailingSlashes(interp, argv[0]);
    const char *path = Jim_String(objPtr);
    const char *lastSlash = strrchr(path, '/');
    const char *p = strrchr(path, '.');

    if (p == NULL || (lastSlash != NULL && lastSlash >= p)) {
        p = "";
    }
    Jim_SetResultString(interp, p, -1);
    Jim_DecrRefCount(interp, objPtr);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdx), %rsi
callq 0x13f17
movq %rax, %r14
movq %rax, %rdi
callq 0x7340
movq %rax, %r15
pushq $0x2f
popq %rsi
movq %rax, %rdi
callq 0x61f0
movq %rax, %r12
pushq $0x2e
popq %rsi
movq %r15, %rdi
callq 0x61f0
cmpq %rax, %r12
leaq 0x16030(%rip), %rcx     # 0x29641
movq %rcx, %rsi
cmovbq %rax, %rsi
testq %rax, %rax
cmoveq %rcx, %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x7363
movq %rax, %r15
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x13649
movq %rbx, %rdi
callq 0x73bf
movq %r15, (%rbx)
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0x13667
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73bf
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: file_cmd_tail
static int file_cmd_tail(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *objPtr = JimStripTrailingSlashes(interp, argv[0]);
    const char *path = Jim_String(objPtr);
    const char *lastSlash = strrchr(path, '/');

    if (lastSlash) {
        Jim_SetResultString(interp, lastSlash + 1, -1);
    }
    else {
        Jim_SetResult(interp, objPtr);
    }
    Jim_DecrRefCount(interp, objPtr);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdx), %rsi
callq 0x13f17
movq %rax, %r14
movq %rax, %rdi
callq 0x7340
pushq $0x2f
popq %rsi
movq %rax, %rdi
callq 0x61f0
testq %rax, %rax
je 0x136fd
incq %rax
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7363
movq %rax, %r15
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x2, %eax
jge 0x136d2
movq %rbx, %rdi
callq 0x73bf
movq %r15, (%rbx)
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0x136f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73bf
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
movq %r14, %r15
cmpl $0x1, %eax
jle 0x136ca
jmp 0x136d2
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: file_cmd_split
static int file_cmd_split(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0);
    const char *path = Jim_String(argv[0]);

    if (*path == '/') {
        Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, "/", 1));
    }

    while (1) {

        while (*path == '/') {
            path++;
        }
        if (*path) {
            const char *pt = strchr(path, '/');
            if (pt) {
                Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, path, pt - path));
                path = pt;
                continue;
            }
            Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, path, -1));
        }
        break;
    }
    Jim_SetResult(interp, listObj);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x745b
movq %rax, %r14
movq (%r15), %rdi
callq 0x7340
movq %rax, %r15
cmpb $0x2f, (%rax)
jne 0x13767
leaq 0x13bbf(%rip), %rsi     # 0x2730d
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x7363
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x74ad
movq %r15, %r12
movzbl (%r12), %eax
cmpl $0x2f, %eax
jne 0x1377c
incq %r12
incl %r15d
jmp 0x1376a
testl %eax, %eax
jne 0x137b1
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1379d
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x2f
popq %rsi
movq %r12, %rdi
callq 0x61c0
testq %rax, %rax
je 0x137dd
movq %rax, %r13
movl %r13d, %edx
subl %r15d, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7363
movq %r13, %r15
jmp 0x13759
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7363
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x74ad
jmp 0x13780
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: file_cmd_normalize
static int file_cmd_normalize(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    const char *path = Jim_String(argv[0]);
    char *newname = Jim_Alloc(MAXPATHLEN);

    if (JimRealPath(path, newname, MAXPATHLEN)) {
        JimFixPath(newname);
        Jim_SetResult(interp, Jim_NewStringObjNoAlloc(interp, newname, -1));
        return JIM_OK;
    }
    Jim_Free(newname);
    Jim_SetResultFormatted(interp, "can't normalize \"%#s\": %s", argv[0], strerror(errno));
    return JIM_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdx), %rdi
callq 0x7340
movl $0x1000, %esi           # imm = 0x1000
xorl %edi, %edi
callq *0x1fa6b(%rip)          # 0x33288
movq %rax, %rdi
xorl %esi, %esi
callq *0x1fa60(%rip)          # 0x33288
movq (%r14), %r14
callq 0x6080
movl (%rax), %edi
callq 0x64b0
leaq 0x13f4f(%rip), %rsi     # 0x2778d
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x68a7
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: file_cmd_delete
static int file_cmd_delete(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    int force = Jim_CompareStringImmediate(interp, argv[0], "-force");

    if (force || Jim_CompareStringImmediate(interp, argv[0], "--")) {
        argc--;
        argv++;
    }

    while (argc--) {
        const char *path = Jim_String(argv[0]);

        if (unlink(path) == -1 && errno != ENOENT) {
            if (rmdir(path) == -1) {

                if (!force || Jim_EvalPrefix(interp, "file delete force", 1, argv) != JIM_OK) {
                    Jim_SetResultFormatted(interp, "couldn't delete file \"%s\": %s", path,
                        strerror(errno));
                    return JIM_ERR;
                }
            }
        }
        argv++;
    }
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movq (%rdx), %rsi
leaq 0x13d84(%rip), %rdx     # 0x277b5
callq 0x7223
movl %eax, -0x2c(%rbp)
testl %eax, %eax
jne 0x13a53
movq (%r14), %rsi
leaq 0x14bc8(%rip), %rdx     # 0x2860f
movq %rbx, %rdi
callq 0x7223
testl %eax, %eax
je 0x13a5a
decl %r15d
addq $0x8, %r14
subl $0x1, %r15d
jb 0x13ae8
movq (%r14), %rdi
callq 0x7340
movq %rax, %r12
movq %rax, %rdi
callq 0x6090
cmpl $-0x1, %eax
jne 0x13a56
callq 0x6080
cmpl $0x2, (%rax)
je 0x13a56
movq %rax, %r13
movq %r12, %rdi
callq 0x6170
cmpl $-0x1, %eax
jne 0x13a56
cmpl $0x0, -0x2c(%rbp)
je 0x13ac3
movq %rbx, %rdi
leaq 0x13d16(%rip), %rsi     # 0x277bc
pushq $-0x1
popq %rdx
callq 0x7363
movq %rbx, %rdi
movq %rax, %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0xf68f
testl %eax, %eax
je 0x13a56
movl (%r13), %edi
callq 0x64b0
leaq 0x13cfb(%rip), %rsi     # 0x277ce
movq %rbx, %rdi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x68a7
pushq $0x1
popq %rax
jmp 0x13aea
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: file_cmd_mkdir
static int file_cmd_mkdir(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    while (argc--) {
        char *path = Jim_StrDup(Jim_String(argv[0]));
        int rc = mkdir_all(path);

        Jim_Free(path);
        if (rc != 0) {
            Jim_SetResultFormatted(interp, "can't create directory \"%#s\": %s", argv[0],
                strerror(errno));
            return JIM_ERR;
        }
        argv++;
    }
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, -0x30(%rbp)
movl %esi, %ebx
xorl %r14d, %r14d
cmpl %r14d, %ebx
je 0x13b4c
movq (%r15,%r14,8), %rdi
callq 0x7340
movq %rax, %rdi
callq 0x9e18
movq %rax, %r12
movq %rax, %rdi
callq 0x13fe9
movl %eax, %r13d
movq %r12, %rdi
xorl %esi, %esi
callq *0x1f746(%rip)          # 0x33288
testl %r13d, %r13d
jne 0x13b50
incq %r14
jmp 0x13b13
xorl %eax, %eax
jmp 0x13b7b
movq (%r15,%r14,8), %r14
callq 0x6080
movl (%rax), %edi
callq 0x64b0
leaq 0x13c85(%rip), %rsi     # 0x277ec
movq -0x30(%rbp), %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x68a7
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: file_cmd_tempfile
static int file_cmd_tempfile(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    int fd = Jim_MakeTempFile(interp, (argc >= 1) ? Jim_String(argv[0]) : NULL, 0);

    if (fd < 0) {
        return JIM_ERR;
    }
    close(fd);

    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x13ba5
movq (%rdx), %rdi
callq 0x7340
movq %rax, %rsi
jmp 0x13ba7
xorl %esi, %esi
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x11963
testl %eax, %eax
js 0x13bc1
movl %eax, %edi
callq 0x6260
jmp 0x13bc5
pushq $0x1
popq %r14
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: file_cmd_rename
static int file_cmd_rename(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    const char *source;
    const char *dest;
    int force = 0;

    if (argc == 3) {
        if (!Jim_CompareStringImmediate(interp, argv[0], "-force")) {
            return -1;
        }
        force++;
        argv++;
        argc--;
    }

    source = Jim_String(argv[0]);
    dest = Jim_String(argv[1]);

    if (!force && access(dest, F_OK) == 0) {
        Jim_SetResultFormatted(interp, "error renaming \"%#s\" to \"%#s\": target exists", argv[0],
            argv[1]);
        return JIM_ERR;
    }
#if ISWINDOWS
    if (access(dest, F_OK) == 0) {

        remove(dest);
    }
#endif
    if (rename(source, dest) != 0) {
        Jim_SetResultFormatted(interp, "error renaming \"%#s\" to \"%#s\": %s", argv[0], argv[1],
            strerror(errno));
        return JIM_ERR;
    }

    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
cmpl $0x3, %esi
jne 0x13c03
movq (%r14), %rsi
leaq 0x13bc2(%rip), %rdx     # 0x277b5
movq %rbx, %rdi
callq 0x7223
testl %eax, %eax
je 0x13c70
addq $0x8, %r14
movq (%r14), %rdi
callq 0x7340
movq %rax, %r12
movq 0x8(%r14), %rdi
callq 0x7340
movq %rax, %r13
cmpl $0x3, %r15d
je 0x13c2e
movq %r13, %rdi
xorl %esi, %esi
callq 0x6430
testl %eax, %eax
je 0x13c74
movq %r12, %rdi
movq %r13, %rsi
callq 0x6440
testl %eax, %eax
je 0x13c6c
movq (%r14), %r15
movq 0x8(%r14), %r14
callq 0x6080
movl (%rax), %edi
callq 0x64b0
leaq 0x13be3(%rip), %rsi     # 0x2783a
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x68a7
jmp 0x13c8c
xorl %eax, %eax
jmp 0x13c8f
pushq $-0x1
jmp 0x13c8e
movq (%r14), %rdx
movq 0x8(%r14), %rcx
leaq 0x13b8b(%rip), %rsi     # 0x2780d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x68a7
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: file_cmd_stat
static int file_cmd_stat(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    jim_stat_t sb;

    if (file_stat(interp, argv[0], &sb) != JIM_OK) {
        return JIM_ERR;
    }
    return Jim_FileStoreStatData(interp, argc == 2 ? argv[1] : NULL, &sb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movq (%rdx), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x13eb7
testl %eax, %eax
je 0x13d34
pushq $0x1
popq %rax
jmp 0x13d51
cmpl $0x2, %r15d
jne 0x13d40
movq 0x8(%r14), %rsi
jmp 0x13d42
xorl %esi, %esi
leaq -0xa8(%rbp), %rdx
movq %rbx, %rdi
callq 0x90f0
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: file_cmd_type
static int file_cmd_type(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    jim_stat_t sb;

    if (file_lstat(interp, argv[0], &sb) != JIM_OK) {
        return JIM_ERR;
    }
    Jim_SetResultString(interp, JimGetFileType((int)sb.st_mode), -1);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movq (%rdx), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x13eb7
testl %eax, %eax
je 0x13d88
pushq $0x1
popq %rax
jmp 0x13dc5
movl -0x88(%rbp), %edi
callq 0x9344
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7363
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x13dc0
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: JimStripTrailingSlashes
static Jim_Obj *JimStripTrailingSlashes(Jim_Interp *interp, Jim_Obj *objPtr)
{
    int len = Jim_Length(objPtr);
    const char *path = Jim_String(objPtr);
    int i = JimPathLenNoTrailingSlashes(path, len);
    if (i != len) {
        objPtr = Jim_NewStringObj(interp, path, i);
    }
    Jim_IncrRefCount(objPtr);
    return objPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xa61a
movl %eax, %r12d
movq %rbx, %rdi
callq 0x7340
movq %rax, %r15
movq %rax, %rdi
movl %r12d, %esi
callq 0x13f6d
cmpl %r12d, %eax
je 0x13f5e
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x7363
movq %rax, %rbx
incl 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: mkdir_all
static int mkdir_all(char *path)
{
    int ok = 1;


    goto first;

    while (ok--) {

        {
            char *slash = strrchr(path, '/');

            if (slash && slash != path) {
                *slash = 0;
                if (mkdir_all(path) != 0) {
                    return -1;
                }
                *slash = '/';
            }
        }
      first:
        if (MKDIR_DEFAULT(path) == 0) {
            return 0;
        }
        if (errno == ENOENT) {

            continue;
        }

        if (errno == EEXIST) {
            jim_stat_t sb;

            if (Jim_Stat(path, &sb) == 0 && S_ISDIR(sb.st_mode)) {
                return 0;
            }

            errno = EEXIST;
        }

        break;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r14
pushq $-0x1
popq %rbx
pushq $0x2f
popq %r15
movl %ebx, %r13d
movq %r14, %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x60d0
testl %eax, %eax
je 0x14092
callq 0x6080
movq %rax, %r12
movl (%rax), %eax
cmpl $0x2, %eax
jne 0x14068
testl %r13d, %r13d
je 0x1409e
movq %r14, %rdi
movl %r15d, %esi
callq 0x61f0
movq %rax, %r12
testq %rax, %rax
setne %al
cmpq %r14, %r12
setne %cl
testb %cl, %al
je 0x14063
movb $0x0, (%r12)
movq %r14, %rdi
callq 0x13fe9
testl %eax, %eax
jne 0x1409e
movb $0x2f, (%r12)
incl %r13d
jmp 0x1400a
cmpl $0x11, %eax
jne 0x1409e
leaq -0xb8(%rbp), %rsi
movq %r14, %rdi
callq 0x61b0
testl %eax, %eax
jne 0x14096
movl $0xf000, %eax           # imm = 0xF000
andl -0xa0(%rbp), %eax
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x14096
xorl %ebx, %ebx
jmp 0x1409e
movl $0x11, (%r12)
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: JimDetachPids
static void JimDetachPids(struct WaitInfoTable *table, int numPids, const phandle_t *pidPtr)
{
    int j;

    for (j = 0; j < numPids; j++) {

        int i;
        for (i = 0; i < table->used; i++) {
            if (pidPtr[j] == table->info[i].phandle) {
                table->info[i].flags |= WI_DETACHED;
                break;
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
xorl %ecx, %ecx
cmpq %rsi, %rcx
je 0x14d69
movl 0xc(%rdi), %r8d
testl %r8d, %r8d
cmovlel %eax, %r8d
imulq $0xc, %r8, %r8
addq $0xc, %r8
xorl %r9d, %r9d
leaq 0xc(%r9), %r10
cmpq %r10, %r8
je 0x14d64
movl (%rdx,%rcx,4), %ebx
movq (%rdi), %r11
cmpl (%r11,%r9), %ebx
movq %r10, %r9
jne 0x14d46
orb $0x2, -0x4(%r11,%r10)
incq %rcx
jmp 0x14d2b
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: JimAppendStreamToString
static int JimAppendStreamToString(Jim_Interp *interp, int fd, Jim_Obj *strObj)
{
    char buf[256];
    int ret = 0;

    while (1) {
        int retval = read(fd, buf, sizeof(buf));
        if (retval > 0) {
            ret = 1;
            Jim_AppendString(interp, strObj, buf, retval);
        }
        if (retval <= 0) {
            break;
        }
    }
    close(fd);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
xorl %r13d, %r13d
leaq -0x130(%rbp), %r12
movl $0x100, %edx            # imm = 0x100
movl %ebx, %edi
movq %r12, %rsi
callq 0x62a0
testl %eax, %eax
jle 0x14dbb
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %eax, %ecx
callq 0x823a
pushq $0x1
popq %r13
jmp 0x14d92
movl %ebx, %edi
callq 0x6260
movl %r13d, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: JimGetChannelFd
static int JimGetChannelFd(Jim_Interp *interp, const char *name)
{
    Jim_Obj *objv[2];

    objv[0] = Jim_NewStringObj(interp, name, -1);
    objv[1] = Jim_NewStringObj(interp, "getfd", -1);

    if (Jim_EvalObjVector(interp, 2, objv) == JIM_OK) {
        jim_wide fd;
        if (Jim_GetWide(interp, Jim_GetResult(interp), &fd) == JIM_OK) {
            return fd;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
pushq $-0x1
popq %rbx
movl %ebx, %edx
callq 0x7363
leaq -0x30(%rbp), %r15
movq %rax, (%r15)
leaq 0x1261e(%rip), %rsi     # 0x2741d
movq %r14, %rdi
movl %ebx, %edx
callq 0x7363
movq %rax, 0x8(%r15)
pushq $0x2
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xf32e
testl %eax, %eax
jne 0x14e35
movq (%r14), %rsi
leaq -0x20(%rbp), %rdx
movq %r14, %rdi
callq 0xc979
testl %eax, %eax
jne 0x14e35
movl -0x20(%rbp), %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: JimWaitRemove
static int JimWaitRemove(struct WaitInfoTable *table, phandle_t phandle)
{
    int i;


    for (i = 0; i < table->used; i++) {
        if (phandle == table->info[i].phandle) {
            if (i != table->used - 1) {
                table->info[i] = table->info[table->used - 1];
            }
            table->used--;
            return 0;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0xc(%rdi), %rcx
xorl %edx, %edx
testl %ecx, %ecx
movl $0x0, %eax
cmovgl %ecx, %eax
leal -0x1(%rcx), %r8d
imulq $0xc, %rax, %r9
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rdx, %r9
je 0x14ea2
movq (%rdi), %r10
cmpl %esi, (%r10,%rdx)
je 0x14e7a
decl %r8d
addq $0xc, %rdx
jmp 0x14e63
decq %rcx
testl %r8d, %r8d
je 0x14e9d
addq %r10, %rdx
imulq $0xc, %rcx, %rax
movl 0x8(%r10,%rax), %ecx
movl %ecx, 0x8(%rdx)
movq (%r10,%rax), %rax
movq %rax, (%rdx)
movl 0xc(%rdi), %ecx
decl %ecx
movl %ecx, 0xc(%rdi)
xorl %eax, %eax
popq %rbp
retq