LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: clock_cmd_format
static int clock_cmd_format(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{

    char buf[100];
    time_t t;
    jim_wide seconds;
    struct clock_options options = { 0, "%a %b %d %H:%M:%S %Z %Y" };
    struct tm *tm;

    if (Jim_GetWide(interp, argv[0], &seconds) != JIM_OK) {
        return JIM_ERR;
    }
    if (argc % 2 == 0) {
        return -1;
    }
    if (parse_clock_options(interp, argc - 1, argv + 1, &options) == JIM_ERR) {
        return JIM_ERR;
    }

    t = seconds;
    tm = options.gmt ? gmtime(&t) : localtime(&t);

    if (tm == NULL || strftime(buf, sizeof(buf), options.format, tm) == 0) {
        Jim_SetResultString(interp, "format string too long or invalid time", -1);
        return JIM_ERR;
    }

    Jim_SetResultString(interp, buf, -1);

    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r15
movl %esi, %r14d
movq %rdi, %rbx
movups 0x1cc1c(%rip), %xmm0    # 0x31ce0
movaps %xmm0, -0x40(%rbp)
movq (%rdx), %rsi
leaq -0x48(%rbp), %rdx
callq 0xc979
pushq $0x1
popq %r12
testl %eax, %eax
jne 0x1515b
testb $0x1, %r14b
jne 0x150e6
pushq $-0x1
jmp 0x15159
decl %r14d
movslq %r14d, %r12
xorl %r13d, %r13d
pushq $0x3
popq %r14
cmpq %r12, %r13
jge 0x15170
movq 0x8(%r15,%r13,8), %rsi
movq %rbx, %rdi
leaq 0x1cbe9(%rip), %rdx     # 0x31cf0
leaq -0xb0(%rbp), %rcx
xorl %r8d, %r8d
movl %r14d, %r9d
callq 0x7b44
testl %eax, %eax
jne 0x15157
movl -0xb0(%rbp), %eax
cmpl $0x1, %eax
je 0x15143
testl %eax, %eax
jne 0x15151
movq 0x10(%r15,%r13,8), %rsi
movq %rbx, %rdi
leaq -0x40(%rbp), %rdx
callq 0xd397
testl %eax, %eax
je 0x15151
jmp 0x15157
movq 0x10(%r15,%r13,8), %rdi
callq 0x7340
movq %rax, -0x38(%rbp)
addq $0x2, %r13
jmp 0x150f3
pushq $0x1
popq %r12
movl %r12d, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x40(%rbp)
je 0x15189
leaq -0x30(%rbp), %rdi
callq 0x6450
jmp 0x15192
leaq -0x30(%rbp), %rdi
callq 0x6060
pushq $0x1
popq %r12
testq %rax, %rax
je 0x151f2
movq -0x38(%rbp), %rdx
leaq -0xb0(%rbp), %rdi
pushq $0x64
popq %rsi
movq %rax, %rcx
callq 0x63e0
testq %rax, %rax
je 0x151f2
leaq -0xb0(%rbp), %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x7363
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x151e7
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %r12d, %r12d
jmp 0x1515b
leaq 0x128b4(%rip), %rsi     # 0x27aad
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x7363
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x15223
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
jmp 0x1515b
// File: /workspace/github_c_makefile_star2_O2/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 0x9378
testq %rax, %rax
je 0x153f7
movq %rax, %r14
cmpl $0x1, %r12d
je 0x153b8
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x153b8
leaq 0x12b47(%rip), %rdx     # 0x27eee
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7223
testl %eax, %eax
jne 0x153bb
jmp 0x15402
xorl %r15d, %r15d
leaq 0x1c046(%rip), %rax     # 0x31408
cmpq %rax, 0x8(%r14)
jne 0x15402
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8b3c
testb $0x1, %al
jne 0x15402
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x153f4
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rcx
pushq $0x3
popq %r8
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1027a
// File: /workspace/github_c_makefile_star2_O2/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 0x9378
testq %rax, %rax
je 0x1544b
cmpl $0x1, %r15d
jne 0x15458
xorl %edx, %edx
jmp 0x1545c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %rdx
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %rax, %rsi
movl %ecx, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1027a
// File: /workspace/github_c_makefile_star2_O2/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 0x8b3c
movl %eax, -0x2c(%rbp)
testb $0x1, %al
jne 0x1552b
movq (%r14), %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x9378
testq %rax, %rax
je 0x15580
movq %rax, %r13
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10391
testl %eax, %eax
js 0x1555f
cmpl $0x2, 0x10(%r13)
movq %r14, -0x38(%rbp)
jl 0x154eb
movq %rbx, %rdi
movq %r13, %rsi
callq 0x8a95
movq %rax, %r13
xorl %r14d, %r14d
cmpl -0x2c(%rbp), %r14d
jge 0x15571
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0xd95e
movq %rax, %r12
leal 0x1(%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd95e
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0xe0b0
addl $0x2, %r14d
jmp 0x154ee
leaq 0x125ec(%rip), %rsi     # 0x27b1e
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x7363
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1555c
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x38(%rbp), %rax
movq (%rax), %rsi
movq %rbx, %rdi
movq %r13, %rdx
jmp 0x15589
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 0x8306
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdx), %rsi
xorl %r14d, %r14d
xorl %edx, %edx
callq 0x9378
testq %rax, %rax
je 0x155ca
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10391
movl %eax, %r14d
testl %eax, %eax
js 0x155fe
movl %r14d, %esi
movq %rbx, %rdi
callq 0x8212
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x155f4
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8212
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x2, %eax
jl 0x155ec
jmp 0x155f4
// File: /workspace/github_c_makefile_star2_O2/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 0x9378
testq %rax, %rax
je 0x1564c
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x103bc
movq (%r14), %rdx
leaq 0x124f2(%rip), %rsi     # 0x27b48
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x68a7
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1569d
movq 0x8(%r14), %rsi
leaq 0x1285d(%rip), %rdx     # 0x27eee
movq %rbx, %rdi
callq 0x7223
testl %eax, %eax
je 0x156bb
movq (%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xbccd
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 0x9378
testq %rax, %rax
je 0x156aa
leaq -0x2c(%rbp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe69c
testq %rax, %rax
je 0x15742
movq %rax, %r15
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xe3f7
movq %rax, -0x38(%rbp)
movslq -0x2c(%rbp), %r12
cmpq %r12, %r13
jge 0x1572e
movq 0x8(%r14), %rsi
movq (%r15,%r13,8), %rdx
xorl %ecx, %ecx
callq 0xa85d
testl %eax, %eax
jne 0x15728
movq (%r15,%r13,8), %rdx
movq 0x8(%r15,%r13,8), %rcx
movq %rbx, %rdi
movq -0x38(%rbp), %rsi
callq 0xe0b0
addq $0x2, %r13
jmp 0x156fb
movq (%r14), %rsi
movq %rbx, %rdi
movq -0x38(%rbp), %rdx
callq 0x8306
jmp 0x156aa
leaq 0x13ef8(%rip), %rsi     # 0x29641
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x7363
movq %rax, %r14
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x15773
movq %rbx, %rdi
callq 0x73bf
movq %r14, (%rbx)
jmp 0x156aa
// File: /workspace/github_c_makefile_star2_O2/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 %ecx, %r13d
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
movq $0x0, -0x40(%rbp)
testb $0x1, %r13b
jne 0x157bd
xorl %r12d, %r12d
jmp 0x157cc
pushq $0x1
popq %r12
movl %r15d, %edi
callq 0x60e0
movl %eax, %r15d
testb $0x2, %r13b
jne 0x157d7
xorl %r13d, %r13d
jmp 0x1580d
xorl %eax, %eax
cmpb $0x5e, (%rbx)
sete %al
subl %eax, %r14d
xorl %r13d, %r13d
cmpb $0x5d, (%rbx,%rax)
movq %rax, -0x40(%rbp)
leaq (%rbx,%rax), %rbx
jne 0x1580d
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
movl %r12d, %edx
callq 0x158c9
leaq -0x30(%rbp), %rax
movl (%rax), %eax
jmp 0x158b4
testl %r14d, %r14d
je 0x15884
movzbl (%rbx), %eax
cmpl $0x5d, %eax
je 0x15884
cmpl $0x5c, %eax
je 0x157f3
movq %rbx, %rdi
leaq -0x2c(%rbp), %rsi
movl %r12d, %edx
callq 0x158c9
cmpl $0x3, %r14d
jl 0x158ae
cmpb $0x2d, 0x1(%rbx)
jne 0x158ae
leaq 0x2(%rbx), %rdi
leaq -0x34(%rbp), %rsi
movl %r12d, %edx
callq 0x158c9
movl -0x2c(%rbp), %eax
cmpl %eax, %r15d
setl %dl
movl -0x34(%rbp), %ecx
cmpl %ecx, %r15d
setg %sil
orb %dl, %sil
cmpb $0x1, %sil
jne 0x15876
cmpl %ecx, %r15d
setl %cl
cmpl %eax, %r15d
setg %al
orb %cl, %al
jne 0x1587a
pushq $0x1
popq %r13
addq $0x3, %rbx
addl $-0x3, %r14d
jmp 0x1580d
xorl %eax, %eax
testl %r13d, %r13d
sete %al
cmpl $0x0, -0x40(%rbp)
cmovel %r13d, %eax
xorl %ecx, %ecx
testl %eax, %eax
cmoveq %rcx, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
incq %rbx
decl %r14d
cmpl %r15d, %eax
pushq $0x1
popq %rax
cmovel %eax, %r13d
jmp 0x1580d
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: utf8_tounicode_case
static int utf8_tounicode_case(const char *s, int *uc, int upper)
{
    int l = utf8_tounicode(s, uc);
    if (upper) {
        *uc = utf8_upper(*uc);
    }
    return l;
}

// Assembly:
movzbl (%rdi), %edi
movl %edi, (%rsi)
testl %edx, %edx
je 0x158e8
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x60e0
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1593d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0x10(%rbx), %rax
cmpq %rax, %r12
jge 0x15975
movq (%rbx), %rax
movq (%rax,%r15), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1596c
movq %r14, %rdi
callq 0x73bf
incq %r12
addq $0x10, %r15
jmp 0x15946
movq (%rbx), %rdi
xorl %esi, %esi
callq *0x1d908(%rip)          # 0x33288
movq 0x8(%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1599a
movq %r14, %rdi
callq 0x73bf
movq 0x1d8e7(%rip), %rax     # 0x33288
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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 0x15a2e
movl %r8d, -0x2c(%rbp)
leal (%rcx,%rcx), %edx
movl %edx, 0x8(%r13)
leaq 0x10(%r13), %rbx
imulq $0x30, %rcx, %rsi
movq 0x1d88d(%rip), %rcx     # 0x33288
cmpq %rbx, %rax
je 0x15a0b
movq %rax, %rdi
callq *%rcx
movq %rax, (%r13)
jmp 0x15a2a
xorl %edi, %edi
callq *%rcx
movq %rax, (%r13)
movslq 0xc(%r13), %rcx
imulq $0x18, %rcx, %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)
imulq $0x18, %rcx, %rcx
movq %r12, (%rax,%rcx)
movl %r15d, 0x8(%rax,%rcx)
movl %r14d, 0xc(%rax,%rcx)
movl %r8d, 0x10(%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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 0x15a9c
cmpl $0x5c, %ecx
jne 0x15ac7
cmpb $0xa, 0x1(%r14)
je 0x15aab
jmp 0x15ac7
cmpl $0x5c, %ecx
je 0x15aab
cmpl $0xa, %ecx
je 0x15ac7
movl 0x8(%rbx), %ecx
jmp 0x15aba
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 0x15a80
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_O2/msteveb[P]autosetup/./jimsh0.c
// Function: JimParseCmd
static int JimParseCmd(struct JimParserCtx *pc)
{
    pc->tstart = pc->p + 1;
    pc->tline = pc->linenr;
    pc->tt = JIM_TT_CMD;
    JimParseSubCmd(pc);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
incq %rax
movq %rax, 0x10(%rdi)
movl 0xc(%rdi), %eax
movl %eax, 0x20(%rdi)
movl $0x5, 0x24(%rdi)
popq %rbp
jmp 0x15fd0
// File: /workspace/github_c_makefile_star2_O2/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 0x15ed4
testl %ecx, %ecx
je 0x15f0e
cmpl $0xa, %ecx
je 0x15ef9
movl 0x8(%rdi), %ecx
jmp 0x15eec
incq %rax
movq %rax, (%rdi)
movl 0x8(%rdi), %ecx
decl %ecx
movl %ecx, 0x8(%rdi)
je 0x15f07
cmpb $0xa, (%rax)
jne 0x15eec
incl 0xc(%rdi)
incq %rax
movq %rax, (%rdi)
decl %ecx
movl %ecx, 0x8(%rdi)
jmp 0x15ebe
incq %rax
movq %rax, (%rdi)
decl 0x8(%rdi)
incl 0xc(%rdi)
jmp 0x15f0e
movl $0x5c, 0x34(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: JimParseBrace
static int JimParseBrace(struct JimParserCtx *pc)
{
    pc->tstart = pc->p + 1;
    pc->tline = pc->linenr;
    pc->tt = JIM_TT_STR;
    JimParseSubBrace(pc);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
incq %rax
movq %rax, 0x10(%rdi)
movl 0xc(%rdi), %eax
movl %eax, 0x20(%rdi)
movl $0x1, 0x24(%rdi)
popq %rbp
jmp 0x15f2e
// File: /workspace/github_c_makefile_star2_O2/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), %rdx
incq %rdx
movq %rdx, (%rdi)
movl 0x8(%rdi), %esi
movl $0x1, %eax
movl %esi, %ecx
decl %ecx
movl %ecx, 0x8(%rdi)
je 0x15fa4
movzbl (%rdx), %r8d
cmpl $0xa, %r8d
je 0x15f91
cmpl $0x7d, %r8d
je 0x15f87
cmpl $0x7b, %r8d
je 0x15f8d
cmpl $0x5c, %r8d
jne 0x15f94
cmpl $0x3, %esi
jl 0x15f94
leaq 0x1(%rdx), %r8
movq %r8, (%rdi)
cmpb $0xa, 0x1(%rdx)
jne 0x15f7d
incl 0xc(%rdi)
addl $-0x2, %esi
movl %esi, 0x8(%rdi)
movl %esi, %ecx
jmp 0x15f97
decl %eax
jne 0x15f94
jmp 0x15fba
incl %eax
jmp 0x15f94
incl 0xc(%rdi)
movq %rdx, %r8
incq %r8
movq %r8, (%rdi)
movq %r8, %rdx
movl %ecx, %esi
jmp 0x15f45
movl $0x7b, 0x34(%rdi)
movl 0x20(%rdi), %eax
movl %eax, 0x38(%rdi)
decq %rdx
movq %rdx, 0x18(%rdi)
popq %rbp
retq
leaq -0x1(%rdx), %rax
movq %rax, 0x18(%rdi)
incq %rdx
movq %rdx, (%rdi)
addl $-0x2, %esi
movl %esi, 0x8(%rdi)
jmp 0x15fb8
// File: /workspace/github_c_makefile_star2_O2/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 0x8(%rdi), %r12d
movl 0x20(%rdi), %eax
movl %eax, -0x2c(%rbp)
incq (%rdi)
decl %r12d
movl %r12d, 0x8(%rdi)
pushq $0x1
popq %r15
movl %r15d, %r13d
testl %r12d, %r12d
je 0x160ae
movq (%rbx), %rax
movzbl (%rax), %ecx
cmpl $0x22, %ecx
je 0x16022
cmpl $0x7b, %ecx
jne 0x1603f
movq %rbx, %rdi
callq 0x15f2e
xorl %r13d, %r13d
jmp 0x16039
testl %r13d, %r13d
je 0x16081
movq %rbx, %rdi
callq 0x160eb
cmpl $0x22, 0x34(%rbx)
je 0x160c5
movl 0x8(%rbx), %r12d
jmp 0x15ffc
cmpl $0xa, %ecx
je 0x1607e
cmpl $0x5b, %ecx
je 0x16079
cmpl $0x5d, %ecx
je 0x16072
cmpl $0x5c, %ecx
jne 0x16081
cmpl $0x2, %r12d
jl 0x16081
leaq 0x1(%rax), %r14
movq %r14, (%rbx)
cmpb $0xa, 0x1(%rax)
jne 0x16069
incl 0xc(%rbx)
decl %r12d
movl %r12d, 0x8(%rbx)
jmp 0x16084
decl %r15d
jne 0x16081
jmp 0x160d4
incl %r15d
jmp 0x16081
incl 0xc(%rbx)
movq %rax, %r14
callq 0x64e0
movq (%rax), %rax
movzbl (%r14), %ecx
movzwl (%rax,%rcx,2), %r13d
andl $0x2000, %r13d          # imm = 0x2000
incq %r14
movq %r14, (%rbx)
decl %r12d
movl %r12d, 0x8(%rbx)
jmp 0x15ffc
movl $0x5b, 0x34(%rbx)
movl -0x2c(%rbp), %eax
movl %eax, 0x38(%rbx)
movq (%rbx), %rax
decq %rax
movq %rax, 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 0x160c5
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0x20(%rdi), %r14d
incq (%rdi)
decl %ecx
movl %ecx, 0x8(%rdi)
pushq $0x1
popq %rax
pushq $0x2
popq %r15
testl %ecx, %ecx
je 0x16177
movq (%rbx), %rdx
movzbl (%rdx), %esi
cmpl $0xa, %esi
je 0x16164
cmpl $0x24, %esi
je 0x16133
cmpl $0x5b, %esi
je 0x16154
cmpl $0x5c, %esi
je 0x16138
cmpl $0x22, %esi
jne 0x16167
jmp 0x16197
movq %rdx, %rsi
jmp 0x1614f
cmpl $0x2, %ecx
jl 0x16167
leaq 0x1(%rdx), %rsi
movq %rsi, (%rbx)
cmpb $0xa, 0x1(%rdx)
jne 0x1614d
incl 0xc(%rbx)
decl %ecx
movl %r15d, %eax
jmp 0x1616a
movq %rbx, %rdi
callq 0x15fd0
movl 0x8(%rbx), %ecx
movl %r15d, %eax
jmp 0x1610e
incl 0xc(%rbx)
movq %rdx, %rsi
incq %rsi
movq %rsi, (%rbx)
decl %ecx
movl %ecx, 0x8(%rbx)
jmp 0x1610e
movl $0x22, 0x34(%rbx)
movl %r14d, 0x38(%rbx)
movq (%rbx), %rcx
decq %rcx
movq %rcx, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x1(%rdx), %rsi
movq %rsi, 0x18(%rbx)
incq %rdx
movq %rdx, (%rbx)
decl %ecx
movl %ecx, 0x8(%rbx)
jmp 0x1618c
// File: /workspace/github_c_makefile_star2_O2/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 0x16211
movq %rsi, %r15
pushq $0x5c
popq %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0x6290
testq %rax, %rax
je 0x16211
movq %r14, %rsi
incq %rsi
xorl %edi, %edi
callq *0x1d09d(%rip)          # 0x33288
movq %rax, %r12
movq (%r15), %rsi
movq %rax, %rdi
movl %r14d, %edx
callq 0x16227
movq %rbx, %rdi
movq %r12, %rsi
movl %eax, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa654
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7363
// File: /workspace/github_c_makefile_star2_O2/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 0x1b7cf(%rip), %r13     # 0x31d80
cmpq %r13, %rcx
je 0x16670
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1b7e1(%rip), %rax     # 0x31da8
cmpq %rax, %rcx
je 0x16642
leaq -0x2c(%rbp), %rsi
movq %rbx, %rdi
callq 0x7fc7
movq %rax, %r13
pushq $0x28
popq %rsi
movq %rax, %rdi
callq 0x61c0
movq %rax, %r12
movl %r12d, %edx
subl %r13d, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x7363
movq %rax, %r15
incq %r12
leaq -0x2c(%rbp), %rax
movslq (%rax), %rax
leaq (%rax,%r13), %rdx
subl %r12d, %edx
xorl %ecx, %ecx
cmpb $0x29, -0x1(%r13,%rax)
leaq 0x1b763(%rip), %r13     # 0x31d80
sete %cl
subl %ecx, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x7363
incl 0x10(%r15)
movq %rax, %r12
incl 0x10(%rax)
movq 0x8(%rbx), %rax
testq %rax, %rax
jne 0x16653
jmp 0x16664
movq 0x18(%rbx), %r15
movq 0x20(%rbx), %r12
incl 0x10(%r15)
incl 0x10(%r12)
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x16664
movq %r14, %rdi
movq %rbx, %rsi
callq *%rax
movq %r13, 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_O2/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
andq $0x0, -0x30(%rbp)
pushq $0x1
popq %rdx
callq 0x9378
testq %rax, %rax
je 0x16731
movq %rax, %r13
leaq -0x30(%rbp), %rcx
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0xe4cf
testl %eax, %eax
je 0x16735
leaq 0x11509(%rip), %rax     # 0x27c16
leaq 0x11511(%rip), %r8      # 0x27c25
cmovsq %rax, %r8
leaq 0x114d7(%rip), %rsi     # 0x27bf6
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x68a7
jmp 0x1675b
xorl %eax, %eax
jmp 0x1675f
testb $0x4, %r12b
je 0x1675b
cmpl $0x2, 0x10(%r13)
jl 0x1675b
movq %r14, %rdi
movq %r13, %rsi
callq 0x8a95
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x8306
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_O2/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
subq $0x10, %rsp
movq %rsi, %rbx
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x7fc7
movl (%r14), %ecx
cmpl $0x2, %ecx
jl 0x1685a
cmpb $0x3a, (%rax)
jne 0x1685a
cmpb $0x3a, 0x1(%rax)
jne 0x1685a
cmpb $0x3a, (%rax)
jne 0x1685a
incq %rax
decl %ecx
movl %ecx, -0x14(%rbp)
jne 0x16849
xorl %ecx, %ecx
movl %ecx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
decl (%rsi)
jne 0x16956
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x4(%rsi)
je 0x168f6
movq 0x18(%r14), %rax
movl 0x10(%rax), %ecx
leal -0x1(%rcx), %edx
movl %edx, 0x10(%rax)
cmpl $0x1, %ecx
jg 0x1689e
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x73bf
movq 0x20(%r14), %rax
movl 0x10(%rax), %ecx
leal -0x1(%rcx), %edx
movl %edx, 0x10(%rax)
cmpl $0x1, %ecx
jg 0x168bc
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x73bf
movq 0x50(%r14), %rax
movl 0x10(%rax), %ecx
leal -0x1(%rcx), %edx
movl %edx, 0x10(%rax)
cmpl $0x1, %ecx
jg 0x168da
movq 0x50(%r14), %rsi
movq %rbx, %rdi
callq 0x73bf
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x16908
callq 0xa3ca
movq 0x28(%r14), %rdi
xorl %esi, %esi
callq *0x1c994(%rip)          # 0x33288
jmp 0x16908
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x16908
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq *%rax
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0x16919
movq %rbx, %rdi
callq 0x16865
movq 0x1c0(%rbx), %rax
movq %rax, 0x8(%r14)
movq %r14, 0x1c0(%rbx)
cmpl $0x0, 0xac(%rbx)
jne 0x16956
movl 0x1c8(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x1c8(%rbx)
cmpl $0x3e7, %eax            # imm = 0x3E7
jl 0x16956
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xb41b
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x16a71
movq %rsi, %rbx
decl %eax
movl %eax, 0x10(%rsi)
je 0x16a42
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x16a5d
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x16a5d
callq 0x73bf
movq 0x1c824(%rip), %rax     # 0x33288
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
leaq 0x111c0(%rip), %rdi     # 0x27c38
leaq 0x1017c(%rip), %rsi     # 0x26bfb
leaq 0x111c3(%rip), %rcx     # 0x27c49
movl $0x2799, %edx           # imm = 0x2799
callq 0x6220
// File: /workspace/github_c_makefile_star2_O2/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), %rax
testq %rax, %rax
je 0x16b07
xorl %ecx, %ecx
pushq $0xa
popq %rsi
testq %rax, %rax
jns 0x16abd
movb $0x2d, -0x20(%rbp)
negq %rax
xorl %edx, %edx
divq %rsi
movb %dl, -0x40(%rbp)
pushq $0x1
popq %rcx
movl %ecx, %ecx
movq %rcx, %r8
testq %rax, %rax
je 0x16ad6
xorl %edx, %edx
divq %rsi
movb %dl, -0x40(%rbp,%r8)
incq %r8
jmp 0x16ac2
movslq %r8d, %rax
leaq (%rax,%rbp), %rdx
addq $-0x41, %rdx
leaq -0x20(%rbp), %rsi
xorl %eax, %eax
movq %r8, %r9
addq %rax, %r9
je 0x16b03
movb (%rdx,%rax), %r9b
addb $0x30, %r9b
movb %r9b, (%rsi,%rcx)
decq %rax
incq %rsi
jmp 0x16ae7
subl %eax, %ecx
jmp 0x16b0e
movb $0x30, -0x20(%rbp)
pushq $0x1
popq %rcx
movb $0x0, -0x20(%rbp,%rcx)
leaq -0x20(%rbp), %rsi
callq 0x16b22
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x16bfe
movsd 0xcc1a(%rip), %xmm2     # 0x23788
divsd %xmm0, %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jne 0x16b8d
jp 0x16b8d
ucomisd %xmm0, %xmm1
jbe 0x16bbf
leaq 0x11147(%rip), %rsi     # 0x27cd2
jmp 0x16bc6
leaq 0x11143(%rip), %rsi     # 0x27cd7
leaq -0x30(%rbp), %rdi
movb $0x1, %al
callq 0x6480
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0x16bd6
movzbl -0x30(%rbp,%rcx), %edx
cmpl $0x2e, %edx
je 0x16bd4
cmpl $0x65, %edx
je 0x16bd4
incq %rcx
jmp 0x16ba6
leaq 0x1110d(%rip), %rsi     # 0x27cd3
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %rbp
jmp 0x16b22
movl %ecx, %eax
movl %eax, %eax
cmpb $0x0, -0x30(%rbp,%rax)
jne 0x16beb
movw $0x302e, -0x30(%rbp,%rax) # imm = 0x302E
movb $0x0, -0x2e(%rbp,%rax)
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x16b22
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
leaq 0x110c9(%rip), %rsi     # 0x27cce
jmp 0x16bc6
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %r14
xorl %r15d, %r15d
movslq 0x20(%rbx), %rax
cmpq %rax, %r15
jge 0x16c4e
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 0x16c49
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x73bf
incq %r15
jmp 0x16c1a
movq 0x1c633(%rip), %rax     # 0x33288
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_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
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 %r15d, %r15d
xorl %edi, %edi
callq *0x1c5f5(%rip)          # 0x33288
movq %rax, 0x18(%rbx)
movq 0x18(%r14), %rsi
movslq 0x20(%r14), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x6320
movslq 0x20(%rbx), %rax
cmpq %rax, %r15
jge 0x16cc4
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rax
incl 0x10(%rax)
incq %r15
jmp 0x16cab
leaq 0x1a73d(%rip), %rax     # 0x31408
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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 0x170a8
movq %rdi, %rbx
cmpl %esi, 0x24(%rdi)
jg 0x170a3
cmpl $0x5, %esi
pushq $0x4
popq %r14
cmovael %esi, %r14d
movq 0x18(%rbx), %rdi
leaq (,%r14,8), %rsi
callq *0x1c1ed(%rip)          # 0x33288
movq %rax, 0x18(%rbx)
movl %r14d, 0x24(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x10c8d(%rip), %rdi     # 0x27d3c
leaq 0xfb45(%rip), %rsi      # 0x26bfb
leaq 0x10c88(%rip), %rcx     # 0x27d45
movl $0x31bd, %edx           # imm = 0x31BD
callq 0x6220
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %r14
movq (%rdi), %rbx
movl 0x8(%rdi), %r12d
movl %esi, %edi
callq 0xa024
movl %eax, 0x8(%r14)
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%r14)
movl %eax, %esi
shlq $0x3, %rsi
xorl %r15d, %r15d
xorl %edi, %edi
callq *0x1c14a(%rip)          # 0x33288
movq %rax, (%r14)
movl 0x8(%r14), %edx
shlq $0x3, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x6240
testl %r12d, %r12d
movl $0x0, %eax
cmovgl %r12d, %eax
cmpq %rax, %r15
je 0x171a6
movl (%rbx,%r15,8), %ecx
testl %ecx, %ecx
jle 0x171a1
movl 0x4(%rbx,%r15,8), %edx
movl 0xc(%r14), %edi
movq (%r14), %rsi
movl %edx, %r8d
movl %edx, %r9d
andl %edi, %r8d
cmpl $0x0, (%rsi,%r8,8)
je 0x17198
shrl $0x5, %r9d
leal (%r8,%r8,4), %r8d
addl %r9d, %r8d
incl %r8d
jmp 0x1717e
movl %ecx, (%rsi,%r8,8)
movl %edx, 0x4(%rsi,%r8,8)
incq %r15
jmp 0x1715f
movq 0x1c0db(%rip), %rax     # 0x33288
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax