LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_GetCallFrameByLevel
Jim_CallFrame *Jim_GetCallFrameByLevel(Jim_Interp *interp, Jim_Obj *levelObjPtr)
{
    long level;
    const char *str;
    Jim_CallFrame *framePtr;

    if (levelObjPtr) {
        str = Jim_String(levelObjPtr);
        if (str[0] == '#') {
            char *endptr;

            level = jim_strtol(str + 1, &endptr);
            if (str[1] == '\0' || endptr[0] != '\0') {
                level = -1;
            }
        }
        else {
            if (Jim_GetLong(interp, levelObjPtr, &level) != JIM_OK || level < 0) {
                level = -1;
            }
            else {

                level = interp->framePtr->level - level;
            }
        }
    }
    else {
        str = "1";
        level = interp->framePtr->level - 1;
    }

    if (level == 0) {
        return interp->topFramePtr;
    }
    if (level > 0) {

        for (framePtr = interp->framePtr; framePtr; framePtr = framePtr->parent) {
            if (framePtr->level == level) {
                return framePtr;
            }
        }
    }

    Jim_SetResultFormatted(interp, "bad level \"%s\"", str);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0xd3ff
movq %rsi, %r15
cmpq $0x0, (%rsi)
jne 0xd3d0
movq 0x8(%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq (%r15), %r14
cmpb $0x23, (%r14)
jne 0xd413
leaq 0x1(%r14), %rdi
leaq -0x20(%rbp), %rsi
callq 0xd4a4
cmpb $0x0, 0x1(%r14)
je 0xd3f6
movq -0x20(%rbp), %rcx
cmpb $0x0, (%rcx)
je 0xd45a
movq $-0x1, %rax
jmp 0xd45a
movq 0x58(%rbx), %rax
movslq 0x8(%rax), %rax
decq %rax
leaq 0x1fbad(%rip), %r14     # 0x2cfbe
jmp 0xd45a
leaq 0x28ec6(%rip), %rax     # 0x362e0
cmpq %rax, 0x8(%r15)
je 0xd438
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0xd6d7
testl %eax, %eax
je 0xd438
movb $0x1, %al
jmp 0xd43e
movq 0x18(%r15), %rcx
xorl %eax, %eax
testq %rcx, %rcx
sets %dl
orb %al, %dl
movq $-0x1, %rax
jne 0xd45a
movq 0x58(%rbx), %rax
movslq 0x8(%rax), %rax
subq %rcx, %rax
testq %rax, %rax
je 0xd492
jle 0xd479
movq 0x58(%rbx), %r15
testq %r15, %r15
je 0xd479
movslq 0x8(%r15), %rcx
cmpq %rcx, %rax
je 0xd496
movq 0x48(%r15), %r15
jmp 0xd465
leaq 0x1eac3(%rip), %rsi     # 0x2bf43
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x692d
jmp 0xd496
movq 0x60(%rbx), %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: jim_strtol
static long jim_strtol(const char *str, char **endptr)
{
    int sign;
    int base;
    int i = JimNumberBase(str, &base, &sign);

    if (base != 0) {
        long value = strtol(str + i, endptr, base);
        if (endptr == NULL || *endptr != str + i) {
            return value * sign;
        }
    }


    return strtol(str, endptr, 10);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x64e0
movq (%rax), %rax
xorl %ecx, %ecx
movzbl (%r14,%rcx), %edx
incq %rcx
testb $0x20, 0x1(%rax,%rdx,2)
jne 0xd4bf
cmpl $0x2b, %edx
je 0xd4e4
cmpl $0x2d, %edx
jne 0xd4e1
movq $-0x1, %r12
jmp 0xd4ea
decq %rcx
movl $0x1, %r12d
movslq %ecx, %rcx
xorl %edx, %edx
cmpb $0x30, (%r14,%rcx)
jne 0xd56e
movzbl 0x1(%r14,%rcx), %edi
movl $0x10, %esi
cmpl $0x61, %edi
jg 0xd517
cmpl $0x4e, %edi
jg 0xd52d
cmpl $0x42, %edi
je 0xd54a
cmpl $0x44, %edi
je 0xd526
jmp 0xd56e
cmpl $0x6e, %edi
jg 0xd539
cmpl $0x62, %edi
je 0xd54a
cmpl $0x64, %edi
jne 0xd56e
movl $0xa, %esi
jmp 0xd54f
cmpl $0x4f, %edi
je 0xd543
cmpl $0x58, %edi
je 0xd54f
jmp 0xd56e
cmpl $0x78, %edi
je 0xd54f
cmpl $0x6f, %edi
jne 0xd56e
movl $0x8, %esi
jmp 0xd54f
movl $0x2, %esi
movzbl 0x2(%r14,%rcx), %edi
cmpl $0x2b, %edi
je 0xd56e
cmpl $0x2d, %edi
je 0xd56e
testb $0x20, 0x1(%rax,%rdi,2)
jne 0xd56e
addq $0x2, %rcx
movl %esi, %edx
jmp 0xd570
xorl %ecx, %ecx
testl %edx, %edx
je 0xd59d
movslq %ecx, %r15
addq %r14, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6310
testq %rbx, %rbx
je 0xd58f
cmpq %r15, (%rbx)
je 0xd597
imulq %r12, %rax
xorl %ecx, %ecx
jmp 0xd599
movb $0x1, %cl
testb %cl, %cl
je 0xd5b5
movq %r14, %rdi
movq %rbx, %rsi
movl $0xa, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6310
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_GetLong
int Jim_GetLong(Jim_Interp *interp, Jim_Obj *objPtr, long *longPtr)
{
    jim_wide wideValue;
    int retval;

    retval = Jim_GetWide(interp, objPtr, &wideValue);
    if (retval == JIM_OK) {
        *longPtr = (long)wideValue;
        return JIM_OK;
    }
    return JIM_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x28d0e(%rip), %rax     # 0x362e0
cmpq %rax, 0x8(%rsi)
je 0xd5ed
movq %r14, %rsi
movl $0x1, %edx
callq 0xd6d7
testl %eax, %eax
je 0xd5ed
xorl %edx, %edx
jmp 0xd5f3
movq 0x18(%r14), %rcx
movb $0x1, %dl
movl $0x1, %eax
testb %dl, %dl
je 0xd601
movq %rcx, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_SetAssocData
int Jim_SetAssocData(Jim_Interp *interp, const char *key, Jim_InterpDeleteProc * delProc,
    void *data)
{
    AssocDataValue *assocEntryPtr = (AssocDataValue *) Jim_Alloc(sizeof(AssocDataValue));

    assocEntryPtr->delProc = delProc;
    assocEntryPtr->data = data;
    return Jim_AddHashEntry(&interp->assocData, key, assocEntryPtr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x10, %esi
xorl %edi, %edi
callq *0x2ac5e(%rip)          # 0x38288
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
addq $0x1d8, %r12            # imm = 0x1D8
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa8c2
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_GetAssocData
void *Jim_GetAssocData(Jim_Interp *interp, const char *key)
{
    Jim_HashEntry *entryPtr = Jim_FindHashEntry(&interp->assocData, key);

    if (entryPtr != NULL) {
        AssocDataValue *assocEntryPtr = Jim_GetHashEntryVal(entryPtr);
        return assocEntryPtr->data;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0xac8e
testq %rax, %rax
je 0xd66d
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
jmp 0xd66f
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: SetIntFromAny
static int SetIntFromAny(Jim_Interp *interp, Jim_Obj *objPtr, int flags)
{
    jim_wide wideValue;
    const char *str;

    if (objPtr->typePtr == &coercedDoubleObjType) {

        objPtr->typePtr = &intObjType;
        return JIM_OK;
    }


    str = Jim_String(objPtr);

    if (Jim_StringToWide(str, &wideValue, 0) != JIM_OK) {
        if (flags & JIM_ERRMSG) {
            Jim_SetResultFormatted(interp, "expected integer but got \"%#s\"", objPtr);
        }
        return JIM_ERR;
    }
    if ((wideValue == JIM_WIDE_MIN || wideValue == JIM_WIDE_MAX) && errno == ERANGE) {
        Jim_SetResultString(interp, "Integer value too big to be represented", -1);
        return JIM_ERR;
    }

    Jim_FreeIntRep(interp, objPtr);
    objPtr->typePtr = &intObjType;
    objPtr->internalRep.wideValue = wideValue;
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq 0x8(%rsi), %rax
leaq 0x28c12(%rip), %rcx     # 0x36308
cmpq %rcx, %rax
je 0xd75c
movl %edx, %r12d
movq %rdi, -0x30(%rbp)
cmpq $0x0, (%r14)
jne 0xd70e
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %r13
leaq -0x38(%rbp), %rbx
movq %r13, %rdi
movq %rbx, %rsi
callq 0xd4a4
movq %rax, %r15
movq (%rbx), %rsi
movq %r13, %rdi
callq 0xa5b8
testl %eax, %eax
je 0xd76c
movl $0x1, %r15d
testb $0x1, %r12b
je 0xd7f8
leaq 0x1f53d(%rip), %rsi     # 0x2cc86
movq -0x30(%rbp), %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x692d
jmp 0xd7f8
leaq 0x28b7d(%rip), %rax     # 0x362e0
movq %rax, 0x8(%r14)
jmp 0xd7f5
movabsq $-0x7fffffffffffffff, %rax # imm = 0x8000000000000001
addq %r15, %rax
cmpq $0x1, %rax
ja 0xd7cb
callq 0x6080
cmpl $0x22, (%rax)
jne 0xd7cb
leaq 0x1f515(%rip), %rsi     # 0x2cca5
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0xd7c0
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
movl $0x1, %r15d
jmp 0xd7f8
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xd7e6
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xd7e6
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq *%rax
leaq 0x28af3(%rip), %rax     # 0x362e0
movq %rax, 0x8(%r14)
movq %r15, 0x18(%r14)
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_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_GetWideExpr
int Jim_GetWideExpr(Jim_Interp *interp, Jim_Obj *objPtr, jim_wide * widePtr)
{
    int ret = JIM_OK;

    if (objPtr->typePtr == &sourceObjType || objPtr->typePtr == NULL) {
        SetIntFromAny(interp, objPtr, 0);
    }
    if (objPtr->typePtr == &intObjType) {
        *widePtr = JimWideValue(objPtr);
    }
    else {
        JimPanic((interp->safeexpr, "interp->safeexpr is set"));
        interp->safeexpr++;
        ret = Jim_EvalExpression(interp, objPtr);
        interp->safeexpr--;

        if (ret == JIM_OK) {
            ret = Jim_GetWide(interp, Jim_GetResult(interp), widePtr);
        }
        if (ret != JIM_OK) {
            Jim_SetResultFormatted(interp, "expected integer expression but got \"%#s\"", objPtr);
        }
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
leaq 0x289ac(%rip), %rcx     # 0x361d8
cmpq %rcx, %rax
setne %cl
testq %rax, %rax
setne %al
testb %al, %cl
jne 0xd849
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xd6d7
leaq 0x28a90(%rip), %r13     # 0x362e0
cmpq %r13, 0x8(%rbx)
je 0xd8c1
incl 0xb0(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd8dd
movl %eax, %r12d
decl 0xb0(%r14)
testl %eax, %eax
jne 0xd8a6
movq (%r14), %rax
cmpq %r13, 0x8(%rax)
movq %rax, %r13
je 0xd89c
movl $0x1, %r12d
movq %r14, %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0xd6d7
testl %eax, %eax
jne 0xd8a6
movq 0x18(%r13), %rax
movq %rax, (%r15)
xorl %r12d, %r12d
testl %r12d, %r12d
je 0xd8c8
leaq 0x1e6a0(%rip), %rsi     # 0x2bf52
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x692d
jmp 0xd8cb
movq 0x18(%rbx), %rax
movq %rax, (%r15)
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_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_GetDouble
int Jim_GetDouble(Jim_Interp *interp, Jim_Obj *objPtr, double *doublePtr)
{
    if (objPtr->typePtr == &coercedDoubleObjType) {
        *doublePtr = JimWideValue(objPtr);
        return JIM_OK;
    }
    if (objPtr->typePtr != &doubleObjType && SetDoubleFromAny(interp, objPtr) == JIM_ERR)
        return JIM_ERR;

    if (objPtr->typePtr == &coercedDoubleObjType) {
        *doublePtr = JimWideValue(objPtr);
    }
    else {
        *doublePtr = objPtr->internalRep.doubleValue;
    }
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rsi), %rax
leaq 0x2828f(%rip), %rcx     # 0x36308
cmpq %rcx, %rax
je 0xe16d
leaq 0x282a7(%rip), %rdx     # 0x36330
cmpq %rdx, %rax
je 0xe15f
movq %rdi, -0x30(%rbp)
cmpq $0x0, (%r14)
jne 0xe0a2
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %r13
leaq -0x40(%rbp), %r12
movq %r13, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x6460
movq %rax, %r15
movq (%r12), %rsi
movq %r13, %rdi
callq 0xa5b8
testl %eax, %eax
je 0xe0fb
leaq -0x38(%rbp), %rsi
movq %r13, %rdi
callq 0xa611
testl %eax, %eax
je 0xe127
leaq 0x1ec08(%rip), %rsi     # 0x2cceb
movq -0x30(%rbp), %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x692d
movl $0x1, %eax
jmp 0xe17c
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xe116
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xe116
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq *%rax
leaq 0x281eb(%rip), %rcx     # 0x36308
movq %rcx, 0x8(%r14)
movq %r15, 0x18(%r14)
jmp 0xe15f
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xe142
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xe142
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq *%rax
leaq 0x281e7(%rip), %rax     # 0x36330
movq %rax, 0x8(%r14)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x18(%r14)
leaq 0x281a9(%rip), %rcx     # 0x36308
cmpq %rcx, 0x8(%r14)
je 0xe16d
movsd 0x18(%r14), %xmm0
jmp 0xe176
xorps %xmm0, %xmm0
cvtsi2sdq 0x18(%r14), %xmm0
movsd %xmm0, (%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_NewDoubleObj
Jim_Obj *Jim_NewDoubleObj(Jim_Interp *interp, double doubleValue)
{
    Jim_Obj *objPtr;

    objPtr = Jim_NewObj(interp);
    objPtr->typePtr = &doubleObjType;
    objPtr->bytes = NULL;
    objPtr->internalRep.doubleValue = doubleValue;
    return objPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
callq 0xae58
leaq 0x2818c(%rip), %rcx     # 0x36330
movq %rcx, 0x8(%rax)
movq $0x0, (%rax)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_GetBoolean
int Jim_GetBoolean(Jim_Interp *interp, Jim_Obj *objPtr, int * booleanPtr)
{
    if (objPtr->typePtr != &intObjType && SetBooleanFromAny(interp, objPtr, JIM_ERRMSG) == JIM_ERR)
        return JIM_ERR;
    *booleanPtr = (int) JimWideValue(objPtr);
    return JIM_OK;
}

// 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 0x8(%rsi), %rax
leaq 0x28102(%rip), %rcx     # 0x362e0
cmpq %rcx, %rax
je 0xe27f
movq %rdi, -0x30(%rbp)
cmpq $0x0, (%r14)
jne 0xe1f7
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %r12
leaq 0x28bff(%rip), %r15     # 0x36e00
xorl %r13d, %r13d
movq (%r15), %rdi
testq %rdi, %rdi
je 0xe218
movq %r12, %rsi
callq 0x62e0
testl %eax, %eax
je 0xe22b
incq %r13
addq $0x8, %r15
cmpq $0x8, %r13
jne 0xe204
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
testl %r13d, %r13d
js 0xe265
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xe24b
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xe24b
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq *%rax
leaq 0x2808e(%rip), %rax     # 0x362e0
movq %rax, 0x8(%r14)
xorl %eax, %eax
cmpl $0x4, %r13d
setl %al
movq %rax, 0x18(%r14)
jmp 0xe27a
leaq 0x1eaac(%rip), %rsi     # 0x2cd18
movq -0x30(%rbp), %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x692d
testl %r13d, %r13d
js 0xe289
movl 0x18(%r14), %eax
movl %eax, (%rbx)
xorl %eax, %eax
jmp 0xe28e
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_O1/msteveb[P]autosetup/./jimsh0.c
// Function: ListInsertElements
static void ListInsertElements(Jim_Obj *listPtr, int idx, int elemc, Jim_Obj *const *elemVec)
{
    int currentLen = listPtr->internalRep.listValue.len;
    int requiredLen = currentLen + elemc;
    int i;
    Jim_Obj **point;

    if (elemc == 0) {

        return;
    }

    if (requiredLen > listPtr->internalRep.listValue.maxLen) {
        if (currentLen) {

            requiredLen *= 2;
        }
        ListEnsureLength(listPtr, requiredLen);
    }
    if (idx < 0) {
        idx = currentLen;
    }
    point = listPtr->internalRep.listValue.ele + idx;
    memmove(point + elemc, point, (currentLen - idx) * sizeof(Jim_Obj *));
    for (i = 0; i < elemc; ++i) {
        point[i] = elemVec[i];
        Jim_IncrRefCount(point[i]);
    }
    listPtr->internalRep.listValue.len += elemc;
}

// Assembly:
testl %edx, %edx
je 0xe337
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebx
movl %esi, %r12d
movq %rdi, %r15
movl 0x20(%rdi), %r13d
leal (%rbx,%r13), %esi
cmpl 0x24(%rdi), %esi
jle 0xe2db
addl %esi, %esi
testl %r13d, %r13d
cmovel %ebx, %esi
movq %r15, %rdi
callq 0x19865
testl %r12d, %r12d
cmovsl %r13d, %r12d
movslq %r12d, %rax
leaq (,%rax,8), %r12
addq 0x18(%r15), %r12
movslq %ebx, %rcx
leaq (%r12,%rcx,8), %rdi
subl %eax, %r13d
movslq %r13d, %rdx
shlq $0x3, %rdx
movq %r12, %rsi
callq 0x6400
testl %ebx, %ebx
jle 0xe325
movl %ebx, %eax
xorl %ecx, %ecx
movq (%r14,%rcx,8), %rdx
movq %rdx, (%r12,%rcx,8)
incl 0x10(%rdx)
incq %rcx
cmpq %rcx, %rax
jne 0xe312
addl %ebx, 0x20(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_ListAppendList
void Jim_ListAppendList(Jim_Interp *interp, Jim_Obj *listPtr, Jim_Obj *appendListPtr)
{
    JimPanic((Jim_IsShared(listPtr), "Jim_ListAppendList called with shared object"));
    SetListFromAny(interp, listPtr);
    SetListFromAny(interp, appendListPtr);
    Jim_InvalidateStringRep(listPtr);
    ListAppendList(listPtr, appendListPtr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0xe338
movq %r15, %rdi
movq %r14, %rsi
callq 0xe338
movq (%rbx), %rdi
testq %rdi, %rdi
sete %al
leaq 0x29ade(%rip), %rcx     # 0x38298
cmpq %rcx, %rdi
sete %cl
orb %al, %cl
jne 0xe7cc
xorl %esi, %esi
callq *0x29abc(%rip)          # 0x38288
movq $0x0, (%rbx)
movl 0x20(%r14), %edx
movq 0x18(%r14), %rcx
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe29d
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_ListInsertElements
void Jim_ListInsertElements(Jim_Interp *interp, Jim_Obj *listPtr, int idx,
    int objc, Jim_Obj *const *objVec)
{
    JimPanic((Jim_IsShared(listPtr), "Jim_ListInsertElement called with shared object"));
    SetListFromAny(interp, listPtr);
    if (idx >= 0 && idx > listPtr->internalRep.listValue.len)
        idx = listPtr->internalRep.listValue.len;
    else if (idx < 0)
        idx = 0;
    Jim_InvalidateStringRep(listPtr);
    ListInsertElements(listPtr, idx, objc, objVec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %r14d
movl %edx, %r13d
movq %rsi, %r15
callq 0xe338
testl %r13d, %r13d
js 0xe81f
movl 0x20(%r15), %r12d
cmpl %r13d, %r12d
jl 0xe829
xorl %r12d, %r12d
testl %r13d, %r13d
cmovgl %r13d, %r12d
movq (%r15), %rdi
testq %rdi, %rdi
sete %al
leaq 0x29a5f(%rip), %rcx     # 0x38298
cmpq %rcx, %rdi
sete %cl
orb %al, %cl
jne 0xe84b
xorl %esi, %esi
callq *0x29a3d(%rip)          # 0x38288
movq $0x0, (%r15)
movq %r15, %rdi
movl %r12d, %esi
movl %r14d, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe29d
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_ListGetIndex
Jim_Obj *Jim_ListGetIndex(Jim_Interp *interp, Jim_Obj *listPtr, int idx)
{
    SetListFromAny(interp, listPtr);
    if ((idx >= 0 && idx >= listPtr->internalRep.listValue.len) ||
        (idx < 0 && (-idx - 1) >= listPtr->internalRep.listValue.len)) {
        return NULL;
    }
    if (idx < 0)
        idx = listPtr->internalRep.listValue.len + idx;
    return listPtr->internalRep.listValue.ele[idx];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
callq 0xe338
testl %ebx, %ebx
js 0xe88c
cmpl %ebx, 0x20(%r14)
jle 0xe8ab
testl %ebx, %ebx
jns 0xe89e
movl %ebx, %ecx
notl %ecx
movl 0x20(%r14), %eax
cmpl %ecx, %eax
jle 0xe8ab
addl %eax, %ebx
movq 0x18(%r14), %rax
movslq %ebx, %rcx
movq (%rax,%rcx,8), %rax
jmp 0xe8ad
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_ListIndex
int Jim_ListIndex(Jim_Interp *interp, Jim_Obj *listPtr, int idx, Jim_Obj **objPtrPtr, int flags)
{
    *objPtrPtr = Jim_ListGetIndex(interp, listPtr, idx);
    if (*objPtrPtr == NULL) {
        if (flags & JIM_ERRMSG) {
            Jim_SetResultString(interp, "list index out of range", -1);
        }
        return JIM_ERR;
    }
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %r15d
movq %rcx, %r14
movq %rdi, %rbx
callq 0xe871
movq %rax, (%r14)
xorl %r14d, %r14d
testq %rax, %rax
jne 0xe917
movl $0x1, %r14d
testb $0x1, %r15b
je 0xe917
leaq 0x1d694(%rip), %rsi     # 0x2bf7c
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rax, %r15
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0xe914
movq %rbx, %rdi
callq 0x759a
movq %r15, (%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: ListSetIndex
static int ListSetIndex(Jim_Interp *interp, Jim_Obj *listPtr, int idx,
    Jim_Obj *newObjPtr, int flags)
{
    SetListFromAny(interp, listPtr);
    if ((idx >= 0 && idx >= listPtr->internalRep.listValue.len) ||
        (idx < 0 && (-idx - 1) >= listPtr->internalRep.listValue.len)) {
        if (flags & JIM_ERRMSG) {
            Jim_SetResultString(interp, "list index out of range", -1);
        }
        return JIM_ERR;
    }
    if (idx < 0)
        idx = listPtr->internalRep.listValue.len + idx;
    Jim_DecrRefCount(interp, listPtr->internalRep.listValue.ele[idx]);
    listPtr->internalRep.listValue.ele[idx] = newObjPtr;
    Jim_IncrRefCount(newObjPtr);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r13d
movq %rcx, %r14
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
callq 0xe338
testl %r12d, %r12d
js 0xeb67
cmpl %r12d, 0x20(%r15)
jle 0xebb6
testl %r12d, %r12d
jns 0xeb7c
movl %r12d, %ecx
notl %ecx
movl 0x20(%r15), %eax
cmpl %ecx, %eax
jle 0xebb6
addl %eax, %r12d
movq 0x18(%r15), %rax
movslq %r12d, %r12
movq (%rax,%r12,8), %rax
movl 0x10(%rax), %ecx
leal -0x1(%rcx), %edx
movl %edx, 0x10(%rax)
cmpl $0x1, %ecx
jg 0xeba5
movq 0x18(%r15), %rax
movq (%rax,%r12,8), %rsi
movq %rbx, %rdi
callq 0x759a
movq 0x18(%r15), %rax
movq %r14, (%rax,%r12,8)
incl 0x10(%r14)
xorl %r14d, %r14d
jmp 0xebf8
movl $0x1, %r14d
testb $0x1, %r13b
je 0xebf8
leaq 0x1d3b3(%rip), %rsi     # 0x2bf7c
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rax, %r15
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0xebf5
movq %rbx, %rdi
callq 0x759a
movq %r15, (%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_ListJoin
Jim_Obj *Jim_ListJoin(Jim_Interp *interp, Jim_Obj *listObjPtr, const char *joinStr, int joinStrLen)
{
    int i;
    int listLen = Jim_ListLength(interp, listObjPtr);
    Jim_Obj *resObjPtr = Jim_NewEmptyStringObj(interp);

    for (i = 0; i < listLen; ) {
        Jim_AppendObj(interp, resObjPtr, Jim_ListGetIndex(interp, listObjPtr, i));
        if (++i != listLen) {
            Jim_AppendString(interp, resObjPtr, joinStr, joinStrLen);
        }
    }
    return resObjPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, -0x2c(%rbp)
movq %rdx, -0x38(%rbp)
movq %rsi, %r15
movq %rdi, %r12
callq 0xe338
movl 0x20(%r15), %r14d
movq %r12, %rdi
callq 0xae58
movq %rax, %r13
leaq 0x29655(%rip), %rax     # 0x38298
movq %rax, (%r13)
movl $0x0, 0x14(%r13)
movq $0x0, 0x8(%r13)
testl %r14d, %r14d
jle 0xeca0
negl %r14d
xorl %ebx, %ebx
movq %r12, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0xe871
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xafb0
leal (%r14,%rbx), %eax
cmpl $-0x1, %eax
je 0xec97
movq %r12, %rdi
movq %r13, %rsi
movq -0x38(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x8653
incl %ebx
movl %r14d, %eax
addl %ebx, %eax
jne 0xec61
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_ListRange
Jim_Obj *Jim_ListRange(Jim_Interp *interp, Jim_Obj *listObjPtr, Jim_Obj *firstObjPtr,
    Jim_Obj *lastObjPtr)
{
    int first, last;
    int len, rangeLen;

    if (Jim_GetIndex(interp, firstObjPtr, &first) != JIM_OK ||
        Jim_GetIndex(interp, lastObjPtr, &last) != JIM_OK)
        return NULL;
    len = Jim_ListLength(interp, listObjPtr);
    first = JimRelToAbsIndex(len, first);
    last = JimRelToAbsIndex(len, last);
    JimRelToAbsRange(len, &first, &last, &rangeLen);
    if (first == 0 && last == len) {
        return listObjPtr;
    }
    return Jim_NewListObj(interp, listObjPtr->internalRep.listValue.ele + first, rangeLen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x80b2
testl %eax, %eax
jne 0xef48
leaq -0x1c(%rbp), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x80b2
xorl %r15d, %r15d
testl %eax, %eax
je 0xef58
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe338
movl 0x20(%rbx), %eax
movl -0x20(%rbp), %ecx
movl $0x80000002, %edx       # imm = 0x80000002
cmpl %edx, %ecx
movl $0x0, %esi
cmovael %eax, %esi
addl %ecx, %esi
movl %esi, -0x20(%rbp)
movl -0x1c(%rbp), %edi
cmpl %edx, %edi
movl $0x0, %ecx
cmovael %eax, %ecx
addl %edi, %ecx
movl %ecx, -0x1c(%rbp)
movl %ecx, %edx
subl %esi, %edx
jl 0xefbf
incl %edx
je 0xefbf
testl %esi, %esi
jns 0xefa7
leal 0x1(%rcx), %edx
movl $0x0, -0x20(%rbp)
cmpl %eax, %ecx
jge 0xefb0
movl %edx, %r15d
jmp 0xefbf
leal -0x1(%rax), %esi
movl %esi, -0x1c(%rbp)
movl %esi, %r15d
subl %ecx, %r15d
addl %edx, %r15d
movslq -0x20(%rbp), %rsi
testq %rsi, %rsi
jne 0xefd1
cmpl %eax, -0x1c(%rbp)
je 0xef4a
xorl %edx, %edx
testl %r15d, %r15d
cmovgl %r15d, %edx
shlq $0x3, %rsi
addq 0x18(%rbx), %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7640
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimRelToAbsRange
static void JimRelToAbsRange(int len, int *firstPtr, int *lastPtr, int *rangeLenPtr)
{
    int rangeLen;

    if (*firstPtr > *lastPtr) {
        rangeLen = 0;
    }
    else {
        rangeLen = *lastPtr - *firstPtr + 1;
        if (rangeLen) {
            if (*firstPtr < 0) {
                rangeLen += *firstPtr;
                *firstPtr = 0;
            }
            if (*lastPtr >= len) {
                rangeLen -= (*lastPtr - (len - 1));
                *lastPtr = len - 1;
            }
        }
    }
    if (rangeLen < 0)
        rangeLen = 0;

    *rangeLenPtr = rangeLen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rsi), %r11d
movl (%rdx), %r9d
xorl %eax, %eax
movl %r9d, %r8d
movl $0x0, %r10d
subl %r11d, %r8d
jl 0xf042
incl %r8d
je 0xf042
testl %r11d, %r11d
jns 0xf024
incl %r9d
movl $0x0, (%rsi)
movl %r9d, %r8d
movl (%rdx), %esi
cmpl %edi, %esi
jge 0xf02f
movl %r8d, %r10d
jmp 0xf042
movl %edi, %r9d
decl %r9d
leal (%r8,%rdi), %r10d
decl %r10d
subl %esi, %r10d
movl %r9d, (%rdx)
testl %r10d, %r10d
cmovgl %r10d, %eax
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_DictAddElement
int Jim_DictAddElement(Jim_Interp *interp, Jim_Obj *objPtr,
    Jim_Obj *keyObjPtr, Jim_Obj *valueObjPtr)
{
    JimPanic((Jim_IsShared(objPtr), "Jim_DictAddElement called with shared object"));
    if (SetDictFromAny(interp, objPtr) != JIM_OK) {
        return JIM_ERR;
    }
    Jim_InvalidateStringRep(objPtr);
    return DictAddElement(interp, objPtr, keyObjPtr, valueObjPtr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0xf0bd
testl %eax, %eax
je 0xf07b
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %rdi
testq %rdi, %rdi
sete %al
leaq 0x2920d(%rip), %rcx     # 0x38298
cmpq %rcx, %rdi
sete %cl
orb %al, %cl
jne 0xf09d
xorl %esi, %esi
callq *0x291eb(%rip)          # 0x38288
movq $0x0, (%r15)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf287
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_NewDictObj
Jim_Obj *Jim_NewDictObj(Jim_Interp *interp, Jim_Obj *const *elements, int len)
{
    Jim_Obj *objPtr;
    int i;

    JimPanic((len % 2, "Jim_NewDictObj() 'len' argument must be even"));

    objPtr = Jim_NewObj(interp);
    objPtr->typePtr = &dictObjType;
    objPtr->bytes = NULL;

    objPtr->internalRep.dictValue = JimDictNew(interp, len, len);
    for (i = 0; i < len; i += 2)
        DictAddElement(interp, objPtr, elements[i], elements[i + 1]);
    return objPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0xae58
movq %rax, %r12
leaq 0x26f5e(%rip), %rax     # 0x36380
movq %rax, 0x8(%r12)
movq $0x0, (%r12)
movl %ebx, %edi
movl %ebx, %esi
callq 0xf473
movq %rax, 0x18(%r12)
testl %ebx, %ebx
jle 0xf461
xorl %r13d, %r13d
movq (%r14,%r13,8), %rdx
movq 0x8(%r14,%r13,8), %rcx
movq %r15, %rdi
movq %r12, %rsi
callq 0xf287
addq $0x2, %r13
cmpl %ebx, %r13d
jl 0xf444
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimDictNew
static Jim_Dict *JimDictNew(Jim_Interp *interp, int table_size, int ht_size)
{
    Jim_Dict *dict = Jim_Alloc(sizeof(*dict));
    memset(dict, 0, sizeof(*dict));

    if (ht_size) {
        JimDictExpandHashTable(dict, ht_size);
    }
    if (table_size) {
        dict->table = Jim_Alloc(table_size * sizeof(*dict->table));
        dict->maxLen = table_size;
    }
#ifdef JIM_RANDOMISE_HASH
    dict->uniq = (rand() ^ time(NULL) ^ clock());
#endif
    return dict;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movl %edi, %ebx
movl $0x30, %esi
xorl %edi, %edi
callq *0x28df9(%rip)          # 0x38288
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
testl %r15d, %r15d
je 0xf4b0
movq %r14, %rdi
movl %r15d, %esi
callq 0x19906
testl %ebx, %ebx
je 0xf4cb
movslq %ebx, %rsi
shlq $0x3, %rsi
xorl %edi, %edi
callq *0x28dc5(%rip)          # 0x38288
movq %rax, 0x18(%r14)
movl %ebx, 0x24(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_DictKey
int Jim_DictKey(Jim_Interp *interp, Jim_Obj *dictPtr, Jim_Obj *keyPtr,
    Jim_Obj **objPtrPtr, int flags)
{
    int tvoffset;
    Jim_Dict *dict;

    if (SetDictFromAny(interp, dictPtr) != JIM_OK) {
        return -1;
    }
    dict = dictPtr->internalRep.dictValue;
    tvoffset = JimDictHashFind(dict, keyPtr, DICT_HASH_FIND);
    if (tvoffset == 0) {
        if (flags & JIM_ERRMSG) {
            Jim_SetResultFormatted(interp, "key \"%#s\" not known in dictionary", keyPtr);
        }
        return JIM_ERR;
    }
    *objPtrPtr = dict->table[tvoffset];
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, -0x2c(%rbp)
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
callq 0xf0bd
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0xf552
movq 0x18(%r12), %r12
movq %r12, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xf564
testl %eax, %eax
je 0xf532
movq 0x18(%r12), %rcx
cltq
movq (%rcx,%rax,8), %rax
movq %rax, (%rbx)
xorl %r13d, %r13d
jmp 0xf552
movl $0x1, %r13d
testb $0x1, -0x2c(%rbp)
je 0xf552
leaq 0x1ca68(%rip), %rsi     # 0x2bfad
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x692d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_DictPairs
Jim_Obj **Jim_DictPairs(Jim_Interp *interp, Jim_Obj *dictPtr, int *len)
{

    if (Jim_IsList(dictPtr)) {
        Jim_Obj **table;
        JimListGetElements(interp, dictPtr, len, &table);
        if (*len % 2 == 0) {
            return table;
        }

    }
    if (SetDictFromAny(interp, dictPtr) != JIM_OK) {

        *len = 1;
        return NULL;
    }
    *len = dictPtr->internalRep.dictValue->len;
    return dictPtr->internalRep.dictValue->table;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x26c9c(%rip), %rax     # 0x36358
cmpq %rax, 0x8(%rsi)
jne 0xf6dd
movq %r15, %rdi
movq %rbx, %rsi
callq 0xe338
movl 0x20(%rbx), %eax
movl %eax, (%r14)
testb $0x1, %al
jne 0xf6dd
movq 0x18(%rbx), %rax
jmp 0xf709
movq %r15, %rdi
movq %rbx, %rsi
callq 0xf0bd
testl %eax, %eax
je 0xf6f7
movl $0x1, (%r14)
xorl %eax, %eax
jmp 0xf709
movq 0x18(%rbx), %rax
movl 0x20(%rax), %eax
movl %eax, (%r14)
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_DictKeysVector
int Jim_DictKeysVector(Jim_Interp *interp, Jim_Obj *dictPtr,
    Jim_Obj *const *keyv, int keyc, Jim_Obj **objPtrPtr, int flags)
{
    int i;

    if (keyc == 0) {
        *objPtrPtr = dictPtr;
        return JIM_OK;
    }

    for (i = 0; i < keyc; i++) {
        Jim_Obj *objPtr;

        int rc = Jim_DictKey(interp, dictPtr, keyv[i], &objPtr, flags);
        if (rc != JIM_OK) {
            return rc;
        }
        dictPtr = objPtr;
    }
    *objPtrPtr = dictPtr;
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, -0x2c(%rbp)
movq %r8, -0x38(%rbp)
testl %ecx, %ecx
jle 0xf764
movq %rdx, %r15
movq %rdi, %r12
movl %ecx, %ebx
xorl %r14d, %r14d
movq (%r15,%r14,8), %rdx
movq %r12, %rdi
leaq -0x40(%rbp), %rcx
movl -0x2c(%rbp), %r8d
callq 0xf4d9
testl %eax, %eax
cmovnel %eax, %r13d
jne 0xf76e
movq -0x40(%rbp), %rsi
incq %r14
cmpq %r14, %rbx
jne 0xf73c
movq -0x38(%rbp), %rax
movq %rsi, (%rax)
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_GetReturnCode
int Jim_GetReturnCode(Jim_Interp *interp, Jim_Obj *objPtr, int *intPtr)
{
    if (objPtr->typePtr != &returnCodeObjType && SetReturnCodeFromAny(interp, objPtr) == JIM_ERR)
        return JIM_ERR;
    *intPtr = objPtr->internalRep.intValue;
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq 0x8(%rsi), %rax
leaq 0x26931(%rip), %r12     # 0x36418
cmpq %r12, %rax
je 0xfb84
movq %rdi, %r15
leaq 0x267e6(%rip), %rcx     # 0x362e0
cmpq %rcx, %rax
je 0xfb15
xorl %r13d, %r13d
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xd6d7
testl %eax, %eax
je 0xfb15
jmp 0xfb1b
movl 0x18(%rbx), %eax
movb $0x1, %r13b
testb %r13b, %r13b
je 0xfb25
movl %eax, -0x2c(%rbp)
jmp 0xfb60
leaq 0x268a4(%rip), %rdx     # 0x363d0
leaq -0x2c(%rbp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x7e97
testl %eax, %eax
je 0xfb60
leaq 0x1d2f9(%rip), %rsi     # 0x2ce45
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x692d
movl $0x1, %eax
jmp 0xfb8c
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xfb7a
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xfb7a
movq %r15, %rdi
movq %rbx, %rsi
callq *%rax
movq %r12, 0x8(%rbx)
movl -0x2c(%rbp), %eax
movl %eax, 0x18(%rbx)
movl 0x18(%rbx), %eax
movl %eax, (%r14)
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_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_GetBoolFromExpr
int Jim_GetBoolFromExpr(Jim_Interp *interp, Jim_Obj *exprObjPtr, int *boolPtr)
{
    int retcode = Jim_EvalExpression(interp, exprObjPtr);

    if (retcode == JIM_OK) {
        switch (ExprBool(interp, Jim_GetResult(interp))) {
            case 0:
                *boolPtr = 0;
                break;

            case 1:
                *boolPtr = 1;
                break;

            case -1:
                retcode = JIM_ERR;
                break;
        }
    }
    return retcode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
callq 0xd8dd
testl %eax, %eax
jne 0xfce8
movq (%r14), %rsi
movq %r14, %rdi
callq 0xfced
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x1, %ecx
ja 0xfce8
movl %ecx, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: ExprBool
static int ExprBool(Jim_Interp *interp, Jim_Obj *obj)
{
    long l;
    double d;
    int b;
    int ret = -1;


    Jim_IncrRefCount(obj);

    if (Jim_GetLong(interp, obj, &l) == JIM_OK) {
        ret = (l != 0);
    }
    else if (Jim_GetDouble(interp, obj, &d) == JIM_OK) {
        ret = (d != 0);
    }
    else if (Jim_GetBoolean(interp, obj, &b) == JIM_OK) {
        ret = (b != 0);
    }

    Jim_DecrRefCount(interp, obj);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
incl 0x10(%rsi)
movq %rdi, %r14
leaq 0x265d6(%rip), %rax     # 0x362e0
cmpq %rax, 0x8(%rsi)
je 0xfd2c
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0xd6d7
xorl %r15d, %r15d
movl $0x0, %ecx
testl %eax, %eax
jne 0xfd3a
xorl %r15d, %r15d
cmpq $0x0, 0x18(%rbx)
setne %r15b
movb $0x1, %cl
testb %cl, %cl
jne 0xfd8a
leaq -0x28(%rbp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe057
testl %eax, %eax
je 0xfd77
leaq -0x1c(%rbp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe1bf
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0xfd8a
xorl %r15d, %r15d
cmpl $0x0, -0x1c(%rbp)
setne %r15b
jmp 0xfd8a
xorpd %xmm0, %xmm0
cmpneqsd -0x28(%rbp), %xmm0
movq %xmm0, %r15
andl $0x1, %r15d
movl 0x10(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
cmpl $0x1, %eax
jg 0xfda3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x759a
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_EvalObjVector
int Jim_EvalObjVector(Jim_Interp *interp, int objc, Jim_Obj *const *objv)
{
    int i, retcode;
    Jim_EvalFrame frame;


    for (i = 0; i < objc; i++)
        Jim_IncrRefCount(objv[i]);


    JimPushEvalFrame(interp, &frame, NULL);

    retcode = JimInvokeCommand(interp, objc, objv);

    JimPopEvalFrame(interp);


    for (i = 0; i < objc; i++)
        Jim_DecrRefCount(interp, objv[i]);

    return retcode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
movl %esi, %r13d
testl %esi, %esi
jle 0x10594
xorl %eax, %eax
movq (%rbx,%rax,8), %rcx
incl 0x10(%rcx)
incq %rax
cmpq %rax, %r13
jne 0x10585
xorps %xmm0, %xmm0
leaq -0x60(%rbp), %rax
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq $0x0, 0x30(%rax)
movq 0x108(%r14), %rcx
movq %rcx, 0x18(%rax)
movl 0x8(%rcx), %edx
incl %edx
movl %edx, 0x8(%rax)
movl 0x110(%r14), %edx
movl %edx, 0xc(%rax)
movq 0x58(%r14), %rdx
movq %rdx, (%rax)
movq 0x30(%rcx), %rcx
movq %rcx, 0x30(%rax)
movq %rax, 0x108(%r14)
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x10640
movl %eax, %r12d
movq 0x108(%r14), %rax
movq 0x18(%rax), %rax
movq %rax, 0x108(%r14)
testl %r15d, %r15d
jle 0x1062e
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x10626
movq %r14, %rdi
callq 0x759a
incq %r15
cmpq %r15, %r13
jne 0x1060c
movl %r12d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_EvalObjPrefix
int Jim_EvalObjPrefix(Jim_Interp *interp, Jim_Obj *prefix, int objc, Jim_Obj *const *objv)
{
    int ret;
    Jim_Obj **nargv = Jim_Alloc((objc + 1) * sizeof(*nargv));

    nargv[0] = prefix;
    memcpy(&nargv[1], &objv[0], sizeof(nargv[0]) * objc);
    ret = Jim_EvalObjVector(interp, objc + 1, nargv);
    Jim_Free(nargv);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
movslq %edx, %r12
leal 0x1(%rdx), %r13d
leaq 0x8(,%r12,8), %rsi
xorl %edi, %edi
callq *0x2791e(%rip)          # 0x38288
movq %rax, %r15
movq %r14, (%rax)
leaq 0x8(%rax), %rdi
shlq $0x3, %r12
movq %rbx, %rsi
movq %r12, %rdx
callq 0x6320
movq -0x30(%rbp), %rdi
movl %r13d, %esi
movq %r15, %rdx
callq 0x10562
movl %eax, %ebx
movq %r15, %rdi
xorl %esi, %esi
callq *0x278e9(%rip)          # 0x38288
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimEvalObjList
static int JimEvalObjList(Jim_Interp *interp, Jim_Obj *listPtr)
{
    int retcode = JIM_OK;
    Jim_EvalFrame frame;

    JimPanic((Jim_IsList(listPtr) == 0, "JimEvalObjList() invoked on non-list."));

    JimPushEvalFrame(interp, &frame, NULL);

    if (listPtr->internalRep.listValue.len) {
        Jim_IncrRefCount(listPtr);
        retcode = JimInvokeCommand(interp,
            listPtr->internalRep.listValue.len,
            listPtr->internalRep.listValue.ele);
        Jim_DecrRefCount(interp, listPtr);
    }

    JimPopEvalFrame(interp);

    return retcode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rax
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq $0x0, 0x30(%rax)
movq 0x108(%rdi), %rcx
movq %rcx, 0x18(%rax)
movl 0x8(%rcx), %edx
incl %edx
movl %edx, 0x8(%rax)
movl 0x110(%rdi), %edx
movl %edx, 0xc(%rax)
movq 0x58(%rdi), %rdx
movq %rdx, (%rax)
movq 0x30(%rcx), %rcx
movq %rcx, 0x30(%rax)
movq %rax, 0x108(%rdi)
movl 0x20(%rsi), %esi
testl %esi, %esi
je 0x10a64
incl 0x10(%r14)
movq 0x18(%r14), %rdx
movq %rbx, %rdi
callq 0x10640
movl %eax, %r15d
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0x10a67
movq %rbx, %rdi
movq %r14, %rsi
callq 0x759a
jmp 0x10a67
xorl %r15d, %r15d
movq 0x108(%rbx), %rax
movq 0x18(%rax), %rax
movq %rax, 0x108(%rbx)
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimSetErrorStack
static void JimSetErrorStack(Jim_Interp *interp, ScriptObj *script)
{
    if (!interp->errorFlag) {
        int i;
        Jim_Obj *stackTrace = Jim_NewListObj(interp, NULL, 0);

        if (interp->procLevel == 0 && script) {
            Jim_ListAppendElement(interp, stackTrace, interp->emptyObj);
            Jim_ListAppendElement(interp, stackTrace, script->fileNameObj);
            Jim_ListAppendElement(interp, stackTrace, Jim_NewIntObj(interp, script->linenr));
            Jim_ListAppendElement(interp, stackTrace, interp->emptyObj);
        }
        else {
            for (i = 0; i <= interp->procLevel; i++) {
                Jim_EvalFrame *frame = JimGetEvalFrameByProcLevel(interp, -i);
                if (frame) {
                    JimAddStackFrame(interp, frame, stackTrace);
                }
            }
        }
        JimSetStackTrace(interp, stackTrace);
    }
}

// Assembly:
cmpl $0x0, 0x1b4(%rdi)
je 0x10b16
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0xae58
movq %rax, %r14
leaq 0x25822(%rip), %rax     # 0x36358
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
testq %r15, %r15
je 0x10bbc
cmpl $0x0, 0x110(%rbx)
jne 0x10bbc
movq 0x128(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7695
movq 0x8(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7695
movslq 0x20(%r15), %r15
movq %rbx, %rdi
callq 0xae58
leaq 0x25755(%rip), %rcx     # 0x362e0
movq %rcx, 0x8(%rax)
movq $0x0, (%rax)
movq %r15, 0x18(%rax)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7695
movq 0x128(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7695
jmp 0x10bfb
cmpl $0x0, 0x110(%rbx)
js 0x10bfb
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
xorl %r15d, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1bd78
testq %rax, %rax
je 0x10bec
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x1bdb5
incl %r12d
decl %r15d
cmpl 0x110(%rbx), %r12d
jl 0x10bce
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1be8f
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimExpandDictSugar
static Jim_Obj *JimExpandDictSugar(Jim_Interp *interp, Jim_Obj *objPtr)
{
    Jim_Obj *resObjPtr = NULL;
    Jim_Obj *substKeyObjPtr = NULL;

    if (interp->safeexpr) {
        return objPtr;
    }

    SetDictSubstFromAny(interp, objPtr);

    if (Jim_SubstObj(interp, objPtr->internalRep.dictSubstValue.indexObjPtr,
            &substKeyObjPtr, JIM_NONE)
        != JIM_OK) {
        return NULL;
    }
    Jim_IncrRefCount(substKeyObjPtr);
    resObjPtr =
        JimDictExpandArrayVariable(interp, objPtr->internalRep.dictSubstValue.varNameObjPtr,
        substKeyObjPtr, 0);
    Jim_DecrRefCount(interp, substKeyObjPtr);

    return resObjPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq $0x0, -0x20(%rbp)
cmpl $0x0, 0xb0(%rdi)
jne 0x10c88
movq %rdi, %r14
movq %rbx, %rsi
callq 0x18b6c
movq 0x20(%rbx), %rsi
leaq -0x20(%rbp), %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x11260
testl %eax, %eax
je 0x10c51
xorl %ebx, %ebx
jmp 0x10c88
movq -0x20(%rbp), %r15
incl 0x10(%r15)
movq 0x18(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x18c98
movq %rax, %rbx
movl 0x10(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r15)
cmpl $0x1, %eax
jg 0x10c88
movq %r14, %rdi
movq %r15, %rsi
callq 0x759a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_EvalGlobal
int Jim_EvalGlobal(Jim_Interp *interp, const char *script)
{
    int retval;
    Jim_CallFrame *savedFramePtr = interp->framePtr;

    interp->framePtr = interp->topFramePtr;
    retval = Jim_Eval(interp, script);
    interp->framePtr = savedFramePtr;

    return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %r14
movq 0x60(%rdi), %rax
movq %rax, 0x58(%rdi)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9078
movq %r14, 0x58(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_EvalFileGlobal
int Jim_EvalFileGlobal(Jim_Interp *interp, const char *filename)
{
    int retval;
    Jim_CallFrame *savedFramePtr = interp->framePtr;

    interp->framePtr = interp->topFramePtr;
    retval = Jim_EvalFile(interp, filename);
    interp->framePtr = savedFramePtr;

    return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %r14
movq 0x60(%rdi), %rax
movq %rax, 0x58(%rdi)
callq 0x110aa
movq %r14, 0x58(%rbx)
popq %rbx
popq %r14
popq %rbp
retq