LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x8(%rdi), %rax
cmpl %eax, 0xc(%rdi)
jne 0x180b6
movl %r8d, -0x2c(%rbp)
leal (%rax,%rax), %ecx
movl %ecx, 0x8(%r13)
movq (%r13), %rdi
leaq 0x10(%r13), %rbx
shlq $0x4, %rax
movq 0x20206(%rip), %rcx     # 0x38288
leaq (%rax,%rax,2), %rsi
cmpq %rbx, %rdi
je 0x18093
callq *%rcx
movq %rax, (%r13)
jmp 0x180b2
xorl %edi, %edi
callq *%rcx
movq %rax, (%r13)
movslq 0xc(%r13), %rcx
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6320
movl -0x2c(%rbp), %r8d
movq (%r13), %rax
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_O1/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 %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq %rax, 0x10(%rdi)
movl 0xc(%rdi), %eax
movl %eax, 0x20(%rdi)
callq 0x64e0
movq (%rax), %rsi
movq (%rbx), %rcx
movzbl (%rcx), %edx
testb $0x20, 0x1(%rsi,%rdx,2)
jne 0x18121
cmpl $0x5c, %edx
jne 0x18141
cmpb $0xa, 0x1(%rcx)
jne 0x18141
cmpl $0x5c, %edx
je 0x1812d
cmpl $0xa, %edx
jne 0x18139
jmp 0x18141
incq %rcx
movq %rcx, (%rbx)
decl 0x8(%rbx)
incl 0xc(%rbx)
incq (%rbx)
decl 0x8(%rbx)
jmp 0x18106
decq %rcx
movq %rcx, 0x18(%rbx)
movl $0x6, 0x24(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x184f8
testl %ecx, %ecx
je 0x1852b
cmpl $0xa, %ecx
jne 0x1850b
jmp 0x18516
incq %rax
movq %rax, (%rdi)
decl 0x8(%rdi)
je 0x18524
cmpb $0xa, (%rax)
jne 0x1850b
incl 0xc(%rdi)
incq %rax
movq %rax, (%rdi)
decl 0x8(%rdi)
jmp 0x184e5
incq %rax
movq %rax, (%rdi)
decl 0x8(%rdi)
incl 0xc(%rdi)
jmp 0x1852b
movl $0x5c, 0x34(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
incq (%rdi)
movl 0x8(%rdi), %edx
movl %edx, %ecx
decl %ecx
movl %ecx, 0x8(%rdi)
je 0x185ab
movq (%rdi), %rsi
movl $0x1, %eax
movzbl (%rsi), %r8d
cmpl $0x7a, %r8d
jg 0x1857d
cmpl $0xa, %r8d
je 0x1858f
cmpl $0x5c, %r8d
jne 0x18596
cmpl $0x3, %edx
jl 0x18596
leaq 0x1(%rsi), %r8
movq %r8, (%rdi)
cmpb $0xa, 0x1(%rsi)
jne 0x18573
incl 0xc(%rdi)
addl $-0x2, %edx
movl %edx, 0x8(%rdi)
movl %edx, %ecx
jmp 0x18599
cmpl $0x7b, %r8d
je 0x18594
cmpl $0x7d, %r8d
jne 0x18596
decl %eax
jne 0x18596
jmp 0x185c4
incl 0xc(%rdi)
jmp 0x18596
incl %eax
movq %rsi, %r8
movl %ecx, %edx
incq %r8
movq %r8, (%rdi)
movq %r8, %rsi
decl %ecx
movl %ecx, 0x8(%rdi)
jne 0x18548
movl $0x7b, 0x34(%rdi)
movl 0x20(%rdi), %eax
movl %eax, 0x38(%rdi)
movq (%rdi), %rax
decq %rax
movq %rax, 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 0x185c2
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
movq %rdi, %rbx
movl 0x20(%rdi), %r14d
incq (%rdi)
decl 0x8(%rdi)
movl $0x1, %eax
movl $0x1, %r15d
testl %eax, %eax
sete %r12b
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0x186ad
movq (%rbx), %rcx
movzbl (%rcx), %edx
cmpl $0x22, %edx
jne 0x18632
testb $0x1, %r12b
jne 0x18688
movq %rbx, %rdi
callq 0x186e0
cmpl $0x22, 0x34(%rbx)
jne 0x18603
jmp 0x186c2
cmpl $0x5b, %edx
jle 0x18649
cmpl $0x7b, %edx
jne 0x18658
movq %rbx, %rdi
callq 0x1852d
movb $0x1, %r12b
jmp 0x18603
cmpl $0xa, %edx
je 0x1867e
cmpl $0x5b, %edx
jne 0x18688
incl %r15d
jmp 0x18688
cmpl $0x5d, %edx
je 0x18683
cmpl $0x5c, %edx
jne 0x18688
cmpl $0x2, %eax
jl 0x18688
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
cmpb $0xa, 0x1(%rcx)
jne 0x18677
incl 0xc(%rbx)
decl %eax
movl %eax, 0x8(%rbx)
jmp 0x18688
incl 0xc(%rbx)
jmp 0x18688
decl %r15d
je 0x186cb
callq 0x64e0
movq (%rax), %rax
movq (%rbx), %rcx
movzbl (%rcx), %edx
movzwl (%rax,%rdx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
incq %rcx
movq %rcx, (%rbx)
decl 0x8(%rbx)
jmp 0x185fd
movl $0x5b, 0x34(%rbx)
movl %r14d, 0x38(%rbx)
movq (%rbx), %rax
decq %rax
movq %rax, 0x18(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x1(%rcx), %rdx
movq %rdx, 0x18(%rbx)
incq %rcx
movq %rcx, (%rbx)
decl %eax
movl %eax, 0x8(%rbx)
jmp 0x186c2
// File: /workspace/github_c_makefile_star2_O1/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 0x8(%rdi), %ecx
movl 0x20(%rdi), %r14d
incq (%rdi)
decl %ecx
movl %ecx, 0x8(%rdi)
movl $0x1, %eax
je 0x18768
movq (%rbx), %rdx
movzbl (%rdx), %esi
cmpl $0x5a, %esi
jg 0x1871c
cmpl $0xa, %esi
je 0x18747
cmpl $0x24, %esi
je 0x18740
cmpl $0x22, %esi
jne 0x1874a
jmp 0x18782
cmpl $0x5b, %esi
je 0x18759
cmpl $0x5c, %esi
jne 0x1874a
cmpl $0x2, %ecx
jl 0x1874a
leaq 0x1(%rdx), %rax
movq %rax, (%rbx)
cmpb $0xa, 0x1(%rdx)
jne 0x1873b
incl 0xc(%rbx)
decl %ecx
movl %ecx, 0x8(%rbx)
movl $0x2, %eax
jmp 0x1874a
incl 0xc(%rbx)
incq (%rbx)
decl 0x8(%rbx)
movl 0x8(%rbx), %ecx
testl %ecx, %ecx
jne 0x18700
jmp 0x18768
movq %rbx, %rdi
callq 0x185da
movl $0x2, %eax
jmp 0x18750
movl $0x22, 0x34(%rbx)
movl %r14d, 0x38(%rbx)
movq (%rbx), %rcx
decq %rcx
movq %rcx, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x1(%rdx), %rsi
movq %rsi, 0x18(%rbx)
incq %rdx
movq %rdx, (%rbx)
decl %ecx
movl %ecx, 0x8(%rbx)
jmp 0x1877d
// File: /workspace/github_c_makefile_star2_O1/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 %rsi, %r14
movq %rdi, %rbx
cmpl $0x2, 0xc(%rsi)
jne 0x187fb
movq (%r14), %rdi
movslq 0x8(%r14), %r15
movl $0x5c, %esi
movq %r15, %rdx
callq 0x6290
testq %rax, %rax
je 0x187fb
movq %r15, %rsi
incq %rsi
xorl %edi, %edi
callq *0x1fab3(%rip)          # 0x38288
movq %rax, %r12
movq (%r14), %rsi
movq %rax, %rdi
movl %r15d, %edx
callq 0x18812
movq %rbx, %rdi
movq %r12, %rsi
movl %eax, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xaf08
movq (%r14), %rsi
movl 0x8(%r14), %edx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7516
// File: /workspace/github_c_makefile_star2_O1/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), %rax
leaq 0x1e1fb(%rip), %r14     # 0x36d80
cmpq %r14, %rax
je 0x18c4a
movq %rsi, %rbx
movq %rdi, %r13
leaq 0x1e20d(%rip), %rcx     # 0x36da8
cmpq %rcx, %rax
je 0x18c13
movq %r13, %r14
cmpq $0x0, (%rbx)
jne 0x18baf
movq %rbx, %rdi
callq *0x18(%rax)
movslq 0x14(%rbx), %rax
movq %rax, -0x30(%rbp)
movq (%rbx), %r13
movq %r13, %rdi
movl $0x28, %esi
callq 0x61c0
movq %rax, %r12
movl %r12d, %edx
subl %r13d, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x7516
movq %rax, %r15
incq %r12
movq -0x30(%rbp), %rcx
leaq (%rcx,%r13), %rdx
subl %r12d, %edx
xorl %eax, %eax
cmpb $0x29, -0x1(%r13,%rcx)
movq %r14, %r13
sete %al
subl %eax, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x7516
movq %rax, %r12
leaq 0x1e16f(%rip), %r14     # 0x36d80
jmp 0x18c1b
movq 0x18(%rbx), %r15
movq 0x20(%rbx), %r12
incl 0x10(%r15)
incl 0x10(%r12)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x18c3e
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x18c3e
movq %r13, %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_O1/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 0x98ef
testq %rax, %rax
je 0x18d10
movq %rax, %r13
leaq -0x30(%rbp), %rcx
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0xf4d9
testl %eax, %eax
je 0x18d14
leaq 0x13f38(%rip), %rax     # 0x2cc24
leaq 0x13f40(%rip), %r8      # 0x2cc33
cmovsq %rax, %r8
leaq 0x13f06(%rip), %rsi     # 0x2cc04
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x692d
jmp 0x18d3a
xorl %eax, %eax
jmp 0x18d3e
testb $0x4, %r12b
je 0x18d3a
cmpl $0x2, 0x10(%r13)
jl 0x18d3a
movq %r14, %rdi
movq %r13, %rsi
callq 0x8fa8
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x871b
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_O1/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
cmpq $0x0, (%rdi)
jne 0x18e33
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movslq 0x14(%r14), %rcx
movq (%r14), %rdx
cmpq $0x2, %rcx
jl 0x18e61
cmpb $0x3a, (%rdx)
jne 0x18e61
cmpb $0x3a, 0x1(%rdx)
jne 0x18e61
movq %rcx, %rax
addq %rdx, %rax
cmpb $0x3a, (%rdx)
jne 0x18e61
incq %rdx
decl %ecx
jne 0x18e51
xorl %ecx, %ecx
jmp 0x18e64
movq %rdx, %rax
movl %ecx, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x18e70
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 0x18f25
movq 0x18(%r14), %rax
movl 0x10(%rax), %ecx
leal -0x1(%rcx), %edx
movl %edx, 0x10(%rax)
cmpl $0x1, %ecx
jg 0x18ea8
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x759a
movq 0x20(%r14), %rax
movl 0x10(%rax), %ecx
leal -0x1(%rcx), %edx
movl %edx, 0x10(%rax)
cmpl $0x1, %ecx
jg 0x18ec6
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x759a
movq 0x50(%r14), %rax
movl 0x10(%rax), %ecx
leal -0x1(%rcx), %edx
movl %edx, 0x10(%rax)
cmpl $0x1, %ecx
jg 0x18ee4
movq 0x50(%r14), %rsi
movq %rbx, %rdi
callq 0x759a
movq 0x28(%r14), %r15
testq %r15, %r15
je 0x18f37
movq %r15, %rdi
callq 0xabc9
movq (%r15), %rdi
xorl %esi, %esi
callq *0x1f388(%rip)          # 0x38288
movq $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movl $0x0, 0x28(%r15)
movq 0x28(%r14), %rdi
xorl %esi, %esi
callq *0x1f365(%rip)          # 0x38288
jmp 0x18f37
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x18f37
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq *%rax
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0x18f48
movq %rbx, %rdi
callq 0x18e6b
movq 0x1c0(%rbx), %rax
movq %rax, 0x8(%r14)
movq %r14, 0x1c0(%rbx)
cmpl $0x0, 0xac(%rbx)
jne 0x18fa8
movl 0x1c8(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x1c8(%rbx)
cmpl $0x3e7, %eax            # imm = 0x3E7
jl 0x18fa8
incq 0x98(%rbx)
movq 0x8(%r14), %r15
movq %r14, %rdi
xorl %esi, %esi
callq *0x1f2f9(%rip)          # 0x38288
movq %r15, 0x1c0(%rbx)
movq %r15, %r14
testq %r15, %r15
jne 0x18f80
movl $0x0, 0x1c8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: 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 0x19149
movq %rsi, %rbx
decl %eax
movl %eax, 0x10(%rsi)
je 0x1911a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x19135
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x19135
callq 0x759a
movq 0x1f14c(%rip), %rax     # 0x38288
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
leaq 0x13af6(%rip), %rdi     # 0x2cc46
leaq 0x12aac(%rip), %rsi     # 0x2bc03
leaq 0x13af9(%rip), %rcx     # 0x2cc57
movl $0x2799, %edx           # imm = 0x2799
callq 0x6220
// File: /workspace/github_c_makefile_star2_O1/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 0x19253
xorl %r8d, %r8d
testq %rcx, %rcx
jns 0x191da
movb $0x2d, -0x20(%rbp)
movabsq $0x6666666666666667, %rdx # imm = 0x6666666666666667
movq %rcx, %rax
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
shrl $0x2, %edx
addl %eax, %edx
addl %edx, %edx
leal (%rdx,%rdx,4), %eax
movl %ecx, %edx
subl %eax, %edx
negb %dl
movb %dl, -0x40(%rbp)
movabsq $-0x6666666666666667, %rdx # imm = 0x9999999999999999
movq %rcx, %rax
imulq %rdx
movq %rdx, %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x2, %rcx
addq %rax, %rcx
movl $0x1, %r8d
movl %r8d, %esi
movl %r8d, %r9d
testq %rcx, %rcx
je 0x19219
movabsq $-0x3333333333333333, %r10 # imm = 0xCCCCCCCCCCCCCCCD
movq %rsi, %r9
movq %rcx, %rax
mulq %r10
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %ecx, %r11d
subl %eax, %r11d
movb %r11b, -0x40(%rbp,%r9)
incq %r9
cmpq $0xa, %rcx
movq %rdx, %rcx
jae 0x191f2
testl %r9d, %r9d
je 0x1924e
movslq %r9d, %rcx
movl %r9d, %eax
leaq -0x40(%rbp), %rdx
addq %rdx, %rcx
decq %rcx
negq %rax
xorl %edx, %edx
movb (%rcx,%rdx), %r8b
addb $0x30, %r8b
movb %r8b, -0x20(%rbp,%rsi)
incq %rsi
decq %rdx
cmpq %rdx, %rax
jne 0x19233
movl %esi, %r8d
movl %r8d, %eax
jmp 0x1925c
movb $0x30, -0x20(%rbp)
movl $0x1, %eax
movb $0x0, -0x20(%rbp,%rax)
leaq -0x20(%rbp), %rsi
callq 0x19270
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1937f
movsd 0xf504(%rip), %xmm2     # 0x287f0
divsd %xmm0, %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jne 0x1930b
jp 0x1930b
ucomisd %xmm0, %xmm1
jbe 0x19340
leaq 0x139d7(%rip), %rsi     # 0x2cce0
jmp 0x19347
leaq 0x139d3(%rip), %rsi     # 0x2cce5
leaq -0x30(%rbp), %rdi
movb $0x1, %al
callq 0x6480
testl %eax, %eax
jle 0x19355
movl %eax, %ecx
xorl %eax, %eax
movzbl -0x30(%rbp,%rax), %edx
cmpl $0x2e, %edx
je 0x19357
cmpl $0x65, %edx
je 0x19357
incq %rax
cmpq %rax, %rcx
jne 0x19325
movl %ecx, %eax
jmp 0x19357
leaq 0x1399a(%rip), %rsi     # 0x2cce1
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %rbp
jmp 0x19270
xorl %eax, %eax
movl %eax, %eax
cmpb $0x0, -0x30(%rbp,%rax)
jne 0x1936c
movw $0x302e, -0x30(%rbp,%rax) # imm = 0x302E
movb $0x0, -0x2e(%rbp,%rax)
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x19270
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
leaq 0x13956(%rip), %rsi     # 0x2ccdc
jmp 0x19347
// File: /workspace/github_c_makefile_star2_O1/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 0x193d3
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 0x193c7
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x759a
incq %r15
movslq 0x20(%rbx), %rax
cmpq %rax, %r15
jl 0x193a1
movq 0x1eeae(%rip), %rax     # 0x38288
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_O1/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)
movl 0x24(%rsi), %eax
movl %eax, 0x24(%rdx)
movslq 0x24(%rsi), %rsi
shlq $0x3, %rsi
xorl %edi, %edi
callq *0x1ee73(%rip)          # 0x38288
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 0x1944c
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 0x19435
leaq 0x1cf05(%rip), %rax     # 0x36358
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x198a4
movq %rdi, %rbx
cmpl %esi, 0x24(%rdi)
jg 0x1989f
cmpl $0x5, %esi
movl $0x4, %r14d
cmovgel %esi, %r14d
movq 0x18(%rbx), %rdi
leaq (,%r14,8), %rsi
callq *0x1e9f1(%rip)          # 0x38288
movq %rax, 0x18(%rbx)
movl %r14d, 0x24(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1349f(%rip), %rdi     # 0x2cd4a
leaq 0x12351(%rip), %rsi     # 0x2bc03
leaq 0x1349a(%rip), %rcx     # 0x2cd53
movl $0x31bd, %edx           # imm = 0x31BD
callq 0x6220
// File: /workspace/github_c_makefile_star2_O1/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 0x1992b
movl $0x10, %ecx
movl %ecx, %eax
leal (%rax,%rax), %ecx
cmpl %esi, %eax
jb 0x19920
jmp 0x19930
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 *0x1e93e(%rip)          # 0x38288
movq %rax, (%rbx)
movl 0x8(%rbx), %edx
shlq $0x3, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x6240
testl %r15d, %r15d
jle 0x199b1
xorl %eax, %eax
movl (%r14,%rax,8), %ecx
testl %ecx, %ecx
jle 0x199a9
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 0x199a0
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 0x19988
movl %ecx, (%rsi,%r8,8)
movl %edx, 0x4(%rsi,%r8,8)
incq %rax
cmpq %r15, %rax
jne 0x19965
movq 0x1e8d0(%rip), %rax     # 0x38288
movq %r14, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: DupDictInternalRep
static void DupDictInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
{
    Jim_Dict *oldDict = srcPtr->internalRep.dictValue;
    int i;


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


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


    newDict->uniq = oldDict->uniq;


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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x18(%rdi), %edx
cmpl $-0x1, %edx
je 0x19b08
testl %edx, %edx
sets %al
cmpl $0x80000001, %edx       # imm = 0x80000001
setne %cl
testb %cl, %al
jne 0x19b1d
leaq 0x14649(%rip), %rsi     # 0x2e14f
jmp 0x19b26
leaq 0x1383a(%rip), %rsi     # 0x2d349
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %rbp
jmp 0x19270
incl %edx
leaq 0x132ae(%rip), %rsi     # 0x2cdd4
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
callq 0x6480
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x19270
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimParseExprOperator
static int JimParseExprOperator(struct JimParserCtx *pc)
{
    int i;
    const struct Jim_ExprOperator *bestOp = NULL;
    int bestLen = 0;


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

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

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


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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, -0x38(%rbp)
movq (%rdi), %rax
movq %rax, -0x48(%rbp)
movb (%rax), %al
xorl %r14d, %r14d
leaq 0x1d2d4(%rip), %r13     # 0x36e40
xorl %esi, %esi
xorl %r12d, %r12d
movb %al, -0x29(%rbp)
movq (%r14,%r13), %rdi
cmpb %al, (%rdi)
jne 0x19bad
movzbl 0x13(%r14,%r13), %r15d
cmpl %r15d, %esi
jge 0x19bad
leaq (%r14,%r13), %rcx
movq %rcx, -0x40(%rbp)
movl %r15d, %edx
movl %esi, %ebx
movq -0x48(%rbp), %rsi
callq 0x60b0
movl %ebx, %esi
testl %eax, %eax
movb -0x29(%rbp), %al
cmoveq -0x40(%rbp), %r12
cmovel %r15d, %esi
addq $0x18, %r14
cmpq $0x3f0, %r14            # imm = 0x3F0
jne 0x19b74
movl $0x1, %edi
testq %r12, %r12
je 0x19c58
testb $0x1, 0x12(%r12)
movslq %esi, %rbx
je 0x19c16
movq -0x38(%rbp), %rax
movq (%rax), %r14
addq %rbx, %r14
movl 0x8(%rax), %r15d
cmpl %ebx, %r15d
je 0x19c10
movl %esi, -0x40(%rbp)
callq 0x64e0
movl $0x1, %edi
movl -0x40(%rbp), %esi
movq (%rax), %rax
movl %esi, %ecx
subl %r15d, %ecx
movzbl (%r14), %edx
testb $0x20, 0x1(%rax,%rdx,2)
je 0x19c10
incq %r14
incl %ecx
jne 0x19bfe
cmpb $0x28, (%r14)
jne 0x19c49
movq -0x38(%rbp), %rdx
movq (%rdx), %rax
leaq (%rax,%rbx), %rcx
addq %rbx, %rax
decq %rax
movq %rax, 0x18(%rdx)
movq %rcx, (%rdx)
subl %esi, 0x8(%rdx)
subq %r13, %r12
shrq $0x3, %r12
imull $0xaaaaaaab, %r12d, %eax # imm = 0xAAAAAAAB
addl $0x14, %eax
movl %eax, 0x24(%rdx)
xorl %edi, %edi
jmp 0x19c58
leaq 0x1326f(%rip), %rax     # 0x2cebf
movq -0x38(%rbp), %rcx
movq %rax, 0x40(%rcx)
movl %edi, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimParseExprBoolean
static int JimParseExprBoolean(struct JimParserCtx *pc)
{
    int i;
    for (i = 0; i < sizeof(jim_true_false_strings) / sizeof(*jim_true_false_strings); i++) {
        if (strncmp(pc->p, jim_true_false_strings[i], jim_true_false_lens[i]) == 0) {
            pc->p += jim_true_false_lens[i];
            pc->len -= jim_true_false_lens[i];
            pc->tend = pc->p - 1;
            pc->tt = JIM_TT_EXPR_BOOLEAN;
            return JIM_OK;
        }
    }
    return JIM_ERR;
}

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

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

    if (result == 1) {

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0x1ac50
cmpl $0x1, %eax
jne 0x1a448
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x1ac50
cmpl $-0x1, %eax
je 0x1a495
movslq %eax, %r15
movq %rbx, %rdi
callq 0xae58
movq %rax, %r14
leaq 0x1be7e(%rip), %rax     # 0x362e0
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movq %r15, 0x18(%r14)
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1a48e
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %eax, %eax
jmp 0x1a49a
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimExprOpOr
static int JimExprOpOr(Jim_Interp *interp, struct JimExprNode *node)
{

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

    if (result == 0) {

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0x1ac50
testl %eax, %eax
jne 0x1a4ce
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x1ac50
cmpl $-0x1, %eax
je 0x1a51b
movslq %eax, %r15
movq %rbx, %rdi
callq 0xae58
movq %rax, %r14
leaq 0x1bdf8(%rip), %rax     # 0x362e0
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
movq %r15, 0x18(%r14)
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x1a514
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %eax, %eax
jmp 0x1a520
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimExprOpIntUnary
static int JimExprOpIntUnary(Jim_Interp *interp, struct JimExprNode *node)
{
    jim_wide wA;
    Jim_Obj *A;
    int rc;

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

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

    Jim_DecrRefCount(interp, A);

    return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0xfb9b
movl %eax, %r14d
testl %eax, %eax
jne 0x1aa09
movq (%rbx), %r15
incl 0x10(%r15)
testl %r14d, %r14d
jne 0x1ab4a
leaq 0x1b8c7(%rip), %rax     # 0x362e0
cmpq %rax, 0x8(%r15)
je 0x1aa3d
movl $0x1, %r14d
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0xd6d7
testl %eax, %eax
je 0x1aa3d
xorl %eax, %eax
jmp 0x1aa4a
movq 0x18(%r15), %rax
movq %rax, -0x30(%rbp)
xorl %r14d, %r14d
movb $0x1, %al
testb %al, %al
je 0x1ab2f
movl (%r12), %eax
cmpl $0x3d, %eax
je 0x1aa91
cmpl $0x34, %eax
jne 0x1ab5c
movq -0x30(%rbp), %r13
notq %r13
movq %rbx, %rdi
callq 0xae58
movq %rax, %r12
leaq 0x1b863(%rip), %rax     # 0x362e0
movq %rax, 0x8(%r12)
movq $0x0, (%r12)
movq %r13, 0x18(%r12)
jmp 0x1ab0e
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
movl $0x8, %edx
callq 0x1ace4
leaq -0x48(%rbp), %r12
movq %rbx, %rdi
movq %r12, %rsi
movl $0x8, %edx
callq 0x1ae0f
movsd (%r12), %xmm0
unpcklps 0xd58d(%rip), %xmm0     # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xd595(%rip), %xmm0     # 0x28060
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0xdd19(%rip), %xmm1     # 0x287f8
movapd %xmm1, -0x40(%rbp)
movq %rbx, %rdi
callq 0xae58
movq %rax, %r12
leaq 0x1b83a(%rip), %rax     # 0x36330
movq %rax, 0x8(%r12)
movq $0x0, (%r12)
movaps -0x40(%rbp), %xmm0
movsd %xmm0, 0x18(%r12)
incl 0x10(%r12)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x2, %eax
jge 0x1ab2c
movq %rbx, %rdi
callq 0x759a
movq %r12, (%rbx)
movl 0x10(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r15)
cmpl $0x1, %eax
jg 0x1ab4a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x759a
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x6070
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimPowWide
static jim_wide JimPowWide(jim_wide b, jim_wide e)
{
    jim_wide res = 1;


    if (b == 1) {

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

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

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

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


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


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

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

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

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

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

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

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

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


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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
cmpq $0x0, 0x208(%rdi)
jne 0x1ae34
movq %r15, %rdi
callq 0x1ad7e
testl %r14d, %r14d
je 0x1ae92
movq 0x208(%r15), %rax
movl %r14d, %ecx
xorl %edx, %edx
movl 0x100(%rax), %esi
incl %esi
movzbl %sil, %esi
movl %esi, 0x100(%rax)
movb (%rax,%rsi), %dil
movb 0x104(%rax), %r8b
addb %dil, %r8b
movzbl %r8b, %r8d
movl %r8d, 0x104(%rax)
movb (%rax,%r8), %r9b
movb %r9b, (%rax,%rsi)
movb %dil, (%rax,%r8)
addb %dil, %r9b
movzbl %r9b, %esi
movb (%rax,%rsi), %sil
movb %sil, (%rbx,%rdx)
incq %rdx
cmpl %edx, %ecx
jne 0x1ae45
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq