LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_DeleteCommand
int Jim_DeleteCommand(Jim_Interp *interp, Jim_Obj *nameObj)
{
    int ret = JIM_OK;

    nameObj = JimQualifyName(interp, nameObj);

    if (Jim_DeleteHashEntry(&interp->commands, nameObj) == JIM_ERR) {
        Jim_SetResultFormatted(interp, "can't delete \"%#s\": command doesn't exist", nameObj);
        ret = JIM_ERR;
    }
    Jim_DecrRefCount(interp, nameObj);

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
incl 0x10(%rsi)
addq $0x68, %rdi
callq 0xa254
testl %eax, %eax
je 0xb5af
leaq 0x1b66a(%rip), %rsi     # 0x26c06
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x68a7
pushq $0x1
popq %r15
jmp 0xb5b2
xorl %r15d, %r15d
movl 0x10(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
cmpl $0x1, %eax
jg 0xb5cb
movq %r14, %rdi
movq %rbx, %rsi
callq 0x73bf
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_RenameCommand
int Jim_RenameCommand(Jim_Interp *interp, Jim_Obj *oldNameObj, Jim_Obj *newNameObj)
{
    int ret = JIM_ERR;
    Jim_HashEntry *he;
    Jim_Cmd *cmdPtr;

    if (Jim_Length(newNameObj) == 0) {
        return Jim_DeleteCommand(interp, oldNameObj);
    }



    oldNameObj = JimQualifyName(interp, oldNameObj);
    newNameObj = JimQualifyName(interp, newNameObj);


    he = Jim_FindHashEntry(&interp->commands, oldNameObj);
    if (he == NULL) {
        Jim_SetResultFormatted(interp, "can't rename \"%#s\": command doesn't exist", oldNameObj);
    }
    else if (Jim_FindHashEntry(&interp->commands, newNameObj)) {
        Jim_SetResultFormatted(interp, "can't rename to \"%#s\": command already exists", newNameObj);
    }
    else {
        cmdPtr = Jim_GetHashEntryVal(he);
        if (cmdPtr->prevCmd) {
            Jim_SetResultFormatted(interp, "can't rename local command \"%#s\"", oldNameObj);
        }
        else {

            JimIncrCmdRefCount(cmdPtr);
            JimUpdateProcNamespace(interp, cmdPtr, newNameObj);
            Jim_AddHashEntry(&interp->commands, newNameObj, cmdPtr);


            Jim_DeleteHashEntry(&interp->commands, oldNameObj);


            Jim_InterpIncrProcEpoch(interp);

            ret = JIM_OK;
        }
    }

    Jim_DecrRefCount(interp, oldNameObj);
    Jim_DecrRefCount(interp, newNameObj);

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %rdi
callq 0xa61a
testl %eax, %eax
je 0xb639
incl 0x10(%r15)
incl 0x10(%rbx)
leaq 0x68(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xa3fb
testq %rax, %rax
je 0xb652
movq %rax, %r13
movq %r12, %rdi
movq %rbx, %rsi
callq 0xa3fb
testq %rax, %rax
je 0xb65b
leaq 0x1b629(%rip), %rsi     # 0x26c5a
movq %r14, %rdi
movq %rbx, %rdx
jmp 0xb673
movq %r14, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb575
leaq 0x1b5d7(%rip), %rsi     # 0x26c30
jmp 0xb66d
movq 0x8(%r13), %rdx
cmpq $0x0, 0x8(%rdx)
je 0xb6c4
leaq 0x1b61b(%rip), %rsi     # 0x26c88
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x68a7
pushq $0x1
popq %r12
movl 0x10(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r15)
cmpl $0x1, %eax
jg 0xb699
movq %r14, %rdi
movq %r15, %rsi
callq 0x73bf
movl 0x10(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
cmpl $0x1, %eax
jg 0xb6b2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x73bf
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incl (%rdx)
movq %r12, %rdi
movq %rbx, %rsi
callq 0xa043
movq %r12, %rdi
movq %r15, %rsi
callq 0xa254
movq %r14, %rdi
callq 0xb41b
xorl %r12d, %r12d
jmp 0xb67e
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: JimDictSugarSet
static int JimDictSugarSet(Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj *valObjPtr)
{
    int err;

    SetDictSubstFromAny(interp, objPtr);

    err = Jim_SetDictKeysVector(interp, objPtr->internalRep.dictSubstValue.varNameObjPtr,
        &objPtr->internalRep.dictSubstValue.indexObjPtr, 1, valObjPtr, JIM_MUSTEXIST);

    if (err == JIM_OK) {

        Jim_SetEmptyResult(interp);
    }
    else {
        if (!valObjPtr) {

            if (Jim_GetVariable(interp, objPtr->internalRep.dictSubstValue.varNameObjPtr, JIM_NONE)) {
                Jim_SetResultFormatted(interp, "can't unset \"%#s\": no such element in array",
                    objPtr);
                return err;
            }
        }

        Jim_SetResultFormatted(interp, "can't %s \"%#s\": variable isn't array",
            (valObjPtr ? "set" : "unset"), objPtr);
    }
    return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
callq 0x16598
movq 0x18(%r15), %rsi
leaq 0x20(%r15), %rdx
pushq $0x1
popq %rcx
pushq $0x8
popq %r9
movq %rbx, %rdi
movq %r12, %r8
callq 0xe775
movl %eax, %r14d
testl %eax, %eax
je 0xb8c8
testq %r12, %r12
je 0xb8f1
leaq 0x1c4e0(%rip), %rdx     # 0x27d92
leaq 0x1c30b(%rip), %rsi     # 0x27bc4
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x68a7
jmp 0xb918
movq 0x128(%rbx), %r15
incl 0x10(%r15)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0xb8ec
movq %rbx, %rdi
callq 0x73bf
movq %r15, (%rbx)
jmp 0xb918
movq 0x18(%r15), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x9378
testq %rax, %rax
je 0xb924
leaq 0x1c28d(%rip), %rsi     # 0x27b98
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x68a7
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1c1ed(%rip), %rdx     # 0x27b18
jmp 0xb8b2
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_SetVariableStr
int Jim_SetVariableStr(Jim_Interp *interp, const char *name, Jim_Obj *objPtr)
{
    Jim_Obj *nameObjPtr;
    int result;

    nameObjPtr = Jim_NewStringObj(interp, name, -1);
    Jim_IncrRefCount(nameObjPtr);
    result = Jim_SetVariable(interp, nameObjPtr, objPtr);
    Jim_DecrRefCount(interp, nameObjPtr);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
pushq $-0x1
popq %rdx
callq 0x7363
movq %rax, %r14
incl 0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x8306
movl %eax, %r15d
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0xb977
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73bf
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_SetVariableStrWithStr
int Jim_SetVariableStrWithStr(Jim_Interp *interp, const char *name, const char *val)
{
    Jim_Obj *valObjPtr;
    int result;

    valObjPtr = Jim_NewStringObj(interp, val, -1);
    Jim_IncrRefCount(valObjPtr);
    result = Jim_SetVariableStr(interp, name, valObjPtr);
    Jim_DecrRefCount(interp, valObjPtr);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
pushq $-0x1
popq %rax
movq %rdx, %rsi
movl %eax, %edx
callq 0x7363
movq %rax, %r14
incl 0x10(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb92d
movl %eax, %r15d
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0xb9f8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73bf
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_GetVariableStr
Jim_Obj *Jim_GetVariableStr(Jim_Interp *interp, const char *name, int flags)
{
    Jim_Obj *nameObjPtr, *varObjPtr;

    nameObjPtr = Jim_NewStringObj(interp, name, -1);
    Jim_IncrRefCount(nameObjPtr);
    varObjPtr = Jim_GetVariable(interp, nameObjPtr, flags);
    Jim_DecrRefCount(interp, nameObjPtr);
    return varObjPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rdi, %rbx
pushq $-0x1
popq %rdx
callq 0x7363
movq %rax, %r14
incl 0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
movl %r15d, %edx
callq 0x9378
movq %rax, %r15
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0xbc9b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73bf
movq %r15, %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: JimCreateCallFrame
static Jim_CallFrame *JimCreateCallFrame(Jim_Interp *interp, Jim_CallFrame *parent, Jim_Obj *nsObj)
{
    Jim_CallFrame *cf;

    if (interp->freeFramesList) {
        cf = interp->freeFramesList;
        interp->freeFramesList = cf->next;

        cf->argv = NULL;
        cf->argc = 0;
        cf->procArgsObjPtr = NULL;
        cf->procBodyObjPtr = NULL;
        cf->next = NULL;
        cf->staticVars = NULL;
        cf->localCommands = NULL;
        cf->tailcallObj = NULL;
        cf->tailcallCmd = NULL;
    }
    else {
        cf = Jim_Alloc(sizeof(*cf));
        memset(cf, 0, sizeof(*cf));

        Jim_InitHashTable(&cf->vars, &JimVariablesHashTableType, interp);
    }

    cf->id = interp->callFrameEpoch++;
    cf->parent = parent;
    cf->level = parent ? parent->level + 1 : 0;
    cf->nsObj = nsObj;
    Jim_IncrRefCount(nsObj);

    return cf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x1d0(%rdi), %r14
testq %r14, %r14
je 0xc19c
movq 0x70(%r14), %rax
movq %rax, 0x1d0(%r12)
andq $0x0, 0x50(%r14)
andl $0x0, 0x58(%r14)
andq $0x0, 0x40(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%r14)
andq $0x0, 0x70(%r14)
movups %xmm0, 0x90(%r14)
andq $0x0, 0xa0(%r14)
jmp 0xc1ca
movl $0xa8, %esi
xorl %edi, %edi
callq *0x270df(%rip)          # 0x33288
movq %rax, %r14
movl $0xa8, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0x6240
leaq 0x25c0e(%rip), %rax     # 0x31dd0
movq %rax, 0x18(%r14)
movq %r12, 0x20(%r14)
movq 0xa0(%r12), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0xa0(%r12)
movq %rax, (%r14)
movq %r15, 0x48(%r14)
testq %r15, %r15
je 0xc1f2
movl 0x8(%r15), %eax
incl %eax
jmp 0xc1f4
xorl %eax, %eax
movl %eax, 0x8(%r14)
movq %rbx, 0x78(%r14)
incl 0x10(%rbx)
movq %r14, %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: JimInvokeDefer
static int JimInvokeDefer(Jim_Interp *interp, int retcode)
{
    Jim_Obj *objPtr;


    if (JimFindVariable(&interp->framePtr->vars, interp->defer) == NULL) {
        return retcode;
    }
    objPtr = Jim_GetVariable(interp, interp->defer, JIM_NONE);

    if (objPtr) {
        int ret = JIM_OK;
        int i;
        int listLen = Jim_ListLength(interp, objPtr);
        Jim_Obj *resultObjPtr;

        Jim_IncrRefCount(objPtr);

        resultObjPtr = Jim_GetResult(interp);
        Jim_IncrRefCount(resultObjPtr);
        Jim_SetEmptyResult(interp);


        for (i = listLen; i > 0; i--) {

            Jim_Obj *scriptObjPtr = Jim_ListGetIndex(interp, objPtr, i - 1);
            ret = Jim_EvalObj(interp, scriptObjPtr);
            if (ret != JIM_OK) {
                break;
            }
        }

        if (ret == JIM_OK || retcode == JIM_ERR) {

            Jim_SetResult(interp, resultObjPtr);
        }
        else {
            retcode = ret;
        }

        Jim_DecrRefCount(interp, resultObjPtr);
        Jim_DecrRefCount(interp, objPtr);
    }
    return retcode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r13d
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
movq 0x1a0(%rbx), %rsi
addq $0x10, %rdi
callq 0x1650a
testq %rax, %rax
je 0xc547
movq 0x1a0(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x9378
testq %rax, %rax
je 0xc547
movq %rax, %r14
movl %r13d, -0x2c(%rbp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8b3c
movl %eax, %r15d
incl 0x10(%r14)
movq (%rbx), %r12
incl 0x10(%r12)
movq 0x128(%rbx), %r13
incl 0x10(%r13)
movl 0x10(%r12), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r12)
cmpl $0x1, %eax
jg 0xc4b9
movq %rbx, %rdi
movq %r12, %rsi
callq 0x73bf
movq %r13, (%rbx)
testl %r15d, %r15d
jle 0xc4ea
decl %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0xd95e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8b54
testl %eax, %eax
je 0xc4bc
movl %eax, %r13d
cmpl $0x1, -0x2c(%rbp)
jne 0xc50f
incl 0x10(%r12)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0xc508
movq %rbx, %rdi
callq 0x73bf
movq %r12, (%rbx)
movl -0x2c(%rbp), %r13d
movl 0x10(%r12), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r12)
cmpl $0x1, %eax
jg 0xc52c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x73bf
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0xc547
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73bf
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: JimFreeCallFrame
static void JimFreeCallFrame(Jim_Interp *interp, Jim_CallFrame *cf, int action)
 {
    JimDeleteLocalProcs(interp, cf->localCommands);

    if (cf->procArgsObjPtr)
        Jim_DecrRefCount(interp, cf->procArgsObjPtr);
    if (cf->procBodyObjPtr)
        Jim_DecrRefCount(interp, cf->procBodyObjPtr);
    Jim_DecrRefCount(interp, cf->nsObj);
    if (action == JIM_FCF_FULL || cf->vars.size != JIM_HT_INITIAL_SIZE)
        Jim_FreeHashTable(&cf->vars);
    else {
        Jim_ClearHashTable(&cf->vars);
    }
    cf->next = interp->freeFramesList;
    interp->freeFramesList = cf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movq 0x90(%rsi), %r12
testq %r12, %r12
je 0xc65b
movl %r15d, -0x34(%rbp)
movq %rbx, -0x40(%rbp)
movq %r14, -0x30(%rbp)
leaq 0x68(%r14), %r13
movq %r13, -0x48(%rbp)
movq %r12, %rdi
callq 0xa553
testq %rax, %rax
je 0xc637
movq %rax, %r15
movq %r13, %rdi
movq %rax, %rsi
callq 0xa3fb
testq %rax, %rax
je 0xc612
movq %rax, %rbx
movq 0x8(%rax), %rsi
movq 0x8(%rsi), %r14
testq %r14, %r14
je 0xc607
movq %r12, %r13
andq $0x0, 0x8(%rsi)
movq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x16865
movq 0x70(%r12), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0xc5fa
movq 0x78(%r12), %rdi
movq %r14, %rsi
callq *%rax
movq %rax, %r14
movq %r13, %r12
movq %r14, 0x8(%rbx)
movq -0x48(%rbp), %r13
jmp 0xc612
movq %r13, %rdi
movq %r15, %rsi
callq 0xa254
movl 0x10(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r15)
cmpl $0x1, %eax
jg 0xc597
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x73bf
jmp 0xc597
movq 0x8(%r12), %rdi
xorl %esi, %esi
callq *0x26c44(%rip)          # 0x33288
movq %r12, %rdi
xorl %esi, %esi
callq *0x26c39(%rip)          # 0x33288
movq -0x40(%rbp), %rbx
movq -0x30(%rbp), %r14
movl -0x34(%rbp), %r15d
movq 0x60(%rbx), %rsi
testq %rsi, %rsi
je 0xc67a
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0xc67a
movq %r14, %rdi
callq 0x73bf
movq 0x68(%rbx), %rsi
testq %rsi, %rsi
je 0xc699
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0xc699
movq %r14, %rdi
callq 0x73bf
movq 0x78(%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0xc6b3
movq %r14, %rdi
callq 0x73bf
testl %r15d, %r15d
je 0xc6c9
cmpl $0x10, 0x28(%rbx)
jne 0xc6c9
leaq 0x10(%rbx), %rdi
callq 0xa33b
jmp 0xc6d2
leaq 0x10(%rbx), %rdi
callq 0xa3ca
movq 0x1d0(%r14), %rax
movq %rax, 0x70(%rbx)
movq %rbx, 0x1d0(%r14)
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_GetCallFrameByLevel
Jim_CallFrame *Jim_GetCallFrameByLevel(Jim_Interp *interp, Jim_Obj *levelObjPtr)
{
    long level;
    const char *str;
    Jim_CallFrame *framePtr;

    if (levelObjPtr) {
        str = Jim_String(levelObjPtr);
        if (str[0] == '#') {
            char *endptr;

            level = jim_strtol(str + 1, &endptr);
            if (str[1] == '\0' || endptr[0] != '\0') {
                level = -1;
            }
        }
        else {
            if (Jim_GetLong(interp, levelObjPtr, &level) != JIM_OK || level < 0) {
                level = -1;
            }
            else {

                level = interp->framePtr->level - level;
            }
        }
    }
    else {
        str = "1";
        level = interp->framePtr->level - 1;
    }

    if (level == 0) {
        return interp->topFramePtr;
    }
    if (level > 0) {

        for (framePtr = interp->framePtr; framePtr; framePtr = framePtr->parent) {
            if (framePtr->level == level) {
                return framePtr;
            }
        }
    }

    Jim_SetResultFormatted(interp, "bad level \"%s\"", str);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0xc74a
movq %rsi, %r15
movq %rsi, %rdi
callq 0x7340
movq %rax, %r14
cmpb $0x23, (%rax)
jne 0xc762
movq %r14, %rdi
incq %rdi
leaq -0x30(%rbp), %rsi
callq 0xc7ef
movq %rax, -0x28(%rbp)
cmpb $0x0, 0x1(%r14)
je 0xc740
movq -0x30(%rbp), %rcx
cmpb $0x0, (%rcx)
je 0xc7a0
orq $-0x1, -0x28(%rbp)
pushq $-0x1
popq %rax
jmp 0xc7a0
movq 0x58(%rbx), %rax
movslq 0x8(%rax), %rax
decq %rax
movq %rax, -0x28(%rbp)
leaq 0x1b850(%rip), %r14     # 0x27fb0
jmp 0xc7a0
leaq -0x28(%rbp), %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xc8cb
testl %eax, %eax
setne %al
movq (%r12), %rcx
testq %rcx, %rcx
sets %dl
orb %al, %dl
cmpb $0x1, %dl
jne 0xc791
orq $-0x1, -0x28(%rbp)
jmp 0xc7c2
movq 0x58(%rbx), %rax
movslq 0x8(%rax), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
testq %rax, %rax
je 0xc7db
jle 0xc7c2
leaq 0x58(%rbx), %r15
movq (%r15), %r15
testq %r15, %r15
je 0xc7c2
movslq 0x8(%r15), %rcx
cmpq %rcx, %rax
je 0xc7df
addq $0x48, %r15
jmp 0xc7ab
leaq 0x1a772(%rip), %rsi     # 0x26f3b
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x68a7
jmp 0xc7df
movq 0x60(%rbx), %r15
movq %r15, %rax
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_strtol
static long jim_strtol(const char *str, char **endptr)
{
    int sign;
    int base;
    int i = JimNumberBase(str, &base, &sign);

    if (base != 0) {
        long value = strtol(str + i, endptr, base);
        if (endptr == NULL || *endptr != str + i) {
            return value * sign;
        }
    }


    return strtol(str, endptr, 10);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x64e0
movq (%rax), %rax
xorl %ecx, %ecx
movzbl (%r14,%rcx), %edx
incq %rcx
testb $0x20, 0x1(%rax,%rdx,2)
jne 0xc80a
cmpl $0x2b, %edx
je 0xc82a
cmpl $0x2d, %edx
jne 0xc827
pushq $-0x1
jmp 0xc82c
decq %rcx
pushq $0x1
popq %r12
movslq %ecx, %rcx
cmpb $0x30, (%r14,%rcx)
jne 0xc8b5
movzbl 0x1(%r14,%rcx), %esi
cmpl $0x42, %esi
je 0xc86d
cmpl $0x44, %esi
je 0xc871
cmpl $0x4f, %esi
je 0xc869
pushq $0x10
popq %rdx
cmpl $0x58, %esi
je 0xc874
cmpl $0x62, %esi
je 0xc86d
cmpl $0x64, %esi
je 0xc871
cmpl $0x78, %esi
je 0xc874
cmpl $0x6f, %esi
jne 0xc8b5
pushq $0x8
jmp 0xc873
pushq $0x2
jmp 0xc873
pushq $0xa
popq %rdx
movzbl 0x2(%r14,%rcx), %esi
cmpl $0x2b, %esi
je 0xc8b5
cmpl $0x2d, %esi
je 0xc8b5
testb $0x20, 0x1(%rax,%rsi,2)
jne 0xc8b5
leaq (%r14,%rcx), %r15
addq $0x2, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6310
testq %rbx, %rbx
je 0xc8a8
cmpq %r15, (%rbx)
je 0xc8b5
imulq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0xa
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6310
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_GetLong
int Jim_GetLong(Jim_Interp *interp, Jim_Obj *objPtr, long *longPtr)
{
    jim_wide wideValue;
    int retval;

    retval = Jim_GetWide(interp, objPtr, &wideValue);
    if (retval == JIM_OK) {
        *longPtr = (long)wideValue;
        return JIM_OK;
    }
    return JIM_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
leaq -0x10(%rbp), %rdx
callq 0xc979
testl %eax, %eax
je 0xc8e6
pushq $0x1
popq %rax
jmp 0xc8ef
movq -0x10(%rbp), %rax
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_SetAssocData
int Jim_SetAssocData(Jim_Interp *interp, const char *key, Jim_InterpDeleteProc * delProc,
    void *data)
{
    AssocDataValue *assocEntryPtr = (AssocDataValue *) Jim_Alloc(sizeof(AssocDataValue));

    assocEntryPtr->delProc = delProc;
    assocEntryPtr->data = data;
    return Jim_AddHashEntry(&interp->assocData, key, assocEntryPtr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x10
popq %rsi
xorl %edi, %edi
callq *0x26970(%rip)          # 0x33288
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
addq $0x1d8, %r12            # imm = 0x1D8
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa043
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_GetAssocData
void *Jim_GetAssocData(Jim_Interp *interp, const char *key)
{
    Jim_HashEntry *entryPtr = Jim_FindHashEntry(&interp->assocData, key);

    if (entryPtr != NULL) {
        AssocDataValue *assocEntryPtr = Jim_GetHashEntryVal(entryPtr);
        return assocEntryPtr->data;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0xa3fb
testq %rax, %rax
je 0xc95b
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
jmp 0xc95d
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: SetIntFromAny
static int SetIntFromAny(Jim_Interp *interp, Jim_Obj *objPtr, int flags)
{
    jim_wide wideValue;
    const char *str;

    if (objPtr->typePtr == &coercedDoubleObjType) {

        objPtr->typePtr = &intObjType;
        return JIM_OK;
    }


    str = Jim_String(objPtr);

    if (Jim_StringToWide(str, &wideValue, 0) != JIM_OK) {
        if (flags & JIM_ERRMSG) {
            Jim_SetResultFormatted(interp, "expected integer but got \"%#s\"", objPtr);
        }
        return JIM_ERR;
    }
    if ((wideValue == JIM_WIDE_MIN || wideValue == JIM_WIDE_MAX) && errno == ERANGE) {
        Jim_SetResultString(interp, "Integer value too big to be represented", -1);
        return JIM_ERR;
    }

    Jim_FreeIntRep(interp, objPtr);
    objPtr->typePtr = &intObjType;
    objPtr->internalRep.wideValue = wideValue;
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
leaq 0x249de(%rip), %rax     # 0x313b8
cmpq %rax, 0x8(%rsi)
je 0xca27
movl %edx, %r12d
movq %rdi, %rbx
movq %r14, %rdi
callq 0x7340
leaq -0x28(%rbp), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x9d27
testl %eax, %eax
je 0xca37
pushq $0x1
popq %r15
testb $0x1, %r12b
je 0xcabe
leaq 0x1b263(%rip), %rsi     # 0x27c78
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x68a7
jmp 0xcabe
leaq 0x24962(%rip), %rax     # 0x31390
movq %rax, 0x8(%r14)
jmp 0xcabb
movq -0x28(%rbp), %r15
movabsq $-0x7fffffffffffffff, %rax # imm = 0x8000000000000001
addq %r15, %rax
cmpq $0x1, %rax
ja 0xca92
callq 0x6080
cmpl $0x22, (%rax)
jne 0xca92
leaq 0x1b238(%rip), %rsi     # 0x27c97
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x7363
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 0xca89
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
pushq $0x1
popq %r15
jmp 0xcabe
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xcaac
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xcaac
movq %rbx, %rdi
movq %r14, %rsi
callq *%rax
leaq 0x248dd(%rip), %rax     # 0x31390
movq %rax, 0x8(%r14)
movq %r15, 0x18(%r14)
xorl %r15d, %r15d
movl %r15d, %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_GetWideExpr
int Jim_GetWideExpr(Jim_Interp *interp, Jim_Obj *objPtr, jim_wide * widePtr)
{
    int ret = JIM_OK;

    if (objPtr->typePtr == &sourceObjType || objPtr->typePtr == NULL) {
        SetIntFromAny(interp, objPtr, 0);
    }
    if (objPtr->typePtr == &intObjType) {
        *widePtr = JimWideValue(objPtr);
    }
    else {
        JimPanic((interp->safeexpr, "interp->safeexpr is set"));
        interp->safeexpr++;
        ret = Jim_EvalExpression(interp, objPtr);
        interp->safeexpr--;

        if (ret == JIM_OK) {
            ret = Jim_GetWide(interp, Jim_GetResult(interp), widePtr);
        }
        if (ret != JIM_OK) {
            Jim_SetResultFormatted(interp, "expected integer expression but got \"%#s\"", objPtr);
        }
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
leaq 0x2479b(%rip), %rcx     # 0x31288
cmpq %rcx, %rax
setne %cl
testq %rax, %rax
setne %dl
testb %dl, %cl
jne 0xcb0e
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xc9c1
movq 0x8(%rbx), %rax
leaq 0x2487b(%rip), %rcx     # 0x31390
cmpq %rcx, %rax
je 0xcb66
incl 0xb0(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcb7c
movl %eax, %r12d
decl 0xb0(%r14)
testl %eax, %eax
jne 0xcb50
movq (%r14), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xc979
testl %eax, %eax
je 0xcb6d
pushq $0x1
popq %r12
leaq 0x1a3f3(%rip), %rsi     # 0x26f4a
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x68a7
jmp 0xcb70
movq 0x18(%rbx), %rax
movq %rax, (%r15)
xorl %r12d, %r12d
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: Jim_GetDouble
int Jim_GetDouble(Jim_Interp *interp, Jim_Obj *objPtr, double *doublePtr)
{
    if (objPtr->typePtr == &coercedDoubleObjType) {
        *doublePtr = JimWideValue(objPtr);
        return JIM_OK;
    }
    if (objPtr->typePtr != &doubleObjType && SetDoubleFromAny(interp, objPtr) == JIM_ERR)
        return JIM_ERR;

    if (objPtr->typePtr == &coercedDoubleObjType) {
        *doublePtr = JimWideValue(objPtr);
    }
    else {
        *doublePtr = objPtr->internalRep.doubleValue;
    }
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rsi), %rax
leaq 0x2412f(%rip), %r13     # 0x313b8
cmpq %r13, %rax
je 0xd2e4
leaq 0x2414b(%rip), %rcx     # 0x313e0
cmpq %rcx, %rax
je 0xd2ec
movq %rdi, %r15
movq %r14, %rdi
callq 0x7340
movq %rax, %r12
leaq -0x30(%rbp), %rsi
pushq $0xa
popq %rdx
movq %rax, %rdi
callq 0x9d27
testl %eax, %eax
je 0xd2f4
leaq -0x38(%rbp), %rsi
movq %r12, %rdi
callq 0x9db5
testl %eax, %eax
je 0xd321
leaq 0x1aa0b(%rip), %rsi     # 0x27cdd
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x68a7
pushq $0x1
popq %rax
jmp 0xd357
cvtsi2sdq 0x18(%r14), %xmm0
jmp 0xd351
movsd 0x18(%r14), %xmm0
jmp 0xd351
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xd30e
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xd30e
movq %r15, %rdi
movq %r14, %rsi
callq *%rax
movq %r13, 0x8(%r14)
movq -0x30(%rbp), %rax
movq %rax, 0x18(%r14)
cvtsi2sd %rax, %xmm0
jmp 0xd351
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xd33b
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xd33b
movq %r15, %rdi
movq %r14, %rsi
callq *%rax
leaq 0x2409e(%rip), %rax     # 0x313e0
movq %rax, 0x8(%r14)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x18(%r14)
movsd %xmm0, (%rbx)
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_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_NewDoubleObj
Jim_Obj *Jim_NewDoubleObj(Jim_Interp *interp, double doubleValue)
{
    Jim_Obj *objPtr;

    objPtr = Jim_NewObj(interp);
    objPtr->typePtr = &doubleObjType;
    objPtr->bytes = NULL;
    objPtr->internalRep.doubleValue = doubleValue;
    return objPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
callq 0xa5c2
leaq 0x24061(%rip), %rcx     # 0x313e0
movq %rcx, 0x8(%rax)
andq $0x0, (%rax)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_GetBoolean
int Jim_GetBoolean(Jim_Interp *interp, Jim_Obj *objPtr, int * booleanPtr)
{
    if (objPtr->typePtr != &intObjType && SetBooleanFromAny(interp, objPtr, JIM_ERRMSG) == JIM_ERR)
        return JIM_ERR;
    *booleanPtr = (int) JimWideValue(objPtr);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x23fde(%rip), %r13     # 0x31390
cmpq %r13, 0x8(%rsi)
je 0xd409
movq %rdi, %r15
movq %r14, %rdi
callq 0x7340
leaq 0x24a36(%rip), %rsi     # 0x31e00
pushq $0x8
popq %rdx
movq %rax, %rdi
callq 0x10610
testl %eax, %eax
js 0xd413
movl %eax, %r12d
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xd3f6
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xd3f6
movq %r15, %rdi
movq %r14, %rsi
callq *%rax
movq %r13, 0x8(%r14)
xorl %eax, %eax
cmpl $0x4, %r12d
setb %al
movq %rax, 0x18(%r14)
jmp 0xd40d
movq 0x18(%r14), %rax
movl %eax, (%rbx)
xorl %eax, %eax
jmp 0xd42a
leaq 0x1a8f0(%rip), %rsi     # 0x27d0a
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x68a7
pushq $0x1
popq %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: ListInsertElements
static void ListInsertElements(Jim_Obj *listPtr, int idx, int elemc, Jim_Obj *const *elemVec)
{
    int currentLen = listPtr->internalRep.listValue.len;
    int requiredLen = currentLen + elemc;
    int i;
    Jim_Obj **point;

    if (elemc == 0) {

        return;
    }

    if (requiredLen > listPtr->internalRep.listValue.maxLen) {
        if (currentLen) {

            requiredLen *= 2;
        }
        ListEnsureLength(listPtr, requiredLen);
    }
    if (idx < 0) {
        idx = currentLen;
    }
    point = listPtr->internalRep.listValue.ele + idx;
    memmove(point + elemc, point, (currentLen - idx) * sizeof(Jim_Obj *));
    for (i = 0; i < elemc; ++i) {
        point[i] = elemVec[i];
        Jim_IncrRefCount(point[i]);
    }
    listPtr->internalRep.listValue.len += elemc;
}

// Assembly:
testl %edx, %edx
je 0xd4d9
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebx
movl %esi, %r12d
movq %rdi, %r15
movl 0x20(%rdi), %r13d
leal (%rbx,%r13), %esi
cmpl 0x24(%rdi), %esi
jle 0xd477
addl %esi, %esi
testl %r13d, %r13d
cmovel %ebx, %esi
movq %r15, %rdi
callq 0x1706b
testl %r12d, %r12d
cmovsl %r13d, %r12d
movslq %r12d, %rax
leaq (,%rax,8), %r12
addq 0x18(%r15), %r12
movslq %ebx, %rcx
leaq (%r12,%rcx,8), %rdi
subl %eax, %r13d
movslq %r13d, %rdx
shlq $0x3, %rdx
movq %r12, %rsi
callq 0x6400
xorl %eax, %eax
testl %ebx, %ebx
movl $0x0, %ecx
cmovgl %ebx, %ecx
cmpq %rax, %rcx
je 0xd4c7
movq (%r14,%rax,8), %rdx
movq %rdx, (%r12,%rax,8)
incl 0x10(%rdx)
incq %rax
jmp 0xd4b2
addl %ebx, 0x20(%r15)
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_ListAppendList
void Jim_ListAppendList(Jim_Interp *interp, Jim_Obj *listPtr, Jim_Obj *appendListPtr)
{
    JimPanic((Jim_IsShared(listPtr), "Jim_ListAppendList called with shared object"));
    SetListFromAny(interp, listPtr);
    SetListFromAny(interp, appendListPtr);
    Jim_InvalidateStringRep(listPtr);
    ListAppendList(listPtr, appendListPtr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xd4da
movq %r15, %rdi
movq %rbx, %rsi
callq 0xd4da
movq %r14, %rdi
callq 0x94f7
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd8ea
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_ListInsertElements
void Jim_ListInsertElements(Jim_Interp *interp, Jim_Obj *listPtr, int idx,
    int objc, Jim_Obj *const *objVec)
{
    JimPanic((Jim_IsShared(listPtr), "Jim_ListInsertElement called with shared object"));
    SetListFromAny(interp, listPtr);
    if (idx >= 0 && idx > listPtr->internalRep.listValue.len)
        idx = listPtr->internalRep.listValue.len;
    else if (idx < 0)
        idx = 0;
    Jim_InvalidateStringRep(listPtr);
    ListInsertElements(listPtr, idx, objc, objVec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %r14d
movl %edx, %r12d
movq %rsi, %r15
callq 0xd4da
testl %r12d, %r12d
js 0xd92d
movl 0x20(%r15), %r13d
cmpl %r12d, %r13d
jl 0xd937
xorl %r13d, %r13d
testl %r12d, %r12d
cmovgl %r12d, %r13d
movq %r15, %rdi
callq 0x94f7
movq %r15, %rdi
movl %r13d, %esi
movl %r14d, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd439
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_ListGetIndex
Jim_Obj *Jim_ListGetIndex(Jim_Interp *interp, Jim_Obj *listPtr, int idx)
{
    SetListFromAny(interp, listPtr);
    if ((idx >= 0 && idx >= listPtr->internalRep.listValue.len) ||
        (idx < 0 && (-idx - 1) >= listPtr->internalRep.listValue.len)) {
        return NULL;
    }
    if (idx < 0)
        idx = listPtr->internalRep.listValue.len + idx;
    return listPtr->internalRep.listValue.ele[idx];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
callq 0xd4da
testl %ebx, %ebx
js 0xd97b
cmpl %ebx, 0x20(%r14)
jg 0xd989
jmp 0xd996
movl %ebx, %ecx
notl %ecx
movl 0x20(%r14), %eax
cmpl %ecx, %eax
jle 0xd996
addl %eax, %ebx
movq 0x18(%r14), %rax
movslq %ebx, %rcx
movq (%rax,%rcx,8), %rax
jmp 0xd998
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_ListIndex
int Jim_ListIndex(Jim_Interp *interp, Jim_Obj *listPtr, int idx, Jim_Obj **objPtrPtr, int flags)
{
    *objPtrPtr = Jim_ListGetIndex(interp, listPtr, idx);
    if (*objPtrPtr == NULL) {
        if (flags & JIM_ERRMSG) {
            Jim_SetResultString(interp, "list index out of range", -1);
        }
        return JIM_ERR;
    }
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %r15d
movq %rcx, %r14
movq %rdi, %rbx
callq 0xd95e
movq %rax, (%r14)
xorl %r14d, %r14d
testq %rax, %rax
jne 0xd9fe
pushq $0x1
popq %r14
testb $0x1, %r15b
je 0xd9fe
leaq 0x195a3(%rip), %rsi     # 0x26f74
pushq $-0x1
popq %rdx
movq %rbx, %rdi
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 0xd9fb
movq %rbx, %rdi
callq 0x73bf
movq %r15, (%rbx)
movl %r14d, %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: ListSetIndex
static int ListSetIndex(Jim_Interp *interp, Jim_Obj *listPtr, int idx,
    Jim_Obj *newObjPtr, int flags)
{
    SetListFromAny(interp, listPtr);
    if ((idx >= 0 && idx >= listPtr->internalRep.listValue.len) ||
        (idx < 0 && (-idx - 1) >= listPtr->internalRep.listValue.len)) {
        if (flags & JIM_ERRMSG) {
            Jim_SetResultString(interp, "list index out of range", -1);
        }
        return JIM_ERR;
    }
    if (idx < 0)
        idx = listPtr->internalRep.listValue.len + idx;
    Jim_DecrRefCount(interp, listPtr->internalRep.listValue.ele[idx]);
    listPtr->internalRep.listValue.ele[idx] = newObjPtr;
    Jim_IncrRefCount(newObjPtr);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r13d
movq %rcx, %r14
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
callq 0xd4da
testl %r12d, %r12d
js 0xdbef
cmpl %r12d, 0x20(%r15)
jg 0xdbff
jmp 0xdc39
movl %r12d, %ecx
notl %ecx
movl 0x20(%r15), %eax
cmpl %ecx, %eax
jle 0xdc39
addl %eax, %r12d
movq 0x18(%r15), %rax
movslq %r12d, %r12
movq (%rax,%r12,8), %rax
movl 0x10(%rax), %ecx
leal -0x1(%rcx), %edx
movl %edx, 0x10(%rax)
cmpl $0x1, %ecx
jg 0xdc28
movq 0x18(%r15), %rax
movq (%rax,%r12,8), %rsi
movq %rbx, %rdi
callq 0x73bf
movq 0x18(%r15), %rax
movq %r14, (%rax,%r12,8)
incl 0x10(%r14)
xorl %r14d, %r14d
jmp 0xdc77
pushq $0x1
popq %r14
testb $0x1, %r13b
je 0xdc77
leaq 0x1932a(%rip), %rsi     # 0x26f74
pushq $-0x1
popq %rdx
movq %rbx, %rdi
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 0xdc74
movq %rbx, %rdi
callq 0x73bf
movq %r15, (%rbx)
movl %r14d, %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_ListJoin
Jim_Obj *Jim_ListJoin(Jim_Interp *interp, Jim_Obj *listObjPtr, const char *joinStr, int joinStrLen)
{
    int i;
    int listLen = Jim_ListLength(interp, listObjPtr);
    Jim_Obj *resObjPtr = Jim_NewEmptyStringObj(interp);

    for (i = 0; i < listLen; ) {
        Jim_AppendObj(interp, resObjPtr, Jim_ListGetIndex(interp, listObjPtr, i));
        if (++i != listLen) {
            Jim_AppendString(interp, resObjPtr, joinStr, joinStrLen);
        }
    }
    return resObjPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, -0x2c(%rbp)
movq %rdx, -0x38(%rbp)
movq %rdi, %r12
movq %rsi, -0x40(%rbp)
callq 0x8b3c
movl %eax, %r13d
leaq 0x1b98a(%rip), %rsi     # 0x29641
xorl %ebx, %ebx
movq %r12, %rdi
xorl %edx, %edx
callq 0x7363
movq %rax, %r14
testl %r13d, %r13d
movl $0x0, %r15d
cmovgl %r13d, %r15d
decl %r13d
cmpl %ebx, %r15d
je 0xdd12
movq %r12, %rdi
movq -0x40(%rbp), %rsi
movl %ebx, %edx
callq 0xd95e
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa6f6
cmpl %ebx, %r13d
je 0xdd0e
movq %r12, %rdi
movq %r14, %rsi
movq -0x38(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x823a
incl %ebx
jmp 0xdcd6
movq %r14, %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_ListRange
Jim_Obj *Jim_ListRange(Jim_Interp *interp, Jim_Obj *listObjPtr, Jim_Obj *firstObjPtr,
    Jim_Obj *lastObjPtr)
{
    int first, last;
    int len, rangeLen;

    if (Jim_GetIndex(interp, firstObjPtr, &first) != JIM_OK ||
        Jim_GetIndex(interp, lastObjPtr, &last) != JIM_OK)
        return NULL;
    len = Jim_ListLength(interp, listObjPtr);
    first = JimRelToAbsIndex(len, first);
    last = JimRelToAbsIndex(len, last);
    JimRelToAbsRange(len, &first, &last, &rangeLen);
    if (first == 0 && last == len) {
        return listObjPtr;
    }
    return Jim_NewListObj(interp, listObjPtr->internalRep.listValue.ele + first, rangeLen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x34(%rbp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x7d46
testl %eax, %eax
jne 0xdfca
leaq -0x2c(%rbp), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x7d46
xorl %r13d, %r13d
testl %eax, %eax
je 0xdfde
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8b3c
movl %eax, %r15d
leaq -0x34(%rbp), %r12
movl (%r12), %eax
movl $0x80000002, %ecx       # imm = 0x80000002
cmpl %ecx, %eax
movl $0x0, %edx
cmovael %r15d, %edx
addl %eax, %edx
movl %edx, (%r12)
leaq -0x2c(%rbp), %rdx
movl (%rdx), %eax
cmpl %ecx, %eax
cmovael %r15d, %r13d
addl %eax, %r13d
movl %r13d, (%rdx)
leaq -0x30(%rbp), %rcx
movl %r15d, %edi
movq %r12, %rsi
callq 0xe05b
movslq (%r12), %rsi
testq %rsi, %rsi
jne 0xe03a
cmpl %r15d, -0x2c(%rbp)
je 0xdfcc
shlq $0x3, %rsi
addq 0x18(%rbx), %rsi
movl -0x30(%rbp), %edx
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x745b
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: JimRelToAbsRange
static void JimRelToAbsRange(int len, int *firstPtr, int *lastPtr, int *rangeLenPtr)
{
    int rangeLen;

    if (*firstPtr > *lastPtr) {
        rangeLen = 0;
    }
    else {
        rangeLen = *lastPtr - *firstPtr + 1;
        if (rangeLen) {
            if (*firstPtr < 0) {
                rangeLen += *firstPtr;
                *firstPtr = 0;
            }
            if (*lastPtr >= len) {
                rangeLen -= (*lastPtr - (len - 1));
                *lastPtr = len - 1;
            }
        }
    }
    if (rangeLen < 0)
        rangeLen = 0;

    *rangeLenPtr = rangeLen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rsi), %r11d
movl (%rdx), %r8d
xorl %eax, %eax
movl %r8d, %r9d
movl $0x0, %r10d
subl %r11d, %r9d
jl 0xe0a5
incl %r9d
je 0xe0a5
testl %r11d, %r11d
jns 0xe08b
movl %r8d, %r9d
incl %r9d
andl $0x0, (%rsi)
movl (%rdx), %r8d
cmpl %edi, %r8d
jge 0xe095
movl %r9d, %r10d
jmp 0xe0a5
movl %edi, %esi
decl %esi
leal (%r9,%rdi), %r10d
decl %r10d
subl %r8d, %r10d
movl %esi, (%rdx)
testl %r10d, %r10d
cmovgl %r10d, %eax
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_NewDictObj
Jim_Obj *Jim_NewDictObj(Jim_Interp *interp, Jim_Obj *const *elements, int len)
{
    Jim_Obj *objPtr;
    int i;

    JimPanic((len % 2, "Jim_NewDictObj() 'len' argument must be even"));

    objPtr = Jim_NewObj(interp);
    objPtr->typePtr = &dictObjType;
    objPtr->bytes = NULL;

    objPtr->internalRep.dictValue = JimDictNew(interp, len, len);
    for (i = 0; i < len; i += 2)
        DictAddElement(interp, objPtr, elements[i], elements[i + 1]);
    return objPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa5c2
movq %rax, %r15
leaq 0x23013(%rip), %rax     # 0x31430
movq %rax, 0x8(%r15)
andq $0x0, (%r15)
movl %r12d, %edi
movl %r12d, %esi
callq 0xe46b
movq %rax, 0x18(%r15)
movslq %r12d, %r12
xorl %r13d, %r13d
cmpq %r12, %r13
jge 0xe459
movq (%rbx,%r13,8), %rdx
movq 0x8(%rbx,%r13,8), %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0xe288
addq $0x2, %r13
jmp 0xe43a
movq %r15, %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: JimDictNew
static Jim_Dict *JimDictNew(Jim_Interp *interp, int table_size, int ht_size)
{
    Jim_Dict *dict = Jim_Alloc(sizeof(*dict));
    memset(dict, 0, sizeof(*dict));

    if (ht_size) {
        JimDictExpandHashTable(dict, ht_size);
    }
    if (table_size) {
        dict->table = Jim_Alloc(table_size * sizeof(*dict->table));
        dict->maxLen = table_size;
    }
#ifdef JIM_RANDOMISE_HASH
    dict->uniq = (rand() ^ time(NULL) ^ clock());
#endif
    return dict;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movl %edi, %ebx
pushq $0x30
popq %rsi
xorl %edi, %edi
callq *0x24e03(%rip)          # 0x33288
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
testl %r15d, %r15d
je 0xe4a6
movq %r14, %rdi
movl %r15d, %esi
callq 0x17106
testl %ebx, %ebx
je 0xe4c1
movslq %ebx, %rsi
shlq $0x3, %rsi
xorl %edi, %edi
callq *0x24dcf(%rip)          # 0x33288
movq %rax, 0x18(%r14)
movl %ebx, 0x24(%r14)
movq %r14, %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_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, %r12d
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
callq 0xe0fd
testl %eax, %eax
je 0xe4fb
pushq $-0x1
popq %r15
jmp 0xe541
movq 0x18(%r13), %r13
pushq $-0x1
popq %rdx
movq %r13, %rdi
movq %rbx, %rsi
callq 0xe553
testl %eax, %eax
je 0xe523
movq 0x18(%r13), %rcx
cltq
movq (%rcx,%rax,8), %rax
movq %rax, (%r15)
xorl %r15d, %r15d
jmp 0xe541
pushq $0x1
popq %r15
testb $0x1, %r12b
je 0xe541
leaq 0x18a71(%rip), %rsi     # 0x26fa5
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x68a7
movl %r15d, %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_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 0x22d52(%rip), %rax     # 0x31408
cmpq %rax, 0x8(%rsi)
jne 0xe6d4
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8b3c
movl %eax, (%r14)
testb $0x1, %al
jne 0xe6d4
movq 0x18(%rbx), %rax
jmp 0xe700
movq %r15, %rdi
movq %rbx, %rsi
callq 0xe0fd
testl %eax, %eax
je 0xe6ee
movl $0x1, (%r14)
xorl %eax, %eax
jmp 0xe700
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_O2/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
testl %ecx, %ecx
je 0xe761
movl %r9d, %r14d
movl %ecx, %r15d
movq %rdx, %r12
movq %rdi, %r13
movq %r8, -0x30(%rbp)
xorl %ebx, %ebx
testl %ecx, %ecx
cmovlel %ebx, %r15d
cmpq %rbx, %r15
je 0xe75d
movq (%r12,%rbx,8), %rdx
movq %r13, %rdi
leaq -0x38(%rbp), %rcx
movl %r14d, %r8d
callq 0xe4cf
incq %rbx
movq -0x38(%rbp), %rsi
testl %eax, %eax
je 0xe738
jmp 0xe766
movq -0x30(%rbp), %r8
movq %rsi, (%r8)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq