LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0xe46b
movq %rax, %r14
movl 0x20(%r15), %eax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
cmpq %rcx, %rdx
je 0x17281
movq 0x18(%r15), %rsi
movq (%rsi,%rcx,8), %rsi
movq 0x18(%r14), %rdi
movq %rsi, (%rdi,%rcx,8)
movq 0x18(%r14), %rsi
movq (%rsi,%rcx,8), %rsi
incl 0x10(%rsi)
incq %rcx
jmp 0x1725c
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 0x1a185(%rip), %rax     # 0x31430
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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 0x172fe
testl %edx, %edx
sets %al
cmpl $0x80000001, %edx       # imm = 0x80000001
setne %cl
testb %cl, %al
jne 0x17313
leaq 0x11e41(%rip), %rsi     # 0x2913d
jmp 0x1731c
leaq 0x11036(%rip), %rsi     # 0x2833b
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %rbp
jmp 0x16b22
incl %edx
leaq 0x10aaa(%rip), %rsi     # 0x27dc6
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
callq 0x6480
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x16b22
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, -0x38(%rbp)
movq (%rdi), %rax
movq %rax, -0x40(%rbp)
movb (%rax), %al
xorl %r14d, %r14d
leaq 0x1aaa3(%rip), %rdx     # 0x31e40
xorl %r13d, %r13d
xorl %r12d, %r12d
movb %al, -0x29(%rbp)
cmpq $0x3f0, %r14            # imm = 0x3F0
je 0x173ef
movq (%r14,%rdx), %rdi
cmpb %al, (%rdi)
jne 0x173e9
movzbl 0x13(%r14,%rdx), %r15d
cmpl %r15d, %r12d
jge 0x173e9
movq %rdx, %rbx
addq %r14, %rdx
movq %rdx, -0x48(%rbp)
movl %r15d, %edx
movq -0x40(%rbp), %rsi
callq 0x60b0
testl %eax, %eax
movb -0x29(%rbp), %al
cmoveq -0x48(%rbp), %r13
movq %rbx, %rdx
cmovel %r15d, %r12d
addq $0x18, %r14
jmp 0x173a6
pushq $0x1
popq %rax
testq %r13, %r13
je 0x1749b
testb $0x1, 0x12(%r13)
jne 0x17411
movq -0x38(%rbp), %rsi
movl 0x8(%rsi), %ebx
movslq %r12d, %r15
subl %r12d, %ebx
jmp 0x1745d
movslq %r12d, %rdx
movq -0x40(%rbp), %rax
movq %rdx, %r15
leaq (%rax,%rdx), %r14
movq -0x38(%rbp), %rax
movl 0x8(%rax), %ebx
subl %r12d, %ebx
xorl %r12d, %r12d
cmpl %r12d, %ebx
je 0x1744a
callq 0x64e0
movq (%rax), %rcx
movzbl (%r14,%r12), %eax
testb $0x20, 0x1(%rcx,%rax,2)
je 0x1744e
incq %r12
jmp 0x1742c
movb (%r14,%rbx), %al
cmpb $0x28, %al
movq -0x38(%rbp), %rsi
leaq 0x1a9e5(%rip), %rdx     # 0x31e40
jne 0x1748d
movq -0x40(%rbp), %rcx
leaq (%rcx,%r15), %rax
addq %r15, %rcx
decq %rcx
movq %rcx, 0x18(%rsi)
movq %rax, (%rsi)
movl %ebx, 0x8(%rsi)
subq %rdx, %r13
pushq $0x18
popq %rcx
movq %r13, %rax
cqto
idivq %rcx
addl $0x14, %eax
movl %eax, 0x24(%rsi)
xorl %eax, %eax
jmp 0x1749b
leaq 0x10a1d(%rip), %rax     # 0x27eb1
movq %rax, 0x40(%rsi)
pushq $0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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 0x1a93a(%rip), %r13     # 0x31e00
xorl %r15d, %r15d
leaq 0x12340(%rip), %rbx     # 0x29810
cmpq $0x20, %r15
je 0x1751a
movq (%r13), %rsi
movslq (%r15,%rbx), %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0x60b0
addq $0x4, %r15
addq $0x8, %r13
testl %eax, %eax
jne 0x174d0
leaq (%r14,%r12), %rax
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
subl %r12d, 0x8(%rcx)
leaq (%r14,%r12), %rax
decq %rax
movq %rax, 0x18(%rcx)
movl $0x10, 0x24(%rcx)
xorl %eax, %eax
jmp 0x1751d
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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 %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0x181b1
cmpl $0x1, %eax
jne 0x17bea
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x181b1
cmpl $-0x1, %eax
je 0x17c1f
movl %eax, %esi
movq %rbx, %rdi
callq 0x8212
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x17c18
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %eax, %eax
jmp 0x17c22
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0x181b1
testl %eax, %eax
jne 0x17c4d
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x181b1
cmpl $-0x1, %eax
je 0x17c82
movl %eax, %esi
movq %rbx, %rdi
callq 0x8212
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x17c7b
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %eax, %eax
jmp 0x17c85
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
leaq -0x30(%rbp), %rdx
callq 0x1818d
movl %eax, %r14d
testl %eax, %eax
jne 0x18138
movq -0x30(%rbp), %r15
leaq -0x28(%rbp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc979
movl %eax, %r14d
testl %eax, %eax
jne 0x1811d
movl (%r12), %eax
cmpl $0x3d, %eax
je 0x180dc
cmpl $0x34, %eax
jne 0x18148
movq -0x28(%rbp), %rsi
notq %rsi
movq %rbx, %rdi
callq 0x8212
jmp 0x180fb
leaq -0x28(%rbp), %rsi
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x18244
movq %rbx, %rdi
callq 0x182e7
movq %rbx, %rdi
callq 0xd366
movq %rax, %r12
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x2, %eax
jge 0x1811a
movq %rbx, %rdi
callq 0x73bf
movq %r12, (%rbx)
movl 0x10(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r15)
cmpl $0x1, %eax
jg 0x18138
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73bf
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x6070
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: JimExprGetTerm
static int JimExprGetTerm(Jim_Interp *interp, struct JimExprNode *node, Jim_Obj **objPtrPtr)
{
    int rc = JimExprEvalTermNode(interp, node);
    if (rc == JIM_OK) {
        *objPtrPtr = Jim_GetResult(interp);
        Jim_IncrRefCount(*objPtrPtr);
    }
    return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
callq 0xea75
testl %eax, %eax
jne 0x181ac
movq (%r14), %rcx
movq %rcx, (%rbx)
incl 0x10(%rcx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8b3c
movl %eax, %r13d
xorl %eax, %eax
testl %r13d, %r13d
cmovlel %eax, %r13d
xorl %r12d, %r12d
cmpl %r12d, %r13d
je 0x18233
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0xd95e
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa7f8
incl %r12d
testl %eax, %eax
je 0x18209
pushq $0x1
popq %rax
jmp 0x18235
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_O2/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 0x18272
movq %r15, %rdi
callq 0x1832a
movq 0x208(%r15), %rax
xorl %ecx, %ecx
cmpq $0x100, %rcx            # imm = 0x100
je 0x18285
movb %cl, (%rax,%rcx)
incq %rcx
jmp 0x18274
xorl %ecx, %ecx
testl %ebx, %ebx
movl $0x0, %edx
cmovgl %ebx, %edx
cmpq %rcx, %rdx
je 0x182b8
movzbl %cl, %esi
movb (%rax,%rsi), %dil
movzbl (%r14,%rcx), %r8d
movb (%rax,%r8), %r8b
movb %r8b, (%rax,%rsi)
movzbl (%r14,%rcx), %esi
movb %dil, (%rax,%rsi)
incq %rcx
jmp 0x18291
andq $0x0, 0x100(%rax)
xorl %r12d, %r12d
cmpl $0xff, %r12d
jg 0x182de
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x183bd
addl %ebx, %r12d
jmp 0x182c3
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 *0x1af33(%rip)          # 0x33288
movq %rax, 0x208(%rbx)
movl $0x400, %esi            # imm = 0x400
xorl %edi, %edi
callq *0x1af1f(%rip)          # 0x33288
movq %rax, %r15
cmpq $0x100, %r13            # imm = 0x100
je 0x18391
callq 0x64d0
movl %eax, %r12d
xorl %r14d, %r12d
callq 0x6150
xorl %r12d, %eax
movl %eax, (%r15,%r13,4)
incq %r13
jmp 0x1836c
movq %rbx, %rdi
movq %r15, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x18244
movq 0x1aee0(%rip), %rax     # 0x33288
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_O2/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 0x183e8
movq %rdi, %r15
callq 0x1832a
movq 0x208(%r15), %rax
movl %r14d, %ecx
xorl %edx, %edx
cmpl %edx, %ecx
je 0x1843c
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
jmp 0x183ed
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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
movq %rdi, %r14
xorl %r15d, %r15d
testl %edx, %edx
cmovlel %r15d, %edx
imulq $0x28, %rdx, %r12
cmpq %r15, %r12
je 0x18a19
movq 0x8(%rbx,%r15), %rsi
testq %rsi, %rsi
je 0x18a13
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x18a13
movq %r14, %rdi
callq 0x73bf
addq $0x28, %r15
jmp 0x189ee
movq 0x1a868(%rip), %rax     # 0x33288
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/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 0x18a43
decl 0x14(%rbx)
je 0x18a4a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x8(%rbx), %rsi
movl 0x10(%rbx), %edx
callq 0x189d0
movq 0x1a82b(%rip), %rax     # 0x33288
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: JimTraceCallback
static int JimTraceCallback(Jim_Interp *interp, const char *type, int argc, Jim_Obj *const *argv)
{
    JimPanic((interp->traceCmdObj == NULL, "xtrace invoked with no object"));

    int ret;
    Jim_Obj *nargv[7];
    Jim_Obj *traceCmdObj = interp->traceCmdObj;
    Jim_Obj *resultObj = Jim_GetResult(interp);
    ScriptObj *script = NULL;



    if (interp->evalFrame->scriptObj) {
        script = JimGetScript(interp, interp->evalFrame->scriptObj);
    }

    nargv[0] = traceCmdObj;
    nargv[1] = Jim_NewStringObj(interp, type, -1);
    nargv[2] = script ? script->fileNameObj : interp->emptyObj;
    nargv[3] = Jim_NewIntObj(interp, script ? script->linenr : 1);
    nargv[4] = resultObj;
    nargv[5] = argv[0];
    nargv[6] = Jim_NewListObj(interp, argv + 1, argc - 1);


    interp->traceCmdObj = NULL;

    Jim_IncrRefCount(resultObj);
    ret = Jim_EvalObjVector(interp, 7, nargv);
    Jim_DecrRefCount(interp, resultObj);

    if (ret == JIM_OK || ret == JIM_RETURN) {

        interp->traceCmdObj = traceCmdObj;
        Jim_SetEmptyResult(interp);
        ret = JIM_OK;
    }
    else {

        Jim_DecrRefCount(interp, traceCmdObj);
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r12
movl %edx, -0x2c(%rbp)
movq %rsi, %r13
movq %rdi, %rbx
movq 0x1a8(%rdi), %rcx
movq (%rdi), %r15
movq 0x108(%rdi), %rax
movq 0x30(%rax), %rsi
testq %rsi, %rsi
je 0x18abf
movq %rbx, %rdi
movq %rcx, %r14
callq 0xad8c
movq %r14, %rcx
movq %rax, %r14
jmp 0x18ac2
xorl %r14d, %r14d
movq %rcx, -0x38(%rbp)
movq %rcx, -0x70(%rbp)
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x7363
movq %rax, -0x68(%rbp)
leaq 0x8(%r14), %rax
leaq 0x128(%rbx), %rcx
testq %r14, %r14
cmoveq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
je 0x18afd
movslq 0x20(%r14), %rsi
jmp 0x18b00
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x8212
leaq -0x70(%rbp), %r14
movq %rax, 0x18(%r14)
movq %r15, 0x20(%r14)
movq (%r12), %rax
movq %rax, 0x28(%r14)
addq $0x8, %r12
movl -0x2c(%rbp), %edx
decl %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x745b
movq %rax, 0x30(%r14)
andq $0x0, 0x1a8(%rbx)
incl 0x10(%r15)
pushq $0x7
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xf32e
movl %eax, %r12d
movl 0x10(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r15)
cmpl $0x1, %eax
jg 0x18b6c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73bf
testl $0xfffffffd, %r12d      # imm = 0xFFFFFFFD
je 0x18b91
movq -0x38(%rbp), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x18bc6
movq %rbx, %rdi
callq 0x73bf
jmp 0x18bc6
movq -0x38(%rbp), %rax
movq %rax, 0x1a8(%rbx)
movq 0x128(%rbx), %r14
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x18bc0
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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:
movq %rdi, %rax
testl %esi, %esi
je 0x190d5
jns 0x190b8
addl 0x110(%rax), %esi
js 0x190e1
pushq %rbp
movq %rsp, %rbp
addq $0x108, %rax            # imm = 0x108
movq (%rax), %rax
testq %rax, %rax
je 0x190dd
cmpl %esi, 0xc(%rax)
je 0x190df
addq $0x18, %rax
jmp 0x190c2
movq 0x108(%rax), %rax
retq
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: JimAddStackFrame
static void JimAddStackFrame(Jim_Interp *interp, Jim_EvalFrame *frame, Jim_Obj *listObj)
{
    Jim_Obj *procNameObj = JimProcForEvalFrame(interp, frame);
    Jim_Obj *fileNameObj = interp->emptyObj;
    int linenr = 1;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x191e9
movq %rax, %r12
leaq 0x128(%r14), %rcx
movq 0x30(%r15), %rsi
testq %rsi, %rsi
je 0x1912f
movq %r14, %rdi
movq %rcx, %r13
callq 0xad8c
movslq 0x20(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq %r13, %rcx
addq $0x8, %rax
jmp 0x19139
pushq $0x1
popq %rax
movq %rax, -0x30(%rbp)
movq %rcx, %rax
movq (%rax), %r13
testq %r12, %r12
jne 0x19144
movq (%rcx), %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x74ad
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x74ad
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq 0x8212
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x74ad
movq 0x20(%r15), %rsi
movl 0x28(%r15), %edx
movq %r14, %rdi
callq 0x745b
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 0x74ad
// File: /workspace/github_c_makefile_star2_O2/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 0x191d3
movq %rbx, %rdi
callq 0x73bf
movq %r14, 0x188(%rbx)
movl $0x1, 0x1b4(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1925e
leaq 0xf191(%rip), %rcx      # 0x283db
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x72a5
jmp 0x192ba
movl %esi, %edx
leaq 0x10(%r14), %rsi
addl $-0x2, %edx
movq %rbx, %rdi
callq 0x745b
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 0x19297
movq %rbx, %rdi
callq 0x73bf
movq %r12, (%rbx)
movq 0x8(%r14), %rsi
leaq 0x5c18(%rip), %rdx      # 0x1eebd
leaq 0x5c6c(%rip), %r8       # 0x1ef18
movq %rbx, %rdi
movq %r15, %rcx
callq 0xb465
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_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 0x192fb
leaq 0xf10f(%rip), %rcx      # 0x283f6
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x72a5
jmp 0x1935a
movq 0x8(%r14), %rsi
cmpl $0x2, %eax
jne 0x1931d
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %edx
callq 0x9378
testq %rax, %rax
je 0x1935a
movq %rax, %r14
jmp 0x19337
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0x8306
testl %eax, %eax
je 0x19333
pushq $0x1
popq %r15
jmp 0x1935a
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 0x19354
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_UnsetCoreCommand
static int Jim_UnsetCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    int i = 1;
    int complain = 1;

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

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

    Jim_SetEmptyResult(interp);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rdi, %rbx
movslq %esi, %rcx
cmpl $0x2, %ecx
pushq $0x1
popq %rax
movq %rcx, -0x38(%rbp)
cmovgel %ecx, %eax
movl %eax, -0x2c(%rbp)
movb $0x1, %r13b
pushq $0x1
popq %r12
pushq $0x2
popq %r14
cmpq -0x38(%rbp), %r12
jge 0x193dc
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
leaq 0xf25e(%rip), %rdx      # 0x2860f
callq 0x7223
testl %eax, %eax
jne 0x193e5
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
leaq 0xd677(%rip), %rdx      # 0x26a3f
callq 0x7223
testl %eax, %eax
je 0x193e2
incq %r12
incl %r14d
xorl %r13d, %r13d
jmp 0x1939d
movl -0x2c(%rbp), %r14d
jmp 0x193e5
movl %r12d, %r14d
movzbl %r13b, %r12d
andl $0x1, %r12d
movslq %r14d, %r14
cmpq -0x38(%rbp), %r14
jge 0x19417
movq (%r15,%r14,8), %rsi
movq %rbx, %rdi
movl %r12d, %edx
callq 0xbccd
testl %eax, %eax
setne %al
incq %r14
testb %al, %r13b
je 0x193f0
pushq $0x1
popq %rax
jmp 0x19440
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 0x1943b
movq %rbx, %rdi
callq 0x73bf
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_O2/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 0x19482
leaq 0xef9b(%rip), %rcx      # 0x28409
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x72a5
jmp 0x194d1
movq 0x8(%r14), %rax
cmpl $0x3, %esi
jne 0x194be
leaq 0xefa7(%rip), %rdx      # 0x28439
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7223
testl %eax, %eax
je 0x194df
movq 0x10(%r14), %rdi
callq 0x7340
movq 0x19ac7(%rip), %rcx     # 0x32f78
movq (%rcx), %rsi
movq %rax, %rdi
callq 0x6230
jmp 0x194ce
movq %rax, %rdi
callq 0x7340
movq %rax, %rdi
callq 0x60f0
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xef37(%rip), %rsi      # 0x2841d
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x7363
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x19510
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
pushq $0x1
popq %r15
jmp 0x194d1
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq %rdi, %rbx
movq $0x1, -0x28(%rbp)
leal -0x4(%rsi), %eax
cmpl $-0x3, %eax
ja 0x19598
leaq 0xeede(%rip), %rcx      # 0x2845f
pushq $0x1
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x72a5
jmp 0x1967b
pushq $0x1
popq %r14
cmpl $0x3, %esi
jne 0x195b9
movq 0x10(%r15), %rsi
leaq -0x28(%rbp), %rdx
movq %rbx, %rdi
callq 0xcace
testl %eax, %eax
jne 0x1967b
movq 0x8(%r15), %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x9378
testq %rax, %rax
je 0x195f5
movq %rax, %r12
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc979
testl %eax, %eax
jne 0x1967b
cmpl $0x2, 0x10(%r12)
jl 0x19626
movq -0x30(%rbp), %rsi
jmp 0x195f7
xorl %esi, %esi
addq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0x8212
movq %rax, %r12
movq 0x8(%r15), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x8306
testl %eax, %eax
je 0x19657
movq %rbx, %rdi
movq %r12, %rsi
callq 0x73bf
jmp 0x1967b
movq %r12, %rdi
callq 0x94f7
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, 0x18(%r12)
movq 0x8(%r15), %rsi
leaq 0x18712(%rip), %rax     # 0x31d58
cmpq %rax, 0x8(%rsi)
je 0x19657
movq %rbx, %rdi
movq %r12, %rdx
callq 0x8306
incl 0x10(%r12)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x19675
movq %rbx, %rdi
callq 0x73bf
movq %r12, (%rbx)
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_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 0x19730
leaq -0x24(%rbp), %r12
andl $0x0, -0x24(%rbp)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0xeb85
testl %eax, %eax
jne 0x1974b
cmpl $0x0, -0x24(%rbp)
je 0x19704
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x8b54
testl %eax, %eax
je 0x196ad
movl %eax, %r15d
leal -0x3(%r15), %eax
cmpl $0x1, %eax
ja 0x196f8
movl 0x18(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x18(%rbx)
cmpl $0x1, %eax
jg 0x1974e
cmpl $0x4, %r15d
je 0x196ad
cmpl $0x3, %r15d
jne 0x1974e
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 0x19728
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %r15d, %r15d
jmp 0x1974e
leaq 0xed3c(%rip), %rcx      # 0x28473
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x72a5
jmp 0x1974e
movl %eax, %r15d
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_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
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x1, %esi
jg 0x19b86
leaq 0xe986(%rip), %rcx      # 0x284f5
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x72a5
jmp 0x19c34
movq 0x8(%r14), %rax
leaq -0x38(%rbp), %r12
movq %rax, (%r12)
andl $0x0, 0x8(%r12)
movl %esi, %r13d
pushq $0x2
popq %r15
movq %rbx, %rdi
cmpq %r15, %r13
je 0x19bd7
movq %r12, %rsi
callq 0x1f63a
testq %rax, %rax
jne 0x19bbb
movq 0x128(%rbx), %rax
movq (%r14,%r15,8), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x8306
incq %r15
testl %eax, %eax
je 0x19b9f
pushq $0x1
popq %r15
jmp 0x19c34
xorl %esi, %esi
xorl %edx, %edx
callq 0x745b
movq %rax, %r14
leaq -0x38(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1f619
testl %eax, %eax
jne 0x19c11
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1f63a
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x74ad
jmp 0x19be7
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x19c2e
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1a152
leaq 0xe4f5(%rip), %rcx      # 0x28636
pushq $0x1
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x72a5
jmp 0x1a1a7
movl %esi, %ecx
movq 0x8(%rdx), %rsi
addq $0x10, %rdx
addl $-0x2, %ecx
leaq -0x18(%rbp), %r8
movq %rbx, %rdi
xorl %r9d, %r9d
callq 0x1f673
testl %eax, %eax
js 0x1a17d
movl %eax, %r14d
jne 0x1a1a7
movq -0x18(%rbp), %r14
jmp 0x1a184
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 0x1a1a1
movq %rbx, %rdi
callq 0x73bf
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_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x2, %esi
jg 0x1a1da
leaq 0xe4a5(%rip), %rcx      # 0x2866e
pushq $0x1
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x72a5
jmp 0x1a23d
movl %esi, %ecx
leaq 0x10(%rdx), %r14
movq 0x8(%rdx), %rsi
cmpl $0x3, %ecx
jne 0x1a1fe
movq (%r14), %rdx
movq %rbx, %rdi
callq 0x8306
testl %eax, %eax
je 0x1a217
pushq $0x1
popq %r14
jmp 0x1a23d
movl %ecx, %eax
addl $-0x3, %ecx
movq -0x8(%rdx,%rax,8), %r8
movq %rbx, %rdi
movq %r14, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0xda0c
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 0x1a237
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1a8e8
leaq 0xde9c(%rip), %rcx      # 0x2876d
pushq $0x1
popq %r12
movq %rbx, %rdi
movl %r12d, %esi
movq %r15, %rdx
callq 0x72a5
jmp 0x1a9ac
movl %esi, %r12d
movq 0x8(%r15), %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x9378
testq %rax, %rax
je 0x1a920
movq %rax, %r14
cmpl $0x2, 0x10(%rax)
jl 0x1a939
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8a95
movq %rax, %r14
movq $0x0, -0x30(%rbp)
jmp 0x1a93f
movq $0x0, -0x30(%rbp)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x745b
movq %rax, %r14
jmp 0x1a93f
movb $0x1, %al
movq %rax, -0x30(%rbp)
movl %r12d, %r12d
pushq $0x2
popq %r13
cmpq %r12, %r13
jae 0x1a95f
movq (%r15,%r13,8), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x74ad
incq %r13
jmp 0x1a946
movq 0x8(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8306
testl %eax, %eax
je 0x1a989
pushq $0x1
popq %r12
cmpb $0x0, -0x30(%rbp)
jne 0x1a9ac
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73bf
jmp 0x1a9ac
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1a9a6
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_LinsertCoreCommand
static int Jim_LinsertCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    int idx, len;
    Jim_Obj *listPtr;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rdi, %rbx
cmpl $0x2, %esi
jg 0x1a9f6
leaq 0xdda8(%rip), %rcx      # 0x28787
pushq $0x1
popq %r12
movq %rbx, %rdi
movl %r12d, %esi
movq %r15, %rdx
callq 0x72a5
jmp 0x1aa99
movl %esi, %r12d
movq 0x8(%r15), %r14
cmpl $0x2, 0x10(%r14)
jl 0x1aa12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8a95
movq %rax, %r14
movq 0x10(%r15), %rsi
leaq -0x24(%rbp), %rdx
movq %rbx, %rdi
callq 0x7d46
testl %eax, %eax
je 0x1aa3d
pushq $0x1
popq %r12
cmpq 0x8(%r15), %r14
je 0x1aa99
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73bf
jmp 0x1aa99
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8b3c
movl -0x24(%rbp), %ecx
cmpl %eax, %ecx
jge 0x1aa5b
testl %ecx, %ecx
js 0x1aa57
movl %ecx, %eax
jmp 0x1aa5b
addl %ecx, %eax
incl %eax
addl $-0x3, %r12d
addq $0x18, %r15
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
movl %r12d, %ecx
movq %r15, %r8
callq 0xd900
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1aa93
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq