LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_GetCommand
Jim_Cmd *Jim_GetCommand(Jim_Interp *interp, Jim_Obj *objPtr, int flags)
{
    Jim_Cmd *cmd;

    if (objPtr->typePtr == &commandObjType
        && objPtr->internalRep.cmdValue.procEpoch == interp->procEpoch
#ifdef jim_ext_namespace
        && Jim_StringEqObj(objPtr->internalRep.cmdValue.nsObj, interp->framePtr->nsObj)
#endif
        && objPtr->internalRep.cmdValue.cmdPtr->inUse) {

        cmd = objPtr->internalRep.cmdValue.cmdPtr;
    }
    else {
        Jim_Obj *qualifiedNameObj = JimQualifyName(interp, objPtr);
        Jim_HashEntry *he = Jim_FindHashEntry(&interp->commands, qualifiedNameObj);
#ifdef jim_ext_namespace
        if (he == NULL && Jim_Length(interp->framePtr->nsObj)) {
            he = Jim_FindHashEntry(&interp->commands, objPtr);
        }
#endif
        if (he == NULL) {
            if (flags & JIM_ERRMSG) {
                Jim_SetResultFormatted(interp, "invalid command name \"%#s\"", objPtr);
            }
            Jim_DecrRefCount(interp, qualifiedNameObj);
            return NULL;
        }
        cmd = Jim_GetHashEntryVal(he);

        cmd->cmdNameObj = Jim_GetHashEntryKey(he);


        Jim_FreeIntRep(interp, objPtr);
        objPtr->typePtr = &commandObjType;
        objPtr->internalRep.cmdValue.procEpoch = interp->procEpoch;
        objPtr->internalRep.cmdValue.cmdPtr = cmd;
        objPtr->internalRep.cmdValue.nsObj = interp->framePtr->nsObj;
        Jim_IncrRefCount(interp->framePtr->nsObj);
        Jim_DecrRefCount(interp, qualifiedNameObj);
    }
    while (cmd->u.proc.upcall) {
        cmd = cmd->prevCmd;
    }
    return cmd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r13d
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2fa39(%rip), %rax     # 0x36228
cmpq %rax, 0x8(%rsi)
jne 0x6810
movq 0x28(%rbx), %rax
cmpq 0x98(%r14), %rax
jne 0x6810
movq 0x20(%rbx), %r15
cmpl $0x0, (%r15)
jne 0x68aa
incl 0x10(%rbx)
leaq 0x68(%r14), %rdi
movq %rbx, %rsi
callq 0xac8e
movq %rax, %r12
testq %rax, %rax
je 0x68c3
movq (%r12), %rax
movq 0x8(%r12), %r15
movq %rax, 0x10(%r15)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x6852
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x6852
movq %r14, %rdi
movq %rbx, %rsi
callq *%rax
leaq 0x2f9cf(%rip), %rax     # 0x36228
movq %rax, 0x8(%rbx)
movq 0x98(%r14), %rax
movq %rax, 0x28(%rbx)
movq %r15, 0x20(%rbx)
movq 0x58(%r14), %rax
movq 0x78(%rax), %rax
movq %rax, 0x18(%rbx)
movq 0x58(%r14), %rax
movq 0x78(%rax), %rax
incl 0x10(%rax)
movl 0x10(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
cmpl $0x1, %eax
jg 0x689c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x759a
testq %r12, %r12
jne 0x68aa
xorl %r15d, %r15d
jmp 0x68b1
movq 0x8(%r15), %r15
cmpl $0x0, 0x40(%r15)
jne 0x68a6
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testb $0x1, %r13b
je 0x68dd
leaq 0x253e1(%rip), %rsi     # 0x2bcb1
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x692d
movl 0x10(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
cmpl $0x2, %eax
jl 0x6891
jmp 0x689c
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_aioInit
int Jim_aioInit(Jim_Interp *interp)
{
    if (Jim_PackageProvide(interp, "aio", "1.0", JIM_ERRMSG))
        return JIM_ERR;

#if defined(JIM_SSL)
    Jim_CreateCommand(interp, "load_ssl_certs", JimAioLoadSSLCertsCommand, NULL, NULL);
#endif

    Jim_CreateCommand(interp, "open", JimAioOpenCommand, NULL, NULL);
#ifdef HAVE_SOCKETS
    Jim_CreateCommand(interp, "socket", JimAioSockCommand, NULL, NULL);
#endif
#ifdef HAVE_PIPE
    Jim_CreateCommand(interp, "pipe", JimAioPipeCommand, NULL, NULL);
#endif


    JimMakeChannel(interp, fileno(stdin), NULL, "stdin", 0, AIO_KEEPOPEN);
    JimMakeChannel(interp, fileno(stdout), NULL, "stdout", 0, AIO_KEEPOPEN);
    JimMakeChannel(interp, fileno(stderr), NULL, "stderr", 0, AIO_KEEPOPEN | AIO_WBUF_NONE);

    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x25a00(%rip), %rsi     # 0x2c5ab
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
leaq 0xfc(%rip), %rdx        # 0x6cb8
movq %rbx, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xbe8d
leaq 0x25ddc(%rip), %rsi     # 0x2c9af
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
leaq 0x3b8(%rip), %rdx       # 0x6f9f
movq %rbx, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xbe8d
movq 0x3138a(%rip), %rax     # 0x37f88
movq (%rax), %rdi
callq 0x6340
leaq 0x24e26(%rip), %rcx     # 0x2ba33
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
movl $0x1, %r8d
callq 0x70b7
movq 0x31352(%rip), %rax     # 0x37f78
movq (%rax), %rdi
callq 0x6340
leaq 0x24e04(%rip), %rcx     # 0x2ba39
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
movl $0x1, %r8d
callq 0x70b7
movq 0x313aa(%rip), %rax     # 0x37ff8
movq (%rax), %rdi
callq 0x6340
leaq 0x24de3(%rip), %rcx     # 0x2ba40
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
movl $0x9, %r8d
callq 0x70b7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimAioPipeCommand
static int JimAioPipeCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    if (argc != 1) {
        Jim_WrongNumArgs(interp, 1, argv, "");
        return JIM_ERR;
    }
    return JimCreatePipe(interp, argv[0], 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1, %esi
jne 0x706d
movq (%rdx), %r15
leaq -0x20(%rbp), %rdi
callq 0x6270
testl %eax, %eax
jne 0x7099
movl -0x20(%rbp), %esi
leaq 0x2564b(%rip), %rcx     # 0x2c61e
movq %rbx, %rdi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0x70b7
testq %rax, %rax
je 0x7089
movq %rbx, %rdi
callq 0xae58
movq %rax, %r14
leaq 0x2f35c(%rip), %rax     # 0x36358
movq %rax, 0x8(%r14)
movq $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movq (%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7695
movl -0x1c(%rbp), %esi
leaq 0x255f7(%rip), %rcx     # 0x2c61e
movq %rbx, %rdi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0x70b7
testq %rax, %rax
je 0x7089
movq (%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7695
incl 0x10(%r14)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x7065
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %r14d, %r14d
jmp 0x70a9
leaq 0x275df(%rip), %rcx     # 0x2e653
movl $0x1, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7454
jmp 0x70a9
movl -0x20(%rbp), %edi
callq 0x6260
movl -0x1c(%rbp), %edi
callq 0x6260
movq %rbx, %rdi
xorl %esi, %esi
callq 0x14d8d
movl $0x1, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_CompareStringImmediate
int Jim_CompareStringImmediate(Jim_Interp *interp, Jim_Obj *objPtr, const char *str)
{
    if (objPtr->typePtr == &comparedStringObjType && objPtr->internalRep.ptr == str) {
        return 1;
    }
    else {
        if (strcmp(str, Jim_String(objPtr)) != 0)
            return 0;

        if (objPtr->typePtr != &comparedStringObjType) {
            Jim_FreeIntRep(interp, objPtr);
            objPtr->typePtr = &comparedStringObjType;
        }
        objPtr->internalRep.ptr = (char *)str;
        return 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rsi), %rax
leaq 0x2edbb(%rip), %r12     # 0x361b0
cmpq %r12, %rax
jne 0x7400
cmpq %rbx, 0x18(%r14)
je 0x7446
cmpq $0x0, (%r14)
jne 0x740c
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x62e0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x744b
movq 0x8(%r14), %rax
cmpq %r12, %rax
je 0x7442
testq %rax, %rax
je 0x743e
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x743e
movq %r15, %rdi
movq %r14, %rsi
callq *%rax
movq %r12, 0x8(%r14)
movq %rbx, 0x18(%r14)
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_WrongNumArgs
void Jim_WrongNumArgs(Jim_Interp *interp, int argc, Jim_Obj *const *argv, const char *msg)
{
    Jim_Obj *objPtr;
    Jim_Obj *listObjPtr;

    JimPanic((argc == 0, "Jim_WrongNumArgs() called with argc=0"));

    listObjPtr = Jim_NewListObj(interp, argv, argc);

    if (msg && *msg) {
        Jim_ListAppendElement(interp, listObjPtr, Jim_NewStringObj(interp, msg, -1));
    }
    Jim_IncrRefCount(listObjPtr);
    objPtr = Jim_ListJoin(interp, listObjPtr, " ", 1);
    Jim_DecrRefCount(interp, listObjPtr);

    Jim_SetResultFormatted(interp, "wrong # args: should be \"%#s\"", objPtr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %esi, %eax
movq %rdi, %rbx
movq %rdx, %rsi
movl %eax, %edx
callq 0x7640
movq %rax, %r14
testq %r15, %r15
je 0x749c
cmpb $0x0, (%r15)
je 0x749c
movq %rbx, %rdi
movq %r15, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7695
incl 0x10(%r14)
leaq 0x270cf(%rip), %rdx     # 0x2e576
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0xec0a
movq %rax, %r15
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0x74d5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x759a
leaq 0x24af3(%rip), %rsi     # 0x2bfcf
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x692d
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_NewStringObj
Jim_Obj *Jim_NewStringObj(Jim_Interp *interp, const char *s, int len)
{
    Jim_Obj *objPtr = Jim_NewObj(interp);


    if (len == -1)
        len = strlen(s);

    if (len == 0) {
        objPtr->bytes = JimEmptyStringRep;
    }
    else {
        objPtr->bytes = Jim_StrDupLen(s, len);
    }
    objPtr->length = len;


    objPtr->typePtr = NULL;
    return objPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
callq 0xae58
movq %rax, %rbx
cmpl $-0x1, %r14d
jne 0x7543
movq %r15, %rdi
callq 0x6180
movq %rax, %r14
testl %r14d, %r14d
je 0x7572
leal 0x1(%r14), %eax
movslq %eax, %rsi
xorl %edi, %edi
callq *0x30d31(%rip)          # 0x38288
movq %rax, %r12
movslq %r14d, %r13
movq %rax, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x6320
movb $0x0, (%r12,%r13)
jmp 0x7579
leaq 0x30d1f(%rip), %r12     # 0x38298
movq %r12, (%rbx)
movl %r14d, 0x14(%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %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_FreeObj
void Jim_FreeObj(Jim_Interp *interp, Jim_Obj *objPtr)
{

    JimPanic((objPtr->refCount != 0, "!!!Object %p freed with bad refcount %d, type=%s", objPtr,
        objPtr->refCount, objPtr->typePtr ? objPtr->typePtr->name : "<none>"));


    Jim_FreeIntRep(interp, objPtr);

    if (objPtr->bytes != NULL) {
        if (objPtr->bytes != JimEmptyStringRep)
            Jim_Free(objPtr->bytes);
    }

    if (objPtr->prevObjPtr)
        objPtr->prevObjPtr->nextObjPtr = objPtr->nextObjPtr;
    if (objPtr->nextObjPtr)
        objPtr->nextObjPtr->prevObjPtr = objPtr->prevObjPtr;
    if (interp->liveList == objPtr)
        interp->liveList = objPtr->nextObjPtr;
#ifdef JIM_DISABLE_OBJECT_POOL
    Jim_Free(objPtr);
#else

    objPtr->prevObjPtr = NULL;
    objPtr->nextObjPtr = interp->freeList;
    if (interp->freeList)
        interp->freeList->prevObjPtr = objPtr;
    interp->freeList = objPtr;
    objPtr->refCount = -1;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x75c1
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x75c1
movq %r14, %rdi
movq %rbx, %rsi
callq *%rax
movq (%rbx), %rdi
testq %rdi, %rdi
sete %al
leaq 0x30cc7(%rip), %rcx     # 0x38298
cmpq %rcx, %rdi
sete %cl
orb %al, %cl
jne 0x75e3
xorl %esi, %esi
callq *0x30ca5(%rip)          # 0x38288
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x75f4
movq 0x38(%rbx), %rcx
movq %rcx, 0x38(%rax)
movq 0x38(%rbx), %rcx
testq %rcx, %rcx
je 0x7601
movq %rax, 0x30(%rcx)
cmpq %rbx, 0xb8(%r14)
jne 0x7611
movq %rcx, 0xb8(%r14)
movq $0x0, 0x30(%rbx)
movq 0xc0(%r14), %rax
movq %rax, 0x38(%rbx)
testq %rax, %rax
je 0x762d
movq %rbx, 0x30(%rax)
movq %rbx, 0xc0(%r14)
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_NewListObj
Jim_Obj *Jim_NewListObj(Jim_Interp *interp, Jim_Obj *const *elements, int len)
{
    Jim_Obj *objPtr;

    objPtr = Jim_NewObj(interp);
    objPtr->typePtr = &listObjType;
    objPtr->bytes = NULL;
    objPtr->internalRep.listValue.ele = NULL;
    objPtr->internalRep.listValue.len = 0;
    objPtr->internalRep.listValue.maxLen = 0;

    if (len) {
        ListInsertElements(objPtr, 0, len, elements);
    }

    return objPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
callq 0xae58
movq %rax, %r15
leaq 0x2ecf9(%rip), %rax     # 0x36358
movq %rax, 0x8(%r15)
movq $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
testl %r14d, %r14d
je 0x7687
movq %r15, %rdi
xorl %esi, %esi
movl %r14d, %edx
movq %rbx, %rcx
callq 0xe29d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_ListAppendElement
void Jim_ListAppendElement(Jim_Interp *interp, Jim_Obj *listPtr, Jim_Obj *objPtr)
{
    JimPanic((Jim_IsShared(listPtr), "Jim_ListAppendElement called with shared object"));
    SetListFromAny(interp, listPtr);
    Jim_InvalidateStringRep(listPtr);
    ListAppendElement(listPtr, objPtr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
callq 0xe338
movq (%rbx), %rdi
testq %rdi, %rdi
sete %al
leaq 0x30bdd(%rip), %rcx     # 0x38298
cmpq %rcx, %rdi
sete %cl
orb %al, %cl
jne 0x76cd
xorl %esi, %esi
callq *0x30bbb(%rip)          # 0x38288
movq $0x0, (%rbx)
leaq -0x18(%rbp), %rcx
movq %r14, (%rcx)
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0xe29d
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_GetIndex
int Jim_GetIndex(Jim_Interp *interp, Jim_Obj *objPtr, int *indexPtr)
{

    if (objPtr->typePtr == &intObjType) {
        jim_wide val = JimWideValue(objPtr);

        if (val < 0)
            *indexPtr = -INT_MAX;
        else if (val > INT_MAX)
            *indexPtr = INT_MAX;
        else
            *indexPtr = (int)val;
        return JIM_OK;
    }
    if (objPtr->typePtr != &indexObjType && SetIndexFromAny(interp, objPtr) == JIM_ERR)
        return JIM_ERR;
    *indexPtr = objPtr->internalRep.intValue;
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rsi), %rax
leaq 0x2e20c(%rip), %rcx     # 0x362e0
cmpq %rcx, %rax
je 0x8154
leaq 0x2e2c8(%rip), %rcx     # 0x363a8
cmpq %rcx, %rax
je 0x8249
movq %rdi, %r15
movq %rbx, -0x38(%rbp)
cmpq $0x0, (%r14)
jne 0x80fc
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %rbx
leaq 0x25243(%rip), %rsi     # 0x2d349
movl $0x3, %edx
movq %rbx, %rdi
callq 0x60b0
movl %eax, %r12d
movq %r14, %r13
testl %eax, %eax
jne 0x8187
movq $0x0, -0x30(%rbp)
movzbl 0x3(%rbx), %eax
testl %eax, %eax
je 0x8184
cmpl $0x2d, %eax
je 0x813b
cmpl $0x2b, %eax
jne 0x81c0
addq $0x3, %rbx
movq %r15, %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rax, %r13
jmp 0x8187
movq 0x18(%r14), %rax
testq %rax, %rax
js 0x8172
movl $0x80000000, %ecx       # imm = 0x80000000
cmpq %rcx, %rax
jl 0x817d
movl $0x7fffffff, (%rbx)     # imm = 0x7FFFFFFF
jmp 0x824f
movl $0x80000001, (%rbx)     # imm = 0x80000001
jmp 0x824f
movl %eax, (%rbx)
jmp 0x824f
xorl %r13d, %r13d
testq %r13, %r13
je 0x81db
incl 0x10(%r13)
leaq -0x30(%rbp), %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0xd80a
movl %eax, %ebx
movl 0x10(%r13), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r13)
cmpl $0x1, %eax
jg 0x81bc
movq %r15, %rdi
movq %r13, %rsi
callq 0x759a
testl %ebx, %ebx
je 0x81db
leaq 0x24c13(%rip), %rsi     # 0x2cdda
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x692d
movl $0x1, %eax
jmp 0x8251
movq -0x30(%rbp), %rax
testl %r12d, %r12d
je 0x8203
testq %rax, %rax
movq $-0x7fffffff, %rcx      # imm = 0x80000001
cmovnsq %rax, %rcx
movq %rcx, -0x30(%rbp)
movq -0x38(%rbp), %rbx
leaq 0x2e1a7(%rip), %r12     # 0x363a8
jmp 0x8224
testq %rax, %rax
movq -0x38(%rbp), %rbx
leaq 0x2e197(%rip), %r12     # 0x363a8
jle 0x821d
movq $0x7fffffff, -0x30(%rbp) # imm = 0x7FFFFFFF
jmp 0x8224
decq %rax
movq %rax, -0x30(%rbp)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x823e
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x823e
movq %r15, %rdi
movq %r14, %rsi
callq *%rax
movq %r12, 0x8(%r14)
movl -0x30(%rbp), %eax
movl %eax, 0x18(%r14)
movl 0x18(%r14), %eax
movl %eax, (%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: SetRegexpFromAny
static regex_t *SetRegexpFromAny(Jim_Interp *interp, Jim_Obj *objPtr, unsigned flags)
{
    regex_t *compre;
    const char *pattern;
    int ret;


    if (objPtr->typePtr == &regexpObjType &&
        objPtr->internalRep.ptrIntValue.ptr && objPtr->internalRep.ptrIntValue.int1 == flags) {

        return objPtr->internalRep.ptrIntValue.ptr;
    }




    pattern = Jim_String(objPtr);
    compre = Jim_Alloc(sizeof(regex_t));

    if ((ret = jim_regcomp(compre, pattern, REG_EXTENDED | flags)) != 0) {
        char buf[100];

        jim_regerror(ret, compre, buf, sizeof(buf));
        Jim_SetResultFormatted(interp, "couldn't compile regular expression pattern: %s", buf);
        jim_regfree(compre);
        Jim_Free(compre);
        return NULL;
    }

    Jim_FreeIntRep(interp, objPtr);

    objPtr->typePtr = &regexpObjType;
    objPtr->internalRep.ptrIntValue.int1 = flags;
    objPtr->internalRep.ptrIntValue.ptr = compre;

    return compre;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rax
leaq 0x2ea33(%rip), %rcx     # 0x36cb8
cmpq %rcx, %rax
je 0x82c9
cmpq $0x0, (%r15)
jne 0x8296
movq %r15, %rdi
callq *0x18(%rax)
movq (%r15), %r13
movl $0x68, %esi
xorl %edi, %edi
callq *0x2ffe2(%rip)          # 0x38288
movq %rax, %r14
movq %rax, %rdi
movq %r13, %rsi
movl %r12d, %edx
callq 0x12d6b
testl %eax, %eax
je 0x82dd
cmpl $0x13, %eax
jbe 0x830c
leaq 0x2402d(%rip), %rcx     # 0x2c2f4
jmp 0x8319
movq 0x18(%r15), %r14
testq %r14, %r14
je 0x828a
cmpl %r12d, 0x20(%r15)
jne 0x828a
jmp 0x8361
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x82f7
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x82f7
movq %rbx, %rdi
movq %r15, %rsi
callq *%rax
leaq 0x2e9ba(%rip), %rax     # 0x36cb8
movq %rax, 0x8(%r15)
movl %r12d, 0x20(%r15)
movq %r14, 0x18(%r15)
jmp 0x8361
movl %eax, %eax
leaq 0x2e60b(%rip), %rcx     # 0x36920
movq (%rcx,%rax,8), %rcx
leaq 0x2445b(%rip), %rdx     # 0x2c77b
leaq -0x90(%rbp), %r15
movl $0x64, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x61e0
leaq 0x242ed(%rip), %rsi     # 0x2c62a
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x692d
movq 0x20(%r14), %rdi
callq 0x6040
movq %r14, %rdi
xorl %esi, %esi
callq *0x2ff2a(%rip)          # 0x38288
xorl %r14d, %r14d
movq %r14, %rax
addq $0x68, %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_GetString
const char *Jim_GetString(Jim_Obj *objPtr, int *lenPtr)
{
    if (objPtr->bytes == NULL) {

        JimPanic((objPtr->typePtr->updateStringProc == NULL, "UpdateStringProc called against '%s' type.", objPtr->typePtr->name));
        objPtr->typePtr->updateStringProc(objPtr);
    }
    if (lenPtr)
        *lenPtr = objPtr->length;
    return objPtr->bytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, (%rdi)
jne 0x8390
movq 0x8(%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
testq %r14, %r14
je 0x839b
movl 0x14(%rbx), %eax
movl %eax, (%r14)
movq (%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_NewIntObj
Jim_Obj *Jim_NewIntObj(Jim_Interp *interp, jim_wide wideValue)
{
    Jim_Obj *objPtr;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0xae58
leaq 0x2dca3(%rip), %rcx     # 0x362e0
movq %rcx, 0x8(%rax)
movq $0x0, (%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_SetVariable
int Jim_SetVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, Jim_Obj *valObjPtr)
{
    int err;
    Jim_VarVal *vv;

    switch (SetVariableFromAny(interp, nameObjPtr)) {
        case JIM_DICT_SUGAR:
            return JimDictSugarSet(interp, nameObjPtr, valObjPtr);

        case JIM_ERR:
            JimCreateVariable(interp, nameObjPtr, valObjPtr);
            break;

        case JIM_OK:
            vv = nameObjPtr->internalRep.varValue.vv;
            if (vv->linkFramePtr == NULL) {
                Jim_IncrRefCount(valObjPtr);
                Jim_DecrRefCount(interp, vv->objPtr);
                vv->objPtr = valObjPtr;
            }
            else {
                Jim_CallFrame *savedCallFrame;

                savedCallFrame = interp->framePtr;
                interp->framePtr = vv->linkFramePtr;
                err = Jim_SetVariable(interp, vv->objPtr, valObjPtr);
                interp->framePtr = savedCallFrame;
                if (err != JIM_OK)
                    return err;
            }
    }
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
callq 0xc1a3
testl %eax, %eax
je 0x87e4
cmpl $0x1, %eax
je 0x8769
cmpl $0x64, %eax
jne 0x887f
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc345
movl $0x18, %esi
xorl %edi, %edi
callq *0x2fb12(%rip)          # 0x38288
movq %rax, %r15
movq %r12, (%rax)
incl 0x10(%r12)
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
cmpq $0x0, (%r14)
jne 0x87a0
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %rsi
cmpb $0x3a, (%rsi)
jne 0x8811
cmpb $0x3a, 0x1(%rsi)
jne 0x8811
movl 0x14(%r14), %edx
decl %edx
cmpb $0x3a, 0x1(%rsi)
leaq 0x1(%rsi), %rsi
je 0x87b2
movq 0x60(%rbx), %r13
leaq 0x10(%r13), %r12
movq %rbx, %rdi
callq 0x7516
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xa8c2
movl $0x1, %r12d
jmp 0x8827
movq 0x18(%r14), %r14
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x885e
movq 0x58(%rbx), %r15
movq %rax, 0x58(%rbx)
movq (%r14), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x871b
movq %r15, 0x58(%rbx)
testl %eax, %eax
jne 0x8881
jmp 0x887f
movq 0x58(%rbx), %r13
leaq 0x10(%r13), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xa8c2
xorl %r12d, %r12d
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x8841
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x8841
movq %rbx, %rdi
movq %r14, %rsi
callq *%rax
leaq 0x2e510(%rip), %rax     # 0x36d58
movq %rax, 0x8(%r14)
movq (%r13), %rax
movq %rax, 0x20(%r14)
movq %r15, 0x18(%r14)
movl %r12d, 0x28(%r14)
jmp 0x887f
incl 0x10(%r12)
movq (%r14), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x887c
movq %rbx, %rdi
callq 0x759a
movq %r12, (%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_DuplicateObj
Jim_Obj *Jim_DuplicateObj(Jim_Interp *interp, Jim_Obj *objPtr)
{
    Jim_Obj *dupPtr;

    dupPtr = Jim_NewObj(interp);
    if (objPtr->bytes == NULL) {

        dupPtr->bytes = NULL;
    }
    else if (objPtr->length == 0) {
        dupPtr->bytes = JimEmptyStringRep;
        dupPtr->length = 0;
        dupPtr->typePtr = NULL;
        return dupPtr;
    }
    else {
        dupPtr->bytes = Jim_Alloc(objPtr->length + 1);
        dupPtr->length = objPtr->length;

        memcpy(dupPtr->bytes, objPtr->bytes, objPtr->length + 1);
    }


    dupPtr->typePtr = objPtr->typePtr;
    if (objPtr->typePtr != NULL) {
        if (objPtr->typePtr->dupIntRepProc == NULL) {
            dupPtr->internalRep = objPtr->internalRep;
        }
        else {

            objPtr->typePtr->dupIntRepProc(interp, objPtr, dupPtr);
        }
    }
    return dupPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0xae58
movq %rax, %rbx
cmpq $0x0, (%r14)
je 0x8ff8
movslq 0x14(%r14), %rsi
testq %rsi, %rsi
je 0x9026
incq %rsi
xorl %edi, %edi
callq *0x2f2ae(%rip)          # 0x38288
movq %rax, (%rbx)
movl 0x14(%r14), %ecx
movl %ecx, 0x14(%rbx)
movq (%r14), %rsi
movslq 0x14(%r14), %rdx
incq %rdx
movq %rax, %rdi
callq 0x6320
jmp 0x8fff
movq $0x0, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x9052
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x9041
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *%rax
jmp 0x9052
leaq 0x2f26b(%rip), %rax     # 0x38298
movq %rax, (%rbx)
movl $0x0, 0x14(%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x9052
movq 0x28(%r14), %rax
movq %rax, 0x28(%rbx)
movups 0x18(%r14), %xmm0
movups %xmm0, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_GetVariable
Jim_Obj *Jim_GetVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, int flags)
{
    if (interp->safeexpr) {
        return nameObjPtr;
    }
    switch (SetVariableFromAny(interp, nameObjPtr)) {
        case JIM_OK:{
                Jim_VarVal *vv = nameObjPtr->internalRep.varValue.vv;

                if (vv->linkFramePtr == NULL) {
                    return vv->objPtr;
                }
                else {
                    Jim_Obj *objPtr;


                    Jim_CallFrame *savedCallFrame = interp->framePtr;

                    interp->framePtr = vv->linkFramePtr;
                    objPtr = Jim_GetVariable(interp, vv->objPtr, flags);
                    interp->framePtr = savedCallFrame;
                    if (objPtr) {
                        return objPtr;
                    }

                }
            }
            break;

        case JIM_DICT_SUGAR:

            return JimDictSugarGet(interp, nameObjPtr, flags);
    }
    if (flags & JIM_ERRMSG) {
        Jim_SetResultFormatted(interp, "can't read \"%#s\": no such variable", nameObjPtr);
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x0, 0xb0(%rdi)
je 0x991e
movq %rbx, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %edx, %r15d
movq %rdi, %r14
movq %rbx, %rsi
callq 0xc1a3
cmpl $0x64, %eax
je 0x9967
testl %eax, %eax
jne 0x99a0
movq 0x18(%rbx), %rax
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x9993
movq 0x58(%r14), %r13
movq %rcx, 0x58(%r14)
movq (%rax), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x98ef
movq %rax, %r12
movq %r13, 0x58(%r14)
testq %rax, %rax
sete %al
jmp 0x9998
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18b6c
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
movq %r14, %rdi
movl %r15d, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18c98
movq (%rax), %r12
xorl %eax, %eax
testb %al, %al
je 0x990c
testb $0x1, %r15b
jne 0x99ae
xorl %r12d, %r12d
jmp 0x990c
leaq 0x22419(%rip), %rsi     # 0x2bdce
xorl %r12d, %r12d
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x692d
jmp 0x990c
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_DictMerge
Jim_Obj *Jim_DictMerge(Jim_Interp *interp, int objc, Jim_Obj *const *objv)
{
    Jim_Obj *objPtr = Jim_NewDictObj(interp, NULL, 0);
    int i;

    JimPanic((objc == 0, "Jim_DictMerge called with objc=0"));



    for (i = 0; i < objc; i++) {
        Jim_Obj **table;
        int tablelen;
        int j;

        table = Jim_DictPairs(interp, objv[i], &tablelen);
        if (tablelen && !table) {
            Jim_FreeNewObj(interp, objPtr);
            return NULL;
        }
        for (j = 0; j < tablelen; j += 2) {
            DictAddElement(interp, objPtr, table[j], table[j + 1]);
        }
    }
    return objPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, -0x40(%rbp)
movl %esi, %r12d
movq %rdi, %r15
callq 0xae58
movq %rax, %rbx
leaq 0x2c98c(%rip), %rax     # 0x36380
movq %rax, 0x8(%rbx)
movq $0x0, (%rbx)
movl $0x30, %esi
xorl %edi, %edi
callq *0x2e87c(%rip)          # 0x38288
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movq %rax, 0x18(%rbx)
testl %r12d, %r12d
jle 0x9aaf
movl %r12d, %eax
movq %rax, -0x38(%rbp)
xorl %ecx, %ecx
movq -0x40(%rbp), %rax
movq %rcx, -0x48(%rbp)
movq (%rax,%rcx,8), %rsi
movq %r15, %rdi
leaq -0x30(%rbp), %rdx
callq 0xf6a2
movq %rax, %r13
movl -0x30(%rbp), %r12d
testl %r12d, %r12d
sete %al
testq %r13, %r13
setne %cl
orb %al, %cl
movb %cl, -0x29(%rbp)
cmpb $0x1, %cl
jne 0x9a8d
testl %r12d, %r12d
jle 0x9a98
xorl %r14d, %r14d
movq (%r13,%r14,8), %rdx
movq 0x8(%r13,%r14,8), %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xf287
addq $0x2, %r14
cmpl %r14d, %r12d
jg 0x9a6d
jmp 0x9a98
movq %r15, %rdi
movq %rbx, %rsi
callq 0x759a
cmpb $0x0, -0x29(%rbp)
je 0x9aad
movq -0x48(%rbp), %rcx
incq %rcx
cmpq -0x38(%rbp), %rcx
jne 0x9a30
jmp 0x9aaf
xorl %ebx, %ebx
movq %rbx, %rax
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: Jim_PwdCmd
static int Jim_PwdCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    char *cwd = Jim_Alloc(MAXPATHLEN);

    if (getcwd(cwd, MAXPATHLEN) == NULL) {
        Jim_SetResultString(interp, "Failed to get pwd", -1);
        Jim_Free(cwd);
        return JIM_ERR;
    }
    JimFixPath(cwd);
    Jim_SetResultString(interp, cwd, -1);

    Jim_Free(cwd);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
movl $0x1000, %esi           # imm = 0x1000
xorl %edi, %edi
callq *0x2e69b(%rip)          # 0x38288
movq %rax, %r14
movl $0x1000, %esi           # imm = 0x1000
movq %rax, %rdi
callq 0x6250
testq %rax, %rax
je 0x9c4b
movq %rbx, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rax, %r12
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x9c31
movq %rbx, %rdi
callq 0x759a
movq %r12, (%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq *0x2e649(%rip)          # 0x38288
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x22c15(%rip), %rsi     # 0x2c867
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rax, %r12
incl 0x10(%rax)
movq (%rbx), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
movl $0x1, %r15d
cmpl $0x2, %eax
jl 0x9c29
jmp 0x9c31
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_CdCmd
static int Jim_CdCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    const char *path;

    if (argc != 2) {
        Jim_WrongNumArgs(interp, 1, argv, "dirname");
        return JIM_ERR;
    }

    path = Jim_String(argv[1]);

    if (chdir(path) != 0) {
        Jim_SetResultFormatted(interp, "couldn't change working directory to \"%s\": %s", path,
            strerror(errno));
        return JIM_ERR;
    }
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x2, %esi
jne 0x9cdb
movq 0x8(%rdx), %r14
cmpq $0x0, (%r14)
jne 0x9ca1
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %r14
movq %r14, %rdi
callq 0x6190
testl %eax, %eax
je 0x9cf7
callq 0x6080
movl (%rax), %edi
callq 0x64b0
leaq 0x22bb6(%rip), %rsi     # 0x2c879
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x692d
movl $0x1, %r14d
jmp 0x9cfa
leaq 0x229c3(%rip), %rcx     # 0x2c6a5
movl $0x1, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7454
jmp 0x9cfa
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_execInit
int Jim_execInit(Jim_Interp *interp)
{
    struct WaitInfoTable *waitinfo;

    Jim_PackageProvideCheck(interp, "exec");

    waitinfo = JimAllocWaitInfoTable();
    Jim_CreateCommand(interp, "exec", Jim_ExecCmd, waitinfo, JimFreeWaitInfoTable);
    waitinfo->refcount++;
    Jim_CreateCommand(interp, "wait", Jim_WaitCommand, waitinfo, JimFreeWaitInfoTable);
    Jim_CreateCommand(interp, "pid", Jim_PidCommand, 0, 0);

    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x18, %esi
xorl %edi, %edi
callq *0x2e56c(%rip)          # 0x38288
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x1, 0x10(%rax)
leaq 0x22c67(%rip), %rsi     # 0x2c99a
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
leaq 0x80(%rip), %rdx        # 0x9dc7
leaq 0x404(%rip), %r15       # 0xa152
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rcx
movq %r15, %r8
callq 0xbe8d
incl 0x10(%r14)
leaq 0x21e8a(%rip), %rsi     # 0x2bbf4
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
leaq 0x402(%rip), %rdx       # 0xa180
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rcx
movq %r15, %r8
callq 0xbe8d
leaq 0x21e63(%rip), %rsi     # 0x2bbf9
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
leaq 0x5a7(%rip), %rdx       # 0xa351
movq %rbx, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xbe8d
xorl %eax, %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: Jim_PidCommand
static int Jim_PidCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    if (argc != 1) {
        Jim_WrongNumArgs(interp, 1, argv, "");
        return JIM_ERR;
    }

    Jim_SetResultInt(interp, (jim_wide)getpid());
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1, %esi
jne 0xa3b1
callq 0x6140
movslq %eax, %r15
movq %rbx, %rdi
callq 0xae58
movq %rax, %r14
leaq 0x2bf63(%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 0xa3a9
movq %rbx, %rdi
callq 0x759a
movq %r14, (%rbx)
xorl %r14d, %r14d
jmp 0xa3cb
leaq 0x2429b(%rip), %rcx     # 0x2e653
movl $0x1, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7454
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_InitStaticExtensions
int Jim_InitStaticExtensions(Jim_Interp *interp)
{
extern int Jim_bootstrapInit(Jim_Interp *);
extern int Jim_aioInit(Jim_Interp *);
extern int Jim_readdirInit(Jim_Interp *);
extern int Jim_regexpInit(Jim_Interp *);
extern int Jim_fileInit(Jim_Interp *);
extern int Jim_globInit(Jim_Interp *);
extern int Jim_execInit(Jim_Interp *);
extern int Jim_clockInit(Jim_Interp *);
extern int Jim_arrayInit(Jim_Interp *);
extern int Jim_stdlibInit(Jim_Interp *);
extern int Jim_tclcompatInit(Jim_Interp *);
Jim_bootstrapInit(interp);
Jim_aioInit(interp);
Jim_readdirInit(interp);
Jim_regexpInit(interp);
Jim_fileInit(interp);
Jim_globInit(interp);
Jim_execInit(interp);
Jim_clockInit(interp);
Jim_arrayInit(interp);
Jim_stdlibInit(interp);
Jim_tclcompatInit(interp);
return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1e3a0(%rip), %rsi     # 0x28808
leaq 0x1e3a7(%rip), %rcx     # 0x28816
movl $0x1, %edx
callq 0x6661
movq %rbx, %rdi
callq 0x6b9b
leaq 0x215e1(%rip), %rsi     # 0x2ba69
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
leaq -0x3256(%rip), %rdx     # 0x7246
movq %rbx, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xbe8d
movq %rbx, %rdi
callq 0x959c
movq %rbx, %rdi
callq 0x9afa
leaq 0x1f063(%rip), %rsi     # 0x29526
leaq 0x1f065(%rip), %rcx     # 0x2952f
movq %rbx, %rdi
movl $0x1, %edx
callq 0x6661
movq %rbx, %rdi
callq 0x9d02
leaq 0x21717(%rip), %rsi     # 0x2bbfd
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
leaq -0x96b(%rip), %r14      # 0x9b8f
leaq 0x2baef(%rip), %rcx     # 0x35ff0
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
xorl %r8d, %r8d
callq 0xbe8d
leaq 0x2264c(%rip), %rsi     # 0x2cb65
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
leaq 0x2bb83(%rip), %rcx     # 0x360b0
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
xorl %r8d, %r8d
callq 0xbe8d
leaq 0x1fd1c(%rip), %rsi     # 0x2a261
leaq 0x1fd20(%rip), %rcx     # 0x2a26c
movq %rbx, %rdi
movl $0x1, %edx
callq 0x6661
leaq 0x20847(%rip), %rsi     # 0x2ada7
leaq 0x2084e(%rip), %rcx     # 0x2adb5
movq %rbx, %rdi
movl $0x1, %edx
callq 0x6661
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_StringToWide
int Jim_StringToWide(const char *str, jim_wide * widePtr, int base)
{
    char *endptr;

    if (base) {
        *widePtr = strtoull(str, &endptr, base);
    }
    else {
        *widePtr = jim_strtoull(str, &endptr);
    }

    return JimCheckConversion(str, endptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x18(%rbp), %rsi
testl %edx, %edx
je 0xa59b
callq 0x6460
jmp 0xa5a0
callq 0xd4a4
movq %rax, (%r14)
movq -0x18(%rbp), %rsi
movq %rbx, %rdi
callq 0xa5b8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimCheckConversion
static int JimCheckConversion(const char *str, const char *endptr)
{
    if (str[0] == '\0' || str == endptr) {
        return JIM_ERR;
    }

    if (endptr[0] != '\0') {
        while (*endptr) {
            if (!isspace(UCHAR(*endptr))) {
                return JIM_ERR;
            }
            endptr++;
        }
    }
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0x1, %ebx
cmpq %rsi, %rdi
je 0xa604
cmpb $0x0, (%rdi)
je 0xa604
movq %rsi, %r14
cmpb $0x0, (%rsi)
je 0xa602
movb (%r14), %r15b
testb %r15b, %r15b
je 0xa602
callq 0x64e0
movq (%rax), %rax
incq %r14
movzbl %r15b, %ecx
testb $0x20, 0x1(%rax,%rcx,2)
je 0xa604
movb (%r14), %r15b
incq %r14
testb %r15b, %r15b
jne 0xa5ec
xorl %ebx, %ebx
movl %ebx, %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: JimDefaultAllocator
void *JimDefaultAllocator(void *ptr, size_t size)
{
    if (size == 0) {
        free(ptr);
        return NULL;
    }
    else if (ptr) {
        return realloc(ptr, size);
    }
    else {
        return malloc(size);
    }
}

// Assembly:
testq %rsi, %rsi
je 0xa66a
testq %rdi, %rdi
jne 0x63b0
movq %rsi, %rdi
jmp 0x6360
pushq %rbp
movq %rsp, %rbp
callq 0x6040
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_StrDupLen
char *Jim_StrDupLen(const char *s, int l)
{
    char *copy = Jim_Alloc(l + 1);

    memcpy(copy, s, l);
    copy[l] = 0;
    return copy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leal 0x1(%rbx), %eax
movslq %eax, %rsi
xorl %edi, %edi
callq *0x2dbab(%rip)          # 0x38288
movq %rax, %r15
movslq %ebx, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6320
movb $0x0, (%r15,%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_GenHashFunction
unsigned int Jim_GenHashFunction(const unsigned char *string, int length)
{
    unsigned result = 0;
    string += length;
    while (length--) {
        result += (result << 3) + (unsigned char)(*--string);
    }
    return result;
}

// Assembly:
testl %esi, %esi
je 0xa782
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rax
leaq (%rax,%rdi), %rcx
decq %rcx
xorl %eax, %eax
movzbl (%rcx), %edx
leal (%rax,%rax,8), %eax
addl %edx, %eax
decq %rcx
decl %esi
jne 0xa771
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_InitHashTable
int Jim_InitHashTable(Jim_HashTable *ht, const Jim_HashTableType *type, void *privDataPtr)
{
    JimResetHashTable(ht);
    ht->type = type;
    ht->privdata = privDataPtr;
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movl $0x0, 0x28(%rdi)
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_ExpandHashTable
void Jim_ExpandHashTable(Jim_HashTable *ht, unsigned int size)
{
    Jim_HashTable n;
    unsigned int realsize = JimHashTableNextPower(size), i;

     if (size <= ht->used)
        return;

    Jim_InitHashTable(&n, ht->type, ht->privdata);
    n.size = realsize;
    n.sizemask = realsize - 1;
    n.table = Jim_Alloc(realsize * sizeof(Jim_HashEntry *));

    n.uniq = ht->uniq;


    memset(n.table, 0, realsize * sizeof(Jim_HashEntry *));

    n.used = ht->used;
    for (i = 0; ht->used > 0; i++) {
        Jim_HashEntry *he, *nextHe;

        if (ht->table[i] == NULL)
            continue;


        he = ht->table[i];
        while (he) {
            unsigned int h;

            nextHe = he->next;

            h = Jim_HashKey(ht, he->key) & n.sizemask;
            he->next = n.table[h];
            n.table[h] = he;
            ht->used--;

            he = nextHe;
        }
    }
    assert(ht->used == 0);
    Jim_Free(ht->table);


    *ht = n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
testl %esi, %esi
js 0xa7d2
movl $0x10, %eax
movl %eax, %ecx
leal (%rcx,%rcx), %eax
cmpl %esi, %ecx
jb 0xa7c7
jmp 0xa7d7
movl $0x80000000, %ecx       # imm = 0x80000000
cmpl %esi, 0x20(%rbx)
jae 0xa8b3
movq 0x8(%rbx), %rax
movq %rax, -0x40(%rbp)
movq 0x10(%rbx), %rax
movq %rax, -0x38(%rbp)
leal -0x1(%rcx), %r13d
movq %rcx, -0x48(%rbp)
movl %ecx, %r12d
shlq $0x3, %r12
xorl %r15d, %r15d
xorl %edi, %edi
movq %r12, %rsi
callq *0x2da7b(%rip)          # 0x38288
movq %rax, %r14
movl 0x28(%rbx), %eax
movl %eax, -0x30(%rbp)
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x6240
movl 0x20(%rbx), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0xa877
movq (%rbx), %rax
movq %r15, -0x50(%rbp)
movl %r15d, %ecx
movq (%rax,%rcx,8), %r15
testq %r15, %r15
je 0xa86a
movq (%r15), %rdi
movq 0x10(%r15), %r12
movq 0x8(%rbx), %rax
callq *(%rax)
addl 0x28(%rbx), %eax
andl %r13d, %eax
movq (%r14,%rax,8), %rcx
movq %rcx, 0x10(%r15)
movq %r15, (%r14,%rax,8)
decl 0x20(%rbx)
movq %r12, %r15
testq %r12, %r12
jne 0xa840
movq -0x50(%rbp), %r15
incl %r15d
cmpl $0x0, 0x20(%rbx)
jne 0xa82d
movq (%rbx), %rdi
xorl %esi, %esi
callq *0x2da06(%rip)          # 0x38288
movq %r14, (%rbx)
movq -0x40(%rbp), %rax
movq %rax, 0x8(%rbx)
movq -0x38(%rbp), %rax
movq %rax, 0x10(%rbx)
movq -0x48(%rbp), %rax
movl %eax, 0x18(%rbx)
movl %r13d, 0x1c(%rbx)
movl -0x2c(%rbp), %eax
movl %eax, 0x20(%rbx)
movl $0x0, 0x24(%rbx)
movl -0x30(%rbp), %eax
movl %eax, 0x28(%rbx)
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: Jim_AddHashEntry
int Jim_AddHashEntry(Jim_HashTable *ht, const void *key, void *val)
{
    Jim_HashEntry *entry = JimInsertHashEntry(ht, key, 0);;
    if (entry == NULL)
        return JIM_ERR;


    Jim_SetHashKey(ht, entry, key);
    Jim_SetHashVal(ht, entry, val);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
xorl %edx, %edx
callq 0xa930
testq %rax, %rax
je 0xa922
movq %rax, %r14
movq 0x8(%r15), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xa8fe
movq 0x10(%r15), %rdi
movq %r12, %rsi
callq *%rax
movq %rax, %r12
movq %r12, (%r14)
movq 0x8(%r15), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0xa91a
movq 0x10(%r15), %rdi
movq %rbx, %rsi
callq *%rax
movq %rax, %rbx
movq %rbx, 0x8(%r14)
xorl %eax, %eax
jmp 0xa927
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: JimInsertHashEntry
static Jim_HashEntry *JimInsertHashEntry(Jim_HashTable *ht, const void *key, int replace)
{
    unsigned int h;
    Jim_HashEntry *he;


    JimExpandHashTableIfNeeded(ht);


    h = Jim_HashKey(ht, key) & ht->sizemask;

    he = ht->table[h];
    while (he) {
        if (Jim_CompareHashKeys(ht, key, he->key))
            return replace ? he : NULL;
        he = he->next;
    }


    he = Jim_Alloc(sizeof(*he));
    he->next = ht->table[h];
    ht->table[h] = he;
    ht->used++;
    he->key = NULL;

    return he;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
jne 0xa95a
movq %rbx, %rdi
movl $0x10, %esi
callq 0xa7aa
movl 0x18(%rbx), %esi
cmpl 0x20(%rbx), %esi
jne 0xa96c
addl %esi, %esi
movq %rbx, %rdi
callq 0xa7aa
movq 0x8(%rbx), %rax
movq %r15, %rdi
callq *(%rax)
movl %eax, %r12d
addl 0x28(%rbx), %r12d
andl 0x1c(%rbx), %r12d
movq (%rbx), %rax
movq (%rax,%r12,8), %r13
testq %r13, %r13
je 0xa9b8
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0xa9ac
movq 0x10(%rbx), %rdi
movq (%r13), %rdx
movq %r15, %rsi
callq *%rax
testl %eax, %eax
je 0xa9b2
jmp 0xa9e4
cmpq %r15, (%r13)
je 0xa9e4
movq 0x10(%r13), %r13
jmp 0xa987
movl $0x18, %esi
xorl %edi, %edi
callq *0x2d8c3(%rip)          # 0x38288
movq %rax, %r13
movq (%rbx), %rax
movq (%rax,%r12,8), %rcx
movq %rcx, 0x10(%r13)
movq %r13, (%rax,%r12,8)
incl 0x20(%rbx)
movq $0x0, (%r13)
jmp 0xa9ed
xorl %eax, %eax
testl %r14d, %r14d
cmoveq %rax, %r13
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq