LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: ExprTreeFreeNodes
static void ExprTreeFreeNodes(Jim_Interp *interp, struct JimExprNode *nodes, int num)
{
    int i;
    for (i = 0; i < num; i++) {
        if (nodes[i].objPtr) {
            Jim_DecrRefCount(interp, nodes[i].objPtr);
        }
    }
    Jim_Free(nodes);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
testl %edx, %edx
jle 0x1b5bb
movq %rdi, %r14
movl %edx, %eax
shlq $0x3, %rax
leaq (%rax,%rax,4), %r15
xorl %r12d, %r12d
movq 0x8(%rbx,%r12), %rsi
testq %rsi, %rsi
je 0x1b5b2
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1b5b2
movq %r14, %rdi
callq 0x759a
addq $0x28, %r12
cmpq %r12, %r15
jne 0x1b592
movq 0x1ccc6(%rip), %rax     # 0x38288
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: FreeExprInternalRep
static void FreeExprInternalRep(Jim_Interp *interp, Jim_Obj *objPtr)
{
    struct ExprTree *expr = (void *)objPtr->internalRep.ptr;

    if (expr) {
        if (--expr->inUse != 0) {
            return;
        }

        ExprTreeFree(interp, expr);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x18(%rsi), %rbx
testq %rbx, %rbx
je 0x1b5e5
decl 0x14(%rbx)
je 0x1b5ec
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x8(%rbx), %rsi
movl 0x10(%rbx), %edx
callq 0x1b570
movq 0x1cc89(%rip), %rax     # 0x38288
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimScanAString
static Jim_Obj *JimScanAString(Jim_Interp *interp, const char *sdescr, const char *str)
{
    char *buffer = Jim_StrDup(str);
    char *p = buffer;

    while (*str) {
        int c;
        int n;

        if (!sdescr && isspace(UCHAR(*str)))
            break;

        n = utf8_tounicode(str, &c);
        if (sdescr && !JimCharsetMatch(sdescr, strlen(sdescr), c, JIM_CHARSET_SCAN))
            break;
        while (n--)
            *p++ = *str++;
    }
    *p = 0;
    return Jim_NewStringObjNoAlloc(interp, buffer, p - buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
movq %rdx, %rdi
callq 0x6180
movq %rax, %rbx
incl %eax
movslq %eax, %rsi
xorl %edi, %edi
callq *0x1cc3e(%rip)          # 0x38288
movq %rax, %r12
movslq %ebx, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6320
movb $0x0, (%r12,%rbx)
movq %r12, %r13
movzbl (%r14), %ebx
testq %rbx, %rbx
je 0x1b6b8
testq %r15, %r15
je 0x1b6a3
movq %r15, %rdi
callq 0x6180
movq %r15, %rdi
movl %eax, %esi
movl %ebx, %edx
movl $0x2, %ecx
callq 0x17e06
testq %rax, %rax
je 0x1b6b2
movb (%r14), %al
movb %al, (%r13)
incq %r13
incq %r14
movb $0x1, %al
jmp 0x1b6b4
callq 0x64e0
movq (%rax), %rax
testb $0x20, 0x1(%rax,%rbx,2)
je 0x1b692
xorl %eax, %eax
testb %al, %al
jne 0x1b666
movb $0x0, (%r13)
subl %r12d, %r13d
movq -0x30(%rbp), %rdi
movq %r12, %rsi
movl %r13d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xaf08
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimGetEvalFrameByProcLevel
static Jim_EvalFrame *JimGetEvalFrameByProcLevel(Jim_Interp *interp, int proclevel)
{
    Jim_EvalFrame *evalFrame;

    if (proclevel == 0) {
        return interp->evalFrame;
    }

    if (proclevel < 0) {

        proclevel = interp->procLevel + proclevel;
    }

    if (proclevel >= 0) {

        for (evalFrame = interp->evalFrame; evalFrame; evalFrame = evalFrame->parent) {
            if (evalFrame->procLevel == proclevel) {
                return evalFrame;
            }
        }
    }
    return NULL;
}

// Assembly:
testl %esi, %esi
je 0x1bdad
jns 0x1bd84
addl 0x110(%rdi), %esi
testl %esi, %esi
js 0x1bdaa
movq 0x108(%rdi), %rax
testq %rax, %rax
je 0x1bdaa
pushq %rbp
movq %rsp, %rbp
cmpl %esi, 0xc(%rax)
je 0x1bda8
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0x1bd98
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
retq
movq 0x108(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimAddStackFrame
static void JimAddStackFrame(Jim_Interp *interp, Jim_EvalFrame *frame, Jim_Obj *listObj)
{
    Jim_Obj *procNameObj = JimProcForEvalFrame(interp, frame);
    Jim_Obj *fileNameObj = interp->emptyObj;
    int linenr = 1;

    if (frame->scriptObj) {
        ScriptObj *script = JimGetScript(interp, frame->scriptObj);
        fileNameObj = script->fileNameObj;
        linenr = script->linenr;
    }

    Jim_ListAppendElement(interp, listObj, procNameObj ? procNameObj : interp->emptyObj);
    Jim_ListAppendElement(interp, listObj, fileNameObj);
    Jim_ListAppendElement(interp, listObj, Jim_NewIntObj(interp, linenr));
    Jim_ListAppendElement(interp, listObj, Jim_NewListObj(interp, frame->argv, frame->argc));
}

// 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
callq 0x1bed2
movq %rax, %r12
leaq 0x128(%r14), %rcx
movq 0x30(%r15), %rsi
testq %rsi, %rsi
je 0x1be00
movq %r14, %rdi
movq %rcx, %r13
callq 0xb66b
movslq 0x20(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq %r13, %rcx
addq $0x8, %rax
jmp 0x1be0c
movl $0x1, %eax
movq %rax, -0x30(%rbp)
movq %rcx, %rax
movq (%rax), %r13
testq %r12, %r12
jne 0x1be17
movq (%rcx), %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x7695
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x7695
movq %r14, %rdi
callq 0xae58
leaq 0x1a49e(%rip), %rcx     # 0x362e0
movq %rcx, 0x8(%rax)
movq $0x0, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x7695
movq 0x20(%r15), %rsi
movl 0x28(%r15), %edx
movq %r14, %rdi
callq 0x7640
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7695
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimSetStackTrace
static void JimSetStackTrace(Jim_Interp *interp, Jim_Obj *stackTraceObj)
{

    Jim_IncrRefCount(stackTraceObj);
    Jim_DecrRefCount(interp, interp->stackTrace);
    interp->stackTrace = stackTraceObj;
    interp->errorFlag = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
incl 0x10(%rsi)
movq 0x188(%rdi), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1bebc
movq %rbx, %rdi
callq 0x759a
movq %r14, 0x188(%rbx)
movl $0x1, 0x1b4(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimProcForEvalFrame
static Jim_Obj *JimProcForEvalFrame(Jim_Interp *interp, Jim_EvalFrame *frame)
{
    if (frame == interp->evalFrame || (frame->cmd && frame->cmd->cmdNameObj)) {
        Jim_EvalFrame *e;
        for (e = frame->parent; e; e = e->parent) {
            if (e->cmd && e->cmd->isproc && e->cmd->cmdNameObj) {
                break;
            }
        }
        if (e && e->cmd && e->cmd->cmdNameObj) {
            return e->cmd->cmdNameObj;
        }
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq %rsi, 0x108(%rdi)
je 0x1beef
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x1bf26
cmpq $0x0, 0x10(%rax)
je 0x1bf26
movq 0x18(%rsi), %rcx
testq %rcx, %rcx
sete %dl
je 0x1bf21
movq 0x10(%rcx), %rax
testq %rax, %rax
je 0x1bf13
cmpl $0x0, 0x4(%rax)
je 0x1bf13
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x1bf21
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
sete %dl
jne 0x1befb
jmp 0x1bf21
testb $0x1, %dl
je 0x1bf28
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_AliasCoreCommand
static int Jim_AliasCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *prefixListObj;

    if (argc < 3) {
        Jim_WrongNumArgs(interp, 1, argv, "newname command ?args ...?");
        return JIM_ERR;
    }

    prefixListObj = Jim_NewListObj(interp, argv + 2, argc - 2);
    Jim_IncrRefCount(prefixListObj);
    Jim_SetResult(interp, argv[1]);

    return Jim_CreateCommandObj(interp, argv[1], JimAliasCmd, prefixListObj, JimAliasCmdDelete);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x2, %esi
jg 0x1bf5f
leaq 0x114a2(%rip), %rcx     # 0x2d3e9
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7454
jmp 0x1bfbb
movl %esi, %edx
leaq 0x10(%r14), %rsi
addl $-0x2, %edx
movq %rbx, %rdi
callq 0x7640
movq %rax, %r15
incl 0x10(%rax)
movq 0x8(%r14), %r12
incl 0x10(%r12)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1bf98
movq %rbx, %rdi
callq 0x759a
movq %r12, (%rbx)
movq 0x8(%r14), %rsi
leaq 0x6443(%rip), %rdx      # 0x223e9
leaq 0x649a(%rip), %r8       # 0x22447
movq %rbx, %rdi
movq %r15, %rcx
callq 0xbe8d
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_SetCoreCommand
static int Jim_SetCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    if (argc != 2 && argc != 3) {
        Jim_WrongNumArgs(interp, 1, argv, "varName ?newValue?");
        return JIM_ERR;
    }
    if (argc == 2) {
        Jim_Obj *objPtr;

        objPtr = Jim_GetVariable(interp, argv[1], JIM_ERRMSG);
        if (!objPtr)
            return JIM_ERR;
        Jim_SetResult(interp, objPtr);
        return JIM_OK;
    }

    if (Jim_SetVariable(interp, argv[1], argv[2]) != JIM_OK)
        return JIM_ERR;
    Jim_SetResult(interp, argv[2]);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %eax
movq %rdi, %rbx
leal -0x4(%rax), %ecx
cmpl $-0x3, %ecx
ja 0x1c000
leaq 0x1141c(%rip), %rcx     # 0x2d404
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7454
jmp 0x1c063
movq 0x8(%r14), %rsi
cmpl $0x2, %eax
jne 0x1c026
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %edx
callq 0x98ef
testq %rax, %rax
je 0x1c063
movq %rax, %r14
jmp 0x1c040
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0x871b
movl $0x1, %r15d
testl %eax, %eax
jne 0x1c063
movq 0x10(%r14), %r14
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1c05d
movq %rbx, %rdi
callq 0x759a
movq %r14, (%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_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_UnsetCoreCommand
static int Jim_UnsetCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    int i = 1;
    int complain = 1;

    while (i < argc) {
        if (Jim_CompareStringImmediate(interp, argv[i], "--")) {
            i++;
            break;
        }
        if (Jim_CompareStringImmediate(interp, argv[i], "-nocomplain")) {
            complain = 0;
            i++;
            continue;
        }
        break;
    }

    while (i < argc) {
        if (Jim_UnsetVariable(interp, argv[i], complain ? JIM_ERRMSG : JIM_NONE) != JIM_OK
            && complain) {
            return JIM_ERR;
        }
        i++;
    }

    Jim_SetEmptyResult(interp);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
cmpl $0x2, %esi
movq %rdi, -0x40(%rbp)
jl 0x1c0f3
movq %rdi, %rbx
movq %rsi, -0x30(%rbp)
movl %esi, %eax
movq %rax, -0x38(%rbp)
movb $0x1, %r13b
movl $0x1, %r12d
movl $0x2, %r14d
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
leaq 0x11565(%rip), %rdx     # 0x2d61d
callq 0x73d6
testl %eax, %eax
jne 0x1c101
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
leaq 0xf978(%rip), %rdx      # 0x2ba47
callq 0x73d6
testl %eax, %eax
je 0x1c0fe
incq %r12
incl %r14d
xorl %r13d, %r13d
cmpq %r12, -0x38(%rbp)
jne 0x1c0aa
xorl %r13d, %r13d
movq -0x38(%rbp), %rax
movl %eax, %r14d
jmp 0x1c101
movl $0x1, %r14d
movb $0x1, %r13b
jmp 0x1c105
movl %r12d, %r14d
movq -0x30(%rbp), %rsi
subl %r14d, %esi
jle 0x1c144
movzbl %r13b, %r12d
andl $0x1, %r12d
movslq %r14d, %rax
leaq (%r15,%rax,8), %r14
xorl %r15d, %r15d
movq %rsi, %rbx
movq (%r14,%r15,8), %rsi
movq -0x40(%rbp), %rdi
movl %r12d, %edx
callq 0xc7d8
testl %eax, %eax
setne %al
testb %al, %r13b
jne 0x1c173
incq %r15
movq %rbx, %rsi
cmpl %r15d, %esi
jne 0x1c11c
movq -0x40(%rbp), %rbx
movq 0x128(%rbx), %r14
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1c16c
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %eax, %eax
jmp 0x1c178
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_PutsCoreCommand
static int Jim_PutsCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    if (argc != 2 && argc != 3) {
        Jim_WrongNumArgs(interp, 1, argv, "?-nonewline? string");
        return JIM_ERR;
    }
    if (argc == 3) {
        if (!Jim_CompareStringImmediate(interp, argv[1], "-nonewline")) {
            Jim_SetResultString(interp, "The second argument must " "be -nonewline", -1);
            return JIM_ERR;
        }
        else {
            fputs(Jim_String(argv[2]), stdout);
        }
    }
    else {
        puts(Jim_String(argv[1]));
    }
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leal -0x4(%rsi), %eax
cmpl $-0x3, %eax
ja 0x1c1be
leaq 0x11271(%rip), %rcx     # 0x2d417
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7454
jmp 0x1c220
movq 0x8(%r14), %r15
cmpl $0x3, %esi
jne 0x1c205
leaq 0x11279(%rip), %rdx     # 0x2d447
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73d6
testl %eax, %eax
je 0x1c22e
movq 0x10(%r14), %rbx
cmpq $0x0, (%rbx)
jne 0x1c1f1
movq 0x8(%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq (%rbx), %rdi
movq 0x1bd7d(%rip), %rax     # 0x37f78
movq (%rax), %rsi
callq 0x6230
jmp 0x1c21d
cmpq $0x0, (%r15)
jne 0x1c215
movq 0x8(%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq (%r15), %rdi
callq 0x60f0
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x111f6(%rip), %rsi     # 0x2d42b
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
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 0x1c261
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
movl $0x1, %r15d
jmp 0x1c220
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_WhileCoreCommand
static int Jim_WhileCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    if (argc != 3) {
        Jim_WrongNumArgs(interp, 1, argv, "condition body");
        return JIM_ERR;
    }


    while (1) {
        int boolean = 0, retval;

        if ((retval = Jim_GetBoolFromExpr(interp, argv[1], &boolean)) != JIM_OK)
            return retval;
        if (!boolean)
            break;

        if ((retval = Jim_EvalObj(interp, argv[2])) != JIM_OK) {
            if (JimCheckLoopRetcode(interp, retval)) {
                return retval;
            }
            switch (retval) {
                case JIM_BREAK:
                    goto out;
                case JIM_CONTINUE:
                    continue;
                default:
                    return retval;
            }
        }
    }
  out:
    Jim_SetEmptyResult(interp);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x3, %esi
jne 0x1c501
movl $0x2, %eax
movl %eax, %eax
movq %rax, -0x38(%rbp)
leaq 0xbfea(%rip), %r13      # 0x2845c
movl $0x0, -0x2c(%rbp)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
leaq -0x2c(%rbp), %rdx
callq 0xfcb7
movl $0x1, %r12d
testl %eax, %eax
je 0x1c4a3
movl %eax, %r15d
movl %r12d, %eax
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
cmpl $0x0, -0x2c(%rbp)
je 0x1c4e7
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x9078
testl %eax, %eax
je 0x1c4ef
leal -0x3(%rax), %ecx
cmpl $0x1, %ecx
ja 0x1c4cf
movl 0x18(%rbx), %ecx
leal -0x1(%rcx), %edx
movl %edx, 0x18(%rbx)
cmpl $0x1, %ecx
jg 0x1c4f4
cmpl $0x3, %eax
je 0x1c4f9
cmpl $0x4, %eax
jne 0x1c4f4
movq -0x38(%rbp), %rax
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movl $0x3, %r12d
jmp 0x1c496
xorl %r12d, %r12d
jmp 0x1c496
movl %eax, %r15d
jmp 0x1c496
movl $0x5, %r12d
jmp 0x1c496
leaq 0x10f79(%rip), %rcx     # 0x2d481
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7454
jmp 0x1c54a
movq 0x128(%rbx), %r14
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1c544
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
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_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_LassignCoreCommand
static int Jim_LassignCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    int result = JIM_ERR;
    int i;
    Jim_ListIter iter;
    Jim_Obj *resultObj;

    if (argc < 2) {
        Jim_WrongNumArgs(interp, 1, argv, "varList list ?varName ...?");
        return JIM_ERR;
    }

    JimListIterInit(&iter, argv[1]);

    for (i = 2; i < argc; i++) {
        Jim_Obj *valObj = JimListIterNext(interp, &iter);
        result = Jim_SetVariable(interp, argv[i], valObj ? valObj : interp->emptyObj);
        if (result != JIM_OK) {
            return result;
        }
    }

    resultObj = Jim_NewListObj(interp, NULL, 0);
    while (!JimListIterDone(interp, &iter)) {
        Jim_ListAppendElement(interp, resultObj, JimListIterNext(interp, &iter));
    }

    Jim_SetResult(interp, resultObj);

    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
cmpl $0x1, %esi
jg 0x1ca2d
leaq 0x10af1(%rip), %rcx     # 0x2d503
movl $0x1, %r14d
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x7454
jmp 0x1cb25
movq 0x8(%r15), %r14
xorl %r12d, %r12d
cmpl $0x2, %esi
je 0x1ca94
movl %esi, %eax
movq %rax, -0x30(%rbp)
xorl %r12d, %r12d
movl $0x2, %r13d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe338
cmpl 0x20(%r14), %r12d
jge 0x1ca69
movq 0x18(%r14), %rax
movslq %r12d, %rcx
incl %r12d
movq (%rax,%rcx,8), %rdx
jmp 0x1ca6b
xorl %edx, %edx
movq (%r15,%r13,8), %rsi
testq %rdx, %rdx
jne 0x1ca7b
movq 0x128(%rbx), %rdx
movq %rbx, %rdi
callq 0x871b
testl %eax, %eax
jne 0x1cb1f
incq %r13
cmpq %r13, -0x30(%rbp)
jne 0x1ca48
movq %rbx, %rdi
callq 0xae58
movq %rax, %r15
leaq 0x198b2(%rip), %rax     # 0x36358
movq %rax, 0x8(%r15)
movq $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe338
cmpl 0x20(%r14), %r12d
jge 0x1cafa
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe338
cmpl 0x20(%r14), %r12d
jge 0x1caeb
movq 0x18(%r14), %rax
movslq %r12d, %rcx
incl %r12d
movq (%rax,%rcx,8), %rdx
jmp 0x1caed
xorl %edx, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7695
jmp 0x1cab9
incl 0x10(%r15)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1cb17
movq %rbx, %rdi
callq 0x759a
movq %r15, (%rbx)
xorl %r14d, %r14d
jmp 0x1cb25
movl $0x1, %r14d
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_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_LindexCoreCommand
static int Jim_LindexCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *objPtr;
    int ret;

    if (argc < 2) {
        Jim_WrongNumArgs(interp, 1, argv, "list ?index ...?");
        return JIM_ERR;
    }
    ret = Jim_ListIndices(interp, argv[1], argv + 2, argc - 2, &objPtr, JIM_NONE);
    if (ret < 0) {
        ret = JIM_OK;
        Jim_SetEmptyResult(interp);
    }
    else if (ret == JIM_OK) {
        Jim_SetResult(interp, objPtr);
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x1, %esi
jg 0x1d18c
leaq 0x104cd(%rip), %rcx     # 0x2d644
movl $0x1, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7454
jmp 0x1d1e1
movl %esi, %ecx
movq 0x8(%rdx), %rsi
addq $0x10, %rdx
addl $-0x2, %ecx
leaq -0x18(%rbp), %r8
movq %rbx, %rdi
xorl %r9d, %r9d
callq 0x22e05
testl %eax, %eax
js 0x1d1b7
movl %eax, %r14d
jne 0x1d1e1
movq -0x18(%rbp), %r14
jmp 0x1d1be
movq 0x128(%rbx), %r14
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1d1db
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_LsetCoreCommand
static int Jim_LsetCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    if (argc < 3) {
        Jim_WrongNumArgs(interp, 1, argv, "listVar ?index ...? value");
        return JIM_ERR;
    }
    else if (argc == 3) {

        if (Jim_SetVariable(interp, argv[1], argv[2]) != JIM_OK)
            return JIM_ERR;
        Jim_SetResult(interp, argv[2]);
        return JIM_OK;
    }
    return Jim_ListSetIndex(interp, argv[1], argv + 2, argc - 3, argv[argc - 1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, %esi
jg 0x1d21b
leaq 0x10476(%rip), %rcx     # 0x2d67c
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7454
jmp 0x1d265
movl %esi, %ecx
leaq 0x10(%rdx), %r14
movq 0x8(%rdx), %rsi
cmpl $0x3, %ecx
jne 0x1d273
movq (%r14), %rdx
movq %rbx, %rdi
callq 0x871b
movl $0x1, %r15d
testl %eax, %eax
jne 0x1d265
movq (%r14), %r14
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1d25f
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %ecx, %eax
addl $-0x3, %ecx
movq -0x8(%rdx,%rax,8), %r8
movq %rbx, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe925
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_LlengthCoreCommand
static int Jim_LlengthCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    if (argc != 2) {
        Jim_WrongNumArgs(interp, 1, argv, "list");
        return JIM_ERR;
    }
    Jim_SetResultInt(interp, Jim_ListLength(interp, argv[1]));
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, %esi
jne 0x1dac6
movq 0x8(%rdx), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe338
movslq 0x20(%r14), %r15
movq %rbx, %rdi
callq 0xae58
movq %rax, %r14
leaq 0x1884e(%rip), %rax     # 0x362e0
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movq %r15, 0x18(%r14)
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1dabe
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %r14d, %r14d
jmp 0x1dae0
leaq 0xfd4b(%rip), %rcx      # 0x2d818
movl $0x1, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7454
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_LappendCoreCommand
static int Jim_LappendCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *listObjPtr;
    int new_obj = 0;
    int i;

    if (argc < 2) {
        Jim_WrongNumArgs(interp, 1, argv, "varName ?value value ...?");
        return JIM_ERR;
    }
    listObjPtr = Jim_GetVariable(interp, argv[1], JIM_UNSHARED);
    if (!listObjPtr) {

        listObjPtr = Jim_NewListObj(interp, NULL, 0);
        new_obj = 1;
    }
    else if (Jim_IsShared(listObjPtr)) {
        listObjPtr = Jim_DuplicateObj(interp, listObjPtr);
        new_obj = 1;
    }
    for (i = 2; i < argc; i++)
        Jim_ListAppendElement(interp, listObjPtr, argv[i]);
    if (Jim_SetVariable(interp, argv[1], listObjPtr) != JIM_OK) {
        if (new_obj)
            Jim_FreeNewObj(interp, listObjPtr);
        return JIM_ERR;
    }
    Jim_SetResult(interp, listObjPtr);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
cmpl $0x1, %esi
jg 0x1db29
leaq 0xfc6d(%rip), %rcx      # 0x2d77b
movl $0x1, %r12d
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x7454
jmp 0x1dc08
movl %esi, %r12d
movq 0x8(%r15), %rsi
movq %rbx, %rdi
movl $0x4, %edx
callq 0x98ef
testq %rax, %rax
je 0x1db5e
movq %rax, %r14
movb $0x1, %al
cmpl $0x2, 0x10(%r14)
jl 0x1db85
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8fa8
movq %rax, %r14
jmp 0x1db83
movq %rbx, %rdi
callq 0xae58
movq %rax, %r14
leaq 0x187e8(%rip), %rax     # 0x36358
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x2, %r12d
je 0x1dbb9
cmpl $0x4, %r12d
movl $0x3, %r13d
cmovgel %r12d, %r13d
movl $0x2, %r12d
movq (%r15,%r12,8), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7695
incq %r12
cmpq %r12, %r13
jne 0x1dba2
movq 0x8(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x871b
testl %eax, %eax
je 0x1dbe5
movl $0x1, %r12d
cmpb $0x0, -0x2c(%rbp)
jne 0x1dc08
movq %rbx, %rdi
movq %r14, %rsi
callq 0x759a
jmp 0x1dc08
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1dc02
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
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_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_LinsertCoreCommand
static int Jim_LinsertCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    int idx, len;
    Jim_Obj *listPtr;

    if (argc < 3) {
        Jim_WrongNumArgs(interp, 1, argv, "list index ?element ...?");
        return JIM_ERR;
    }
    listPtr = argv[1];
    if (Jim_IsShared(listPtr))
        listPtr = Jim_DuplicateObj(interp, listPtr);
    if (Jim_GetIndex(interp, argv[2], &idx) != JIM_OK)
        goto err;
    len = Jim_ListLength(interp, listPtr);
    if (idx >= len)
        idx = len;
    else if (idx < 0)
        idx = len + idx + 1;
    Jim_ListInsertElements(interp, listPtr, idx, argc - 3, &argv[3]);
    Jim_SetResult(interp, listPtr);
    return JIM_OK;
  err:
    if (listPtr != argv[1]) {
        Jim_FreeNewObj(interp, listPtr);
    }
    return JIM_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rdi, %rbx
cmpl $0x2, %esi
jg 0x1dc56
leaq 0xfb5a(%rip), %rcx      # 0x2d795
movl $0x1, %r12d
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x7454
jmp 0x1dd04
movl %esi, %r12d
movq 0x8(%r15), %r14
cmpl $0x2, 0x10(%r14)
jl 0x1dc72
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8fa8
movq %rax, %r14
movq 0x10(%r15), %rsi
leaq -0x24(%rbp), %rdx
movq %rbx, %rdi
callq 0x80b2
testl %eax, %eax
je 0x1dc9f
movl $0x1, %r12d
cmpq 0x8(%r15), %r14
je 0x1dd04
movq %rbx, %rdi
movq %r14, %rsi
callq 0x759a
jmp 0x1dd04
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe338
movl 0x20(%r14), %eax
movl -0x24(%rbp), %ecx
cmpl %eax, %ecx
jge 0x1dcc2
testl %ecx, %ecx
jns 0x1dcc5
addl %ecx, %eax
incl %eax
movl %eax, -0x24(%rbp)
jmp 0x1dcc5
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edx
addl $-0x3, %r12d
addq $0x18, %r15
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %ecx
movq %r15, %r8
callq 0xe7f2
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1dcfe
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_AppendCoreCommand
static int Jim_AppendCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *stringObjPtr;
    int i;

    if (argc < 2) {
        Jim_WrongNumArgs(interp, 1, argv, "varName ?value ...?");
        return JIM_ERR;
    }
    if (argc == 2) {
        stringObjPtr = Jim_GetVariable(interp, argv[1], JIM_ERRMSG);
        if (!stringObjPtr)
            return JIM_ERR;
    }
    else {
        int new_obj = 0;
        stringObjPtr = Jim_GetVariable(interp, argv[1], JIM_UNSHARED);
        if (!stringObjPtr) {

            stringObjPtr = Jim_NewEmptyStringObj(interp);
            new_obj = 1;
        }
        else if (Jim_IsShared(stringObjPtr)) {
            new_obj = 1;
            stringObjPtr = Jim_DuplicateObj(interp, stringObjPtr);
        }
        for (i = 2; i < argc; i++) {
            Jim_AppendObj(interp, stringObjPtr, argv[i]);
        }
        if (Jim_SetVariable(interp, argv[1], stringObjPtr) != JIM_OK) {
            if (new_obj) {
                Jim_FreeNewObj(interp, stringObjPtr);
            }
            return JIM_ERR;
        }
    }
    Jim_SetResult(interp, stringObjPtr);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
cmpl $0x1, %esi
jg 0x1e39b
leaq 0xf526(%rip), %rcx      # 0x2d8a6
movl $0x1, %r12d
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x7454
jmp 0x1e49e
movl %esi, %r12d
movq 0x8(%r15), %rsi
cmpl $0x2, %r12d
jne 0x1e3cc
movl $0x1, %r12d
movq %rbx, %rdi
movl $0x1, %edx
callq 0x98ef
movq %rax, %r14
testq %rax, %rax
jne 0x1e47b
jmp 0x1e49e
movq %rbx, %rdi
movl $0x4, %edx
callq 0x98ef
testq %rax, %rax
je 0x1e3fa
movq %rax, %r14
movb $0x1, %al
cmpl $0x2, 0x10(%r14)
jl 0x1e421
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8fa8
movq %rax, %r14
jmp 0x1e41f
movq %rbx, %rdi
callq 0xae58
movq %rax, %r14
leaq 0x19e8c(%rip), %rax     # 0x38298
movq %rax, (%r14)
movl $0x0, 0x14(%r14)
movq $0x0, 0x8(%r14)
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x4, %r12d
movl $0x3, %r13d
cmovgel %r12d, %r13d
movl $0x2, %r12d
movq (%r15,%r12,8), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xafb0
incq %r12
cmpq %r12, %r13
jne 0x1e438
movq 0x8(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x871b
testl %eax, %eax
je 0x1e47b
movl $0x1, %r12d
cmpb $0x0, -0x2c(%rbp)
jne 0x1e49e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x759a
jmp 0x1e49e
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1e498
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
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_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_EvalCoreCommand
static int Jim_EvalCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    int rc;

    if (argc < 2) {
        Jim_WrongNumArgs(interp, 1, argv, "arg ?arg ...?");
        return JIM_ERR;
    }

    if (argc == 2) {
        rc = Jim_EvalObj(interp, argv[1]);
    }
    else {
        rc = Jim_EvalObj(interp, Jim_ConcatObj(interp, argc - 1, argv + 1));
    }

    return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1, %esi
jg 0x1e4de
leaq 0xf3f5(%rip), %rcx      # 0x2d8ba
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7454
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpl $0x2, %esi
jne 0x1e4ec
movq 0x8(%rdx), %rsi
movq %rbx, %rdi
jmp 0x1e500
decl %esi
addq $0x8, %rdx
movq %rbx, %rdi
callq 0xecb2
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9078
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_UplevelCoreCommand
static int Jim_UplevelCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    if (argc >= 2) {
        int retcode;
        Jim_CallFrame *savedCallFrame, *targetCallFrame;
        const char *str;


        savedCallFrame = interp->framePtr;


        str = Jim_String(argv[1]);
        if ((str[0] >= '0' && str[0] <= '9') || str[0] == '#') {
            targetCallFrame = Jim_GetCallFrameByLevel(interp, argv[1]);
            argc--;
            argv++;
        }
        else {
            targetCallFrame = Jim_GetCallFrameByLevel(interp, NULL);
        }
        if (targetCallFrame == NULL) {
            return JIM_ERR;
        }
        if (argc < 2) {
            Jim_WrongNumArgs(interp, 1, argv - 1, "?level? command ?arg ...?");
            return JIM_ERR;
        }

        interp->framePtr = targetCallFrame;
        if (argc == 2) {
            retcode = Jim_EvalObj(interp, argv[1]);
        }
        else {
            retcode = Jim_EvalObj(interp, Jim_ConcatObj(interp, argc - 1, argv + 1));
        }
        interp->framePtr = savedCallFrame;
        return retcode;
    }
    else {
        Jim_WrongNumArgs(interp, 1, argv, "?level? command ?arg ...?");
        return JIM_ERR;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x2, %esi
jl 0x1e586
movl %esi, %r15d
movq 0x58(%rbx), %r13
movq 0x8(%r14), %r12
cmpq $0x0, (%r12)
jne 0x1e541
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
movq (%r12), %rax
movb (%rax), %al
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
setae %cl
cmpb $0x23, %al
setne %al
testb %cl, %al
jne 0x1e56d
addq $0x8, %r14
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xd3ab
decl %r15d
jmp 0x1e577
movq %rbx, %rdi
xorl %esi, %esi
callq 0xd3ab
testq %rax, %rax
je 0x1e59d
cmpl $0x1, %r15d
jg 0x1e5b1
addq $-0x8, %r14
leaq 0xf33b(%rip), %rcx      # 0x2d8c8
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7454
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x58(%rbx)
cmpl $0x2, %r15d
jne 0x1e5c1
movq 0x8(%r14), %rsi
jmp 0x1e5d9
decl %r15d
addq $0x8, %r14
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0xecb2
movq %rax, %rsi
movq %rbx, %rdi
callq 0x9078
movq %r13, 0x58(%rbx)
jmp 0x1e5a2
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_ExprCoreCommand
static int Jim_ExprCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    int retcode;

    if (argc == 2) {
        retcode = Jim_EvalExpression(interp, argv[1]);
    }
#ifndef JIM_COMPAT
    else {
        Jim_WrongNumArgs(interp, 1, argv, "expression");
        retcode = JIM_ERR;
    }
#else
    else if (argc > 2) {
        Jim_Obj *objPtr;

        objPtr = Jim_ConcatObj(interp, argc - 1, argv + 1);
        Jim_IncrRefCount(objPtr);
        retcode = Jim_EvalExpression(interp, objPtr);
        Jim_DecrRefCount(interp, objPtr);
    }
    else {
        Jim_WrongNumArgs(interp, 1, argv, "expression ?...?");
        return JIM_ERR;
    }
#endif
    return retcode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, %esi
jne 0x1e60f
movq 0x8(%rdx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd8dd
jle 0x1e650
decl %esi
addq $0x8, %rdx
movq %rbx, %rdi
callq 0xecb2
movq %rax, %r15
incl 0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd8dd
movl %eax, %r14d
movl 0x10(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r15)
cmpl $0x1, %eax
jg 0x1e66a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x759a
jmp 0x1e66a
leaq 0xf28b(%rip), %rcx      # 0x2d8e2
movl $0x1, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7454
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_ProcCoreCommand
static int Jim_ProcCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Cmd *cmd;

    if (argc != 4 && argc != 5) {
        Jim_WrongNumArgs(interp, 1, argv, "name arglist ?statics? body");
        return JIM_ERR;
    }

    if (argc == 4) {
        cmd = JimCreateProcedureCmd(interp, argv[2], NULL, argv[3], NULL);
    }
    else {
        cmd = JimCreateProcedureCmd(interp, argv[2], argv[3], argv[4], NULL);
    }

    if (cmd) {

        Jim_Obj *nameObjPtr = JimQualifyName(interp, argv[1]);
        JimCreateCommand(interp, nameObjPtr, cmd);


        JimUpdateProcNamespace(interp, cmd, nameObjPtr);
        Jim_DecrRefCount(interp, nameObjPtr);


        Jim_SetResult(interp, argv[1]);
        return JIM_OK;
    }
    return JIM_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %eax
movq %rdi, %rbx
leal -0x6(%rax), %ecx
cmpl $-0x3, %ecx
ja 0x1e6d2
leaq 0xf244(%rip), %rcx      # 0x2d8fb
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7454
jmp 0x1e75d
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rcx
cmpl $0x4, %eax
jne 0x1e6e6
movq %rbx, %rdi
xorl %edx, %edx
jmp 0x1e6f3
movq 0x20(%r14), %rax
movq %rbx, %rdi
movq %rcx, %rdx
movq %rax, %rcx
callq 0x23646
testq %rax, %rax
je 0x1e757
movq 0x8(%r14), %r15
incl 0x10(%r15)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xbf22
movl 0x10(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r15)
cmpl $0x1, %eax
jg 0x1e72e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x759a
movq 0x8(%r14), %r14
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1e74f
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %r15d, %r15d
jmp 0x1e75d
movl $0x1, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_XtraceCoreCommand
static int Jim_XtraceCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    if (argc != 2) {
        Jim_WrongNumArgs(interp, 1, argv, "callback");
        return JIM_ERR;
    }

    if (interp->traceCmdObj) {
        Jim_DecrRefCount(interp, interp->traceCmdObj);
        interp->traceCmdObj = NULL;
    }

    if (Jim_Length(argv[1])) {

        interp->traceCmdObj = argv[1];
        Jim_IncrRefCount(interp->traceCmdObj);
    }
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0x2, %esi
jne 0x1e7df
movq 0x1a8(%r14), %rsi
testq %rsi, %rsi
je 0x1e7ae
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1e7a3
movq %r14, %rdi
callq 0x759a
movq $0x0, 0x1a8(%r14)
movq 0x8(%rbx), %r12
cmpq $0x0, (%r12)
jne 0x1e7c4
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
xorl %r15d, %r15d
cmpl $0x0, 0x14(%r12)
je 0x1e7fc
movq 0x8(%rbx), %rax
movq %rax, 0x1a8(%r14)
incl 0x10(%rax)
jmp 0x1e7fc
leaq 0xf2ea(%rip), %rcx      # 0x2dad0
movl $0x1, %r15d
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x7454
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_UpvarCoreCommand
static int Jim_UpvarCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    int i;
    Jim_CallFrame *targetCallFrame;


    if (argc > 3 && (argc % 2 == 0)) {
        targetCallFrame = Jim_GetCallFrameByLevel(interp, argv[1]);
        argc--;
        argv++;
    }
    else {
        targetCallFrame = Jim_GetCallFrameByLevel(interp, NULL);
    }
    if (targetCallFrame == NULL) {
        return JIM_ERR;
    }


    if (argc < 3) {
        Jim_WrongNumArgs(interp, 1, argv, "?level? otherVar localVar ?otherVar localVar ...?");
        return JIM_ERR;
    }


    for (i = 1; i < argc; i += 2) {
        if (Jim_SetVariableLink(interp, argv[i + 1], argv[i], targetCallFrame) != JIM_OK)
            return JIM_ERR;
    }
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
cmpl $0x4, %esi
setl %al
movl %r15d, %ecx
orb %al, %cl
testb $0x1, %cl
jne 0x1eac1
movq 0x8(%rbx), %rsi
addq $0x8, %rbx
movq %r14, %rdi
callq 0xd3ab
movq %rax, %r13
decl %r15d
jmp 0x1eace
movq %r14, %rdi
xorl %esi, %esi
callq 0xd3ab
movq %rax, %r13
movl $0x1, %r12d
testq %r13, %r13
je 0x1eb2d
cmpl $0x3, %r15d
jge 0x1eaf8
leaq 0xf05d(%rip), %rcx      # 0x2db43
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x7454
jmp 0x1eb2d
movl %r15d, %r15d
movl $0x1, %r12d
movq (%rbx,%r12,8), %rdx
movq 0x8(%rbx,%r12,8), %rsi
movq %r14, %rdi
movq %r13, %rcx
callq 0xc4e5
testl %eax, %eax
jne 0x1eb27
addq $0x2, %r12
cmpq %r15, %r12
jb 0x1eb01
xorl %r12d, %r12d
jmp 0x1eb2d
movl $0x1, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_GlobalCoreCommand
static int Jim_GlobalCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    int i;

    if (argc < 2) {
        Jim_WrongNumArgs(interp, 1, argv, "varName ?varName ...?");
        return JIM_ERR;
    }

    if (interp->framePtr->level == 0)
        return JIM_OK;
    for (i = 1; i < argc; i++) {

        const char *name = Jim_String(argv[i]);
        if (name[0] != ':' || name[1] != ':') {
            if (Jim_SetVariableLink(interp, argv[i], argv[i], interp->topFramePtr) != JIM_OK)
                return JIM_ERR;
        }
    }
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %r15
cmpl $0x1, %esi
jg 0x1eb76
leaq 0xf016(%rip), %rcx      # 0x2db75
movl $0x1, %ebx
movq %r15, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7454
jmp 0x1ebd7
movq 0x58(%r15), %rax
xorl %ebx, %ebx
cmpl $0x0, 0x8(%rax)
je 0x1ebd7
movl %esi, %r13d
movl $0x1, %ebx
movq (%r14,%rbx,8), %r12
cmpq $0x0, (%r12)
jne 0x1eba0
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
movq (%r12), %rax
cmpb $0x3a, (%rax)
jne 0x1ebaf
cmpb $0x3a, 0x1(%rax)
je 0x1ebc6
movq (%r14,%rbx,8), %rdx
movq 0x60(%r15), %rcx
movq %r15, %rdi
movq %rdx, %rsi
callq 0xc4e5
testl %eax, %eax
jne 0x1ebd2
incq %rbx
cmpq %rbx, %r13
jne 0x1eb8a
xorl %ebx, %ebx
jmp 0x1ebd7
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_ExitCoreCommand
static int Jim_ExitCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    long exitCode = 0;

    if (argc > 2) {
        Jim_WrongNumArgs(interp, 1, argv, "?exitCode?");
        return JIM_ERR;
    }
    if (argc == 2) {
        if (Jim_GetLong(interp, argv[1], &exitCode) != JIM_OK)
            return JIM_ERR;
        Jim_SetResult(interp, argv[1]);
    }
    interp->exitCode = exitCode;
    return JIM_EXIT;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x3, %esi
jl 0x1faae
leaq 0xe356(%rip), %rcx      # 0x2ddec
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7454
jmp 0x1fb27
xorl %eax, %eax
cmpl $0x2, %esi
jne 0x1fb1e
movq 0x8(%r14), %r15
leaq 0x16820(%rip), %rax     # 0x362e0
cmpq %rax, 0x8(%r15)
je 0x1fadf
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0xd6d7
testl %eax, %eax
je 0x1fadf
xorl %r13d, %r13d
jmp 0x1fae6
movl 0x18(%r15), %r12d
movb $0x1, %r13b
movl $0x1, %r15d
testb %r13b, %r13b
je 0x1fb27
movq 0x8(%r14), %r14
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1fb12
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %eax, %eax
testb %r13b, %r13b
cmovnel %r12d, %eax
movl %eax, 0x30(%rbx)
movl $0x6, %r15d
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_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_SubstCoreCommand
static int Jim_SubstCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    static const char * const options[] = {
        "-nobackslashes", "-nocommands", "-novariables", NULL
    };
    enum
    { OPT_NOBACKSLASHES, OPT_NOCOMMANDS, OPT_NOVARIABLES };
    int i;
    int flags = JIM_SUBST_FLAG;
    Jim_Obj *objPtr;

    if (argc < 2) {
        Jim_WrongNumArgs(interp, 1, argv, "?options? string");
        return JIM_ERR;
    }
    for (i = 1; i < (argc - 1); i++) {
        int option;

        if (Jim_GetEnum(interp, argv[i], options, &option, NULL,
                JIM_ERRMSG | JIM_ENUM_ABBREV) != JIM_OK) {
            return JIM_ERR;
        }
        switch (option) {
            case OPT_NOBACKSLASHES:
                flags |= JIM_SUBST_NOESC;
                break;
            case OPT_NOCOMMANDS:
                flags |= JIM_SUBST_NOCMD;
                break;
            case OPT_NOVARIABLES:
                flags |= JIM_SUBST_NOVAR;
                break;
        }
    }
    if (Jim_SubstObj(interp, argv[argc - 1], &objPtr, flags) != JIM_OK) {
        return JIM_ERR;
    }
    Jim_SetResult(interp, objPtr);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x2, %esi
jge 0x1ffed
leaq 0xe067(%rip), %rcx      # 0x2e039
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7454
jmp 0x200ac
leal -0x1(%rsi), %eax
movl $0x80, %r15d
movl %eax, %r12d
cmpl $0x2, %esi
jne 0x20048
movq (%r14,%r12,8), %rsi
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
movl %r15d, %ecx
callq 0x11260
movl $0x1, %r15d
testl %eax, %eax
jne 0x200ac
movq -0x38(%rbp), %r14
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x20040
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %r15d, %r15d
jmp 0x200ac
movl $0x1, %r13d
movq (%r14,%r13,8), %rsi
movq %rbx, %rdi
leaq 0x17924(%rip), %rdx     # 0x37980
leaq -0x2c(%rbp), %rcx
xorl %r8d, %r8d
movl $0x3, %r9d
callq 0x7e97
testl %eax, %eax
je 0x20083
testl %eax, %eax
jne 0x200a6
incq %r13
cmpq %r13, %r12
jne 0x2004e
jmp 0x1fffe
movl -0x2c(%rbp), %ecx
cmpl $0x2, %ecx
je 0x200a0
cmpl $0x1, %ecx
je 0x2009a
testl %ecx, %ecx
jne 0x20072
orl $0x4, %r15d
jmp 0x20072
orl $0x2, %r15d
jmp 0x20072
orl $0x1, %r15d
jmp 0x20072
movl $0x1, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq