LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: JimAddMulHelper
static int JimAddMulHelper(Jim_Interp *interp, int argc, Jim_Obj *const *argv, int op)
{
    jim_wide wideValue, res;
    double doubleValue, doubleRes;
    int i;

    res = (op == JIM_EXPROP_ADD) ? 0 : 1;

    for (i = 1; i < argc; i++) {
        if (Jim_GetWide(interp, argv[i], &wideValue) != JIM_OK)
            goto trydouble;
        if (op == JIM_EXPROP_ADD)
            res += wideValue;
        else
            res *= wideValue;
    }
    Jim_SetResultInt(interp, res);
    return JIM_OK;
  trydouble:
    doubleRes = (double)res;
    for (; i < argc; i++) {
        if (Jim_GetDouble(interp, argv[i], &doubleValue) != JIM_OK)
            return JIM_ERR;
        if (op == JIM_EXPROP_ADD)
            doubleRes += doubleValue;
        else
            doubleRes *= doubleValue;
    }
    Jim_SetResult(interp, Jim_NewDoubleObj(interp, doubleRes));
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r14d
movq %rdx, -0x38(%rbp)
movq %rdi, %r15
xorl %r12d, %r12d
cmpl $0x18, %ecx
setne %r12b
movslq %esi, %r13
pushq $0x1
popq %rbx
cmpq %r13, %rbx
jge 0x1ef96
movq -0x38(%rbp), %rax
movq (%rax,%rbx,8), %rsi
movq %r15, %rdi
leaq -0x48(%rbp), %rdx
callq 0xc979
testl %eax, %eax
jne 0x1efc7
movq -0x48(%rbp), %rax
leaq (%rax,%r12), %rcx
imulq %r12, %rax
cmpl $0x18, %r14d
cmoveq %rcx, %rax
incq %rbx
movq %rax, %r12
jmp 0x1ef5d
movq %r15, %rdi
movq %r12, %rsi
callq 0x8212
movq %rax, %r14
incl 0x10(%rax)
movq (%r15), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x2, %eax
jge 0x1efc0
movq %r15, %rdi
callq 0x73bf
movq %r14, (%r15)
xorl %eax, %eax
jmp 0x1f03d
cvtsi2sd %r12, %xmm0
leaq -0x40(%rbp), %r12
cmpq %r13, %rbx
jge 0x1f019
movsd %xmm0, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq (%rax,%rbx,8), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0xd267
testl %eax, %eax
jne 0x1f03a
movsd -0x40(%rbp), %xmm0
cmpl $0x18, %r14d
jne 0x1f007
movsd -0x30(%rbp), %xmm1
addsd %xmm0, %xmm1
jmp 0x1f010
movsd -0x30(%rbp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
incq %rbx
jmp 0x1efd0
movq %r15, %rdi
callq 0xd366
movq %rax, %r14
incl 0x10(%rax)
movq (%r15), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jle 0x1efb8
jmp 0x1efc0
pushq $0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_ListIndices
static int Jim_ListIndices(Jim_Interp *interp, Jim_Obj *listPtr,
    Jim_Obj *const *indexv, int indexc, Jim_Obj **resultObj, int flags)
{
    int i;
    int static_idxes[5];
    int *idxes = static_idxes;
    int ret = JIM_OK;

    if (indexc > sizeof(static_idxes) / sizeof(*static_idxes)) {
        idxes = Jim_Alloc(indexc * sizeof(*idxes));
    }

    for (i = 0; i < indexc; i++) {
        ret = Jim_GetIndex(interp, indexv[i], &idxes[i]);
        if (ret != JIM_OK) {
            goto err;
        }
    }

    for (i = 0; i < indexc; i++) {
        Jim_Obj *objPtr = Jim_ListGetIndex(interp, listPtr, idxes[i]);
        if (!objPtr) {
            if (flags & JIM_ERRMSG) {
                if (idxes[i] < 0 || idxes[i] > Jim_ListLength(interp, listPtr)) {
                    Jim_SetResultFormatted(interp, "index \"%#s\" out of range", indexv[i]);
                }
                else {
                    Jim_SetResultFormatted(interp, "element %#s missing from sublist \"%#s\"", indexv[i], listPtr);
                }
            }
            return -1;
        }
        listPtr = objPtr;
    }
    *resultObj = listPtr;
err:
    if (idxes != static_idxes)
        Jim_Free(idxes);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, -0x34(%rbp)
movq %r8, -0x40(%rbp)
movl %ecx, %r12d
movq %rdx, -0x30(%rbp)
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x6, %ecx
jb 0x1f6b2
movslq %r12d, %rsi
shlq $0x2, %rsi
xorl %edi, %edi
callq *0x13bdb(%rip)          # 0x33288
movq %rax, %r13
jmp 0x1f6b6
leaq -0x60(%rbp), %r13
xorl %r14d, %r14d
testl %r12d, %r12d
cmovlel %r14d, %r12d
movq %r12, -0x48(%rbp)
leaq (,%r12,4), %r12
cmpq %r14, %r12
je 0x1f6f3
movq -0x30(%rbp), %rax
movq (%rax,%r14,2), %rsi
leaq (%r14,%r13), %rdx
movq %rbx, %rdi
callq 0x7d46
addq $0x4, %r14
testl %eax, %eax
je 0x1f6cc
pushq $0x1
popq %r15
jmp 0x1f764
xorl %r12d, %r12d
movq %r15, %r14
cmpq %r12, -0x48(%rbp)
je 0x1f75a
movl (%r13,%r12,4), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd95e
movq %rax, %r15
incq %r12
testq %rax, %rax
jne 0x1f6f6
pushq $-0x1
popq %r15
testb $0x1, -0x34(%rbp)
je 0x1f79b
movl -0x4(%r13,%r12,4), %r15d
testl %r15d, %r15d
js 0x1f73e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8b3c
cmpl %eax, %r15d
jle 0x1f77a
movq -0x30(%rbp), %rax
movq -0x8(%rax,%r12,8), %rdx
leaq 0x783e(%rip), %rsi      # 0x26f8c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x68a7
jmp 0x1f797
movq -0x40(%rbp), %rax
movq %r14, (%rax)
xorl %r15d, %r15d
leaq -0x60(%rbp), %rax
cmpq %rax, %r13
je 0x1f79b
movq %r13, %rdi
xorl %esi, %esi
callq *0x13b10(%rip)          # 0x33288
jmp 0x1f79b
movq -0x30(%rbp), %rax
movq -0x8(%rax,%r12,8), %rdx
leaq 0x8ebd(%rip), %rsi      # 0x28647
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x68a7
pushq $-0x1
popq %r15
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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 %rbx
subq $0x18, %rsp
leaq -0x18(%rbp), %rdx
andq $0x0, (%rdx)
movq %rsi, %rbx
andq $0x0, -0x10(%rbp)
movq 0x13918(%rip), %rax     # 0x332a8
movq 0xd0(%rax), %rax
movq (%rdi), %rsi
movq %rax, %rdi
callq 0xc979
testl %eax, %eax
jne 0x1f9ef
movq 0x138fb(%rip), %rax     # 0x332a8
movq 0xd0(%rax), %rdi
movq (%rbx), %rsi
leaq -0x10(%rbp), %rdx
callq 0xc979
testl %eax, %eax
jne 0x1f9ef
movq -0x18(%rbp), %rax
xorl %ecx, %ecx
xorl %edx, %edx
cmpq -0x10(%rbp), %rax
setge %dl
leal -0x1(%rdx,%rdx), %eax
cmovel %ecx, %eax
movq 0x138c7(%rip), %rcx     # 0x332a8
imull 0xdc(%rcx), %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq 0x138b2(%rip), %rdi     # 0x332a8
pushq $0x1
popq %rsi
callq 0x63c0
// File: /workspace/github_c_makefile_star2_O2/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
leaq -0x18(%rbp), %rdx
andq $0x0, (%rdx)
movq %rsi, %rbx
andq $0x0, -0x10(%rbp)
movq 0x1388a(%rip), %rax     # 0x332a8
movq 0xd0(%rax), %rax
movq (%rdi), %rsi
movq %rax, %rdi
callq 0xd267
testl %eax, %eax
jne 0x1fa7a
movq 0x1386d(%rip), %rax     # 0x332a8
movq 0xd0(%rax), %rdi
movq (%rbx), %rsi
leaq -0x10(%rbp), %rdx
callq 0xd267
testl %eax, %eax
jne 0x1fa7a
movsd -0x18(%rbp), %xmm0
xorl %eax, %eax
ucomisd -0x10(%rbp), %xmm0
jne 0x1fa62
jnp 0x1fa73
movq 0x1383f(%rip), %rax     # 0x332a8
movl 0xdc(%rax), %eax
ja 0x1fa73
negl %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq 0x13827(%rip), %rdi     # 0x332a8
pushq $0x1
popq %rsi
callq 0x63c0
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, -0x20(%rbp)
movq %rdi, %r14
movq 0x13803(%rip), %rax     # 0x332a8
movq 0xc8(%rax), %rsi
movq 0xd0(%rax), %rdi
callq 0x8a95
movq %rax, %r15
movq 0x137e6(%rip), %rax     # 0x332a8
movq 0xd0(%rax), %rdi
movq (%r14), %rdx
movq %r15, %rsi
callq 0x74ad
movq 0x137cd(%rip), %rax     # 0x332a8
movq 0xd0(%rax), %rdi
movq (%rbx), %rdx
movq %r15, %rsi
callq 0x74ad
movq 0x137b4(%rip), %rax     # 0x332a8
movq 0xd0(%rax), %rdi
movq %r15, %rsi
callq 0x8b54
movl %eax, %ebx
testl %eax, %eax
jne 0x1fb56
movq 0x13798(%rip), %rax     # 0x332a8
movq 0xd0(%rax), %rdi
movq (%rdi), %rsi
leaq -0x20(%rbp), %rdx
callq 0xc979
testl %eax, %eax
jne 0x1fb56
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
orl $0x1, %edx
xorl %eax, %eax
testq %rcx, %rcx
cmovnel %edx, %eax
movq 0x13764(%rip), %rcx     # 0x332a8
imull 0xdc(%rcx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x1374b(%rip), %rdi     # 0x332a8
movl %ebx, %esi
callq 0x63c0
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rdi, -0x30(%rbp)
movq (%rdi), %rdi
callq 0x7340
movq %rax, %r15
movq %rbx, -0x38(%rbp)
movq (%rbx), %rdi
callq 0x7340
movq %rax, %r13
callq 0x64e0
movq %rax, %r12
leaq -0x40(%rbp), %r14
movq (%r12), %rax
movzbl (%r15), %edi
testb $0x8, 0x1(%rax,%rdi,2)
je 0x1fbbd
movzbl (%r13), %ecx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x1fbde
callq 0x60e0
movl %eax, %ebx
movzbl (%r13), %edi
callq 0x60e0
cmpl %eax, %ebx
jne 0x1fc1e
incq %r15
incq %r13
testl %ebx, %ebx
jne 0x1fba2
jmp 0x1fc38
movq %r15, %rdi
leaq -0x48(%rbp), %rsi
callq 0xc7ef
movq %rax, %rbx
movq %r13, %rdi
movq %r14, %rsi
callq 0xc7ef
cmpq %rax, %rbx
jne 0x1fc5d
movq -0x48(%rbp), %rax
movq %rax, %rdx
subq %r15, %rdx
movq -0x40(%rbp), %rcx
movq %rcx, %rsi
subq %r13, %rsi
cmpq %rsi, %rdx
jne 0x1fc5d
movq %rcx, %r13
movq %rax, %r15
jmp 0x1fba2
movl %eax, %ecx
movq 0x13681(%rip), %rax     # 0x332a8
movl 0xdc(%rax), %edx
movl %edx, %eax
negl %eax
cmpl %ecx, %ebx
cmovgel %edx, %eax
jmp 0x1fc76
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq -0x38(%rbp), %rax
movq (%rax), %rdx
xorl %ecx, %ecx
callq 0xaa82
movq 0x13654(%rip), %rcx     # 0x332a8
imull 0xdc(%rcx), %eax
jmp 0x1fc76
setl %cl
movq 0x13641(%rip), %rax     # 0x332a8
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_O2/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 0x13610(%rip), %rax     # 0x332a8
movq (%rdi), %rsi
movq 0xd0(%rax), %rdi
movq 0xe0(%rax), %rdx
movl 0xe8(%rax), %ecx
leaq -0x18(%rbp), %r8
pushq $0x1
popq %r9
callq 0x1f673
testl %eax, %eax
jne 0x1fd0b
movq 0x135e1(%rip), %rax     # 0x332a8
movq (%rbx), %rsi
movq 0xd0(%rax), %rdi
movq 0xe0(%rax), %rdx
movl 0xe8(%rax), %ecx
leaq -0x10(%rbp), %r8
pushq $0x1
popq %r9
callq 0x1f673
testl %eax, %eax
jne 0x1fd0b
movq 0x135b2(%rip), %rax     # 0x332a8
leaq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq *0xf0(%rax)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq 0x13596(%rip), %rdi     # 0x332a8
pushq $0x1
popq %rsi
callq 0x63c0
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leal -0x3(%rsi), %eax
cmpl $-0x3, %eax
ja 0x1fd46
leaq 0x8bae(%rip), %rcx      # 0x288e5
pushq $0x1
popq %rbx
movq %r14, %rdi
movl %ebx, %esi
callq 0x72a5
jmp 0x1fd6d
movl %ecx, %ebx
cmpl $0x2, %esi
jne 0x1fd6d
movq 0x8(%rdx), %rsi
leaq -0x18(%rbp), %rdx
movq %r14, %rdi
callq 0xc8cb
testl %eax, %eax
je 0x1fd66
pushq $0x1
popq %rbx
jmp 0x1fd6d
movl -0x18(%rbp), %eax
movl %eax, 0x18(%r14)
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rsi, %rax
movq %rdi, -0x48(%rbp)
leaq -0x30(%rbp), %rsi
movq %rax, -0x50(%rbp)
movq %rax, %rdi
callq 0x7fc7
movq %rax, %r15
movl $0x5, -0x2c(%rbp)
testq %rbx, %rbx
je 0x20249
leaq -0x2c(%rbp), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x7fc7
movq %rax, %r12
movl (%r13), %ebx
jmp 0x20253
leaq 0x34f4(%rip), %r12      # 0x23744
pushq $0x5
popq %rbx
movl -0x30(%rbp), %eax
movq %rax, %rcx
addq %r15, %rcx
movq %rcx, -0x38(%rbp)
leaq -0x1(%r15), %r13
movq %rax, -0x40(%rbp)
movl %eax, %r14d
subl $0x1, %r14d
jb 0x2028a
movzbl 0x1(%r13), %edx
incq %r13
movq %r12, %rdi
movl %ebx, %esi
callq 0x203b0
testq %rax, %rax
jne 0x2026b
jmp 0x2028e
movq -0x38(%rbp), %r13
cmpq %r15, %r13
movq -0x50(%rbp), %rax
je 0x202ad
subl %r13d, %r15d
addl -0x40(%rbp), %r15d
movq -0x48(%rbp), %rdi
movq %r13, %rsi
movl %r15d, %edx
callq 0x7363
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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
movl $0x5, -0x2c(%rbp)
testq %rdx, %rdx
je 0x202f0
leaq -0x2c(%rbp), %rsi
movq %rdx, %rdi
callq 0x7fc7
movq %rax, %r12
jmp 0x202f7
leaq 0x344d(%rip), %r12      # 0x23744
movq %r14, -0x50(%rbp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa697
movq %rbx, %rdi
callq 0xa61a
movq %rbx, -0x48(%rbp)
movq (%rbx), %rdx
movl -0x2c(%rbp), %r14d
movslq %eax, %r15
movq %rdx, -0x38(%rbp)
addq %rdx, %r15
pushq $-0x1
popq %r13
movq %rax, -0x40(%rbp)
movl %eax, %ebx
subl $0x1, %ebx
jb 0x2036f
movzbl (%r15,%r13), %edx
movq %r12, %rdi
movl %r14d, %esi
callq 0x203b0
decq %r13
testq %rax, %rax
jne 0x2032d
cmpq $-0x2, %r13
je 0x20383
movq -0x48(%rbp), %rax
cmpl $0x2, 0x10(%rax)
jl 0x20389
movq -0x40(%rbp), %rax
leal (%rax,%r13), %edx
addl $0x2, %edx
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rsi
jmp 0x2037c
leaq 0x92cb(%rip), %rsi      # 0x29641
movq -0x50(%rbp), %rdi
xorl %edx, %edx
callq 0x7363
jmp 0x203a1
movq -0x48(%rbp), %rax
jmp 0x203a1
movb $0x0, 0x2(%r15,%r13)
movq -0x40(%rbp), %rcx
addl -0x38(%rbp), %ecx
subl (%rax), %ecx
addl %r13d, %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_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
xorl %r12d, %r12d
movzbl (%r15,%r12), %edi
testl %edi, %edi
je 0x203fa
testl %ebx, %ebx
je 0x203ec
callq 0x60e0
jmp 0x203f1
callq 0x6350
movb %al, (%r14,%r12)
incq %r12
jmp 0x203d8
movb $0x0, (%r14,%r12)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
movl %r8d, %r14d
movq %rcx, -0x30(%rbp)
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r13
xorl %esi, %esi
xorl %edx, %edx
callq 0x745b
movq %rax, %r12
testq %r15, %r15
je 0x20c0d
movq %r15, %rdi
callq 0x7340
leaq 0x8567(%rip), %rsi      # 0x29167
movq %rax, %rdi
callq 0x63a0
testq %rax, %rax
je 0x20c47
movq %rbx, %rax
leaq -0x50(%rbp), %rbx
movq %rax, (%rbx)
orl $-0x1, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq %rbx, %rdi
callq 0xa496
testq %rax, %rax
je 0x20c6d
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %r8
movl %r14d, %r9d
callq *-0x30(%rbp)
jmp 0x20c22
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa3fb
testq %rax, %rax
je 0x20c6d
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %r8
movl %r14d, %r9d
callq *-0x30(%rbp)
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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 0x20cae
cmpq $0x0, 0x8(%r14)
jne 0x20cd9
testq %r8, %r8
je 0x20cc4
movq %r8, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0xa85d
testl %eax, %eax
je 0x20cd9
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x74ad
btl $0xc, %r12d
jb 0x20ce8
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 0x74ad
// File: /workspace/github_c_makefile_star2_O2/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 0x20d2e
cmpl $0x0, 0x4(%rcx)
je 0x20dba
incl 0x10(%rbx)
cmpl $0x2, %r9d
jne 0x20d46
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6703
testl %eax, %eax
js 0x20d93
testq %r12, %r12
je 0x20d85
leaq -0x2c(%rbp), %rsi
movq %r12, %rdi
callq 0x1681c
movq %rax, %r12
leaq -0x30(%rbp), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1681c
leaq -0x2c(%rbp), %rcx
movl (%rcx), %esi
movl (%r13), %ecx
movq %r12, %rdi
movq %rax, %rdx
xorl %r8d, %r8d
callq 0xa8b5
testl %eax, %eax
je 0x20d93
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x74ad
movl 0x10(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
cmpl $0x1, %eax
jg 0x20dba
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x73bf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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 *0x1247b(%rip)          # 0x33288
movq %rax, %r12
movq 0x18(%r14), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x6320
movq %r12, 0x18(%rbx)
leaq 0x11e9e(%rip), %rax     # 0x32cc8
movq %rax, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
pushq $0x2
popq %rsi
callq 0x21917
movq 0x20(%r14), %rax
movslq 0x30(%r14), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x30(%r14)
movl %ebx, (%rax,%rcx,4)
movslq 0x30(%r14), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x30(%r14)
andl $0x0, (%rax,%rcx,4)
movl 0x30(%r14), %eax
addl $-0x2, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %eax
movq %rdi, %r15
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x117c2
testl %eax, %eax
jne 0x218e1
movq 0x20(%r15), %rax
movslq %r14d, %rcx
movl %r14d, %edx
subl %ebx, %edx
subl %r14d, %ebx
cmpl $0x7, (%rax,%rcx,4)
cmovel %edx, %ebx
movl %ebx, 0x4(%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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:
movzbl (%rdi), %edi
movl %edi, (%rsi)
testl %edx, %edx
je 0x2196c
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x60e0
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: 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 0x21990
movq %r14, %rdi
movl %edx, %esi
movl %ebx, %edx
callq 0x2196d
incl %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x11601
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11601
// File: /workspace/github_c_makefile_star2_O2/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)
leal -0x65(%rax), %ecx
cmpl $0x13, %ecx
ja 0x219f2
leaq 0x1c3b(%rip), %rax      # 0x23618
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x1b, (%r15)
jmp 0x21ab4
testl %eax, %eax
je 0x21a84
cmpl $0x55, %eax
je 0x21a90
cmpl $0x62, %eax
jne 0x21ab4
movl $0x8, (%r15)
jmp 0x21ab4
movl $0x9, (%r15)
jmp 0x21ab4
movl $0xc, (%r15)
jmp 0x21ab4
pushq $0x2
jmp 0x21a96
cmpb $0x7b, (%r14)
jne 0x21a94
leaq 0x2(%rbx), %rdi
pushq $0x6
popq %rsi
movq %r15, %rdx
callq 0x21aed
testl %eax, %eax
jle 0x21aad
movl %eax, %eax
cmpb $0x7d, 0x1(%r14,%rax)
jne 0x21aad
cmpl $0x1fffff, (%r15)       # imm = 0x1FFFFF
ja 0x21aad
addq %rax, %r14
addq $0x2, %r14
jmp 0x21ab4
movl $0xa, (%r15)
jmp 0x21ab4
movl $0xd, (%r15)
jmp 0x21ab4
movl $0xb, (%r15)
jmp 0x21ab4
movl $0x5c, (%r15)
movq %rbx, %r14
jmp 0x21ab4
pushq $0x8
jmp 0x21a96
pushq $0x4
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x21aed
testl %eax, %eax
jle 0x21ab4
movl %eax, %eax
addq %rax, %r14
jmp 0x21ab4
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_O2/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
movl %esi, %eax
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
xorl %ecx, %ecx
cmpl %esi, %eax
je 0x21b3d
movsbl (%rdi,%rsi), %r8d
leal -0x30(%r8), %r9d
cmpl $0xa, %r9d
jb 0x21b30
leal -0x61(%r8), %r9d
cmpl $0x5, %r9d
ja 0x21b1f
addl $-0x57, %r8d
jmp 0x21b2d
leal -0x47(%r8), %r9d
cmpl $-0x6, %r9d
jb 0x21b3b
addl $-0x37, %r8d
movl %r8d, %r9d
shll $0x4, %ecx
orl %r9d, %ecx
incq %rsi
jmp 0x21afc
movl %esi, %eax
testl %eax, %eax
je 0x21b43
movl %ecx, (%rdx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/msteveb[P]autosetup/./jimsh0.c
// Function: reg_range_find
static int reg_range_find(const int *range, int c)
{
	while (*range) {

		if (c >= range[1] && c <= (range[0] + range[1] - 1)) {
			return 1;
		}
		range += 2;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %eax
movl (%rdi), %ecx
testl %ecx, %ecx
je 0x2231d
movl 0x4(%rdi), %edx
cmpl %esi, %edx
setle %r8b
addl %edx, %ecx
cmpl %esi, %ecx
setg %cl
andb %r8b, %cl
addq $0x8, %rdi
cmpb $0x1, %cl
jne 0x222f9
jmp 0x2231f
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movslq %esi, %r12
pushq $0x1
popq %r13
cmpq %r12, %r13
jge 0x254b
callq 0xde71
movq %rax, %r15
movq (%rbx,%r13,8), %rdi
callq 0xdcf6
movq %r15, %rdi
movq %rax, %rsi
callq 0xdf95
movq %r14, %rdi
movq %rax, %rsi
callq 0x4991
movq %rax, %r15
cmpl $0x2, (%rax)
jne 0x253e
movq %r15, %rdi
callq 0xd469
movq %r15, %rdi
callq 0xded1
incq %r13
jmp 0x2502
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2c34
movq %rbx, %rsi
callq 0x55f9
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x2c4d
movq %rbx, %r15
movq %r15, %rax
jmp 0x2cf6
leaq 0xd4bf(%rip), %rdi      # 0x100fa
pushq $0x2
popq %rdx
movq %r14, %rsi
xorl %eax, %eax
callq 0xdb45
jmp 0x2ce8
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movl (%rcx), %edi
cmpl $0x2, %edi
jae 0x2cb9
movq 0x8(%rax), %rax
movl (%rax), %edi
cmpl $0x2, %edi
jae 0x2ccc
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe2bf
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe2bf
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0xe587
leaq 0xe296(%rip), %rsi      # 0x10f28
movq %r14, %rdi
callq 0xf0d6
testb %al, %al
je 0x2d10
movl (%r15), %eax
cmpl $0x1, %eax
je 0x2cff
testl %eax, %eax
jne 0x2d10
movq 0x18(%r15), %rax
cmpq 0x18(%r12), %rax
setg %bpl
jmp 0x2d10
callq 0xd97c
leaq 0xd37b(%rip), %rdi      # 0x10040
movq %r14, %rsi
xorl %edx, %edx
jmp 0x2cde
callq 0xd97c
leaq 0xd368(%rip), %rdi      # 0x10040
pushq $0x1
popq %rdx
movq %r14, %rsi
movq %rax, %rcx
xorl %eax, %eax
callq 0xdb45
movq %rax, %r14
movq %rbx, %rdi
callq 0xded1
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 0xd418(%rip), %rsi      # 0x1012f
movq %r14, %rdi
callq 0xf0d6
testb %al, %al
je 0x2d4f
movl (%r15), %eax
cmpl $0x1, %eax
je 0x2d3e
testl %eax, %eax
jne 0x2d4f
movq 0x18(%r15), %rax
cmpq 0x18(%r12), %rax
setl %bpl
jmp 0x2d4f
movsd 0x18(%r12), %xmm0
ucomisd 0x18(%r15), %xmm0
seta %bpl
leaq 0xd3db(%rip), %rsi      # 0x10131
movq %r14, %rdi
callq 0xf0d6
testb %al, %al
je 0x2d8e
movl (%r15), %eax
cmpl $0x1, %eax
je 0x2d7d
testl %eax, %eax
jne 0x2d8e
movq 0x18(%r15), %rax
cmpq 0x18(%r12), %rax
setge %bpl
jmp 0x2d8e
movsd 0x18(%r15), %xmm0
ucomisd 0x18(%r12), %xmm0
setae %bpl
leaq 0xd39f(%rip), %rsi      # 0x10134
movq %r14, %rdi
callq 0xf0d6
testb %al, %al
je 0x2dcd
movl (%r15), %eax
cmpl $0x1, %eax
je 0x2dbc
testl %eax, %eax
jne 0x2dcd
movq 0x18(%r15), %rax
cmpq 0x18(%r12), %rax
setle %bpl
jmp 0x2dcd
movsd 0x18(%r12), %xmm0
ucomisd 0x18(%r15), %xmm0
setae %bpl
movq %r12, %rdi
callq 0xded1
movq %rbx, %rdi
callq 0xded1
movl $0x6, (%r15)
andb $0x1, %bpl
movb %bpl, 0x18(%r15)
jmp 0x2c2c
// File: /workspace/github_c_makefile_star2_O2/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 0x2e48
movq %r14, %rsi
callq 0x55f9
movq %rax, %r14
cmpl $0x2, (%rax)
jne 0x2e6f
movq %r14, %rax
jmp 0x2e6a
leaq 0xd2ab(%rip), %rdi      # 0x100fa
pushq $0x2
popq %rdx
movq %rbx, %rsi
xorl %eax, %eax
callq 0xdb45
movq %rax, %rbx
movq %r14, %rdi
callq 0xded1
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8(%r14), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0xe867
movl %eax, %ebp
leaq 0xd2af(%rip), %rsi      # 0x10137
movq %rbx, %rdi
callq 0xf0d6
leaq 0xd2a3(%rip), %rsi      # 0x1013a
movq %rbx, %rdi
callq 0xf0d6
movl %eax, %ebx
xorb %bpl, %bl
movq %r14, %rdi
callq 0xded1
movzbl %bl, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0xdd3e
// File: /workspace/github_c_makefile_star2_O2/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 0x3141
movq %rdi, %r14
movq %rbx, %rsi
callq 0x55f9
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x316f
movq %rbx, %rax
jmp 0x3167
leaq 0xcfb2(%rip), %rdi      # 0x100fa
leaq 0xd053(%rip), %rsi      # 0x101a2
pushq $0x1
popq %rdx
xorl %eax, %eax
callq 0xdb45
movq %rax, %r14
movq %rbx, %rdi
callq 0xded1
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 0x31a9
cmpl $0x0, 0x4(%rax)
je 0x31d8
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe31b
movq %rax, %rdi
xorl %esi, %esi
callq 0xe31b
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x52a8
callq 0xd97c
movq %rax, %r14
pushq $0xc
popq %rdi
callq 0xd97c
leaq 0xcf81(%rip), %rdi      # 0x10141
leaq 0xcfdb(%rip), %rsi      # 0x101a2
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xdb45
jmp 0x3159
leaq 0xcfaa(%rip), %rdi      # 0x10189
leaq 0xcfbc(%rip), %rsi      # 0x101a2
xorl %eax, %eax
callq 0xdb45
jmp 0x3159
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x1, %ecx
jne 0x3219
movq %rdi, %r14
movq %rbx, %rsi
callq 0x55f9
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x3247
movq %rbx, %rax
jmp 0x323f
leaq 0xceda(%rip), %rdi      # 0x100fa
leaq 0xcf7a(%rip), %rsi      # 0x101a1
pushq $0x1
popq %rdx
xorl %eax, %eax
callq 0xdb45
movq %rax, %r14
movq %rbx, %rdi
callq 0xded1
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 0x327f
cmpl $0x0, 0x4(%rax)
je 0x32ae
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe31b
movq %rax, %rdi
xorl %esi, %esi
callq 0xe31b
movl (%rax), %ecx
cmpl $0xb, %ecx
je 0x32c8
cmpl $0x3, %ecx
jne 0x32cd
pushq $0x4
jmp 0x32ca
callq 0xd97c
movq %rax, %r14
pushq $0xc
popq %rdi
callq 0xd97c
leaq 0xceab(%rip), %rdi      # 0x10141
leaq 0xcf04(%rip), %rsi      # 0x101a1
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xdb45
jmp 0x3231
leaq 0xced4(%rip), %rdi      # 0x10189
leaq 0xcee5(%rip), %rsi      # 0x101a1
xorl %eax, %eax
callq 0xdb45
jmp 0x3231
pushq $0xc
popq %rcx
movl %ecx, (%rax)
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x52a8
// File: /workspace/github_c_makefile_star2_O2/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 0x3303
movq %rbx, %rsi
callq 0x55f9
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x3331
movq %rbx, %rax
jmp 0x3329
leaq 0xcdf0(%rip), %rdi      # 0x100fa
leaq 0xce96(%rip), %rsi      # 0x101a7
pushq $0x1
popq %rdx
xorl %eax, %eax
callq 0xdb45
movq %rax, %r14
movq %rbx, %rdi
callq 0xded1
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 0x3364
cmpl $0x0, 0x4(%rax)
je 0x3393
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe31b
movl 0x4(%rax), %edx
pushq $0x1
popq %rsi
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe57f
callq 0xd97c
movq %rax, %r14
pushq $0xc
popq %rdi
callq 0xd97c
leaq 0xcdc6(%rip), %rdi      # 0x10141
leaq 0xce25(%rip), %rsi      # 0x101a7
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xdb45
jmp 0x331b
leaq 0xcdef(%rip), %rdi      # 0x10189
leaq 0xce06(%rip), %rsi      # 0x101a7
xorl %eax, %eax
callq 0xdb45
jmp 0x331b
// File: /workspace/github_c_makefile_star2_O2/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 0x33d1
movq %rbx, %rsi
callq 0x55f9
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x33ff
movq %rbx, %rax
jmp 0x33f7
leaq 0xcd22(%rip), %rdi      # 0x100fa
leaq 0xcdcd(%rip), %rsi      # 0x101ac
pushq $0x1
popq %rdx
xorl %eax, %eax
callq 0xdb45
movq %rax, %r14
movq %rbx, %rdi
callq 0xded1
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 0x3431
cmpl $0x0, 0x4(%rax)
je 0x3460
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe31b
pushq $0x1
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe57f
callq 0xd97c
movq %rax, %r14
pushq $0xc
popq %rdi
callq 0xd97c
leaq 0xccf9(%rip), %rdi      # 0x10141
leaq 0xcd5d(%rip), %rsi      # 0x101ac
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xdb45
jmp 0x33e9
leaq 0xcd22(%rip), %rdi      # 0x10189
leaq 0xcd3e(%rip), %rsi      # 0x101ac
xorl %eax, %eax
callq 0xdb45
jmp 0x33e9
// File: /workspace/github_c_makefile_star2_O2/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 0x349e
movq %rbx, %rsi
callq 0x55f9
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x34cc
movq %rbx, %rax
jmp 0x34c4
leaq 0xcc55(%rip), %rdi      # 0x100fa
leaq 0xcd0d(%rip), %rsi      # 0x101b9
pushq $0x1
popq %rdx
xorl %eax, %eax
callq 0xdb45
movq %rax, %r14
movq %rbx, %rdi
callq 0xded1
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 0x34ff
cmpl $0x0, 0x4(%rax)
je 0x352e
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe31b
movl 0x4(%rax), %edx
leal -0x1(%rdx), %esi
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe57f
callq 0xd97c
movq %rax, %r14
pushq $0xc
popq %rdi
callq 0xd97c
leaq 0xcc2b(%rip), %rdi      # 0x10141
leaq 0xcc9c(%rip), %rsi      # 0x101b9
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xdb45
jmp 0x34b6
leaq 0xcc54(%rip), %rdi      # 0x10189
leaq 0xcc7d(%rip), %rsi      # 0x101b9
xorl %eax, %eax
callq 0xdb45
jmp 0x34b6
// File: /workspace/github_c_makefile_star2_O2/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 0x356c
movq %rbx, %rsi
callq 0x55f9
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x359a
movq %rbx, %rax
jmp 0x3592
leaq 0xcb87(%rip), %rdi      # 0x100fa
leaq 0xcc38(%rip), %rsi      # 0x101b2
pushq $0x1
popq %rdx
xorl %eax, %eax
callq 0xdb45
movq %rax, %r14
movq %rbx, %rdi
callq 0xded1
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 0x35ce
cmpl $0x0, 0x4(%rax)
je 0x35fd
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe31b
movl 0x4(%rax), %edx
decl %edx
movq %rax, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe57f
callq 0xd97c
movq %rax, %r14
pushq $0xc
popq %rdi
callq 0xd97c
leaq 0xcb5c(%rip), %rdi      # 0x10141
leaq 0xcbc6(%rip), %rsi      # 0x101b2
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xdb45
jmp 0x3584
leaq 0xcb85(%rip), %rdi      # 0x10189
leaq 0xcba7(%rip), %rsi      # 0x101b2
xorl %eax, %eax
callq 0xdb45
jmp 0x3584
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/builtins.c
// Function: builtin_eval
awlval* builtin_eval(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 1, "eval");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 0, AWLVAL_QEXPR, "eval");

    awlval* x = awlval_take(a, 0);
    x->type = AWLVAL_SEXPR;
    return awlval_eval(e, x);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x1, %ecx
jne 0x3651
movq %rdi, %r14
movq %rbx, %rsi
callq 0x55f9
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x367f
movq %rbx, %rax
jmp 0x3677
leaq 0xcaa2(%rip), %rdi      # 0x100fa
leaq 0xcb5f(%rip), %rsi      # 0x101be
pushq $0x1
popq %rdx
xorl %eax, %eax
callq 0xdb45
movq %rax, %r14
movq %rbx, %rdi
callq 0xded1
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 0x36af
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe31b
movl $0xb, (%rax)
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x52a8
callq 0xd97c
movq %rax, %r14
pushq $0xc
popq %rdi
callq 0xd97c
leaq 0xca7b(%rip), %rdi      # 0x10141
leaq 0xcaf1(%rip), %rsi      # 0x101be
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xdb45
jmp 0x3669