LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x20933
cmpl $0x2, %esi
jne 0x2098a
movl $0x3, -0x1c(%rbp)
movl $0x8, %eax
jmp 0x20966
movq 0x8(%r14), %rsi
leaq 0x17362(%rip), %rdx     # 0x37ca0
leaq -0x1c(%rbp), %rcx
movq %rbx, %rdi
xorl %r8d, %r8d
movl $0x3, %r9d
callq 0x7e97
movl $0x1, %r15d
testl %eax, %eax
jne 0x20a3c
movl $0x10, %eax
movq (%r14,%rax), %rsi
movl -0x1c(%rbp), %r15d
cmpl $0x3, %r15d
jne 0x209ac
movq %rbx, %rdi
xorl %edx, %edx
callq 0x98ef
xorl %r14d, %r14d
testq %rax, %rax
setne %r14b
jmp 0x209f5
leaq 0xd7ff(%rip), %rcx      # 0x2e190
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7454
jmp 0x20a3c
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x67d1
testq %rax, %rax
je 0x209f5
cmpl $0x2, %r15d
je 0x209dd
cmpl $0x1, %r15d
je 0x209d7
testl %r15d, %r15d
jne 0x209f5
movl $0x1, %r14d
jmp 0x209f5
movl 0x4(%rax), %r14d
jmp 0x209f5
cmpl $0x0, 0x4(%rax)
jne 0x209f5
leaq 0x19ff(%rip), %rcx      # 0x223e9
xorl %r14d, %r14d
cmpq %rcx, 0x18(%rax)
sete %r14b
movslq %r14d, %r15
movq %rbx, %rdi
callq 0xae58
movq %rax, %r14
leaq 0x158d6(%rip), %rax     # 0x362e0
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movq %r15, 0x18(%r14)
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x20a36
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_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 0x20cd5
leaq 0xd4fa(%rip), %rcx      # 0x2e1b7
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7454
jmp 0x20d34
cmpl $0x2, %esi
jne 0x20ce8
leaq 0xd895(%rip), %rdx      # 0x2e576
movl $0x1, %ecx
jmp 0x20d03
movq 0x10(%r14), %r15
cmpq $0x0, (%r15)
jne 0x20cfc
movq 0x8(%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
movl 0x14(%r15), %ecx
movq (%r15), %rdx
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xec0a
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 0x20d2e
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_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 0x20d73
leaq 0xd46e(%rip), %rcx      # 0x2e1c9
movl $0x1, %r14d
movq %rbx, %rdi
movl $0x1, %esi
movq %rax, %rdx
callq 0x7454
jmp 0x20dbd
movl %esi, %edx
movq 0x8(%rax), %rsi
addl $-0x2, %edx
addq $0x10, %rax
movq %rbx, %rdi
movq %rax, %rcx
callq 0x12160
testq %rax, %rax
je 0x20db7
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 0x20daf
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %r14d, %r14d
jmp 0x20dbd
movl $0x1, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x21614
leaq 0xcdaa(%rip), %rcx      # 0x2e3ac
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x7454
jmp 0x2164b
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 0x21636
movq %r14, %rdi
callq 0x759a
movq %r12, (%r14)
cmpl $0x3, %r15d
jne 0x2164b
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x1be8f
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_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 0x216ab
movq 0x8(%rdx), %rsi
movq 0x10(%rdx), %rax
movq 0x18(%rdx), %rcx
movq %rbx, %rdi
movq %rax, %rdx
callq 0xef0c
testq %rax, %rax
je 0x216c7
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 0x216a3
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %r14d, %r14d
jmp 0x216cd
leaq 0xcd0f(%rip), %rcx      # 0x2e3c1
movl $0x1, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7454
jmp 0x216cd
movl $0x1, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2171a
movl %esi, %r15d
movq 0x8(%r14), %rsi
leaq -0x30(%rbp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0xd80a
testl %eax, %eax
setne %al
movq (%r12), %r13
testq %r13, %r13
sets %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x2173c
leaq 0xccb0(%rip), %rcx      # 0x2e3d1
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7454
jmp 0x2180c
testq %r13, %r13
setne %al
cmpl $0x2, %r15d
setne %cl
testb %al, %cl
jne 0x21779
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 0x21771
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
jmp 0x21809
addl $-0x2, %r15d
movq %rbx, %rdi
callq 0xae58
movq %rax, %r12
leaq 0x14bc9(%rip), %rax     # 0x36358
movq %rax, 0x8(%r12)
movq $0x0, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r12)
imull %r15d, %r13d
movq %r12, %rdi
movl %r13d, %esi
callq 0x19865
movq -0x30(%rbp), %r13
movq %r13, %rax
subq $0x1, %rax
jb 0x217e4
addq $0x10, %r14
movq %r12, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl %r15d, %edx
movq %r14, %rcx
callq 0xe29d
decq %r13
jne 0x217c5
movq $-0x1, %rax
movq %rax, -0x30(%rbp)
incl 0x10(%r12)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x21806
movq %rbx, %rdi
callq 0x759a
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_O1/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 0x219e8
movq 0x8(%rdx), %r14
cmpq $0x0, (%r14)
jne 0x219d1
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x110aa
xorl %r14d, %r14d
cmpl $0x2, %eax
cmovnel %eax, %r14d
jmp 0x21a02
leaq 0xca30(%rip), %rcx      # 0x2e41f
movl $0x1, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7454
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x21ac3
movq 0x8(%rdx), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe338
movslq 0x20(%r14), %r15
movq 0x18(%r14), %r13
movq %rbx, %rdi
callq 0xae58
movq %rax, %r14
leaq 0x1490b(%rip), %rax     # 0x36358
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movq %r14, %rdi
movl %r15d, %esi
callq 0x19865
testq %r15, %r15
jle 0x21a9e
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 0xe29d
decq %r15
cmpq $0x1, %r15
jg 0x21a77
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x21abb
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %r14d, %r14d
jmp 0x21add
leaq 0xbd4e(%rip), %rcx      # 0x2d818
movl $0x1, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7454
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_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 0x21f59
movl %esi, %r15d
xorl %r12d, %r12d
cmpl $0x2, %esi
jl 0x21f95
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 0x21f95
incl (%rax)
addq $0x8, %r14
movq %rax, 0xa0(%r13)
decl %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x7640
movq %rax, 0x98(%r13)
incl 0x10(%rax)
movl $0x7, %r12d
jmp 0x21f95
leaq 0xc527(%rip), %rsi      # 0x2e487
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x21f8c
movq %rbx, %rdi
callq 0x759a
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_O1/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 %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, %esi
jg 0x21fd9
leaq 0xc4f8(%rip), %rcx      # 0x2e4b9
movl $0x1, %r12d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7454
jmp 0x2205e
incl 0xa8(%rbx)
decl %esi
addq $0x8, %rdx
movq %rbx, %rdi
callq 0x10562
movl %eax, %r14d
decl 0xa8(%rbx)
testl %eax, %eax
jne 0x2205b
movq (%rbx), %r15
movl $0x1, %r12d
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x67d1
testq %rax, %rax
je 0x2205e
movq 0x58(%rbx), %rax
cmpq $0x0, 0x90(%rax)
jne 0x22044
movl $0x10, %esi
xorl %edi, %edi
callq *0x16255(%rip)          # 0x38288
movq 0x58(%rbx), %rcx
movq %rax, 0x90(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
incl 0x10(%r15)
movq 0x58(%rbx), %rax
movq 0x90(%rax), %rdi
movq %r15, %rsi
callq 0xad96
movl %r14d, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_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 0x22099
leaq 0xc432(%rip), %rcx      # 0x2e4b9
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7454
jmp 0x2210d
movl %esi, %r15d
movq 0x8(%r14), %rsi
addq $0x8, %r14
movq %rbx, %rdi
movl $0x1, %edx
callq 0x67d1
testq %rax, %rax
je 0x220f9
movq %rax, %r12
cmpl $0x0, 0x4(%rax)
je 0x220f9
cmpq $0x0, 0x8(%r12)
je 0x220f9
incl 0x40(%r12)
incl (%r12)
decl %r15d
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x10562
movl %eax, %r14d
decl 0x40(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x18e6b
movl %r14d, %eax
jmp 0x22112
movq (%r14), %rdx
leaq 0xc3c5(%rip), %rsi      # 0x2e4c8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x692d
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_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 %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, -0x38(%rbp)
movq %rax, -0x30(%rbp)
cmpl $0x2, %esi
jl 0x22325
movq 0x8(%r14), %rsi
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0xd80a
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x223da
cmpl $0x3, %r15d
jl 0x2234a
movq 0x10(%r14), %rsi
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0xd80a
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x223da
movq %rbx, %rdi
callq 0xae58
movq %rax, %r14
leaq 0x13ffc(%rip), %rax     # 0x36358
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movl -0x38(%rbp), %r15d
cmpl %r15d, 0x110(%rbx)
jl 0x223b8
movq -0x30(%rbp), %r12
leal -0x1(%r15), %r13d
negl %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1bd78
movslq 0xc(%rax), %rcx
cmpq %rcx, %r12
jg 0x223b8
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x1bdb5
incl %r13d
decl %r15d
cmpl 0x110(%rbx), %r13d
jl 0x22387
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x223d5
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8fa8
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0xe338
movl 0x20(%r12), %edx
decl %r14d
addq $0x8, %rbx
movq %r15, %rdi
movq %r12, %rsi
movl %r14d, %ecx
movq %rbx, %r8
callq 0xe7f2
movq %r15, %rdi
movq %r12, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x109ce
// File: /workspace/github_c_makefile_star2_O1/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 $0x38, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, -0x38(%rbp)
xorl %r15d, %r15d
cmpl $0x18, %ecx
setne %r15b
cmpl $0x2, %esi
jl 0x224eb
movl %ecx, %r14d
movl %esi, -0x3c(%rbp)
movl %esi, %eax
movq %rax, -0x48(%rbp)
movl $0x1, %ebx
movq -0x50(%rbp), %rax
movq (%rax,%rbx,8), %r13
leaq 0x13e37(%rip), %rax     # 0x362e0
cmpq %rax, 0x8(%r13)
je 0x224c8
movq -0x38(%rbp), %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0xd6d7
testl %eax, %eax
je 0x224c8
xorl %eax, %eax
jmp 0x224ce
movq 0x18(%r13), %r12
movb $0x1, %al
testb %al, %al
je 0x22543
leaq (%r12,%r15), %rax
imulq %r12, %r15
cmpl $0x18, %r14d
cmoveq %rax, %r15
incq %rbx
cmpq %rbx, -0x48(%rbp)
jne 0x2249a
movq -0x38(%rbp), %r12
movq %r12, %rdi
callq 0xae58
movq %rax, %r14
leaq 0x13ddf(%rip), %rax     # 0x362e0
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movq %r15, 0x18(%r14)
incl 0x10(%r14)
movq (%r12), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x2, %eax
jge 0x2252e
movq %r12, %rdi
callq 0x759a
movq %r14, (%r12)
xorl %eax, %eax
addq $0x38, %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 0x225a0
leaq -0x58(%rbp), %r13
movq -0x38(%rbp), %r12
movq -0x50(%rbp), %rax
movq (%rax,%rbx,8), %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0xe057
testl %eax, %eax
jne 0x225eb
movsd -0x58(%rbp), %xmm0
cmpl $0x18, %r14d
jne 0x22587
movsd -0x30(%rbp), %xmm1
addsd %xmm0, %xmm1
jmp 0x22590
movsd -0x30(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, -0x30(%rbp)
incq %rbx
cmpq %rbx, -0x48(%rbp)
jne 0x2255a
jmp 0x225a4
movq -0x38(%rbp), %r12
movq %r12, %rdi
callq 0xae58
movq %rax, %r14
leaq 0x13d7a(%rip), %rax     # 0x36330
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x18(%r14)
incl 0x10(%r14)
movq (%r12), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jle 0x22526
jmp 0x2252e
movl $0x1, %eax
jmp 0x22534
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: ListSortInteger
static int ListSortInteger(Jim_Obj **lhsObj, Jim_Obj **rhsObj)
{
    jim_wide lhs = 0, rhs = 0;

    if (Jim_GetWide(sort_info->interp, *lhsObj, &lhs) != JIM_OK ||
        Jim_GetWide(sort_info->interp, *rhsObj, &rhs) != JIM_OK) {
        longjmp(sort_info->jmpbuf, JIM_ERR);
    }

    return JimSign(lhs - rhs) * sort_info->order;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %r14
leaq 0x13146(%rip), %r15     # 0x362e0
cmpq %r15, 0x8(%r14)
je 0x231c6
movq 0x15101(%rip), %rax     # 0x382a8
movq 0xd0(%rax), %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0xd6d7
testl %eax, %eax
je 0x231c6
xorl %r14d, %r14d
xorl %eax, %eax
jmp 0x231cc
movq 0x18(%r14), %r14
movb $0x1, %al
testb %al, %al
je 0x23232
movq (%rbx), %rbx
cmpq %r15, 0x8(%rbx)
je 0x231fe
movq 0x150c8(%rip), %rax     # 0x382a8
movq 0xd0(%rax), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0xd6d7
testl %eax, %eax
je 0x231fe
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x23204
movq 0x18(%rbx), %rax
movb $0x1, %cl
testb %cl, %cl
je 0x23232
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %rax, %r14
setge %dl
leal -0x1(%rdx,%rdx), %eax
cmovel %ecx, %eax
movq 0x15088(%rip), %rcx     # 0x382a8
imull 0xdc(%rcx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x1506f(%rip), %rdi     # 0x382a8
movl $0x1, %esi
callq 0x63c0
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: ListSortReal
static int ListSortReal(Jim_Obj **lhsObj, Jim_Obj **rhsObj)
{
    double lhs = 0, rhs = 0;

    if (Jim_GetDouble(sort_info->interp, *lhsObj, &lhs) != JIM_OK ||
        Jim_GetDouble(sort_info->interp, *rhsObj, &rhs) != JIM_OK) {
        longjmp(sort_info->jmpbuf, JIM_ERR);
    }
    if (lhs == rhs) {
        return 0;
    }
    if (lhs > rhs) {
        return sort_info->order;
    }
    return -sort_info->order;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
xorl %eax, %eax
leaq -0x18(%rbp), %rdx
movq %rax, (%rdx)
movq %rax, -0x10(%rbp)
movq 0x15045(%rip), %rax     # 0x382a8
movq 0xd0(%rax), %rax
movq (%rdi), %rsi
movq %rax, %rdi
callq 0xe057
testl %eax, %eax
jne 0x232bf
movq 0x15028(%rip), %rax     # 0x382a8
movq 0xd0(%rax), %rdi
movq (%rbx), %rsi
leaq -0x10(%rbp), %rdx
callq 0xe057
testl %eax, %eax
jne 0x232bf
movsd -0x18(%rbp), %xmm0
xorl %eax, %eax
ucomisd -0x10(%rbp), %xmm0
jne 0x232a7
jnp 0x232b8
movq 0x14ffa(%rip), %rax     # 0x382a8
movl 0xdc(%rax), %eax
ja 0x232b8
negl %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq 0x14fe2(%rip), %rdi     # 0x382a8
movl $0x1, %esi
callq 0x63c0
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: ListSortCommand
static int ListSortCommand(Jim_Obj **lhsObj, Jim_Obj **rhsObj)
{
    Jim_Obj *compare_script;
    int rc;

    jim_wide ret = 0;


    compare_script = Jim_DuplicateObj(sort_info->interp, sort_info->command);
    Jim_ListAppendElement(sort_info->interp, compare_script, *lhsObj);
    Jim_ListAppendElement(sort_info->interp, compare_script, *rhsObj);

    rc = Jim_EvalObj(sort_info->interp, compare_script);

    if (rc != JIM_OK || Jim_GetWide(sort_info->interp, Jim_GetResult(sort_info->interp), &ret) != JIM_OK) {
        longjmp(sort_info->jmpbuf, rc);
    }

    return JimSign(ret) * sort_info->order;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x14fc1(%rip), %rax     # 0x382a8
movq 0xc8(%rax), %rsi
movq 0xd0(%rax), %rdi
callq 0x8fa8
movq %rax, %r15
movq 0x14fa4(%rip), %rax     # 0x382a8
movq 0xd0(%rax), %rdi
movq (%r14), %rdx
movq %r15, %rsi
callq 0x7695
movq 0x14f8b(%rip), %rax     # 0x382a8
movq 0xd0(%rax), %rdi
movq (%rbx), %rdx
movq %r15, %rsi
callq 0x7695
movq 0x14f72(%rip), %rax     # 0x382a8
movq 0xd0(%rax), %rdi
movq %r15, %rsi
callq 0x9078
movl %eax, %ebx
testl %eax, %eax
jne 0x233b5
movq 0x14f56(%rip), %rax     # 0x382a8
movq 0xd0(%rax), %rdi
movq (%rdi), %r14
leaq 0x12f7d(%rip), %rax     # 0x362e0
cmpq %rax, 0x8(%r14)
je 0x23380
movq %r14, %rsi
movl $0x1, %edx
callq 0xd6d7
testl %eax, %eax
je 0x23380
xorl %ecx, %ecx
xorl %eax, %eax
jmp 0x23386
movq 0x18(%r14), %rcx
movb $0x1, %al
testb %al, %al
je 0x233b5
movq %rcx, %rdx
sarq $0x3f, %rdx
orl $0x1, %edx
xorl %eax, %eax
testq %rcx, %rcx
cmovnel %edx, %eax
movq 0x14f05(%rip), %rcx     # 0x382a8
imull 0xdc(%rcx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x14eec(%rip), %rdi     # 0x382a8
movl %ebx, %esi
callq 0x63c0
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: ListSortDict
static int ListSortDict(Jim_Obj **lhsObj, Jim_Obj **rhsObj)
{

    const char *left = Jim_String(*lhsObj);
    const char *right = Jim_String(*rhsObj);

    while (1) {
        if (isdigit(UCHAR(*left)) && isdigit(UCHAR(*right))) {

            jim_wide lint, rint;
            char *lend, *rend;
            lint = jim_strtoull(left, &lend);
            rint = jim_strtoull(right, &rend);
            if (lint != rint) {
                return JimSign(lint - rint) * sort_info->order;
            }
            if (lend -left != rend - right) {
                return JimSign((lend - left) - (rend - right)) * sort_info->order;
            }
            left = lend;
            right = rend;
        }
        else {
            int cl, cr;
            left += utf8_tounicode_case(left, &cl, 1);
            right += utf8_tounicode_case(right, &cr, 1);
            if (cl != cr) {
                return JimSign(cl - cr) * sort_info->order;
            }
            if (cl == 0) {

                return Jim_StringCompareObj(sort_info->interp, *lhsObj, *rhsObj, 0) * sort_info->order;
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
movq (%rdi), %rbx
cmpq $0x0, (%rbx)
jne 0x233ee
movq 0x8(%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq (%rbx), %r15
movq %r14, -0x38(%rbp)
movq (%r14), %rbx
cmpq $0x0, (%rbx)
jne 0x23408
movq 0x8(%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq (%rbx), %r13
callq 0x64e0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movzbl (%r15), %edi
testb $0x8, 0x1(%rax,%rdi,2)
je 0x23432
movzbl (%r13), %ecx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x234a6
callq 0x60e0
movl %eax, %r14d
movzbl (%r13), %edi
callq 0x60e0
cmpl %eax, %r14d
jne 0x2347b
movb $0x1, %r12b
testl %r14d, %r14d
jne 0x23495
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq -0x38(%rbp), %rax
movq (%rax), %rdx
xorl %r12d, %r12d
xorl %ecx, %ecx
callq 0xb302
movl %eax, %ebx
movq 0x14e36(%rip), %rax     # 0x382a8
imull 0xdc(%rax), %ebx
jmp 0x23495
movq 0x14e26(%rip), %rcx     # 0x382a8
movl 0xdc(%rcx), %ecx
movl %ecx, %ebx
negl %ebx
cmpl %eax, %r14d
cmovgel %ecx, %ebx
xorl %r12d, %r12d
incq %r15
incq %r13
testb %r12b, %r12b
jne 0x23414
jmp 0x23510
movq %r15, %rdi
leaq -0x50(%rbp), %rsi
callq 0xd4a4
movq %rax, %r14
movq %r13, %rdi
leaq -0x48(%rbp), %rsi
callq 0xd4a4
cmpq %rax, %r14
jne 0x234e1
movq -0x50(%rbp), %rax
movq %rax, %rsi
subq %r15, %rsi
movq -0x48(%rbp), %rdx
movq %rdx, %rdi
subq %r13, %rdi
movb $0x1, %cl
cmpq %rdi, %rsi
je 0x23502
setl %al
movq 0x14dbd(%rip), %rcx     # 0x382a8
movl 0xdc(%rcx), %ecx
movl %ecx, %ebx
negl %ebx
testb %al, %al
cmovel %ecx, %ebx
xorl %ecx, %ecx
movq %r13, %rdx
movq %r15, %rax
movq %rdx, %r13
movq %rax, %r15
testb %cl, %cl
jne 0x23414
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: ListSortIndexHelper
static int ListSortIndexHelper(Jim_Obj **lhsObj, Jim_Obj **rhsObj)
{
    Jim_Obj *lObj, *rObj;

    if (Jim_ListIndices(sort_info->interp, *lhsObj, sort_info->indexv, sort_info->indexc, &lObj, JIM_ERRMSG) != JIM_OK ||
        Jim_ListIndices(sort_info->interp, *rhsObj, sort_info->indexv, sort_info->indexc, &rObj, JIM_ERRMSG) != JIM_OK) {
        longjmp(sort_info->jmpbuf, JIM_ERR);
    }
    return sort_info->subfn(&lObj, &rObj);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq 0x14d74(%rip), %rax     # 0x382a8
movq (%rdi), %rsi
movq 0xd0(%rax), %rdi
movq 0xe0(%rax), %rdx
movl 0xe8(%rax), %ecx
leaq -0x18(%rbp), %r8
movl $0x1, %r9d
callq 0x22e05
testl %eax, %eax
jne 0x235ab
movq 0x14d43(%rip), %rax     # 0x382a8
movq (%rbx), %rsi
movq 0xd0(%rax), %rdi
movq 0xe0(%rax), %rdx
movl 0xe8(%rax), %ecx
leaq -0x10(%rbp), %r8
movl $0x1, %r9d
callq 0x22e05
testl %eax, %eax
jne 0x235ab
movq 0x14d12(%rip), %rax     # 0x382a8
leaq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq *0xf0(%rax)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq 0x14cf6(%rip), %rdi     # 0x382a8
movl $0x1, %esi
callq 0x63c0
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimBreakContinueHelper
static int JimBreakContinueHelper(Jim_Interp *interp, int argc, Jim_Obj *const *argv, int retcode)
{
    if (argc != 1 && argc != 2) {
        Jim_WrongNumArgs(interp, 1, argv, "?level?");
        return JIM_ERR;
    }
    if (argc == 2) {
        long level;
        int ret = Jim_GetLong(interp, argv[1], &level);
        if (ret != JIM_OK) {
            return ret;
        }
        interp->break_level = level;
    }
    return retcode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
leal -0x3(%rsi), %eax
cmpl $-0x3, %eax
ja 0x235ee
leaq 0xa31a(%rip), %rcx      # 0x2d8f3
movl $0x1, %r15d
movq %r14, %rdi
movl $0x1, %esi
callq 0x7454
jmp 0x2363a
movl %ecx, %ebx
cmpl $0x2, %esi
jne 0x23637
movq 0x8(%rdx), %r12
leaq 0x12ce0(%rip), %rax     # 0x362e0
cmpq %rax, 0x8(%r12)
je 0x23625
movl $0x1, %r15d
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0xd6d7
testl %eax, %eax
je 0x23625
movb $0x1, %cl
jmp 0x2362f
movl 0x18(%r12), %eax
xorl %ecx, %ecx
xorl %r15d, %r15d
testb %cl, %cl
jne 0x2363a
movl %eax, 0x18(%r14)
movl %ebx, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimStringFirst
static int JimStringFirst(const char *s1, int l1, const char *s2, int l2, int idx)
{
    int i;
    int l1bytelen;

    if (!l1 || !l2 || l1 > l2) {
        return -1;
    }
    if (idx < 0)
        idx = 0;
    s2 += utf8_index(s2, idx);

    l1bytelen = utf8_index(s1, l1);

    for (i = idx; i <= l2 - l1; i++) {
        int c;
        if (memcmp(s2, s1, l1bytelen) == 0) {
            return i;
        }
        s2 += utf8_tounicode(s2, &c);
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, -0x30(%rbp)
movl %ecx, %r13d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
subl %esi, %r13d
jl 0x23d95
testl %esi, %esi
je 0x23d95
testl %ecx, %ecx
je 0x23d95
xorl %ecx, %ecx
testl %r8d, %r8d
cmovgl %r8d, %ecx
cmpl %r13d, %ecx
jg 0x23d95
movq %rdi, %r15
movslq %esi, %r12
movl %ecx, %ebx
incl %r13d
movl %ecx, %r14d
movq -0x30(%rbp), %rax
leaq (%rax,%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x6390
movl %ebx, %ecx
testl %eax, %eax
cmovnel %r14d, %ecx
je 0x23d93
incq %rbx
cmpl %ebx, %r13d
jne 0x23d64
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x23d95
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimStringLast
static int JimStringLast(const char *s1, int l1, const char *s2, int l2)
{
    const char *p;

    if (!l1 || !l2 || l1 > l2)
        return -1;


    for (p = s2 + l2 - 1; p != s2 - 1; p--) {
        if (*p == *s1 && memcmp(s1, p, l1) == 0) {
            return p - s2;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, -0x38(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %esi
jg 0x23e1b
testl %esi, %esi
je 0x23e1b
testl %ecx, %ecx
je 0x23e1b
movl %ecx, -0x2c(%rbp)
movslq %ecx, %r14
movq -0x38(%rbp), %rax
movb (%rax), %r15b
movslq %esi, %r12
leaq (%r14,%rdx), %r13
decq %r13
negq %r14
xorl %ebx, %ebx
cmpb %r15b, (%r13)
jne 0x23dff
movq -0x38(%rbp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x6390
testl %eax, %eax
je 0x23e14
incq %rbx
decq %r13
movq %r14, %rax
addq %rbx, %rax
jne 0x23de6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x23e1b
notl %ebx
addl -0x2c(%rbp), %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimStringTrim
static Jim_Obj *JimStringTrim(Jim_Interp *interp, Jim_Obj *strObjPtr, Jim_Obj *trimcharsObjPtr)
{

    Jim_Obj *objPtr = JimStringTrimLeft(interp, strObjPtr, trimcharsObjPtr);


    strObjPtr = JimStringTrimRight(interp, objPtr, trimcharsObjPtr);


    if (objPtr != strObjPtr && objPtr->refCount == 0) {

        Jim_FreeNewObj(interp, objPtr);
    }

    return strObjPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
callq 0x23e78
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x23f5b
movq %rax, %r15
cmpq %rax, %r14
je 0x23e6a
cmpl $0x0, 0x10(%r14)
jne 0x23e6a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x759a
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimStringTrimLeft
static Jim_Obj *JimStringTrimLeft(Jim_Interp *interp, Jim_Obj *strObjPtr, Jim_Obj *trimcharsObjPtr)
{
    int len;
    const char *str = Jim_GetString(strObjPtr, &len);
    const char *trimchars = default_trim_chars;
    int trimcharslen = default_trim_chars_len;
    const char *newstr;

    if (trimcharsObjPtr) {
        trimchars = Jim_GetString(trimcharsObjPtr, &trimcharslen);
    }

    newstr = JimFindTrimLeft(str, len, trimchars, trimcharslen);
    if (newstr == str) {
        return strObjPtr;
    }

    return Jim_NewStringObj(interp, newstr, len - (newstr - str));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, -0x40(%rbp)
cmpq $0x0, (%rsi)
jne 0x23ea3
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movl 0x14(%r14), %eax
movq %r14, -0x30(%rbp)
movq (%r14), %r15
testq %rbx, %rbx
je 0x23ed2
cmpq $0x0, (%rbx)
jne 0x23ec9
movq %rax, %r14
movq 0x8(%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %r14, %rax
movslq 0x14(%rbx), %r13
movq (%rbx), %rbx
jmp 0x23edf
leaq 0x48d7(%rip), %rbx      # 0x287b0
movl $0x5, %r13d
leaq (%r15,%rax), %rcx
movq %rcx, -0x38(%rbp)
leaq -0x1(%r15), %r12
movq %rax, -0x48(%rbp)
movl %eax, %r14d
subl $0x1, %r14d
jb 0x23f1e
movzbl 0x1(%r12), %esi
incq %r12
movq %rbx, %rdi
movq %r13, %rdx
callq 0x6290
testq %rax, %rax
jne 0x23ef2
cmpq $0x1, %rax
sbbq $-0x1, %r12
movq %r12, %rsi
jmp 0x23f22
movq -0x38(%rbp), %rsi
cmpq %r15, %rsi
movq -0x48(%rbp), %rdx
je 0x23f48
subl %esi, %r15d
addl %r15d, %edx
movq -0x40(%rbp), %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7516
movq -0x30(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimStringTrimRight
static Jim_Obj *JimStringTrimRight(Jim_Interp *interp, Jim_Obj *strObjPtr, Jim_Obj *trimcharsObjPtr)
{
    int len;
    const char *trimchars = default_trim_chars;
    int trimcharslen = default_trim_chars_len;
    const char *nontrim;

    if (trimcharsObjPtr) {
        trimchars = Jim_GetString(trimcharsObjPtr, &trimcharslen);
    }

    SetStringFromAny(interp, strObjPtr);

    len = Jim_Length(strObjPtr);
    nontrim = JimFindTrimRight(strObjPtr->bytes, len, trimchars, trimcharslen);

    if (nontrim == NULL) {

        return Jim_NewEmptyStringObj(interp);
    }
    if (nontrim == strObjPtr->bytes + len) {

        return strObjPtr;
    }

    if (Jim_IsShared(strObjPtr)) {
        strObjPtr = Jim_NewStringObj(interp, strObjPtr->bytes, (nontrim - strObjPtr->bytes));
    }
    else {

        strObjPtr->bytes[nontrim - strObjPtr->bytes] = 0;
        strObjPtr->length = (nontrim - strObjPtr->bytes);
    }

    return strObjPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x23f9a
movq %rdx, %r12
cmpq $0x0, (%rdx)
jne 0x23f8b
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
movslq 0x14(%r12), %rax
movq %rax, -0x40(%rbp)
movq (%r12), %r12
jmp 0x23faa
leaq 0x480f(%rip), %r12      # 0x287b0
movl $0x5, %eax
movq %rax, -0x40(%rbp)
movq %r14, -0x30(%rbp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xaf4e
cmpq $0x0, (%rbx)
jne 0x23fc9
movq 0x8(%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movslq 0x14(%rbx), %r13
movq %rbx, -0x38(%rbp)
movq (%rbx), %rax
movq %r13, %rbx
movq %rax, -0x48(%rbp)
addq %rax, %rbx
movq %rbx, -0x50(%rbp)
subl $0x1, %r13d
jb 0x2400a
leaq -0x1(%rbx), %r15
movzbl -0x1(%rbx), %esi
movq %r12, %rdi
movq -0x40(%rbp), %rdx
callq 0x6290
testq %rax, %rax
cmoveq %rbx, %r14
movq %r15, %rbx
jne 0x23fe2
jmp 0x2400d
xorl %r14d, %r14d
testq %r14, %r14
je 0x24043
cmpq -0x50(%rbp), %r14
je 0x24067
movq %r14, %rdx
movq -0x48(%rbp), %rsi
subq %rsi, %rdx
movq -0x38(%rbp), %rax
cmpl $0x2, 0x10(%rax)
jl 0x2406d
movq -0x30(%rbp), %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7516
movq -0x30(%rbp), %rdi
callq 0xae58
leaq 0x14245(%rip), %rcx     # 0x38298
movq %rcx, (%rax)
movl $0x0, 0x14(%rax)
movq $0x0, 0x8(%rax)
jmp 0x24078
movq -0x38(%rbp), %rax
jmp 0x24078
movb $0x0, (%rsi,%rdx)
subl (%rax), %r14d
movl %r14d, 0x14(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimStringToLower
static Jim_Obj *JimStringToLower(Jim_Interp *interp, Jim_Obj *strObjPtr)
{
    char *buf;
    int len;
    const char *str;

    str = Jim_GetString(strObjPtr, &len);

#ifdef JIM_UTF8
    len *= 2;
#endif
    buf = Jim_Alloc(len + 1);
    JimStrCopyUpperLower(buf, str, 0);
    return Jim_NewStringObjNoAlloc(interp, buf, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, (%rsi)
jne 0x240a8
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movslq 0x14(%r14), %rsi
movq (%r14), %r15
incq %rsi
xorl %edi, %edi
callq *0x141ce(%rip)          # 0x38288
movq %rax, %r14
movb (%r15), %al
movq %r14, %r12
testb %al, %al
je 0x240e6
incq %r15
movq %r14, %r12
movzbl %al, %edi
callq 0x6350
movb %al, (%r12)
incq %r12
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x240cd
movb $0x0, (%r12)
movq %rbx, %rdi
callq 0xae58
movq %rax, %rbx
movq %r14, (%rax)
movq %r14, %rdi
callq 0x6180
movl %eax, 0x14(%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimStringToUpper
static Jim_Obj *JimStringToUpper(Jim_Interp *interp, Jim_Obj *strObjPtr)
{
    char *buf;
    const char *str;
    int len;

    str = Jim_GetString(strObjPtr, &len);

#ifdef JIM_UTF8
    len *= 2;
#endif
    buf = Jim_Alloc(len + 1);
    JimStrCopyUpperLower(buf, str, 1);
    return Jim_NewStringObjNoAlloc(interp, buf, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, (%rsi)
jne 0x24139
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movslq 0x14(%r14), %rsi
movq (%r14), %r15
incq %rsi
xorl %edi, %edi
callq *0x1413d(%rip)          # 0x38288
movq %rax, %r14
movb (%r15), %al
movq %r14, %r12
testb %al, %al
je 0x24177
incq %r15
movq %r14, %r12
movzbl %al, %edi
callq 0x60e0
movb %al, (%r12)
incq %r12
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x2415e
movb $0x0, (%r12)
movq %rbx, %rdi
callq 0xae58
movq %rax, %rbx
movq %r14, (%rax)
movq %r14, %rdi
callq 0x6180
movl %eax, 0x14(%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimStringToTitle
static Jim_Obj *JimStringToTitle(Jim_Interp *interp, Jim_Obj *strObjPtr)
{
    char *buf, *p;
    int len;
    int c;
    const char *str;

    str = Jim_GetString(strObjPtr, &len);

#ifdef JIM_UTF8
    len *= 2;
#endif
    buf = p = Jim_Alloc(len + 1);

    str += utf8_tounicode(str, &c);
    p += utf8_getchars(p, utf8_title(c));

    JimStrCopyUpperLower(p, str, 0);

    return Jim_NewStringObjNoAlloc(interp, buf, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, (%rsi)
jne 0x241ca
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movslq 0x14(%r14), %rsi
movq (%r14), %r15
incq %rsi
xorl %edi, %edi
callq *0x140ac(%rip)          # 0x38288
movq %rax, %r14
movzbl (%r15), %edi
callq 0x60e0
movb %al, (%r14)
movq %r14, %r12
incq %r12
movb 0x1(%r15), %al
testb %al, %al
je 0x24216
addq $0x2, %r15
movzbl %al, %edi
callq 0x6350
movb %al, (%r12)
incq %r12
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x241fd
movb $0x0, (%r12)
movq %rbx, %rdi
callq 0xae58
movq %rax, %rbx
movq %r14, (%rax)
movq %r14, %rdi
callq 0x6180
movl %eax, 0x14(%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimInfoLevel
static int JimInfoLevel(Jim_Interp *interp, Jim_Obj *levelObjPtr, Jim_Obj **objPtrPtr)
{
    long level;

    if (Jim_GetLong(interp, levelObjPtr, &level) == JIM_OK) {
        Jim_CallFrame *targetCallFrame = JimGetCallFrameByInteger(interp, level);
        if (targetCallFrame && targetCallFrame != interp->topFramePtr) {
#ifdef JIM_NO_INTROSPECTION

            *objPtrPtr = Jim_NewListObj(interp, targetCallFrame->argv, 1);
#else
            *objPtrPtr = Jim_NewListObj(interp, targetCallFrame->argv, targetCallFrame->argc);
#endif
            return JIM_OK;
        }
    }
    Jim_SetResultFormatted(interp, "bad level \"%#s\"", levelObjPtr);
    return JIM_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x11320(%rip), %rax     # 0x362e0
cmpq %rax, 0x8(%rsi)
je 0x24fde
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0xd6d7
testl %eax, %eax
je 0x24fde
xorl %ecx, %ecx
jmp 0x24fe4
movq 0x18(%r15), %rax
movb $0x1, %cl
testb %cl, %cl
je 0x25040
testq %rax, %rax
je 0x2501b
jns 0x24ffa
movq 0x58(%r14), %rcx
movslq 0x8(%rcx), %rcx
addq %rcx, %rax
testq %rax, %rax
jle 0x25017
movq 0x58(%r14), %rcx
testq %rcx, %rcx
je 0x25017
movslq 0x8(%rcx), %rdx
cmpq %rdx, %rax
je 0x2501f
movq 0x48(%rcx), %rcx
jmp 0x25003
xorl %ecx, %ecx
jmp 0x2501f
movq 0x58(%r14), %rcx
testq %rcx, %rcx
je 0x25040
cmpq 0x60(%r14), %rcx
je 0x25040
movq 0x50(%rcx), %rsi
movl 0x58(%rcx), %edx
movq %r14, %rdi
callq 0x7640
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x25059
leaq 0x8aaf(%rip), %rsi      # 0x2daf6
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x692d
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq