LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimCheckLoopRetcode
static int JimCheckLoopRetcode(Jim_Interp *interp, int retval)
{
    if (retval == JIM_BREAK || retval == JIM_CONTINUE) {
        if (--interp->break_level > 0) {
            return 1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
je 0x2eeb7
cmpl $0x4, -0x14(%rbp)
jne 0x2eed4
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x18(%rcx)
cmpl $0x0, %eax
jle 0x2eed2
movl $0x1, -0x4(%rbp)
jmp 0x2eedb
jmp 0x2eed4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: ListSortInteger
static int ListSortInteger(Jim_Obj **lhsObj, Jim_Obj **rhsObj)
{
    jim_wide lhs = 0, rhs = 0;

    if (Jim_GetWide(sort_info->interp, *lhsObj, &lhs) != JIM_OK ||
        Jim_GetWide(sort_info->interp, *rhsObj, &rhs) != JIM_OK) {
        longjmp(sort_info->jmpbuf, JIM_ERR);
    }

    return JimSign(lhs - rhs) * sort_info->order;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq 0x18c19(%rip), %rax     # 0x483e0
movq 0xd0(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq -0x18(%rbp), %rdx
callq 0xf640
cmpl $0x0, %eax
jne 0x2f806
movq 0x18bf6(%rip), %rax     # 0x483e0
movq 0xd0(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq -0x20(%rbp), %rdx
callq 0xf640
cmpl $0x0, %eax
je 0x2f817
movq 0x18bd3(%rip), %rdi     # 0x483e0
movl $0x1, %esi
callq 0x63d0
movq -0x18(%rbp), %rdi
subq -0x20(%rbp), %rdi
callq 0x1d480
movq 0x18bb5(%rip), %rcx     # 0x483e0
imull 0xdc(%rcx), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: ListSortReal
static int ListSortReal(Jim_Obj **lhsObj, Jim_Obj **rhsObj)
{
    double lhs = 0, rhs = 0;

    if (Jim_GetDouble(sort_info->interp, *lhsObj, &lhs) != JIM_OK ||
        Jim_GetDouble(sort_info->interp, *rhsObj, &rhs) != JIM_OK) {
        longjmp(sort_info->jmpbuf, JIM_ERR);
    }
    if (lhs == rhs) {
        return 0;
    }
    if (lhs > rhs) {
        return sort_info->order;
    }
    return -sort_info->order;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq 0x18b79(%rip), %rax     # 0x483e0
movq 0xd0(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq -0x20(%rbp), %rdx
callq 0xfa00
cmpl $0x0, %eax
jne 0x2f8a6
movq 0x18b56(%rip), %rax     # 0x483e0
movq 0xd0(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq -0x28(%rbp), %rdx
callq 0xfa00
cmpl $0x0, %eax
je 0x2f8b7
movq 0x18b33(%rip), %rdi     # 0x483e0
movl $0x1, %esi
callq 0x63d0
movsd -0x20(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jne 0x2f8ce
jp 0x2f8ce
movl $0x0, -0x4(%rbp)
jmp 0x2f8fe
movsd -0x20(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x2f8ec
movq 0x18aff(%rip), %rax     # 0x483e0
movl 0xdc(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x2f8fe
movq 0x18aed(%rip), %rcx     # 0x483e0
xorl %eax, %eax
subl 0xdc(%rcx), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: ListSortCommand
static int ListSortCommand(Jim_Obj **lhsObj, Jim_Obj **rhsObj)
{
    Jim_Obj *compare_script;
    int rc;

    jim_wide ret = 0;


    compare_script = Jim_DuplicateObj(sort_info->interp, sort_info->command);
    Jim_ListAppendElement(sort_info->interp, compare_script, *lhsObj);
    Jim_ListAppendElement(sort_info->interp, compare_script, *rhsObj);

    rc = Jim_EvalObj(sort_info->interp, compare_script);

    if (rc != JIM_OK || Jim_GetWide(sort_info->interp, Jim_GetResult(sort_info->interp), &ret) != JIM_OK) {
        longjmp(sort_info->jmpbuf, rc);
    }

    return JimSign(ret) * sort_info->order;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq 0x18ab1(%rip), %rax     # 0x483e0
movq 0xd0(%rax), %rdi
movq 0x18aa3(%rip), %rax     # 0x483e0
movq 0xc8(%rax), %rsi
callq 0x9a00
movq %rax, -0x18(%rbp)
movq 0x18a8c(%rip), %rax     # 0x483e0
movq 0xd0(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
callq 0x7bd0
movq 0x18a6e(%rip), %rax     # 0x483e0
movq 0xd0(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
callq 0x7bd0
movq 0x18a50(%rip), %rax     # 0x483e0
movq 0xd0(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x9b80
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x2f9d6
movq 0x18a30(%rip), %rax     # 0x483e0
movq 0xd0(%rax), %rdi
movq 0x18a22(%rip), %rax     # 0x483e0
movq 0xd0(%rax), %rax
movq (%rax), %rsi
leaq -0x28(%rbp), %rdx
callq 0xf640
cmpl $0x0, %eax
je 0x2f9e5
movq 0x18a03(%rip), %rdi     # 0x483e0
movl -0x1c(%rbp), %esi
callq 0x63d0
movq -0x28(%rbp), %rdi
callq 0x1d480
movq 0x189eb(%rip), %rcx     # 0x483e0
imull 0xdc(%rcx), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: ListSortIndexHelper
static int ListSortIndexHelper(Jim_Obj **lhsObj, Jim_Obj **rhsObj)
{
    Jim_Obj *lObj, *rObj;

    if (Jim_ListIndices(sort_info->interp, *lhsObj, sort_info->indexv, sort_info->indexc, &lObj, JIM_ERRMSG) != JIM_OK ||
        Jim_ListIndices(sort_info->interp, *rhsObj, sort_info->indexv, sort_info->indexc, &rObj, JIM_ERRMSG) != JIM_OK) {
        longjmp(sort_info->jmpbuf, JIM_ERR);
    }
    return sort_info->subfn(&lObj, &rObj);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x187c9(%rip), %rax     # 0x483e0
movq 0xd0(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq 0x187b4(%rip), %rax     # 0x483e0
movq 0xe0(%rax), %rdx
movq 0x187a6(%rip), %rax     # 0x483e0
movl 0xe8(%rax), %ecx
leaq -0x18(%rbp), %r8
movl $0x1, %r9d
callq 0x2f3d0
cmpl $0x0, %eax
jne 0x2fc98
movq 0x18785(%rip), %rax     # 0x483e0
movq 0xd0(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq 0x18770(%rip), %rax     # 0x483e0
movq 0xe0(%rax), %rdx
movq 0x18762(%rip), %rax     # 0x483e0
movl 0xe8(%rax), %ecx
leaq -0x20(%rbp), %r8
movl $0x1, %r9d
callq 0x2f3d0
cmpl $0x0, %eax
je 0x2fca9
movq 0x18741(%rip), %rdi     # 0x483e0
movl $0x1, %esi
callq 0x63d0
movq 0x18730(%rip), %rax     # 0x483e0
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq *0xf0(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: ListRemoveDuplicates
static void ListRemoveDuplicates(Jim_Obj *listObjPtr, int (*comp)(Jim_Obj **lhs, Jim_Obj **rhs))
{
    int src;
    int dst = 0;
    Jim_Obj **ele = listObjPtr->internalRep.listValue.ele;

    for (src = 1; src < listObjPtr->internalRep.listValue.len; src++) {
        if (comp(&ele[dst], &ele[src]) == 0) {

            Jim_DecrRefCount(sort_info->interp, ele[dst]);
        }
        else {

            dst++;
        }
        ele[dst] = ele[src];
    }


    dst++;
    if (dst < listObjPtr->internalRep.listValue.len) {
        ele[dst] = ele[src];
    }


    listObjPtr->internalRep.listValue.len = dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x2fd9d
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rdi
movq -0x20(%rbp), %rsi
movslq -0x14(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x2fd6e
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movl 0x10(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rcx)
cmpl $0x0, %eax
jg 0x2fd6c
movq 0x1868c(%rip), %rax     # 0x483e0
movq 0xd0(%rax), %rdi
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x7a10
jmp 0x2fd77
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2fcfa
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x2fdca
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimBreakContinueHelper
static int JimBreakContinueHelper(Jim_Interp *interp, int argc, Jim_Obj *const *argv, int retcode)
{
    if (argc != 1 && argc != 2) {
        Jim_WrongNumArgs(interp, 1, argv, "?level?");
        return JIM_ERR;
    }
    if (argc == 2) {
        long level;
        int ret = Jim_GetLong(interp, argv[1], &level);
        if (ret != JIM_OK) {
            return ret;
        }
        interp->break_level = level;
    }
    return retcode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpl $0x1, -0x14(%rbp)
je 0x2fe24
cmpl $0x2, -0x14(%rbp)
je 0x2fe24
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x1, %esi
leaq 0xce41(%rip), %rcx      # 0x3cc57
callq 0x7880
movl $0x1, -0x4(%rbp)
jmp 0x2fe63
cmpl $0x2, -0x14(%rbp)
jne 0x2fe5d
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x30(%rbp), %rdx
callq 0xf4d0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x2fe50
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2fe63
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimStringFirst
static int JimStringFirst(const char *s1, int l1, const char *s2, int l2, int idx)
{
    int i;
    int l1bytelen;

    if (!l1 || !l2 || l1 > l2) {
        return -1;
    }
    if (idx < 0)
        idx = 0;
    s2 += utf8_index(s2, idx);

    l1bytelen = utf8_index(s1, l1);

    for (i = idx; i <= l2 - l1; i++) {
        int c;
        if (memcmp(s2, s1, l1bytelen) == 0) {
            return i;
        }
        s2 += utf8_tounicode(s2, &c);
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x307ee
cmpl $0x0, -0x24(%rbp)
je 0x307ee
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
jle 0x307f7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x30874
cmpl $0x0, -0x28(%rbp)
jge 0x30804
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl -0x24(%rbp), %ecx
subl -0x14(%rbp), %ecx
cmpl %ecx, %eax
jg 0x3086d
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x30(%rbp), %rdx
callq 0x62c0
cmpl $0x0, %eax
jne 0x3084c
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x30874
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x30821
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimStringLast
static int JimStringLast(const char *s1, int l1, const char *s2, int l2)
{
    const char *p;

    if (!l1 || !l2 || l1 > l2)
        return -1;


    for (p = s2 + l2 - 1; p != s2 - 1; p--) {
        if (*p == *s1 && memcmp(s1, p, l1) == 0) {
            return p - s2;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x308aa
cmpl $0x0, -0x24(%rbp)
je 0x308aa
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
jle 0x308b3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x30926
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $-0x1, %rcx
cmpq %rcx, %rax
je 0x3091f
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x3090f
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x62c0
cmpl $0x0, %eax
jne 0x3090f
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
jmp 0x30926
jmp 0x30911
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x308c6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimStringTrim
static Jim_Obj *JimStringTrim(Jim_Interp *interp, Jim_Obj *strObjPtr, Jim_Obj *trimcharsObjPtr)
{

    Jim_Obj *objPtr = JimStringTrimLeft(interp, strObjPtr, trimcharsObjPtr);


    strObjPtr = JimStringTrimRight(interp, objPtr, trimcharsObjPtr);


    if (objPtr != strObjPtr && objPtr->refCount == 0) {

        Jim_FreeNewObj(interp, objPtr);
    }

    return strObjPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x309a0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x30a50
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x3098f
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x3098f
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7a10
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimStringTrimLeft
static Jim_Obj *JimStringTrimLeft(Jim_Interp *interp, Jim_Obj *strObjPtr, Jim_Obj *trimcharsObjPtr)
{
    int len;
    const char *str = Jim_GetString(strObjPtr, &len);
    const char *trimchars = default_trim_chars;
    int trimcharslen = default_trim_chars_len;
    const char *newstr;

    if (trimcharsObjPtr) {
        trimchars = Jim_GetString(trimcharsObjPtr, &trimcharslen);
    }

    newstr = JimFindTrimLeft(str, len, trimchars, trimcharslen);
    if (newstr == str) {
        return strObjPtr;
    }

    return Jim_NewStringObj(interp, newstr, len - (newstr - str));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x89b0
movq %rax, -0x30(%rbp)
leaq 0x6eb4(%rip), %rax      # 0x37880
movq %rax, -0x38(%rbp)
movl 0x1796a(%rip), %eax     # 0x48340
movl %eax, -0x3c(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x309f1
movq -0x20(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x89b0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x38(%rbp), %rdx
movl -0x3c(%rbp), %ecx
callq 0x31170
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x30a1c
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x30a41
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
movslq -0x24(%rbp), %rax
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %rdx
subq %rdx, %rcx
subq %rcx, %rax
movl %eax, %edx
callq 0x7990
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimStringTrimRight
static Jim_Obj *JimStringTrimRight(Jim_Interp *interp, Jim_Obj *strObjPtr, Jim_Obj *trimcharsObjPtr)
{
    int len;
    const char *trimchars = default_trim_chars;
    int trimcharslen = default_trim_chars_len;
    const char *nontrim;

    if (trimcharsObjPtr) {
        trimchars = Jim_GetString(trimcharsObjPtr, &trimcharslen);
    }

    SetStringFromAny(interp, strObjPtr);

    len = Jim_Length(strObjPtr);
    nontrim = JimFindTrimRight(strObjPtr->bytes, len, trimchars, trimcharslen);

    if (nontrim == NULL) {

        return Jim_NewEmptyStringObj(interp);
    }
    if (nontrim == strObjPtr->bytes + len) {

        return strObjPtr;
    }

    if (Jim_IsShared(strObjPtr)) {
        strObjPtr = Jim_NewStringObj(interp, strObjPtr->bytes, (nontrim - strObjPtr->bytes));
    }
    else {

        strObjPtr->bytes[nontrim - strObjPtr->bytes] = 0;
        strObjPtr->length = (nontrim - strObjPtr->bytes);
    }

    return strObjPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x6e15(%rip), %rax      # 0x37880
movq %rax, -0x30(%rbp)
movl 0x178cb(%rip), %eax     # 0x48340
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x30a90
movq -0x20(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x89b0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc7f0
movq -0x18(%rbp), %rdi
callq 0xc700
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl -0x24(%rbp), %esi
movq -0x30(%rbp), %rdx
movl -0x34(%rbp), %ecx
callq 0x31210
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x30ae5
movq -0x10(%rbp), %rdi
leaq 0xcedd(%rip), %rsi      # 0x3d9b2
xorl %edx, %edx
callq 0x7990
movq %rax, -0x8(%rbp)
jmp 0x30b6e
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x24(%rbp), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jne 0x30b06
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x30b6e
movq -0x18(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jle 0x30b36
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movl %eax, %edx
callq 0x7990
movq %rax, -0x18(%rbp)
jmp 0x30b66
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimStringToLower
static Jim_Obj *JimStringToLower(Jim_Interp *interp, Jim_Obj *strObjPtr)
{
    char *buf;
    int len;
    const char *str;

    str = Jim_GetString(strObjPtr, &len);

#ifdef JIM_UTF8
    len *= 2;
#endif
    buf = Jim_Alloc(len + 1);
    JimStrCopyUpperLower(buf, str, 0);
    return Jim_NewStringObjNoAlloc(interp, buf, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x89b0
movq %rax, -0x28(%rbp)
movq 0x176e8(%rip), %rax     # 0x48290
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rsi
xorl %ecx, %ecx
movl %ecx, %edi
callq *%rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x312b0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xc780
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimStringToUpper
static Jim_Obj *JimStringToUpper(Jim_Interp *interp, Jim_Obj *strObjPtr)
{
    char *buf;
    const char *str;
    int len;

    str = Jim_GetString(strObjPtr, &len);

#ifdef JIM_UTF8
    len *= 2;
#endif
    buf = Jim_Alloc(len + 1);
    JimStrCopyUpperLower(buf, str, 1);
    return Jim_NewStringObjNoAlloc(interp, buf, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x89b0
movq %rax, -0x20(%rbp)
movq 0x17678(%rip), %rax     # 0x48290
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rsi
xorl %ecx, %ecx
movl %ecx, %edi
callq *%rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x312b0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xc780
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimStringToTitle
static Jim_Obj *JimStringToTitle(Jim_Interp *interp, Jim_Obj *strObjPtr)
{
    char *buf, *p;
    int len;
    int c;
    const char *str;

    str = Jim_GetString(strObjPtr, &len);

#ifdef JIM_UTF8
    len *= 2;
#endif
    buf = p = Jim_Alloc(len + 1);

    str += utf8_tounicode(str, &c);
    p += utf8_getchars(p, utf8_title(c));

    JimStrCopyUpperLower(p, str, 0);

    return Jim_NewStringObjNoAlloc(interp, buf, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x89b0
movq %rax, -0x30(%rbp)
movq 0x17608(%rip), %rax     # 0x48290
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rsi
xorl %ecx, %ecx
movl %ecx, %edi
callq *%rax
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movl -0x28(%rbp), %edi
callq 0x60f0
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x312b0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xc780
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimFindTrimLeft
static const char *JimFindTrimLeft(const char *str, int len, const char *trimchars, int trimlen)
{
    while (len) {
        int c;
        int n = utf8_tounicode(str, &c);

        if (utf8_memchr(trimchars, trimlen, c) == NULL) {

            break;
        }
        str += n;
        len -= n;
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x311d2
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
callq 0x311e0
cmpq $0x0, %rax
jne 0x311b4
jmp 0x311d2
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x24(%rbp), %ecx
movl -0xc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0x31186
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimFindTrimRight
static const char *JimFindTrimRight(const char *str, int len, const char *trimchars, int trimlen)
{
    str += len;

    while (len) {
        int c;
        int n = utf8_prev_len(str, len);

        len -= n;
        str -= n;

        n = utf8_tounicode(str, &c);

        if (utf8_memchr(trimchars, trimlen, c) == NULL) {
            return str + n;
        }
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x3129e
movl $0x1, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0x311e0
cmpq $0x0, %rax
jne 0x3129c
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x312a6
jmp 0x31237
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimStrCopyUpperLower
static void JimStrCopyUpperLower(char *dest, const char *str, int uc)
{
    while (*str) {
        int c;
        str += utf8_tounicode(str, &c);
        dest += utf8_getchars(dest, uc ? utf8_upper(c) : utf8_lower(c));
    }
    *dest = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x31319
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x312f5
movl -0x18(%rbp), %edi
callq 0x60f0
movl %eax, -0x1c(%rbp)
jmp 0x31300
movl -0x18(%rbp), %edi
callq 0x6370
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x312c3
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimMatchReturnCodes
static int JimMatchReturnCodes(Jim_Interp *interp, Jim_Obj *retcodeListObj, int rc)
{
    int len = Jim_ListLength(interp, retcodeListObj);
    int i;
    for (i = 0; i < len; i++) {
        int returncode;
        if (Jim_GetReturnCode(interp, Jim_ListGetIndex(interp, retcodeListObj, i), &returncode) != JIM_OK) {
            return JIM_ERR;
        }
        if (rc == returncode) {
            return JIM_OK;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9b50
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x31de6
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x101d0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
leaq -0x28(%rbp), %rdx
callq 0x11b90
cmpl $0x0, %eax
je 0x31dc8
movl $0x1, -0x4(%rbp)
jmp 0x31ded
movl -0x1c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jne 0x31dd9
movl $0x0, -0x4(%rbp)
jmp 0x31ded
jmp 0x31ddb
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x31d8a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_EvalEnsemble
static int Jim_EvalEnsemble(Jim_Interp *interp, const char *basecmd, const char *subcmd, int argc, Jim_Obj *const *argv)
{
    Jim_Obj *prefixObj = Jim_NewStringObj(interp, basecmd, -1);

    Jim_AppendString(interp, prefixObj, " ", 1);
    Jim_AppendString(interp, prefixObj, subcmd, -1);

    return Jim_EvalObjPrefix(interp, prefixObj, argc, argv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7990
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq 0xb855(%rip), %rdx      # 0x3d8d5
movl $0x1, %ecx
callq 0x8db0
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x8db0
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0x13010
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimVariablesList
static Jim_Obj *JimVariablesList(Jim_Interp *interp, Jim_Obj *patternObjPtr, int mode)
{
    if (mode == JIM_VARLIST_LOCALS && interp->framePtr == interp->topFramePtr) {
        return interp->emptyObj;
    }
    else {
        Jim_CallFrame *framePtr = (mode == JIM_VARLIST_GLOBALS) ? interp->topFramePtr : interp->framePtr;
        return JimHashtablePatternMatch(interp, &framePtr->vars, patternObjPtr, JimVariablesMatch,
            mode);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0x3213c
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x60(%rcx), %rax
jne 0x3213c
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x32188
cmpl $0x0, -0x1c(%rbp)
jne 0x32150
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x3215c
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x10, %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %r8d
leaq 0x521(%rip), %rcx       # 0x326a0
callq 0x325b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimInfoLevel
static int JimInfoLevel(Jim_Interp *interp, Jim_Obj *levelObjPtr, Jim_Obj **objPtrPtr)
{
    long level;

    if (Jim_GetLong(interp, levelObjPtr, &level) == JIM_OK) {
        Jim_CallFrame *targetCallFrame = JimGetCallFrameByInteger(interp, level);
        if (targetCallFrame && targetCallFrame != interp->topFramePtr) {
#ifdef JIM_NO_INTROSPECTION

            *objPtrPtr = Jim_NewListObj(interp, targetCallFrame->argv, 1);
#else
            *objPtrPtr = Jim_NewListObj(interp, targetCallFrame->argv, targetCallFrame->argc);
#endif
            return JIM_OK;
        }
    }
    Jim_SetResultFormatted(interp, "bad level \"%#s\"", levelObjPtr);
    return JIM_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xf4d0
cmpl $0x0, %eax
jne 0x3221d
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x32830
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x3221b
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x60(%rcx), %rax
je 0x3221b
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rsi
movq -0x30(%rbp), %rax
movl 0x58(%rax), %edx
callq 0x7b50
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x3223a
jmp 0x3221d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xac2e(%rip), %rsi      # 0x3ce5a
movb $0x0, %al
callq 0x6b40
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimHashtablePatternMatch
static Jim_Obj *JimHashtablePatternMatch(Jim_Interp *interp, Jim_HashTable *ht, Jim_Obj *patternObjPtr,
    JimHashtableIteratorCallbackType *callback, int type)
{
    Jim_HashEntry *he;
    Jim_Obj *listObjPtr = Jim_NewListObj(interp, NULL, 0);


    if (patternObjPtr && JimTrivialMatch(Jim_String(patternObjPtr))) {
        he = Jim_FindHashEntry(ht, patternObjPtr);
        if (he) {
            callback(interp, listObjPtr, Jim_GetHashEntryKey(he), Jim_GetHashEntryVal(he),
                patternObjPtr, type);
        }
    }
    else {
        Jim_HashTableIterator htiter;
        JimInitHashTableIterator(ht, &htiter);
        while ((he = Jim_NextHashEntry(&htiter)) != NULL) {
            callback(interp, listObjPtr, Jim_GetHashEntryKey(he), Jim_GetHashEntryVal(he),
                patternObjPtr, type);
        }
    }
    return listObjPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x7b50
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x32643
movq -0x18(%rbp), %rdi
callq 0x7960
movq %rax, %rdi
leaq 0xaedf(%rip), %rsi      # 0x3d4d8
callq 0x63b0
cmpq $0x0, %rax
jne 0x32643
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc250
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x32641
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rcx
movq (%rcx), %rdx
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x18(%rbp), %r8
movl -0x24(%rbp), %r9d
callq *%rax
jmp 0x3268c
movq -0x10(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xc360
leaq -0x58(%rbp), %rdi
callq 0xc3a0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x3268a
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rcx
movq (%rcx), %rdx
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x18(%rbp), %r8
movl -0x24(%rbp), %r9d
callq *%rax
jmp 0x32650
jmp 0x3268c
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimVariablesMatch
static void JimVariablesMatch(Jim_Interp *interp, Jim_Obj *listObjPtr,
    Jim_Obj *keyObj, void *value, Jim_Obj *patternObj, int type)
{
    Jim_VarVal *vv = (Jim_VarVal *)value;

    if ((type & JIM_VARLIST_MASK) != JIM_VARLIST_LOCALS || vv->linkFramePtr == NULL) {
        if (patternObj == NULL || Jim_StringMatchObj(interp, patternObj, keyObj, 0)) {
            Jim_ListAppendElement(interp, listObjPtr, keyObj);
            if (type & JIM_VARLIST_VALUES) {
                Jim_ListAppendElement(interp, listObjPtr, vv->objPtr);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %eax
andl $0xf, %eax
cmpl $0x1, %eax
jne 0x326de
movq -0x38(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x32733
cmpq $0x0, -0x28(%rbp)
je 0x326fd
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0xcbd0
cmpl $0x0, %eax
je 0x32731
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7bd0
movl -0x2c(%rbp), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
je 0x3272f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rax
movq (%rax), %rdx
callq 0x7bd0
jmp 0x32731
jmp 0x32733
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimCommandMatch
static void JimCommandMatch(Jim_Interp *interp, Jim_Obj *listObjPtr,
    Jim_Obj *keyObj, void *value, Jim_Obj *patternObj, int type)
{
    Jim_Cmd *cmdPtr = (Jim_Cmd *)value;

    if (type == JIM_CMDLIST_PROCS && !cmdPtr->isproc) {

        return;
    }

    Jim_IncrRefCount(keyObj);

    if (type != JIM_CMDLIST_CHANNELS || Jim_AioFilehandle(interp, keyObj) >= 0) {
        int match = 1;
        if (patternObj) {
            int plen, slen;
            const char *pattern = Jim_GetStringNoQualifier(patternObj, &plen);
            const char *str = Jim_GetStringNoQualifier(keyObj, &slen);
#ifdef JIM_NO_INTROSPECTION

            match = (JimStringCompareUtf8(pattern, plen, str, slen, 0) == 0);
#else
            match = JimGlobMatch(pattern, plen, str, slen, 0);
#endif
        }
        if (match) {
            Jim_ListAppendElement(interp, listObjPtr, keyObj);
        }
    }
    Jim_DecrRefCount(interp, keyObj);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x1, -0x2c(%rbp)
jne 0x3277d
movq -0x38(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x3277d
jmp 0x32823
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
cmpl $0x2, -0x2c(%rbp)
jne 0x327a2
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x68b0
cmpl $0x0, %eax
jl 0x32804
movl $0x1, -0x3c(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x327eb
movq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1fc80
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x44(%rbp), %rsi
callq 0x1fc80
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movl -0x40(%rbp), %esi
movq -0x58(%rbp), %rdx
movl -0x44(%rbp), %ecx
xorl %r8d, %r8d
callq 0xcc30
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x32802
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7bd0
jmp 0x32804
movq -0x18(%rbp), %rcx
movl 0x10(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rcx)
cmpl $0x0, %eax
jg 0x32823
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7a10
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimGetCallFrameByInteger
static Jim_CallFrame *JimGetCallFrameByInteger(Jim_Interp *interp, long level)
{
    Jim_CallFrame *framePtr;

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

    if (level < 0) {

        level = interp->framePtr->level + level;
    }

    if (level > 0) {

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x32851
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x328b8
cmpq $0x0, -0x18(%rbp)
jge 0x3286c
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movslq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jle 0x328b0
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x328ae
movq -0x20(%rbp), %rax
movslq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x3289e
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x328b8
jmp 0x328a0
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3287f
jmp 0x328b0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: DupScanFmtInternalRep
void DupScanFmtInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
{
    size_t size = (size_t) ((ScanFmtStringObj *) srcPtr->internalRep.ptr)->size;
    ScanFmtStringObj *newVec = (ScanFmtStringObj *) Jim_Alloc(size);

    JIM_NOTUSED(interp);
    memcpy(newVec, srcPtr->internalRep.ptr, size);
    dupPtr->internalRep.ptr = newVec;
    dupPtr->typePtr = &scanFmtStringObjType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq 0x15136(%rip), %rax     # 0x48290
movq -0x20(%rbp), %rsi
xorl %ecx, %ecx
movl %ecx, %edi
callq *%rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x6340
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
leaq 0x14bc4(%rip), %rcx     # 0x47d58
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimRangeLen
static int JimRangeLen(jim_wide start, jim_wide end, jim_wide step)
{
    jim_wide len;

    if (step == 0)
        return -1;
    if (start == end)
        return 0;
    else if (step > 0 && start > end)
        return -1;
    else if (step < 0 && end > start)
        return -1;
    len = end - start;
    if (len < 0)
        len = -len;
    if (step < 0)
        step = -step;
    len = 1 + ((len - 1) / step);
    if (len > INT_MAX)
        len = INT_MAX;
    return (int)((len < 0) ? -1 : len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x331f3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x332bd
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x33209
movl $0x0, -0x4(%rbp)
jmp 0x332bd
cmpq $0x0, -0x20(%rbp)
jle 0x33226
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jle 0x33226
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x332bd
cmpq $0x0, -0x20(%rbp)
jge 0x33240
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jle 0x33240
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x332bd
jmp 0x33242
jmp 0x33244
movq -0x18(%rbp), %rax
subq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x33261
xorl %eax, %eax
subq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x33272
xorl %eax, %eax
subq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
subq $0x1, %rax
cqto
idivq -0x20(%rbp)
addq $0x1, %rax
movq %rax, -0x28(%rbp)
cmpq $0x7fffffff, -0x28(%rbp) # imm = 0x7FFFFFFF
jle 0x3329a
movq $0x7fffffff, -0x28(%rbp) # imm = 0x7FFFFFFF
cmpq $0x0, -0x28(%rbp)
jge 0x332ae
movq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x332b6
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: regnode
static int regnode(regex_t *preg, int op)
{
	reg_grow(preg, 2);


	preg->program[preg->p++] = op;
	preg->program[preg->p++] = 0;


	return preg->p - 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x33570
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x30(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x30(%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdx
movl 0x30(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x30(%rdx)
movslq %ecx, %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
subl $0x2, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: regbranch
static int regbranch(regex_t *preg, int *flagp )
{
	int ret;
	int chain;
	int latest;
	int flags;

	*flagp = WORST;

	ret = regnode(preg, BRANCH);
	chain = 0;
	while (*preg->regparse != '\0' && *preg->regparse != ')' &&
	       *preg->regparse != '|') {
		latest = regpiece(preg, &flags);
		if (latest == 0)
			return 0;
		*flagp |= flags&HASWIDTH;
		if (chain == 0) {
			*flagp |= flags&SPSTART;
		}
		else {
			regtail(preg, chain, latest);
		}
		chain = latest;
	}
	if (chain == 0)
		(void) regnode(preg, NOTHING);

	return(ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
movl $0x6, %esi
callq 0x33330
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0x33410
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x29, %ecx
movb %al, -0x29(%rbp)
je 0x33410
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movsbl (%rax), %eax
cmpl $0x7c, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x33419
jmp 0x33476
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x335d0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x33438
movl $0x0, -0x4(%rbp)
jmp 0x33490
movl -0x28(%rbp), %ecx
andl $0x1, %ecx
movq -0x18(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
cmpl $0x0, -0x20(%rbp)
jne 0x3345c
movl -0x28(%rbp), %ecx
andl $0x4, %ecx
movq -0x18(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x3346b
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x334a0
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x333d2
cmpl $0x0, -0x20(%rbp)
jne 0x3348a
movq -0x10(%rbp), %rdi
movl $0x9, %esi
callq 0x33330
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: regtail
static void regtail(regex_t *preg, int p, int val)
{
	int scan;
	int temp;
	int offset;


	scan = p;
	for (;;) {
		temp = regnext(preg, scan);
		if (temp == 0)
			break;
		scan = temp;
	}

	if (OP(preg, scan) == BACK)
		offset = scan - val;
	else
		offset = val - scan;

	preg->program[scan + 1] = offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x162c0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x334cf
jmp 0x334d7
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x334b8
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x7, (%rax,%rcx,4)
jne 0x334f4
movl -0x14(%rbp), %eax
subl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x334fd
movl -0x10(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: reginsert
static int reginsert(regex_t *preg, int op, int size, int opnd )
{
	reg_grow(preg, size);


	memmove(preg->program + opnd + size, preg->program + opnd, sizeof(int) * (preg->p - opnd));

	memset(preg->program + opnd, 0, sizeof(int) * size);

	preg->program[opnd] = op;

	preg->p += size;

	return opnd + size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x33570
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movslq -0x14(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movslq -0x10(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movslq -0x14(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
subl -0x14(%rbp), %eax
movslq %eax, %rdx
shlq $0x2, %rdx
callq 0x6410
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movslq -0x14(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movslq -0x10(%rbp), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x6250
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x30(%rax), %ecx
movl %ecx, 0x30(%rax)
movl -0x14(%rbp), %eax
addl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: reg_utf8_tounicode_case
static int reg_utf8_tounicode_case(const char *s, int *uc, int upper)
{
	int l = utf8_tounicode(s, uc);
	if (upper) {
		*uc = utf8_upper(*uc);
	}
	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x34500
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x60f0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)