LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x1d4e0
leaq 0xf272(%rip), %rcx      # 0x2c737
movl $0x1, %r12d
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x7446
jmp 0x1d587
movl %esi, %r12d
movq 0x8(%r15), %r14
cmpl $0x2, 0x10(%r14)
jl 0x1d4fc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8fc2
movq %rax, %r14
movq 0x10(%r15), %rsi
leaq -0x24(%rbp), %rdx
movq %rbx, %rdi
callq 0x80ce
testl %eax, %eax
je 0x1d529
movl $0x1, %r12d
cmpq 0x8(%r15), %r14
je 0x1d587
movq %rbx, %rdi
movq %r14, %rsi
callq 0x758c
jmp 0x1d587
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe2fe
movl 0x20(%r14), %edx
movl -0x24(%rbp), %eax
cmpl %edx, %eax
jge 0x1d54b
testl %eax, %eax
js 0x1d547
movl %eax, %edx
jmp 0x1d54b
addl %eax, %edx
incl %edx
addl $-0x3, %r12d
addq $0x18, %r15
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %ecx
movq %r15, %r8
callq 0xe784
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1d581
movq %rbx, %rdi
callq 0x758c
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_O3/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 0x1dba4
leaq 0xecbf(%rip), %rcx      # 0x2c848
movl $0x1, %r12d
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x7446
jmp 0x1dc9c
movl %esi, %r12d
movq 0x8(%r15), %rsi
cmpl $0x2, %r12d
jne 0x1dbd5
movl $0x1, %r12d
movq %rbx, %rdi
movl $0x1, %edx
callq 0x98e7
movq %rax, %r14
testq %rax, %rax
jne 0x1dc79
jmp 0x1dc9c
movq %rbx, %rdi
movl $0x4, %edx
callq 0x98e7
testq %rax, %rax
je 0x1dc03
movq %rax, %r14
movb $0x1, %al
cmpl $0x2, 0x10(%r14)
jl 0x1dc2a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8fc2
movq %rax, %r14
jmp 0x1dc28
movq %rbx, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x19683(%rip), %rax     # 0x37298
movq %rax, (%r14)
movl $0x0, 0x14(%r14)
movq $0x0, 0x8(%r14)
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
movl %r12d, %r12d
movl $0x2, %r13d
movq (%r15,%r13,8), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaf90
incq %r13
cmpq %r13, %r12
jne 0x1dc36
movq 0x8(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x876e
testl %eax, %eax
je 0x1dc79
movl $0x1, %r12d
cmpb $0x0, -0x2c(%rbp)
jne 0x1dc9c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x758c
jmp 0x1dc9c
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1dc96
movq %rbx, %rdi
callq 0x758c
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_O3/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 0x1dcdc
leaq 0xeb99(%rip), %rcx      # 0x2c85c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7446
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpl $0x2, %esi
jne 0x1dcea
movq 0x8(%rdx), %rsi
movq %rbx, %rdi
jmp 0x1dcfe
decl %esi
addq $0x8, %rdx
movq %rbx, %rdi
callq 0xec4d
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x908a
// File: /workspace/github_c_makefile_star2_O3/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 0x1dd86
movl %esi, %r15d
movq 0x58(%rbx), %r13
movq 0x8(%r14), %r12
movq (%r12), %rax
testq %rax, %rax
jne 0x1dd45
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 0x1dd6d
addq $0x8, %r14
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xd3b7
decl %r15d
jmp 0x1dd77
movq %rbx, %rdi
xorl %esi, %esi
callq 0xd3b7
testq %rax, %rax
je 0x1dd9d
cmpl $0x1, %r15d
ja 0x1ddb1
addq $-0x8, %r14
leaq 0xeadd(%rip), %rcx      # 0x2c86a
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7446
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 0x1ddc1
movq 0x8(%r14), %rsi
jmp 0x1ddd9
decl %r15d
addq $0x8, %r14
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0xec4d
movq %rax, %rsi
movq %rbx, %rdi
callq 0x908a
movq %r13, 0x58(%rbx)
jmp 0x1dda2
// File: /workspace/github_c_makefile_star2_O3/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 0x1de0f
movq 0x8(%rdx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd8ce
jle 0x1de50
decl %esi
addq $0x8, %rdx
movq %rbx, %rdi
callq 0xec4d
movq %rax, %r15
incl 0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd8ce
movl %eax, %r14d
movl 0x10(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r15)
cmpl $0x1, %eax
jg 0x1de6a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x758c
jmp 0x1de6a
leaq 0xea2d(%rip), %rcx      # 0x2c884
movl $0x1, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7446
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: 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 0x1ded2
leaq 0xe9e6(%rip), %rcx      # 0x2c89d
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7446
jmp 0x1df5d
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rcx
cmpl $0x4, %eax
jne 0x1dee6
movq %rbx, %rdi
xorl %edx, %edx
jmp 0x1def3
movq 0x20(%r14), %rax
movq %rbx, %rdi
movq %rcx, %rdx
movq %rax, %rcx
callq 0x22d67
testq %rax, %rax
je 0x1df57
movq 0x8(%r14), %r15
incl 0x10(%r15)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xbf5a
movl 0x10(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r15)
cmpl $0x1, %eax
jg 0x1df2e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x758c
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 0x1df4f
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %r15d, %r15d
jmp 0x1df5d
movl $0x1, %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_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 0x1dfdf
movq 0x1a8(%r14), %rsi
testq %rsi, %rsi
je 0x1dfae
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1dfa3
movq %r14, %rdi
callq 0x758c
movq $0x0, 0x1a8(%r14)
movq 0x8(%rbx), %r12
cmpq $0x0, (%r12)
jne 0x1dfc4
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
xorl %r15d, %r15d
cmpl $0x0, 0x14(%r12)
je 0x1dffc
movq 0x8(%rbx), %rax
movq %rax, 0x1a8(%r14)
incl 0x10(%rax)
jmp 0x1dffc
leaq 0xea8c(%rip), %rcx      # 0x2ca72
movl $0x1, %r15d
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x7446
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: 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 0x1e2f2
movq 0x8(%rbx), %rsi
addq $0x8, %rbx
movq %r14, %rdi
callq 0xd3b7
movq %rax, %r13
decl %r15d
jmp 0x1e2ff
movq %r14, %rdi
xorl %esi, %esi
callq 0xd3b7
movq %rax, %r13
movl $0x1, %r12d
testq %r13, %r13
je 0x1e35e
cmpl $0x3, %r15d
jge 0x1e329
leaq 0xe7ce(%rip), %rcx      # 0x2cae5
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x7446
jmp 0x1e35e
movl %r15d, %r15d
movl $0x1, %r12d
movq (%rbx,%r12,8), %rdx
movq 0x8(%rbx,%r12,8), %rsi
movq %r14, %rdi
movq %r13, %rcx
callq 0xc500
testl %eax, %eax
jne 0x1e358
addq $0x2, %r12
cmpq %r15, %r12
jb 0x1e332
xorl %r12d, %r12d
jmp 0x1e35e
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_O3/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 0x1e3a7
leaq 0xe787(%rip), %rcx      # 0x2cb17
movl $0x1, %ebx
movq %r15, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7446
jmp 0x1e40a
movq 0x58(%r15), %rax
xorl %ebx, %ebx
cmpl $0x0, 0x8(%rax)
je 0x1e40a
movl %esi, %r13d
movl $0x1, %ebx
movq (%r14,%rbx,8), %r12
movq (%r12), %rax
testq %rax, %rax
jne 0x1e3d7
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
movq (%r12), %rax
cmpb $0x3a, (%rax)
jne 0x1e3e2
cmpb $0x3a, 0x1(%rax)
je 0x1e3f9
movq (%r14,%rbx,8), %rdx
movq 0x60(%r15), %rcx
movq %r15, %rdi
movq %rdx, %rsi
callq 0xc500
testl %eax, %eax
jne 0x1e405
incq %rbx
cmpq %rbx, %r13
jne 0x1e3bb
xorl %ebx, %ebx
jmp 0x1e40a
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_O3/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 %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x3, %esi
jl 0x1f369
leaq 0xda3d(%rip), %rcx      # 0x2cd8e
movl $0x1, %r12d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7446
jmp 0x1f3d2
xorl %r15d, %r15d
cmpl $0x2, %esi
jne 0x1f3c8
movq 0x8(%r14), %r15
leaq 0x15f74(%rip), %rax     # 0x352f0
movq %r15, %r12
cmpq %rax, 0x8(%r15)
je 0x1f3a3
movl $0x1, %r12d
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0xd6c3
testl %eax, %eax
jne 0x1f3d2
movq 0x8(%r14), %r12
movq 0x18(%r15), %r15
incl 0x10(%r12)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1f3c5
movq %rbx, %rdi
callq 0x758c
movq %r12, (%rbx)
movl %r15d, 0x30(%rbx)
movl $0x6, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: 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 0x1f8bf
leaq 0xd733(%rip), %rcx      # 0x2cfd7
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7446
jmp 0x1f97a
jne 0x1f8cf
movl $0x80, %r12d
movl $0x1, %r15d
jmp 0x1f92e
movl %esi, %r15d
decl %r15d
movl $0x80, %r12d
movl $0x1, %r13d
movq (%r14,%r13,8), %rsi
movq %rbx, %rdi
leaq 0x17091(%rip), %rdx     # 0x36980
leaq -0x2c(%rbp), %rcx
xorl %r8d, %r8d
movl $0x3, %r9d
callq 0x7eac
testl %eax, %eax
jne 0x1f974
movl -0x2c(%rbp), %eax
cmpl $0x2, %eax
je 0x1f922
cmpl $0x1, %eax
je 0x1f91c
testl %eax, %eax
jne 0x1f926
orl $0x4, %r12d
jmp 0x1f926
orl $0x2, %r12d
jmp 0x1f926
orl $0x1, %r12d
incq %r13
cmpq %r13, %r15
jne 0x1f8e1
movq (%r14,%r15,8), %rsi
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
movl %r12d, %ecx
callq 0x1113d
movl $0x1, %r15d
testl %eax, %eax
jne 0x1f97a
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 0x1f96c
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %r15d, %r15d
jmp 0x1f97a
movl $0x1, %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_ExistsCoreCommand
static int Jim_ExistsCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *objPtr;
    int result = 0;

    static const char * const options[] = {
        "-command", "-proc", "-alias", "-var", NULL
    };
    enum
    {
        OPT_COMMAND, OPT_PROC, OPT_ALIAS, OPT_VAR
    };
    int option;

    if (argc == 2) {
        option = OPT_VAR;
        objPtr = argv[1];
    }
    else if (argc == 3) {
        if (Jim_GetEnum(interp, argv[1], options, &option, NULL, JIM_ERRMSG | JIM_ENUM_ABBREV) != JIM_OK) {
            return JIM_ERR;
        }
        objPtr = argv[2];
    }
    else {
        Jim_WrongNumArgs(interp, 1, argv, "?option? name");
        return JIM_ERR;
    }

    if (option == OPT_VAR) {
        result = Jim_GetVariable(interp, objPtr, 0) != NULL;
    }
    else {

        Jim_Cmd *cmd = Jim_GetCommand(interp, objPtr, JIM_NONE);

        if (cmd) {
            switch (option) {
            case OPT_COMMAND:
                result = 1;
                break;

            case OPT_ALIAS:
                result = cmd->isproc == 0 && cmd->u.native.cmdProc == JimAliasCmd;
                break;

            case OPT_PROC:
                result = cmd->isproc;
                break;
            }
        }
    }
    Jim_SetResultBool(interp, result);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x3, %esi
je 0x202bc
cmpl $0x2, %esi
jne 0x2032e
movq 0x8(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x98e7
xorl %r14d, %r14d
testq %rax, %rax
setne %r14b
movslq %r14d, %r15
movq %rbx, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x1506b(%rip), %rax     # 0x352f0
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movq %r15, 0x18(%r14)
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x202b1
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %r15d, %r15d
jmp 0x2034b
movq 0x8(%r14), %rsi
leaq 0x169d9(%rip), %rdx     # 0x36ca0
leaq -0x1c(%rbp), %rcx
movq %rbx, %rdi
xorl %r8d, %r8d
movl $0x3, %r9d
callq 0x7eac
movl $0x1, %r15d
testl %eax, %eax
jne 0x2034b
movl -0x1c(%rbp), %r15d
movq 0x10(%r14), %rsi
cmpl $0x3, %r15d
je 0x2025c
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x67d1
testq %rax, %rax
je 0x20270
cmpl $0x2, %r15d
je 0x20362
cmpl $0x1, %r15d
je 0x20359
testl %r15d, %r15d
jne 0x20270
movl $0x1, %r14d
jmp 0x20270
leaq 0xcdf9(%rip), %rcx      # 0x2d12e
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7446
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x4(%rax), %r14d
jmp 0x20270
cmpl $0x0, 0x4(%rax)
jne 0x20270
leaq 0x1932(%rip), %rcx      # 0x21ca5
xorl %r14d, %r14d
cmpq %rcx, 0x18(%rax)
sete %r14b
jmp 0x20270
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_JoinCoreCommand
static int Jim_JoinCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    const char *joinStr;
    int joinStrLen;

    if (argc != 2 && argc != 3) {
        Jim_WrongNumArgs(interp, 1, argv, "list ?joinString?");
        return JIM_ERR;
    }

    if (argc == 2) {
        joinStr = " ";
        joinStrLen = 1;
    }
    else {
        joinStr = Jim_GetString(argv[2], &joinStrLen);
    }
    Jim_SetResult(interp, Jim_ListJoin(interp, argv[1], joinStr, joinStrLen));
    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 0x205ce
leaq 0xcb9f(%rip), %rcx      # 0x2d155
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7446
jmp 0x2062f
cmpl $0x2, %esi
jne 0x205e1
leaq 0xcf3a(%rip), %rdx      # 0x2d514
movl $0x1, %ecx
jmp 0x205fe
movq 0x10(%r14), %r15
movq (%r15), %rdx
testq %rdx, %rdx
jne 0x205fa
movq 0x8(%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq (%r15), %rdx
movl 0x14(%r15), %ecx
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xeba5
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 0x20629
movq %rbx, %rdi
callq 0x758c
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_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_FormatCoreCommand
static int Jim_FormatCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *objPtr;

    if (argc < 2) {
        Jim_WrongNumArgs(interp, 1, argv, "formatString ?arg arg ...?");
        return JIM_ERR;
    }
    objPtr = Jim_FormatString(interp, argv[1], argc - 2, argv + 2);
    if (objPtr == NULL)
        return JIM_ERR;
    Jim_SetResult(interp, objPtr);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rax
movq %rdi, %rbx
cmpl $0x1, %esi
jg 0x2066e
leaq 0xcb11(%rip), %rcx      # 0x2d167
movl $0x1, %r14d
movq %rbx, %rdi
movl $0x1, %esi
movq %rax, %rdx
callq 0x7446
jmp 0x206b8
movl %esi, %edx
movq 0x8(%rax), %rsi
addl $-0x2, %edx
addq $0x10, %rax
movq %rbx, %rdi
movq %rax, %rcx
callq 0x12040
testq %rax, %rax
je 0x206b2
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 0x206aa
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %r14d, %r14d
jmp 0x206b8
movl $0x1, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_ErrorCoreCommand
static int Jim_ErrorCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    if (argc != 2 && argc != 3) {
        Jim_WrongNumArgs(interp, 1, argv, "message ?stacktrace?");
        return JIM_ERR;
    }
    Jim_SetResult(interp, argv[1]);
    if (argc == 3) {
        JimSetStackTrace(interp, argv[2]);
        return JIM_ERR;
    }
    return JIM_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
leal -0x4(%r15), %eax
cmpl $-0x3, %eax
ja 0x20ec8
leaq 0xc494(%rip), %rcx      # 0x2d34a
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x7446
jmp 0x20eff
movq 0x8(%rbx), %r12
incl 0x10(%r12)
movq (%r14), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x20eea
movq %r14, %rdi
callq 0x758c
movq %r12, (%r14)
cmpl $0x3, %r15d
jne 0x20eff
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x1b8ae
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_LrangeCoreCommand
static int Jim_LrangeCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *objPtr;

    if (argc != 4) {
        Jim_WrongNumArgs(interp, 1, argv, "list first last");
        return JIM_ERR;
    }
    if ((objPtr = Jim_ListRange(interp, argv[1], argv[2], argv[3])) == NULL)
        return JIM_ERR;
    Jim_SetResult(interp, objPtr);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x4, %esi
jne 0x20f5f
movq 0x8(%rdx), %rsi
movq 0x10(%rdx), %rax
movq 0x18(%rdx), %rcx
movq %rbx, %rdi
movq %rax, %rdx
callq 0xeee8
testq %rax, %rax
je 0x20f7b
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 0x20f57
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %r14d, %r14d
jmp 0x20f81
leaq 0xc3f9(%rip), %rcx      # 0x2d35f
movl $0x1, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7446
jmp 0x20f81
movl $0x1, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_LrepeatCoreCommand
static int Jim_LrepeatCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *objPtr;
    jim_wide count;

    if (argc < 2 || Jim_GetWideExpr(interp, argv[1], &count) != JIM_OK || count < 0) {
        Jim_WrongNumArgs(interp, 1, argv, "count ?value ...?");
        return JIM_ERR;
    }
    if (count == 0 || argc == 2) {
        Jim_SetEmptyResult(interp);
        return JIM_OK;
    }

    argc -= 2;
    argv += 2;

    objPtr = Jim_NewListObj(interp, NULL, 0);
    ListEnsureLength(objPtr, argc * count);
    while (count--) {
        ListInsertElements(objPtr, -1, argc, argv);
    }

    Jim_SetResult(interp, objPtr);
    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, %rbx
cmpl $0x2, %esi
jl 0x20fce
movl %esi, %r15d
movq 0x8(%r14), %rsi
leaq -0x30(%rbp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0xd7f8
testl %eax, %eax
setne %al
movq (%r12), %r13
testq %r13, %r13
sets %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x20ff0
leaq 0xc39a(%rip), %rcx      # 0x2d36f
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7446
jmp 0x210a5
testq %r13, %r13
setne %al
cmpl $0x2, %r15d
setne %cl
testb %al, %cl
jne 0x2102a
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 0x21025
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
jmp 0x210a2
addl $-0x2, %r15d
addq $0x10, %r14
movq %rbx, %rdi
callq 0xae38
movq %rax, %r12
leaq 0x14324(%rip), %rax     # 0x35368
movq %rax, 0x8(%r12)
movq $0x0, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r12)
movl %r13d, %esi
imull %r15d, %esi
movq %r12, %rdi
callq 0x1939a
movq %r12, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl %r15d, %edx
movq %r14, %rcx
callq 0xe263
decq %r13
jne 0x21069
incl 0x10(%r12)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x2109f
movq %rbx, %rdi
callq 0x758c
movq %r12, (%rbx)
xorl %r15d, %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_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_SourceCoreCommand
static int Jim_SourceCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    int retval;

    if (argc != 2) {
        Jim_WrongNumArgs(interp, 1, argv, "fileName");
        return JIM_ERR;
    }
    retval = Jim_EvalFile(interp, Jim_String(argv[1]));
    if (retval == JIM_RETURN)
        return JIM_OK;
    return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x2, %esi
jne 0x21286
movq 0x8(%rdx), %r14
movq (%r14), %rsi
testq %rsi, %rsi
jne 0x21272
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x10f95
xorl %r14d, %r14d
cmpl $0x2, %eax
cmovnel %eax, %r14d
jmp 0x212a0
leaq 0xc130(%rip), %rcx      # 0x2d3bd
movl $0x1, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7446
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_LreverseCoreCommand
static int Jim_LreverseCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *revObjPtr, **ele;
    int len;

    if (argc != 2) {
        Jim_WrongNumArgs(interp, 1, argv, "list");
        return JIM_ERR;
    }
    JimListGetElements(interp, argv[1], &len, &ele);
    revObjPtr = Jim_NewListObj(interp, NULL, 0);
    ListEnsureLength(revObjPtr, len);
    len--;
    while (len >= 0)
        ListAppendElement(revObjPtr, ele[len--]);
    Jim_SetResult(interp, revObjPtr);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, %esi
jne 0x21361
movq 0x8(%rdx), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe2fe
movslq 0x20(%r14), %r15
movq 0x18(%r14), %r13
movq %rbx, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x1407d(%rip), %rax     # 0x35368
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movq %r14, %rdi
movl %r15d, %esi
callq 0x1939a
testq %r15, %r15
jle 0x2133c
incq %r15
leaq -0x30(%rbp), %r12
movq -0x10(%r13,%r15,8), %rax
movq %rax, -0x30(%rbp)
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
movq %r12, %rcx
callq 0xe263
decq %r15
cmpq $0x1, %r15
ja 0x21315
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x21359
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %r14d, %r14d
jmp 0x2137b
leaq 0xb452(%rip), %rcx      # 0x2c7ba
movl $0x1, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7446
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_TailcallCoreCommand
static int Jim_TailcallCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    if (interp->framePtr->level == 0) {
        Jim_SetResultString(interp, "tailcall can only be called from a proc or lambda", -1);
        return JIM_ERR;
    }
    else if (argc >= 2) {

        Jim_CallFrame *cf = interp->framePtr->parent;

        Jim_Cmd *cmdPtr = Jim_GetCommand(interp, argv[1], JIM_ERRMSG);
        if (cmdPtr == NULL) {
            return JIM_ERR;
        }

        JimPanic((cf->tailcallCmd != NULL, "Already have a tailcallCmd"));


        JimIncrCmdRefCount(cmdPtr);
        cf->tailcallCmd = cmdPtr;


        JimPanic((cf->tailcallObj != NULL, "Already have a tailcallobj"));

        cf->tailcallObj = Jim_NewListObj(interp, argv + 1, argc - 1);
        Jim_IncrRefCount(cf->tailcallObj);


        return JIM_EVAL;
    }
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rax
cmpl $0x0, 0x8(%rax)
je 0x21816
movl %esi, %r15d
xorl %r12d, %r12d
cmpl $0x2, %esi
jl 0x21852
movq %rdx, %r14
movq 0x48(%rax), %r13
movq 0x8(%rdx), %rsi
movl $0x1, %r12d
movq %rbx, %rdi
movl $0x1, %edx
callq 0x67d1
testq %rax, %rax
je 0x21852
incl (%rax)
addq $0x8, %r14
movq %rax, 0xa0(%r13)
decl %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x762e
movq %rax, 0x98(%r13)
incl 0x10(%rax)
movl $0x7, %r12d
jmp 0x21852
leaq 0xbc08(%rip), %rsi      # 0x2d425
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 0x21849
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
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_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_LocalCoreCommand
static int Jim_LocalCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    int retcode;

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


    interp->local++;
    retcode = Jim_EvalObjVector(interp, argc - 1, argv + 1);
    interp->local--;



    if (retcode == 0) {
        Jim_Obj *cmdNameObj = Jim_GetResult(interp);

        if (Jim_GetCommand(interp, cmdNameObj, JIM_ERRMSG) == NULL) {
            return JIM_ERR;
        }
        if (interp->framePtr->localCommands == NULL) {
            interp->framePtr->localCommands = Jim_Alloc(sizeof(*interp->framePtr->localCommands));
            Jim_InitStack(interp->framePtr->localCommands);
        }
        Jim_IncrRefCount(cmdNameObj);
        Jim_StackPush(interp->framePtr->localCommands, cmdNameObj);
    }

    return retcode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1, %esi
jg 0x21895
leaq 0xbbda(%rip), %rcx      # 0x2d457
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7446
jmp 0x2191c
incl 0xa8(%rbx)
decl %esi
addq $0x8, %rdx
movq %rbx, %rdi
callq 0x10431
movl %eax, %r15d
decl 0xa8(%rbx)
testl %eax, %eax
jne 0x2191c
movq (%rbx), %r14
movl $0x1, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x67d1
testq %rax, %rax
je 0x2191c
movq 0x58(%rbx), %rax
movq 0x90(%rax), %rdi
testq %rdi, %rdi
jne 0x2190d
movl $0x10, %esi
xorl %edi, %edi
callq *0x15997(%rip)          # 0x37288
movq 0x58(%rbx), %rcx
movq %rax, 0x90(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq 0x58(%rbx), %rax
movq 0x90(%rax), %rdi
incl 0x10(%r14)
movq %r14, %rsi
callq 0xad73
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_UpcallCoreCommand
static int Jim_UpcallCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    if (argc < 2) {
        Jim_WrongNumArgs(interp, 1, argv, "cmd ?args ...?");
        return JIM_ERR;
    }
    else {
        int retcode;

        Jim_Cmd *cmdPtr = Jim_GetCommand(interp, argv[1], JIM_ERRMSG);
        if (cmdPtr == NULL || !cmdPtr->isproc || !cmdPtr->prevCmd) {
            Jim_SetResultFormatted(interp, "no previous command: \"%#s\"", argv[1]);
            return JIM_ERR;
        }

        cmdPtr->u.proc.upcall++;
        JimIncrCmdRefCount(cmdPtr);


        retcode = Jim_EvalObjVector(interp, argc - 1, argv + 1);


        cmdPtr->u.proc.upcall--;
        JimDecrCmdRefCount(interp, cmdPtr);

        return retcode;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x1, %esi
jg 0x21959
leaq 0xbb10(%rip), %rcx      # 0x2d457
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7446
jmp 0x219cd
movl %esi, %r15d
movq 0x8(%r14), %rsi
addq $0x8, %r14
movq %rbx, %rdi
movl $0x1, %edx
callq 0x67d1
testq %rax, %rax
je 0x219b9
movq %rax, %r12
cmpl $0x0, 0x4(%rax)
je 0x219b9
cmpq $0x0, 0x8(%r12)
je 0x219b9
incl 0x40(%r12)
incl (%r12)
decl %r15d
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x10431
movl %eax, %r14d
decl 0x40(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x189aa
movl %r14d, %eax
jmp 0x219d2
movq (%r14), %rdx
leaq 0xbaa3(%rip), %rsi      # 0x2d466
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6923
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_StacktraceCoreCommand
static int Jim_StacktraceCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *listObj;
    int i;
    jim_wide skip = 0;
    jim_wide last = 0;

    if (argc > 1) {
        if (Jim_GetWideExpr(interp, argv[1], &skip) != JIM_OK) {
            return JIM_ERR;
        }
    }
    if (argc > 2) {
        if (Jim_GetWideExpr(interp, argv[2], &last) != JIM_OK) {
            return JIM_ERR;
        }
    }

    listObj = Jim_NewListObj(interp, NULL, 0);
    for (i = skip; i <= interp->procLevel; i++) {
        Jim_EvalFrame *frame = JimGetEvalFrameByProcLevel(interp, -i);
        if (frame->procLevel < last) {
            break;
        }
        JimAddStackFrame(interp, frame, listObj);
    }
    Jim_SetResult(interp, listObj);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, -0x38(%rbp)
movq %rax, -0x30(%rbp)
cmpl $0x2, %esi
jl 0x21c02
movq %rdx, %r14
movl %esi, %r12d
movq 0x8(%rdx), %rsi
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0xd7f8
movl $0x1, %r15d
testl %eax, %eax
jne 0x21c93
cmpl $0x2, %r12d
je 0x21c02
movq 0x10(%r14), %rsi
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0xd7f8
testl %eax, %eax
jne 0x21c93
movq %rbx, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x13754(%rip), %rax     # 0x35368
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movl -0x38(%rbp), %r15d
cmpl %r15d, 0x110(%rbx)
jl 0x21c70
movq -0x30(%rbp), %r12
leal -0x1(%r15), %r13d
negl %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1b792
movslq 0xc(%rax), %rcx
cmpq %rcx, %r12
jg 0x21c70
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x1b7cd
incl %r13d
decl %r15d
cmpl 0x110(%rbx), %r13d
jl 0x21c3f
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x21c8d
movq %rbx, %rdi
callq 0x758c
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_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimAliasCmd
static int JimAliasCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *cmdList;
    Jim_Obj *prefixListObj = Jim_CmdPrivData(interp);


    cmdList = Jim_DuplicateObj(interp, prefixListObj);
    Jim_ListInsertElements(interp, cmdList, Jim_ListLength(interp, cmdList), argc - 1, argv + 1);

    return JimEvalObjList(interp, cmdList);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movq 0x1b8(%rdi), %rsi
callq 0x8fc2
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0xe2fe
movl 0x20(%r12), %edx
decl %r14d
addq $0x8, %rbx
movq %r15, %rdi
movq %r12, %rsi
movl %r14d, %ecx
movq %rbx, %r8
callq 0xe784
movq %r15, %rdi
movq %r12, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10897
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimAddMulHelper
static int JimAddMulHelper(Jim_Interp *interp, int argc, Jim_Obj *const *argv, int op)
{
    jim_wide wideValue, res;
    double doubleValue, doubleRes;
    int i;

    res = (op == JIM_EXPROP_ADD) ? 0 : 1;

    for (i = 1; i < argc; i++) {
        if (Jim_GetWide(interp, argv[i], &wideValue) != JIM_OK)
            goto trydouble;
        if (op == JIM_EXPROP_ADD)
            res += wideValue;
        else
            res *= wideValue;
    }
    Jim_SetResultInt(interp, res);
    return JIM_OK;
  trydouble:
    doubleRes = (double)res;
    for (; i < argc; i++) {
        if (Jim_GetDouble(interp, argv[i], &doubleValue) != JIM_OK)
            return JIM_ERR;
        if (op == JIM_EXPROP_ADD)
            doubleRes += doubleValue;
        else
            doubleRes *= doubleValue;
    }
    Jim_SetResult(interp, Jim_NewDoubleObj(interp, doubleRes));
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, -0x48(%rbp)
movq %rdi, -0x38(%rbp)
xorl %r15d, %r15d
cmpl $0x18, %ecx
setne %r15b
cmpl $0x2, %esi
jl 0x21d9e
movl %ecx, %r14d
movl %esi, -0x3c(%rbp)
movl %esi, %r12d
movl $0x1, %ebx
movq -0x48(%rbp), %rax
movq (%rax,%rbx,8), %r13
leaq 0x1358e(%rip), %rax     # 0x352f0
cmpq %rax, 0x8(%r13)
je 0x21d7d
movq -0x38(%rbp), %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0xd6c3
testl %eax, %eax
jne 0x21df7
movq 0x18(%r13), %r13
leaq (%r15,%r13), %rax
imulq %r15, %r13
cmpl $0x18, %r14d
cmoveq %rax, %r13
incq %rbx
movq %r13, %r15
cmpq %rbx, %r12
jne 0x21d53
jmp 0x21da1
movq %r15, %r13
movq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x13539(%rip), %rax     # 0x352f0
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movq %r13, 0x18(%r14)
incl 0x10(%r14)
movq (%r15), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x2, %eax
jge 0x21de3
movq %r15, %rdi
callq 0x758c
movq %r14, (%r15)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cvtsi2sd %r15, %xmm0
movsd %xmm0, -0x30(%rbp)
cmpl -0x3c(%rbp), %ebx
jge 0x21e53
leaq -0x50(%rbp), %r13
movq -0x38(%rbp), %r15
movq -0x48(%rbp), %rax
movq (%rax,%rbx,8), %rsi
movq %r15, %rdi
movq %r13, %rdx
callq 0xe040
testl %eax, %eax
jne 0x21e9d
movsd -0x50(%rbp), %xmm0
cmpl $0x18, %r14d
jne 0x21e3b
movsd -0x30(%rbp), %xmm1
addsd %xmm0, %xmm1
jmp 0x21e44
movsd -0x30(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, -0x30(%rbp)
incq %rbx
cmpq %rbx, %r12
jne 0x21e0e
jmp 0x21e57
movq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x134d7(%rip), %rax     # 0x35340
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x18(%r14)
incl 0x10(%r14)
movq (%r15), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jle 0x21ddb
jmp 0x21de3
movl $0x1, %eax
jmp 0x21de8
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_ListIndices
static int Jim_ListIndices(Jim_Interp *interp, Jim_Obj *listPtr,
    Jim_Obj *const *indexv, int indexc, Jim_Obj **resultObj, int flags)
{
    int i;
    int static_idxes[5];
    int *idxes = static_idxes;
    int ret = JIM_OK;

    if (indexc > sizeof(static_idxes) / sizeof(*static_idxes)) {
        idxes = Jim_Alloc(indexc * sizeof(*idxes));
    }

    for (i = 0; i < indexc; i++) {
        ret = Jim_GetIndex(interp, indexv[i], &idxes[i]);
        if (ret != JIM_OK) {
            goto err;
        }
    }

    for (i = 0; i < indexc; i++) {
        Jim_Obj *objPtr = Jim_ListGetIndex(interp, listPtr, idxes[i]);
        if (!objPtr) {
            if (flags & JIM_ERRMSG) {
                if (idxes[i] < 0 || idxes[i] > Jim_ListLength(interp, listPtr)) {
                    Jim_SetResultFormatted(interp, "index \"%#s\" out of range", indexv[i]);
                }
                else {
                    Jim_SetResultFormatted(interp, "element %#s missing from sublist \"%#s\"", indexv[i], listPtr);
                }
            }
            return -1;
        }
        listPtr = objPtr;
    }
    *resultObj = listPtr;
err:
    if (idxes != static_idxes)
        Jim_Free(idxes);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %r13d
movq %r8, %r15
movq %rdx, -0x30(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x6, %ecx
jb 0x225e2
movslq %ecx, %rsi
shlq $0x2, %rsi
xorl %edi, %edi
movl %ecx, %r12d
callq *0x14cae(%rip)          # 0x37288
movl %r12d, %ecx
movq %rax, %r12
jmp 0x225e6
leaq -0x60(%rbp), %r12
testl %ecx, %ecx
jle 0x22656
movl %r13d, -0x34(%rbp)
movq %r15, -0x40(%rbp)
movl %ecx, -0x38(%rbp)
movl %ecx, %eax
movq %rax, -0x48(%rbp)
leaq (,%rax,4), %r13
xorl %r15d, %r15d
movq -0x30(%rbp), %rax
movq (%rax,%r15,2), %rsi
leaq (%r12,%r15), %rdx
movq %rbx, %rdi
callq 0x80ce
testl %eax, %eax
jne 0x22661
addq $0x4, %r15
cmpq %r15, %r13
jne 0x22606
cmpl $0x0, -0x38(%rbp)
movq -0x40(%rbp), %r15
jle 0x22656
xorl %r13d, %r13d
movl (%r12,%r13,4), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe803
testq %rax, %rax
je 0x2268d
incq %r13
movq %rax, %r14
cmpq %r13, -0x48(%rbp)
jne 0x22634
jmp 0x22659
movq %r14, %rax
movq %rax, (%r15)
xorl %r15d, %r15d
jmp 0x22667
movl $0x1, %r15d
leaq -0x60(%rbp), %rax
cmpq %rax, %r12
je 0x2267b
movq %r12, %rdi
xorl %esi, %esi
callq *0x14c0d(%rip)          # 0x37288
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testb $0x1, -0x34(%rbp)
je 0x2267b
movl (%r12,%r13,4), %r15d
testl %r15d, %r15d
js 0x226b3
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe2fe
cmpl 0x20(%r14), %r15d
jle 0x226ce
movq -0x30(%rbp), %rax
movq (%rax,%r13,8), %rdx
leaq 0x887a(%rip), %rsi      # 0x2af3c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6923
jmp 0x226ea
movq -0x30(%rbp), %rax
movq (%rax,%r13,8), %rdx
leaq 0x9f1a(%rip), %rsi      # 0x2c5f7
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x6923
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x2267b