LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
cmpq $0x0, (%rdx)
jne 0xc098
movq 0x8(%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
cmpl $0x0, 0x14(%rbx)
je 0xc0db
incl 0x10(%r15)
incl 0x10(%rbx)
leaq 0x68(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xac6b
testq %rax, %rax
je 0xc0f4
movq %rax, %r13
movq %r12, %rdi
movq %rbx, %rsi
callq 0xac6b
testq %rax, %rax
je 0xc0fd
leaq 0x1eb37(%rip), %rsi     # 0x2ac0a
movq %r14, %rdi
movq %rbx, %rdx
jmp 0xc115
movq %r14, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc00b
leaq 0x1eae5(%rip), %rsi     # 0x2abe0
jmp 0xc10f
movq 0x8(%r13), %rdx
cmpq $0x0, 0x8(%rdx)
je 0xc168
leaq 0x1eb29(%rip), %rsi     # 0x2ac38
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x6923
movl $0x1, %r12d
movl 0x10(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r15)
cmpl $0x1, %eax
jg 0xc13d
movq %r14, %rdi
movq %r15, %rsi
callq 0x758c
movl 0x10(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
cmpl $0x1, %eax
jg 0xc156
movq %r14, %rdi
movq %rbx, %rsi
callq 0x758c
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 0xa8a8
movq %r12, %rdi
movq %r15, %rsi
callq 0xaab0
incq 0x98(%r14)
movq 0x1c0(%r14), %rdi
testq %rdi, %rdi
je 0xc1ae
movq 0x8(%rdi), %r12
xorl %esi, %esi
callq *0x2b0e9(%rip)          # 0x37288
movq %r12, 0x1c0(%r14)
movq %r12, %rdi
testq %r12, %r12
jne 0xc193
movl $0x0, 0x1c8(%r14)
xorl %r12d, %r12d
jmp 0xc122
// File: /workspace/github_c_makefile_star2_O3/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 0x186a9
movq 0x18(%r15), %rsi
leaq 0x20(%r15), %rdx
movq %rbx, %rdi
movl $0x1, %ecx
movq %r12, %r8
movl $0x8, %r9d
callq 0xf76e
movl %eax, %r14d
testl %eax, %eax
je 0xc3c0
testq %r12, %r12
je 0xc3e9
leaq 0x1f998(%rip), %rdx     # 0x2bd42
leaq 0x1f7c3(%rip), %rsi     # 0x2bb74
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x6923
jmp 0xc410
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 0xc3e4
movq %rbx, %rdi
callq 0x758c
movq %r15, (%rbx)
jmp 0xc410
movq 0x18(%r15), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x98e7
testq %rax, %rax
je 0xc41c
leaq 0x1f745(%rip), %rsi     # 0x2bb48
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x6923
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f6a5(%rip), %rdx     # 0x2bac8
jmp 0xc3aa
// File: /workspace/github_c_makefile_star2_O3/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
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq %rax, %r14
incl 0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x876e
movl %eax, %r15d
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0xc471
movq %rbx, %rdi
movq %r14, %rsi
callq 0x758c
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_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
movq %rdx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq %rax, %r14
incl 0x10(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xc425
movl %eax, %r15d
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0xc4f2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x758c
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_GetGlobalVariable
Jim_Obj *Jim_GetGlobalVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, int flags)
{
    Jim_CallFrame *savedFramePtr;
    Jim_Obj *objPtr;

    savedFramePtr = interp->framePtr;
    interp->framePtr = interp->topFramePtr;
    objPtr = Jim_GetVariable(interp, nameObjPtr, flags);
    interp->framePtr = savedFramePtr;

    return objPtr;
}

// 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 0x98e7
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_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
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq %rax, %r14
incl 0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
movl %r15d, %edx
callq 0x98e7
movq %rax, %r15
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0xc7c2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x758c
movq %r15, %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: 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 0xcd4a
movq 0x70(%r14), %rax
movq %rax, 0x1d0(%r12)
xorl %eax, %eax
movq %rax, 0x50(%r14)
movl $0x0, 0x58(%r14)
movq %rax, 0x40(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%r14)
movq %rax, 0x70(%r14)
movups %xmm0, 0x90(%r14)
movq %rax, 0xa0(%r14)
jmp 0xcd78
movl $0xa8, %esi
xorl %edi, %edi
callq *0x2a531(%rip)          # 0x37288
movq %rax, %r14
movl $0xa8, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0x6240
leaq 0x29060(%rip), %rax     # 0x35dd0
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 0xcda0
movl 0x8(%r15), %eax
incl %eax
jmp 0xcda2
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_O3/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 0xac6b
testq %rax, %rax
je 0xd1d4
cmpq $0x0, 0x8(%rax)
je 0xd1d4
movq 0x1a0(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x98e7
testq %rax, %rax
je 0xd1d4
movq %rax, %r15
movl %r13d, -0x2c(%rbp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe2fe
movl 0x20(%r15), %r14d
incl 0x10(%r15)
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 0xd146
movq %rbx, %rdi
movq %r12, %rsi
callq 0x758c
movq %r13, (%rbx)
testl %r14d, %r14d
jle 0xd177
decl %r14d
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0xe803
movq %rbx, %rdi
movq %rax, %rsi
callq 0x908a
testl %eax, %eax
je 0xd149
movl %eax, %r13d
cmpl $0x1, -0x2c(%rbp)
jne 0xd19c
incl 0x10(%r12)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0xd195
movq %rbx, %rdi
callq 0x758c
movq %r12, (%rbx)
movl -0x2c(%rbp), %r13d
movl 0x10(%r12), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r12)
cmpl $0x1, %eax
jg 0xd1b9
movq %rbx, %rdi
movq %r12, %rsi
callq 0x758c
movl 0x10(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r15)
cmpl $0x1, %eax
jg 0xd1d4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x758c
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: 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 0xd2fd
movl %r15d, -0x34(%rbp)
movq %rbx, -0x40(%rbp)
movl (%r12), %eax
testl %eax, %eax
je 0xd2dd
leaq 0x68(%r14), %r13
movq %r14, -0x30(%rbp)
movq %r13, -0x48(%rbp)
leal -0x1(%rax), %ecx
movl %ecx, (%r12)
movq 0x8(%r12), %rcx
cltq
movq -0x8(%rcx,%rax,8), %r15
testq %r15, %r15
je 0xd2dd
movq %r13, %rdi
movq %r15, %rsi
callq 0xac6b
testq %rax, %rax
je 0xd2b6
movq %rax, %rbx
movq 0x8(%rax), %rsi
movq 0x8(%rsi), %r14
testq %r14, %r14
je 0xd2a7
movq $0x0, 0x8(%rsi)
movq -0x30(%rbp), %r13
movq %r13, %rdi
callq 0x189aa
movq 0x70(%r13), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0xd299
movq 0x78(%r13), %rdi
movq %r14, %rsi
callq *%rax
movq %rax, %r14
movq %r14, 0x8(%rbx)
movq -0x30(%rbp), %r14
movq -0x48(%rbp), %r13
jmp 0xd2b6
movq %r13, %rdi
movq %r15, %rsi
callq 0xaab0
movq -0x30(%rbp), %r14
movl 0x10(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r15)
cmpl $0x1, %eax
jg 0xd2d1
movq %r14, %rdi
movq %r15, %rsi
callq 0x758c
movl (%r12), %eax
testl %eax, %eax
jne 0xd230
movq 0x8(%r12), %rdi
xorl %esi, %esi
callq *0x29f9e(%rip)          # 0x37288
movq %r12, %rdi
xorl %esi, %esi
callq *0x29f93(%rip)          # 0x37288
movq -0x40(%rbp), %rbx
movl -0x34(%rbp), %r15d
movq 0x60(%rbx), %rsi
testq %rsi, %rsi
je 0xd31c
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0xd31c
movq %r14, %rdi
callq 0x758c
movq 0x68(%rbx), %rsi
testq %rsi, %rsi
je 0xd33b
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0xd33b
movq %r14, %rdi
callq 0x758c
movq 0x78(%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0xd355
movq %r14, %rdi
callq 0x758c
testl %r15d, %r15d
je 0xd36b
cmpl $0x10, 0x28(%rbx)
jne 0xd36b
leaq 0x10(%rbx), %rdi
callq 0xaba2
jmp 0xd396
leaq 0x10(%rbx), %rdi
callq 0xaba2
movq 0x10(%rbx), %rdi
xorl %esi, %esi
callq *0x29f08(%rip)          # 0x37288
movq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movl $0x0, 0x38(%rbx)
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_O3/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 %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0xd40d
movq %rsi, %r15
movq (%rsi), %r14
testq %r14, %r14
jne 0xd3e1
movq 0x8(%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq (%r15), %r14
cmpb $0x23, (%r14)
jne 0xd421
leaq 0x1(%r14), %rdi
leaq -0x20(%rbp), %rsi
callq 0xd4a0
cmpb $0x0, 0x1(%r14)
je 0xd404
movq -0x20(%rbp), %rcx
cmpb $0x0, (%rcx)
je 0xd456
movq $-0x1, %rax
jmp 0xd456
movq 0x58(%rbx), %rax
movslq 0x8(%rax), %rax
decq %rax
leaq 0x1eb41(%rip), %r14     # 0x2bf60
jmp 0xd456
leaq 0x27ec8(%rip), %rax     # 0x352f0
cmpq %rax, 0x8(%r15)
je 0xd442
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0xd6c3
testl %eax, %eax
jne 0xd475
movq 0x18(%r15), %rcx
testq %rcx, %rcx
js 0xd475
movq 0x58(%rbx), %rax
movslq 0x8(%rax), %rax
subq %rcx, %rax
testq %rax, %rax
je 0xd48e
jle 0xd475
movq 0x58(%rbx), %r15
testq %r15, %r15
je 0xd475
movslq 0x8(%r15), %rcx
cmpq %rcx, %rax
je 0xd492
movq 0x48(%r15), %r15
jmp 0xd461
leaq 0x1da6f(%rip), %rsi     # 0x2aeeb
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x6923
jmp 0xd492
movq 0x60(%rbx), %r15
movq %r15, %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_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 0xd4bb
cmpl $0x2b, %edx
je 0xd4e0
cmpl $0x2d, %edx
jne 0xd4dd
movq $-0x1, %r12
jmp 0xd4e6
decq %rcx
movl $0x1, %r12d
movslq %ecx, %rcx
cmpb $0x30, (%r14,%rcx)
jne 0xd58e
movzbl 0x1(%r14,%rcx), %esi
movl $0x10, %edx
cmpl $0x61, %esi
jg 0xd515
cmpl $0x4e, %esi
jg 0xd52b
cmpl $0x42, %esi
je 0xd548
cmpl $0x44, %esi
je 0xd524
jmp 0xd58e
cmpl $0x6e, %esi
jg 0xd537
cmpl $0x62, %esi
je 0xd548
cmpl $0x64, %esi
jne 0xd58e
movl $0xa, %edx
jmp 0xd54d
cmpl $0x4f, %esi
je 0xd541
cmpl $0x58, %esi
je 0xd54d
jmp 0xd58e
cmpl $0x78, %esi
je 0xd54d
cmpl $0x6f, %esi
jne 0xd58e
movl $0x8, %edx
jmp 0xd54d
movl $0x2, %edx
movzbl 0x2(%r14,%rcx), %esi
cmpl $0x2b, %esi
je 0xd58e
cmpl $0x2d, %esi
je 0xd58e
testb $0x20, 0x1(%rax,%rsi,2)
jne 0xd58e
leaq (%r14,%rcx), %r15
addq $0x2, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6310
testq %rbx, %rbx
je 0xd581
cmpq %r15, (%rbx)
je 0xd58e
imulq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
movl $0xa, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6310
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x27d33(%rip), %rax     # 0x352f0
cmpq %rax, 0x8(%rsi)
je 0xd5da
movl $0x1, %r15d
movq %r14, %rsi
movl $0x1, %edx
callq 0xd6c3
testl %eax, %eax
jne 0xd5e4
movq 0x18(%r14), %rax
movq %rax, (%rbx)
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_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
movl $0x10, %esi
xorl %edi, %edi
callq *0x29c72(%rip)          # 0x37288
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 0xa8a8
// File: /workspace/github_c_makefile_star2_O3/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 0xac6b
testq %rax, %rax
je 0xd659
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
jmp 0xd65b
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq 0x8(%rsi), %rax
leaq 0x27c36(%rip), %rcx     # 0x35318
cmpq %rcx, %rax
je 0xd74a
movl %edx, %r12d
movq %rdi, -0x30(%rbp)
movq (%r14), %r13
testq %r13, %r13
jne 0xd6ff
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %r13
leaq -0x38(%rbp), %rbx
movq %r13, %rdi
movq %rbx, %rsi
callq 0xd4a0
movq %rax, %r15
movq (%rbx), %rsi
movq %r13, %rdi
callq 0xa59d
testl %eax, %eax
je 0xd75a
movl $0x1, %r15d
testb $0x1, %r12b
je 0xd7e6
leaq 0x1e4f1(%rip), %rsi     # 0x2bc28
movq -0x30(%rbp), %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x6923
jmp 0xd7e6
leaq 0x27b9f(%rip), %rax     # 0x352f0
movq %rax, 0x8(%r14)
jmp 0xd7e3
movabsq $-0x7fffffffffffffff, %rax # imm = 0x8000000000000001
addq %r15, %rax
cmpq $0x1, %rax
ja 0xd7b9
callq 0x6080
cmpl $0x22, (%rax)
jne 0xd7b9
leaq 0x1e4c9(%rip), %rsi     # 0x2bc47
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
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 0xd7ae
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
movl $0x1, %r15d
jmp 0xd7e6
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xd7d4
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xd7d4
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq *%rax
leaq 0x27b15(%rip), %rax     # 0x352f0
movq %rax, 0x8(%r14)
movq %r15, 0x18(%r14)
xorl %r15d, %r15d
movl %r15d, %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_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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %rax
leaq 0x279ce(%rip), %rcx     # 0x351e8
cmpq %rcx, %rax
setne %cl
testq %rax, %rax
setne %dl
testb %dl, %cl
jne 0xd83b
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xd6c3
movq 0x8(%rbx), %rax
leaq 0x27aae(%rip), %r14     # 0x352f0
cmpq %r14, %rax
je 0xd881
movq %r12, -0x30(%rbp)
incl 0xb0(%r15)
movq %r15, %rdi
movq %rbx, %rsi
callq 0xd8ce
movl %eax, %r12d
decl 0xb0(%r15)
testl %eax, %eax
je 0xd88b
leaq 0x1d688(%rip), %rsi     # 0x2aefa
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x6923
jmp 0xd8bc
movq 0x18(%rbx), %rax
movq %rax, (%r12)
jmp 0xd8b9
movq (%r15), %r13
cmpq %r14, 0x8(%r13)
je 0xd8ae
movl $0x1, %r12d
movq %r15, %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0xd6c3
testl %eax, %eax
jne 0xd86b
movq 0x18(%r13), %rax
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x272b6(%rip), %rcx     # 0x35318
cmpq %rcx, %rax
je 0xe0da
leaq 0x272d2(%rip), %rcx     # 0x35340
cmpq %rcx, %rax
je 0xe0e2
movq %rdi, -0x30(%rbp)
movq (%r14), %r13
testq %r13, %r13
jne 0xe088
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %r13
leaq -0x40(%rbp), %r15
movq %r13, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x6460
movq %rax, %r12
movq (%r15), %rsi
movq %r13, %rdi
callq 0xa59d
testl %eax, %eax
je 0xe0ea
leaq -0x38(%rbp), %rsi
movq %r13, %rdi
callq 0xa5f1
testl %eax, %eax
je 0xe11b
leaq 0x1dbc8(%rip), %rsi     # 0x2bc8d
movq -0x30(%rbp), %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x6923
movl $0x1, %eax
jmp 0xe152
cvtsi2sdq 0x18(%r14), %xmm0
jmp 0xe14c
movsd 0x18(%r14), %xmm0
jmp 0xe14c
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xe105
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xe105
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq *%rax
leaq 0x2720c(%rip), %rax     # 0x35318
movq %rax, 0x8(%r14)
movq %r12, 0x18(%r14)
cvtsi2sd %r12, %xmm0
jmp 0xe14c
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xe136
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xe136
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq *%rax
leaq 0x27203(%rip), %rax     # 0x35340
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_O3/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 0xae38
leaq 0x271c6(%rip), %rcx     # 0x35340
movq %rcx, 0x8(%rax)
movq $0x0, (%rax)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rsi, %r14
movq 0x8(%rsi), %rax
leaq 0x2713f(%rip), %rcx     # 0x352f0
cmpq %rcx, %rax
je 0xe214
movq %rdi, %r15
movq %rdx, -0x30(%rbp)
movq (%r14), %r12
testq %r12, %r12
jne 0xe1ce
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %r12
leaq 0x27c2b(%rip), %rbx     # 0x35e00
xorl %r13d, %r13d
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xe1ec
movq %r12, %rsi
callq 0x62e0
testl %eax, %eax
je 0xe21a
incq %r13
addq $0x8, %rbx
cmpq $0x8, %r13
jne 0xe1d8
leaq 0x1daba(%rip), %rsi     # 0x2bcba
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x6923
movl $0x1, %eax
jmp 0xe254
movq 0x18(%r14), %rax
jmp 0xe250
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xe234
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xe234
movq %r15, %rdi
movq %r14, %rsi
callq *%rax
leaq 0x270b5(%rip), %rax     # 0x352f0
movq %rax, 0x8(%r14)
xorl %eax, %eax
cmpq $0x4, %r13
setb %al
movq %rax, 0x18(%r14)
movq -0x30(%rbp), %rdx
movl %eax, (%rdx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe2fd
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 0xe2a1
addl %esi, %esi
testl %r13d, %r13d
cmovel %ebx, %esi
movq %r15, %rdi
callq 0x1939a
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
testl %ebx, %ebx
jle 0xe2eb
movl %ebx, %eax
xorl %ecx, %ecx
movq (%r14,%rcx,8), %rdx
movq %rdx, (%r12,%rcx,8)
incl 0x10(%rdx)
incq %rcx
cmpq %rcx, %rax
jne 0xe2d8
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_O3/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, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0xe2fe
movq %r15, %rdi
movq %r14, %rsi
callq 0xe2fe
movq (%rbx), %rdi
testq %rdi, %rdi
sete %al
leaq 0x28b4c(%rip), %rcx     # 0x37298
cmpq %rcx, %rdi
sete %cl
orb %al, %cl
jne 0xe75e
xorl %esi, %esi
callq *0x28b2a(%rip)          # 0x37288
movq $0x0, (%rbx)
movq 0x18(%r14), %rcx
movl 0x20(%r14), %edx
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe263
// File: /workspace/github_c_makefile_star2_O3/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, %r13d
movq %rsi, %r15
callq 0xe2fe
testl %r13d, %r13d
js 0xe7b1
movl 0x20(%r15), %r12d
cmpl %r13d, %r12d
jl 0xe7bb
xorl %r12d, %r12d
testl %r13d, %r13d
cmovgl %r13d, %r12d
movq (%r15), %rdi
testq %rdi, %rdi
sete %al
leaq 0x28acd(%rip), %rcx     # 0x37298
cmpq %rcx, %rdi
sete %cl
orb %al, %cl
jne 0xe7dd
xorl %esi, %esi
callq *0x28aab(%rip)          # 0x37288
movq $0x0, (%r15)
movq %r15, %rdi
movl %r12d, %esi
movl %r14d, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe263
// File: /workspace/github_c_makefile_star2_O3/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 0xe2fe
testl %ebx, %ebx
js 0xe820
cmpl %ebx, 0x20(%r14)
jg 0xe82e
jmp 0xe83b
movl %ebx, %ecx
notl %ecx
movl 0x20(%r14), %eax
cmpl %ecx, %eax
jle 0xe83b
addl %eax, %ebx
movq 0x18(%r14), %rax
movslq %ebx, %rcx
movq (%rax,%rcx,8), %rax
jmp 0xe83d
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe803
movq %rax, (%r14)
xorl %r14d, %r14d
testq %rax, %rax
jne 0xe8a7
movl $0x1, %r14d
testb $0x1, %r15b
je 0xe8a7
leaq 0x1c6ac(%rip), %rsi     # 0x2af24
movq %rbx, %rdi
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 0xe8a4
movq %rbx, %rdi
callq 0x758c
movq %r15, (%rbx)
movl %r14d, %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: 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 0xe2fe
testl %r12d, %r12d
js 0xeb07
cmpl %r12d, 0x20(%r15)
jg 0xeb17
jmp 0xeb51
movl %r12d, %ecx
notl %ecx
movl 0x20(%r15), %eax
cmpl %ecx, %eax
jle 0xeb51
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 0xeb40
movq 0x18(%r15), %rax
movq (%rax,%r12,8), %rsi
movq %rbx, %rdi
callq 0x758c
movq 0x18(%r15), %rax
movq %r14, (%rax,%r12,8)
incl 0x10(%r14)
xorl %r14d, %r14d
jmp 0xeb93
movl $0x1, %r14d
testb $0x1, %r13b
je 0xeb93
leaq 0x1c3c0(%rip), %rsi     # 0x2af24
movq %rbx, %rdi
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 0xeb90
movq %rbx, %rdi
callq 0x758c
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_O3/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 %rsi, %r15
movq %rdi, %r12
callq 0xe2fe
movl 0x20(%r15), %r14d
movq %r12, %rdi
callq 0xae38
movq %rax, %r13
leaq 0x286ba(%rip), %rax     # 0x37298
movq %rax, (%r13)
movl $0x0, 0x14(%r13)
movq $0x0, 0x8(%r13)
testl %r14d, %r14d
jle 0xec3b
negl %r14d
xorl %ebx, %ebx
movq %r12, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0xe803
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xaf90
leal (%r14,%rbx), %eax
cmpl $-0x1, %eax
je 0xec32
movq %r12, %rdi
movq %r13, %rsi
movq -0x38(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x86a0
incl %ebx
movl %r14d, %eax
addl %ebx, %eax
jne 0xebfc
movq %r13, %rax
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_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 %rbx
pushq %rax
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x80ce
testl %eax, %eax
jne 0xef24
leaq -0x1c(%rbp), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x80ce
xorl %r15d, %r15d
testl %eax, %eax
je 0xef34
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe2fe
movl 0x20(%rbx), %eax
movl -0x20(%rbp), %ecx
movl $0x80000002, %edx       # imm = 0x80000002
cmpl %edx, %ecx
movl $0x0, %edi
cmovael %eax, %edi
addl %ecx, %edi
movl -0x1c(%rbp), %ecx
cmpl %edx, %ecx
movl $0x0, %edx
cmovael %eax, %edx
addl %ecx, %edx
movl %edx, %esi
subl %edi, %esi
jl 0xef6f
incl %esi
jne 0xef7b
movl %edi, %ecx
testl %ecx, %ecx
jne 0xef9a
cmpl %eax, %edx
je 0xef26
jmp 0xef9a
xorl %ecx, %ecx
testl %edi, %edi
cmovgl %edi, %ecx
leal 0x1(%rdx), %edi
cmovsl %edi, %esi
cmpl %eax, %edx
jge 0xef91
movl %esi, %r15d
jmp 0xef71
notl %edx
addl %edx, %eax
addl %esi, %eax
movl %eax, %r15d
xorl %edx, %edx
testl %r15d, %r15d
cmovgl %r15d, %edx
movslq %ecx, %rsi
shlq $0x3, %rsi
addq 0x18(%rbx), %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x762e
// File: /workspace/github_c_makefile_star2_O3/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 0xf00d
incl %r9d
je 0xf00d
testl %r11d, %r11d
jns 0xeff3
movl %r8d, %r9d
incl %r9d
movl $0x0, (%rsi)
movl (%rdx), %r8d
cmpl %edi, %r8d
jge 0xeffd
movl %r9d, %r10d
jmp 0xf00d
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_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_DictAddElement
int Jim_DictAddElement(Jim_Interp *interp, Jim_Obj *objPtr,
    Jim_Obj *keyObjPtr, Jim_Obj *valueObjPtr)
{
    JimPanic((Jim_IsShared(objPtr), "Jim_DictAddElement called with shared object"));
    if (SetDictFromAny(interp, objPtr) != JIM_OK) {
        return JIM_ERR;
    }
    Jim_InvalidateStringRep(objPtr);
    return DictAddElement(interp, objPtr, keyObjPtr, valueObjPtr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
callq 0xf08c
testl %eax, %eax
je 0xf046
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r12), %rdi
testq %rdi, %rdi
sete %al
leaq 0x28241(%rip), %rcx     # 0x37298
cmpq %rcx, %rdi
sete %cl
orb %al, %cl
jne 0xf069
xorl %esi, %esi
callq *0x2821f(%rip)          # 0x37288
movq $0x0, (%r12)
movq 0x18(%r12), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf26d
// File: /workspace/github_c_makefile_star2_O3/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, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0xae38
movq %rax, %r12
leaq 0x25f8a(%rip), %rax     # 0x35390
movq %rax, 0x8(%r12)
movq $0x0, (%r12)
movl %ebx, %edi
movl %ebx, %esi
callq 0xf459
movq %rax, 0x18(%r12)
testl %ebx, %ebx
jle 0xf447
xorl %r13d, %r13d
movq (%r14,%r13,8), %rdx
movq 0x8(%r14,%r13,8), %rcx
movq 0x18(%r12), %rsi
movq %r15, %rdi
callq 0xf26d
addq $0x2, %r13
cmpl %ebx, %r13d
jl 0xf428
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x30, %esi
xorl %edi, %edi
callq *0x27e13(%rip)          # 0x37288
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
testl %r15d, %r15d
je 0xf496
movq %r14, %rdi
movl %r15d, %esi
callq 0x1943b
testl %ebx, %ebx
je 0xf4b1
movslq %ebx, %rsi
shlq $0x3, %rsi
xorl %edi, %edi
callq *0x27ddf(%rip)          # 0x37288
movq %rax, 0x18(%r14)
movl %ebx, 0x24(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq