LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %r14
leaq 0x129dd(%rip), %r15     # 0x352f0
cmpq %r15, 0x8(%r14)
je 0x22938
movq 0x14988(%rip), %rax     # 0x372a8
movq 0xd0(%rax), %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0xd6c3
testl %eax, %eax
jne 0x2298f
movq 0x18(%r14), %r14
movq (%rbx), %rbx
cmpq %r15, 0x8(%rbx)
je 0x22964
movq 0x1495c(%rip), %rax     # 0x372a8
movq 0xd0(%rax), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0xd6c3
testl %eax, %eax
jne 0x2298f
xorl %ecx, %ecx
xorl %eax, %eax
cmpq 0x18(%rbx), %r14
setge %al
leal -0x1(%rax,%rax), %eax
cmovel %ecx, %eax
movq 0x1492b(%rip), %rcx     # 0x372a8
imull 0xdc(%rcx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x14912(%rip), %rdi     # 0x372a8
movl $0x1, %esi
callq 0x63c0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
xorl %eax, %eax
leaq -0x18(%rbp), %rdx
movq %rax, (%rdx)
movq %rax, -0x10(%rbp)
movq 0x148e8(%rip), %rax     # 0x372a8
movq 0xd0(%rax), %rax
movq (%rdi), %rsi
movq %rax, %rdi
callq 0xe040
testl %eax, %eax
jne 0x22a1c
movq 0x148cb(%rip), %rax     # 0x372a8
movq 0xd0(%rax), %rdi
movq (%rbx), %rsi
leaq -0x10(%rbp), %rdx
callq 0xe040
testl %eax, %eax
jne 0x22a1c
movsd -0x18(%rbp), %xmm0
xorl %eax, %eax
ucomisd -0x10(%rbp), %xmm0
jne 0x22a04
jnp 0x22a15
movq 0x1489d(%rip), %rax     # 0x372a8
movl 0xdc(%rax), %eax
ja 0x22a15
negl %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq 0x14885(%rip), %rdi     # 0x372a8
movl $0x1, %esi
callq 0x63c0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x14864(%rip), %rax     # 0x372a8
movq 0xc8(%rax), %rsi
movq 0xd0(%rax), %rdi
callq 0x8fc2
movq %rax, %r15
movq 0x14847(%rip), %rax     # 0x372a8
movq 0xd0(%rax), %rdi
movq (%r14), %rdx
movq %r15, %rsi
callq 0x7683
movq 0x1482e(%rip), %rax     # 0x372a8
movq 0xd0(%rax), %rdi
movq (%rbx), %rdx
movq %r15, %rsi
callq 0x7683
movq 0x14815(%rip), %rax     # 0x372a8
movq 0xd0(%rax), %rdi
movq %r15, %rsi
callq 0x908a
movl %eax, %ebx
testl %eax, %eax
jne 0x22b06
movq 0x147f9(%rip), %rcx     # 0x372a8
movq 0xd0(%rcx), %rdi
movq (%rdi), %r14
leaq 0x12830(%rip), %rax     # 0x352f0
cmpq %rax, 0x8(%r14)
je 0x22ade
movq %r14, %rsi
movl $0x1, %edx
callq 0xd6c3
testl %eax, %eax
jne 0x22b06
movq 0x147ca(%rip), %rcx     # 0x372a8
movq 0x18(%r14), %rdx
movq %rdx, %rsi
sarq $0x3f, %rsi
orl $0x1, %esi
xorl %eax, %eax
testq %rdx, %rdx
cmovnel %esi, %eax
imull 0xdc(%rcx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x1479b(%rip), %rdi     # 0x372a8
movl %ebx, %esi
callq 0x63c0
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: ListSortDict
static int ListSortDict(Jim_Obj **lhsObj, Jim_Obj **rhsObj)
{

    const char *left = Jim_String(*lhsObj);
    const char *right = Jim_String(*rhsObj);

    while (1) {
        if (isdigit(UCHAR(*left)) && isdigit(UCHAR(*right))) {

            jim_wide lint, rint;
            char *lend, *rend;
            lint = jim_strtoull(left, &lend);
            rint = jim_strtoull(right, &rend);
            if (lint != rint) {
                return JimSign(lint - rint) * sort_info->order;
            }
            if (lend -left != rend - right) {
                return JimSign((lend - left) - (rend - right)) * sort_info->order;
            }
            left = lend;
            right = rend;
        }
        else {
            int cl, cr;
            left += utf8_tounicode_case(left, &cl, 1);
            right += utf8_tounicode_case(right, &cr, 1);
            if (cl != cr) {
                return JimSign(cl - cr) * sort_info->order;
            }
            if (cl == 0) {

                return Jim_StringCompareObj(sort_info->interp, *lhsObj, *rhsObj, 0) * sort_info->order;
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
movq (%rdi), %rbx
movq (%rbx), %r15
testq %r15, %r15
jne 0x22b44
movq 0x8(%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq (%rbx), %r15
movq %r14, -0x38(%rbp)
movq (%r14), %rbx
movq (%rbx), %r12
testq %r12, %r12
jne 0x22b60
movq 0x8(%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq (%rbx), %r12
callq 0x64e0
movq %rax, %r13
leaq -0x40(%rbp), %r14
movq (%r13), %rax
movzbl (%r15), %edi
testb $0x8, 0x1(%rax,%rdi,2)
je 0x22b87
movzbl (%r12), %ecx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x22ba8
callq 0x60e0
movl %eax, %ebx
movzbl (%r12), %edi
callq 0x60e0
cmpl %eax, %ebx
jne 0x22be8
incq %r15
incq %r12
testl %ebx, %ebx
jne 0x22b6c
jmp 0x22c02
movq %r15, %rdi
leaq -0x48(%rbp), %rsi
callq 0xd4a0
movq %rax, %rbx
movq %r12, %rdi
movq %r14, %rsi
callq 0xd4a0
cmpq %rax, %rbx
jne 0x22c27
movq -0x48(%rbp), %rax
movq %rax, %rdx
subq %r15, %rdx
movq -0x40(%rbp), %rcx
movq %rcx, %rsi
subq %r12, %rsi
cmpq %rsi, %rdx
jne 0x22c27
movq %rcx, %r12
movq %rax, %r15
jmp 0x22b6c
movl %eax, %ecx
movq 0x146b7(%rip), %rax     # 0x372a8
movl 0xdc(%rax), %edx
movl %edx, %eax
negl %eax
cmpl %ecx, %ebx
cmovgel %edx, %eax
jmp 0x22c40
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq -0x38(%rbp), %rax
movq (%rax), %rdx
xorl %ecx, %ecx
callq 0xb312
movq 0x1468a(%rip), %rcx     # 0x372a8
imull 0xdc(%rcx), %eax
jmp 0x22c40
setl %cl
movq 0x14677(%rip), %rax     # 0x372a8
movl 0xdc(%rax), %edx
movl %edx, %eax
negl %eax
testb %cl, %cl
cmovel %edx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: 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
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq 0x14646(%rip), %rax     # 0x372a8
movq (%rdi), %rsi
movq 0xd0(%rax), %rdi
movq 0xe0(%rax), %rdx
movl 0xe8(%rax), %ecx
leaq -0x18(%rbp), %r8
movl $0x1, %r9d
callq 0x225a2
testl %eax, %eax
jne 0x22cd9
movq 0x14615(%rip), %rax     # 0x372a8
movq (%rbx), %rsi
movq 0xd0(%rax), %rdi
movq 0xe0(%rax), %rdx
movl 0xe8(%rax), %ecx
leaq -0x10(%rbp), %r8
movl $0x1, %r9d
callq 0x225a2
testl %eax, %eax
jne 0x22cd9
movq 0x145e4(%rip), %rax     # 0x372a8
leaq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq *0xf0(%rax)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq 0x145c8(%rip), %rdi     # 0x372a8
movl $0x1, %esi
callq 0x63c0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
leal -0x3(%rsi), %eax
cmpl $-0x3, %eax
ja 0x22d1c
leaq 0x9b8e(%rip), %rcx      # 0x2c895
movl $0x1, %r15d
movq %r14, %rdi
movl $0x1, %esi
callq 0x7446
jmp 0x22d5b
movl %ecx, %ebx
cmpl $0x2, %esi
jne 0x22d58
movq 0x8(%rdx), %r12
leaq 0x125c2(%rip), %rax     # 0x352f0
cmpq %rax, 0x8(%r12)
je 0x22d4f
movl $0x1, %r15d
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0xd6c3
testl %eax, %eax
jne 0x22d5b
movl 0x18(%r12), %eax
movl %eax, 0x18(%r14)
movl %ebx, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r13d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
subl %esi, %r13d
jl 0x234cc
testl %esi, %esi
je 0x234cc
testl %ecx, %ecx
je 0x234cc
xorl %ecx, %ecx
testl %r8d, %r8d
cmovgl %r8d, %ecx
cmpl %r13d, %ecx
jg 0x234cc
movq %rdx, %r14
movq %rdi, %r15
movslq %esi, %r12
movl %ecx, %ebx
incl %r13d
leaq (%r14,%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x6390
testl %eax, %eax
je 0x234ca
incq %rbx
cmpl %ebx, %r13d
jne 0x234a8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x234cc
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, -0x38(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %esi
jg 0x23552
testl %esi, %esi
je 0x23552
testl %ecx, %ecx
je 0x23552
movl %ecx, -0x2c(%rbp)
movslq %ecx, %r14
movq -0x38(%rbp), %rax
movb (%rax), %r15b
movslq %esi, %r12
leaq (%r14,%rdx), %r13
decq %r13
negq %r14
xorl %ebx, %ebx
cmpb %r15b, (%r13)
jne 0x23536
movq -0x38(%rbp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x6390
testl %eax, %eax
je 0x2354b
incq %rbx
decq %r13
movq %r14, %rax
addq %rbx, %rax
jne 0x2351d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x23552
notl %ebx
addl -0x2c(%rbp), %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: 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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
callq 0x235af
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x23685
movq %rax, %r15
cmpq %rax, %r14
je 0x235a1
cmpl $0x0, 0x10(%r14)
jne 0x235a1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x758c
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, -0x48(%rbp)
movq (%rsi), %r14
testq %r14, %r14
jne 0x235df
movq 0x8(%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq (%rbx), %r14
movl 0x14(%rbx), %r15d
testq %r13, %r13
movq %rbx, -0x30(%rbp)
je 0x23609
movq (%r13), %r12
testq %r12, %r12
jne 0x23603
movq 0x8(%r13), %rax
movq %r13, %rdi
callq *0x18(%rax)
movq (%r13), %r12
movslq 0x14(%r13), %rbx
jmp 0x23615
leaq 0x4144(%rip), %r12      # 0x27754
movl $0x5, %ebx
leaq (%r14,%r15), %rax
movq %rax, -0x38(%rbp)
leaq -0x1(%r14), %r13
movq %r15, -0x40(%rbp)
subl $0x1, %r15d
jb 0x23645
movzbl 0x1(%r13), %esi
incq %r13
movq %r12, %rdi
movq %rbx, %rdx
callq 0x6290
testq %rax, %rax
jne 0x23625
jmp 0x23649
movq -0x38(%rbp), %r13
cmpq %r14, %r13
je 0x23672
subl %r13d, %r14d
movq -0x40(%rbp), %rdx
addl %r14d, %edx
movq -0x48(%rbp), %rdi
movq %r13, %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7508
movq -0x30(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x236c2
movq %rdx, %r12
movq (%rdx), %r15
testq %r15, %r15
jne 0x236bb
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
movq (%r12), %r15
movslq 0x14(%r12), %r13
jmp 0x236cf
leaq 0x408b(%rip), %r15      # 0x27754
movl $0x5, %r13d
movq %r14, -0x40(%rbp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xaf2e
movq (%rbx), %rax
testq %rax, %rax
jne 0x236f3
movq 0x8(%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq (%rbx), %rax
movq %rbx, -0x38(%rbp)
movslq 0x14(%rbx), %rcx
movl %ecx, %edx
movq %rdx, -0x48(%rbp)
movq %rcx, %r12
movq %rax, -0x30(%rbp)
addq %rax, %r12
movq $-0x1, %r14
movq %rcx, -0x50(%rbp)
movl %ecx, %ebx
subl $0x1, %ebx
jb 0x2376b
movzbl (%r12,%r14), %esi
movq %r15, %rdi
movq %r13, %rdx
callq 0x6290
decq %r14
testq %rax, %rax
jne 0x23718
cmpq $-0x2, %r14
je 0x2378f
movq -0x38(%rbp), %rax
cmpl $0x2, 0x10(%rax)
jl 0x23795
movq -0x48(%rbp), %rax
leal (%rax,%r14), %edx
addl $0x2, %edx
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7508
movq -0x40(%rbp), %rdi
callq 0xae38
leaq 0x13b1d(%rip), %rcx     # 0x37298
movq %rcx, (%rax)
movl $0x0, 0x14(%rax)
movq $0x0, 0x8(%rax)
jmp 0x237ad
movq -0x38(%rbp), %rax
jmp 0x237ad
movb $0x0, 0x2(%r12,%r14)
movq -0x30(%rbp), %rcx
addl -0x50(%rbp), %ecx
subl (%rax), %ecx
addl %r14d, %ecx
addl $0x2, %ecx
movl %ecx, 0x14(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: 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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
testq %r15, %r15
jne 0x237e2
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %r15
movslq 0x14(%r14), %rsi
incq %rsi
xorl %edi, %edi
callq *0x13a97(%rip)          # 0x37288
movq %rax, %r14
movb (%r15), %al
movq %r14, %r12
testb %al, %al
je 0x2381d
incq %r15
movq %r14, %r12
movzbl %al, %edi
callq 0x6350
movb %al, (%r12)
incq %r12
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x23804
movb $0x0, (%r12)
movq %rbx, %rdi
callq 0xae38
movq %rax, %rbx
movq %r14, (%rax)
movq %r14, %rdi
callq 0x6180
movl %eax, 0x14(%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
testq %r15, %r15
jne 0x23875
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %r15
movslq 0x14(%r14), %rsi
incq %rsi
xorl %edi, %edi
callq *0x13a04(%rip)          # 0x37288
movq %rax, %r14
movb (%r15), %al
movq %r14, %r12
testb %al, %al
je 0x238b0
incq %r15
movq %r14, %r12
movzbl %al, %edi
callq 0x60e0
movb %al, (%r12)
incq %r12
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x23897
movb $0x0, (%r12)
movq %rbx, %rdi
callq 0xae38
movq %rax, %rbx
movq %r14, (%rax)
movq %r14, %rdi
callq 0x6180
movl %eax, 0x14(%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
testq %r15, %r15
jne 0x23908
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %r15
movslq 0x14(%r14), %rsi
incq %rsi
xorl %edi, %edi
callq *0x13971(%rip)          # 0x37288
movq %rax, %r14
movzbl (%r15), %edi
callq 0x60e0
movb %al, (%r14)
movq %r14, %r12
incq %r12
movb 0x1(%r15), %al
testb %al, %al
je 0x23951
addq $0x2, %r15
movzbl %al, %edi
callq 0x6350
movb %al, (%r12)
incq %r12
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x23938
movb $0x0, (%r12)
movq %rbx, %rdi
callq 0xae38
movq %rax, %rbx
movq %r14, (%rax)
movq %r14, %rdi
callq 0x6180
movl %eax, 0x14(%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10b14(%rip), %rax     # 0x352f0
cmpq %rax, 0x8(%rsi)
je 0x247f6
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0xd6c3
testl %eax, %eax
jne 0x24819
movq 0x18(%r15), %rcx
testq %rcx, %rcx
je 0x24810
movq 0x58(%r14), %rax
jns 0x2483d
movslq 0x8(%rax), %rdx
addq %rdx, %rcx
jg 0x24842
jmp 0x24819
movq 0x58(%r14), %rax
testq %rax, %rax
jne 0x24851
leaq 0x8278(%rip), %rsi      # 0x2ca98
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x6923
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testq %rax, %rax
je 0x24819
movslq 0x8(%rax), %rdx
cmpq %rdx, %rcx
je 0x24851
movq 0x48(%rax), %rax
jmp 0x2483d
cmpq 0x60(%r14), %rax
je 0x24819
movq 0x50(%rax), %rsi
movl 0x58(%rax), %edx
movq %r14, %rdi
callq 0x762e
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x24832
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, -0x2c(%rbp)
movq %rcx, -0x40(%rbp)
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, -0x38(%rbp)
callq 0xae38
movq %rax, %r12
leaq 0x1084c(%rip), %rax     # 0x35368
movq %rax, 0x8(%r12)
movq $0x0, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r12)
testq %r15, %r15
je 0x24b5d
movq (%r15), %rdi
testq %rdi, %rdi
jne 0x24b4c
movq 0x8(%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq (%r15), %rdi
leaq 0x85c4(%rip), %rsi      # 0x2d117
callq 0x63a0
testq %rax, %rax
je 0x24ba7
movb $0x1, %cl
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
xorl %eax, %eax
testb $0x1, %cl
je 0x24b7f
incl %r14d
cmpl 0x18(%rbx), %r14d
jge 0x24bcf
movq (%rbx), %rax
movslq %r14d, %rcx
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0x24b6c
movq 0x10(%rax), %r13
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq -0x38(%rbp), %rdi
movq %r12, %rsi
movq %r15, %r8
movl -0x2c(%rbp), %r9d
callq *-0x40(%rbp)
xorl %ecx, %ecx
movq %r13, %rax
jmp 0x24b67
movq %rbx, %rdi
movq %r15, %rsi
callq 0xac6b
testq %rax, %rax
je 0x24bcf
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq -0x38(%rbp), %rdi
movq %r12, %rsi
movq %r15, %r8
movl -0x2c(%rbp), %r9d
callq *-0x40(%rbp)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r12d
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r15
movl %r9d, %eax
andl $0xf, %eax
cmpl $0x1, %eax
jne 0x24c10
cmpq $0x0, 0x8(%r14)
jne 0x24c3b
testq %r8, %r8
je 0x24c26
movq %r8, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0xb104
testl %eax, %eax
je 0x24c3b
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x7683
btl $0xc, %r12d
jb 0x24c4a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rdx
movq %r15, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7683
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpl $0x1, %r9d
jne 0x24c99
cmpl $0x0, 0x4(%rcx)
je 0x24d2a
leaq 0x10(%rbx), %r13
incl 0x10(%rbx)
jmp 0x24cb5
leaq 0x10(%rbx), %r13
incl 0x10(%rbx)
cmpl $0x2, %r9d
jne 0x24cb5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x677b
testl %eax, %eax
js 0x24d01
testq %r12, %r12
je 0x24cf3
leaq -0x30(%rbp), %rsi
movq %r12, %rdi
callq 0x18953
movq %rax, %r12
leaq -0x2c(%rbp), %rsi
movq %rbx, %rdi
callq 0x18953
leaq -0x30(%rbp), %rcx
movl (%rcx), %esi
leaq -0x2c(%rbp), %rcx
movl (%rcx), %ecx
movq %r12, %rdi
movq %rax, %rdx
xorl %r8d, %r8d
callq 0xb15f
testl %eax, %eax
je 0x24d01
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x7683
movl (%r13), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r13)
cmpl $0x1, %eax
jg 0x24d2a
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x758c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: 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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq 0x18(%rsi), %rax
movq (%rax), %r15
xorl %edi, %edi
movq %r15, %rsi
callq *0x12508(%rip)          # 0x37288
movq %rax, %r12
movq 0x18(%r14), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x6320
movq %r12, 0x18(%rbx)
leaq 0x11f2b(%rip), %rax     # 0x36cc8
movq %rax, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: reg_addrange
static void reg_addrange(regex_t *preg, int lower, int upper)
{
	if (lower > upper) {
		reg_addrange(preg, upper, lower);
	}

	regc(preg, upper - lower + 1);
	regc(preg, lower);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %edx, %r15d
subl %esi, %r15d
jge 0x25d59
movq %r14, %rdi
movl %edx, %esi
movl %ebx, %edx
callq 0x25d36
incl %r15d
movq %r14, %rdi
movl $0x1, %esi
callq 0x25d00
movq 0x20(%r14), %rax
movslq 0x30(%r14), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x30(%r14)
movl %r15d, (%rax,%rcx,4)
movq %r14, %rdi
movl $0x1, %esi
callq 0x25d00
movq 0x20(%r14), %rax
movslq 0x30(%r14), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x30(%r14)
movl %ebx, (%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: reg_decode_escape
static int reg_decode_escape(const char *s, int *ch)
{
	int n;
	const char *s0 = s;

	*ch = *s++;

	switch (*ch) {
		case 'b': *ch = '\b'; break;
		case 'e': *ch = 27; break;
		case 'f': *ch = '\f'; break;
		case 'n': *ch = '\n'; break;
		case 'r': *ch = '\r'; break;
		case 't': *ch = '\t'; break;
		case 'v': *ch = '\v'; break;
		case 'u':
			if (*s == '{') {

				n = parse_hex(s + 1, 6, ch);
				if (n > 0 && s[n + 1] == '}' && *ch >= 0 && *ch <= 0x1fffff) {
					s += n + 2;
				}
				else {

					*ch = 'u';
				}
			}
			else if ((n = parse_hex(s, 4, ch)) > 0) {
				s += n;
			}
			break;
		case 'U':
			if ((n = parse_hex(s, 8, ch)) > 0) {
				s += n;
			}
			break;
		case 'x':
			if ((n = parse_hex(s, 2, ch)) > 0) {
				s += n;
			}
			break;
		case '\0':
			s--;
			*ch = '\\';
			break;
	}
	return s - s0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1(%rdi), %r14
movzbl (%rdi), %eax
movsbl %al, %ecx
movl %ecx, (%rsi)
cmpl $0x64, %eax
jle 0x25def
addl $-0x65, %eax
cmpl $0x13, %eax
ja 0x25ec7
leaq 0x189e(%rip), %rcx      # 0x27678
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1b, (%r15)
jmp 0x25ec7
testl %eax, %eax
je 0x25e8f
cmpl $0x55, %eax
je 0x25e9b
cmpl $0x62, %eax
jne 0x25ec7
movl $0x8, (%r15)
jmp 0x25ec7
movl $0x9, (%r15)
jmp 0x25ec7
movl $0xb, (%r15)
jmp 0x25ec7
movl $0xa, (%r15)
jmp 0x25ec7
movl $0xc, (%r15)
jmp 0x25ec7
movl $0xd, (%r15)
jmp 0x25ec7
movq %r14, %rdi
movl $0x2, %esi
jmp 0x25ead
cmpb $0x7b, (%r14)
jne 0x25ea5
leaq 0x2(%rbx), %rdi
movl $0x6, %esi
movq %r15, %rdx
callq 0x25ed8
testl %eax, %eax
jle 0x25ec0
movl %eax, %eax
cmpb $0x7d, 0x1(%r14,%rax)
jne 0x25ec0
cmpl $0x1fffff, (%r15)       # imm = 0x1FFFFF
ja 0x25ec0
addq %rax, %r14
addq $0x2, %r14
jmp 0x25ec7
movl $0x5c, (%r15)
movq %rbx, %r14
jmp 0x25ec7
movq %r14, %rdi
movl $0x8, %esi
jmp 0x25ead
movq %r14, %rdi
movl $0x4, %esi
movq %r15, %rdx
callq 0x25ed8
testl %eax, %eax
jle 0x25ec7
movl %eax, %eax
addq %rax, %r14
jmp 0x25ec7
movl $0x75, (%r15)
subl %ebx, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/msteveb[P]autosetup/./jimsh0.c
// Function: parse_hex
static int parse_hex(const char *s, int n, int *uc)
{
	int val = 0;
	int k;

	for (k = 0; k < n; k++) {
		int c = hexdigitval(*s++);
		if (c == -1) {
			break;
		}
		val = (val << 4) | c;
	}
	if (k) {
		*uc = val;
	}
	return k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
jle 0x25f2d
movl %esi, %esi
xorl %eax, %eax
xorl %ecx, %ecx
movsbl (%rdi,%rax), %r8d
leal -0x30(%r8), %r9d
cmpl $0xa, %r9d
jb 0x25f16
leal -0x61(%r8), %r9d
cmpl $0x5, %r9d
ja 0x25f05
addl $-0x57, %r8d
jmp 0x25f13
leal -0x41(%r8), %r9d
cmpl $0x5, %r9d
ja 0x25f29
addl $-0x37, %r8d
movl %r8d, %r9d
shll $0x4, %ecx
orl %r9d, %ecx
incq %rax
cmpl %eax, %esi
jne 0x25ee6
movl %esi, %eax
movl %ecx, (%rdx)
jmp 0x25f2f
testl %eax, %eax
jne 0x25f25
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/voithos[P]awl/src/awl.c
// Function: run_scripts
void run_scripts(awlenv* e, int argc, char** argv) {
    for (int i = 1; i < argc; i++) {
        awlval* args = awlval_add(awlval_sexpr(), awlval_str(argv[i]));
        awlval* x = builtin_import(e, args);

        if (x->type == AWLVAL_ERR) {
            awlval_println(x);
        }
        awlval_del(x);
    }
}

// Assembly:
cmpl $0x2, %esi
jl 0x2cb9
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, %r12d
movl $0x1, %r13d
callq 0x1020f
movq %rax, %r15
movq (%rbx,%r13,8), %rdi
callq 0x10032
movq %r15, %rdi
movq %rax, %rsi
callq 0x1036d
movq %r14, %rdi
movq %rax, %rsi
callq 0x5220
movq %rax, %r15
cmpl $0x2, (%rax)
jne 0x2ca0
movq %r15, %rdi
callq 0xf717
movq %r15, %rdi
callq 0x1029f
incq %r13
cmpq %r13, %r12
jne 0x2c69
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/voithos[P]awl/src/builtins.c
// Function: builtin_ord_op
awlval* builtin_ord_op(awlenv* e, awlval* a, char* op) {
    AWLASSERT_ARGCOUNT(a, 2, op);
    EVAL_ARGS(e, a);
    AWLASSERT_ISNUMERIC(a, 0, op);
    AWLASSERT_ISNUMERIC(a, 1, op);

    awlval* x = awlval_pop(a, 0);
    awlval* y = awlval_pop(a, 0);

    awlval_maybe_promote_numeric(x, y);

    bool res;
    if (streq(op, ">")) {
        BINARY_OP_RES(res, x, y, >);
    }
    if (streq(op, "<")) {
        BINARY_OP_RES(res, x, y, <);
    }
    if (streq(op, ">=")) {
        BINARY_OP_RES(res, x, y, >=);
    }
    if (streq(op, "<=")) {
        BINARY_OP_RES(res, x, y, <=);
    }

    awlval_del(y);
    awlval_del(a);

    x->type = AWLVAL_BOOL;
    x->bln = res;
    return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x2, %ecx
jne 0x33db
movq %rbx, %rsi
callq 0x5f58
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x33f6
movq %rbx, %r15
movq %r15, %rax
jmp 0x34a1
leaq 0xed18(%rip), %rdi      # 0x120fa
movq %r14, %rsi
movl $0x2, %edx
xorl %eax, %eax
callq 0xfe6b
jmp 0x3493
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movl (%rcx), %edi
cmpl $0x2, %edi
jae 0x3462
movq 0x8(%rax), %rax
movl (%rax), %edi
cmpl $0x2, %edi
jae 0x3475
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1075b
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1075b
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x10ae4
leaq 0xfaf5(%rip), %rsi      # 0x12f30
movq %r14, %rdi
callq 0x11692
testb %al, %al
je 0x34bb
movl (%r15), %eax
cmpl $0x1, %eax
je 0x34aa
testl %eax, %eax
jne 0x34bb
movq 0x18(%r15), %rax
cmpq 0x18(%r12), %rax
setg %bpl
jmp 0x34bb
callq 0xfc74
leaq 0xebd2(%rip), %rdi      # 0x12040
movq %r14, %rsi
xorl %edx, %edx
jmp 0x3489
callq 0xfc74
leaq 0xebbf(%rip), %rdi      # 0x12040
movq %r14, %rsi
movl $0x1, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfe6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1029f
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movsd 0x18(%r15), %xmm0
ucomisd 0x18(%r12), %xmm0
seta %bpl
leaq 0xec6d(%rip), %rsi      # 0x1212f
movq %r14, %rdi
callq 0x11692
testb %al, %al
je 0x34fa
movl (%r15), %eax
cmpl $0x1, %eax
je 0x34e9
testl %eax, %eax
jne 0x34fa
movq 0x18(%r15), %rax
cmpq 0x18(%r12), %rax
setl %bpl
jmp 0x34fa
movsd 0x18(%r12), %xmm0
ucomisd 0x18(%r15), %xmm0
seta %bpl
leaq 0xec30(%rip), %rsi      # 0x12131
movq %r14, %rdi
callq 0x11692
testb %al, %al
je 0x3539
movl (%r15), %eax
cmpl $0x1, %eax
je 0x3528
testl %eax, %eax
jne 0x3539
movq 0x18(%r15), %rax
cmpq 0x18(%r12), %rax
setge %bpl
jmp 0x3539
movsd 0x18(%r15), %xmm0
ucomisd 0x18(%r12), %xmm0
setae %bpl
leaq 0xebf4(%rip), %rsi      # 0x12134
movq %r14, %rdi
callq 0x11692
testb %al, %al
je 0x3578
movl (%r15), %eax
cmpl $0x1, %eax
je 0x3567
testl %eax, %eax
jne 0x3578
movq 0x18(%r15), %rax
cmpq 0x18(%r12), %rax
setle %bpl
jmp 0x3578
movsd 0x18(%r12), %xmm0
ucomisd 0x18(%r15), %xmm0
setae %bpl
movq %r12, %rdi
callq 0x1029f
movq %rbx, %rdi
callq 0x1029f
movl $0x6, (%r15)
andb $0x1, %bpl
movb %bpl, 0x18(%r15)
jmp 0x33d3
// File: /workspace/github_c_makefile_star2_O3/voithos[P]awl/src/builtins.c
// Function: builtin_logic_op
awlval* builtin_logic_op(awlenv* e, awlval* a, char* op) {
    AWLASSERT_ARGCOUNT(a, 2, op);
    EVAL_ARGS(e, a);

    bool eq = awlval_eq(a->cell[0], a->cell[1]);
    bool res;
    if (streq(op, "==")) {
        res = eq;
    }
    if (streq(op, "!=")) {
        res = !eq;
    }
    awlval_del(a);
    return awlval_bool(res);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl 0x4(%rsi), %ecx
cmpl $0x2, %ecx
jne 0x35f3
movq %r14, %rsi
callq 0x5f58
movq %rax, %r14
cmpl $0x2, (%rax)
jne 0x361c
movq %r14, %rax
jmp 0x3617
leaq 0xeb00(%rip), %rdi      # 0x120fa
movq %rbx, %rsi
movl $0x2, %edx
xorl %eax, %eax
callq 0xfe6b
movq %rax, %rbx
movq %r14, %rdi
callq 0x1029f
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8(%r14), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x10dee
movl %eax, %ebp
leaq 0xeb02(%rip), %rsi      # 0x12137
movq %rbx, %rdi
callq 0x11692
leaq 0xeaf6(%rip), %rsi      # 0x1213a
movq %rbx, %rdi
callq 0x11692
movl %eax, %ebx
xorb %bpl, %bl
movq %r14, %rdi
callq 0x1029f
movzbl %bl, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x10090
// File: /workspace/github_c_makefile_star2_O3/voithos[P]awl/src/builtins.c
// Function: builtin_head
awlval* builtin_head(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 1, "head");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 0, AWLVAL_QEXPR, "head");
    AWLASSERT_NONEMPTY(a, a->cell[0], "head");

    awlval* v = awlval_take(a, 0);
    return awlval_eval(e, awlval_take(v, 0));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x1, %ecx
jne 0x3906
movq %rdi, %r14
movq %rbx, %rsi
callq 0x5f58
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x3936
movq %rbx, %rax
jmp 0x392e
leaq 0xe7ed(%rip), %rdi      # 0x120fa
leaq 0xe88e(%rip), %rsi      # 0x121a2
movl $0x1, %edx
xorl %eax, %eax
callq 0xfe6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1029f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0xc, %edi
jne 0x3970
cmpl $0x0, 0x4(%rax)
je 0x39a4
movq %rbx, %rdi
xorl %esi, %esi
callq 0x107b7
movq %rax, %rdi
xorl %esi, %esi
callq 0x107b7
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5be8
callq 0xfc74
movq %rax, %r14
movl $0xc, %edi
callq 0xfc74
leaq 0xe7b8(%rip), %rdi      # 0x12141
leaq 0xe812(%rip), %rsi      # 0x121a2
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xfe6b
jmp 0x3920
leaq 0xe7de(%rip), %rdi      # 0x12189
leaq 0xe7f0(%rip), %rsi      # 0x121a2
xorl %eax, %eax
callq 0xfe6b
jmp 0x3920
// File: /workspace/github_c_makefile_star2_O3/voithos[P]awl/src/builtins.c
// Function: builtin_qhead
awlval* builtin_qhead(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 1, "qhead");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 0, AWLVAL_QEXPR, "qhead");
    AWLASSERT_NONEMPTY(a, a->cell[0], "qhead");

    awlval* q = awlval_take(a, 0);
    awlval* v = awlval_take(q, 0);

    if (v->type == AWLVAL_SEXPR) {
        v->type = AWLVAL_QEXPR;
    } else if (v->type == AWLVAL_SYM) {
        v->type = AWLVAL_QSYM;
    }
    return awlval_eval(e, v);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl 0x4(%rsi), %ecx
cmpl $0x1, %ecx
jne 0x39e5
movq %rdi, %rbx
movq %r14, %rsi
callq 0x5f58
movq %rax, %r14
cmpl $0x2, (%rax)
jne 0x3a15
movq %r14, %rax
jmp 0x3a0d
leaq 0xe70e(%rip), %rdi      # 0x120fa
leaq 0xe7ae(%rip), %rsi      # 0x121a1
movl $0x1, %edx
xorl %eax, %eax
callq 0xfe6b
movq %rax, %rbx
movq %r14, %rdi
callq 0x1029f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%r14), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0xc, %edi
jne 0x3a50
cmpl $0x0, 0x4(%rax)
je 0x3a84
movq %r14, %rdi
xorl %esi, %esi
callq 0x107b7
movq %rax, %rdi
xorl %esi, %esi
callq 0x107b7
movl (%rax), %ecx
cmpl $0xb, %ecx
je 0x3a9e
cmpl $0x3, %ecx
jne 0x3aa5
movl $0x4, %ecx
jmp 0x3aa3
callq 0xfc74
movq %rax, %rbx
movl $0xc, %edi
callq 0xfc74
leaq 0xe6d8(%rip), %rdi      # 0x12141
leaq 0xe731(%rip), %rsi      # 0x121a1
xorl %edx, %edx
movq %rbx, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xfe6b
jmp 0x39ff
leaq 0xe6fe(%rip), %rdi      # 0x12189
leaq 0xe70f(%rip), %rsi      # 0x121a1
xorl %eax, %eax
callq 0xfe6b
jmp 0x39ff
movl $0xc, %ecx
movl %ecx, (%rax)
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5be8
// File: /workspace/github_c_makefile_star2_O3/voithos[P]awl/src/builtins.c
// Function: builtin_tail
awlval* builtin_tail(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 1, "tail");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 0, AWLVAL_QEXPR, "tail");
    AWLASSERT_NONEMPTY(a, a->cell[0], "tail");

    awlval* v = awlval_take(a, 0);
    return awlval_slice(v, 1, v->count);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x1, %ecx
jne 0x3adb
movq %rbx, %rsi
callq 0x5f58
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x3b0b
movq %rbx, %rax
jmp 0x3b03
leaq 0xe618(%rip), %rdi      # 0x120fa
leaq 0xe6be(%rip), %rsi      # 0x121a7
movl $0x1, %edx
xorl %eax, %eax
callq 0xfe6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1029f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0xc, %edi
jne 0x3b40
cmpl $0x0, 0x4(%rax)
je 0x3b71
movq %rbx, %rdi
xorl %esi, %esi
callq 0x107b7
movl 0x4(%rax), %edx
movq %rax, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10ada
callq 0xfc74
movq %rax, %r14
movl $0xc, %edi
callq 0xfc74
leaq 0xe5e8(%rip), %rdi      # 0x12141
leaq 0xe647(%rip), %rsi      # 0x121a7
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xfe6b
jmp 0x3af5
leaq 0xe611(%rip), %rdi      # 0x12189
leaq 0xe628(%rip), %rsi      # 0x121a7
xorl %eax, %eax
callq 0xfe6b
jmp 0x3af5
// File: /workspace/github_c_makefile_star2_O3/voithos[P]awl/src/builtins.c
// Function: builtin_first
awlval* builtin_first(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 1, "first");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 0, AWLVAL_QEXPR, "first");
    AWLASSERT_NONEMPTY(a, a->cell[0], "first");

    awlval* v = awlval_take(a, 0);
    return awlval_slice(v, 0, 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x1, %ecx
jne 0x3baf
movq %rbx, %rsi
callq 0x5f58
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x3bdf
movq %rbx, %rax
jmp 0x3bd7
leaq 0xe544(%rip), %rdi      # 0x120fa
leaq 0xe5ef(%rip), %rsi      # 0x121ac
movl $0x1, %edx
xorl %eax, %eax
callq 0xfe6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1029f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0xc, %edi
jne 0x3c13
cmpl $0x0, 0x4(%rax)
je 0x3c44
movq %rbx, %rdi
xorl %esi, %esi
callq 0x107b7
movq %rax, %rdi
xorl %esi, %esi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10ada
callq 0xfc74
movq %rax, %r14
movl $0xc, %edi
callq 0xfc74
leaq 0xe515(%rip), %rdi      # 0x12141
leaq 0xe579(%rip), %rsi      # 0x121ac
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xfe6b
jmp 0x3bc9
leaq 0xe53e(%rip), %rdi      # 0x12189
leaq 0xe55a(%rip), %rsi      # 0x121ac
xorl %eax, %eax
callq 0xfe6b
jmp 0x3bc9
// File: /workspace/github_c_makefile_star2_O3/voithos[P]awl/src/builtins.c
// Function: builtin_last
awlval* builtin_last(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 1, "last");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 0, AWLVAL_QEXPR, "last");
    AWLASSERT_NONEMPTY(a, a->cell[0], "last");

    awlval* v = awlval_take(a, 0);
    return awlval_slice(v, v->count - 1, v->count);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x1, %ecx
jne 0x3c82
movq %rbx, %rsi
callq 0x5f58
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x3cb2
movq %rbx, %rax
jmp 0x3caa
leaq 0xe471(%rip), %rdi      # 0x120fa
leaq 0xe529(%rip), %rsi      # 0x121b9
movl $0x1, %edx
xorl %eax, %eax
callq 0xfe6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1029f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0xc, %edi
jne 0x3ce5
cmpl $0x0, 0x4(%rax)
je 0x3d16
movq %rbx, %rdi
xorl %esi, %esi
callq 0x107b7
movl 0x4(%rax), %edx
leal -0x1(%rdx), %esi
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10ada
callq 0xfc74
movq %rax, %r14
movl $0xc, %edi
callq 0xfc74
leaq 0xe443(%rip), %rdi      # 0x12141
leaq 0xe4b4(%rip), %rsi      # 0x121b9
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xfe6b
jmp 0x3c9c
leaq 0xe46c(%rip), %rdi      # 0x12189
leaq 0xe495(%rip), %rsi      # 0x121b9
xorl %eax, %eax
callq 0xfe6b
jmp 0x3c9c
// File: /workspace/github_c_makefile_star2_O3/voithos[P]awl/src/builtins.c
// Function: builtin_exceptlast
awlval* builtin_exceptlast(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 1, "except-last");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 0, AWLVAL_QEXPR, "except-last");
    AWLASSERT_NONEMPTY(a, a->cell[0], "except-last");

    awlval* v = awlval_take(a, 0);
    return awlval_slice(v, 0, v->count - 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x1, %ecx
jne 0x3d54
movq %rbx, %rsi
callq 0x5f58
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x3d84
movq %rbx, %rax
jmp 0x3d7c
leaq 0xe39f(%rip), %rdi      # 0x120fa
leaq 0xe450(%rip), %rsi      # 0x121b2
movl $0x1, %edx
xorl %eax, %eax
callq 0xfe6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1029f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0xc, %edi
jne 0x3db8
cmpl $0x0, 0x4(%rax)
je 0x3de9
movq %rbx, %rdi
xorl %esi, %esi
callq 0x107b7
movl 0x4(%rax), %edx
decl %edx
movq %rax, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10ada
callq 0xfc74
movq %rax, %r14
movl $0xc, %edi
callq 0xfc74
leaq 0xe370(%rip), %rdi      # 0x12141
leaq 0xe3da(%rip), %rsi      # 0x121b2
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xfe6b
jmp 0x3d6e
leaq 0xe399(%rip), %rdi      # 0x12189
leaq 0xe3bb(%rip), %rsi      # 0x121b2
xorl %eax, %eax
callq 0xfe6b
jmp 0x3d6e