LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_DictKey
int Jim_DictKey(Jim_Interp *interp, Jim_Obj *dictPtr, Jim_Obj *keyPtr,
    Jim_Obj **objPtrPtr, int flags)
{
    int tvoffset;
    Jim_Dict *dict;

    if (SetDictFromAny(interp, dictPtr) != JIM_OK) {
        return -1;
    }
    dict = dictPtr->internalRep.dictValue;
    tvoffset = JimDictHashFind(dict, keyPtr, DICT_HASH_FIND);
    if (tvoffset == 0) {
        if (flags & JIM_ERRMSG) {
            Jim_SetResultFormatted(interp, "key \"%#s\" not known in dictionary", keyPtr);
        }
        return JIM_ERR;
    }
    *objPtrPtr = dict->table[tvoffset];
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, -0x2c(%rbp)
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
callq 0xf08c
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0xf538
movq 0x18(%r12), %r12
movq %r12, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xf54a
testl %eax, %eax
je 0xf518
movq 0x18(%r12), %rcx
cltq
movq (%rcx,%rax,8), %rax
movq %rax, (%rbx)
xorl %r13d, %r13d
jmp 0xf538
movl $0x1, %r13d
testb $0x1, -0x2c(%rbp)
je 0xf538
leaq 0x1ba2a(%rip), %rsi     # 0x2af55
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x6923
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_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_DictPairs
Jim_Obj **Jim_DictPairs(Jim_Interp *interp, Jim_Obj *dictPtr, int *len)
{

    if (Jim_IsList(dictPtr)) {
        Jim_Obj **table;
        JimListGetElements(interp, dictPtr, len, &table);
        if (*len % 2 == 0) {
            return table;
        }

    }
    if (SetDictFromAny(interp, dictPtr) != JIM_OK) {

        *len = 1;
        return NULL;
    }
    *len = dictPtr->internalRep.dictValue->len;
    return dictPtr->internalRep.dictValue->table;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x25cb4(%rip), %rax     # 0x35368
cmpq %rax, 0x8(%rsi)
jne 0xf6d5
movq %r15, %rdi
movq %rbx, %rsi
callq 0xe2fe
movl 0x20(%rbx), %eax
movl %eax, (%r14)
testb $0x1, %al
jne 0xf6d5
movq 0x18(%rbx), %rax
jmp 0xf701
movq %r15, %rdi
movq %rbx, %rsi
callq 0xf08c
testl %eax, %eax
je 0xf6ef
movl $0x1, (%r14)
xorl %eax, %eax
jmp 0xf701
movq 0x18(%rbx), %rax
movl 0x20(%rax), %eax
movl %eax, (%r14)
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_DictKeysVector
int Jim_DictKeysVector(Jim_Interp *interp, Jim_Obj *dictPtr,
    Jim_Obj *const *keyv, int keyc, Jim_Obj **objPtrPtr, int flags)
{
    int i;

    if (keyc == 0) {
        *objPtrPtr = dictPtr;
        return JIM_OK;
    }

    for (i = 0; i < keyc; i++) {
        Jim_Obj *objPtr;

        int rc = Jim_DictKey(interp, dictPtr, keyv[i], &objPtr, flags);
        if (rc != JIM_OK) {
            return rc;
        }
        dictPtr = objPtr;
    }
    *objPtrPtr = dictPtr;
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, -0x30(%rbp)
testl %ecx, %ecx
jle 0xf756
movl %r9d, %r14d
movq %rdx, %r15
movq %rdi, %r12
movl %ecx, %ebx
xorl %r13d, %r13d
movq (%r15,%r13,8), %rdx
movq %r12, %rdi
leaq -0x38(%rbp), %rcx
movl %r14d, %r8d
callq 0xf4bf
testl %eax, %eax
jne 0xf75f
movq -0x38(%rbp), %rsi
incq %r13
cmpq %r13, %rbx
jne 0xf733
movq -0x30(%rbp), %rax
movq %rsi, (%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: 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
movq 0x8(%rsi), %rax
leaq 0x25975(%rip), %r12     # 0x35428
cmpq %r12, %rax
je 0xfb45
movq %rdi, %r15
leaq 0x2582a(%rip), %rcx     # 0x352f0
cmpq %rcx, %rax
je 0xfb17
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xd6c3
testl %eax, %eax
je 0xfb17
leaq 0x258fd(%rip), %rdx     # 0x353e0
leaq -0x24(%rbp), %rcx
movq %r15, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x7eac
testl %eax, %eax
je 0xfb1e
leaq 0x1c2e4(%rip), %rsi     # 0x2bde7
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x6923
movl $0x1, %eax
jmp 0xfb4d
movl 0x18(%r14), %eax
movl %eax, -0x24(%rbp)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xfb38
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xfb38
movq %r15, %rdi
movq %r14, %rsi
callq *%rax
movq %r12, 0x8(%r14)
movl -0x24(%rbp), %eax
movl %eax, 0x18(%r14)
jmp 0xfb49
movl 0x18(%r14), %eax
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_O3/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 0xd8ce
testl %eax, %eax
jne 0xfc9f
movq (%r14), %rsi
movq %r14, %rdi
callq 0xfca4
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x1, %ecx
ja 0xfc9f
movl %ecx, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
incl 0x10(%rsi)
movq %rdi, %r14
leaq 0x2562f(%rip), %rax     # 0x352f0
cmpq %rax, 0x8(%rsi)
je 0xfd10
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0xd6c3
testl %eax, %eax
je 0xfd10
leaq -0x28(%rbp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe040
testl %eax, %eax
je 0xfd43
leaq -0x1c(%rbp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe195
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0xfd1c
xorl %r15d, %r15d
cmpl $0x0, -0x1c(%rbp)
jmp 0xfd18
xorl %r15d, %r15d
cmpq $0x0, 0x18(%rbx)
setne %r15b
movl 0x10(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
cmpl $0x1, %eax
jg 0xfd35
movq %r14, %rdi
movq %rbx, %rsi
callq 0x758c
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorpd %xmm0, %xmm0
cmpneqsd -0x28(%rbp), %xmm0
movq %xmm0, %r15
andl $0x1, %r15d
jmp 0xfd1c
// File: /workspace/github_c_makefile_star2_O3/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
movl %esi, %r15d
movq %rdi, %r14
movl %esi, %r13d
testl %esi, %esi
jle 0x10463
xorl %eax, %eax
movq (%rbx,%rax,8), %rcx
incl 0x10(%rcx)
incq %rax
cmpq %rax, %r13
jne 0x10454
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
movl %r15d, %esi
movq %rbx, %rdx
callq 0x10504
movl %eax, %r12d
movq 0x108(%r14), %rax
movq 0x18(%rax), %rax
movq %rax, 0x108(%r14)
testl %r15d, %r15d
jle 0x104f2
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x104ea
movq %r14, %rdi
callq 0x758c
incq %r15
cmpq %r15, %r13
jne 0x104d0
movl %r12d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: 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 *0x26a55(%rip)          # 0x37288
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 0x10431
movl %eax, %ebx
movq %r15, %rdi
xorl %esi, %esi
callq *0x26a20(%rip)          # 0x37288
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_O3/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 0x109d4
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0xae38
movq %rax, %r14
leaq 0x24971(%rip), %rax     # 0x35368
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movl 0x110(%rbx), %r12d
testl %r12d, %r12d
sete %al
testq %r15, %r15
setne %cl
testb %al, %cl
je 0x10a86
movq 0x128(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7683
movq 0x8(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7683
movslq 0x20(%r15), %r15
movq %rbx, %rdi
callq 0xae38
leaq 0x2489b(%rip), %rcx     # 0x352f0
movq %rcx, 0x8(%rax)
movq $0x0, (%rax)
movq %r15, 0x18(%rax)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7683
movq 0x128(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7683
jmp 0x10ac4
testl %r12d, %r12d
js 0x10ac4
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
xorl %r15d, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1b792
testq %rax, %rax
je 0x10ab9
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x1b7cd
movl 0x110(%rbx), %r12d
incl %r13d
decl %r15d
cmpl %r12d, %r13d
jl 0x10a94
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1b8ae
// File: /workspace/github_c_makefile_star2_O3/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
movq %rsi, %rbx
movq $0x0, -0x20(%rbp)
cmpl $0x0, 0xb0(%rdi)
jne 0x10b57
movq %rdi, %r14
movq %rbx, %rsi
callq 0x186a9
movq 0x20(%rbx), %rsi
leaq -0x20(%rbp), %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x1113d
testl %eax, %eax
je 0x10b20
xorl %ebx, %ebx
jmp 0x10b57
movq -0x20(%rbp), %r15
incl 0x10(%r15)
movq 0x18(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x187d5
movq %rax, %rbx
movl 0x10(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r15)
cmpl $0x1, %eax
jg 0x10b57
movq %r14, %rdi
movq %r15, %rsi
callq 0x758c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: 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)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq %rbx, %rdi
movq %rax, %rsi
callq 0x908a
movq %r14, 0x58(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10f95
movq %r14, 0x58(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1a90f(%rip), %r15     # 0x2b8d4
cmpl $-0x1, %eax
je 0x11103
movq %r14, %rdi
xorl %esi, %esi
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x63d0
testl %eax, %eax
js 0x11103
movl %eax, %r12d
movq -0x88(%rbp), %r13
leaq 0x1(%r13), %rsi
xorl %edi, %edi
callq *0x2628b(%rip)          # 0x37288
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 0x110f1
movl %r13d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movb $0x0, (%r15,%rax)
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
callq 0xaee8
testq %rax, %rax
je 0x11122
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq %rax, %r14
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x11076
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x11076
movq %rbx, %rdi
movq %r15, %rsi
callq *%rax
incl 0x10(%r14)
movq %r14, 0x18(%r15)
movl $0x1, 0x20(%r15)
leaq 0x2415b(%rip), %rax     # 0x351e8
movq %rax, 0x8(%r15)
movq 0x10(%rbx), %r12
incl 0x10(%r14)
movq %r14, 0x10(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x908a
movl %eax, %r14d
movq 0x10(%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x110c5
movq %rbx, %rdi
callq 0x758c
movq %r12, 0x10(%rbx)
cmpl $0x2, %r14d
jne 0x11128
movl 0x2c(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x2c(%rbx)
movl $0x2, %r14d
cmpl $0x1, %eax
jg 0x11128
movl 0x28(%rbx), %r14d
movq $0x0, 0x28(%rbx)
jmp 0x11128
movq %r15, %rdi
xorl %esi, %esi
callq *0x2618c(%rip)          # 0x37288
leaq 0x1b182(%rip), %r15     # 0x2c285
callq 0x6080
movl (%rax), %edi
callq 0x64b0
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x6923
movl $0x1, %r14d
movl %r14d, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: 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 0x114b3
leaq 0x19586(%rip), %rsi     # 0x2aa22
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq %rax, -0x48(%rbp)
movl $0x2, %r12d
testb $0x2, %r13b
je 0x114d8
leaq 0x1b0ff(%rip), %rsi     # 0x2c5bf
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
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 0x10431
movl %eax, %r14d
testl %eax, %eax
je 0x11504
negl %r14d
jmp 0x1152c
movq (%rbx), %r15
leaq 0x23de2(%rip), %rax     # 0x352f0
cmpq %rax, 0x8(%r15)
je 0x11528
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0xd6c3
testl %eax, %eax
jne 0x114ff
movl 0x18(%r15), %r14d
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: 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 0xf08c
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x11641
movl %r13d, -0x44(%rbp)
movl %r15d, -0x2c(%rbp)
movq 0x18(%rbx), %r13
movq %r14, -0x40(%rbp)
movq %r14, %rdi
callq 0xae38
leaq 0x23dd7(%rip), %rcx     # 0x35368
movq %rcx, 0x8(%rax)
movq $0x0, (%rax)
xorps %xmm0, %xmm0
movq %rax, -0x38(%rbp)
movups %xmm0, 0x18(%rax)
cmpl $0x0, 0x20(%r13)
jle 0x11614
xorl %r14d, %r14d
movq 0x18(%r13), %rax
movq (%rax,%r14,8), %rbx
movq 0x8(%rax,%r14,8), %r15
testq %r12, %r12
je 0x115dc
cmpl $0x1, -0x44(%rbp)
movq %r15, %rdx
cmoveq %rbx, %rdx
movq %r12, %rsi
xorl %ecx, %ecx
callq 0xb104
testl %eax, %eax
je 0x1160a
movl -0x2c(%rbp), %eax
testb $0x1, %al
je 0x115f6
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rbx, %rdx
callq 0x7683
movl -0x2c(%rbp), %eax
testb $0x2, %al
je 0x1160a
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %r15, %rdx
callq 0x7683
addq $0x2, %r14
cmpl %r14d, 0x20(%r13)
jg 0x115b1
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 0x11638
movq %rbx, %rdi
callq 0x758c
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_O3/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 0xf08c
movl $0x1, %r14d
testl %eax, %eax
jne 0x116fc
movq 0x18(%r15), %rax
movl 0x8(%rax), %r8d
movl 0x20(%rax), %ecx
leaq 0x198e1(%rip), %rdx     # 0x2af95
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 0x7508
movq %rax, %r15
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x116f9
movq %rbx, %rdi
callq 0x758c
movq %r15, (%rbx)
movl %r14d, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1b984(%rip), %r14     # 0x2d0c3
movl $0x10, %r15d
leaq 0x23d34(%rip), %r12     # 0x35480
movq %rbx, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq -0x8(%r15,%r12), %rdx
movq (%r15,%r12), %r14
movq %rbx, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xbec5
addq $0x10, %r15
cmpq $0x430, %r15            # imm = 0x430
jne 0x1174c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x19817(%rip), %rsi     # 0x2afb5
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
leaq -0x20(%rbp), %rdx
movq %rax, (%rdx)
movq (%rbx), %rax
movq %rax, 0x8(%rdx)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10431
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x197dd(%rip), %rdx     # 0x2afbf
callq 0x73c6
testl %eax, %eax
je 0x11888
movq %r14, %rdi
callq 0x11898
movq %rax, %r14
movq %rbx, %rdi
callq 0xae38
movq %rax, %r15
leaq 0x23b5c(%rip), %rax     # 0x35368
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 0x1183c
movq %rbx, %rdi
callq 0x758c
movq %r15, (%rbx)
movq (%r14), %rsi
testq %rsi, %rsi
je 0x11879
movq %r14, %r12
addq $0x8, %r12
movq (%rbx), %r15
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7683
movq (%r12), %rsi
addq $0x8, %r12
testq %rsi, %rsi
jne 0x1184e
xorl %ebx, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq *0x25a02(%rip)          # 0x37288
jmp 0x1188d
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: 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 0x118a8
leaq (,%rbx,8), %r15
leaq 0x8(,%rbx,8), %rax
movabsq $0x7fffffff8, %rsi      # imm = 0x7FFFFFFF8
andq %rax, %rsi
xorl %edi, %edi
callq *0x259ae(%rip)          # 0x37288
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6320
leaq 0x134ca(%rip), %rcx     # 0x24dbc
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_O3/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 0x11963
movq %rsi, %r15
movq %rdi, %r12
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movq (%r15,%r13,8), %rdi
testq %rdi, %rdi
je 0x11956
movq %r12, %rsi
callq 0x62e0
testl %eax, %eax
je 0x11960
incq %r13
cmpq %r13, %r14
jne 0x11941
jmp 0x11963
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_O3/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 0x11a47
movq %rdx, %r12
movq (%rbx), %r15
movq (%rdx), %rdx
testq %rdx, %rdx
jne 0x11a30
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
movq (%r12), %rdx
leaq 0x1badd(%rip), %rcx     # 0x2d514
movq %rbx, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xafd1
movq (%rbx), %rsi
movq (%r14), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xafd1
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0x11a86
cmpb $0x0, (%rcx)
je 0x11a86
movq (%rbx), %rsi
leaq 0x1baa3(%rip), %rdx     # 0x2d514
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xafd1
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xae38
movq %rax, %r15
leaq 0x2351e(%rip), %rax     # 0x35368
movq %rax, 0x8(%r15)
movq $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movq (%r12), %rsi
testq %rsi, %rsi
je 0x11e9a
addq $0x20, %r12
testb $0x1, -0x4(%r12)
jne 0x11e8d
movq %r14, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7683
movq (%r12), %rsi
addq $0x20, %r12
testq %rsi, %rsi
jne 0x11e6a
leaq 0x1a45f(%rip), %rsi     # 0x2c300
movq %r14, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
leaq -0x30(%rbp), %rdx
movq %rax, (%rdx)
movq %r15, 0x8(%rdx)
movq %r14, %rdi
movl $0x2, %esi
callq 0x10431
movq (%r14), %r15
testl %eax, %eax
jne 0x11ee8
movq %rbx, %rdi
callq 0x6180
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl %eax, %ecx
callq 0xeba5
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_O3/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 0x11fa3
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 0x11f78
addl $-0x2, %edx
leaq 0x10(%r14), %rax
movq %r15, %rdi
movl %edx, %esi
movq %rax, %rdx
jmp 0x11f80
movq %r15, %rdi
movl %edx, %esi
movq %r14, %rdx
callq *%rcx
testl %eax, %eax
jns 0x11f99
movq (%r14), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1198a
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: 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 0x11fba
movb %sil, (%rdi)
movl $0x1, %eax
jmp 0x1203e
movl %esi, %eax
cmpl $0x7ff, %esi            # imm = 0x7FF
ja 0x11fde
shrl $0x6, %eax
orb $-0x40, %al
movb %al, (%rdi)
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0x1(%rdi)
movl $0x2, %eax
jmp 0x1203e
cmpl $0xffff, %esi           # imm = 0xFFFF
ja 0x1200c
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 0x1203e
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_O3/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 %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
testl %edx, %edx
je 0x12e73
movl %r15d, %edi
callq 0x60e0
movl %eax, %r15d
decq %rbx
movzbl 0x1(%rbx), %eax
testl %eax, %eax
je 0x12e94
testl %r14d, %r14d
je 0x12e8a
movl %eax, %edi
callq 0x60e0
incq %rbx
cmpl %eax, %r15d
jne 0x12e76
jmp 0x12e96
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: 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 0x12ed3
movq 0x58(%rbx), %rdi
shlq $0x3, %rdx
movl $0xff, %esi
callq 0x6240
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x25f31
testl %eax, %eax
je 0x12f01
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 0x12f04
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: 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 0x130fe
movl %edi, %ecx
cmpl $0xd, %edi
jne 0x13107
leaq 0x181d9(%rip), %rbx     # 0x2b2d5
jmp 0x13124
leaq 0x181c9(%rip), %rbx     # 0x2b2ce
jmp 0x13124
leaq 0x2418b(%rip), %rbx     # 0x37299
leaq 0x19fd8(%rip), %rdx     # 0x2d0ed
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_O3/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 *0x24140(%rip)          # 0x37288
movq %rax, %rbx
movq 0x23e26(%rip), %r15     # 0x36f78
movq (%r15), %rsi
movq %r14, %rdi
callq 0x6230
movq (%r15), %rdi
callq 0x6370
movq 0x23e1c(%rip), %rax     # 0x36f88
movq (%rax), %rdx
movq %rbx, %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x62c0
testq %rax, %rax
je 0x1319d
movq %rbx, %rdi
callq 0x6180
testl %eax, %eax
je 0x131aa
decl %eax
cltq
cmpb $0xa, (%rbx,%rax)
jne 0x131aa
movb $0x0, (%rbx,%rax)
jmp 0x131aa
movq %rbx, %rdi
xorl %esi, %esi
callq *0x240e0(%rip)          # 0x37288
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: 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 0x17ecb(%rip), %rdi     # 0x2b310
xorl %esi, %esi
movl $0x54, %edx
xorl %eax, %eax
callq 0x61d0
leaq 0x17ecb(%rip), %rdi     # 0x2b325
movq %rbx, %rsi
xorl %eax, %eax
callq 0x61d0
leaq 0x17ec5(%rip), %rdi     # 0x2b330
movq %rbx, %rsi
xorl %eax, %eax
callq 0x61d0
movl $0xa, %edi
callq 0x6050
leaq 0x1a18f(%rip), %rdi     # 0x2d615
callq 0x60f0
movl $0xa, %edi
callq 0x6050
leaq 0x1a19b(%rip), %rdi     # 0x2d637
callq 0x60f0
leaq 0x1a198(%rip), %rdi     # 0x2d640
callq 0x60f0
leaq 0x1a1b9(%rip), %rdi     # 0x2d66d
callq 0x60f0
leaq 0x1a1d1(%rip), %rdi     # 0x2d691
callq 0x60f0
leaq 0x1a1ed(%rip), %rdi     # 0x2d6b9
callq 0x60f0
leaq 0x1a23c(%rip), %rdi     # 0x2d714
callq 0x60f0
leaq 0x1a289(%rip), %rdi     # 0x2d76d
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x60f0
// File: /workspace/github_c_makefile_star2_O3/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 0xae38
movq %rax, %r12
leaq 0x21bce(%rip), %rax     # 0x35368
movq %rax, 0x8(%r12)
movq $0x0, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r12)
movl %r14d, -0x2c(%rbp)
testl %r14d, %r14d
jle 0x137e7
movl -0x2c(%rbp), %r13d
xorl %r14d, %r14d
movq (%r15,%r14,8), %rsi
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x7683
incq %r14
cmpq %r14, %r13
jne 0x137c0
leaq 0x19e1d(%rip), %rsi     # 0x2d60b
movq %rbx, %rdi
movq %r12, %rdx
callq 0xc425
movslq -0x2c(%rbp), %r14
movq %rbx, %rdi
callq 0xae38
leaq 0x21ae4(%rip), %rcx     # 0x352f0
movq %rcx, 0x8(%rax)
movq $0x0, (%rax)
movq %r14, 0x18(%rax)
leaq 0x19dee(%rip), %rsi     # 0x2d610
movq %rbx, %rdi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc425
// File: /workspace/github_c_makefile_star2_O3/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 0x149ff
movslq 0x18(%r14), %r15
movq %rbx, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x2161e(%rip), %rax     # 0x352f0
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movq %r15, 0x18(%r14)
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x13cfe
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: 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
movq %rdx, %r12
movl %esi, %r15d
movq %rdi, %r14
movq 0x1b8(%rdi), %rbx
movq (%rdx), %rdx
cmpl $0x2, %esi
jne 0x13fa3
leaq 0x18473(%rip), %rax     # 0x2c3e9
movq %r14, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x73c6
testl %eax, %eax
je 0x14030
movq 0x8(%r12), %rdx
leaq 0x38(%rbx), %r12
movq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0xaf90
jmp 0x13fcb
leaq 0x38(%rbx), %r12
movq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0xaf90
movq 0x38(%rbx), %rsi
leaq 0x179c5(%rip), %rdx     # 0x2b983
movq %r14, %rdi
movl $0x1, %ecx
callq 0x86a0
movq (%r12), %r12
movq (%r12), %rdi
testq %rdi, %rdi
jne 0x13fe7
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
movq (%r12), %rdi
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0x1401d
movslq 0x14(%r12), %rdx
xorl %r12d, %r12d
cmpl $0x2, %eax
je 0x14017
cmpl $0x1, %eax
jne 0x14036
cmpl $0x2, %r15d
jne 0x1401d
movl $0xa, %esi
callq 0x6290
testq %rax, %rax
jne 0x1401d
jmp 0x14036
cmpq %rdx, 0x50(%rbx)
ja 0x14036
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x149ff
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: aio_cmd_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 0xae38
movq %rax, %r14
leaq 0x2127d(%rip), %rax     # 0x352f0
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movq %r15, 0x18(%r14)
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1409f
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq