LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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, -0x2c(%rbp)
movq %rcx, -0x48(%rbp)
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, -0x40(%rbp)
callq 0xae58
leaq 0x11042(%rip), %rcx     # 0x36358
movq %rcx, 0x8(%rax)
movq $0x0, (%rax)
xorps %xmm0, %xmm0
movq %rax, -0x38(%rbp)
movups %xmm0, 0x18(%rax)
testq %r12, %r12
je 0x25358
cmpq $0x0, (%r12)
jne 0x25343
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
movq (%r12), %rdi
leaq 0x8e2b(%rip), %rsi      # 0x2e179
callq 0x63a0
testq %rax, %rax
je 0x253b4
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
xorl %r13d, %r13d
xorl %r15d, %r15d
movq %r13, %rax
testq %r15, %r15
jne 0x2537f
incl %r14d
cmpl 0x18(%rbx), %r14d
jge 0x2538d
movq (%rbx), %rax
movslq %r14d, %rcx
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0x253af
movq 0x10(%rax), %r13
movq %rax, %r15
jmp 0x2538f
xorl %eax, %eax
testq %rax, %rax
je 0x253e0
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %r12, %r8
movl -0x2c(%rbp), %r9d
callq *-0x48(%rbp)
jmp 0x25364
movq %rax, %r15
jmp 0x2536c
movq %rbx, %rdi
movq %r12, %rbx
movq %r12, %rsi
callq 0xac8e
testq %rax, %rax
je 0x253e0
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rbx, %r8
movl -0x2c(%rbp), %r9d
callq *-0x48(%rbp)
movq -0x38(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: 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 0x25422
cmpq $0x0, 0x8(%r14)
jne 0x2544d
testq %r8, %r8
je 0x25438
movq %r8, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0xb120
testl %eax, %eax
je 0x2544d
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x7695
btl $0xc, %r12d
jb 0x2545c
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 0x7695
// File: /workspace/github_c_makefile_star2_O1/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 0x254a2
cmpl $0x0, 0x4(%rcx)
je 0x2552e
incl 0x10(%rbx)
cmpl $0x2, %r9d
jne 0x254ba
movq %r14, %rdi
movq %rbx, %rsi
callq 0x677b
testl %eax, %eax
js 0x25507
testq %r12, %r12
je 0x254f9
leaq -0x2c(%rbp), %rsi
movq %r12, %rdi
callq 0x18e16
movq %rax, %r12
leaq -0x30(%rbp), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x18e16
leaq -0x2c(%rbp), %rcx
movl (%rcx), %esi
movl (%r13), %ecx
movq %r12, %rdi
movq %rax, %rdx
xorl %r8d, %r8d
callq 0xb177
testl %eax, %eax
je 0x25507
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x7695
movl 0x10(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
cmpl $0x1, %eax
jg 0x2552e
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x759a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: 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 *0x12d04(%rip)          # 0x38288
movq %rax, %r12
movq 0x18(%r14), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x6320
movq %r12, 0x18(%rbx)
leaq 0x12727(%rip), %rax     # 0x37cc8
movq %rax, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x26647
movq %r14, %rdi
movl %edx, %esi
movl %ebx, %edx
callq 0x26624
incl %r15d
movq %r14, %rdi
movl $0x1, %esi
callq 0x265ee
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 0x265ee
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_O1/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 0x266dd
addl $-0x65, %eax
cmpl $0x13, %eax
ja 0x267b5
leaq 0x1fec(%rip), %rcx      # 0x286b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1b, (%r15)
jmp 0x267b5
testl %eax, %eax
je 0x2677d
cmpl $0x55, %eax
je 0x26789
cmpl $0x62, %eax
jne 0x267b5
movl $0x8, (%r15)
jmp 0x267b5
movl $0x9, (%r15)
jmp 0x267b5
movl $0xb, (%r15)
jmp 0x267b5
movl $0xa, (%r15)
jmp 0x267b5
movl $0xc, (%r15)
jmp 0x267b5
movl $0xd, (%r15)
jmp 0x267b5
movq %r14, %rdi
movl $0x2, %esi
jmp 0x2679b
cmpb $0x7b, (%r14)
jne 0x26793
leaq 0x2(%rbx), %rdi
movl $0x6, %esi
movq %r15, %rdx
callq 0x267c6
testl %eax, %eax
jle 0x267ae
movl %eax, %eax
cmpb $0x7d, 0x1(%r14,%rax)
jne 0x267ae
cmpl $0x1fffff, (%r15)       # imm = 0x1FFFFF
ja 0x267ae
addq %rax, %r14
addq $0x2, %r14
jmp 0x267b5
movl $0x5c, (%r15)
movq %rbx, %r14
jmp 0x267b5
movq %r14, %rdi
movl $0x8, %esi
jmp 0x2679b
movq %r14, %rdi
movl $0x4, %esi
movq %r15, %rdx
callq 0x267c6
testl %eax, %eax
jle 0x267b5
movl %eax, %eax
addq %rax, %r14
jmp 0x267b5
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_O1/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 0x26829
movl %esi, %eax
xorl %esi, %esi
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
movsbl (%rdi,%rsi), %r9d
leal -0x30(%r9), %r10d
cmpl $0xa, %r10d
jb 0x2680c
leal -0x61(%r9), %r10d
cmpl $0x5, %r10d
ja 0x267f9
addl $-0x57, %r9d
jmp 0x26809
leal -0x41(%r9), %r10d
addl $-0x37, %r9d
cmpl $0x6, %r10d
cmovael %r8d, %r9d
movl %r9d, %r10d
movl %ecx, %r9d
shll $0x4, %r9d
orl %r10d, %r9d
cmpl $-0x1, %r10d
cmovnel %r9d, %ecx
je 0x2682f
incq %rsi
cmpl %esi, %eax
jne 0x267da
jmp 0x26831
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x26831
movl %esi, %eax
testl %eax, %eax
je 0x26837
movl %ecx, (%rdx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x106d7
movq %rax, %r15
movq (%rbx,%r13,8), %rdi
callq 0x104fa
movq %r15, %rdi
movq %rax, %rsi
callq 0x10835
movq %r14, %rdi
movq %rax, %rsi
callq 0x5495
movq %rax, %r15
cmpl $0x2, (%rax)
jne 0x2ca0
movq %r15, %rdi
callq 0xfbdf
movq %r15, %rdi
callq 0x10767
incq %r13
cmpq %r13, %r12
jne 0x2c69
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x342b
movq %rbx, %rsi
callq 0x6214
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x3446
movq %rbx, %r15
movq %r15, %rax
jmp 0x34f1
leaq 0xecc8(%rip), %rdi      # 0x120fa
movq %r14, %rsi
movl $0x2, %edx
xorl %eax, %eax
callq 0x1032f
jmp 0x34e3
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movl (%rcx), %edi
cmpl $0x2, %edi
jae 0x34b2
movq 0x8(%rax), %rax
movl (%rax), %edi
cmpl $0x2, %edi
jae 0x34c5
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c23
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c23
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x10fb2
leaq 0xfa4d(%rip), %rsi      # 0x12ed8
movq %r14, %rdi
callq 0x11b89
testb %al, %al
je 0x350b
movl (%r15), %eax
cmpl $0x1, %eax
je 0x34fa
testl %eax, %eax
jne 0x350b
movq 0x18(%r15), %rax
cmpq 0x18(%r12), %rax
setg %bpl
jmp 0x350b
callq 0x10138
leaq 0xeb82(%rip), %rdi      # 0x12040
movq %r14, %rsi
xorl %edx, %edx
jmp 0x34d9
callq 0x10138
leaq 0xeb6f(%rip), %rdi      # 0x12040
movq %r14, %rsi
movl $0x1, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1032f
movq %rax, %r14
movq %rbx, %rdi
callq 0x10767
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 0xec1d(%rip), %rsi      # 0x1212f
movq %r14, %rdi
callq 0x11b89
testb %al, %al
je 0x354a
movl (%r15), %eax
cmpl $0x1, %eax
je 0x3539
testl %eax, %eax
jne 0x354a
movq 0x18(%r15), %rax
cmpq 0x18(%r12), %rax
setl %bpl
jmp 0x354a
movsd 0x18(%r12), %xmm0
ucomisd 0x18(%r15), %xmm0
seta %bpl
leaq 0xebe0(%rip), %rsi      # 0x12131
movq %r14, %rdi
callq 0x11b89
testb %al, %al
je 0x3589
movl (%r15), %eax
cmpl $0x1, %eax
je 0x3578
testl %eax, %eax
jne 0x3589
movq 0x18(%r15), %rax
cmpq 0x18(%r12), %rax
setge %bpl
jmp 0x3589
movsd 0x18(%r15), %xmm0
ucomisd 0x18(%r12), %xmm0
setae %bpl
leaq 0xeba4(%rip), %rsi      # 0x12134
movq %r14, %rdi
callq 0x11b89
testb %al, %al
je 0x35c8
movl (%r15), %eax
cmpl $0x1, %eax
je 0x35b7
testl %eax, %eax
jne 0x35c8
movq 0x18(%r15), %rax
cmpq 0x18(%r12), %rax
setle %bpl
jmp 0x35c8
movsd 0x18(%r12), %xmm0
ucomisd 0x18(%r15), %xmm0
setae %bpl
movq %r12, %rdi
callq 0x10767
movq %rbx, %rdi
callq 0x10767
movl $0x6, (%r15)
andb $0x1, %bpl
movb %bpl, 0x18(%r15)
jmp 0x3423
// File: /workspace/github_c_makefile_star2_O1/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 0x3643
movq %r14, %rsi
callq 0x6214
movq %rax, %r14
cmpl $0x2, (%rax)
jne 0x366c
movq %r14, %rax
jmp 0x3667
leaq 0xeab0(%rip), %rdi      # 0x120fa
movq %rbx, %rsi
movl $0x2, %edx
xorl %eax, %eax
callq 0x1032f
movq %rax, %rbx
movq %r14, %rdi
callq 0x10767
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8(%r14), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x11298
movl %eax, %ebp
leaq 0xeab2(%rip), %rsi      # 0x12137
movq %rbx, %rdi
callq 0x11b89
leaq 0xeaa6(%rip), %rsi      # 0x1213a
movq %rbx, %rdi
callq 0x11b89
movl %eax, %ebx
xorb %bpl, %bl
movq %r14, %rdi
callq 0x10767
movzbl %bl, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x10558
// File: /workspace/github_c_makefile_star2_O1/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 0x3956
movq %rdi, %r14
movq %rbx, %rsi
callq 0x6214
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x3986
movq %rbx, %rax
jmp 0x397e
leaq 0xe79d(%rip), %rdi      # 0x120fa
leaq 0xe83e(%rip), %rsi      # 0x121a2
movl $0x1, %edx
xorl %eax, %eax
callq 0x1032f
movq %rax, %r14
movq %rbx, %rdi
callq 0x10767
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 0x39c0
cmpl $0x0, 0x4(%rax)
je 0x39f4
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c7f
movq %rax, %rdi
xorl %esi, %esi
callq 0x10c7f
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5e90
callq 0x10138
movq %rax, %r14
movl $0xc, %edi
callq 0x10138
leaq 0xe768(%rip), %rdi      # 0x12141
leaq 0xe7c2(%rip), %rsi      # 0x121a2
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x1032f
jmp 0x3970
leaq 0xe78e(%rip), %rdi      # 0x12189
leaq 0xe7a0(%rip), %rsi      # 0x121a2
xorl %eax, %eax
callq 0x1032f
jmp 0x3970
// File: /workspace/github_c_makefile_star2_O1/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 0x3a35
movq %rdi, %rbx
movq %r14, %rsi
callq 0x6214
movq %rax, %r14
cmpl $0x2, (%rax)
jne 0x3a65
movq %r14, %rax
jmp 0x3a5d
leaq 0xe6be(%rip), %rdi      # 0x120fa
leaq 0xe75e(%rip), %rsi      # 0x121a1
movl $0x1, %edx
xorl %eax, %eax
callq 0x1032f
movq %rax, %rbx
movq %r14, %rdi
callq 0x10767
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 0x3aa0
cmpl $0x0, 0x4(%rax)
je 0x3ad4
movq %r14, %rdi
xorl %esi, %esi
callq 0x10c7f
movq %rax, %rdi
xorl %esi, %esi
callq 0x10c7f
movl (%rax), %ecx
cmpl $0xb, %ecx
je 0x3aee
cmpl $0x3, %ecx
jne 0x3af5
movl $0x4, %ecx
jmp 0x3af3
callq 0x10138
movq %rax, %rbx
movl $0xc, %edi
callq 0x10138
leaq 0xe688(%rip), %rdi      # 0x12141
leaq 0xe6e1(%rip), %rsi      # 0x121a1
xorl %edx, %edx
movq %rbx, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x1032f
jmp 0x3a4f
leaq 0xe6ae(%rip), %rdi      # 0x12189
leaq 0xe6bf(%rip), %rsi      # 0x121a1
xorl %eax, %eax
callq 0x1032f
jmp 0x3a4f
movl $0xc, %ecx
movl %ecx, (%rax)
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5e90
// File: /workspace/github_c_makefile_star2_O1/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 0x3b2b
movq %rbx, %rsi
callq 0x6214
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x3b5b
movq %rbx, %rax
jmp 0x3b53
leaq 0xe5c8(%rip), %rdi      # 0x120fa
leaq 0xe66e(%rip), %rsi      # 0x121a7
movl $0x1, %edx
xorl %eax, %eax
callq 0x1032f
movq %rax, %r14
movq %rbx, %rdi
callq 0x10767
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 0x3b90
cmpl $0x0, 0x4(%rax)
je 0x3bc1
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c7f
movl 0x4(%rax), %edx
movq %rax, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10fa8
callq 0x10138
movq %rax, %r14
movl $0xc, %edi
callq 0x10138
leaq 0xe598(%rip), %rdi      # 0x12141
leaq 0xe5f7(%rip), %rsi      # 0x121a7
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x1032f
jmp 0x3b45
leaq 0xe5c1(%rip), %rdi      # 0x12189
leaq 0xe5d8(%rip), %rsi      # 0x121a7
xorl %eax, %eax
callq 0x1032f
jmp 0x3b45
// File: /workspace/github_c_makefile_star2_O1/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 0x3bff
movq %rbx, %rsi
callq 0x6214
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x3c2f
movq %rbx, %rax
jmp 0x3c27
leaq 0xe4f4(%rip), %rdi      # 0x120fa
leaq 0xe59f(%rip), %rsi      # 0x121ac
movl $0x1, %edx
xorl %eax, %eax
callq 0x1032f
movq %rax, %r14
movq %rbx, %rdi
callq 0x10767
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 0x3c63
cmpl $0x0, 0x4(%rax)
je 0x3c94
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c7f
movq %rax, %rdi
xorl %esi, %esi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10fa8
callq 0x10138
movq %rax, %r14
movl $0xc, %edi
callq 0x10138
leaq 0xe4c5(%rip), %rdi      # 0x12141
leaq 0xe529(%rip), %rsi      # 0x121ac
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x1032f
jmp 0x3c19
leaq 0xe4ee(%rip), %rdi      # 0x12189
leaq 0xe50a(%rip), %rsi      # 0x121ac
xorl %eax, %eax
callq 0x1032f
jmp 0x3c19
// File: /workspace/github_c_makefile_star2_O1/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 0x3cd2
movq %rbx, %rsi
callq 0x6214
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x3d02
movq %rbx, %rax
jmp 0x3cfa
leaq 0xe421(%rip), %rdi      # 0x120fa
leaq 0xe4d9(%rip), %rsi      # 0x121b9
movl $0x1, %edx
xorl %eax, %eax
callq 0x1032f
movq %rax, %r14
movq %rbx, %rdi
callq 0x10767
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 0x3d35
cmpl $0x0, 0x4(%rax)
je 0x3d66
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c7f
movl 0x4(%rax), %edx
leal -0x1(%rdx), %esi
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10fa8
callq 0x10138
movq %rax, %r14
movl $0xc, %edi
callq 0x10138
leaq 0xe3f3(%rip), %rdi      # 0x12141
leaq 0xe464(%rip), %rsi      # 0x121b9
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x1032f
jmp 0x3cec
leaq 0xe41c(%rip), %rdi      # 0x12189
leaq 0xe445(%rip), %rsi      # 0x121b9
xorl %eax, %eax
callq 0x1032f
jmp 0x3cec
// File: /workspace/github_c_makefile_star2_O1/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 0x3da4
movq %rbx, %rsi
callq 0x6214
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x3dd4
movq %rbx, %rax
jmp 0x3dcc
leaq 0xe34f(%rip), %rdi      # 0x120fa
leaq 0xe400(%rip), %rsi      # 0x121b2
movl $0x1, %edx
xorl %eax, %eax
callq 0x1032f
movq %rax, %r14
movq %rbx, %rdi
callq 0x10767
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 0x3e08
cmpl $0x0, 0x4(%rax)
je 0x3e39
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c7f
movl 0x4(%rax), %edx
decl %edx
movq %rax, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10fa8
callq 0x10138
movq %rax, %r14
movl $0xc, %edi
callq 0x10138
leaq 0xe320(%rip), %rdi      # 0x12141
leaq 0xe38a(%rip), %rsi      # 0x121b2
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x1032f
jmp 0x3dbe
leaq 0xe349(%rip), %rdi      # 0x12189
leaq 0xe36b(%rip), %rsi      # 0x121b2
xorl %eax, %eax
callq 0x1032f
jmp 0x3dbe
// File: /workspace/github_c_makefile_star2_O1/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 0x3e8d
movq %rdi, %r14
movq %rbx, %rsi
callq 0x6214
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x3ebd
movq %rbx, %rax
jmp 0x3eb5
leaq 0xe266(%rip), %rdi      # 0x120fa
leaq 0xe323(%rip), %rsi      # 0x121be
movl $0x1, %edx
xorl %eax, %eax
callq 0x1032f
movq %rax, %r14
movq %rbx, %rdi
callq 0x10767
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 0x3eed
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c7f
movl $0xb, (%rax)
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5e90
callq 0x10138
movq %rax, %r14
movl $0xc, %edi
callq 0x10138
leaq 0xe23b(%rip), %rdi      # 0x12141
leaq 0xe2b1(%rip), %rsi      # 0x121be
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x1032f
jmp 0x3ea7
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/builtins.c
// Function: builtin_append
awlval* builtin_append(awlenv* e, awlval* a) {
    AWLASSERT_MINARGCOUNT(a, 2, "append");
    EVAL_ARGS(e, a);

    for (int i = 0; i < a->count; i++) {
        AWLASSERT_TYPE(a, i, AWLVAL_QEXPR, "append");
    }

    awlval* x = awlval_pop(a, 0);
    while (a->count) {
        x = awlval_join(x, awlval_pop(a, 0));
    }

    awlval_del(a);
    return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x1, %ecx
jle 0x3f45
movq %rbx, %rsi
callq 0x6214
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x3f78
movq %rbx, %r14
jmp 0x3f6a
leaq 0xe17b(%rip), %rdi      # 0x120c7
leaq 0xe270(%rip), %rsi      # 0x121c3
movl $0x2, %edx
xorl %eax, %eax
callq 0x1032f
movq %rax, %r14
movq %rbx, %rdi
callq 0x10767
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movslq 0x4(%rbx), %rax
testq %rax, %rax
setg %bpl
jle 0x3fff
movq 0x8(%rbx), %rcx
movq (%rcx), %rdx
movl (%rdx), %edi
xorl %r14d, %r14d
cmpl $0xc, %edi
jne 0x3fb8
leaq -0x1(%rax), %rdx
xorl %r14d, %r14d
cmpq %r14, %rdx
je 0x3ff5
movq 0x8(%rcx,%r14,8), %rsi
movl (%rsi), %edi
incq %r14
cmpl $0xc, %edi
je 0x3f9d
cmpq %rax, %r14
setb %bpl
callq 0x10138
movq %rax, %r15
movl $0xc, %edi
callq 0x10138
leaq 0xe170(%rip), %rdi      # 0x12141
leaq 0xe1eb(%rip), %rsi      # 0x121c3
movl %r14d, %edx
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x1032f
movq %rax, %r14
movq %rbx, %rdi
callq 0x10767
jmp 0x3fff
incq %r14
cmpq %rax, %r14
setb %bpl
testb %bpl, %bpl
jne 0x3f6a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c23
movq %rax, %r14
cmpl $0x0, 0x4(%rbx)
je 0x3f62
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c23
movq %r14, %rdi
movq %rax, %rsi
callq 0x10ca1
jmp 0x4012
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/builtins.c
// Function: builtin_cons
awlval* builtin_cons(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 2, "cons");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 1, AWLVAL_QEXPR, "cons");

    awlval* v = awlval_pop(a, 0);
    awlval* x = awlval_take(a, 0);
    awlval_add_front(x, v);
    return x;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x2, %ecx
jne 0x408e
movq %rbx, %rsi
callq 0x6214
movq %rax, %rbx
cmpl $0x2, (%rax)
je 0x4089
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movl (%rax), %edi
cmpl $0xc, %edi
jne 0x40be
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c23
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c7f
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x10876
movq %rbx, %rax
jmp 0x40b6
leaq 0xe065(%rip), %rdi      # 0x120fa
leaq 0xe12e(%rip), %rsi      # 0x121ca
movl $0x2, %edx
xorl %eax, %eax
callq 0x1032f
movq %rax, %r14
movq %rbx, %rdi
callq 0x10767
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x10138
movq %rax, %r14
movl $0xc, %edi
callq 0x10138
leaq 0xe06a(%rip), %rdi      # 0x12141
leaq 0xe0ec(%rip), %rsi      # 0x121ca
movl $0x1, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x1032f
jmp 0x40a8
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/builtins.c
// Function: builtin_dictget
awlval* builtin_dictget(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 2, "dict-get");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 0, AWLVAL_DICT, "dict-get");
    AWLASSERT_TYPE(a, 1, AWLVAL_QSYM, "dict-get");

    awlval* d = awlval_pop(a, 0);
    awlval* k = awlval_take(a, 0);

    awlval* v = awlval_get_dict(d, k);
    awlval_del(d);
    awlval_del(k);
    return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x2, %ecx
jne 0x411a
movq %rbx, %rsi
callq 0x6214
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x4139
movq %rbx, %rax
jmp 0x41f3
leaq 0xdfd9(%rip), %rdi      # 0x120fa
leaq 0xe0a7(%rip), %rsi      # 0x121cf
movl $0x2, %edx
xorl %eax, %eax
callq 0x1032f
jmp 0x41e5
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movl (%rcx), %edi
cmpl $0xa, %edi
jne 0x418f
movq 0x8(%rax), %rax
movl (%rax), %edi
cmpl $0x4, %edi
jne 0x41b3
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c23
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c7f
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x108f5
movq %rax, %r15
movq %r14, %rdi
callq 0x10767
movq %rbx, %rdi
callq 0x10767
movq %r15, %rax
jmp 0x41f3
callq 0x10138
movq %rax, %r14
movl $0xa, %edi
callq 0x10138
leaq 0xdf99(%rip), %rdi      # 0x12141
leaq 0xe020(%rip), %rsi      # 0x121cf
xorl %edx, %edx
jmp 0x41d8
callq 0x10138
movq %rax, %r14
movl $0x4, %edi
callq 0x10138
leaq 0xdf75(%rip), %rdi      # 0x12141
leaq 0xdffc(%rip), %rsi      # 0x121cf
movl $0x1, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x1032f
movq %rax, %r14
movq %rbx, %rdi
callq 0x10767
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/builtins.c
// Function: builtin_dictset
awlval* builtin_dictset(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 3, "dict-set");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 0, AWLVAL_DICT, "dict-set");
    AWLASSERT_TYPE(a, 1, AWLVAL_QSYM, "dict-set");

    awlval* d = awlval_pop(a, 0);
    awlval* k = awlval_pop(a, 0);
    awlval* v = awlval_take(a, 0);

    d = awlval_add_dict(d, k, v);
    awlval_del(k);
    awlval_del(v);
    return d;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x3, %ecx
jne 0x4221
movq %rbx, %rsi
callq 0x6214
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x4240
movq %rbx, %rax
jmp 0x42ff
leaq 0xded2(%rip), %rdi      # 0x120fa
leaq 0xdfa9(%rip), %rsi      # 0x121d8
movl $0x3, %edx
xorl %eax, %eax
callq 0x1032f
jmp 0x42f1
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movl (%rcx), %edi
cmpl $0xa, %edi
jne 0x429b
movq 0x8(%rax), %rax
movl (%rax), %edi
cmpl $0x4, %edi
jne 0x42bf
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c23
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c23
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c7f
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x108d0
movq %rax, %r14
movq %r15, %rdi
callq 0x10767
jmp 0x42f4
callq 0x10138
movq %rax, %r14
movl $0xa, %edi
callq 0x10138
leaq 0xde8d(%rip), %rdi      # 0x12141
leaq 0xdf1d(%rip), %rsi      # 0x121d8
xorl %edx, %edx
jmp 0x42e4
callq 0x10138
movq %rax, %r14
movl $0x4, %edi
callq 0x10138
leaq 0xde69(%rip), %rdi      # 0x12141
leaq 0xdef9(%rip), %rsi      # 0x121d8
movl $0x1, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x1032f
movq %rax, %r14
movq %rbx, %rdi
callq 0x10767
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/builtins.c
// Function: builtin_dictdel
awlval* builtin_dictdel(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 2, "dict-del");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 0, AWLVAL_DICT, "dict-del");
    AWLASSERT_TYPE(a, 1, AWLVAL_QSYM, "dict-del");

    awlval* d = awlval_pop(a, 0);
    awlval* k = awlval_take(a, 0);

    awlval_rm_dict(d, k);
    awlval_del(k);
    return d;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x2, %ecx
jne 0x432c
movq %rbx, %rsi
callq 0x6214
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x434b
movq %rbx, %rax
jmp 0x43fa
leaq 0xddc7(%rip), %rdi      # 0x120fa
leaq 0xdea7(%rip), %rsi      # 0x121e1
movl $0x2, %edx
xorl %eax, %eax
callq 0x1032f
jmp 0x43ec
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movl (%rcx), %edi
cmpl $0xa, %edi
jne 0x4396
movq 0x8(%rax), %rax
movl (%rax), %edi
cmpl $0x4, %edi
jne 0x43ba
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c23
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c7f
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x10902
movq %rbx, %rdi
callq 0x10767
movq %r14, %rbx
jmp 0x4324
callq 0x10138
movq %rax, %r14
movl $0xa, %edi
callq 0x10138
leaq 0xdd92(%rip), %rdi      # 0x12141
leaq 0xde2b(%rip), %rsi      # 0x121e1
xorl %edx, %edx
jmp 0x43df
callq 0x10138
movq %rax, %r14
movl $0x4, %edi
callq 0x10138
leaq 0xdd6e(%rip), %rdi      # 0x12141
leaq 0xde07(%rip), %rsi      # 0x121e1
movl $0x1, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x1032f
movq %rax, %r14
movq %rbx, %rdi
callq 0x10767
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/builtins.c
// Function: builtin_dicthaskey
awlval* builtin_dicthaskey(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 2, "dict-haskey?");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 0, AWLVAL_DICT, "dict-haskey?");
    AWLASSERT_TYPE(a, 1, AWLVAL_QSYM, "dict-haskey?");

    awlval* d = awlval_pop(a, 0);
    awlval* k = awlval_take(a, 0);

    bool v = awlval_haskey_dict(d, k);
    awlval_del(d);
    awlval_del(k);
    return awlval_bool(v);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x2, %ecx
jne 0x4429
movq %rbx, %rsi
callq 0x6214
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x4448
movq %rbx, %rax
jmp 0x4509
leaq 0xdcca(%rip), %rdi      # 0x120fa
leaq 0xddb3(%rip), %rsi      # 0x121ea
movl $0x2, %edx
xorl %eax, %eax
callq 0x1032f
jmp 0x44fb
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movl (%rcx), %edi
cmpl $0xa, %edi
jne 0x44a5
movq 0x8(%rax), %rax
movl (%rax), %edi
cmpl $0x4, %edi
jne 0x44c9
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c23
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c7f
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x10927
movl %eax, %ebp
movq %r14, %rdi
callq 0x10767
movq %rbx, %rdi
callq 0x10767
movzbl %bpl, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x10558
callq 0x10138
movq %rax, %r14
movl $0xa, %edi
callq 0x10138
leaq 0xdc83(%rip), %rdi      # 0x12141
leaq 0xdd25(%rip), %rsi      # 0x121ea
xorl %edx, %edx
jmp 0x44ee
callq 0x10138
movq %rax, %r14
movl $0x4, %edi
callq 0x10138
leaq 0xdc5f(%rip), %rdi      # 0x12141
leaq 0xdd01(%rip), %rsi      # 0x121ea
movl $0x1, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x1032f
movq %rax, %r14
movq %rbx, %rdi
callq 0x10767
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/builtins.c
// Function: builtin_dictkeys
awlval* builtin_dictkeys(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 1, "dict-keys");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 0, AWLVAL_DICT, "dict-keys");

    awlval* d = awlval_take(a, 0);

    awlval* v = awlval_keys_dict(d);
    awlval_del(d);
    return v;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x1, %ecx
jne 0x4532
movq %rbx, %rsi
callq 0x6214
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x4562
movq %rbx, %rax
jmp 0x455a
leaq 0xdbc1(%rip), %rdi      # 0x120fa
leaq 0xdcb7(%rip), %rsi      # 0x121f7
movl $0x1, %edx
xorl %eax, %eax
callq 0x1032f
movq %rax, %r14
movq %rbx, %rdi
callq 0x10767
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0xa, %edi
jne 0x4587
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c7f
movq %rax, %rbx
movq %rax, %rdi
callq 0x1093d
jmp 0x454c
callq 0x10138
movq %rax, %r14
movl $0xa, %edi
callq 0x10138
leaq 0xdba1(%rip), %rdi      # 0x12141
leaq 0xdc50(%rip), %rsi      # 0x121f7
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x1032f
jmp 0x454c
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/builtins.c
// Function: builtin_dictvals
awlval* builtin_dictvals(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 1, "dict-vals");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 0, AWLVAL_DICT, "dict-vals");

    awlval* d = awlval_take(a, 0);

    awlval* v = awlval_vals_dict(d);
    awlval_del(d);
    return v;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x1, %ecx
jne 0x45dc
movq %rbx, %rsi
callq 0x6214
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x460c
movq %rbx, %rax
jmp 0x4604
leaq 0xdb17(%rip), %rdi      # 0x120fa
leaq 0xdc17(%rip), %rsi      # 0x12201
movl $0x1, %edx
xorl %eax, %eax
callq 0x1032f
movq %rax, %r14
movq %rbx, %rdi
callq 0x10767
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0xa, %edi
jne 0x4631
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c7f
movq %rax, %rbx
movq %rax, %rdi
callq 0x109d1
jmp 0x45f6
callq 0x10138
movq %rax, %r14
movl $0xa, %edi
callq 0x10138
leaq 0xdaf7(%rip), %rdi      # 0x12141
leaq 0xdbb0(%rip), %rsi      # 0x12201
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x1032f
jmp 0x45f6
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/builtins.c
// Function: builtin_len
awlval* builtin_len(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 1, "len");
    EVAL_ARGS(e, a);
    AWLASSERT_ISCOLLECTION(a, 0, "len");

    awlval* x = awlval_int(a->cell[0]->length);
    awlval_del(a);
    return x;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x1, %ecx
jne 0x4686
movq %rbx, %rsi
callq 0x6214
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x46a2
movq %rbx, %rax
jmp 0x46d1
leaq 0xda6d(%rip), %rdi      # 0x120fa
leaq 0xdb77(%rip), %rsi      # 0x1220b
movl $0x1, %edx
xorl %eax, %eax
callq 0x1032f
jmp 0x46c3
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0xc, %edi
ja 0x46d9
movl $0x1430, %ecx           # imm = 0x1430
btl %edi, %ecx
jae 0x46d9
movslq 0x10(%rax), %rdi
callq 0x10437
movq %rax, %r14
movq %rbx, %rdi
callq 0x10767
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x10138
leaq 0xdb2a(%rip), %rdi      # 0x1220f
leaq 0xdb1f(%rip), %rsi      # 0x1220b
xorl %edx, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1032f
jmp 0x46c3
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/builtins.c
// Function: builtin_reverse
awlval* builtin_reverse(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 1, "reverse");
    EVAL_ARGS(e, a);
    AWLASSERT_ISORDEREDCOLLECTION(a, 0, "reverse");

    awlval* collection = awlval_take(a, 0);

    return awlval_reverse(collection);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x1, %ecx
jne 0x471e
movq %rbx, %rsi
callq 0x6214
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x474e
movq %rbx, %rax
jmp 0x4746
leaq 0xd9d5(%rip), %rdi      # 0x120fa
leaq 0xdb34(%rip), %rsi      # 0x12260
movl $0x1, %edx
xorl %eax, %eax
callq 0x1032f
movq %rax, %r14
movq %rbx, %rdi
callq 0x10767
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0xc, %edi
ja 0x477f
movl $0x1030, %eax           # imm = 0x1030
btl %edi, %eax
jae 0x477f
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c7f
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10dac
callq 0x10138
leaq 0xdadd(%rip), %rdi      # 0x12268
leaq 0xdace(%rip), %rsi      # 0x12260
xorl %edx, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1032f
jmp 0x4738
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/builtins.c
// Function: builtin_if
awlval* builtin_if(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 3, "if");

    EVAL_SINGLE_ARG(e, a, 0);
    AWLASSERT_TYPE(a, 0, AWLVAL_BOOL, "if");

    awlval* x;
    /* does not eval result; sends it back to awlval_eval for
     * potential tail call optimization */
    if (a->cell[0]->bln) {
        x = awlval_pop(a, 1);
    } else {
        x = awlval_pop(a, 2);
    }

    awlval_del(a);
    return x;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x3, %ecx
jne 0x4a11
movq %rbx, %rsi
xorl %edx, %edx
callq 0x61cd
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x4a41
movq %rbx, %rax
jmp 0x4a39
leaq 0xd6e2(%rip), %rdi      # 0x120fa
leaq 0xd90a(%rip), %rsi      # 0x12329
movl $0x3, %edx
xorl %eax, %eax
callq 0x1032f
movq %rax, %r14
movq %rbx, %rdi
callq 0x10767
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0x6, %edi
jne 0x4a64
movzbl 0x18(%rax), %eax
movl $0x2, %esi
subl %eax, %esi
movq %rbx, %rdi
callq 0x10c23
jmp 0x4a2b
callq 0x10138
movq %rax, %r14
movl $0x6, %edi
callq 0x10138
leaq 0xd6c4(%rip), %rdi      # 0x12141
leaq 0xd8a5(%rip), %rsi      # 0x12329
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x1032f
jmp 0x4a2b
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/builtins.c
// Function: builtin_lambda
awlval* builtin_lambda(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 2, "fn");
    AWLASSERT_ISEXPR(a, 0, "fn");

    for (int i = 0; i < a->cell[0]->count; i++) {
        AWLASSERT(a, (a->cell[0]->cell[i]->type == AWLVAL_SYM),
                "function 'fn' cannot take non-symbol argument at position %i", i);
    }

    awlval* formals = awlval_pop(a, 0);
    awlval* body = awlval_take(a, 0);
    return awlval_lambda(e, formals, body);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x2, %ecx
jne 0x50ed
movq %rdi, %r14
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movl (%rcx), %edi
leal -0xb(%rdi), %eax
cmpl $0x1, %eax
ja 0x5109
movslq 0x4(%rcx), %rax
testq %rax, %rax
setg %bpl
jle 0x514b
movq 0x8(%rcx), %rcx
movq (%rcx), %rdx
xorl %esi, %esi
cmpl $0x3, (%rdx)
jne 0x50d2
leaq -0x1(%rax), %rdx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x5141
movq 0x8(%rcx,%rsi,8), %rdi
incq %rsi
cmpl $0x3, (%rdi)
je 0x50b5
cmpq %rax, %rsi
setb %bpl
leaq 0xd3db(%rip), %rdi      # 0x124b4
xorl %eax, %eax
callq 0x1032f
movq %rax, %r15
movq %rbx, %rdi
callq 0x10767
jmp 0x514b
leaq 0xd006(%rip), %rdi      # 0x120fa
leaq 0xd365(%rip), %rsi      # 0x12460
movl $0x2, %edx
xorl %eax, %eax
callq 0x1032f
jmp 0x5128
callq 0x10138
leaq 0xd34e(%rip), %rdi      # 0x12463
leaq 0xd344(%rip), %rsi      # 0x12460
xorl %edx, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1032f
movq %rax, %r14
movq %rbx, %rdi
callq 0x10767
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
incq %rsi
cmpq %rax, %rsi
setb %bpl
testb %bpl, %bpl
je 0x5155
movq %r15, %rax
jmp 0x5136
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c23
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c7f
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x105d9
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/builtins.c
// Function: builtin_macro
awlval* builtin_macro(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 3, "macro");
    AWLASSERT_TYPE(a, 0, AWLVAL_SYM, "macro");
    AWLASSERT_ISEXPR(a, 1, "macro");

    int index = awlenv_index(e, a->cell[0]);
    AWLASSERT(a, index == -1,
            "cannot redefine '%s'", a->cell[0]->sym);

    for (int i = 0; i < a->cell[1]->count; i++) {
        AWLASSERT(a, (a->cell[1]->cell[i]->type == AWLVAL_SYM),
                "macro cannot take non-symbol argument at position %i", i);
    }

    awlval* name = awlval_pop(a, 0);
    awlval* formals = awlval_pop(a, 0);
    awlval* body = awlval_take(a, 0);

    awlval* macro = awlval_macro(e, formals, body);

    awlenv_put(e, name, macro);

    awlval_del(name);
    awlval_del(macro);
    return awlval_qexpr();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x3, %ecx
jne 0x51e2
movq %rdi, %r14
movq 0x8(%rbx), %rax
movq (%rax), %rsi
movl (%rsi), %edi
cmpl $0x3, %edi
jne 0x51fe
movq 0x8(%rax), %rax
movl (%rax), %edi
leal -0xb(%rdi), %eax
cmpl $0x2, %eax
jae 0x522f
movq %r14, %rdi
callq 0x118f8
movq 0x8(%rbx), %rcx
cmpl $-0x1, %eax
je 0x5268
movq (%rcx), %rax
movq 0x18(%rax), %rsi
leaq 0xd161(%rip), %rdi      # 0x1233a
xorl %eax, %eax
callq 0x1032f
jmp 0x5251
leaq 0xcf11(%rip), %rdi      # 0x120fa
leaq 0xd301(%rip), %rsi      # 0x124f1
movl $0x3, %edx
xorl %eax, %eax
callq 0x1032f
jmp 0x5251
callq 0x10138
movq %rax, %r14
movl $0x3, %edi
callq 0x10138
leaq 0xcf2a(%rip), %rdi      # 0x12141
leaq 0xd2d3(%rip), %rsi      # 0x124f1
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x1032f
jmp 0x5251
callq 0x10138
leaq 0xd228(%rip), %rdi      # 0x12463
leaq 0xd2af(%rip), %rsi      # 0x124f1
movl $0x1, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1032f
movq %rax, %r14
movq %rbx, %rdi
callq 0x10767
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rcx), %rcx
movslq 0x4(%rcx), %rax
testq %rax, %rax
setg %bpl
jle 0x52cb
movq 0x8(%rcx), %rcx
movq (%rcx), %rdx
xorl %esi, %esi
cmpl $0x3, (%rdx)
jne 0x52a6
leaq -0x1(%rax), %rdx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x52c1
movq 0x8(%rcx,%rsi,8), %rdi
incq %rsi
cmpl $0x3, (%rdi)
je 0x528d
cmpq %rax, %rsi
setb %bpl
leaq 0xd24a(%rip), %rdi      # 0x124f7
xorl %eax, %eax
callq 0x1032f
movq %rax, %r15
movq %rbx, %rdi
callq 0x10767
jmp 0x52cb
incq %rsi
cmpq %rax, %rsi
setb %bpl
testb %bpl, %bpl
je 0x52d5
movq %r15, %rax
jmp 0x525f
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c23
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c23
movq %rax, %r12
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10c7f
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1067d
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x11958
movq %r15, %rdi
callq 0x10767
movq %rbx, %rdi
callq 0x10767
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x106fb
// File: /workspace/github_c_makefile_star2_O1/voithos[P]awl/src/builtins.c
// Function: builtin_typeof
awlval* builtin_typeof(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 1, "typeof");
    EVAL_ARGS(e, a);

    awlval* arg = awlval_take(a, 0);
    awlval* res = awlval_qsym(awlval_type_sysname(arg->type));
    awlval_del(arg);
    return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x1, %ecx
jne 0x536f
movq %rbx, %rsi
callq 0x6214
cmpl $0x2, (%rax)
je 0x5397
movq %rax, %rdi
xorl %esi, %esi
callq 0x10c7f
movq %rax, %rbx
movl (%rax), %edi
callq 0x10156
movq %rax, %rdi
callq 0x104ec
jmp 0x5389
leaq 0xcd84(%rip), %rdi      # 0x120fa
leaq 0xd1af(%rip), %rsi      # 0x1252c
movl $0x1, %edx
xorl %eax, %eax
callq 0x1032f
movq %rax, %r14
movq %rbx, %rdi
callq 0x10767
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq