LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimGetChannelFd
static int JimGetChannelFd(Jim_Interp *interp, const char *name)
{
    Jim_Obj *objv[2];

    objv[0] = Jim_NewStringObj(interp, name, -1);
    objv[1] = Jim_NewStringObj(interp, "getfd", -1);

    if (Jim_EvalObjVector(interp, 2, objv) == JIM_OK) {
        jim_wide fd;
        if (Jim_GetWide(interp, Jim_GetResult(interp), &fd) == JIM_OK) {
            return fd;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
leaq -0x30(%rbp), %r15
movq %rax, (%r15)
leaq 0x147ae(%rip), %rsi     # 0x2b3cd
movq %r14, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq %rax, 0x8(%r15)
movq %r14, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x10431
testl %eax, %eax
jne 0x16c6c
movq (%r14), %r15
leaq 0x1e6a2(%rip), %rax     # 0x352f0
cmpq %rax, 0x8(%r15)
je 0x16c68
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0xd6c3
testl %eax, %eax
jne 0x16c6c
movl 0x18(%r15), %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimWaitRemove
static int JimWaitRemove(struct WaitInfoTable *table, phandle_t phandle)
{
    int i;


    for (i = 0; i < table->used; i++) {
        if (phandle == table->info[i].phandle) {
            if (i != table->used - 1) {
                table->info[i] = table->info[table->used - 1];
            }
            table->used--;
            return 0;
        }
    }
    return -1;
}

// Assembly:
movslq 0xc(%rdi), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
jle 0x16ccd
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdx
movq %rdx, %r8
movq %rcx, %r9
cmpl %esi, (%r8)
je 0x16ca4
addq $0xc, %r8
decq %r9
jne 0x16c94
jmp 0x16ccc
decl %ecx
cmpl $0x1, %r9d
je 0x16cc7
movslq %ecx, %rax
leaq (%rax,%rax,2), %rax
movl 0x8(%rdx,%rax,4), %ecx
movl %ecx, 0x8(%r8)
movq (%rdx,%rax,4), %rax
movq %rax, (%r8)
movl 0xc(%rdi), %ecx
decl %ecx
movl %ecx, 0xc(%rdi)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: array_cmd_get
static int array_cmd_get(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *objPtr = Jim_GetVariable(interp, argv[0], JIM_NONE);
    Jim_Obj *patternObj;

    if (!objPtr) {
        return JIM_OK;
    }

    patternObj = (argc == 1) ? NULL : argv[1];


    if (patternObj == NULL || Jim_CompareStringImmediate(interp, patternObj, "*")) {
        if (Jim_IsList(objPtr) && Jim_ListLength(interp, objPtr) % 2 == 0) {

            Jim_SetResult(interp, objPtr);
            return JIM_OK;
        }
    }

    return Jim_DictMatchTypes(interp, objPtr, patternObj, JIM_DICTMATCH_KEYS, JIM_DICTMATCH_KEYS | JIM_DICTMATCH_VALUES);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %rbx
movq (%rdx), %rsi
xorl %edx, %edx
callq 0x98e7
testq %rax, %rax
je 0x174a6
movq %rax, %r14
cmpl $0x1, %r12d
je 0x17464
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x17464
leaq 0x14a4b(%rip), %rdx     # 0x2be9e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73c6
testl %eax, %eax
jne 0x17467
jmp 0x174b1
xorl %r15d, %r15d
leaq 0x1defa(%rip), %rax     # 0x35368
cmpq %rax, 0x8(%r14)
jne 0x174b1
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe2fe
testb $0x1, 0x20(%r14)
jne 0x174b1
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x174a3
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x1, %ecx
movl $0x3, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1153e
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: array_cmd_names
static int array_cmd_names(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *objPtr = Jim_GetVariable(interp, argv[0], JIM_NONE);

    if (!objPtr) {
        return JIM_OK;
    }

    return Jim_DictMatchTypes(interp, objPtr, argc == 1 ? NULL : argv[1], JIM_DICTMATCH_KEYS, JIM_DICTMATCH_KEYS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movq (%rdx), %rsi
xorl %edx, %edx
callq 0x98e7
testq %rax, %rax
je 0x174fe
cmpl $0x1, %r15d
jne 0x1750b
xorl %edx, %edx
jmp 0x1750f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %rdx
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %ecx
movl $0x1, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1153e
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: array_cmd_set
static int array_cmd_set(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    int i;
    int len;
    Jim_Obj *listObj = argv[1];
    Jim_Obj *dictObj;

    len = Jim_ListLength(interp, listObj);
    if (len % 2) {
        Jim_SetResultString(interp, "list must have an even number of elements", -1);
        return JIM_ERR;
    }

    dictObj = Jim_GetVariable(interp, argv[0], JIM_UNSHARED);
    if (!dictObj) {

        return Jim_SetVariable(interp, argv[0], listObj);
    }
    else if (Jim_DictSize(interp, dictObj) < 0) {
        return JIM_ERR;
    }

    if (Jim_IsShared(dictObj)) {
        dictObj = Jim_DuplicateObj(interp, dictObj);
    }

    for (i = 0; i < len; i += 2) {
        Jim_Obj *nameObj;
        Jim_Obj *valueObj;

        Jim_ListIndex(interp, listObj, i, &nameObj, JIM_NONE);
        Jim_ListIndex(interp, listObj, i + 1, &valueObj, JIM_NONE);

        Jim_DictAddElement(interp, dictObj, nameObj, valueObj);
    }
    return Jim_SetVariable(interp, argv[0], dictObj);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %r15
movq %r15, %rsi
callq 0xe2fe
movl 0x20(%r15), %r12d
testb $0x1, %r12b
jne 0x1760d
movq (%r14), %rsi
movq %rbx, %rdi
movl $0x4, %edx
callq 0x98e7
testq %rax, %rax
je 0x17657
movq %rax, %r13
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf08c
testl %eax, %eax
jne 0x17643
movq 0x18(%r13), %rax
cmpl $-0x1, 0x20(%rax)
jl 0x17643
movq %r14, -0x38(%rbp)
cmpl $0x2, 0x10(%r13)
jl 0x175b6
movq %rbx, %rdi
movq %r13, %rsi
callq 0x8fc2
movq %rax, %r13
movq %r13, -0x30(%rbp)
testl %r12d, %r12d
jle 0x175fd
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
callq 0xe803
movq %rax, %r14
leal 0x1(%r13), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe803
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
movq %r14, %rdx
movq %rax, %rcx
callq 0xf018
addl $0x2, %r13d
cmpl %r12d, %r13d
jl 0x175c2
movq -0x38(%rbp), %rax
movq (%rax), %rsi
movq %rbx, %rdi
movq -0x30(%rbp), %rdx
jmp 0x17660
leaq 0x144ba(%rip), %rsi     # 0x2bace
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x17640
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x876e
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: array_cmd_size
static int array_cmd_size(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *objPtr;
    int len = 0;


    objPtr = Jim_GetVariable(interp, argv[0], JIM_NONE);
    if (objPtr) {
        len = Jim_DictSize(interp, objPtr);
        if (len < 0) {

            Jim_SetResultInt(interp, 0);
            return JIM_OK;
        }
    }

    Jim_SetResultInt(interp, len);

    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdx), %rsi
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x98e7
testq %rax, %rax
je 0x17709
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf08c
testl %eax, %eax
jne 0x176b0
movq 0x18(%r14), %rax
movl 0x20(%rax), %eax
cmpl $-0x2, %eax
jg 0x176fc
movq %rbx, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x1dc2e(%rip), %rax     # 0x352f0
movq %rax, 0x8(%r14)
xorl %eax, %eax
movq %rax, (%r14)
movq %rax, 0x18(%r14)
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x2, %eax
jge 0x176ec
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r15d
shrl $0x1f, %r15d
addl %eax, %r15d
sarl %r15d
movl %r15d, %r15d
movq %rbx, %rdi
callq 0xae38
movq %rax, %r14
leaq 0x1dbd2(%rip), %rax     # 0x352f0
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movq %r15, 0x18(%r14)
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jle 0x176e4
jmp 0x176ec
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: array_cmd_stat
static int array_cmd_stat(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *objPtr = Jim_GetVariable(interp, argv[0], JIM_NONE);
    if (objPtr) {
        return Jim_DictInfo(interp, objPtr);
    }
    Jim_SetResultFormatted(interp, "\"%#s\" isn't an array", argv[0], NULL);
    return JIM_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdx), %rsi
xorl %edx, %edx
callq 0x98e7
testq %rax, %rax
je 0x1776f
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x11680
movq (%r14), %rdx
leaq 0x1437f(%rip), %rsi     # 0x2baf8
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x6923
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: array_cmd_unset
static int array_cmd_unset(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    int i;
    int len;
    Jim_Obj *resultObj;
    Jim_Obj *objPtr;
    Jim_Obj **dictValuesObj;

    if (argc == 1 || Jim_CompareStringImmediate(interp, argv[1], "*")) {

        Jim_UnsetVariable(interp, argv[0], JIM_NONE);
        return JIM_OK;
    }

    objPtr = Jim_GetVariable(interp, argv[0], JIM_NONE);

    if (objPtr == NULL) {

        return JIM_OK;
    }

    dictValuesObj = Jim_DictPairs(interp, objPtr, &len);
    if (dictValuesObj == NULL) {

        Jim_SetResultString(interp, "", -1);
        return JIM_OK;
    }


    resultObj = Jim_NewDictObj(interp, NULL, 0);

    for (i = 0; i < len; i += 2) {
        if (!Jim_StringMatchObj(interp, argv[1], dictValuesObj[i], 0)) {
            Jim_DictAddElement(interp, resultObj, dictValuesObj[i], dictValuesObj[i + 1]);
        }
    }

    Jim_SetVariable(interp, argv[0], 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
je 0x177c2
movq 0x8(%r14), %rsi
leaq 0x146e8(%rip), %rdx     # 0x2be9e
movq %rbx, %rdi
callq 0x73c6
testl %eax, %eax
je 0x177e0
movq (%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xc7f4
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x98e7
testq %rax, %rax
je 0x177cf
leaq -0x2c(%rbp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf69a
testq %rax, %rax
je 0x178a1
movq %rax, %r15
movq %rbx, %rdi
callq 0xae38
movq %rax, %r12
leaq 0x1db71(%rip), %rax     # 0x35390
movq %rax, 0x8(%r12)
movq $0x0, (%r12)
movl $0x30, %esi
xorl %edi, %edi
callq *0x1fa4f(%rip)          # 0x37288
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movq %r12, -0x38(%rbp)
movq %rax, 0x18(%r12)
movl -0x2c(%rbp), %r13d
testl %r13d, %r13d
jle 0x1788d
xorl %r12d, %r12d
movq 0x8(%r14), %rsi
movq (%r15,%r12,8), %rdx
xorl %ecx, %ecx
callq 0xb104
testl %eax, %eax
jne 0x17884
movq (%r15,%r12,8), %rdx
movq 0x8(%r15,%r12,8), %rcx
movq %rbx, %rdi
movq -0x38(%rbp), %rsi
callq 0xf018
addq $0x2, %r12
cmpl %r12d, %r13d
jg 0x1785c
movq (%r14), %rsi
movq %rbx, %rdi
movq -0x38(%rbp), %rdx
callq 0x876e
jmp 0x177cf
leaq 0x15d49(%rip), %rsi     # 0x2d5f1
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7508
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x178d4
movq %rbx, %rdi
callq 0x758c
movq %r14, (%rbx)
jmp 0x177cf
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimCharsetMatch
static const char *JimCharsetMatch(const char *pattern, int plen, int c, int flags)
{
    int not = 0;
    int pchar;
    int match = 0;
    int nocase = 0;
    int n;

    if (flags & JIM_NOCASE) {
        nocase++;
        c = utf8_upper(c);
    }

    if (flags & JIM_CHARSET_SCAN) {
        if (*pattern == '^') {
            not++;
            pattern++;
            plen--;
        }


        if (*pattern == ']') {
            goto first;
        }
    }

    while (plen && *pattern != ']') {

        if (pattern[0] == '\\') {
first:
            n = utf8_tounicode_case(pattern, &pchar, nocase);
            pattern += n;
            plen -= n;
        }
        else {

            int start;
            int end;

            n = utf8_tounicode_case(pattern, &start, nocase);
            pattern += n;
            plen -= n;
            if (pattern[0] == '-' && plen > 1) {

                n = 1 + utf8_tounicode_case(pattern + 1, &end, nocase);
                pattern += n;
                plen -= n;


                if ((c >= start && c <= end) || (c >= end && c <= start)) {
                    match = 1;
                }
                continue;
            }
            pchar = start;
        }

        if (pchar == c) {
            match = 1;
        }
    }
    if (not) {
        match = !match;
    }

    return match ? pattern : NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r12d
movl %esi, %r15d
movq %rdi, %rbx
movl %ecx, -0x2c(%rbp)
testb $0x1, %cl
je 0x1791b
movl %r12d, %edi
callq 0x60e0
movl %eax, %r12d
testb $0x2, -0x2c(%rbp)
jne 0x1792e
movq $0x0, -0x38(%rbp)
xorl %r14d, %r14d
jmp 0x17954
xorl %eax, %eax
cmpb $0x5e, (%rbx)
sete %al
subl %eax, %r15d
xorl %r14d, %r14d
cmpb $0x5d, (%rbx,%rax)
movq %rax, -0x38(%rbp)
leaq (%rbx,%rax), %rbx
movl $0x5d, %r13d
je 0x179fe
testl %r15d, %r15d
je 0x179d1
movzbl (%rbx), %r13d
cmpl $0x5d, %r13d
je 0x179d1
cmpl $0x5c, %r13d
je 0x179f8
testb $0x1, -0x2c(%rbp)
jne 0x1798d
cmpl $0x3, %r15d
jl 0x17a0f
cmpb $0x2d, 0x1(%rbx)
jne 0x17a0f
movzbl 0x2(%rbx), %eax
jmp 0x179ad
movl %r13d, %edi
callq 0x60e0
movl %eax, %r13d
cmpl $0x3, %r15d
jl 0x17a0f
cmpb $0x2d, 0x1(%rbx)
jne 0x17a0f
movzbl 0x2(%rbx), %edi
callq 0x60e0
cmpl %r13d, %r12d
jl 0x179b7
cmpl %eax, %r12d
jle 0x179c1
cmpl %r13d, %r12d
jg 0x179c7
cmpl %eax, %r12d
jl 0x179c7
movl $0x1, %r14d
addq $0x3, %rbx
addl $-0x3, %r15d
jne 0x17959
xorl %ecx, %ecx
testl %r14d, %r14d
sete %cl
cmpl $0x0, -0x38(%rbp)
cmovel %r14d, %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovneq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x5c, %r13d
testb $0x1, -0x2c(%rbp)
je 0x17a0f
movl %r13d, %edi
callq 0x60e0
movl %eax, %r13d
incq %rbx
decl %r15d
cmpl %r12d, %r13d
movl $0x1, %eax
cmovel %eax, %r14d
jmp 0x17954
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: FreeScriptInternalRep
void FreeScriptInternalRep(Jim_Interp *interp, Jim_Obj *objPtr)
{
    int i;
    struct ScriptObj *script = (void *)objPtr->internalRep.ptr;

    if (--script->inUse != 0)
        return;
    for (i = 0; i < script->len; i++) {
        Jim_DecrRefCount(interp, script->token[i].objPtr);
    }
    Jim_Free(script->token);
    Jim_DecrRefCount(interp, script->fileNameObj);
    Jim_Free(script);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x18(%rsi), %rbx
decl 0x18(%rbx)
je 0x17a7a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movl 0x10(%rbx), %eax
testl %eax, %eax
jle 0x17ab9
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rbx), %rcx
movq (%rcx,%r15), %rsi
movl 0x10(%rsi), %ecx
leal -0x1(%rcx), %edx
movl %edx, 0x10(%rsi)
cmpl $0x1, %ecx
jg 0x17aaa
movq %r14, %rdi
callq 0x758c
movl 0x10(%rbx), %eax
incq %r12
movslq %eax, %rcx
addq $0x10, %r15
cmpq %rcx, %r12
jl 0x17a8a
movq (%rbx), %rdi
xorl %esi, %esi
callq *0x1f7c4(%rip)          # 0x37288
movq 0x8(%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x17ade
movq %r14, %rdi
callq 0x758c
movq 0x1f7a3(%rip), %rax     # 0x37288
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: ScriptAddToken
static void ScriptAddToken(ParseTokenList *tokenlist, const char *token, int len, int type,
    int line)
{
    ParseToken *t;

    if (tokenlist->count == tokenlist->size) {

        tokenlist->size *= 2;
        if (tokenlist->list != tokenlist->static_list) {
            tokenlist->list =
                Jim_Realloc(tokenlist->list, tokenlist->size * sizeof(*tokenlist->list));
        }
        else {

            tokenlist->list = Jim_Alloc(tokenlist->size * sizeof(*tokenlist->list));
            memcpy(tokenlist->list, tokenlist->static_list,
                tokenlist->count * sizeof(*tokenlist->list));
        }
    }
    t = &tokenlist->list[tokenlist->count++];
    t->token = token;
    t->len = len;
    t->type = type;
    t->line = line;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r13
movslq 0xc(%rdi), %rcx
movq (%rdi), %rax
cmpl 0x8(%rdi), %ecx
jne 0x17b7d
movl %r8d, -0x2c(%rbp)
leal (%rcx,%rcx), %edx
movl %edx, 0x8(%r13)
leaq 0x10(%r13), %rbx
shlq $0x4, %rcx
movq 0x1f746(%rip), %rdx     # 0x37288
leaq (%rcx,%rcx,2), %rsi
cmpq %rbx, %rax
je 0x17b56
movq %rax, %rdi
callq *%rdx
movq %rax, (%r13)
jmp 0x17b79
xorl %edi, %edi
callq *%rdx
movq %rax, (%r13)
movslq 0xc(%r13), %rcx
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6320
movq (%r13), %rax
movl -0x2c(%rbp), %r8d
movslq 0xc(%r13), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0xc(%r13)
leaq (%rcx,%rcx,2), %rcx
movq %r12, (%rax,%rcx,8)
movl %r15d, 0x8(%rax,%rcx,8)
movl %r14d, 0xc(%rax,%rcx,8)
movl %r8d, 0x10(%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimParseSep
static int JimParseSep(struct JimParserCtx *pc)
{
    pc->tstart = pc->p;
    pc->tline = pc->linenr;
    while (isspace(UCHAR(*pc->p)) || (*pc->p == '\\' && *(pc->p + 1) == '\n')) {
        if (*pc->p == '\n') {
            break;
        }
        if (*pc->p == '\\') {
            pc->p++;
            pc->len--;
            pc->linenr++;
        }
        pc->p++;
        pc->len--;
    }
    pc->tend = pc->p - 1;
    pc->tt = JIM_TT_SEP;
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq %r14, 0x10(%rdi)
movl 0xc(%rdi), %r15d
movl %r15d, 0x20(%rdi)
callq 0x64e0
movq (%rax), %rdx
movzbl (%r14), %ecx
testb $0x20, 0x1(%rdx,%rcx,2)
jne 0x17beb
cmpl $0x5c, %ecx
jne 0x17c16
cmpb $0xa, 0x1(%r14)
je 0x17bfa
jmp 0x17c16
cmpl $0x5c, %ecx
je 0x17bfa
cmpl $0xa, %ecx
je 0x17c16
movl 0x8(%rbx), %ecx
jmp 0x17c09
incq %r14
movl 0x8(%rbx), %ecx
decl %ecx
incl %r15d
movl %r15d, 0xc(%rbx)
incq %r14
movq %r14, (%rbx)
decl %ecx
movl %ecx, 0x8(%rbx)
jmp 0x17bcf
decq %r14
movq %r14, 0x18(%rbx)
movl $0x6, 0x24(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimParseComment
static int JimParseComment(struct JimParserCtx *pc)
{
    while (*pc->p) {
        if (*pc->p == '\\') {
            pc->p++;
            pc->len--;
            if (pc->len == 0) {
                pc->missing.ch = '\\';
                return JIM_OK;
            }
            if (*pc->p == '\n') {
                pc->linenr++;
            }
        }
        else if (*pc->p == '\n') {
            pc->p++;
            pc->len--;
            pc->linenr++;
            break;
        }
        pc->p++;
        pc->len--;
    }
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movzbl (%rax), %ecx
cmpl $0x5c, %ecx
je 0x17ffd
testl %ecx, %ecx
je 0x18037
cmpl $0xa, %ecx
je 0x18022
movl 0x8(%rdi), %ecx
jmp 0x18015
incq %rax
movq %rax, (%rdi)
movl 0x8(%rdi), %ecx
decl %ecx
movl %ecx, 0x8(%rdi)
je 0x18030
cmpb $0xa, (%rax)
jne 0x18015
incl 0xc(%rdi)
incq %rax
movq %rax, (%rdi)
decl %ecx
movl %ecx, 0x8(%rdi)
jmp 0x17fe7
incq %rax
movq %rax, (%rdi)
decl 0x8(%rdi)
incl 0xc(%rdi)
jmp 0x18037
movl $0x5c, 0x34(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimParseSubBrace
static void JimParseSubBrace(struct JimParserCtx *pc)
{
    int level = 1;


    pc->p++;
    pc->len--;
    while (pc->len) {
        switch (*pc->p) {
            case '\\':
                if (pc->len > 1) {
                    if (*++pc->p == '\n') {
                        pc->linenr++;
                    }
                    pc->len--;
                }
                break;

            case '{':
                level++;
                break;

            case '}':
                if (--level == 0) {
                    pc->tend = pc->p - 1;
                    pc->p++;
                    pc->len--;
                    return;
                }
                break;

            case '\n':
                pc->linenr++;
                break;
        }
        pc->p++;
        pc->len--;
    }
    pc->missing.ch = '{';
    pc->missing.line = pc->tline;
    pc->tend = pc->p - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %r8
leaq 0x1(%r8), %rsi
movq %rsi, (%rdi)
movl 0x8(%rdi), %edx
movl %edx, %ecx
decl %ecx
movl %ecx, 0x8(%rdi)
je 0x180b6
movl $0x1, %eax
movzbl (%rsi), %r8d
cmpl $0x7a, %r8d
jg 0x1808a
cmpl $0xa, %r8d
je 0x1809c
cmpl $0x5c, %r8d
jne 0x180a3
cmpl $0x3, %edx
jl 0x180a3
leaq 0x1(%rsi), %r8
movq %r8, (%rdi)
cmpb $0xa, 0x1(%rsi)
jne 0x18083
incl 0xc(%rdi)
addl $-0x2, %edx
movl %edx, %ecx
jmp 0x180a6
cmpl $0x7b, %r8d
je 0x180a1
cmpl $0x7d, %r8d
jne 0x180a3
decl %eax
jne 0x180a3
jmp 0x180c9
incl 0xc(%rdi)
jmp 0x180a3
incl %eax
movq %rsi, %r8
movl %ecx, %edx
leaq 0x1(%r8), %rsi
movq %rsi, (%rdi)
decl %ecx
movl %ecx, 0x8(%rdi)
jne 0x18058
movl $0x7b, 0x34(%rdi)
movl 0x20(%rdi), %eax
movl %eax, 0x38(%rdi)
movq %r8, 0x18(%rdi)
popq %rbp
retq
leaq -0x1(%rsi), %rax
movq %rax, 0x18(%rdi)
incq %rsi
movq %rsi, (%rdi)
addl $-0x2, %edx
movl %edx, 0x8(%rdi)
jmp 0x180c7
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimParseSubCmd
static void JimParseSubCmd(struct JimParserCtx *pc)
{
    int level = 1;
    int startofword = 1;
    int line = pc->tline;


    pc->p++;
    pc->len--;
    while (pc->len) {
        switch (*pc->p) {
            case '\\':
                if (pc->len > 1) {
                    if (*++pc->p == '\n') {
                        pc->linenr++;
                    }
                    pc->len--;
                }
                break;

            case '[':
                level++;
                break;

            case ']':
                if (--level == 0) {
                    pc->tend = pc->p - 1;
                    pc->p++;
                    pc->len--;
                    return;
                }
                break;

            case '"':
                if (startofword) {
                    JimParseSubQuote(pc);
                    if (pc->missing.ch == '"') {
                        return;
                    }
                    continue;
                }
                break;

            case '{':
                JimParseSubBrace(pc);
                startofword = 0;
                continue;

            case '\n':
                pc->linenr++;
                break;
        }
        startofword = isspace(UCHAR(*pc->p));
        pc->p++;
        pc->len--;
    }
    pc->missing.ch = '[';
    pc->missing.line = line;
    pc->tend = pc->p - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x20(%rdi), %eax
movq (%rdi), %r13
incq %r13
movq %r13, (%rdi)
movl 0x8(%rdi), %r12d
decl %r12d
movl %r12d, 0x8(%rdi)
je 0x181d8
movl %eax, -0x2c(%rbp)
movl $0x1, %r15d
movl $0x1, %r14d
movq (%rbx), %rax
movzbl (%rax), %ecx
cmpl $0x5b, %ecx
jg 0x18144
cmpl $0x22, %ecx
jne 0x1815f
testl %r14d, %r14d
je 0x181a1
movq %rbx, %rdi
callq 0x1820f
cmpl $0x22, 0x34(%rbx)
jne 0x18154
jmp 0x181e9
cmpl $0x7b, %ecx
jne 0x1816e
movq %rbx, %rdi
callq 0x18039
xorl %r14d, %r14d
movl 0x8(%rbx), %r12d
testl %r12d, %r12d
jne 0x1811c
jmp 0x181d2
cmpl $0xa, %ecx
je 0x18197
cmpl $0x5b, %ecx
jne 0x181a1
incl %r15d
jmp 0x181a1
cmpl $0x5d, %ecx
je 0x1819c
cmpl $0x5c, %ecx
jne 0x181a1
cmpl $0x2, %r12d
jl 0x181a1
leaq 0x1(%rax), %r13
movq %r13, (%rbx)
cmpb $0xa, 0x1(%rax)
jne 0x1818e
incl 0xc(%rbx)
decl %r12d
movl %r12d, 0x8(%rbx)
jmp 0x181a4
incl 0xc(%rbx)
jmp 0x181a1
decl %r15d
je 0x181f8
movq %rax, %r13
callq 0x64e0
movq (%rax), %rax
movzbl (%r13), %ecx
movzwl (%rax,%rcx,2), %r14d
andl $0x2000, %r14d          # imm = 0x2000
incq %r13
movq %r13, (%rbx)
decl %r12d
movl %r12d, 0x8(%rbx)
jne 0x1811c
jmp 0x181d5
movq (%rbx), %r13
movl -0x2c(%rbp), %eax
movl $0x5b, 0x34(%rbx)
movl %eax, 0x38(%rbx)
decq %r13
movq %r13, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
incq %rax
movq %rax, (%rbx)
decl %r12d
movl %r12d, 0x8(%rbx)
jmp 0x181e9
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimParseSubQuote
static int JimParseSubQuote(struct JimParserCtx *pc)
{
    int tt = JIM_TT_STR;
    int line = pc->tline;


    pc->p++;
    pc->len--;
    while (pc->len) {
        switch (*pc->p) {
            case '\\':
                if (pc->len > 1) {
                    if (*++pc->p == '\n') {
                        pc->linenr++;
                    }
                    pc->len--;
                    tt = JIM_TT_ESC;
                }
                break;

            case '"':
                pc->tend = pc->p - 1;
                pc->p++;
                pc->len--;
                return tt;

            case '[':
                JimParseSubCmd(pc);
                tt = JIM_TT_ESC;
                continue;

            case '\n':
                pc->linenr++;
                break;

            case '$':
                tt = JIM_TT_ESC;
                break;
        }
        pc->p++;
        pc->len--;
    }
    pc->missing.ch = '"';
    pc->missing.line = line;
    pc->tend = pc->p - 1;
    return tt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x20(%rdi), %r14d
movq (%rdi), %rdx
incq %rdx
movq %rdx, (%rdi)
movl 0x8(%rdi), %ecx
decl %ecx
movl %ecx, 0x8(%rdi)
movl $0x1, %eax
je 0x182ad
movq %rdx, %rsi
movzbl (%rsi), %edx
cmpl $0x5a, %edx
jg 0x18251
cmpl $0xa, %edx
je 0x18279
cmpl $0x24, %edx
jne 0x18293
movl $0x2, %eax
jmp 0x18298
cmpl $0x5b, %edx
je 0x1827e
cmpl $0x5c, %edx
jne 0x18298
cmpl $0x2, %ecx
jl 0x18298
leaq 0x1(%rsi), %rdx
movq %rdx, (%rbx)
cmpb $0xa, 0x1(%rsi)
jne 0x18270
incl 0xc(%rbx)
decl %ecx
movl $0x2, %eax
jmp 0x1829b
incl 0xc(%rbx)
jmp 0x18298
movq %rbx, %rdi
callq 0x180df
movl 0x8(%rbx), %ecx
movq (%rbx), %rdx
movl $0x2, %eax
jmp 0x182a6
cmpl $0x22, %edx
je 0x182c4
movq %rsi, %rdx
incq %rdx
movq %rdx, (%rbx)
decl %ecx
movl %ecx, 0x8(%rbx)
movq %rdx, %rsi
testl %ecx, %ecx
jne 0x18238
movl $0x22, 0x34(%rbx)
movl %r14d, 0x38(%rbx)
decq %rdx
movq %rdx, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x1(%rsi), %rdx
movq %rdx, 0x18(%rbx)
incq %rsi
movq %rsi, (%rbx)
decl %ecx
movl %ecx, 0x8(%rbx)
jmp 0x182bf
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimMakeScriptObj
static Jim_Obj *JimMakeScriptObj(Jim_Interp *interp, const ParseToken *t)
{
    Jim_Obj *objPtr;

    if (t->type == JIM_TT_ESC && memchr(t->token, '\\', t->len) != NULL) {

        int len = t->len;
        char *str = Jim_Alloc(len + 1);
        len = JimEscape(str, t->token, len);
        objPtr = Jim_NewStringObjNoAlloc(interp, str, len);
    }
    else {
        objPtr = Jim_NewStringObj(interp, t->token, t->len);
    }
    return objPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x2, 0xc(%rsi)
movq (%rsi), %r12
movslq 0x8(%rsi), %r14
jne 0x18340
movq %rsi, %r15
movq %r12, %rdi
movl $0x5c, %esi
movq %r14, %rdx
callq 0x6290
testq %rax, %rax
je 0x18340
movq %r14, %rsi
incq %rsi
xorl %edi, %edi
callq *0x1ef6e(%rip)          # 0x37288
movq %rax, %r12
movq (%r15), %rsi
movq %rax, %rdi
movl %r14d, %edx
callq 0x18356
movq %rbx, %rdi
movq %r12, %rsi
movl %eax, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xaee8
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7508
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: SetDictSubstFromAny
static void SetDictSubstFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
{
    if (objPtr->typePtr != &dictSubstObjType) {
        Jim_Obj *varObjPtr, *keyObjPtr;

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


            varObjPtr = objPtr->internalRep.dictSubstValue.varNameObjPtr;
            keyObjPtr = objPtr->internalRep.dictSubstValue.indexObjPtr;

            Jim_IncrRefCount(varObjPtr);
            Jim_IncrRefCount(keyObjPtr);
        }
        else {
            JimDictSugarParseVarKey(interp, objPtr, &varObjPtr, &keyObjPtr);
        }

        Jim_FreeIntRep(interp, objPtr);
        objPtr->typePtr = &dictSubstObjType;
        objPtr->internalRep.dictSubstValue.varNameObjPtr = varObjPtr;
        objPtr->internalRep.dictSubstValue.indexObjPtr = keyObjPtr;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rcx
leaq 0x1d6be(%rip), %r14     # 0x35d80
cmpq %r14, %rcx
je 0x18787
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x1d6d0(%rip), %rax     # 0x35da8
cmpq %rax, %rcx
movq %rdi, -0x30(%rbp)
je 0x18758
movq (%rbx), %r12
testq %r12, %r12
jne 0x186f2
movq %rbx, %rdi
callq *0x18(%rcx)
movq (%rbx), %r12
movslq 0x14(%rbx), %r14
movq %r12, %rdi
movl $0x28, %esi
callq 0x61c0
movq %rax, %r13
movl %r13d, %edx
subl %r12d, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x7508
movq %r15, %rdi
movq %rax, %r15
incq %r13
leaq (%r12,%r14), %rdx
subl %r13d, %edx
xorl %eax, %eax
cmpb $0x29, -0x1(%r12,%r14)
sete %al
subl %eax, %edx
movq %r13, %rsi
callq 0x7508
incl 0x10(%r15)
movq %rax, %r12
incl 0x10(%rax)
movq 0x8(%rbx), %rax
testq %rax, %rax
leaq 0x1d62c(%rip), %r14     # 0x35d80
jne 0x18769
jmp 0x1877b
movq 0x18(%rbx), %r15
movq 0x20(%rbx), %r12
incl 0x10(%r15)
incl 0x10(%r12)
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x1877b
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq *%rax
movq %r14, 0x8(%rbx)
movq %r15, 0x18(%rbx)
movq %r12, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimDictExpandArrayVariable
static Jim_Obj *JimDictExpandArrayVariable(Jim_Interp *interp, Jim_Obj *varObjPtr,
    Jim_Obj *keyObjPtr, int flags)
{
    Jim_Obj *dictObjPtr;
    Jim_Obj *resObjPtr = NULL;
    int ret;

    dictObjPtr = Jim_GetVariable(interp, varObjPtr, JIM_ERRMSG);
    if (!dictObjPtr) {
        return NULL;
    }

    ret = Jim_DictKey(interp, dictObjPtr, keyObjPtr, &resObjPtr, JIM_NONE);
    if (ret != JIM_OK) {
        Jim_SetResultFormatted(interp,
            "can't read \"%#s(%#s)\": %s array", varObjPtr, keyObjPtr,
            ret < 0 ? "variable isn't" : "no such element in");
    }
    else if ((flags & JIM_UNSHARED) && Jim_IsShared(dictObjPtr)) {

        Jim_SetVariable(interp, varObjPtr, Jim_DuplicateObj(interp, dictObjPtr));
    }

    return resObjPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r12d
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq $0x0, -0x30(%rbp)
movl $0x1, %edx
callq 0x98e7
testq %rax, %rax
je 0x1884d
movq %rax, %r13
leaq -0x30(%rbp), %rcx
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0xf4bf
testl %eax, %eax
je 0x18851
leaq 0x1339d(%rip), %rax     # 0x2bbc6
leaq 0x133a5(%rip), %r8      # 0x2bbd5
cmovsq %rax, %r8
leaq 0x1336b(%rip), %rsi     # 0x2bba6
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x6923
jmp 0x18877
xorl %eax, %eax
jmp 0x1887b
testb $0x4, %r12b
je 0x18877
cmpl $0x2, 0x10(%r13)
jl 0x18877
movq %r14, %rdi
movq %r13, %rsi
callq 0x8fc2
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x876e
movq -0x30(%rbp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_GetStringNoQualifier
static const char *Jim_GetStringNoQualifier(Jim_Obj *objPtr, int *length)
{
    int len;
    const char *str = Jim_GetString(objPtr, &len);
    if (len >= 2 && str[0] == ':' && str[1] == ':') {
        while (len && *str == ':') {
            len--;
            str++;
        }
    }
    *length = len;
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdx
testq %rdx, %rdx
jne 0x18975
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %rdx
movslq 0x14(%r14), %rcx
cmpq $0x2, %rcx
jl 0x189a0
cmpb $0x3a, (%rdx)
jne 0x189a0
cmpb $0x3a, 0x1(%rdx)
jne 0x189a0
movq %rcx, %rax
addq %rdx, %rax
cmpb $0x3a, (%rdx)
jne 0x189a0
incq %rdx
decl %ecx
jne 0x18990
xorl %ecx, %ecx
jmp 0x189a3
movq %rdx, %rax
movl %ecx, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimDecrCmdRefCount
static void JimDecrCmdRefCount(Jim_Interp *interp, Jim_Cmd *cmdPtr)
{
    if (--cmdPtr->inUse == 0) {
        if (cmdPtr->isproc) {
            Jim_DecrRefCount(interp, cmdPtr->u.proc.argListObjPtr);
            Jim_DecrRefCount(interp, cmdPtr->u.proc.bodyObjPtr);
            Jim_DecrRefCount(interp, cmdPtr->u.proc.nsObj);
            if (cmdPtr->u.proc.staticVars) {
                Jim_FreeHashTable(cmdPtr->u.proc.staticVars);
                Jim_Free(cmdPtr->u.proc.staticVars);
            }
        }
        else {

            if (cmdPtr->u.native.delProc) {
                cmdPtr->u.native.delProc(interp, cmdPtr->u.native.privData);
            }
        }
        if (cmdPtr->prevCmd) {

            JimDecrCmdRefCount(interp, cmdPtr->prevCmd);
        }

        cmdPtr->prevCmd = interp->oldCmdCache;
        interp->oldCmdCache = cmdPtr;
        if (!interp->quitting && ++interp->oldCmdCacheSize >= 1000) {
            Jim_InterpIncrProcEpoch(interp);
        }
    }
}

// Assembly:
decl (%rsi)
je 0x189af
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x4(%rsi)
je 0x18a64
movq 0x18(%r14), %rax
movl 0x10(%rax), %ecx
leal -0x1(%rcx), %edx
movl %edx, 0x10(%rax)
cmpl $0x1, %ecx
jg 0x189e7
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x758c
movq 0x20(%r14), %rax
movl 0x10(%rax), %ecx
leal -0x1(%rcx), %edx
movl %edx, 0x10(%rax)
cmpl $0x1, %ecx
jg 0x18a05
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x758c
movq 0x50(%r14), %rax
movl 0x10(%rax), %ecx
leal -0x1(%rcx), %edx
movl %edx, 0x10(%rax)
cmpl $0x1, %ecx
jg 0x18a23
movq 0x50(%r14), %rsi
movq %rbx, %rdi
callq 0x758c
movq 0x28(%r14), %r15
testq %r15, %r15
je 0x18a76
movq %r15, %rdi
callq 0xaba2
movq (%r15), %rdi
xorl %esi, %esi
callq *0x1e849(%rip)          # 0x37288
movq $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movl $0x0, 0x28(%r15)
movq 0x28(%r14), %rdi
xorl %esi, %esi
callq *0x1e826(%rip)          # 0x37288
jmp 0x18a76
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x18a76
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq *%rax
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0x18a87
movq %rbx, %rdi
callq 0x189aa
movq 0x1c0(%rbx), %rax
movq %rax, 0x8(%r14)
movq %r14, 0x1c0(%rbx)
cmpl $0x0, 0xac(%rbx)
jne 0x18ae7
movl 0x1c8(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x1c8(%rbx)
cmpl $0x3e7, %eax            # imm = 0x3E7
jl 0x18ae7
incq 0x98(%rbx)
movq 0x8(%r14), %r15
movq %r14, %rdi
xorl %esi, %esi
callq *0x1e7ba(%rip)          # 0x37288
movq %r15, 0x1c0(%rbx)
movq %r15, %r14
testq %r15, %r15
jne 0x18abf
movl $0x0, 0x1c8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimDecrVarRef
static void JimDecrVarRef(Jim_Interp *interp, Jim_VarVal *vv)
{
    assert(vv->refCount > 0);
    if (--vv->refCount == 0) {
        if (vv->objPtr) {
            Jim_DecrRefCount(interp, vv->objPtr);
        }
        Jim_Free(vv);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0x10(%rsi), %eax
testl %eax, %eax
jle 0x18c88
movq %rsi, %rbx
decl %eax
movl %eax, 0x10(%rsi)
je 0x18c59
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x18c74
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x18c74
callq 0x758c
movq 0x1e60d(%rip), %rax     # 0x37288
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
leaq 0x12f59(%rip), %rdi     # 0x2bbe8
leaq 0x11f15(%rip), %rsi     # 0x2abab
leaq 0x12f5c(%rip), %rcx     # 0x2bbf9
movl $0x2799, %edx           # imm = 0x2799
callq 0x6220
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: UpdateStringOfInt
static void UpdateStringOfInt(struct Jim_Obj *objPtr)
{
    char buf[JIM_INTEGER_SPACE + 1];
    jim_wide wideValue = JimWideValue(objPtr);
    int pos = 0;

    if (wideValue == 0) {
        buf[pos++] = '0';
    }
    else {
        char tmp[JIM_INTEGER_SPACE];
        int num = 0;
        int i;

        if (wideValue < 0) {
            buf[pos++] = '-';
            i = wideValue % 10;
            tmp[num++] = (i > 0) ? (10 - i) : -i;
            wideValue /= -10;
        }

        while (wideValue) {
            tmp[num++] = wideValue % 10;
            wideValue /= 10;
        }

        for (i = 0; i < num; i++) {
            buf[pos++] = '0' + tmp[num - i - 1];
        }
    }
    buf[pos] = 0;

    JimSetStringBytes(objPtr, buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x18cc8
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
js 0x18cd6
xorl %esi, %esi
jmp 0x18d09
movb $0x30, -0x20(%rbp)
movl $0x1, %esi
jmp 0x18d67
negq %rcx
movq %rcx, %rax
mulq %r8
movb $0x2d, -0x20(%rbp)
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %ecx, %esi
subl %eax, %esi
movb %sil, -0x40(%rbp)
movl $0x1, %r9d
movl $0x1, %esi
cmpq $0xa, %rcx
movq %rdx, %rcx
jb 0x18d33
movq %rsi, %r9
movq %rcx, %rax
mulq %r8
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %ecx, %r10d
subl %eax, %r10d
movb %r10b, -0x40(%rbp,%r9)
incq %r9
cmpq $0xa, %rcx
movq %rdx, %rcx
jae 0x18d0c
movslq %r9d, %rdx
movl %edx, %eax
leaq (%rsi,%rbp), %rcx
addq $-0x20, %rcx
leaq -0x40(%rbp), %r8
addq %rdx, %r8
decq %r8
negq %rax
xorl %edx, %edx
movb (%r8,%rdx), %r9b
addb $0x30, %r9b
movb %r9b, (%rcx)
incq %rcx
decq %rdx
cmpq %rdx, %rax
jne 0x18d4f
subl %edx, %esi
movb $0x0, -0x20(%rbp,%rsi)
leaq -0x20(%rbp), %rsi
callq 0x18d7b
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: UpdateStringOfDouble
static void UpdateStringOfDouble(struct Jim_Obj *objPtr)
{
    double value = objPtr->internalRep.doubleValue;

    if (isnan(value)) {
        JimSetStringBytes(objPtr, "NaN");
        return;
    }
    if (isinf(value)) {
        if (value < 0) {
            JimSetStringBytes(objPtr, "-Inf");
        }
        else {
            JimSetStringBytes(objPtr, "Inf");
        }
        return;
    }
    {
        char buf[JIM_DOUBLE_SPACE + 1];
        int i;
        int len = sprintf(buf, "%.12g", value);


        for (i = 0; i < len; i++) {
            if (buf[i] == '.' || buf[i] == 'e') {
#if defined(JIM_SPRINTF_DOUBLE_NEEDS_FIX)
                char *e = strchr(buf, 'e');
                if (e && (e[1] == '-' || e[1] == '+') && e[2] == '0') {

                    e += 2;
                    memmove(e, e + 1, len - (e - buf));
                }
#endif
                break;
            }
        }
        if (buf[i] == '\0') {
            buf[i++] = '.';
            buf[i++] = '0';
            buf[i] = '\0';
        }
        JimSetStringBytes(objPtr, buf);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movsd 0x18(%rdi), %xmm0
ucomisd %xmm0, %xmm0
jp 0x18e8a
movsd 0xe9a1(%rip), %xmm2     # 0x27798
divsd %xmm0, %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jne 0x18e16
jp 0x18e16
ucomisd %xmm0, %xmm1
jbe 0x18e4b
leaq 0x12e6e(%rip), %rsi     # 0x2bc82
jmp 0x18e52
leaq 0x12e6a(%rip), %rsi     # 0x2bc87
leaq -0x30(%rbp), %rdi
movb $0x1, %al
callq 0x6480
testl %eax, %eax
jle 0x18e60
movl %eax, %ecx
xorl %eax, %eax
movzbl -0x30(%rbp,%rax), %edx
cmpl $0x2e, %edx
je 0x18e62
cmpl $0x65, %edx
je 0x18e62
incq %rax
cmpq %rax, %rcx
jne 0x18e30
movl %ecx, %eax
jmp 0x18e62
leaq 0x12e31(%rip), %rsi     # 0x2bc83
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %rbp
jmp 0x18d7b
xorl %eax, %eax
movl %eax, %eax
cmpb $0x0, -0x30(%rbp,%rax)
jne 0x18e77
movw $0x302e, -0x30(%rbp,%rax) # imm = 0x302E
movb $0x0, -0x2e(%rbp,%rax)
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x18d7b
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
leaq 0x12ded(%rip), %rsi     # 0x2bc7e
jmp 0x18e52
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: FreeListInternalRep
void FreeListInternalRep(Jim_Interp *interp, Jim_Obj *objPtr)
{
    int i;

    for (i = 0; i < objPtr->internalRep.listValue.len; i++) {
        Jim_DecrRefCount(interp, objPtr->internalRep.listValue.ele[i]);
    }
    Jim_Free(objPtr->internalRep.listValue.ele);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x0, 0x20(%rsi)
jle 0x18ede
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rax
movl 0x10(%rax), %ecx
leal -0x1(%rcx), %edx
movl %edx, 0x10(%rax)
cmpl $0x1, %ecx
jg 0x18ed2
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x758c
incq %r15
movslq 0x20(%rbx), %rax
cmpq %rax, %r15
jl 0x18eac
movq 0x1e3a3(%rip), %rax     # 0x37288
movq 0x18(%rbx), %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: DupListInternalRep
void DupListInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
{
    int i;

    JIM_NOTUSED(interp);

    dupPtr->internalRep.listValue.len = srcPtr->internalRep.listValue.len;
    dupPtr->internalRep.listValue.maxLen = srcPtr->internalRep.listValue.maxLen;
    dupPtr->internalRep.listValue.ele =
        Jim_Alloc(sizeof(Jim_Obj *) * srcPtr->internalRep.listValue.maxLen);
    memcpy(dupPtr->internalRep.listValue.ele, srcPtr->internalRep.listValue.ele,
        sizeof(Jim_Obj *) * srcPtr->internalRep.listValue.len);
    for (i = 0; i < dupPtr->internalRep.listValue.len; i++) {
        Jim_IncrRefCount(dupPtr->internalRep.listValue.ele[i]);
    }
    dupPtr->typePtr = &listObjType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl 0x20(%rsi), %eax
movl %eax, 0x20(%rdx)
movslq 0x24(%rsi), %rsi
movl %esi, 0x24(%rdx)
shlq $0x3, %rsi
xorl %edi, %edi
callq *0x1e36b(%rip)          # 0x37288
movq %rax, 0x18(%rbx)
movq 0x18(%r14), %rsi
movslq 0x20(%r14), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x6320
cmpl $0x0, 0x20(%rbx)
jle 0x18f54
xorl %eax, %eax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
incl 0x10(%rcx)
incq %rax
movslq 0x20(%rbx), %rcx
cmpq %rcx, %rax
jl 0x18f3d
leaq 0x1c40d(%rip), %rax     # 0x35368
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: ListEnsureLength
static void ListEnsureLength(Jim_Obj *listPtr, int idx)
{
    assert(idx >= 0);
    if (idx >= listPtr->internalRep.listValue.maxLen) {
        if (idx < 4) {

            idx = 4;
        }
        listPtr->internalRep.listValue.ele = Jim_Realloc(listPtr->internalRep.listValue.ele,
            sizeof(Jim_Obj *) * idx);

        listPtr->internalRep.listValue.maxLen = idx;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testl %esi, %esi
js 0x193d9
movq %rdi, %rbx
cmpl %esi, 0x24(%rdi)
jg 0x193d4
cmpl $0x5, %esi
movl $0x4, %r14d
cmovael %esi, %r14d
movq 0x18(%rbx), %rdi
leaq (,%r14,8), %rsi
callq *0x1debc(%rip)          # 0x37288
movq %rax, 0x18(%rbx)
movl %r14d, 0x24(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1290c(%rip), %rdi     # 0x2bcec
leaq 0x117c4(%rip), %rsi     # 0x2abab
leaq 0x12907(%rip), %rcx     # 0x2bcf5
movl $0x31bd, %edx           # imm = 0x31BD
callq 0x6220
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: JimDictExpandHashTable
static void JimDictExpandHashTable(Jim_Dict *dict, unsigned int size)
{
    int i;
    struct JimDictHashEntry *prevht = dict->ht;
    int prevsize = dict->size;

    dict->size = JimHashTableNextPower(size);
    dict->sizemask = dict->size - 1;


    dict->ht = Jim_Alloc(dict->size * sizeof(*dict->ht));
    memset(dict->ht, 0, dict->size * sizeof(*dict->ht));


    for (i = 0; i < prevsize; i++) {
        if (prevht[i].offset > 0) {

            unsigned h = prevht[i].hash;
            unsigned idx = h & dict->sizemask;
            unsigned peturb = h;

            while (dict->ht[idx].offset) {
                peturb >>= 5;
                idx = (5 * idx + 1 + peturb) & dict->sizemask;
            }
            dict->ht[idx].offset = prevht[i].offset;
            dict->ht[idx].hash = h;
        }
    }
    Jim_Free(prevht);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %r15d
testl %esi, %esi
js 0x19460
movl $0x10, %ecx
movl %ecx, %eax
leal (%rax,%rax), %ecx
cmpl %esi, %eax
jb 0x19455
jmp 0x19465
movl $0x80000000, %eax       # imm = 0x80000000
movq (%rbx), %r14
movl %eax, 0x8(%rbx)
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rbx)
movl %eax, %esi
shlq $0x3, %rsi
xorl %edi, %edi
callq *0x1de09(%rip)          # 0x37288
movq %rax, (%rbx)
movl 0x8(%rbx), %edx
shlq $0x3, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x6240
testl %r15d, %r15d
jle 0x194e6
xorl %eax, %eax
movl (%r14,%rax,8), %ecx
testl %ecx, %ecx
jle 0x194de
movl 0x4(%r14,%rax,8), %edx
movl 0xc(%rbx), %edi
movq (%rbx), %rsi
movl %edx, %r8d
andl %edi, %r8d
cmpl $0x0, (%rsi,%r8,8)
je 0x194d5
movl %edx, %r9d
shrl $0x5, %r9d
leal (%r8,%r8,4), %r8d
addl %r9d, %r8d
incl %r8d
andl %edi, %r8d
cmpl $0x0, (%rsi,%r8,8)
jne 0x194bd
movl %ecx, (%rsi,%r8,8)
movl %edx, 0x4(%rsi,%r8,8)
incq %rax
cmpq %r15, %rax
jne 0x1949a
movq 0x1dd9b(%rip), %rax     # 0x37288
movq %r14, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax