LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: DupDictInternalRep
static void DupDictInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
{
    Jim_Dict *oldDict = srcPtr->internalRep.dictValue;
    int i;


    Jim_Dict *newDict = JimDictNew(interp, oldDict->maxLen, oldDict->size);


    for (i = 0; i < oldDict->len; i++) {
        newDict->table[i] = oldDict->table[i];
        Jim_IncrRefCount(newDict->table[i]);
    }
    newDict->len = oldDict->len;


    newDict->uniq = oldDict->uniq;


    memcpy(newDict->ht, oldDict->ht, sizeof(*oldDict->ht) * oldDict->size);

    dupPtr->internalRep.dictValue = newDict;
    dupPtr->typePtr = &dictObjType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x18(%rsi), %r15
movl 0x8(%r15), %esi
movl 0x24(%r15), %edi
callq 0xf459
movq %rax, %r14
movslq 0x20(%r15), %rax
testq %rax, %rax
jle 0x195c3
movq 0x18(%r14), %rcx
xorl %edx, %edx
movq 0x18(%r15), %rsi
movq (%rsi,%rdx,8), %rsi
movq %rsi, (%rcx,%rdx,8)
movq 0x18(%r14), %rcx
movq (%rcx,%rdx,8), %rsi
incl 0x10(%rsi)
incq %rdx
cmpq %rdx, %rax
jne 0x195a4
movl %eax, 0x20(%r14)
movl 0x10(%r15), %eax
movl %eax, 0x10(%r14)
movq (%r14), %rdi
movq (%r15), %rsi
movl 0x8(%r15), %edx
shlq $0x3, %rdx
callq 0x6320
movq %r14, 0x18(%rbx)
leaq 0x1bda3(%rip), %rax     # 0x35390
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: UpdateStringOfIndex
static void UpdateStringOfIndex(struct Jim_Obj *objPtr)
{
    if (objPtr->internalRep.intValue == -1) {
        JimSetStringBytes(objPtr, "end");
    }
    else {
        char buf[JIM_INTEGER_SPACE + 1];
        if (objPtr->internalRep.intValue >= 0 || objPtr->internalRep.intValue == -INT_MAX) {
            sprintf(buf, "%d", objPtr->internalRep.intValue);
        }
        else {

            sprintf(buf, "end%d", objPtr->internalRep.intValue + 1);
        }
        JimSetStringBytes(objPtr, buf);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x18(%rdi), %edx
cmpl $-0x1, %edx
je 0x19640
testl %edx, %edx
sets %al
cmpl $0x80000001, %edx       # imm = 0x80000001
setne %cl
testb %cl, %al
jne 0x19655
leaq 0x13aaf(%rip), %rsi     # 0x2d0ed
jmp 0x1965e
leaq 0x12ca4(%rip), %rsi     # 0x2c2eb
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %rbp
jmp 0x18d7b
incl %edx
leaq 0x12718(%rip), %rsi     # 0x2bd76
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
callq 0x6480
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x18d7b
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimParseExprOperator
static int JimParseExprOperator(struct JimParserCtx *pc)
{
    int i;
    const struct Jim_ExprOperator *bestOp = NULL;
    int bestLen = 0;


    for (i = 0; i < (signed)JIM_EXPR_OPERATORS_NUM; i++) {
        const struct Jim_ExprOperator *op = &Jim_ExprOperators[i];

        if (op->name[0] != pc->p[0]) {
            continue;
        }

        if (op->namelen > bestLen && strncmp(op->name, pc->p, op->namelen) == 0) {
            bestOp = op;
            bestLen = op->namelen;
        }
    }
    if (bestOp == NULL) {
        return JIM_ERR;
    }


    if (bestOp->attr & OP_FUNC) {
        const char *p = pc->p + bestLen;
        int len = pc->len - bestLen;

        while (len && isspace(UCHAR(*p))) {
            len--;
            p++;
        }
        if (*p != '(') {
            pc->errmsg = "function requires parentheses";
            return JIM_ERR;
        }
    }
    pc->tend = pc->p + bestLen - 1;
    pc->p += bestLen;
    pc->len -= bestLen;

    pc->tt = (bestOp - Jim_ExprOperators) + JIM_TT_EXPR_OP;
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, -0x30(%rbp)
movq (%rdi), %rax
movq %rax, -0x38(%rbp)
movb (%rax), %al
xorl %r14d, %r14d
leaq 0x1c79c(%rip), %rsi     # 0x35e40
xorl %r15d, %r15d
xorl %r13d, %r13d
movq (%r14,%rsi), %rdi
cmpb %al, (%rdi)
jne 0x196f0
movzbl 0x13(%r14,%rsi), %r12d
cmpl %r12d, %r15d
jge 0x196f0
leaq (%rsi,%r14), %rcx
movq %rcx, -0x48(%rbp)
movl %r12d, %edx
movq %rsi, %rbx
movq -0x38(%rbp), %rsi
movl %r15d, -0x40(%rbp)
movl %eax, %r15d
callq 0x60b0
movq %rbx, %rsi
testl %eax, %eax
movl %r15d, %eax
movl -0x40(%rbp), %r15d
cmoveq -0x48(%rbp), %r13
cmovel %r12d, %r15d
addq $0x18, %r14
cmpq $0x3f0, %r14            # imm = 0x3F0
jne 0x196aa
movl $0x1, %edi
testq %r13, %r13
je 0x197b3
testb $0x1, 0x12(%r13)
jne 0x19721
movq -0x30(%rbp), %rdx
movl 0x8(%rdx), %ebx
movslq %r15d, %r8
subl %r15d, %ebx
jmp 0x19778
movslq %r15d, %r8
movq -0x38(%rbp), %rax
leaq (%rax,%r8), %r14
movq -0x30(%rbp), %rax
movl 0x8(%rax), %r12d
movl %r12d, %ebx
subl %r8d, %ebx
je 0x1976e
movq %r8, -0x40(%rbp)
callq 0x64e0
movq -0x40(%rbp), %r8
movl $0x1, %edi
leaq 0x1c6eb(%rip), %rsi     # 0x35e40
movq (%rax), %rax
subl %r12d, %r15d
movzbl (%r14), %ecx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x1976e
incq %r14
incl %r15d
jne 0x1975b
cmpb $0x28, (%r14)
movq -0x30(%rbp), %rdx
jne 0x197a8
movq -0x38(%rbp), %rcx
leaq (%rcx,%r8), %rax
addq %r8, %rcx
decq %rcx
movq %rcx, 0x18(%rdx)
movq %rax, (%rdx)
movl %ebx, 0x8(%rdx)
subq %rsi, %r13
shrq $0x3, %r13
imull $0xaaaaaaab, %r13d, %eax # imm = 0xAAAAAAAB
addl $0x14, %eax
movl %eax, 0x24(%rdx)
xorl %edi, %edi
jmp 0x197b3
leaq 0x126b2(%rip), %rax     # 0x2be61
movq %rax, 0x40(%rdx)
movl %edi, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimParseExprBoolean
static int JimParseExprBoolean(struct JimParserCtx *pc)
{
    int i;
    for (i = 0; i < sizeof(jim_true_false_strings) / sizeof(*jim_true_false_strings); i++) {
        if (strncmp(pc->p, jim_true_false_strings[i], jim_true_false_lens[i]) == 0) {
            pc->p += jim_true_false_lens[i];
            pc->len -= jim_true_false_lens[i];
            pc->tend = pc->p - 1;
            pc->tt = JIM_TT_EXPR_BOOLEAN;
            return JIM_OK;
        }
    }
    return JIM_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, -0x30(%rbp)
movq (%rdi), %r14
leaq 0x1c620(%rip), %r12     # 0x35e00
xorl %r13d, %r13d
leaq 0x13fd6(%rip), %rbx     # 0x2d7c0
movq (%r12), %rsi
movslq (%r13,%rbx), %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x60b0
testl %eax, %eax
je 0x19817
addq $0x8, %r12
addq $0x4, %r13
cmpq $0x20, %r13
jne 0x197ea
movl $0x1, %eax
jmp 0x1983a
leaq (%r14,%r15), %rax
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
subl %r15d, 0x8(%rcx)
leaq (%r14,%r15), %rax
decq %rax
movq %rax, 0x18(%rcx)
movl $0x10, 0x24(%rcx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimExprOpAnd
static int JimExprOpAnd(Jim_Interp *interp, struct JimExprNode *node)
{

    int result = JimExprGetTermBoolean(interp, node->left);

    if (result == 1) {

        result = JimExprGetTermBoolean(interp, node->right);
    }
    if (result == -1) {
        return JIM_ERR;
    }
    Jim_SetResultInt(interp, result);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0x1a6b2
cmpl $0x1, %eax
jne 0x19f33
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x1a6b2
cmpl $-0x1, %eax
je 0x19f80
movl %eax, %r15d
movq %rbx, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x1b3a3(%rip), %rax     # 0x352f0
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movq %r15, 0x18(%r14)
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x19f79
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %eax, %eax
jmp 0x19f85
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimExprOpOr
static int JimExprOpOr(Jim_Interp *interp, struct JimExprNode *node)
{

    int result = JimExprGetTermBoolean(interp, node->left);

    if (result == 0) {

        result = JimExprGetTermBoolean(interp, node->right);
    }
    if (result == -1) {
        return JIM_ERR;
    }
    Jim_SetResultInt(interp, result);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0x1a6b2
testl %eax, %eax
jne 0x19fb9
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x1a6b2
cmpl $-0x1, %eax
je 0x1a006
movl %eax, %r15d
movq %rbx, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x1b31d(%rip), %rax     # 0x352f0
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movq %r15, 0x18(%r14)
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x19fff
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %eax, %eax
jmp 0x1a00b
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimExprOpIntUnary
static int JimExprOpIntUnary(Jim_Interp *interp, struct JimExprNode *node)
{
    jim_wide wA;
    Jim_Obj *A;
    int rc;

    if ((rc = JimExprGetTerm(interp, node->left, &A)) != JIM_OK) {
        return rc;
    }

    rc = Jim_GetWide(interp, A, &wA);
    if (rc == JIM_OK) {
        switch (node->type) {
            case JIM_EXPROP_BITNOT:
                Jim_SetResultInt(interp, ~wA);
                break;
            case JIM_EXPROP_FUNC_SRAND:
                JimPrngSeed(interp, (unsigned char *)&wA, sizeof(wA));
                Jim_SetResult(interp, Jim_NewDoubleObj(interp, JimRandDouble(interp)));
                break;
            default:
                abort();
        }
    }

    Jim_DecrRefCount(interp, A);

    return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0xfb5a
movl %eax, %r15d
testl %eax, %eax
jne 0x1a5af
movq (%rbx), %r14
incl 0x10(%r14)
leaq 0x1ae5c(%rip), %rax     # 0x352f0
cmpq %rax, 0x8(%r14)
je 0x1a4b8
movl $0x1, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0xd6c3
testl %eax, %eax
jne 0x1a594
movq 0x18(%r14), %r13
movq %r13, -0x30(%rbp)
movl (%r12), %eax
cmpl $0x3d, %eax
je 0x1a4f8
cmpl $0x34, %eax
jne 0x1a5c1
notq %r13
movq %rbx, %rdi
callq 0xae38
movq %rax, %r15
leaq 0x1ae09(%rip), %rax     # 0x352f0
movq %rax, 0x8(%r15)
movq $0x0, (%r15)
movq %r13, 0x18(%r15)
jmp 0x1a571
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
movl $0x8, %edx
callq 0x1a746
leaq -0x48(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
movl $0x8, %edx
callq 0x1a873
movsd (%r15), %xmm0
unpcklps 0xcb27(%rip), %xmm0     # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xcb2f(%rip), %xmm0     # 0x27060
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0xd25b(%rip), %xmm1     # 0x277a0
movapd %xmm1, -0x40(%rbp)
movq %rbx, %rdi
callq 0xae38
movq %rax, %r15
leaq 0x1ade4(%rip), %rax     # 0x35340
movq %rax, 0x8(%r15)
movq $0x0, (%r15)
movaps -0x40(%rbp), %xmm0
movsd %xmm0, 0x18(%r15)
incl 0x10(%r15)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x2, %eax
jge 0x1a58e
movq %rbx, %rdi
callq 0x758c
movq %r15, (%rbx)
xorl %r15d, %r15d
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0x1a5af
movq %rbx, %rdi
movq %r14, %rsi
callq 0x758c
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x6070
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimPowWide
static jim_wide JimPowWide(jim_wide b, jim_wide e)
{
    jim_wide res = 1;


    if (b == 1) {

        return 1;
    }
    if (e < 0) {
        if (b != -1) {
            return 0;
        }
        e = -e;
    }
    while (e)
    {
        if (e & 1) {
            res *= b;
        }
        e >>= 1;
        b *= b;
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %eax
cmpq $0x1, %rdi
je 0x1a6b0
testq %rsi, %rsi
js 0x1a67c
jne 0x1a689
jmp 0x1a6b0
cmpq $-0x1, %rdi
je 0x1a686
xorl %eax, %eax
jmp 0x1a6b0
negq %rsi
movl $0x1, %ecx
movq %rsi, %rdx
testb $0x1, %sil
movq %rdi, %r8
cmoveq %rcx, %r8
imulq %r8, %rax
shrq %rdx
imulq %rdi, %rdi
cmpq $0x1, %rsi
movq %rdx, %rsi
ja 0x1a691
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimSearchList
static int JimSearchList(Jim_Interp *interp, Jim_Obj *listObjPtr, Jim_Obj *valObj)
{
    int listlen;
    int i;

    listlen = Jim_ListLength(interp, listObjPtr);
    for (i = 0; i < listlen; i++) {
        if (Jim_StringEqObj(Jim_ListGetIndex(interp, listObjPtr, i), valObj)) {
            return 1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xe2fe
movl 0x20(%r14), %r13d
testl %r13d, %r13d
jle 0x1a72e
xorl %r12d, %r12d
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0xe803
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb096
testl %eax, %eax
jne 0x1a732
incl %r12d
cmpl %r12d, %r13d
jne 0x1a709
xorl %eax, %eax
jmp 0x1a737
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimPrngSeed
static void JimPrngSeed(Jim_Interp *interp, unsigned char *seed, int seedLen)
{
    int i;
    Jim_PrngState *prng;


    if (interp->prngState == NULL)
        JimPrngInit(interp);
    prng = interp->prngState;


    for (i = 0; i < 256; i++)
        prng->sbox[i] = i;

    for (i = 0; i < seedLen; i++) {
        unsigned char t;

        t = prng->sbox[i & 0xFF];
        prng->sbox[i & 0xFF] = prng->sbox[seed[i]];
        prng->sbox[seed[i]] = t;
    }
    prng->i = prng->j = 0;

    for (i = 0; i < 256; i += seedLen) {
        JimRandomBytes(interp, seed, seedLen);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x208(%rdi), %rax
testq %rax, %rax
jne 0x1a774
movq %r15, %rdi
callq 0x1a7e2
movq 0x208(%r15), %rax
xorl %ecx, %ecx
movb %cl, (%rax,%rcx)
incq %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0x1a776
testl %ebx, %ebx
jle 0x1a7b2
movl %ebx, %ecx
xorl %edx, %edx
movzbl %dl, %esi
movb (%rax,%rsi), %dil
movzbl (%r14,%rdx), %r8d
movb (%rax,%r8), %r8b
movb %r8b, (%rax,%rsi)
movzbl (%r14,%rdx), %esi
movb %dil, (%rax,%rsi)
incq %rdx
cmpq %rdx, %rcx
jne 0x1a78d
movq $0x0, 0x100(%rax)
xorl %r12d, %r12d
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1a873
addl %ebx, %r12d
cmpl $0x100, %r12d           # imm = 0x100
jl 0x1a7c0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimPrngInit
static void JimPrngInit(Jim_Interp *interp)
{
#define PRNG_SEED_SIZE 256
    int i;
    unsigned int *seed;
    time_t t = time(NULL);

    interp->prngState = Jim_Alloc(sizeof(Jim_PrngState));

    seed = Jim_Alloc(PRNG_SEED_SIZE * sizeof(*seed));
    for (i = 0; i < PRNG_SEED_SIZE; i++) {
        seed[i] = (rand() ^ t ^ clock());
    }
    JimPrngSeed(interp, (unsigned char *)seed, PRNG_SEED_SIZE * sizeof(*seed));
    Jim_Free(seed);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r13d, %r13d
xorl %edi, %edi
callq 0x6330
movq %rax, %r14
movl $0x108, %esi            # imm = 0x108
xorl %edi, %edi
callq *0x1ca7b(%rip)          # 0x37288
movq %rax, 0x208(%rbx)
movl $0x400, %esi            # imm = 0x400
xorl %edi, %edi
callq *0x1ca67(%rip)          # 0x37288
movq %rax, %r15
callq 0x64d0
movl %eax, %r12d
xorl %r14d, %r12d
callq 0x6150
xorl %r12d, %eax
movl %eax, (%r15,%r13,4)
incq %r13
cmpq $0x100, %r13            # imm = 0x100
jne 0x1a824
movq %rbx, %rdi
movq %r15, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x1a746
movq 0x1ca2a(%rip), %rax     # 0x37288
movq %r15, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimRandomBytes
static void JimRandomBytes(Jim_Interp *interp, void *dest, unsigned int len)
{
    Jim_PrngState *prng;
    unsigned char *destByte = (unsigned char *)dest;
    unsigned int si, sj, x;


    if (interp->prngState == NULL)
        JimPrngInit(interp);
    prng = interp->prngState;

    for (x = 0; x < len; x++) {
        prng->i = (prng->i + 1) & 0xff;
        si = prng->sbox[prng->i];
        prng->j = (prng->j + si) & 0xff;
        sj = prng->sbox[prng->j];
        prng->sbox[prng->i] = sj;
        prng->sbox[prng->j] = si;
        *destByte++ = prng->sbox[(si + sj) & 0xff];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movq 0x208(%rdi), %rax
testq %rax, %rax
jne 0x1a89e
movq %rdi, %r15
callq 0x1a7e2
movq 0x208(%r15), %rax
testl %r14d, %r14d
je 0x1a8f5
movl %r14d, %ecx
xorl %edx, %edx
movl 0x100(%rax), %esi
incl %esi
movzbl %sil, %esi
movl %esi, 0x100(%rax)
movb (%rax,%rsi), %dil
movb 0x104(%rax), %r8b
addb %dil, %r8b
movzbl %r8b, %r8d
movl %r8d, 0x104(%rax)
movb (%rax,%r8), %r9b
movb %r9b, (%rax,%rsi)
movb %dil, (%rax,%r8)
addb %dil, %r9b
movzbl %r9b, %esi
movb (%rax,%rsi), %sil
movb %sil, (%rbx,%rdx)
incq %rdx
cmpl %edx, %ecx
jne 0x1a8a8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: ExprTreeFreeNodes
static void ExprTreeFreeNodes(Jim_Interp *interp, struct JimExprNode *nodes, int num)
{
    int i;
    for (i = 0; i < num; i++) {
        if (nodes[i].objPtr) {
            Jim_DecrRefCount(interp, nodes[i].objPtr);
        }
    }
    Jim_Free(nodes);
}

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

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

        ExprTreeFree(interp, expr);
    }
}

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, -0x38(%rbp)
movq %rdx, %rdi
callq 0x6180
movq %rax, %rbx
incl %eax
movslq %eax, %rsi
xorl %edi, %edi
callq *0x1c247(%rip)          # 0x37288
movq %rax, %r13
movslq %ebx, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6320
movb $0x0, (%r13,%rbx)
movb (%r14), %r12b
movq %r13, -0x30(%rbp)
testb %r12b, %r12b
je 0x1b0b8
incq %r14
movq -0x30(%rbp), %r13
movzbl %r12b, %ebx
testq %r15, %r15
je 0x1b097
movq %r15, %rdi
callq 0x6180
movq %r15, %rdi
movl %eax, %esi
movl %ebx, %edx
movl $0x2, %ecx
callq 0x178ee
testq %rax, %rax
jne 0x1b0a6
jmp 0x1b0b8
callq 0x64e0
movq (%rax), %rax
testb $0x20, 0x1(%rax,%rbx,2)
jne 0x1b0b8
movb %r12b, (%r13)
incq %r13
movb (%r14), %r12b
incq %r14
testb %r12b, %r12b
jne 0x1b06e
movb $0x0, (%r13)
movq -0x30(%rbp), %rsi
subl %esi, %r13d
movq -0x38(%rbp), %rdi
movl %r13d, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xaee8
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimGetEvalFrameByProcLevel
static Jim_EvalFrame *JimGetEvalFrameByProcLevel(Jim_Interp *interp, int proclevel)
{
    Jim_EvalFrame *evalFrame;

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

    if (proclevel < 0) {

        proclevel = interp->procLevel + proclevel;
    }

    if (proclevel >= 0) {

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x108(%rdi), %rdi
callq 0x1b8f1
movq %rax, %r12
leaq 0x128(%r14), %rcx
movq 0x30(%r15), %rsi
testq %rsi, %rsi
je 0x1b81f
movq %r14, %rdi
movq %rcx, %r13
callq 0xb679
movslq 0x20(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq %r13, %rcx
addq $0x8, %rax
jmp 0x1b82b
movl $0x1, %eax
movq %rax, -0x30(%rbp)
movq %rcx, %rax
movq (%rax), %r13
testq %r12, %r12
jne 0x1b836
movq (%rcx), %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x7683
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x7683
movq %r14, %rdi
callq 0xae38
leaq 0x19a8f(%rip), %rcx     # 0x352f0
movq %rcx, 0x8(%rax)
movq $0x0, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x7683
movq 0x20(%r15), %rsi
movl 0x28(%r15), %edx
movq %r14, %rdi
callq 0x762e
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7683
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimSetStackTrace
static void JimSetStackTrace(Jim_Interp *interp, Jim_Obj *stackTraceObj)
{

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq %rsi, %rdi
je 0x1b90a
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x1b931
cmpq $0x0, 0x10(%rax)
je 0x1b931
movq 0x18(%rsi), %rcx
testq %rcx, %rcx
je 0x1b931
movq 0x10(%rcx), %rax
testq %rax, %rax
je 0x1b92b
cmpl $0x0, 0x4(%rax)
je 0x1b92b
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x1b933
movq 0x18(%rcx), %rcx
jmp 0x1b90e
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_AliasCoreCommand
static int Jim_AliasCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *prefixListObj;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x2, %esi
jg 0x1b96a
leaq 0x10a39(%rip), %rcx     # 0x2c38b
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7446
jmp 0x1b9c6
movl %esi, %edx
leaq 0x10(%r14), %rsi
addl $-0x2, %edx
movq %rbx, %rdi
callq 0x762e
movq %rax, %r15
incl 0x10(%rax)
movq 0x8(%r14), %r12
incl 0x10(%r12)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1b9a3
movq %rbx, %rdi
callq 0x758c
movq %r12, (%rbx)
movq 0x8(%r14), %rsi
leaq 0x62f4(%rip), %rdx      # 0x21ca5
leaq 0x634b(%rip), %r8       # 0x21d03
movq %rbx, %rdi
movq %r15, %rcx
callq 0xbec5
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_SetCoreCommand
static int Jim_SetCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    if (argc != 2 && argc != 3) {
        Jim_WrongNumArgs(interp, 1, argv, "varName ?newValue?");
        return JIM_ERR;
    }
    if (argc == 2) {
        Jim_Obj *objPtr;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %eax
movq %rdi, %rbx
leal -0x4(%rax), %ecx
cmpl $-0x3, %ecx
ja 0x1ba0b
leaq 0x109b3(%rip), %rcx     # 0x2c3a6
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7446
jmp 0x1ba6e
movq 0x8(%r14), %rsi
cmpl $0x2, %eax
jne 0x1ba31
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %edx
callq 0x98e7
testq %rax, %rax
je 0x1ba6e
movq %rax, %r14
jmp 0x1ba4b
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0x876e
movl $0x1, %r15d
testl %eax, %eax
jne 0x1ba6e
movq 0x10(%r14), %r14
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1ba68
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_UnsetCoreCommand
static int Jim_UnsetCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    int i = 1;
    int complain = 1;

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

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

    Jim_SetEmptyResult(interp);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x2, %esi
jl 0x1baef
movl %esi, -0x2c(%rbp)
movl %esi, %eax
movq %rax, -0x38(%rbp)
movb $0x1, %r15b
movl $0x1, %r12d
movl $0x2, %r13d
movq (%r14,%r12,8), %rsi
movq %rbx, %rdi
leaq 0x10b01(%rip), %rdx     # 0x2c5bf
callq 0x73c6
testl %eax, %eax
jne 0x1bafd
movq (%r14,%r12,8), %rsi
movq %rbx, %rdi
leaq 0xef1a(%rip), %rdx      # 0x2a9ef
callq 0x73c6
testl %eax, %eax
je 0x1bafa
incq %r12
incl %r13d
xorl %r15d, %r15d
cmpq %r12, -0x38(%rbp)
jne 0x1bab0
jmp 0x1bb38
movl $0x1, %r13d
movb $0x1, %r15b
jmp 0x1bb00
movl %r12d, %r13d
movl -0x2c(%rbp), %esi
cmpl %esi, %r13d
jge 0x1bb38
movzbl %r15b, %r12d
andl $0x1, %r12d
movslq %r13d, %r13
movl %esi, %eax
movq %rax, -0x38(%rbp)
movq (%r14,%r13,8), %rsi
movq %rbx, %rdi
movl %r12d, %edx
callq 0xc7f4
testl %eax, %eax
setne %al
testb %al, %r15b
jne 0x1bb63
incq %r13
cmpl %r13d, -0x38(%rbp)
jne 0x1bb16
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 0x1bb5c
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %eax, %eax
jmp 0x1bb68
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_PutsCoreCommand
static int Jim_PutsCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    if (argc != 2 && argc != 3) {
        Jim_WrongNumArgs(interp, 1, argv, "?-nonewline? string");
        return JIM_ERR;
    }
    if (argc == 3) {
        if (!Jim_CompareStringImmediate(interp, argv[1], "-nonewline")) {
            Jim_SetResultString(interp, "The second argument must " "be -nonewline", -1);
            return JIM_ERR;
        }
        else {
            fputs(Jim_String(argv[2]), stdout);
        }
    }
    else {
        puts(Jim_String(argv[1]));
    }
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leal -0x4(%rsi), %eax
cmpl $-0x3, %eax
ja 0x1bbae
leaq 0x10823(%rip), %rcx     # 0x2c3b9
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7446
jmp 0x1bc14
movq 0x8(%r14), %r15
cmpl $0x3, %esi
jne 0x1bbf7
leaq 0x1082b(%rip), %rdx     # 0x2c3e9
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73c6
testl %eax, %eax
je 0x1bc22
movq 0x10(%r14), %rbx
movq (%rbx), %rdi
testq %rdi, %rdi
jne 0x1bbe6
movq 0x8(%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq (%rbx), %rdi
movq 0x1b38b(%rip), %rax     # 0x36f78
movq (%rax), %rsi
callq 0x6230
jmp 0x1bc11
movq (%r15), %rdi
testq %rdi, %rdi
jne 0x1bc0c
movq 0x8(%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq (%r15), %rdi
callq 0x60f0
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x107a4(%rip), %rsi     # 0x2c3cd
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1bc55
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
movl $0x1, %r15d
jmp 0x1bc14
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_IncrCoreCommand
static int Jim_IncrCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    jim_wide wideValue, increment = 1;
    Jim_Obj *intObjPtr;

    if (argc != 2 && argc != 3) {
        Jim_WrongNumArgs(interp, 1, argv, "varName ?increment?");
        return JIM_ERR;
    }
    if (argc == 3) {
        if (Jim_GetWideExpr(interp, argv[2], &increment) != JIM_OK)
            return JIM_ERR;
    }
    intObjPtr = Jim_GetVariable(interp, argv[1], JIM_UNSHARED);
    if (!intObjPtr) {

        wideValue = 0;
    }
    else if (Jim_GetWide(interp, intObjPtr, &wideValue) != JIM_OK) {
        return JIM_ERR;
    }
    if (!intObjPtr || Jim_IsShared(intObjPtr)) {
        intObjPtr = Jim_NewIntObj(interp, wideValue + increment);
        if (Jim_SetVariable(interp, argv[1], intObjPtr) != JIM_OK) {
            Jim_FreeNewObj(interp, intObjPtr);
            return JIM_ERR;
        }
    }
    else {

        Jim_InvalidateStringRep(intObjPtr);
        JimWideValue(intObjPtr) = wideValue + increment;

        if (argv[1]->typePtr != &variableObjType) {

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq $0x1, -0x28(%rbp)
leal -0x4(%rsi), %eax
cmpl $-0x3, %eax
ja 0x1bce3
leaq 0x10747(%rip), %rcx     # 0x2c40f
movl $0x1, %r12d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7446
jmp 0x1be19
cmpl $0x3, %esi
jne 0x1bd06
movq 0x10(%r14), %rsi
leaq -0x28(%rbp), %rdx
movq %rbx, %rdi
callq 0xd7f8
movl $0x1, %r12d
testl %eax, %eax
jne 0x1be19
movq 0x8(%r14), %rsi
movq %rbx, %rdi
movl $0x4, %edx
callq 0x98e7
testq %rax, %rax
je 0x1bda8
movq %rax, %r15
leaq 0x195c6(%rip), %rax     # 0x352f0
cmpq %rax, 0x8(%r15)
je 0x1bd4e
movl $0x1, %r12d
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0xd6c3
testl %eax, %eax
jne 0x1be19
movq 0x18(%r15), %r12
cmpl $0x2, 0x10(%r15)
jge 0x1bdab
movq (%r15), %rdi
testq %rdi, %rdi
sete %al
leaq 0x1b52f(%rip), %rcx     # 0x37298
cmpq %rcx, %rdi
sete %cl
orb %al, %cl
jne 0x1bd7b
xorl %esi, %esi
callq *0x1b50d(%rip)          # 0x37288
movq $0x0, (%r15)
addq -0x28(%rbp), %r12
movq %r12, 0x18(%r15)
movq 0x8(%r14), %rsi
leaq 0x19fc3(%rip), %rax     # 0x35d58
cmpq %rax, 0x8(%rsi)
je 0x1bdf6
movq %rbx, %rdi
movq %r15, %rdx
callq 0x876e
jmp 0x1bdf6
xorl %r12d, %r12d
addq -0x28(%rbp), %r12
movq %rbx, %rdi
callq 0xae38
movq %rax, %r15
leaq 0x1952f(%rip), %rax     # 0x352f0
movq %rax, 0x8(%r15)
movq $0x0, (%r15)
movq %r12, 0x18(%r15)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x876e
testl %eax, %eax
je 0x1bdf6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x758c
movl $0x1, %r12d
jmp 0x1be19
incl 0x10(%r15)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1be13
movq %rbx, %rdi
callq 0x758c
movq %r15, (%rbx)
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_WhileCoreCommand
static int Jim_WhileCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    if (argc != 3) {
        Jim_WrongNumArgs(interp, 1, argv, "condition body");
        return JIM_ERR;
    }


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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x3, %esi
jne 0x1be62
leaq -0x24(%rbp), %rdx
movl $0x0, (%rdx)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xfc6e
testl %eax, %eax
je 0x1be8f
movl %eax, %r15d
jmp 0x1be7f
leaq 0x105ba(%rip), %rcx     # 0x2c423
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x7446
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x24(%rbp), %r12
cmpl $0x0, -0x24(%rbp)
je 0x1beee
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x908a
testl %eax, %eax
je 0x1bec9
movl %eax, %r15d
leal -0x3(%r15), %eax
cmpl $0x1, %eax
ja 0x1bec3
movl 0x18(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x18(%rbx)
cmpl $0x1, %eax
jg 0x1be7f
cmpl $0x4, %r15d
jne 0x1bee8
movl $0x0, -0x24(%rbp)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0xfc6e
testl %eax, %eax
je 0x1be93
jmp 0x1be5d
cmpl $0x3, %r15d
jne 0x1be7f
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 0x1bf12
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %r15d, %r15d
jmp 0x1be7f
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_LassignCoreCommand
static int Jim_LassignCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    int result = JIM_ERR;
    int i;
    Jim_ListIter iter;
    Jim_Obj *resultObj;

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

    JimListIterInit(&iter, argv[1]);

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

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

    Jim_SetResult(interp, resultObj);

    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
cmpl $0x1, %esi
jg 0x1c3ef
leaq 0x100d1(%rip), %rcx     # 0x2c4a5
movl $0x1, %r14d
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x7446
jmp 0x1c4e9
movq 0x8(%r15), %r14
xorl %r12d, %r12d
cmpl $0x2, %esi
je 0x1c458
movl %esi, %eax
movq %rax, -0x30(%rbp)
xorl %r12d, %r12d
movl $0x2, %r13d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe2fe
cmpl 0x20(%r14), %r12d
jge 0x1c434
movq 0x18(%r14), %rax
movslq %r12d, %rcx
incl %r12d
movq (%rax,%rcx,8), %rdx
movq (%r15,%r13,8), %rsi
testq %rdx, %rdx
jne 0x1c43f
jmp 0x1c438
movq (%r15,%r13,8), %rsi
movq 0x128(%rbx), %rdx
movq %rbx, %rdi
callq 0x876e
testl %eax, %eax
jne 0x1c4e3
incq %r13
cmpq %r13, -0x30(%rbp)
jne 0x1c40a
movq %rbx, %rdi
callq 0xae38
movq %rax, %r15
leaq 0x18efe(%rip), %rax     # 0x35368
movq %rax, 0x8(%r15)
movq $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe2fe
cmpl %r12d, 0x20(%r14)
jle 0x1c4be
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe2fe
cmpl 0x20(%r14), %r12d
jge 0x1c4af
movq 0x18(%r14), %rax
movslq %r12d, %rcx
incl %r12d
movq (%rax,%rcx,8), %rdx
jmp 0x1c4b1
xorl %edx, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7683
jmp 0x1c47d
incl 0x10(%r15)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1c4db
movq %rbx, %rdi
callq 0x758c
movq %r15, (%rbx)
xorl %r14d, %r14d
jmp 0x1c4e9
movl $0x1, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_LindexCoreCommand
static int Jim_LindexCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *objPtr;
    int ret;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x1, %esi
jg 0x1ca9f
leaq 0xfb5c(%rip), %rcx      # 0x2c5e6
movl $0x1, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7446
jmp 0x1caf4
movl %esi, %ecx
movq 0x8(%rdx), %rsi
addq $0x10, %rdx
addl $-0x2, %ecx
leaq -0x18(%rbp), %r8
movq %rbx, %rdi
xorl %r9d, %r9d
callq 0x225a2
testl %eax, %eax
js 0x1caca
movl %eax, %r14d
jne 0x1caf4
movq -0x18(%rbp), %r14
jmp 0x1cad1
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 0x1caee
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_LsetCoreCommand
static int Jim_LsetCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    if (argc < 3) {
        Jim_WrongNumArgs(interp, 1, argv, "listVar ?index ...? value");
        return JIM_ERR;
    }
    else if (argc == 3) {

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, %esi
jg 0x1cb2e
leaq 0xfb05(%rip), %rcx      # 0x2c61e
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7446
jmp 0x1cb78
movl %esi, %ecx
leaq 0x10(%rdx), %r14
movq 0x8(%rdx), %rsi
cmpl $0x3, %ecx
jne 0x1cb86
movq (%r14), %rdx
movq %rbx, %rdi
callq 0x876e
movl $0x1, %r15d
testl %eax, %eax
jne 0x1cb78
movq (%r14), %r14
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1cb72
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %ecx, %eax
addl $-0x3, %ecx
movq -0x8(%rdx,%rax,8), %r8
movq %rbx, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe8b5
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_LlengthCoreCommand
static int Jim_LlengthCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    if (argc != 2) {
        Jim_WrongNumArgs(interp, 1, argv, "list");
        return JIM_ERR;
    }
    Jim_SetResultInt(interp, Jim_ListLength(interp, argv[1]));
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, %esi
jne 0x1d35b
movq 0x8(%rdx), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe2fe
movslq 0x20(%r14), %r15
movq %rbx, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x17fc9(%rip), %rax     # 0x352f0
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movq %r15, 0x18(%r14)
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1d353
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %r14d, %r14d
jmp 0x1d375
leaq 0xf458(%rip), %rcx      # 0x2c7ba
movl $0x1, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7446
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_LappendCoreCommand
static int Jim_LappendCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *listObjPtr;
    int new_obj = 0;
    int i;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
cmpl $0x1, %esi
jg 0x1d3be
leaq 0xf37a(%rip), %rcx      # 0x2c71d
movl $0x1, %r12d
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x7446
jmp 0x1d492
movl %esi, %r12d
movq 0x8(%r15), %rsi
movq %rbx, %rdi
movl $0x4, %edx
callq 0x98e7
testq %rax, %rax
je 0x1d3f3
movq %rax, %r14
movb $0x1, %al
cmpl $0x2, 0x10(%r14)
jl 0x1d41a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8fc2
movq %rax, %r14
jmp 0x1d418
movq %rbx, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x17f63(%rip), %rax     # 0x35368
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x2, %r12d
je 0x1d443
movl %r12d, %r12d
movl $0x2, %r13d
movq (%r15,%r13,8), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7683
incq %r13
cmpq %r13, %r12
jne 0x1d42c
movq 0x8(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x876e
testl %eax, %eax
je 0x1d46f
movl $0x1, %r12d
cmpb $0x0, -0x2c(%rbp)
jne 0x1d492
movq %rbx, %rdi
movq %r14, %rsi
callq 0x758c
jmp 0x1d492
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1d48c
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq