LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x14dfd
testq %r14, %r14
je 0x14dc6
leaq 0x1775f(%rip), %rsi     # 0x2c511
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x692d
movq %rbx, %rdi
movq %rax, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
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 0x14df5
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x14e54
movl %esi, %ebx
movl 0x14(%r14), %eax
subl %esi, %eax
jl 0x14e73
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 0x176be(%rip), %rdi     # 0x2c519
leaq 0x16da1(%rip), %rsi     # 0x2bc03
leaq 0x176be(%rip), %rcx     # 0x2c527
movl $0x8f2, %edx            # imm = 0x8F2
callq 0x6220
leaq 0x176ce(%rip), %rdi     # 0x2c548
leaq 0x16d82(%rip), %rsi     # 0x2bc03
leaq 0x1769f(%rip), %rcx     # 0x2c527
movl $0x8f3, %edx            # imm = 0x8F3
callq 0x6220
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq %rdi, %rbx
movq 0x38(%rsi), %r15
cmpq $0x0, (%r15)
jne 0x14eb6
movq 0x8(%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
movl 0x14(%r15), %edx
testl %edx, %edx
je 0x14f53
movq (%r15), %rsi
movq 0x28(%r14), %rax
movq %r14, %rdi
callq *(%rax)
movl %eax, %r15d
testl %eax, %eax
jle 0x14ee1
movq 0x38(%r14), %rdi
movl %r15d, %esi
callq 0x14e1f
testl %r15d, %r15d
js 0x14f3e
movq 0x38(%r14), %r14
cmpq $0x0, (%r14)
jne 0x14efa
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
cmpl $0x0, 0x14(%r14)
je 0x14f4d
leaq 0x17654(%rip), %rsi     # 0x2c55c
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
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 0x14f34
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
movl $0x1, %eax
jmp 0x14f49
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14d4a
xorl %ecx, %ecx
jmp 0x14f4f
movb $0x1, %cl
testb %cl, %cl
je 0x14f55
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x15028
callq 0x6080
cmpl $0x20, (%rax)
jne 0x15028
movq 0x38(%r14), %r14
cmpq $0x0, (%r14)
jne 0x1501c
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movl 0x14(%r14), %esi
movq %r14, %rdi
callq 0x14e1f
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1506c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl (%r14), %ecx
cmpl $0x4, %ecx
je 0x15063
cmpl $0xb, %ecx
je 0x15063
orb $0x4, 0xc(%rbx)
jmp 0x15063
// File: /workspace/github_c_makefile_star2_O1/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 0x15f54
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x1516e
movq -0x60(%rbp), %r15
movq %rbx, %rdi
callq 0xae58
movq %rax, %r14
leaq 0x211a3(%rip), %rax     # 0x362e0
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 0x15169
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1520d
movq 0x8(%r14), %rsi
leaq 0x2113e(%rip), %rax     # 0x362e0
cmpq %rax, 0x8(%rsi)
je 0x151bf
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %edx
callq 0xd6d7
testl %eax, %eax
jne 0x15229
movq (%r14), %rdi
cmpq $0x0, (%rdi)
jne 0x151cf
movq 0x8(%rdi), %rax
callq *0x18(%rax)
leaq 0x175a8(%rip), %rsi     # 0x2c77e
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
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 0x15208
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
jmp 0x15229
movq (%r14), %rsi
leaq -0xa8(%rbp), %rdx
movq %rbx, %rdi
callq 0x15f54
movl $0x1, %r15d
testl %eax, %eax
je 0x1523a
movl %r15d, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq -0x50(%rbp), %r15
movq %rbx, %rdi
callq 0xae58
movq %rax, %r14
leaq 0x21090(%rip), %rax     # 0x362e0
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 0x15200
jmp 0x15208
// File: /workspace/github_c_makefile_star2_O1/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 0x15fbe
movq %rax, %r14
cmpq $0x0, (%rax)
jne 0x15326
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 0x1538d
cmpb $0x0, 0x1(%rax)
je 0x15396
cmpq %r15, %rax
je 0x153ab
subl %r15d, %eax
cmpl $0x2, %eax
jl 0x15367
movl %eax, %ecx
cmpb $0x2f, -0x1(%r15,%rcx)
jne 0x15367
leal -0x1(%rax), %ecx
cmpl $0x2, %eax
movl %ecx, %eax
jg 0x1534e
movl $0x1, %eax
movq %rbx, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x7516
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 0x153d6
jmp 0x153de
leaq 0x17382(%rip), %rsi     # 0x2c716
jmp 0x153b2
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
movq %r14, %r15
jmp 0x153d1
leaq 0x16f63(%rip), %rsi     # 0x2c315
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
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 0x153de
movq %rbx, %rdi
callq 0x759a
movq %r15, (%rbx)
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0x153fc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x759a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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), %r15
cmpq $0x0, (%r15)
jne 0x1542d
movq 0x8(%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq (%r15), %r15
movq %r15, %rdi
movl $0x2f, %esi
callq 0x61f0
movq %rax, %r12
movq %r15, %rdi
movl $0x2e, %esi
callq 0x61f0
testq %rax, %rax
je 0x15480
cmpq %rax, %r12
ja 0x15480
subl %r15d, %eax
movq %rbx, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x7516
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 0x15498
jmp 0x154a0
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 0x154a0
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x15fbe
movq %rax, %r14
cmpq $0x0, (%rax)
jne 0x154d7
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 0x19152(%rip), %rcx     # 0x2e653
movq %rcx, %rsi
cmovbq %rax, %rsi
testq %rax, %rax
cmoveq %rcx, %rsi
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
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 0x1553b
movq %rbx, %rdi
callq 0x759a
movq %r15, (%rbx)
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0x15559
movq %rbx, %rdi
movq %r14, %rsi
callq 0x759a
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x15fbe
movq %rax, %r14
cmpq $0x0, (%rax)
jne 0x1558c
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %rdi
movl $0x2f, %esi
callq 0x61f0
testq %rax, %rax
je 0x155fb
incq %rax
movq %rbx, %rdi
movq %rax, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
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 0x155d0
movq %rbx, %rdi
callq 0x759a
movq %r15, (%rbx)
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0x155ee
movq %rbx, %rdi
movq %r14, %rsi
callq 0x759a
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 0x155c8
jmp 0x155d0
// File: /workspace/github_c_makefile_star2_O1/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 0xae58
movq %rax, %r14
leaq 0x20d23(%rip), %rax     # 0x36358
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movq (%r15), %r15
cmpq $0x0, (%r15)
jne 0x1565b
movq 0x8(%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq (%r15), %r15
cmpb $0x2f, (%r15)
jne 0x156f2
movq %rbx, %rdi
callq 0xae58
movq %rax, %r12
movl $0x2, %esi
xorl %edi, %edi
callq *0x22c08(%rip)          # 0x38288
movw $0x2f, (%rax)
movq %rax, (%r12)
movl $0x1, 0x14(%r12)
movq $0x0, 0x8(%r12)
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x7695
jmp 0x156f2
movq %r15, %rdi
movl $0x2f, %esi
callq 0x61c0
movq %rax, %r12
subl %r15d, %eax
cmpq $0x1, %r12
movl $0x0, %edx
sbbl %edx, %edx
orl %eax, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7516
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7695
testq %r12, %r12
cmovneq %r12, %r15
jne 0x156f2
jmp 0x156ff
incq %r15
movzbl (%r15), %eax
cmpl $0x2f, %eax
je 0x156ef
testl %eax, %eax
jne 0x156ab
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1571c
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x15747
movq 0x8(%rdi), %rax
callq *0x18(%rax)
movl $0x1000, %esi           # imm = 0x1000
xorl %edi, %edi
callq *0x22b34(%rip)          # 0x38288
movq %rax, %rdi
xorl %esi, %esi
callq *0x22b29(%rip)          # 0x38288
movq (%r14), %r14
callq 0x6080
movl (%rax), %edi
callq 0x64b0
leaq 0x17023(%rip), %rsi     # 0x2c798
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x692d
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x18, %rsp
movq %rdx, %rbx
movl %esi, %r14d
movq (%rdx), %rsi
leaq 0x16e24(%rip), %rdx     # 0x2c7c0
movq %rdi, -0x30(%rbp)
callq 0x73d6
movl %eax, -0x3c(%rbp)
testl %eax, %eax
jne 0x159c3
movq (%rbx), %rsi
leaq 0x17c67(%rip), %rdx     # 0x2d61d
movq -0x30(%rbp), %rdi
callq 0x73d6
testl %eax, %eax
je 0x159ca
decl %r14d
addq $0x8, %rbx
incl %r14d
decl %r14d
je 0x15ab2
movq (%rbx), %r12
cmpq $0x0, (%r12)
jne 0x159eb
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
movq (%r12), %r13
movq %r13, %rdi
callq 0x6090
cmpl $-0x1, %eax
jne 0x15a16
callq 0x6080
cmpl $0x2, (%rax)
je 0x15a16
movq %rax, %r12
movq %r13, %rdi
callq 0x6170
cmpl $-0x1, %eax
je 0x15a27
addq $0x8, %rbx
movb $0x1, %r15b
testb %r15b, %r15b
jne 0x159cd
jmp 0x15ab6
cmpl $0x0, -0x3c(%rbp)
je 0x15a89
movq -0x30(%rbp), %rdi
leaq 0x16d8f(%rip), %rsi     # 0x2c7c7
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rax, -0x38(%rbp)
movl $0x10, %esi
xorl %edi, %edi
callq *0x22835(%rip)          # 0x38288
movq %rax, %r15
movq -0x38(%rbp), %rax
movq %rax, (%r15)
movq (%rbx), %rax
movq %rax, 0x8(%r15)
movq -0x30(%rbp), %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x10562
movl %eax, -0x38(%rbp)
movq %r15, %rdi
xorl %esi, %esi
callq *0x22805(%rip)          # 0x38288
cmpl $0x0, -0x38(%rbp)
je 0x15a16
movl (%r12), %edi
callq 0x64b0
xorl %r15d, %r15d
movq -0x30(%rbp), %rdi
leaq 0x16d39(%rip), %rsi     # 0x2c7d9
movq %r13, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x692d
jmp 0x15a1d
xorl %eax, %eax
jmp 0x15abb
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_O1/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, %r14
movl %esi, %r15d
movq %rdi, -0x30(%rbp)
incl %r15d
decl %r15d
je 0x15b8a
movq (%r14), %rbx
cmpq $0x0, (%rbx)
jne 0x15b01
movq 0x8(%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq (%rbx), %rbx
movq %rbx, %rdi
callq 0x6180
movq %rax, %r13
incl %eax
movslq %eax, %rsi
xorl %edi, %edi
callq *0x2276c(%rip)          # 0x38288
movq %rax, %r12
movslq %r13d, %r13
movq %rax, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x6320
movb $0x0, (%r12,%r13)
movq %r12, %rdi
callq 0x160be
movl %eax, %ebx
movq %r12, %rdi
xorl %esi, %esi
callq *0x2273e(%rip)          # 0x38288
testl %ebx, %ebx
je 0x15b77
movq (%r14), %r12
callq 0x6080
movl (%rax), %edi
callq 0x64b0
movq -0x30(%rbp), %rdi
leaq 0x16c8f(%rip), %rsi     # 0x2c7f7
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x692d
jmp 0x15b7b
addq $0x8, %r14
testl %ebx, %ebx
je 0x15ae5
movl $0x1, %eax
jmp 0x15b8c
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_O1/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 0x15bc1
movq (%rdx), %r14
cmpq $0x0, (%r14)
jne 0x15bbc
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %rsi
jmp 0x15bc3
xorl %esi, %esi
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1334c
testl %eax, %eax
js 0x15bdd
movl %eax, %edi
callq 0x6260
jmp 0x15be3
movl $0x1, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x15c25
movq (%r14), %rsi
leaq 0x16baf(%rip), %rdx     # 0x2c7c0
movq %rbx, %rdi
callq 0x73d6
testl %eax, %eax
je 0x15cad
addq $0x8, %r14
movq (%r14), %r12
cmpq $0x0, (%r12)
jne 0x15c3a
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
movq (%r12), %r12
movq 0x8(%r14), %r13
cmpq $0x0, (%r13)
jne 0x15c53
movq 0x8(%r13), %rax
movq %r13, %rdi
callq *0x18(%rax)
movq (%r13), %r13
cmpl $0x3, %r15d
je 0x15c6b
movq %r13, %rdi
xorl %esi, %esi
callq 0x6430
testl %eax, %eax
je 0x15cb4
movq %r12, %rdi
movq %r13, %rsi
callq 0x6440
testl %eax, %eax
je 0x15ca9
movq (%r14), %r15
movq 0x8(%r14), %r14
callq 0x6080
movl (%rax), %edi
callq 0x64b0
leaq 0x16bb1(%rip), %rsi     # 0x2c845
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x692d
jmp 0x15ccc
xorl %eax, %eax
jmp 0x15cd1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x15cd1
movq (%r14), %rdx
movq 0x8(%r14), %rcx
leaq 0x16b56(%rip), %rsi     # 0x2c818
movq %rbx, %rdi
xorl %eax, %eax
callq 0x692d
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_O1/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 0x15f54
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 0xae58
movq %rax, %r14
leaq 0x2045a(%rip), %rax     # 0x362e0
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 0x15eb2
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x15f54
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 0xae58
movq %rax, %r14
leaq 0x203cb(%rip), %rax     # 0x362e0
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 0x15f41
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpq $0x0, (%rsi)
jne 0x15f77
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 0x15fb3
callq 0x6080
movl (%rax), %edi
callq 0x64b0
leaq 0x167c7(%rip), %rsi     # 0x2c765
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x692d
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpq $0x0, (%rsi)
jne 0x15fde
movq 0x8(%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movl 0x14(%rbx), %r15d
cmpq $0x0, (%rbx)
jne 0x15ff2
movq 0x8(%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq (%rbx), %rsi
movl %r15d, %edx
cmpl $0x2, %r15d
jl 0x16019
movl %r15d, %edx
movl %edx, %eax
cmpb $0x2f, -0x1(%rsi,%rax)
jne 0x16019
leal -0x1(%rdx), %eax
cmpl $0x2, %edx
movl %eax, %edx
jg 0x16001
movl $0x1, %edx
cmpl %r15d, %edx
je 0x16029
movq %r14, %rdi
callq 0x7516
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_O1/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, %r15
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x60d0
xorl %ebx, %ebx
testl %eax, %eax
je 0x1619a
movl $0xfffffffe, %r13d      # imm = 0xFFFFFFFE
callq 0x6080
movq %rax, %r14
movl (%r14), %eax
cmpl $0x2, %eax
jne 0x16151
incl %r13d
je 0x16195
movq %r15, %rdi
movl $0x2f, %esi
callq 0x61f0
movq %rax, %r12
testq %rax, %rax
sete %al
cmpq %r15, %r12
sete %cl
orb %al, %cl
jne 0x1613e
movb $0x0, (%r12)
movq %r15, %rdi
callq 0x160be
testl %eax, %eax
jne 0x16195
movb $0x2f, (%r12)
movq %r15, %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x60d0
testl %eax, %eax
jne 0x160f7
jmp 0x1619a
cmpl $0x11, %eax
jne 0x16195
leaq -0xb8(%rbp), %rsi
movq %r15, %rdi
callq 0x61b0
testl %eax, %eax
jne 0x16183
movl $0xf000, %ecx           # imm = 0xF000
andl -0xa0(%rbp), %ecx
xorl %ebx, %ebx
movl $0x0, %eax
cmpl $0x4000, %ecx           # imm = 0x4000
je 0x16191
movl $0x11, (%r14)
movb $0x1, %al
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testb %al, %al
je 0x1619a
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
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_O1/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, -0x30(%rbp)
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
movq %rax, %r14
testl %r14d, %r14d
jle 0x170e7
movq %r15, %rdi
movq -0x30(%rbp), %rsi
movq %r12, %rdx
movl %r14d, %ecx
callq 0x8653
movl $0x1, %r13d
testl %r14d, %r14d
jg 0x170b8
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_O1/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
leaq -0x20(%rbp), %r14
movq %rax, (%r14)
leaq 0x152fa(%rip), %rsi     # 0x2c428
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rax, 0x8(%r14)
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x10562
testl %eax, %eax
jne 0x17185
movq (%rbx), %r14
leaq 0x1f183(%rip), %rax     # 0x362e0
cmpq %rax, 0x8(%r14)
je 0x1717b
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0xd6d7
testl %eax, %eax
je 0x1717b
xorl %ecx, %ecx
jmp 0x17181
movl 0x18(%r14), %eax
movb $0x1, %cl
testb %cl, %cl
jne 0x1718a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movslq 0xc(%rdi), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
jle 0x171e2
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdx
movq %rdx, %r8
movq %rcx, %r9
cmpl %esi, (%r8)
je 0x171be
addq $0xc, %r8
decq %r9
jne 0x171ae
jmp 0x171e1
cmpl $0x1, %r9d
je 0x171dc
decl %ecx
movslq %ecx, %rax
leaq (%rax,%rax,2), %rax
movl 0x8(%rdx,%rax,4), %ecx
movl %ecx, 0x8(%r8)
movq (%rdx,%rax,4), %rax
movq %rax, (%r8)
decl 0xc(%rdi)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: array_cmd_get
static int array_cmd_get(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *objPtr = Jim_GetVariable(interp, argv[0], JIM_NONE);
    Jim_Obj *patternObj;

    if (!objPtr) {
        return JIM_OK;
    }

    patternObj = (argc == 1) ? NULL : argv[1];


    if (patternObj == NULL || Jim_CompareStringImmediate(interp, patternObj, "*")) {
        if (Jim_IsList(objPtr) && Jim_ListLength(interp, objPtr) % 2 == 0) {

            Jim_SetResult(interp, objPtr);
            return JIM_OK;
        }
    }

    return Jim_DictMatchTypes(interp, objPtr, patternObj, JIM_DICTMATCH_KEYS, JIM_DICTMATCH_KEYS | JIM_DICTMATCH_VALUES);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %rbx
movq (%rdx), %rsi
xorl %edx, %edx
callq 0x98ef
testq %rax, %rax
je 0x179b8
movq %rax, %r14
cmpl $0x1, %r12d
jne 0x1795a
xorl %r15d, %r15d
jmp 0x1795e
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x17979
leaq 0x15592(%rip), %rdx     # 0x2cefc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73d6
testl %eax, %eax
je 0x179c3
leaq 0x1e9d8(%rip), %rax     # 0x36358
cmpq %rax, 0x8(%r14)
jne 0x179c3
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe338
testb $0x1, 0x20(%r14)
jne 0x179c3
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x179b5
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x1, %ecx
movl $0x3, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x11667
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: array_cmd_names
static int array_cmd_names(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *objPtr = Jim_GetVariable(interp, argv[0], JIM_NONE);

    if (!objPtr) {
        return JIM_OK;
    }

    return Jim_DictMatchTypes(interp, objPtr, argc == 1 ? NULL : argv[1], JIM_DICTMATCH_KEYS, JIM_DICTMATCH_KEYS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movq (%rdx), %rsi
xorl %edx, %edx
callq 0x98ef
testq %rax, %rax
je 0x17a10
cmpl $0x1, %r15d
jne 0x17a1d
xorl %edx, %edx
jmp 0x17a21
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %rdx
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %ecx
movl $0x1, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11667
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: array_cmd_set
static int array_cmd_set(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    int i;
    int len;
    Jim_Obj *listObj = argv[1];
    Jim_Obj *dictObj;

    len = Jim_ListLength(interp, listObj);
    if (len % 2) {
        Jim_SetResultString(interp, "list must have an even number of elements", -1);
        return JIM_ERR;
    }

    dictObj = Jim_GetVariable(interp, argv[0], JIM_UNSHARED);
    if (!dictObj) {

        return Jim_SetVariable(interp, argv[0], listObj);
    }
    else if (Jim_DictSize(interp, dictObj) < 0) {
        return JIM_ERR;
    }

    if (Jim_IsShared(dictObj)) {
        dictObj = Jim_DuplicateObj(interp, dictObj);
    }

    for (i = 0; i < len; i += 2) {
        Jim_Obj *nameObj;
        Jim_Obj *valueObj;

        Jim_ListIndex(interp, listObj, i, &nameObj, JIM_NONE);
        Jim_ListIndex(interp, listObj, i + 1, &valueObj, JIM_NONE);

        Jim_DictAddElement(interp, dictObj, nameObj, valueObj);
    }
    return Jim_SetVariable(interp, argv[0], dictObj);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %r15
movq %r15, %rsi
callq 0xe338
movl 0x20(%r15), %r12d
testb $0x1, %r12b
jne 0x17b1f
movq (%r14), %rsi
movq %rbx, %rdi
movl $0x4, %edx
callq 0x98ef
testq %rax, %rax
je 0x17b69
movq %rax, %r13
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf0bd
testl %eax, %eax
jne 0x17b55
movq 0x18(%r13), %rax
cmpl $-0x1, 0x20(%rax)
jl 0x17b55
movq %r14, -0x38(%rbp)
cmpl $0x2, 0x10(%r13)
jl 0x17ac8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x8fa8
movq %rax, %r13
movq %r13, -0x30(%rbp)
testl %r12d, %r12d
jle 0x17b0f
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
callq 0xe871
movq %rax, %r14
leal 0x1(%r13), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe871
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
movq %r14, %rdx
movq %rax, %rcx
callq 0xf04d
addl $0x2, %r13d
cmpl %r12d, %r13d
jl 0x17ad4
movq -0x38(%rbp), %rax
movq (%rax), %rsi
movq %rbx, %rdi
movq -0x30(%rbp), %rdx
jmp 0x17b72
leaq 0x15006(%rip), %rsi     # 0x2cb2c
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
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 0x17b52
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x871b
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: array_cmd_size
static int array_cmd_size(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *objPtr;
    int len = 0;


    objPtr = Jim_GetVariable(interp, argv[0], JIM_NONE);
    if (objPtr) {
        len = Jim_DictSize(interp, objPtr);
        if (len < 0) {

            Jim_SetResultInt(interp, 0);
            return JIM_OK;
        }
    }

    Jim_SetResultInt(interp, len);

    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdx), %rsi
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x98ef
testq %rax, %rax
je 0x17bd5
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf0bd
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x17bd0
movq 0x18(%r14), %rax
movl 0x20(%rax), %eax
movl %eax, %r15d
shrl $0x1f, %r15d
addl %eax, %r15d
sarl %r15d
testl %r15d, %r15d
js 0x17c26
movl %r15d, %r15d
movq %rbx, %rdi
callq 0xae58
movq %rax, %r14
leaq 0x1e6f6(%rip), %rax     # 0x362e0
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 0x17c16
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0xae58
movq %rax, %r14
leaq 0x1e6a8(%rip), %rax     # 0x362e0
movq %rax, 0x8(%r14)
xorl %eax, %eax
movq %rax, (%r14)
movq %rax, 0x18(%r14)
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x2, %eax
jl 0x17c0e
jmp 0x17c16
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: array_cmd_stat
static int array_cmd_stat(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *objPtr = Jim_GetVariable(interp, argv[0], JIM_NONE);
    if (objPtr) {
        return Jim_DictInfo(interp, objPtr);
    }
    Jim_SetResultFormatted(interp, "\"%#s\" isn't an array", argv[0], NULL);
    return JIM_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdx), %rsi
xorl %edx, %edx
callq 0x98ef
testq %rax, %rax
je 0x17c87
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x117a9
movq (%r14), %rdx
leaq 0x14ec5(%rip), %rsi     # 0x2cb56
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x692d
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: array_cmd_unset
static int array_cmd_unset(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    int i;
    int len;
    Jim_Obj *resultObj;
    Jim_Obj *objPtr;
    Jim_Obj **dictValuesObj;

    if (argc == 1 || Jim_CompareStringImmediate(interp, argv[1], "*")) {

        Jim_UnsetVariable(interp, argv[0], JIM_NONE);
        return JIM_OK;
    }

    objPtr = Jim_GetVariable(interp, argv[0], JIM_NONE);

    if (objPtr == NULL) {

        return JIM_OK;
    }

    dictValuesObj = Jim_DictPairs(interp, objPtr, &len);
    if (dictValuesObj == NULL) {

        Jim_SetResultString(interp, "", -1);
        return JIM_OK;
    }


    resultObj = Jim_NewDictObj(interp, NULL, 0);

    for (i = 0; i < len; i += 2) {
        if (!Jim_StringMatchObj(interp, argv[1], dictValuesObj[i], 0)) {
            Jim_DictAddElement(interp, resultObj, dictValuesObj[i], dictValuesObj[i + 1]);
        }
    }

    Jim_SetVariable(interp, argv[0], resultObj);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x1, %esi
je 0x17cda
movq 0x8(%r14), %rsi
leaq 0x1522e(%rip), %rdx     # 0x2cefc
movq %rbx, %rdi
callq 0x73d6
testl %eax, %eax
je 0x17cf8
movq (%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xc7d8
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x98ef
testq %rax, %rax
je 0x17ce7
leaq -0x2c(%rbp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf6a2
testq %rax, %rax
je 0x17db9
movq %rax, %r15
movq %rbx, %rdi
callq 0xae58
movq %rax, %r12
leaq 0x1e649(%rip), %rax     # 0x36380
movq %rax, 0x8(%r12)
movq $0x0, (%r12)
movl $0x30, %esi
xorl %edi, %edi
callq *0x20537(%rip)          # 0x38288
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movq %r12, -0x38(%rbp)
movq %rax, 0x18(%r12)
movl -0x2c(%rbp), %r13d
testl %r13d, %r13d
jle 0x17da5
xorl %r12d, %r12d
movq 0x8(%r14), %rsi
movq (%r15,%r12,8), %rdx
xorl %ecx, %ecx
callq 0xb120
testl %eax, %eax
jne 0x17d9c
movq (%r15,%r12,8), %rdx
movq 0x8(%r15,%r12,8), %rcx
movq %rbx, %rdi
movq -0x38(%rbp), %rsi
callq 0xf04d
addq $0x2, %r12
cmpl %r12d, %r13d
jg 0x17d74
movq (%r14), %rsi
movq %rbx, %rdi
movq -0x38(%rbp), %rdx
callq 0x871b
jmp 0x17ce7
leaq 0x16893(%rip), %rsi     # 0x2e653
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
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 0x17dec
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
jmp 0x17ce7
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: FreeScriptInternalRep
void FreeScriptInternalRep(Jim_Interp *interp, Jim_Obj *objPtr)
{
    int i;
    struct ScriptObj *script = (void *)objPtr->internalRep.ptr;

    if (--script->inUse != 0)
        return;
    for (i = 0; i < script->len; i++) {
        Jim_DecrRefCount(interp, script->token[i].objPtr);
    }
    Jim_Free(script->token);
    Jim_DecrRefCount(interp, script->fileNameObj);
    Jim_Free(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x18(%rsi), %rbx
decl 0x18(%rbx)
je 0x17fbc
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
cmpl $0x0, 0x10(%rbx)
jle 0x17ff8
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rbx), %rax
movq (%rax,%r15), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x17fe8
movq %r14, %rdi
callq 0x759a
incq %r12
movslq 0x10(%rbx), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x17fcb
movq (%rbx), %rdi
xorl %esi, %esi
callq *0x20285(%rip)          # 0x38288
movq 0x8(%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1801d
movq %r14, %rdi
callq 0x759a
movq 0x20264(%rip), %rax     # 0x38288
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax