LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_LreplaceCoreCommand
static int Jim_LreplaceCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    int first, last, len, rangeLen;
    Jim_Obj *listObj;
    Jim_Obj *newListObj;

    if (argc < 4) {
        Jim_WrongNumArgs(interp, 1, argv, "list first last ?element ...?");
        return JIM_ERR;
    }
    if (Jim_GetIndex(interp, argv[2], &first) != JIM_OK ||
        Jim_GetIndex(interp, argv[3], &last) != JIM_OK) {
        return JIM_ERR;
    }

    listObj = argv[1];
    len = Jim_ListLength(interp, listObj);

    first = JimRelToAbsIndex(len, first);
    last = JimRelToAbsIndex(len, last);
    JimRelToAbsRange(len, &first, &last, &rangeLen);


    if (first > len) {
        first = len;
    }


    newListObj = Jim_NewListObj(interp, listObj->internalRep.listValue.ele, first);


    ListInsertElements(newListObj, -1, argc - 4, argv + 4);


    ListInsertElements(newListObj, -1, len - first - rangeLen, listObj->internalRep.listValue.ele + first + rangeLen);

    Jim_SetResult(interp, newListObj);
    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
movq %rdi, %rbx
cmpl $0x3, %esi
jg 0x1aae3
leaq 0xdcd4(%rip), %rcx      # 0x287a0
pushq $0x1
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x72a5
jmp 0x1abfe
movl %esi, %r12d
movq 0x10(%r15), %rsi
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x7d46
pushq $0x1
popq %r14
testl %eax, %eax
jne 0x1abfe
movq 0x18(%r15), %rsi
leaq -0x34(%rbp), %rdx
movq %rbx, %rdi
callq 0x7d46
testl %eax, %eax
jne 0x1abfe
movq 0x8(%r15), %rsi
movq %rsi, -0x40(%rbp)
movq %rbx, %rdi
callq 0x8b3c
movl %eax, %edi
movl %eax, -0x2c(%rbp)
leaq -0x38(%rbp), %r13
movl (%r13), %eax
xorl %r14d, %r14d
movl $0x80000002, %ecx       # imm = 0x80000002
cmpl %ecx, %eax
movl $0x0, %edx
cmovael %edi, %edx
addl %eax, %edx
movl %edx, (%r13)
leaq -0x34(%rbp), %rdx
movl (%rdx), %eax
cmpl %ecx, %eax
movl $0x0, %ecx
cmovael %edi, %ecx
addl %eax, %ecx
movl %ecx, (%rdx)
leaq -0x30(%rbp), %rcx
movq %r13, %rsi
callq 0xe05b
movl (%r13), %r13d
movl -0x2c(%rbp), %eax
cmpl %eax, %r13d
cmovgel %eax, %r13d
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rsi
movq %rbx, %rdi
movl %r13d, %edx
callq 0x745b
addl $-0x4, %r12d
addq $0x20, %r15
pushq $-0x1
popq %rsi
movq %rax, %rdi
movl %r12d, %edx
movq %r15, %rcx
movq %rax, %r15
callq 0xd439
leaq -0x30(%rbp), %rax
movslq (%rax), %rax
movl -0x2c(%rbp), %r8d
subl %eax, %r8d
subl %r13d, %r8d
movslq %r13d, %rcx
shlq $0x3, %rcx
movq -0x40(%rbp), %rdx
addq 0x18(%rdx), %rcx
leaq (%rcx,%rax,8), %rcx
movq %r15, %rdi
pushq $-0x1
popq %rsi
movl %r8d, %edx
callq 0xd439
incl 0x10(%r15)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1abfb
movq %rbx, %rdi
callq 0x73bf
movq %r15, (%rbx)
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_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 0x1b040
leaq 0xd86f(%rip), %rcx      # 0x28898
pushq $0x1
popq %r12
movq %rbx, %rdi
movl %r12d, %esi
movq %r15, %rdx
callq 0x72a5
jmp 0x1b12c
movl %esi, %r12d
movq 0x8(%r15), %rsi
cmpl $0x2, %r12d
jne 0x1b06d
pushq $0x1
popq %r12
movq %rbx, %rdi
movl %r12d, %edx
callq 0x9378
movq %rax, %r14
testq %rax, %rax
jne 0x1b109
jmp 0x1b12c
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x9378
testq %rax, %rax
je 0x1b09d
movq %rax, %r14
cmpl $0x2, 0x10(%rax)
jl 0x1b0ba
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8a95
movq %rax, %r14
movl $0x0, -0x2c(%rbp)
jmp 0x1b0bf
leaq 0xe59d(%rip), %rsi      # 0x29641
movl $0x0, -0x2c(%rbp)
movq %rbx, %rdi
xorl %edx, %edx
callq 0x7363
movq %rax, %r14
jmp 0x1b0bf
movb $0x1, %al
movl %eax, -0x2c(%rbp)
movl %r12d, %r12d
pushq $0x2
popq %r13
cmpq %r12, %r13
jae 0x1b0df
movq (%r15,%r13,8), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa6f6
incq %r13
jmp 0x1b0c6
movq 0x8(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8306
testl %eax, %eax
je 0x1b109
pushq $0x1
popq %r12
cmpb $0x0, -0x2c(%rbp)
jne 0x1b12c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73bf
jmp 0x1b12c
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1b126
movq %rbx, %rdi
callq 0x73bf
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_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, %esi
jg 0x1b16b
leaq 0xd758(%rip), %rcx      # 0x288ac
pushq $0x1
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x72a5
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x2, %esi
jne 0x1b179
movq 0x8(%rdx), %rsi
movq %rbx, %rdi
jmp 0x1b18d
decl %esi
addq $0x8, %rdx
movq %rbx, %rdi
callq 0xdd24
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x8b54
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x2, %esi
jl 0x1b1fd
movl %esi, %r15d
movq 0x58(%rbx), %r12
movq 0x8(%r14), %rdi
callq 0x7340
movb (%rax), %al
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
setae %cl
cmpb $0x23, %al
setne %al
testb %cl, %al
jne 0x1b1e4
addq $0x8, %r14
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xc6f3
decl %r15d
jmp 0x1b1ee
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc6f3
testq %rax, %rax
je 0x1b212
cmpl $0x1, %r15d
ja 0x1b21e
addq $-0x8, %r14
leaq 0xd6b6(%rip), %rcx      # 0x288ba
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x72a5
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x58(%rbx)
cmpl $0x2, %r15d
jne 0x1b22e
movq 0x8(%r14), %rsi
jmp 0x1b246
decl %r15d
addq $0x8, %r14
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0xdd24
movq %rax, %rsi
movq %rbx, %rdi
callq 0x8b54
movq %r12, 0x58(%rbx)
jmp 0x1b215
// File: /workspace/github_c_makefile_star2_O2/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 0x1b27c
movq 0x8(%rdx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xcb7c
jle 0x1b2bd
decl %esi
addq $0x8, %rdx
movq %rbx, %rdi
callq 0xdd24
movq %rax, %r15
incl 0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xcb7c
movl %eax, %r14d
movl 0x10(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r15)
cmpl $0x1, %eax
jg 0x1b2d3
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73bf
jmp 0x1b2d3
leaq 0xd610(%rip), %rcx      # 0x288d4
pushq $0x1
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x72a5
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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 0x1b337
leaq 0xd5cd(%rip), %rcx      # 0x288ed
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x72a5
jmp 0x1b3c0
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rcx
cmpl $0x4, %eax
jne 0x1b34b
movq %rbx, %rdi
xorl %edx, %edx
jmp 0x1b358
movq 0x20(%r14), %rax
movq %rbx, %rdi
movq %rcx, %rdx
movq %rax, %rcx
callq 0x1fd78
testq %rax, %rax
je 0x1b3bc
movq 0x8(%r14), %r15
incl 0x10(%r15)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb4f5
movl 0x10(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r15)
cmpl $0x1, %eax
jg 0x1b393
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73bf
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 0x1b3b4
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %r15d, %r15d
jmp 0x1b3c0
pushq $0x1
popq %r15
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_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 %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0x2, %esi
jne 0x1b42d
movq 0x1a8(%r14), %rsi
testq %rsi, %rsi
je 0x1b40d
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1b405
movq %r14, %rdi
callq 0x73bf
andq $0x0, 0x1a8(%r14)
movq 0x8(%rbx), %rdi
callq 0xa61a
xorl %r15d, %r15d
testl %eax, %eax
je 0x1b446
movq 0x8(%rbx), %rax
movq %rax, 0x1a8(%r14)
incl 0x10(%rax)
jmp 0x1b446
leaq 0xd68e(%rip), %rcx      # 0x28ac2
pushq $0x1
popq %r15
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x72a5
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_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 0x1b6ca
movq 0x8(%rbx), %rsi
addq $0x8, %rbx
movq %r14, %rdi
callq 0xc6f3
movq %rax, %r13
decl %r15d
jmp 0x1b6d7
movq %r14, %rdi
xorl %esi, %esi
callq 0xc6f3
movq %rax, %r13
pushq $0x1
popq %r12
testq %r13, %r13
je 0x1b72e
cmpl $0x3, %r15d
jge 0x1b6fd
leaq 0xd448(%rip), %rcx      # 0x28b35
movq %r14, %rdi
movl %r12d, %esi
movq %rbx, %rdx
callq 0x72a5
jmp 0x1b72e
movl %r15d, %r15d
pushq $0x1
popq %r12
cmpq %r15, %r12
jae 0x1b72b
movq (%rbx,%r12,8), %rdx
movq 0x8(%rbx,%r12,8), %rsi
movq %r14, %rdi
movq %r13, %rcx
callq 0xba06
addq $0x2, %r12
testl %eax, %eax
je 0x1b704
pushq $0x1
popq %r12
jmp 0x1b72e
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_O2/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 0x1b772
leaq 0xd407(%rip), %rcx      # 0x28b67
pushq $0x1
popq %rbx
movq %r15, %rdi
movl %ebx, %esi
movq %r14, %rdx
callq 0x72a5
jmp 0x1b7bd
movq 0x58(%r15), %rax
xorl %ebx, %ebx
cmpl $0x0, 0x8(%rax)
je 0x1b7bd
movl %esi, %r12d
pushq $0x1
popq %r13
cmpq %r13, %r12
je 0x1b7bd
movq (%r14,%r13,8), %rdi
callq 0x7340
cmpb $0x3a, (%rax)
jne 0x1b79e
cmpb $0x3a, 0x1(%rax)
je 0x1b7b5
movq (%r14,%r13,8), %rdx
movq 0x60(%r15), %rcx
movq %r15, %rdi
movq %rdx, %rsi
callq 0xba06
testl %eax, %eax
jne 0x1b7ba
incq %r13
jmp 0x1b785
pushq $0x1
popq %rbx
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_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_TimeCoreCommand
static int Jim_TimeCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    long i, count = 1;
    jim_wide start, elapsed;

    if (argc < 2) {
        Jim_WrongNumArgs(interp, 1, argv, "script ?count?");
        return JIM_ERR;
    }
    if (argc == 3) {
        if (Jim_GetLong(interp, argv[2], &count) != JIM_OK)
            return JIM_ERR;
    }
    if (count < 0)
        return JIM_OK;
    i = count;
    start = Jim_GetTimeUsec(CLOCK_MONOTONIC_RAW);
    while (i-- > 0) {
        int retval;

        retval = Jim_EvalObj(interp, argv[1]);
        if (retval != JIM_OK) {
            return retval;
        }
    }
    elapsed = Jim_GetTimeUsec(CLOCK_MONOTONIC_RAW) - start;
    if (elapsed < count * 10) {
        Jim_SetResult(interp, Jim_NewDoubleObj(interp, elapsed * 1.0 / count));
    }
    else {
        Jim_SetResultInt(interp, count == 0 ? 0 : elapsed / count);
    }
    Jim_AppendString(interp, Jim_GetResult(interp)," microseconds per iteration", -1);
    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
movq $0x1, -0x30(%rbp)
cmpl $0x1, %esi
jg 0x1c450
leaq 0xc93f(%rip), %rcx      # 0x28d78
pushq $0x1
popq %r12
movq %rbx, %rdi
movl %r12d, %esi
movq %r14, %rdx
callq 0x72a5
jmp 0x1c542
cmpl $0x3, %esi
jne 0x1c472
movq 0x10(%r14), %rsi
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0xc8cb
testl %eax, %eax
je 0x1c4e4
pushq $0x1
popq %r12
jmp 0x1c542
pushq $0x1
popq %r13
callq 0x9e7a
movq %rax, -0x38(%rbp)
leaq 0x1(%r13), %r15
decq %r15
testq %r15, %r15
jle 0x1c4a3
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x8b54
testl %eax, %eax
je 0x1c483
movl %eax, %r12d
jmp 0x1c542
callq 0x9e7a
subq -0x38(%rbp), %rax
imulq $0xa, %r13, %rcx
cmpq %rcx, %rax
jge 0x1c4ef
cvtsi2sd %rax, %xmm0
cvtsi2sd %r13, %xmm1
divsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0xd366
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x2, %eax
jl 0x1c51f
jmp 0x1c527
movq -0x30(%rbp), %r13
testq %r13, %r13
jns 0x1c476
jmp 0x1c53f
testq %r13, %r13
je 0x1c4fe
cqto
idivq %r13
movq %rax, %rsi
jmp 0x1c500
xorl %esi, %esi
movq %rbx, %rdi
callq 0x8212
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 0x1c527
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
leaq 0xc856(%rip), %rdx      # 0x28d87
pushq $-0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x823a
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_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 %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
andq $0x0, -0x20(%rbp)
cmpl $0x3, %esi
jl 0x1c7d7
leaq 0xc61b(%rip), %rcx      # 0x28dde
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x72a5
jmp 0x1c824
xorl %eax, %eax
cmpl $0x2, %esi
jne 0x1c81d
movq 0x8(%r14), %rsi
leaq -0x20(%rbp), %rdx
movq %rbx, %rdi
callq 0xc8cb
testl %eax, %eax
je 0x1c7f6
pushq $0x1
jmp 0x1c822
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 0x1c817
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
movl -0x20(%rbp), %eax
movl %eax, 0x30(%rbx)
pushq $0x6
popq %r15
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_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 0x1cdb8
leaq 0xc283(%rip), %rcx      # 0x29027
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x72a5
jmp 0x1ce30
movl %esi, %r15d
decl %r15d
movl $0x80, %r12d
pushq $0x1
popq %r13
cmpq %r13, %r15
je 0x1ce15
movq (%r14,%r13,8), %rsi
movq %rbx, %rdi
leaq 0x15ba5(%rip), %rdx     # 0x32980
leaq -0x2c(%rbp), %rcx
xorl %r8d, %r8d
pushq $0x3
popq %r9
callq 0x7b44
testl %eax, %eax
jne 0x1ce2c
movl -0x2c(%rbp), %eax
cmpl $0x2, %eax
je 0x1ce0c
cmpl $0x1, %eax
je 0x1ce06
testl %eax, %eax
jne 0x1ce10
orl $0x4, %r12d
jmp 0x1ce10
orl $0x2, %r12d
jmp 0x1ce10
orl $0x1, %r12d
incq %r13
jmp 0x1cdc8
movq (%r14,%r15,8), %rsi
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
movl %r12d, %ecx
callq 0xfecc
testl %eax, %eax
je 0x1ce42
pushq $0x1
popq %r15
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
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 0x1ce63
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %r15d, %r15d
jmp 0x1ce30
// File: /workspace/github_c_makefile_star2_O2/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 0x1d783
cmpl $0x2, %esi
jne 0x1d7ab
movq 0x8(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x9378
xorl %r14d, %r14d
testq %rax, %rax
setne %r14b
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0x8212
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 0x1d77b
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %r15d, %r15d
jmp 0x1d7c4
movq 0x8(%r14), %rsi
leaq 0x15512(%rip), %rdx     # 0x32ca0
leaq -0x1c(%rbp), %rcx
pushq $0x3
popq %r9
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0x7b44
testl %eax, %eax
je 0x1d7d2
pushq $0x1
popq %r15
jmp 0x1d7c4
leaq 0xb9cc(%rip), %rcx      # 0x2917e
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x72a5
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl -0x1c(%rbp), %r15d
movq 0x10(%r14), %rsi
cmpl $0x3, %r15d
je 0x1d73d
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6755
testq %rax, %rax
je 0x1d751
cmpl $0x2, %r15d
je 0x1d821
cmpl $0x1, %r15d
je 0x1d818
testl %r15d, %r15d
jne 0x1d751
pushq $0x1
popq %r14
jmp 0x1d751
movl 0x4(%rax), %r14d
jmp 0x1d751
cmpl $0x0, 0x4(%rax)
jne 0x1d751
leaq 0x168b(%rip), %rcx      # 0x1eebd
xorl %r14d, %r14d
cmpq %rcx, 0x18(%rax)
sete %r14b
jmp 0x1d751
// File: /workspace/github_c_makefile_star2_O2/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 0x1da18
leaq 0xb7a1(%rip), %rcx      # 0x291a5
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x72a5
jmp 0x1da77
cmpl $0x2, %esi
jne 0x1da30
movl $0x1, -0x1c(%rbp)
leaq 0xbb39(%rip), %rdx      # 0x29564
pushq $0x1
popq %rcx
jmp 0x1da46
movq 0x10(%r14), %rdi
leaq -0x1c(%rbp), %r15
movq %r15, %rsi
callq 0x7fc7
movq %rax, %rdx
movl (%r15), %ecx
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xdc89
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 0x1da71
movq %rbx, %rdi
callq 0x73bf
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_O2/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 0x1dab2
leaq 0xb719(%rip), %rcx      # 0x291b7
pushq $0x1
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
movq %rax, %rdx
callq 0x72a5
jmp 0x1dafa
movl %esi, %edx
movq 0x8(%rax), %rsi
addl $-0x2, %edx
addq $0x10, %rax
movq %rbx, %rdi
movq %rax, %rcx
callq 0x10ca4
testq %rax, %rax
je 0x1daf6
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 0x1daee
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %r14d, %r14d
jmp 0x1dafa
pushq $0x1
popq %r14
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1e2a9
leaq 0xb101(%rip), %rcx      # 0x2939a
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x72a5
jmp 0x1e2e0
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 0x1e2cb
movq %r14, %rdi
callq 0x73bf
movq %r12, (%r14)
cmpl $0x3, %r15d
jne 0x1e2e0
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x191a6
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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 0x1e33e
movq 0x8(%rdx), %rsi
movq 0x10(%rdx), %rax
movq 0x18(%rdx), %rcx
movq %rbx, %rdi
movq %rax, %rdx
callq 0xdf87
testq %rax, %rax
je 0x1e356
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 0x1e336
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %r14d, %r14d
jmp 0x1e35a
leaq 0xb06a(%rip), %rcx      # 0x293af
pushq $0x1
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x72a5
jmp 0x1e35a
pushq $0x1
popq %r14
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %r13
cmpl $0x2, %esi
jl 0x1e3aa
movl %esi, %r15d
movq 0x8(%r14), %rsi
leaq -0x38(%rbp), %r12
movq %r13, %rdi
movq %r12, %rdx
callq 0xcace
testl %eax, %eax
setne %al
movq (%r12), %rbx
testq %rbx, %rbx
sets %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x1e3c8
leaq 0xb00e(%rip), %rcx      # 0x293bf
pushq $0x1
popq %r15
movq %r13, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x72a5
jmp 0x1e471
testq %rbx, %rbx
setne %al
cmpl $0x2, %r15d
setne %cl
testb %al, %cl
jne 0x1e403
movq 0x128(%r13), %rbx
incl 0x10(%rbx)
movq (%r13), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1e3fd
movq %r13, %rdi
callq 0x73bf
movq %rbx, (%r13)
jmp 0x1e46e
addl $-0x2, %r15d
addq $0x10, %r14
movq %r13, -0x30(%rbp)
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x745b
movq %rax, %r12
movl %ebx, %esi
imull %r15d, %esi
movq %rax, %rdi
callq 0x1706b
pushq $-0x1
popq %r13
subq $0x1, %rbx
jb 0x1e449
movq %r12, %rdi
movl %r13d, %esi
movl %r15d, %edx
movq %r14, %rcx
callq 0xd439
jmp 0x1e430
incl 0x10(%r12)
movq -0x30(%rbp), %rbx
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1e46b
movq %rbx, %rdi
callq 0x73bf
movq %r12, (%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_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_EnvCoreCommand
static int Jim_EnvCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    const char *key;
    const char *val;

    if (argc == 1) {
        char **e = Jim_GetEnviron();

        int i;
        Jim_Obj *listObjPtr = Jim_NewListObj(interp, NULL, 0);

        for (i = 0; e[i]; i++) {
            const char *equals = strchr(e[i], '=');

            if (equals) {
                Jim_ListAppendElement(interp, listObjPtr, Jim_NewStringObj(interp, e[i],
                        equals - e[i]));
                Jim_ListAppendElement(interp, listObjPtr, Jim_NewStringObj(interp, equals + 1, -1));
            }
        }

        Jim_SetResult(interp, listObjPtr);
        return JIM_OK;
    }

    if (argc > 3) {
        Jim_WrongNumArgs(interp, 1, argv, "varName ?default?");
        return JIM_ERR;
    }
    key = Jim_String(argv[1]);
    val = getenv(key);
    if (val == NULL) {
        if (argc < 3) {
            Jim_SetResultFormatted(interp, "environment variable \"%#s\" does not exist", argv[1]);
            return JIM_ERR;
        }
        val = Jim_String(argv[2]);
    }
    Jim_SetResult(interp, Jim_NewStringObj(interp, val, -1));
    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 $0x1, %esi
jne 0x1e511
movq 0x14b18(%rip), %rax     # 0x32fb8
movq (%rax), %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x745b
movq %rax, %r14
movq (%r15), %r12
testq %r12, %r12
je 0x1e537
movq %r12, %rdi
pushq $0x3d
popq %rsi
callq 0x61c0
testq %rax, %rax
je 0x1e50b
movq %rax, %r13
movl %r13d, %edx
subl %r12d, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7363
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x74ad
incq %r13
movq %rbx, %rdi
movq %r13, %rsi
pushq $-0x1
popq %rdx
callq 0x7363
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x74ad
addq $0x8, %r15
jmp 0x1e4b2
movq %rdx, %r14
movl %esi, %r15d
cmpl $0x4, %esi
jl 0x1e53d
leaq 0xaeae(%rip), %rcx      # 0x293d1
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x72a5
jmp 0x1e595
incl 0x10(%r14)
jmp 0x1e576
movq 0x8(%r14), %rdi
callq 0x7340
movq %rax, %rdi
callq 0x6030
testq %rax, %rax
jne 0x1e562
cmpl $0x3, %r15d
jne 0x1e5a7
movq 0x10(%r14), %rdi
callq 0x7340
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7363
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1e58f
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %rdx
leaq 0xae31(%rip), %rsi      # 0x293e3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x68a7
pushq $0x1
popq %r15
jmp 0x1e595
// File: /workspace/github_c_makefile_star2_O2/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 0x1e5f1
movq 0x8(%rdx), %rdi
callq 0x7340
movq %rbx, %rdi
movq %rax, %rsi
callq 0xfd51
xorl %r14d, %r14d
cmpl $0x2, %eax
cmovnel %eax, %r14d
jmp 0x1e607
leaq 0xae15(%rip), %rcx      # 0x2940d
pushq $0x1
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x72a5
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x2, %esi
jne 0x1e691
movq 0x8(%rdx), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8b3c
movl %eax, %r15d
movq 0x18(%r14), %r12
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x745b
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
callq 0x1706b
movl %r15d, %r15d
testl %r15d, %r15d
jle 0x1e66c
movq -0x8(%r12,%r15,8), %rsi
decq %r15
movq %r14, %rdi
callq 0xd88d
jmp 0x1e655
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1e689
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %r14d, %r14d
jmp 0x1e6a7
leaq 0xa172(%rip), %rcx      # 0x2880a
pushq $0x1
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x72a5
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_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 0x1ea9a
movl %esi, %r15d
xorl %r12d, %r12d
cmpl $0x2, %esi
jl 0x1ead2
movq %rdx, %r14
movq 0x48(%rax), %r13
movq 0x8(%rdx), %rsi
pushq $0x1
popq %r12
movq %rbx, %rdi
movl %r12d, %edx
callq 0x6755
testq %rax, %rax
je 0x1ead2
incl (%rax)
addq $0x8, %r14
movq %rax, 0xa0(%r13)
decl %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x745b
movq %rax, 0x98(%r13)
incl 0x10(%rax)
pushq $0x7
jmp 0x1ead0
leaq 0xa9d4(%rip), %rsi      # 0x29475
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x7363
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1eacb
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
pushq $0x1
popq %r12
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_O2/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 0x1eb11
leaq 0xa9aa(%rip), %rcx      # 0x294a7
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x72a5
jmp 0x1eb92
incl 0xa8(%rbx)
decl %esi
addq $0x8, %rdx
movq %rbx, %rdi
callq 0xf32e
movl %eax, %r15d
decl 0xa8(%rbx)
testl %eax, %eax
jne 0x1eb92
movq (%rbx), %r14
pushq $0x1
popq %r15
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x6755
testq %rax, %rax
je 0x1eb92
movq 0x58(%rbx), %rax
movq 0x90(%rax), %rdi
testq %rdi, %rdi
jne 0x1eb83
pushq $0x10
popq %rsi
xorl %edi, %edi
callq *0x14721(%rip)          # 0x33288
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 0xa502
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_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 0x1ebcd
leaq 0xa8ea(%rip), %rcx      # 0x294a7
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x72a5
jmp 0x1ec3f
movl %esi, %r15d
movq 0x8(%r14), %rsi
addq $0x8, %r14
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x6755
testq %rax, %rax
je 0x1ec2b
movq %rax, %r12
cmpl $0x0, 0x4(%rax)
je 0x1ec2b
cmpq $0x0, 0x8(%r12)
je 0x1ec2b
incl 0x40(%r12)
incl (%r12)
decl %r15d
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0xf32e
movl %eax, %r14d
decl 0x40(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x16865
movl %r14d, %eax
jmp 0x1ec42
movq (%r14), %rdx
leaq 0xa881(%rip), %rsi      # 0x294b6
movq %rbx, %rdi
xorl %eax, %eax
callq 0x68a7
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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
andq $0x0, -0x38(%rbp)
andq $0x0, -0x30(%rbp)
cmpl $0x2, %esi
jl 0x1ee1c
movq %rdx, %r15
movl %esi, %r12d
movq 0x8(%rdx), %rsi
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0xcace
pushq $0x1
popq %r14
testl %eax, %eax
jne 0x1ee8e
cmpl $0x2, %r12d
jne 0x1eea0
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x745b
movq %rax, %r14
movl -0x38(%rbp), %r13d
movl %r13d, %r15d
negl %r15d
cmpl 0x110(%rbx), %r13d
jg 0x1ee6b
movq %rbx, %rdi
movl %r15d, %esi
callq 0x190a7
movslq 0xc(%rax), %rcx
cmpq %rcx, %r12
jg 0x1ee6b
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x190e4
incl %r13d
decl %r15d
jmp 0x1ee38
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1ee88
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%r15), %rsi
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0xcace
testl %eax, %eax
jne 0x1ee8e
movq -0x30(%rbp), %r12
jmp 0x1ee1f
// File: /workspace/github_c_makefile_star2_O2/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 0x8a95
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x8b3c
decl %r14d
addq $0x8, %rbx
movq %r15, %rdi
movq %r12, %rsi
movl %eax, %edx
movl %r14d, %ecx
movq %rbx, %r8
callq 0xd900
movq %r15, %rdi
movq %r12, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf722