LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_EvalFile
int Jim_EvalFile(Jim_Interp *interp, const char *filename)
{
    Jim_Obj *filenameObj;
    Jim_Obj *oldFilenameObj;
    Jim_Obj *scriptObjPtr;
    int retcode;

    scriptObjPtr = JimReadTextFile(interp, filename);
    if (!scriptObjPtr) {
        return JIM_ERR;
    }

    filenameObj = Jim_NewStringObj(interp, filename, -1);
    Jim_SetSourceInfo(interp, scriptObjPtr, filenameObj, 1);

    oldFilenameObj = JimPushInterpObj(interp->currentFilenameObj, filenameObj);

    retcode = Jim_EvalObj(interp, scriptObjPtr);

    JimPopInterpObj(interp, interp->currentFilenameObj, oldFilenameObj);


    if (retcode == JIM_RETURN) {
        if (--interp->returnLevel <= 0) {
            retcode = interp->returnCode;
            interp->returnCode = JIM_OK;
            interp->returnLevel = 0;
        }
    }

    return retcode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0xb8(%rbp), %rsi
movq %r14, %rdi
callq 0x61b0
cmpl $-0x1, %eax
je 0x11148
movq %r14, %rdi
xorl %esi, %esi
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x63d0
testl %eax, %eax
js 0x11148
movl %eax, %r15d
movq -0x88(%rbp), %r13
leaq 0x1(%r13), %rsi
xorl %edi, %edi
callq *0x27185(%rip)          # 0x38288
movq %rax, %r12
movl %r15d, %edi
movq %rax, %rsi
movq %r13, %rdx
callq 0x62a0
movq %rax, %r13
movl %r15d, %edi
callq 0x6260
testl %r13d, %r13d
js 0x1123a
movl %r13d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movb $0x0, (%r12,%rax)
movq %rbx, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0xaf08
movq %rax, %r15
jmp 0x1116e
callq 0x6080
movl (%rax), %edi
callq 0x64b0
leaq 0x1b7d7(%rip), %rsi     # 0x2c932
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x692d
testq %r15, %r15
je 0x1121f
movq %rbx, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rax, %r14
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x111a4
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x111a4
movq %rbx, %rdi
movq %r15, %rsi
callq *%rax
incl 0x10(%r14)
movq %r14, 0x18(%r15)
movl $0x1, 0x20(%r15)
leaq 0x2501d(%rip), %rax     # 0x361d8
movq %rax, 0x8(%r15)
movq 0x10(%rbx), %r12
incl 0x10(%r14)
movq %r14, 0x10(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9078
movl %eax, %r14d
movq 0x10(%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x111f3
movq %rbx, %rdi
callq 0x759a
movq %r12, 0x10(%rbx)
cmpl $0x2, %r14d
jne 0x11225
movl 0x2c(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x2c(%rbx)
movl $0x2, %r14d
cmpl $0x1, %eax
jg 0x11225
movl 0x28(%rbx), %r14d
movq $0x0, 0x28(%rbx)
jmp 0x11225
movl $0x1, %r14d
movl %r14d, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
movq %r12, %rdi
xorl %esi, %esi
callq *0x27040(%rip)          # 0x38288
callq 0x6080
movl (%rax), %edi
callq 0x64b0
leaq 0x1c088(%rip), %rsi     # 0x2d2e3
jmp 0x1115e
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_CommandMatchObj
int Jim_CommandMatchObj(Jim_Interp *interp, Jim_Obj *commandObj, Jim_Obj *patternObj,
    Jim_Obj *stringObj, int flags)
{
    Jim_Obj *parms[5];
    int argc = 0;
    long eq;
    int rc;

    parms[argc++] = commandObj;
    if (flags & JIM_NOCASE) {
        parms[argc++] = Jim_NewStringObj(interp, "-nocase", -1);
    }
    if (flags & JIM_OPT_END) {
        parms[argc++] = Jim_NewStringObj(interp, "--", -1);
    }
    parms[argc++] = patternObj;
    parms[argc++] = stringObj;

    rc = Jim_EvalObjVector(interp, argc, parms);

    if (rc != JIM_OK || Jim_GetLong(interp, Jim_GetResult(interp), &eq) != JIM_OK) {
        eq = -rc;
    }

    return eq;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r13d
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
movq %rsi, -0x50(%rbp)
movl $0x1, %r12d
testb $0x1, %r13b
je 0x115d4
leaq 0x1a4bd(%rip), %rsi     # 0x2ba7a
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rax, -0x48(%rbp)
movl $0x2, %r12d
testb $0x2, %r13b
je 0x115f9
leaq 0x1c03c(%rip), %rsi     # 0x2d61d
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movl %r12d, %ecx
incl %r12d
movq %rax, -0x50(%rbp,%rcx,8)
movl %r12d, %eax
movq %r15, -0x50(%rbp,%rax,8)
addl $0x2, %r12d
movq %r14, -0x48(%rbp,%rax,8)
leaq -0x50(%rbp), %rdx
movq %rbx, %rdi
movl %r12d, %esi
callq 0x10562
movl %eax, %r14d
testl %eax, %eax
jne 0x11652
movq (%rbx), %r15
leaq 0x24cb6(%rip), %rax     # 0x362e0
cmpq %rax, 0x8(%r15)
je 0x11648
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0xd6d7
testl %eax, %eax
je 0x11648
xorl %ecx, %ecx
jmp 0x1164e
movq 0x18(%r15), %rax
movb $0x1, %cl
testb %cl, %cl
jne 0x11658
negl %r14d
movq %r14, %rax
addq $0x28, %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: Jim_DictMatchTypes
int Jim_DictMatchTypes(Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj *patternObj, int match_type, int return_types)
{
    Jim_Obj *listObjPtr;
    Jim_Dict *dict;
    int i;

    if (SetDictFromAny(interp, objPtr) != JIM_OK) {
        return JIM_ERR;
    }
    dict = objPtr->internalRep.dictValue;

    listObjPtr = Jim_NewListObj(interp, NULL, 0);

    for (i = 0; i < dict->len; i += 2 ) {
        Jim_Obj *keyObj = dict->table[i];
        Jim_Obj *valObj = dict->table[i + 1];
        if (patternObj) {
            Jim_Obj *matchObj = (match_type == JIM_DICTMATCH_KEYS) ? keyObj : valObj;
            if (!Jim_StringMatchObj(interp, patternObj, matchObj, 0)) {

                continue;
            }
        }
        if (return_types & JIM_DICTMATCH_KEYS) {
            Jim_ListAppendElement(interp, listObjPtr, keyObj);
        }
        if (return_types & JIM_DICTMATCH_VALUES) {
            Jim_ListAppendElement(interp, listObjPtr, valObj);
        }
    }

    Jim_SetResult(interp, listObjPtr);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r13d
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
callq 0xf0bd
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x1176a
movl %r13d, -0x44(%rbp)
movl %r15d, -0x2c(%rbp)
movq 0x18(%rbx), %r13
movq %r14, -0x40(%rbp)
movq %r14, %rdi
callq 0xae58
leaq 0x24c9e(%rip), %rcx     # 0x36358
movq %rcx, 0x8(%rax)
movq $0x0, (%rax)
xorps %xmm0, %xmm0
movq %rax, -0x38(%rbp)
movups %xmm0, 0x18(%rax)
cmpl $0x0, 0x20(%r13)
jle 0x1173d
xorl %r14d, %r14d
movq 0x18(%r13), %rax
movq (%rax,%r14,8), %rbx
movq 0x8(%rax,%r14,8), %r15
testq %r12, %r12
je 0x11705
cmpl $0x1, -0x44(%rbp)
movq %r15, %rdx
cmoveq %rbx, %rdx
movq %r12, %rsi
xorl %ecx, %ecx
callq 0xb120
testl %eax, %eax
je 0x11733
movl -0x2c(%rbp), %eax
testb $0x1, %al
je 0x1171f
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rbx, %rdx
callq 0x7695
movl -0x2c(%rbp), %eax
testb $0x2, %al
je 0x11733
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %r15, %rdx
callq 0x7695
addq $0x2, %r14
cmpl %r14d, 0x20(%r13)
jg 0x116da
movq -0x38(%rbp), %rax
incl 0x10(%rax)
movq -0x40(%rbp), %rbx
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x11761
movq %rbx, %rdi
callq 0x759a
movq -0x38(%rbp), %rax
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x28, %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: Jim_DictInfo
int Jim_DictInfo(Jim_Interp *interp, Jim_Obj *objPtr)
{
    char buffer[100];
    Jim_Obj *output;
    Jim_Dict *dict;

    if (SetDictFromAny(interp, objPtr) != JIM_OK) {
        return JIM_ERR;
    }

    dict = objPtr->internalRep.dictValue;


    snprintf(buffer, sizeof(buffer), "%d entries in table, %d buckets", dict->len, dict->size);
    output = Jim_NewStringObj(interp, buffer, -1);
    Jim_SetResult(interp, output);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0xf0bd
movl $0x1, %r14d
testl %eax, %eax
jne 0x11825
movq 0x18(%r15), %rax
movl 0x8(%rax), %r8d
movl 0x20(%rax), %ecx
leaq 0x1a810(%rip), %rdx     # 0x2bfed
xorl %r14d, %r14d
leaq -0x80(%rbp), %r15
movl $0x64, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x61e0
movq %rbx, %rdi
movq %r15, %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 $0x1, %eax
jg 0x11822
movq %rbx, %rdi
callq 0x759a
movq %r15, (%rbx)
movl %r14d, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_RegisterCoreCommands
void Jim_RegisterCoreCommands(Jim_Interp *interp)
{
    int i = 0;

    while (Jim_CoreCommandsTable[i].name != NULL) {
        Jim_CreateCommand(interp,
            Jim_CoreCommandsTable[i].name, Jim_CoreCommandsTable[i].cmdProc, NULL, NULL);
        i++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x1c8bd(%rip), %r14     # 0x2e125
movl $0x10, %r15d
leaq 0x24bfb(%rip), %r12     # 0x36470
movq %rbx, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq -0x8(%r15,%r12), %rdx
movq (%r15,%r12), %r14
movq %rbx, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xbe8d
addq $0x10, %r15
cmpq $0x430, %r15            # imm = 0x430
jne 0x11875
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_MakeErrorMessage
void Jim_MakeErrorMessage(Jim_Interp *interp)
{
    Jim_Obj *argv[2];

    argv[0] = Jim_NewStringObj(interp, "errorInfo", -1);
    argv[1] = interp->result;

    Jim_EvalObjVector(interp, 2, argv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x1a746(%rip), %rsi     # 0x2c00d
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
leaq -0x20(%rbp), %rdx
movq %rax, (%rdx)
movq (%rbx), %rax
movq %rax, 0x8(%rdx)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10562
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_CheckShowCommands
int Jim_CheckShowCommands(Jim_Interp *interp, Jim_Obj *objPtr, const char *const *tablePtr)
{
    if (Jim_CompareStringImmediate(interp, objPtr, "-commands")) {
        int i;
        char **tablePtrSorted = JimSortStringTable(tablePtr);
        Jim_SetResult(interp, Jim_NewListObj(interp, NULL, 0));
        for (i = 0; tablePtrSorted[i]; i++) {
            Jim_ListAppendElement(interp, Jim_GetResult(interp), Jim_NewStringObj(interp, tablePtrSorted[i], -1));
        }
        Jim_Free(tablePtrSorted);
        return JIM_OK;
    }
    return JIM_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x1a70c(%rip), %rdx     # 0x2c017
callq 0x73d6
testl %eax, %eax
je 0x119b1
movq %r14, %rdi
callq 0x119c1
movq %rax, %r14
movq %rbx, %rdi
callq 0xae58
movq %rax, %r15
leaq 0x24a23(%rip), %rax     # 0x36358
movq %rax, 0x8(%r15)
movq $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
incl 0x10(%r15)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x11965
movq %rbx, %rdi
callq 0x759a
movq %r15, (%rbx)
movq (%r14), %rsi
testq %rsi, %rsi
je 0x119a2
movq %r14, %r12
addq $0x8, %r12
movq (%rbx), %r15
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7695
movq (%r12), %rsi
addq $0x8, %r12
testq %rsi, %rsi
jne 0x11977
xorl %ebx, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq *0x268d9(%rip)          # 0x38288
jmp 0x119b6
movl $0x1, %ebx
movl %ebx, %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: JimSortStringTable
static char **JimSortStringTable(const char *const *tablePtr)
{
    int count;
    char **tablePtrSorted;


    for (count = 0; tablePtr[count]; count++) {
    }


    tablePtrSorted = Jim_Alloc(sizeof(char *) * (count + 1));
    memcpy(tablePtrSorted, tablePtr, sizeof(char *) * count);
    qsort(tablePtrSorted, count, sizeof(char *), qsortCompareStringPointers);
    tablePtrSorted[count] = NULL;

    return tablePtrSorted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
xorl %eax, %eax
movq %rax, %rbx
incq %rax
cmpq $0x0, (%r14,%rbx,8)
jne 0x119d1
leaq (,%rbx,8), %r15
leaq 0x8(,%rbx,8), %rax
movabsq $0x7fffffff8, %rsi      # imm = 0x7FFFFFFF8
andq %rax, %rsi
xorl %edi, %edi
callq *0x26885(%rip)          # 0x38288
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6320
leaq 0x13ba5(%rip), %rcx     # 0x255c0
movl $0x8, %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x6100
movq $0x0, (%r12,%rbx,8)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_FindByName
int Jim_FindByName(const char *name, const char * const array[], size_t len)
{
    int i;

    for (i = 0; i < (int)len; i++) {
        if (array[i] && strcmp(array[i], name) == 0) {
            return i;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %r14d, %r14d
jle 0x11a8c
movq %rsi, %r15
movq %rdi, %r12
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movq (%r15,%r13,8), %rdi
testq %rdi, %rdi
je 0x11a7f
movq %r12, %rsi
callq 0x62e0
testl %eax, %eax
je 0x11a89
incq %r13
cmpq %r13, %r14
jne 0x11a6a
jmp 0x11a8c
movl %r13d, %ebx
movl %ebx, %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: add_cmd_usage
static void add_cmd_usage(Jim_Interp *interp, const jim_subcmd_type * ct, Jim_Obj *cmd)
{
    if (cmd) {
        Jim_AppendStrings(interp, Jim_GetResult(interp), Jim_String(cmd), " ", NULL);
    }
    Jim_AppendStrings(interp, Jim_GetResult(interp), ct->cmd, NULL);
    if (ct->args && *ct->args) {
        Jim_AppendStrings(interp, Jim_GetResult(interp), " ", ct->args, NULL);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
je 0x11b6e
movq %rdx, %r12
movq (%rbx), %r15
cmpq $0x0, (%rdx)
jne 0x11b53
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
movq (%r12), %rdx
leaq 0x1ca18(%rip), %rcx     # 0x2e576
movq %rbx, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xafef
movq (%rbx), %rsi
movq (%r14), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xafef
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0x11bad
cmpb $0x0, (%rcx)
je 0x11bad
movq (%rbx), %rsi
leaq 0x1c9de(%rip), %rdx     # 0x2e576
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xafef
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: subcmd_cmd_list
static Jim_Obj *subcmd_cmd_list(Jim_Interp *interp, const jim_subcmd_type * ct, const char *sep)
{

    Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0);
    Jim_Obj *sortCmd[2];

    for (; ct->cmd; ct++) {
        if (!(ct->flags & JIM_MODFLAG_HIDDEN)) {
            Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, ct->cmd, -1));
        }
    }


    sortCmd[0] = Jim_NewStringObj(interp, "lsort", -1);
    sortCmd[1] = listObj;

    if (Jim_EvalObjVector(interp, 2, sortCmd) == JIM_OK) {
        return Jim_ListJoin(interp, Jim_GetResult(interp), sep, strlen(sep));
    }

    return Jim_GetResult(interp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
callq 0xae58
movq %rax, %r15
leaq 0x243ee(%rip), %rax     # 0x36358
movq %rax, 0x8(%r15)
movq $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movq (%r12), %rsi
testq %rsi, %rsi
je 0x11fba
addq $0x20, %r12
testb $0x1, -0x4(%r12)
jne 0x11fad
movq %r14, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7695
movq (%r12), %rsi
addq $0x20, %r12
testq %rsi, %rsi
jne 0x11f8a
leaq 0x1b39d(%rip), %rsi     # 0x2d35e
movq %r14, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
leaq -0x30(%rbp), %rdx
movq %rax, (%rdx)
movq %r15, 0x8(%rdx)
movq %r14, %rdi
movl $0x2, %esi
callq 0x10562
movq (%r14), %r15
testl %eax, %eax
jne 0x12008
movq %rbx, %rdi
callq 0x6180
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl %eax, %ecx
callq 0xec0a
movq %rax, %r15
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_CallSubCmd
int Jim_CallSubCmd(Jim_Interp *interp, const jim_subcmd_type * ct, int argc, Jim_Obj *const *argv)
{
    int ret = JIM_ERR;

    if (ct) {
        if (ct->flags & JIM_MODFLAG_FULLARGV) {
            ret = ct->function(interp, argc, argv);
        }
        else {
            ret = ct->function(interp, argc - 2, argv + 2);
        }
        if (ret < 0) {
            Jim_SubCmdArgError(interp, ct, argv[0]);
            ret = JIM_ERR;
        }
    }
    return ret;
}

// Assembly:
movl $0x1, %eax
testq %rsi, %rsi
je 0x120c3
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testb $0x2, 0x1c(%rsi)
movq 0x10(%rsi), %rcx
jne 0x12098
addl $-0x2, %edx
leaq 0x10(%r14), %rax
movq %r15, %rdi
movl %edx, %esi
movq %rax, %rdx
jmp 0x120a0
movq %r15, %rdi
movl %edx, %esi
movq %r14, %rdx
callq *%rcx
testl %eax, %eax
jns 0x120b9
movq (%r14), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x11ab3
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: utf8_fromunicode
int utf8_fromunicode(char *p, unsigned uc)
{
    if (uc <= 0x7f) {
        *p = uc;
        return 1;
    }
    else if (uc <= 0x7ff) {
        *p++ = 0xc0 | ((uc & 0x7c0) >> 6);
        *p = 0x80 | (uc & 0x3f);
        return 2;
    }
    else if (uc <= 0xffff) {
        *p++ = 0xe0 | ((uc & 0xf000) >> 12);
        *p++ = 0x80 | ((uc & 0xfc0) >> 6);
        *p = 0x80 | (uc & 0x3f);
        return 3;
    }

    else {
        *p++ = 0xf0 | ((uc & 0x1c0000) >> 18);
        *p++ = 0x80 | ((uc & 0x3f000) >> 12);
        *p++ = 0x80 | ((uc & 0xfc0) >> 6);
        *p = 0x80 | (uc & 0x3f);
        return 4;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x7f, %esi
ja 0x120da
movb %sil, (%rdi)
movl $0x1, %eax
jmp 0x1215e
movl %esi, %eax
cmpl $0x7ff, %esi            # imm = 0x7FF
ja 0x120fe
shrl $0x6, %eax
orb $-0x40, %al
movb %al, (%rdi)
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0x1(%rdi)
movl $0x2, %eax
jmp 0x1215e
cmpl $0xffff, %esi           # imm = 0xFFFF
ja 0x1212c
shrl $0xc, %eax
orb $-0x20, %al
movb %al, (%rdi)
movl %esi, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rdi)
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0x2(%rdi)
movl $0x3, %eax
jmp 0x1215e
shrl $0x12, %eax
andb $0x7, %al
orb $-0x10, %al
movb %al, (%rdi)
movl %esi, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rdi)
movl %esi, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x2(%rdi)
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0x3(%rdi)
movl $0x4, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: str_find
static const char *str_find(const char *string, int c, int nocase)
{
	if (nocase) {

		c = utf8_upper(c);
	}
	while (*string) {
		int ch;
		int n = reg_utf8_tounicode_case(string, &ch, nocase);
		if (c == ch) {
			return string;
		}
		string += n;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
testl %edx, %edx
je 0x1320a
movl %r15d, %edi
callq 0x60e0
movl %eax, %r15d
movzbl (%r14), %eax
testl %eax, %eax
je 0x1322c
testl %ebx, %ebx
je 0x1321d
movl %eax, %edi
callq 0x60e0
cmpl %eax, %r15d
cmoveq %r14, %r12
leaq 0x1(%r14), %r14
jne 0x1320a
jmp 0x1322f
xorl %r12d, %r12d
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: prefix_cmp
static int prefix_cmp(const int *prog, int proglen, const char *string, int nocase)
{
	const char *s = string;
	while (proglen && *s) {
		int ch;
		int n = reg_utf8_tounicode_case(s, &ch, nocase);
		if (ch != *prog) {
			return -1;
		}
		prog++;
		s += n;
		proglen--;
	}
	if (proglen == 0) {
		return s - string;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, -0x2c(%rbp)
movq %rdx, %r14
movq %rdi, %r15
movl %esi, %r13d
xorl %ebx, %ebx
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpl %ebx, %r13d
je 0x13287
movzbl (%r14,%rbx), %eax
testl %eax, %eax
je 0x1328a
cmpl $0x0, -0x2c(%rbp)
je 0x13278
movl %eax, %edi
callq 0x60e0
leaq 0x1(%rbx), %rcx
cmpl (%r15,%rbx,4), %eax
movq %rcx, %rbx
je 0x1325d
jmp 0x1328a
movl %r13d, %r12d
movl %r12d, %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: regtry
static int regtry( regex_t *preg, const char *string )
{
	int i;

	preg->reginput = string;

	for (i = 0; i < preg->nmatch; i++) {
		preg->pmatch[i].rm_so = -1;
		preg->pmatch[i].rm_eo = -1;
	}
	if (regmatch(preg, 1)) {
		preg->pmatch[0].rm_so = string - preg->start;
		preg->pmatch[0].rm_eo = preg->reginput - preg->start;
		return(1);
	} else
		return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x48(%rdi)
movslq 0x60(%rdi), %rdx
testq %rdx, %rdx
jle 0x132cb
movq 0x58(%rbx), %rdi
shlq $0x3, %rdx
movl $0xff, %esi
callq 0x6240
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x26839
testl %eax, %eax
je 0x132f9
movl 0x40(%rbx), %eax
subl %eax, %r14d
movq 0x58(%rbx), %rcx
movl %r14d, (%rcx)
movl 0x48(%rbx), %edx
subl %eax, %edx
movl %edx, 0x4(%rcx)
jmp 0x132fc
xorl %r15d, %r15d
movl %r15d, %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: Jim_MakeTempFile
int Jim_MakeTempFile(Jim_Interp *interp, const char *filename_template, int unlink_file)
{
    int fd;
    mode_t mask;
    Jim_Obj *filenameObj;

    if (filename_template == NULL) {
        const char *tmpdir = getenv("TMPDIR");
        if (tmpdir == NULL || *tmpdir == '\0' || access(tmpdir, W_OK) != 0) {
            tmpdir = "/tmp/";
        }
        filenameObj = Jim_NewStringObj(interp, tmpdir, -1);
        if (tmpdir[0] && tmpdir[strlen(tmpdir) - 1] != '/') {
            Jim_AppendString(interp, filenameObj, "/", 1);
        }
        Jim_AppendString(interp, filenameObj, "tcl.tmp.XXXXXX", -1);
    }
    else {
        filenameObj = Jim_NewStringObj(interp, filename_template, -1);
    }


#ifdef HAVE_UMASK
    mask = umask(S_IXUSR | S_IRWXG | S_IRWXO);
#endif
#ifdef HAVE_MKSTEMP
    fd = mkstemp(filenameObj->bytes);
#else
    if (mktemp(filenameObj->bytes) == NULL) {
        fd = -1;
    }
    else {
        fd = open(filenameObj->bytes, O_RDWR | O_CREAT | O_TRUNC);
    }
#endif
#ifdef HAVE_UMASK
    umask(mask);
#endif
    if (fd < 0) {
        Jim_SetResultErrno(interp, Jim_String(filenameObj));
        Jim_FreeNewObj(interp, filenameObj);
        return -1;
    }
    if (unlink_file) {
        remove(Jim_String(filenameObj));
    }

    Jim_SetResult(interp, filenameObj);
    return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rdi, %rbx
testq %rsi, %rsi
je 0x1337a
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rax, %r14
jmp 0x13403
leaq 0x18f89(%rip), %rdi     # 0x2c30a
callq 0x6030
testq %rax, %rax
je 0x133a4
movq %rax, %r12
cmpb $0x0, (%rax)
je 0x133a4
movq %r12, %rdi
movl $0x2, %esi
callq 0x6430
testl %eax, %eax
je 0x133ab
leaq 0x18f66(%rip), %r12     # 0x2c311
movq %rbx, %rdi
movq %r12, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rax, %r14
cmpb $0x0, (%r12)
je 0x133ec
movq %r12, %rdi
callq 0x6180
cmpb $0x2f, -0x1(%rax,%r12)
je 0x133ec
leaq 0x18f39(%rip), %rdx     # 0x2c315
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x8653
leaq 0x18f24(%rip), %rdx     # 0x2c317
movq %rbx, %rdi
movq %r14, %rsi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x8653
movl $0x7f, %edi
callq 0x6300
movl %eax, %r13d
movq (%r14), %rdi
callq 0x62b0
movl %eax, %r12d
movl %r13d, %edi
callq 0x6300
testl %r12d, %r12d
js 0x13467
testl %r15d, %r15d
je 0x13445
cmpq $0x0, (%r14)
jne 0x1343d
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %rdi
callq 0x60a0
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x13462
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
jmp 0x13493
cmpq $0x0, (%r14)
jne 0x13477
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x13318
movq %rbx, %rdi
movq %r14, %rsi
callq 0x759a
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl %r12d, %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: Jim_SignalId
const char *Jim_SignalId(int sig)
{
	static char buf[10];
	switch (sig) {
		case SIGINT: return "SIGINT";
		case SIGPIPE: return "SIGPIPE";

	}
	snprintf(buf, sizeof(buf), "%d", sig);
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpl $0x2, %edi
je 0x134f2
movl %edi, %ecx
cmpl $0xd, %edi
jne 0x134fb
leaq 0x18e3d(%rip), %rbx     # 0x2c32d
jmp 0x13518
leaq 0x18e2d(%rip), %rbx     # 0x2c326
jmp 0x13518
leaq 0x24d97(%rip), %rbx     # 0x38299
leaq 0x1ac46(%rip), %rdx     # 0x2e14f
movl $0xa, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x61e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_HistoryGetline
char *Jim_HistoryGetline(Jim_Interp *interp, const char *prompt)
{
#ifdef USE_LINENOISE
    struct JimCompletionInfo *compinfo = JimGetCompletionInfo(interp);
    char *result;
    Jim_Obj *objPtr;
    long mlmode = 0;
    if (compinfo->completion_command) {
        linenoiseSetCompletionCallback(JimCompletionCallback, compinfo);
    }
    if (compinfo->hints_command) {
        linenoiseSetHintsCallback(JimHintsCallback, compinfo);
        linenoiseSetFreeHintsCallback(JimFreeHintsCallback);
    }
    objPtr = Jim_GetVariableStr(interp, "history::multiline", JIM_NONE);
    if (objPtr && Jim_GetLong(interp, objPtr, &mlmode) == JIM_NONE) {
        linenoiseSetMultiLine(mlmode);
    }

    result = linenoise(prompt);

    linenoiseSetCompletionCallback(NULL, NULL);
    linenoiseSetHintsCallback(NULL, NULL);
    linenoiseSetFreeHintsCallback(NULL);
    return result;
#else
    int len;
    char *line = Jim_Alloc(MAX_LINE_LEN);

    fputs(prompt, stdout);
    fflush(stdout);

    if (fgets(line, MAX_LINE_LEN, stdin) == NULL) {
        Jim_Free(line);
        return NULL;
    }
    len = strlen(line);
    if (len && line[len - 1] == '\n') {
        line[len - 1] = '\0';
    }
    return line;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl $0x200, %esi            # imm = 0x200
xorl %edi, %edi
callq *0x24d4c(%rip)          # 0x38288
movq %rax, %rbx
movq 0x24a32(%rip), %r15     # 0x37f78
movq (%r15), %rsi
movq %r14, %rdi
callq 0x6230
movq (%r15), %rdi
callq 0x6370
movq 0x24a28(%rip), %rax     # 0x37f88
movq (%rax), %rdx
movq %rbx, %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x62c0
testq %rax, %rax
je 0x13591
movq %rbx, %rdi
callq 0x6180
testl %eax, %eax
je 0x1359e
decl %eax
cltq
cmpb $0xa, (%rbx,%rax)
jne 0x1359e
movb $0x0, (%rbx,%rax)
jmp 0x1359e
movq %rbx, %rdi
xorl %esi, %esi
callq *0x24cec(%rip)          # 0x38288
xorl %ebx, %ebx
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: usage
void usage(const char* executable_name)
{
    printf("jimsh version %d.%d\n", JIM_VERSION / 100, JIM_VERSION % 100);
    printf("Usage: %s\n", executable_name);
    printf("or   : %s [options] [filename]\n", executable_name);
    printf("\n");
    printf("Without options: Interactive mode\n");
    printf("\n");
    printf("Options:\n");
    printf("      --version  : prints the version string\n");
    printf("      --help     : prints this text\n");
    printf("      -e CMD     : executes command CMD\n");
    printf("                   NOTE: all subsequent options will be passed as arguments to the command\n");
    printf("    [filename|-] : executes the script contained in the named file, or from stdin if \"-\"\n");
    printf("                   NOTE: all subsequent options will be passed to the script\n\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18b06(%rip), %rdi     # 0x2c368
xorl %esi, %esi
movl $0x54, %edx
xorl %eax, %eax
callq 0x61d0
leaq 0x18b06(%rip), %rdi     # 0x2c37d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x61d0
leaq 0x18b00(%rip), %rdi     # 0x2c388
movq %rbx, %rsi
xorl %eax, %eax
callq 0x61d0
movl $0xa, %edi
callq 0x6050
leaq 0x1add4(%rip), %rdi     # 0x2e677
callq 0x60f0
movl $0xa, %edi
callq 0x6050
leaq 0x1ade0(%rip), %rdi     # 0x2e699
callq 0x60f0
leaq 0x1addd(%rip), %rdi     # 0x2e6a2
callq 0x60f0
leaq 0x1adfe(%rip), %rdi     # 0x2e6cf
callq 0x60f0
leaq 0x1ae16(%rip), %rdi     # 0x2e6f3
callq 0x60f0
leaq 0x1ae32(%rip), %rdi     # 0x2e71b
callq 0x60f0
leaq 0x1ae81(%rip), %rdi     # 0x2e776
callq 0x60f0
leaq 0x1aece(%rip), %rdi     # 0x2e7cf
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x60f0
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimSetArgv
static void JimSetArgv(Jim_Interp *interp, int argc, char *const argv[])
{
    int n;
    Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0);


    for (n = 0; n < argc; n++) {
        Jim_Obj *obj = Jim_NewStringObj(interp, argv[n], -1);

        Jim_ListAppendElement(interp, listObj, obj);
    }

    Jim_SetVariableStr(interp, "argv", listObj);
    Jim_SetVariableStr(interp, "argc", Jim_NewIntObj(interp, argc));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %r14d
movq %rdi, %rbx
callq 0xae58
movq %rax, %r12
leaq 0x22787(%rip), %rax     # 0x36358
movq %rax, 0x8(%r12)
movq $0x0, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r12)
movl %r14d, -0x2c(%rbp)
testl %r14d, %r14d
jle 0x13c1e
movl -0x2c(%rbp), %r13d
xorl %r14d, %r14d
movq (%r15,%r14,8), %rsi
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x7695
incq %r14
cmpq %r14, %r13
jne 0x13bf7
leaq 0x1aa48(%rip), %rsi     # 0x2e66d
movq %rbx, %rdi
movq %r12, %rdx
callq 0xc40a
movslq -0x2c(%rbp), %r14
movq %rbx, %rdi
callq 0xae58
leaq 0x2269d(%rip), %rcx     # 0x362e0
movq %rcx, 0x8(%rax)
movq $0x0, (%rax)
movq %r14, 0x18(%rax)
leaq 0x1aa19(%rip), %rsi     # 0x2e672
movq %rbx, %rdi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc40a
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: aio_cmd_getfd
static int aio_cmd_getfd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    AioFile *af = Jim_CmdPrivData(interp);


    aio_flush(interp, af);

    Jim_SetResultInt(interp, af->fd);

    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1b8(%rdi), %r14
movq %r14, %rsi
callq 0x14e92
movslq 0x18(%r14), %r15
movq %rbx, %rdi
callq 0xae58
movq %rax, %r14
leaq 0x221ac(%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 0x14160
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
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: aio_cmd_puts
static int aio_cmd_puts(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    AioFile *af = Jim_CmdPrivData(interp);
    int wlen;
    const char *wdata;
    Jim_Obj *strObj;
    int wnow = 0;
    int nl = 1;

    if (argc == 2) {
        if (!Jim_CompareStringImmediate(interp, argv[0], "-nonewline")) {
            return -1;
        }
        strObj = argv[1];
        nl = 0;
    }
    else {
        strObj = argv[0];
    }

#ifdef JIM_MAINTAINER
    if (Jim_IsShared(af->writebuf)) {
        Jim_DecrRefCount(interp, af->writebuf);
        af->writebuf = Jim_DuplicateObj(interp, af->writebuf);
        Jim_IncrRefCount(af->writebuf);
    }
#endif
    Jim_AppendObj(interp, af->writebuf, strObj);
    if (nl) {
        Jim_AppendString(interp, af->writebuf, "\n", 1);
    }


    wdata = Jim_GetString(af->writebuf, &wlen);
    switch (af->wbuft) {
        case WBUF_OPT_NONE:

            wnow = 1;
            break;

        case WBUF_OPT_LINE:

            if (nl || memchr(wdata, '\n', wlen) != NULL) {
                wnow = 1;
            }
            break;

        case WBUF_OPT_FULL:
            if (wlen >= af->wbuf_limit) {
                wnow = 1;
            }
            break;
    }

    if (wnow) {
        return aio_flush(interp, af);
    }
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movl %esi, %r15d
movq %rdi, %r14
movq 0x1b8(%rdi), %rbx
cmpl $0x2, %esi
jne 0x143d5
movq (%r12), %rsi
leaq 0x19086(%rip), %rdx     # 0x2d447
movq %r14, %rdi
callq 0x73d6
testl %eax, %eax
je 0x1446a
addq $0x8, %r12
movq (%r12), %rdx
movq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0xafb0
cmpl $0x2, %r15d
je 0x14403
movq 0x38(%rbx), %rsi
leaq 0x185eb(%rip), %rdx     # 0x2c9e1
movq %r14, %rdi
movl $0x1, %ecx
callq 0x8653
movq 0x38(%rbx), %r13
cmpq $0x0, (%r13)
jne 0x14418
movq 0x8(%r13), %rax
movq %r13, %rdi
callq *0x18(%rax)
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0x14451
movslq 0x14(%r13), %rdx
xorl %r12d, %r12d
cmpl $0x2, %eax
je 0x1444b
cmpl $0x1, %eax
jne 0x14470
cmpl $0x2, %r15d
jne 0x14451
movq (%r13), %rdi
movl $0xa, %esi
callq 0x6290
testq %rax, %rax
jne 0x14451
jmp 0x14470
cmpq %rdx, 0x50(%rbx)
ja 0x14470
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x14e92
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl %r12d, %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: aio_cmd_isatty
static int aio_cmd_isatty(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
#ifdef HAVE_ISATTY
    AioFile *af = Jim_CmdPrivData(interp);
    Jim_SetResultInt(interp, isatty(af->fd));
#else
    Jim_SetResultInt(interp, 0);
#endif

    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1b8(%rdi), %rax
movl 0x18(%rax), %edi
callq 0x6110
movslq %eax, %r15
movq %rbx, %rdi
callq 0xae58
movq %rax, %r14
leaq 0x21e2d(%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 0x144df
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
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: 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), %rax
movq %rax, -0x30(%rbp)
xorl %ebx, %ebx
movb $0x1, %r15b
cmpl $0x2, %esi
jne 0x14658
movq 0x8(%r12), %rsi
leaq 0x17485(%rip), %rdx     # 0x2ba8e
movq %r14, %rdi
callq 0x73d6
testl %eax, %eax
jne 0x14658
movq 0x8(%r12), %rsi
leaq 0x17f4f(%rip), %rdx     # 0x2c570
movq %r14, %rdi
callq 0x73d6
testl %eax, %eax
je 0x14637
movl $0x1, %ebx
xorl %r15d, %r15d
jmp 0x14658
movq 0x8(%r12), %rsi
leaq 0x18d06(%rip), %rdx     # 0x2d349
movq %r14, %rdi
callq 0x73d6
movl $0x2, %ebx
testl %eax, %eax
je 0x14705
movq (%r12), %r12
leaq 0x21c7d(%rip), %rax     # 0x362e0
cmpq %rax, 0x8(%r12)
je 0x14682
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0xd6d7
testl %eax, %eax
je 0x14682
xorl %eax, %eax
jmp 0x14689
movq 0x18(%r12), %r13
movb $0x1, %al
movl $0x1, %r12d
testb %al, %al
je 0x146f3
testq %r13, %r13
setne %al
orb %al, %r15b
cmpb $0x1, %r15b
movq -0x30(%rbp), %r15
jne 0x146b1
movq %r14, %rdi
movq %r15, %rsi
callq 0x14e92
movl 0x18(%r15), %edi
movq %r13, %rsi
movl %ebx, %edx
callq 0x64a0
cmpq $-0x1, %rax
je 0x146e8
movq 0x30(%r15), %rsi
testq %rsi, %rsi
je 0x146de
movq %r14, %rdi
callq 0x759a
movq $0x0, 0x30(%r15)
andb $-0x5, 0xc(%r15)
xorl %r12d, %r12d
jmp 0x146f3
movq (%r15), %rsi
movq %r14, %rdi
callq 0x14d8d
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 0x146f3
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1b8(%rdi), %r14
testl %esi, %esi
je 0x14813
movq (%rdx), %r15
leaq 0x21b02(%rip), %rax     # 0x362e0
cmpq %rax, 0x8(%r15)
je 0x147fc
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0xd6d7
testl %eax, %eax
je 0x147fc
xorl %ecx, %ecx
jmp 0x14802
movl 0x18(%r15), %esi
movb $0x1, %cl
movl $0x1, %eax
testb %cl, %cl
je 0x14862
movq %r14, %rdi
callq 0x14c5d
movl 0xc(%r14), %r15d
shrl $0x4, %r15d
andl $0x1, %r15d
movq %rbx, %rdi
callq 0xae58
movq %rax, %r14
leaq 0x21aaf(%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 0x1485d
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
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: 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 0x1491e
movq %rdx, %r13
movl %esi, %r12d
movq (%rdx), %rsi
leaq 0x8(%r14), %r15
leaq 0x2235f(%rip), %rdx     # 0x36c00
movq %rbx, %rdi
movq %r15, %rcx
xorl %r8d, %r8d
movl $0x1, %r9d
callq 0x7e97
testl %eax, %eax
je 0x148c4
movl $0x1, %r15d
jmp 0x149c7
cmpl $0x2, %r12d
jne 0x1490e
cmpl $0x2, (%r15)
jne 0x1490e
movq 0x8(%r13), %r12
leaq 0x21a05(%rip), %rax     # 0x362e0
cmpq %rax, 0x8(%r12)
je 0x148fa
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0xd6d7
testl %eax, %eax
je 0x148fa
xorl %ecx, %ecx
jmp 0x14901
movq 0x18(%r12), %rax
movb $0x1, %cl
testb %cl, %cl
je 0x148b9
testq %rax, %rax
jle 0x148b9
movq %rax, 0x50(%r14)
cmpl $0x0, (%r15)
movl $0x1, %r15d
je 0x149d9
movq %rbx, %rdi
callq 0xae58
movq %rax, %r15
leaq 0x21a28(%rip), %rax     # 0x36358
movq %rax, 0x8(%r15)
movq $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movslq 0x8(%r14), %rax
leaq 0x222b2(%rip), %rcx     # 0x36c00
movq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7695
cmpl $0x2, 0x8(%r14)
jne 0x149a4
movq 0x50(%r14), %r14
movq %rbx, %rdi
callq 0xae58
leaq 0x21959(%rip), %rcx     # 0x362e0
movq %rcx, 0x8(%rax)
movq $0x0, (%rax)
movq %r14, 0x18(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7695
incl 0x10(%r15)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x149c1
movq %rbx, %rdi
callq 0x759a
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 0x14e92
testl %eax, %eax
jne 0x149c7
jmp 0x1491e
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: aio_cmd_readsize
static int aio_cmd_readsize(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    AioFile *af = Jim_CmdPrivData(interp);

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

    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1b8(%rdi), %r15
testl %esi, %esi
je 0x14a86
movq (%rdx), %r14
leaq 0x218a7(%rip), %rax     # 0x362e0
cmpq %rax, 0x8(%r14)
je 0x14a57
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0xd6d7
testl %eax, %eax
je 0x14a57
xorl %eax, %eax
jmp 0x14a5d
movq 0x18(%r14), %rsi
movb $0x1, %al
testq %rsi, %rsi
setg %cl
andb %al, %cl
movl $0x1, %eax
cmpb $0x1, %cl
jne 0x14acd
movq %rsi, 0x48(%r15)
movq 0x40(%r15), %rdi
testq %rdi, %rdi
je 0x14a86
callq *0x23806(%rip)          # 0x38288
movq %rax, 0x40(%r15)
movq 0x48(%r15), %r15
movq %rbx, %rdi
callq 0xae58
movq %rax, %r14
leaq 0x21844(%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 0x14ac8
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
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: aio_set_nonblocking
static void aio_set_nonblocking(AioFile *af, int nb)
{
#ifdef O_NDELAY
    int old = !!(af->flags & AIO_NONBLOCK);
    if (old != nb) {
        int fmode = fcntl(af->fd, F_GETFL);
        if (nb) {
            fmode |= O_NDELAY;
            af->flags |= AIO_NONBLOCK;
        }
        else {
            fmode &= ~O_NDELAY;
            af->flags &= ~AIO_NONBLOCK;
        }
        (void)fcntl(af->fd, F_SETFL, fmode);
    }
#endif
}

// Assembly:
movl 0xc(%rdi), %eax
shrl $0x4, %eax
andl $0x1, %eax
cmpl %esi, %eax
jne 0x14c6b
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movl 0x18(%rdi), %edi
movl $0x3, %esi
xorl %eax, %eax
callq 0x63f0
xorl %edx, %edx
testl %r14d, %r14d
setne %dl
andl $0xfffff7ff, %eax       # imm = 0xFFFFF7FF
movl 0xc(%rbx), %ecx
movl 0x18(%rbx), %edi
andl $-0x11, %ecx
movl %edx, %esi
shll $0x4, %esi
orl %ecx, %esi
shll $0xb, %edx
orl %eax, %edx
movl %esi, 0xc(%rbx)
movl $0x4, %esi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x63f0
// File: /workspace/github_c_makefile_star2_O1/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 0x14d31
movq 0x30(%r14), %r12
testq %r12, %r12
je 0x14d31
movl %edx, %ebx
movq %rdi, %r15
cmpq $0x0, (%r12)
jne 0x14cee
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
cmpl %ebx, 0x14(%r12)
jle 0x14d31
movq 0x30(%r14), %r12
testq %r12, %r12
je 0x14d46
cmpq $0x0, (%r12)
jne 0x14d10
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
movq (%r12), %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0x7516
movq %rax, %r15
movq 0x30(%r14), %rdi
movl %ebx, %esi
callq 0x14e1f
movq %r15, %rax
jmp 0x14d3d
movq 0x30(%r14), %rax
movq $0x0, 0x30(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x14d3d
// File: /workspace/github_c_makefile_star2_O1/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 0x14d82
movq %rsi, %r15
movq %rdi, %r14
movq 0x28(%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
testl %eax, %eax
je 0x14d82
movl %eax, %r12d
movq (%r15), %rsi
movq %r14, %rdi
callq 0x14d8d
movl %r12d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq