LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rax
movq %rdx, %r12
movq %rdi, %r14
movq 0x1b8(%rdi), %r13
xorl %ebx, %ebx
movb $0x1, %r15b
cmpl $0x2, %esi
jne 0x14214
movq 0x8(%r12), %rsi
leaq 0x16871(%rip), %rdx     # 0x2aa36
movq %r14, %rdi
callq 0x73c6
testl %eax, %eax
jne 0x14214
movq 0x8(%r12), %rsi
leaq 0x17338(%rip), %rdx     # 0x2b515
movq %r14, %rdi
callq 0x73c6
testl %eax, %eax
je 0x141f3
movl $0x1, %ebx
xorl %r15d, %r15d
jmp 0x14214
movq 0x8(%r12), %rsi
leaq 0x180ec(%rip), %rdx     # 0x2c2eb
movq %r14, %rdi
callq 0x73c6
movl $0x2, %ebx
testl %eax, %eax
je 0x142bf
movq %r13, -0x30(%rbp)
movq (%r12), %r13
leaq 0x210cd(%rip), %rax     # 0x352f0
cmpq %rax, 0x8(%r13)
je 0x14243
movl $0x1, %r12d
movq %r14, %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0xd6c3
testl %eax, %eax
jne 0x142ad
movq 0x18(%r13), %r12
testq %r12, %r12
setne %al
orb %al, %r15b
cmpb $0x1, %r15b
movq -0x30(%rbp), %r15
jne 0x14265
movq %r14, %rdi
movq %r15, %rsi
callq 0x149ff
movl 0x18(%r15), %edi
movq %r12, %rsi
movl %ebx, %edx
callq 0x64a0
cmpq $-0x1, %rax
je 0x1429c
movq 0x30(%r15), %rsi
testq %rsi, %rsi
je 0x14292
movq %r14, %rdi
callq 0x758c
movq $0x0, 0x30(%r15)
andb $-0x5, 0xc(%r15)
xorl %r12d, %r12d
jmp 0x142ad
movq (%r15), %rsi
movq %r14, %rdi
callq 0x148fa
movl $0x1, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
jmp 0x142ad
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x1b8(%rdi), %r14
testl %esi, %esi
je 0x143c5
movq (%rdx), %r15
leaq 0x20f57(%rip), %rax     # 0x352f0
cmpq %rax, 0x8(%r15)
je 0x143b9
movl $0x1, %r12d
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0xd6c3
testl %eax, %eax
jne 0x14415
movl 0x18(%r15), %esi
movq %r14, %rdi
callq 0x147c8
movl 0xc(%r14), %r15d
shrl $0x4, %r15d
andl $0x1, %r15d
movq %rbx, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x20f0d(%rip), %rax     # 0x352f0
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movq %r15, 0x18(%r14)
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1440f
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %r12d, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rax
movq %rdi, %rbx
movq 0x1b8(%rdi), %r14
testl %esi, %esi
je 0x144d4
movq %rdx, %r15
movl %esi, %r12d
movq (%rdx), %rsi
leaq 0x8(%r14), %r13
leaq 0x217ab(%rip), %rdx     # 0x35c00
movq %rbx, %rdi
movq %r13, %rcx
xorl %r8d, %r8d
movl $0x1, %r9d
callq 0x7eac
testl %eax, %eax
je 0x14478
movl $0x1, %r15d
jmp 0x1457d
movl (%r13), %eax
movl %eax, %ecx
xorl $0x2, %ecx
xorl $0x2, %r12d
orl %ecx, %r12d
jne 0x144cc
movq 0x8(%r15), %r12
leaq 0x20e5b(%rip), %rax     # 0x352f0
cmpq %rax, 0x8(%r12)
je 0x144ba
movl $0x1, %r15d
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0xd6c3
testl %eax, %eax
jne 0x1457d
movq 0x18(%r12), %rax
testq %rax, %rax
jle 0x1446d
movq %rax, 0x50(%r14)
movl 0x8(%r14), %eax
testl %eax, %eax
je 0x1458f
movq %rbx, %rdi
callq 0xae38
movq %rax, %r15
leaq 0x20e82(%rip), %rax     # 0x35368
movq %rax, 0x8(%r15)
movq $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movslq 0x8(%r14), %rax
leaq 0x216fc(%rip), %rcx     # 0x35c00
movq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7683
cmpl $0x2, 0x8(%r14)
jne 0x1455a
movq 0x50(%r14), %r14
movq %rbx, %rdi
callq 0xae38
leaq 0x20db3(%rip), %rcx     # 0x352f0
movq %rcx, 0x8(%rax)
movq $0x0, (%rax)
movq %r14, 0x18(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7683
incl 0x10(%r15)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x14577
movq %rbx, %rdi
callq 0x758c
movq %r15, (%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x149ff
movl $0x1, %r15d
testl %eax, %eax
jne 0x1457d
jmp 0x144d4
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
movq %rdi, %rbx
movq 0x1b8(%rdi), %r12
testl %esi, %esi
je 0x14639
movq (%rdx), %r14
leaq 0x20cfa(%rip), %rax     # 0x352f0
cmpq %rax, 0x8(%r14)
je 0x14616
movl $0x1, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0xd6c3
testl %eax, %eax
jne 0x14682
movq 0x18(%r14), %rsi
testq %rsi, %rsi
jle 0x1468e
movq %rsi, 0x48(%r12)
movq 0x40(%r12), %rdi
testq %rdi, %rdi
je 0x14639
callq *0x22c54(%rip)          # 0x37288
movq %rax, 0x40(%r12)
movq 0x48(%r12), %r15
movq %rbx, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x20ca0(%rip), %rax     # 0x352f0
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movq %r15, 0x18(%r14)
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1467c
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %r15d
jmp 0x14682
// File: /workspace/github_c_makefile_star2_O3/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), %r14
testq %r14, %r14
jne 0x146e4
movq -0x30(%rbp), %rdi
callq 0xae38
movq %rax, %r14
leaq 0x22bcb(%rip), %rax     # 0x37298
movq %rax, (%r14)
movl $0x0, 0x14(%r14)
movq $0x0, 0x8(%r14)
movq %r14, 0x30(%rbx)
testl %r12d, %r12d
js 0x14703
cmpq $0x0, (%r14)
jne 0x146f9
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
subl 0x14(%r14), %r12d
jle 0x14795
movl %r13d, %r15d
andl $0x10, %r15d
testl %r12d, %r12d
je 0x14795
testb $0x4, 0xc(%rbx)
jne 0x14795
cmpl $-0x1, %r12d
je 0x14733
movslq %r12d, %rax
movq 0x48(%rbx), %rsi
movl %esi, %r14d
cmpq %rax, %rsi
jb 0x1473a
movl %r12d, %r14d
jmp 0x1473a
movq 0x48(%rbx), %rsi
movl %esi, %r14d
movq 0x40(%rbx), %rax
testq %rax, %rax
jne 0x1474f
xorl %edi, %edi
callq *0x22b3d(%rip)          # 0x37288
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 0x147a8
movl %eax, %r14d
movq 0x30(%rbx), %rsi
movq 0x40(%rbx), %rdx
movq -0x30(%rbp), %rdi
movl %eax, %ecx
callq 0x86a0
movl %r12d, %eax
subl %r14d, %eax
cmpl $-0x1, %r12d
cmovnel %eax, %r12d
testb $0x20, %r13b
je 0x1470a
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %ecx
testb $0x20, %r13b
jne 0x14797
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x148b7
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
jmp 0x14797
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
movq %rsi, %r14
testl %edx, %edx
js 0x1489e
movq 0x30(%r14), %r12
testq %r12, %r12
je 0x1489e
movl %edx, %ebx
movq %rdi, %r15
cmpq $0x0, (%r12)
jne 0x14859
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
cmpl %ebx, 0x14(%r12)
jle 0x1489e
movq 0x30(%r14), %r12
testq %r12, %r12
je 0x148b3
movq (%r12), %rsi
testq %rsi, %rsi
jne 0x14881
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
movq (%r12), %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0x7508
movq %rax, %r15
movq 0x30(%r14), %rdi
movl %ebx, %esi
callq 0x1498c
movq %r15, %rax
jmp 0x148aa
movq 0x30(%r14), %rax
movq $0x0, 0x30(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x148aa
// File: /workspace/github_c_makefile_star2_O3/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 0x148ef
movq %rsi, %r15
movq %rdi, %r14
movq 0x28(%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
testl %eax, %eax
je 0x148ef
movl %eax, %r12d
movq (%r15), %rsi
movq %r14, %rdi
callq 0x148fa
movl %r12d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1496a
testq %r14, %r14
je 0x14933
leaq 0x16b97(%rip), %rsi     # 0x2b4b6
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x6923
movq %rbx, %rdi
movq %rax, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
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 0x14962
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x149c1
movl %esi, %ebx
movl 0x14(%r14), %eax
subl %esi, %eax
jl 0x149e0
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 0x16af6(%rip), %rdi     # 0x2b4be
leaq 0x161dc(%rip), %rsi     # 0x2abab
leaq 0x16af6(%rip), %rcx     # 0x2b4cc
movl $0x8f2, %edx            # imm = 0x8F2
callq 0x6220
leaq 0x16b06(%rip), %rdi     # 0x2b4ed
leaq 0x161bd(%rip), %rsi     # 0x2abab
leaq 0x16ad7(%rip), %rcx     # 0x2b4cc
movl $0x8f3, %edx            # imm = 0x8F3
callq 0x6220
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq 0x38(%rsi), %r12
cmpq $0x0, (%r12)
jne 0x14a26
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
movl 0x14(%r12), %edx
xorl %r14d, %r14d
testl %edx, %edx
je 0x14aa9
movq (%r12), %rsi
movq 0x28(%r15), %rax
movq %r15, %rdi
callq *(%rax)
testl %eax, %eax
jle 0x14a50
movq 0x38(%r15), %rdi
movl %eax, %esi
callq 0x1498c
jmp 0x14a52
js 0x14ab5
movq 0x38(%r15), %r15
cmpq $0x0, (%r15)
jne 0x14a66
movq 0x8(%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
cmpl $0x0, 0x14(%r15)
je 0x14aa9
leaq 0x16a8d(%rip), %rsi     # 0x2b501
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
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 0x14aa0
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
movl $0x1, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x148b7
// File: /workspace/github_c_makefile_star2_O3/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 0x14b90
callq 0x6080
cmpl $0x20, (%rax)
jne 0x14b90
movq 0x38(%r14), %r14
cmpq $0x0, (%r14)
jne 0x14b84
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movl 0x14(%r14), %esi
movq %r14, %rdi
callq 0x1498c
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x0, (%rax)
movl 0x18(%rbx), %edi
movslq %r15d, %rdx
movq %r12, %rsi
callq 0x62a0
testl %eax, %eax
jle 0x14bd4
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl (%r14), %ecx
cmpl $0x4, %ecx
je 0x14bcb
cmpl $0xb, %ecx
je 0x14bcb
orb $0x4, 0xc(%rbx)
jmp 0x14bcb
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: file_cmd_atime
static int file_cmd_atime(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;
    }
    Jim_SetResultInt(interp, sb.st_atime);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq (%rdx), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x15ae6
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x14cd6
movq -0x60(%rbp), %r15
movq %rbx, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x2064b(%rip), %rax     # 0x352f0
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movq %r15, 0x18(%r14)
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x14cd1
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x2, %esi
jne 0x14d75
movq 0x8(%r14), %rsi
leaq 0x205e6(%rip), %rax     # 0x352f0
cmpq %rax, 0x8(%rsi)
je 0x14d27
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %edx
callq 0xd6c3
testl %eax, %eax
jne 0x14d91
movq (%r14), %rdi
cmpq $0x0, (%rdi)
jne 0x14d37
movq 0x8(%rdi), %rax
callq *0x18(%rax)
leaq 0x169e5(%rip), %rsi     # 0x2b723
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
movl $0x1, %r15d
cmpl $0x2, %eax
jge 0x14d70
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
jmp 0x14d91
movq (%r14), %rsi
leaq -0xa8(%rbp), %rdx
movq %rbx, %rdi
callq 0x15ae6
movl $0x1, %r15d
testl %eax, %eax
je 0x14da2
movl %r15d, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq -0x50(%rbp), %r15
movq %rbx, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x20538(%rip), %rax     # 0x352f0
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movq %r15, 0x18(%r14)
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
xorl %r15d, %r15d
cmpl $0x1, %eax
jle 0x14d68
jmp 0x14d70
// File: /workspace/github_c_makefile_star2_O3/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 0x15b52
movq %rax, %r14
movq (%rax), %r15
testq %r15, %r15
jne 0x14e93
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %r15
movq %r15, %rdi
movl $0x2f, %esi
callq 0x61f0
testq %rax, %rax
je 0x14ef7
cmpb $0x0, 0x1(%rax)
je 0x14f00
cmpq %r15, %rax
je 0x14f15
subl %r15d, %eax
cmpl $0x2, %eax
jl 0x14ed1
movl %eax, %ecx
cmpb $0x2f, -0x1(%r15,%rcx)
jne 0x14ed1
leal -0x1(%rax), %ecx
cmpl $0x2, %eax
movl %ecx, %eax
jg 0x14eb8
movl $0x1, %eax
movq %rbx, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x7508
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 0x14f40
jmp 0x14f48
leaq 0x167bd(%rip), %rsi     # 0x2b6bb
jmp 0x14f1c
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
movq %r14, %r15
jmp 0x14f3b
leaq 0x163a1(%rip), %rsi     # 0x2b2bd
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
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 0x14f48
movq %rbx, %rdi
callq 0x758c
movq %r15, (%rbx)
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0x14f66
movq %rbx, %rdi
movq %r14, %rsi
callq 0x758c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r14
movq %rdi, %rbx
movq (%rdx), %r12
movq (%r12), %r15
testq %r15, %r15
jne 0x14f9f
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
movq (%r12), %r15
movq %r15, %rdi
movl $0x2f, %esi
callq 0x61f0
movq %rax, %r12
movq %r15, %rdi
movl $0x2e, %esi
callq 0x61f0
testq %rax, %rax
je 0x14fef
cmpq %rax, %r12
ja 0x14fef
subl %r15d, %eax
movq %rbx, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x7508
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 0x15007
jmp 0x1500f
movq (%r14), %r14
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x2, %eax
jge 0x1500f
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x15b52
movq %rax, %r14
movq (%rax), %r15
testq %r15, %r15
jne 0x1504b
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %r15
movq %r15, %rdi
movl $0x2f, %esi
callq 0x61f0
movq %rax, %r12
movq %r15, %rdi
movl $0x2e, %esi
callq 0x61f0
cmpq %rax, %r12
leaq 0x1857f(%rip), %rcx     # 0x2d5f1
movq %rcx, %rsi
cmovbq %rax, %rsi
testq %rax, %rax
cmoveq %rcx, %rsi
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
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 0x150ac
movq %rbx, %rdi
callq 0x758c
movq %r15, (%rbx)
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0x150ca
movq %rbx, %rdi
movq %r14, %rsi
callq 0x758c
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x15b52
movq %rax, %r14
movq (%rax), %rdi
testq %rdi, %rdi
jne 0x15102
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %rdi
movl $0x2f, %esi
callq 0x61f0
testq %rax, %rax
je 0x1516e
incq %rax
movq %rbx, %rdi
movq %rax, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
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 0x15143
movq %rbx, %rdi
callq 0x758c
movq %r15, (%rbx)
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0x15161
movq %rbx, %rdi
movq %r14, %rsi
callq 0x758c
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 0x1513b
jmp 0x15143
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
movq %rdx, %r15
movq %rdi, %rbx
callq 0xae38
movq %rax, %r14
leaq 0x201c0(%rip), %rax     # 0x35368
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movq (%r15), %r12
movq (%r12), %r15
testq %r15, %r15
jne 0x151d6
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
movq (%r12), %r15
cmpb $0x2f, (%r15)
jne 0x1525b
movq %rbx, %rdi
callq 0xae38
movq %rax, %r12
movl $0x2, %esi
xorl %edi, %edi
callq *0x22094(%rip)          # 0x37288
movw $0x2f, (%rax)
movq %rax, (%r12)
movl $0x1, 0x14(%r12)
movq $0x0, 0x8(%r12)
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x7683
jmp 0x1525b
movq %r15, %rdi
movl $0x2f, %esi
callq 0x61c0
testq %rax, %rax
je 0x1526a
movq %rax, %r12
movl %r12d, %edx
subl %r15d, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7508
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7683
movq %r12, %r15
jmp 0x1525b
incq %r15
movzbl (%r15), %eax
cmpl $0x2f, %eax
je 0x15258
testl %eax, %eax
jne 0x1521f
jmp 0x15288
movq %rbx, %rdi
movq %r15, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7683
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x152a5
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
cmpq $0x0, (%rdi)
jne 0x152d0
movq 0x8(%rdi), %rax
callq *0x18(%rax)
movl $0x1000, %esi           # imm = 0x1000
xorl %edi, %edi
callq *0x21fab(%rip)          # 0x37288
movq %rax, %rdi
xorl %esi, %esi
callq *0x21fa0(%rip)          # 0x37288
movq (%r14), %r14
callq 0x6080
movl (%rax), %edi
callq 0x64b0
leaq 0x1643f(%rip), %rsi     # 0x2b73d
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x6923
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x28, %rsp
movq %rdx, %rbx
movl %esi, %r12d
movq (%rdx), %rsi
leaq 0x16259(%rip), %rdx     # 0x2b765
movq %rdi, -0x30(%rbp)
callq 0x73c6
movl %eax, -0x3c(%rbp)
testl %eax, %eax
jne 0x15533
movq (%rbx), %rsi
leaq 0x17099(%rip), %rdx     # 0x2c5bf
movq -0x30(%rbp), %rdi
callq 0x73c6
testl %eax, %eax
je 0x1553a
decl %r12d
addq $0x8, %rbx
testl %r12d, %r12d
je 0x1560f
movl %r12d, %r15d
xorl %r14d, %r14d
movq %rbx, -0x48(%rbp)
movq (%rbx,%r14,8), %r12
movq (%r12), %r13
testq %r13, %r13
jne 0x15569
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
movq (%r12), %r13
movq %r13, %rdi
callq 0x6090
cmpl $-0x1, %eax
jne 0x15603
callq 0x6080
cmpl $0x2, (%rax)
je 0x15603
movq %rax, %r12
movq %r13, %rdi
callq 0x6170
cmpl $-0x1, %eax
jne 0x15603
cmpl $0x0, -0x3c(%rbp)
je 0x15620
movq -0x30(%rbp), %rdi
leaq 0x161c3(%rip), %rsi     # 0x2b76c
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq %rax, -0x38(%rbp)
movl $0x10, %esi
xorl %edi, %edi
callq *0x21cc4(%rip)          # 0x37288
movq %rax, %rbx
movq -0x38(%rbp), %rax
movq %rax, (%rbx)
movq -0x48(%rbp), %rax
movq (%rax,%r14,8), %rax
movq %rax, 0x8(%rbx)
movq -0x30(%rbp), %rdi
movl $0x2, %esi
movq %rbx, %rdx
callq 0x10431
movl %eax, -0x38(%rbp)
movq %rbx, %rdi
movq -0x48(%rbp), %rbx
xorl %esi, %esi
callq *0x21c8b(%rip)          # 0x37288
cmpl $0x0, -0x38(%rbp)
jne 0x15620
incq %r14
cmpl %r14d, %r15d
jne 0x1554d
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl (%r12), %edi
callq 0x64b0
leaq 0x1614e(%rip), %rsi     # 0x2b77e
movq -0x30(%rbp), %rdi
movq %r13, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x6923
movl $0x1, %eax
jmp 0x15611
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
je 0x156e5
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, -0x30(%rbp)
movl %esi, %eax
movq %rax, -0x38(%rbp)
xorl %ebx, %ebx
movq (%r14,%rbx,8), %r12
movq (%r12), %r15
testq %r15, %r15
jne 0x1568c
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
movq (%r12), %r15
movq %r15, %rdi
callq 0x6180
movq %rax, %r12
incl %eax
movslq %eax, %rsi
xorl %edi, %edi
callq *0x21be4(%rip)          # 0x37288
movq %rax, %r13
movslq %r12d, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x6320
movb $0x0, (%r13,%r12)
movq %r13, %rdi
callq 0x15c5b
movl %eax, %r15d
movq %r13, %rdi
xorl %esi, %esi
callq *0x21bb4(%rip)          # 0x37288
testl %r15d, %r15d
jne 0x156e8
incq %rbx
cmpl %ebx, -0x38(%rbp)
jne 0x15670
xorl %eax, %eax
jmp 0x15715
xorl %eax, %eax
retq
movq (%r14,%rbx,8), %r14
callq 0x6080
movl (%rax), %edi
callq 0x64b0
leaq 0x1609d(%rip), %rsi     # 0x2b79c
movq -0x30(%rbp), %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x6923
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1574c
movq (%rdx), %r14
movq (%r14), %rsi
testq %rsi, %rsi
jne 0x1574e
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %rsi
jmp 0x1574e
xorl %esi, %esi
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12f54
testl %eax, %eax
js 0x15768
movl %eax, %edi
callq 0x6260
jmp 0x1576e
movl $0x1, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x157b0
movq (%r14), %rsi
leaq 0x15fc9(%rip), %rdx     # 0x2b765
movq %rbx, %rdi
callq 0x73c6
testl %eax, %eax
je 0x1583e
addq $0x8, %r14
movq %rbx, -0x30(%rbp)
movq (%r14), %r13
movq (%r13), %r12
testq %r12, %r12
jne 0x157ce
movq 0x8(%r13), %rax
movq %r13, %rdi
callq *0x18(%rax)
movq (%r13), %r12
movq 0x8(%r14), %rbx
movq (%rbx), %r13
testq %r13, %r13
jne 0x157e7
movq 0x8(%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq (%rbx), %r13
cmpl $0x3, %r15d
je 0x157fb
movq %r13, %rdi
xorl %esi, %esi
callq 0x6430
testl %eax, %eax
je 0x15845
movq %r12, %rdi
movq %r13, %rsi
callq 0x6440
testl %eax, %eax
je 0x1583a
movq (%r14), %rbx
movq 0x8(%r14), %r14
callq 0x6080
movl (%rax), %edi
callq 0x64b0
leaq 0x15fc6(%rip), %rsi     # 0x2b7ea
movq -0x30(%rbp), %rdi
movq %rbx, %rdx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x6923
jmp 0x1585e
xorl %eax, %eax
jmp 0x15863
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x15863
movq (%r14), %rdx
movq 0x8(%r14), %rcx
leaq 0x15f6a(%rip), %rsi     # 0x2b7bd
movq -0x30(%rbp), %rdi
xorl %eax, %eax
callq 0x6923
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: file_cmd_size
static int file_cmd_size(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;
    }
    Jim_SetResultInt(interp, sb.st_size);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq (%rdx), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x15ae6
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x158e6
movq -0x78(%rbp), %r15
movq %rbx, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x1fa3b(%rip), %rax     # 0x352f0
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movq %r15, 0x18(%r14)
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x158e1
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: file_cmd_isdirectory
static int file_cmd_isdirectory(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    jim_stat_t sb;
    int ret = 0;

    if (file_stat(interp, argv[0], &sb) == JIM_OK) {
        ret = S_ISDIR(sb.st_mode);
    }
    Jim_SetResultInt(interp, ret);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq (%rdx), %rsi
leaq -0xa8(%rbp), %r14
movq %r14, %rdx
callq 0x15ae6
movl 0x18(%r14), %ecx
andl $0xf000, %ecx           # imm = 0xF000
xorl $0x4000, %ecx           # imm = 0x4000
xorl %r15d, %r15d
orl %eax, %ecx
sete %r15b
movq %rbx, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x1f8d8(%rip), %rax     # 0x352f0
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movq %r15, 0x18(%r14)
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x15a44
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: file_cmd_isfile
static int file_cmd_isfile(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    jim_stat_t sb;
    int ret = 0;

    if (file_stat(interp, argv[0], &sb) == JIM_OK) {
        ret = S_ISREG(sb.st_mode);
    }
    Jim_SetResultInt(interp, ret);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq (%rdx), %rsi
leaq -0xa8(%rbp), %r14
movq %r14, %rdx
callq 0x15ae6
movl 0x18(%r14), %ecx
andl $0xf000, %ecx           # imm = 0xF000
xorl $0x8000, %ecx           # imm = 0x8000
xorl %r15d, %r15d
orl %eax, %ecx
sete %r15b
movq %rbx, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x1f849(%rip), %rax     # 0x352f0
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movq %r15, 0x18(%r14)
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x15ad3
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: file_stat
static int file_stat(Jim_Interp *interp, Jim_Obj *filename, jim_stat_t *sb)
{
    const char *path = Jim_String(filename);

    if (Jim_Stat(path, sb) == -1) {
        Jim_SetResultFormatted(interp, "could not read \"%#s\": %s", filename, strerror(errno));
        return JIM_ERR;
    }
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
testq %rdi, %rdi
jne 0x15b0e
movq 0x8(%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x61b0
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
jne 0x15b47
callq 0x6080
movl (%rax), %edi
callq 0x64b0
leaq 0x15bd8(%rip), %rsi     # 0x2b70a
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x6923
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x15b70
movl 0x14(%rbx), %r15d
jmp 0x15b93
movq 0x8(%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq (%rbx), %rsi
movl 0x14(%rbx), %r15d
testq %rsi, %rsi
jne 0x15b93
movq 0x8(%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq (%rbx), %rsi
cmpl $0x2, %r15d
jl 0x15bc4
movl %r15d, %edx
movl %edx, %eax
cmpb $0x2f, -0x1(%rsi,%rax)
jne 0x15bb4
leal -0x1(%rdx), %eax
cmpl $0x2, %edx
movl %eax, %edx
jg 0x15b9c
movl $0x1, %edx
cmpl %r15d, %edx
je 0x15bc4
movq %r14, %rdi
callq 0x7508
movq %rax, %rbx
incl 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x60d0
testl %eax, %eax
je 0x15ce7
movl $0xfffffffe, %r13d      # imm = 0xFFFFFFFE
callq 0x6080
movq %rax, %rbx
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl (%rbx), %eax
cmpl $0x2, %eax
jne 0x15cec
incl %r13d
je 0x15d1c
movq %r14, %rdi
movl $0x2f, %esi
callq 0x61f0
movq %rax, %r12
testq %rax, %rax
sete %al
cmpq %r14, %r12
sete %cl
orb %al, %cl
jne 0x15cd6
movb $0x0, (%r12)
movq %r14, %rdi
callq 0x15c5b
testl %eax, %eax
jne 0x15d1c
movb $0x2f, (%r12)
movq %r14, %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x60d0
testl %eax, %eax
jne 0x15c94
xorl %r15d, %r15d
jmp 0x15d1c
cmpl $0x11, %eax
jne 0x15d1c
leaq -0xb8(%rbp), %rsi
movq %r14, %rdi
callq 0x61b0
testl %eax, %eax
jne 0x15d16
movl $0xf000, %eax           # imm = 0xF000
andl -0xa0(%rbp), %eax
cmpl $0x4000, %eax           # imm = 0x4000
je 0x15ce7
movl $0x11, (%rbx)
movl %r15d, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
leaq -0x120(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
movl %ebx, %edi
callq 0x62a0
testl %eax, %eax
jle 0x16bd5
leaq -0x120(%rbp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %eax, %ecx
callq 0x86a0
movl $0x100, %edx            # imm = 0x100
movl %ebx, %edi
movq %r12, %rsi
callq 0x62a0
testl %eax, %eax
jg 0x16baa
movl $0x1, %r14d
jmp 0x16bd8
xorl %r14d, %r14d
movl %ebx, %edi
callq 0x6260
movl %r14d, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq