LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_GetReturnCode
int Jim_GetReturnCode(Jim_Interp *interp, Jim_Obj *objPtr, int *intPtr)
{
    if (objPtr->typePtr != &returnCodeObjType && SetReturnCodeFromAny(interp, objPtr) == JIM_ERR)
        return JIM_ERR;
    *intPtr = objPtr->internalRep.intValue;
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x22ae7(%rip), %r12     # 0x314c8
cmpq %r12, 0x8(%rsi)
je 0xea33
movq %rdi, %r15
leaq -0x30(%rbp), %rdx
movq %r14, %rsi
callq 0x1733a
testl %eax, %eax
je 0xea39
leaq 0x22a7f(%rip), %rdx     # 0x31480
leaq -0x24(%rbp), %rcx
movq %r15, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x7b44
testl %eax, %eax
je 0xea3f
leaq 0x19416(%rip), %rsi     # 0x27e37
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x68a7
pushq $0x1
popq %rax
jmp 0xea68
movl 0x18(%r14), %eax
jmp 0xea64
movl -0x30(%rbp), %eax
movl %eax, -0x24(%rbp)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xea59
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xea59
movq %r15, %rdi
movq %r14, %rsi
callq *%rax
movq %r12, 0x8(%r14)
movl -0x24(%rbp), %eax
movl %eax, 0x18(%r14)
movl %eax, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_GetBoolFromExpr
int Jim_GetBoolFromExpr(Jim_Interp *interp, Jim_Obj *exprObjPtr, int *boolPtr)
{
    int retcode = Jim_EvalExpression(interp, exprObjPtr);

    if (retcode == JIM_OK) {
        switch (ExprBool(interp, Jim_GetResult(interp))) {
            case 0:
                *boolPtr = 0;
                break;

            case 1:
                *boolPtr = 1;
                break;

            case -1:
                retcode = JIM_ERR;
                break;
        }
    }
    return retcode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
callq 0xcb7c
testl %eax, %eax
jne 0xebb4
movq (%r14), %rsi
movq %r14, %rdi
callq 0xebb9
cmpl $0x1, %eax
ja 0xebb1
movl %eax, (%rbx)
xorl %eax, %eax
jmp 0xebb4
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: ExprBool
static int ExprBool(Jim_Interp *interp, Jim_Obj *obj)
{
    long l;
    double d;
    int b;
    int ret = -1;


    Jim_IncrRefCount(obj);

    if (Jim_GetLong(interp, obj, &l) == JIM_OK) {
        ret = (l != 0);
    }
    else if (Jim_GetDouble(interp, obj, &d) == JIM_OK) {
        ret = (d != 0);
    }
    else if (Jim_GetBoolean(interp, obj, &b) == JIM_OK) {
        ret = (b != 0);
    }

    Jim_DecrRefCount(interp, obj);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
incl 0x10(%rsi)
leaq -0x30(%rbp), %rdx
callq 0xc8cb
testl %eax, %eax
je 0xec08
leaq -0x28(%rbp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd267
testl %eax, %eax
je 0xec12
leaq -0x1c(%rbp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd397
testl %eax, %eax
je 0xec27
pushq $-0x1
popq %r15
jmp 0xec32
xorl %r15d, %r15d
cmpq $0x0, -0x30(%rbp)
jmp 0xec2e
xorpd %xmm0, %xmm0
cmpneqsd -0x28(%rbp), %xmm0
movq %xmm0, %r15
andl $0x1, %r15d
jmp 0xec32
xorl %r15d, %r15d
cmpl $0x0, -0x1c(%rbp)
setne %r15b
movl 0x10(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
cmpl $0x1, %eax
jg 0xec4b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x73bf
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_EvalObjVector
int Jim_EvalObjVector(Jim_Interp *interp, int objc, Jim_Obj *const *objv)
{
    int i, retcode;
    Jim_EvalFrame frame;


    for (i = 0; i < objc; i++)
        Jim_IncrRefCount(objv[i]);


    JimPushEvalFrame(interp, &frame, NULL);

    retcode = JimInvokeCommand(interp, objc, objv);

    JimPopEvalFrame(interp);


    for (i = 0; i < objc; i++)
        Jim_DecrRefCount(interp, objv[i]);

    return retcode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rdi, %r14
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %r12d
cmovgl %esi, %r12d
cmpq %rax, %r12
je 0xf364
movq (%rbx,%rax,8), %rcx
incl 0x10(%rcx)
incq %rax
jmp 0xf353
xorps %xmm0, %xmm0
leaq -0x60(%rbp), %rax
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movq 0x108(%r14), %rcx
movq %rcx, 0x18(%rax)
movl 0x8(%rcx), %edx
incl %edx
movl %edx, 0x8(%rax)
movl 0x110(%r14), %edx
movl %edx, 0xc(%rax)
movq 0x58(%r14), %rdx
movq %rdx, (%rax)
movq 0x30(%rcx), %rcx
movq %rcx, 0x30(%rax)
movq %rax, 0x108(%r14)
movq %r14, %rdi
movq %rbx, %rdx
callq 0xf3ff
movl %eax, %r15d
movq 0x108(%r14), %rax
movq 0x18(%rax), %rax
movq %rax, 0x108(%r14)
xorl %r13d, %r13d
cmpq %r13, %r12
je 0xf3ed
movq (%rbx,%r13,8), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0xf3e8
movq %r14, %rdi
callq 0x73bf
incq %r13
jmp 0xf3c9
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_EvalObjPrefix
int Jim_EvalObjPrefix(Jim_Interp *interp, Jim_Obj *prefix, int objc, Jim_Obj *const *objv)
{
    int ret;
    Jim_Obj **nargv = Jim_Alloc((objc + 1) * sizeof(*nargv));

    nargv[0] = prefix;
    memcpy(&nargv[1], &objv[0], sizeof(nargv[0]) * objc);
    ret = Jim_EvalObjVector(interp, objc + 1, nargv);
    Jim_Free(nargv);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
movslq %edx, %r12
leal 0x1(%rdx), %r13d
leaq 0x8(,%r12,8), %rsi
xorl %edi, %edi
callq *0x23bca(%rip)          # 0x33288
movq %rax, %r15
movq %r14, (%rax)
leaq 0x8(%rax), %rdi
shlq $0x3, %r12
movq %rbx, %rsi
movq %r12, %rdx
callq 0x6320
movq -0x30(%rbp), %rdi
movl %r13d, %esi
movq %r15, %rdx
callq 0xf32e
movl %eax, %ebx
movq %r15, %rdi
xorl %esi, %esi
callq *0x23b95(%rip)          # 0x33288
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_O2/msteveb[P]autosetup/./jimsh0.c
// Function: JimEvalObjList
static int JimEvalObjList(Jim_Interp *interp, Jim_Obj *listPtr)
{
    int retcode = JIM_OK;
    Jim_EvalFrame frame;

    JimPanic((Jim_IsList(listPtr) == 0, "JimEvalObjList() invoked on non-list."));

    JimPushEvalFrame(interp, &frame, NULL);

    if (listPtr->internalRep.listValue.len) {
        Jim_IncrRefCount(listPtr);
        retcode = JimInvokeCommand(interp,
            listPtr->internalRep.listValue.len,
            listPtr->internalRep.listValue.ele);
        Jim_DecrRefCount(interp, listPtr);
    }

    JimPopEvalFrame(interp);

    return retcode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rax
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movq 0x108(%rdi), %rcx
movq %rcx, 0x18(%rax)
movl 0x8(%rcx), %edx
incl %edx
movl %edx, 0x8(%rax)
movl 0x110(%rdi), %edx
movl %edx, 0xc(%rax)
movq 0x58(%rdi), %rdx
movq %rdx, (%rax)
movq 0x30(%rcx), %rcx
movq %rcx, 0x30(%rax)
movq %rax, 0x108(%rdi)
movl 0x20(%rsi), %esi
testl %esi, %esi
je 0xf7ad
incl 0x10(%r14)
movq 0x18(%r14), %rdx
movq %rbx, %rdi
callq 0xf3ff
movl %eax, %r15d
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0xf7b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73bf
jmp 0xf7b0
xorl %r15d, %r15d
movq 0x108(%rbx), %rax
movq 0x18(%rax), %rax
movq %rax, 0x108(%rbx)
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: JimSetErrorStack
static void JimSetErrorStack(Jim_Interp *interp, ScriptObj *script)
{
    if (!interp->errorFlag) {
        int i;
        Jim_Obj *stackTrace = Jim_NewListObj(interp, NULL, 0);

        if (interp->procLevel == 0 && script) {
            Jim_ListAppendElement(interp, stackTrace, interp->emptyObj);
            Jim_ListAppendElement(interp, stackTrace, script->fileNameObj);
            Jim_ListAppendElement(interp, stackTrace, Jim_NewIntObj(interp, script->linenr));
            Jim_ListAppendElement(interp, stackTrace, interp->emptyObj);
        }
        else {
            for (i = 0; i <= interp->procLevel; i++) {
                Jim_EvalFrame *frame = JimGetEvalFrameByProcLevel(interp, -i);
                if (frame) {
                    JimAddStackFrame(interp, frame, stackTrace);
                }
            }
        }
        JimSetStackTrace(interp, stackTrace);
    }
}

// Assembly:
cmpl $0x0, 0x1b4(%rdi)
je 0xf856
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %esi, %esi
xorl %edx, %edx
callq 0x745b
movq %rax, %r14
movl 0x110(%rbx), %r13d
testl %r13d, %r13d
sete %al
testq %r12, %r12
setne %cl
testb %al, %cl
je 0xf8f8
movq 0x128(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x74ad
movq 0x8(%r12), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x74ad
movslq 0x20(%r12), %rsi
movq %rbx, %rdi
callq 0x8212
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x74ad
movq 0x128(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x74ad
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x191a6
xorl %r12d, %r12d
cmpl %r13d, %r12d
jg 0xf8df
movq %rbx, %rdi
movl %r15d, %esi
callq 0x190a7
testq %rax, %rax
je 0xf925
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x190e4
movl 0x110(%rbx), %r13d
incl %r12d
decl %r15d
jmp 0xf8fb
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: JimExpandDictSugar
static Jim_Obj *JimExpandDictSugar(Jim_Interp *interp, Jim_Obj *objPtr)
{
    Jim_Obj *resObjPtr = NULL;
    Jim_Obj *substKeyObjPtr = NULL;

    if (interp->safeexpr) {
        return objPtr;
    }

    SetDictSubstFromAny(interp, objPtr);

    if (Jim_SubstObj(interp, objPtr->internalRep.dictSubstValue.indexObjPtr,
            &substKeyObjPtr, JIM_NONE)
        != JIM_OK) {
        return NULL;
    }
    Jim_IncrRefCount(substKeyObjPtr);
    resObjPtr =
        JimDictExpandArrayVariable(interp, objPtr->internalRep.dictSubstValue.varNameObjPtr,
        substKeyObjPtr, 0);
    Jim_DecrRefCount(interp, substKeyObjPtr);

    return resObjPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
andq $0x0, -0x20(%rbp)
movq %rsi, %rbx
cmpl $0x0, 0xb0(%rdi)
jne 0xf9a4
movq %rdi, %r14
movq %rbx, %rsi
callq 0x16598
movq 0x20(%rbx), %rsi
leaq -0x20(%rbp), %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xfecc
testl %eax, %eax
je 0xf96d
xorl %ebx, %ebx
jmp 0xf9a4
movq -0x20(%rbp), %r15
incl 0x10(%r15)
movq 0x18(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x166be
movq %rax, %rbx
movl 0x10(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r15)
cmpl $0x1, %eax
jg 0xf9a4
movq %r14, %rdi
movq %r15, %rsi
callq 0x73bf
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_EvalGlobal
int Jim_EvalGlobal(Jim_Interp *interp, const char *script)
{
    int retval;
    Jim_CallFrame *savedFramePtr = interp->framePtr;

    interp->framePtr = interp->topFramePtr;
    retval = Jim_Eval(interp, script);
    interp->framePtr = savedFramePtr;

    return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %r14
movq 0x60(%rdi), %rax
movq %rax, 0x58(%rdi)
callq 0xfce7
movq %r14, 0x58(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_EvalFileGlobal
int Jim_EvalFileGlobal(Jim_Interp *interp, const char *filename)
{
    int retval;
    Jim_CallFrame *savedFramePtr = interp->framePtr;

    interp->framePtr = interp->topFramePtr;
    retval = Jim_EvalFile(interp, filename);
    interp->framePtr = savedFramePtr;

    return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %r14
movq 0x60(%rdi), %rax
movq %rax, 0x58(%rdi)
callq 0xfd51
movq %r14, 0x58(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x17ba3(%rip), %r15     # 0x27924
cmpl $-0x1, %eax
je 0xfe90
movq %r14, %rdi
xorl %esi, %esi
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x63d0
testl %eax, %eax
js 0xfe90
movl %eax, %r12d
movq -0x88(%rbp), %r13
leaq 0x1(%r13), %rsi
xorl %edi, %edi
callq *0x234cf(%rip)          # 0x33288
movq %rax, %r15
movl %r12d, %edi
movq %rax, %rsi
movq %r13, %rdx
callq 0x62a0
movq %rax, %r13
movl %r12d, %edi
callq 0x6260
testl %r13d, %r13d
js 0xfe7e
movl %r13d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movb $0x0, (%r15,%rax)
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
callq 0xa654
testq %rax, %rax
je 0xfeaf
movq %rax, %r15
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7363
movq %rax, %r14
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb3cf
movq 0x10(%rbx), %r12
incl 0x10(%r14)
movq %r14, 0x10(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8b54
movl %eax, %r14d
movq 0x10(%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0xfe5b
movq %rbx, %rdi
callq 0x73bf
movq %r12, 0x10(%rbx)
cmpl $0x2, %r14d
jne 0xfeb3
movl 0x2c(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x2c(%rbx)
cmpl $0x1, %eax
jg 0xfec8
movl 0x28(%rbx), %r14d
andq $0x0, 0x28(%rbx)
jmp 0xfeb3
movq %r15, %rdi
xorl %esi, %esi
callq *0x233ff(%rip)          # 0x33288
leaq 0x18445(%rip), %r15     # 0x282d5
callq 0x6080
movl (%rax), %edi
callq 0x64b0
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x68a7
pushq $0x1
popq %r14
movl %r14d, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x2
jmp 0xfeb1
// File: /workspace/github_c_makefile_star2_O2/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 $0x38, %rsp
movl %r8d, %r13d
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
movq %rsi, -0x60(%rbp)
testb $0x1, %r13b
jne 0x101e8
pushq $0x1
jmp 0x10200
leaq 0x16883(%rip), %rsi     # 0x26a72
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x7363
movq %rax, -0x58(%rbp)
pushq $0x2
popq %r12
testb $0x2, %r13b
je 0x10225
leaq 0x18400(%rip), %rsi     # 0x2860f
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x7363
movl %r12d, %ecx
incl %r12d
movq %rax, -0x60(%rbp,%rcx,8)
movl %r12d, %eax
movq %r15, -0x60(%rbp,%rax,8)
addl $0x2, %r12d
movq %r14, -0x58(%rbp,%rax,8)
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
movl %r12d, %esi
callq 0xf32e
movl %eax, %r14d
testl %eax, %eax
jne 0x1025f
movq (%rbx), %rsi
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0xc8cb
testl %eax, %eax
je 0x10274
negl %r14d
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl -0x30(%rbp), %r14d
jmp 0x10262
// File: /workspace/github_c_makefile_star2_O2/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, %r14d
movl %ecx, %r13d
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
callq 0xe0fd
testl %eax, %eax
je 0x102ab
pushq $0x1
popq %rax
jmp 0x10382
movl %r14d, -0x2c(%rbp)
movq 0x18(%r15), %r15
xorl %r14d, %r14d
movq %rbx, -0x48(%rbp)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x745b
movq %rax, -0x38(%rbp)
movq %r12, %rcx
movq %r12, -0x40(%rbp)
movslq 0x20(%r15), %rax
cmpq %rax, %r14
jge 0x10355
movl %r13d, %r12d
movq %r15, %rbx
movq 0x18(%r15), %rax
movq (%rax,%r14,8), %r13
movq 0x8(%rax,%r14,8), %r15
testq %rcx, %rcx
je 0x10310
cmpl $0x1, %r12d
movq %r15, %rdx
cmoveq %r13, %rdx
movq -0x40(%rbp), %rsi
xorl %ecx, %ecx
callq 0xa85d
movq -0x40(%rbp), %rcx
testl %eax, %eax
je 0x10346
movl -0x2c(%rbp), %eax
testb $0x1, %al
je 0x1032e
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %r13, %rdx
callq 0x74ad
movq -0x40(%rbp), %rcx
movl -0x2c(%rbp), %eax
testb $0x2, %al
je 0x10346
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %r15, %rdx
callq 0x74ad
movq -0x40(%rbp), %rcx
addq $0x2, %r14
movl %r12d, %r13d
movq %rbx, %r15
jmp 0x102d1
movq -0x38(%rbp), %rax
incl 0x10(%rax)
movq -0x48(%rbp), %rbx
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x10379
movq %rbx, %rdi
callq 0x73bf
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_O2/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, %r14
movq %rdi, %rbx
callq 0xe0fd
testl %eax, %eax
je 0x103de
pushq $0x1
popq %r14
jmp 0x10434
movq 0x18(%r14), %rax
movl 0x8(%rax), %r8d
movl 0x20(%rax), %ecx
leaq 0x16bf5(%rip), %rdx     # 0x26fe5
xorl %r14d, %r14d
leaq -0x80(%rbp), %r15
pushq $0x64
popq %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x61e0
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7363
movq %rax, %r15
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x10431
movq %rbx, %rdi
callq 0x73bf
movq %r15, (%rbx)
movl %r14d, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x8
popq %r14
leaq 0x210a6(%rip), %r15     # 0x31520
cmpq $0x428, %r14            # imm = 0x428
je 0x1049f
movq -0x8(%r14,%r15), %rsi
movq (%r14,%r15), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6bac
addq $0x10, %r14
jmp 0x1047a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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 0x16b48(%rip), %rsi     # 0x27005
pushq $-0x1
popq %rdx
callq 0x7363
leaq -0x20(%rbp), %rdx
movq %rax, (%rdx)
movq (%rbx), %rax
movq %rax, 0x8(%rdx)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf32e
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x16b0f(%rip), %rdx     # 0x2700f
callq 0x7223
testl %eax, %eax
je 0x10583
movq %r14, %rdi
callq 0x10597
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x745b
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 0x1053f
movq %rbx, %rdi
callq 0x73bf
movq %r15, (%rbx)
pushq $-0x1
popq %r15
movq %r14, %r13
movq (%r13), %rsi
testq %rsi, %rsi
je 0x10574
movq (%rbx), %r12
movq %rbx, %rdi
movl %r15d, %edx
callq 0x7363
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x74ad
addq $0x8, %r13
jmp 0x10549
xorl %ebx, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq *0x22d07(%rip)          # 0x33288
jmp 0x10586
pushq $0x1
popq %rbx
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_O2/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 0x105a7
leaq (,%rbx,8), %r15
leaq 0x8(,%rbx,8), %rax
movabsq $0x7fffffff8, %rsi      # imm = 0x7FFFFFFF8
andq %rax, %rsi
xorl %edi, %edi
callq *0x22caf(%rip)          # 0x33288
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6320
leaq 0x10858(%rip), %rcx     # 0x20e49
pushq $0x8
popq %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x6100
andq $0x0, (%r12,%rbx,8)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
testl %ebx, %ebx
cmovlel %r13d, %ebx
pushq $-0x1
popq %r12
cmpq %r13, %rbx
je 0x10656
movq (%r14,%r13,8), %rdi
testq %rdi, %rdi
je 0x1064e
movq %r15, %rsi
callq 0x62e0
testl %eax, %eax
je 0x10653
incq %r13
jmp 0x10634
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_O2/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 %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
je 0x10729
movq (%rbx), %r15
movq %rdx, %rdi
callq 0x7340
leaq 0x18e4e(%rip), %rcx     # 0x29564
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xa731
movq (%rbx), %rsi
movq (%r14), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xa731
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0x1076a
cmpb $0x0, (%rcx)
je 0x1076a
movq (%rbx), %rsi
leaq 0x18e11(%rip), %rdx     # 0x29564
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa731
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x745b
movq %rax, %r15
pushq $-0x1
popq %r13
movq (%r12), %rsi
testq %rsi, %rsi
je 0x10b04
testb $0x1, 0x1c(%r12)
jne 0x10afe
movq %r14, %rdi
movl %r13d, %edx
callq 0x7363
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x74ad
addq $0x20, %r12
jmp 0x10ad4
leaq 0x17845(%rip), %rsi     # 0x28350
pushq $-0x1
popq %rdx
movq %r14, %rdi
callq 0x7363
leaq -0x40(%rbp), %rdx
movq %rax, (%rdx)
movq %r15, 0x8(%rdx)
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0xf32e
movq (%r14), %r15
testl %eax, %eax
jne 0x10b4e
movq %rbx, %rdi
callq 0x6180
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl %eax, %ecx
callq 0xdc89
movq %rax, %r15
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq $0x1
popq %r12
testq %rsi, %rsi
je 0x10bfc
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testb $0x2, 0x1c(%rsi)
movq 0x10(%rsi), %rcx
jne 0x10be0
addl $-0x2, %edx
leaq 0x10(%r14), %rax
movq %r15, %rdi
movl %edx, %esi
movq %rax, %rdx
jmp 0x10be8
movq %r15, %rdi
movl %edx, %esi
movq %r14, %rdx
callq *%rcx
testl %eax, %eax
jns 0x10bff
movq (%r14), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1067e
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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 0x10c1e
movb %sil, (%rdi)
movl $0x1, %eax
jmp 0x10ca2
movl %esi, %eax
cmpl $0x7ff, %esi            # imm = 0x7FF
ja 0x10c42
shrl $0x6, %eax
orb $-0x40, %al
movb %al, (%rdi)
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0x1(%rdi)
movl $0x2, %eax
jmp 0x10ca2
cmpl $0xffff, %esi           # imm = 0xFFFF
ja 0x10c70
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 0x10ca2
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_O2/msteveb[P]autosetup/./jimsh0.c
// Function: regnext
static int regnext(regex_t *preg, int p )
{
	int offset;

	offset = NEXT(preg, p);

	if (offset == 0)
		return 0;

	if (OP(preg, p) == BACK)
		return(p-offset);
	else
		return(p+offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %eax
movq 0x20(%rdi), %rdx
movslq %esi, %rsi
movl 0x4(%rdx,%rsi,4), %ecx
testl %ecx, %ecx
je 0x117e1
cmpl $0x7, (%rdx,%rsi,4)
jne 0x117e5
subl %ecx, %eax
jmp 0x117e7
xorl %eax, %eax
jmp 0x117e7
addl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
testl %edx, %edx
je 0x11822
movl %r15d, %edi
callq 0x60e0
movl %eax, %r15d
xorl %r12d, %r12d
leaq -0x2c(%rbp), %r13
cmpb $0x0, (%rbx)
je 0x1184b
movq %rbx, %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0x2194d
incq %rbx
cmpl -0x2c(%rbp), %r15d
jne 0x11829
decq %rbx
movq %rbx, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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, %ebx
movq %rdx, %r15
movq %rdi, %r12
movl %esi, %r14d
xorl %r13d, %r13d
cmpl %r13d, %r14d
je 0x118a7
leaq (%r15,%r13), %rdi
cmpb $0x0, (%rdi)
je 0x118a2
leaq -0x2c(%rbp), %rsi
movl %ebx, %edx
callq 0x2194d
movl -0x2c(%rbp), %eax
leaq 0x1(%r13), %rcx
cmpl (%r12,%r13,4), %eax
movq %rcx, %r13
je 0x11879
pushq $-0x1
popq %rax
jmp 0x118aa
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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), %rax
xorl %ecx, %ecx
cmpq %rax, %rcx
jge 0x118e6
movq 0x58(%rbx), %rdx
orq $-0x1, (%rdx,%rcx,8)
incq %rcx
jmp 0x118d3
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x21b45
testl %eax, %eax
je 0x11910
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 0x11913
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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, %r14d
movq %rdi, %rbx
testq %rsi, %rsi
je 0x1198f
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x7363
movq %rax, %r15
jmp 0x11a10
leaq 0x1596c(%rip), %rdi     # 0x27302
callq 0x6030
testq %rax, %rax
je 0x119b7
movq %rax, %r12
cmpb $0x0, (%rax)
je 0x119b7
pushq $0x2
popq %rsi
movq %r12, %rdi
callq 0x6430
testl %eax, %eax
je 0x119be
leaq 0x1594b(%rip), %r12     # 0x27309
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7363
movq %rax, %r15
cmpb $0x0, (%r12)
je 0x119fb
movq %r12, %rdi
callq 0x6180
cmpb $0x2f, -0x1(%rax,%r12)
je 0x119fb
leaq 0x15920(%rip), %rdx     # 0x2730d
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x823a
leaq 0x1590d(%rip), %rdx     # 0x2730f
pushq $-0x1
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x823a
pushq $0x7f
popq %rdi
callq 0x6300
movl %eax, %r13d
movq (%r15), %rdi
callq 0x62b0
movl %eax, %r12d
movl %r13d, %edi
callq 0x6300
testl %r12d, %r12d
js 0x11a6a
testl %r14d, %r14d
je 0x11a48
movq %r15, %rdi
callq 0x7340
movq %rax, %rdi
callq 0x60a0
incl 0x10(%r15)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x11a65
movq %rbx, %rdi
callq 0x73bf
movq %r15, (%rbx)
jmp 0x11a8c
pushq $-0x1
popq %r12
movq %r15, %rdi
callq 0x7340
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1192f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73bf
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_O2/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 0x11aeb
movl %edi, %ecx
cmpl $0xd, %edi
jne 0x11af4
leaq 0x1583c(%rip), %rbx     # 0x27325
jmp 0x11b0f
leaq 0x1582c(%rip), %rbx     # 0x2731e
jmp 0x11b0f
leaq 0x2179e(%rip), %rbx     # 0x33299
leaq 0x1763b(%rip), %rdx     # 0x2913d
pushq $0xa
popq %rsi
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_O2/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 *0x21755(%rip)          # 0x33288
movq %rax, %rbx
movq 0x2143b(%rip), %r15     # 0x32f78
movq (%r15), %rsi
movq %r14, %rdi
callq 0x6230
movq (%r15), %rdi
callq 0x6370
movq 0x21431(%rip), %rax     # 0x32f88
movq (%rax), %rdx
movq %rbx, %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x62c0
testq %rax, %rax
je 0x11b88
movq %rbx, %rdi
callq 0x6180
testl %eax, %eax
je 0x11b95
decl %eax
cltq
cmpb $0xa, (%rbx,%rax)
jne 0x11b95
movb $0x0, (%rbx,%rax)
jmp 0x11b95
movq %rbx, %rdi
xorl %esi, %esi
callq *0x216f5(%rip)          # 0x33288
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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 0x15581(%rip), %rdi     # 0x27360
pushq $0x54
popq %rdx
xorl %esi, %esi
xorl %eax, %eax
callq 0x61d0
leaq 0x15583(%rip), %rdi     # 0x27375
movq %rbx, %rsi
xorl %eax, %eax
callq 0x61d0
leaq 0x1557d(%rip), %rdi     # 0x27380
movq %rbx, %rsi
xorl %eax, %eax
callq 0x61d0
pushq $0xa
popq %rbx
movl %ebx, %edi
callq 0x6050
leaq 0x17847(%rip), %rdi     # 0x29665
callq 0x60f0
movl %ebx, %edi
callq 0x6050
leaq 0x17856(%rip), %rdi     # 0x29687
callq 0x60f0
leaq 0x17853(%rip), %rdi     # 0x29690
callq 0x60f0
leaq 0x17874(%rip), %rdi     # 0x296bd
callq 0x60f0
leaq 0x1788c(%rip), %rdi     # 0x296e1
callq 0x60f0
leaq 0x178a8(%rip), %rdi     # 0x29709
callq 0x60f0
leaq 0x178f7(%rip), %rdi     # 0x29764
callq 0x60f0
leaq 0x17944(%rip), %rdi     # 0x297bd
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x60f0
// File: /workspace/github_c_makefile_star2_O2/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, %r13d
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %esi, %esi
xorl %edx, %edx
callq 0x745b
movq %rax, %r12
movl %r13d, %eax
testl %r13d, %r13d
movl $0x0, %r13d
movl %eax, -0x2c(%rbp)
cmovgl %eax, %r13d
cmpq %r14, %r13
je 0x12154
movq (%r15,%r14,8), %rsi
movq %rbx, %rdi
pushq $-0x1
popq %rdx
callq 0x7363
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x74ad
incq %r14
jmp 0x1212d
leaq 0x17500(%rip), %rsi     # 0x2965b
movq %rbx, %rdi
movq %r12, %rdx
callq 0xb92d
movslq -0x2c(%rbp), %rsi
movq %rbx, %rdi
callq 0x8212
leaq 0x174e7(%rip), %rsi     # 0x29660
movq %rbx, %rdi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb92d
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
movq 0x1b8(%rdi), %r14
movq %r14, %rsi
callq 0x130af
movslq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x8212
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x12599
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movl %esi, %r15d
movq %rdi, %r14
movq 0x1b8(%rdi), %rbx
cmpl $0x2, %esi
jne 0x12794
movq (%r12), %rsi
leaq 0x15cb9(%rip), %rdx     # 0x28439
movq %r14, %rdi
callq 0x7223
testl %eax, %eax
je 0x12817
addq $0x8, %r12
movq (%r12), %rdx
movq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0xa6f6
cmpl $0x2, %r15d
je 0x127c0
movq 0x38(%rbx), %rsi
leaq 0x1521e(%rip), %rdx     # 0x279d3
pushq $0x1
popq %rcx
movq %r14, %rdi
callq 0x823a
movq 0x38(%rbx), %rdi
leaq -0x24(%rbp), %rsi
callq 0x7fc7
movl 0x8(%rbx), %ecx
testl %ecx, %ecx
je 0x12807
xorl %r12d, %r12d
cmpl $0x2, %ecx
je 0x127fd
cmpl $0x1, %ecx
jne 0x1281b
cmpl $0x2, %r15d
jne 0x12807
movslq -0x24(%rbp), %rdx
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x6290
testq %rax, %rax
jne 0x12807
jmp 0x1281b
movslq -0x24(%rbp), %rax
cmpq %rax, 0x50(%rbx)
ja 0x1281b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x130af
movl %eax, %r12d
jmp 0x1281b
pushq $-0x1
popq %r12
movl %r12d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq