LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/zepl.c
// Function: create_keys
void create_keys()
{
	char ch;
	char ctrx_map[] = "c-x c-|";
	char ctrl_map[] = "c-|";
	char esc_map[] = "esc-|";
	char ctrx_bytes[] = "\x18\x01";
	char ctrl_bytes[] = "\x01";
	char esc_bytes[] = "\x1B\x61";

	assert(khead == NULL);
	khead = ktail = new_key("c-space", "\x00");

	/* control-a to z */
	for (ch = 1; ch <= 26; ch++) {
		if (ch == 9 || ch == 10 || ch == 24) continue;  /* skip tab, linefeed, ctrl-x */
		ctrl_map[2] = ch + 96;   /* ASCII a is 97 */
		ctrl_bytes[0] = ch;
		make_key(ctrl_map, ctrl_bytes);
	}

	/* esc-a to z */
	for (ch = 1; ch <= 26; ch++) {
		esc_map[4] = ch + 96;
		esc_bytes[1] = ch + 96;
		make_key(esc_map, esc_bytes);
	}

	/* control-x control-a to z */
	for (ch = 1; ch <= 26; ch++) {
		ctrx_map[6] = ch + 96;
		ctrx_bytes[1] = ch;
		make_key(ctrx_map, ctrx_bytes);
	}

	make_key("c-x ?", "\x18\x3F");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x6c80(%rip), %rax      # 0xb19f
movq %rax, -0x9(%rbp)
movl 0x6c7a(%rip), %eax      # 0xb1a3
movl %eax, -0xd(%rbp)
movl 0x6c75(%rip), %eax      # 0xb1a7
movl %eax, -0x13(%rbp)
movw 0x6c6f(%rip), %ax       # 0xb1ab
movw %ax, -0xf(%rbp)
movw 0x6c66(%rip), %ax       # 0xb1ad
movw %ax, -0x16(%rbp)
movb 0x6c5e(%rip), %al       # 0xb1af
movb %al, -0x14(%rbp)
movw 0x6c53(%rip), %ax       # 0xb1ae
movw %ax, -0x18(%rbp)
movw 0x6c4a(%rip), %ax       # 0xb1b0
movw %ax, -0x1b(%rbp)
movb 0x6c42(%rip), %al       # 0xb1b2
movb %al, -0x19(%rbp)
leaq 0x6c39(%rip), %rdi      # 0xb1b3
leaq 0x6ebc(%rip), %rsi      # 0xb43d
callq 0x4390
movq %rax, 0xb39b(%rip)      # 0xf928
movq %rax, 0xb38c(%rip)      # 0xf920
movb $0x1, -0x1(%rbp)
movsbl -0x1(%rbp), %eax
cmpl $0x1a, %eax
jg 0x45e5
movsbl -0x1(%rbp), %eax
cmpl $0x9, %eax
je 0x45bc
movsbl -0x1(%rbp), %eax
cmpl $0xa, %eax
je 0x45bc
movsbl -0x1(%rbp), %eax
cmpl $0x18, %eax
jne 0x45be
jmp 0x45db
movsbl -0x1(%rbp), %eax
addl $0x60, %eax
movb %al, -0xb(%rbp)
movb -0x1(%rbp), %al
movb %al, -0x18(%rbp)
leaq -0xd(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x44c0
movb -0x1(%rbp), %al
addb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4598
movb $0x1, -0x1(%rbp)
movsbl -0x1(%rbp), %eax
cmpl $0x1a, %eax
jg 0x461d
movsbl -0x1(%rbp), %eax
addl $0x60, %eax
movb %al, -0xf(%rbp)
movsbl -0x1(%rbp), %eax
addl $0x60, %eax
movb %al, -0x1a(%rbp)
leaq -0x13(%rbp), %rdi
leaq -0x1b(%rbp), %rsi
callq 0x44c0
movb -0x1(%rbp), %al
addb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x45e9
movb $0x1, -0x1(%rbp)
movsbl -0x1(%rbp), %eax
cmpl $0x1a, %eax
jg 0x4651
movsbl -0x1(%rbp), %eax
addl $0x60, %eax
movb %al, -0x3(%rbp)
movb -0x1(%rbp), %al
movb %al, -0x15(%rbp)
leaq -0x9(%rbp), %rdi
leaq -0x16(%rbp), %rsi
callq 0x44c0
movb -0x1(%rbp), %al
addb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4621
leaq 0x6b63(%rip), %rdi      # 0xb1bb
leaq 0x6b62(%rip), %rsi      # 0xb1c1
callq 0x44c0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/zepl.c
// Function: set_key_internal
int set_key_internal(char *name, char *funcname, char *bytes, void (*func)(void))
{
	keymap_t *kp;
	
	for (kp = khead; kp->k_next != NULL; kp = kp->k_next) {
		if (0 == strcmp(kp->k_name, name)) {
			strncpy(kp->k_funcname, funcname, MAX_KFUNC);
			kp->k_funcname[MAX_KFUNC] ='\0';
			if (func != NULL)  /* dont set if its a user_func */
				kp->k_func = func;
			return 1;
		}
	}

	/* not found, create it and add onto the tail */
	if (func != NULL) {
		kp = new_key(name, bytes);
		strncpy(kp->k_funcname, funcname, MAX_KFUNC);
		kp->k_funcname[MAX_KFUNC] ='\0';
		kp->k_func = func;
		ktail->k_next = kp;
		ktail = kp;
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq 0xb291(%rip), %rax      # 0xf920
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x46fd
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x21c0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x46ed
movq -0x30(%rbp), %rdi
addq $0x1a, %rdi
movq -0x18(%rbp), %rsi
movl $0x1e, %edx
callq 0x2070
movq -0x30(%rbp), %rax
movb $0x0, 0x38(%rax)
cmpq $0x0, -0x28(%rbp)
je 0x46e4
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x40(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x4769
jmp 0x46ef
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x4693
cmpq $0x0, -0x28(%rbp)
je 0x4762
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4390
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x1a, %rdi
movq -0x18(%rbp), %rsi
movl $0x1e, %edx
callq 0x2070
movq -0x30(%rbp), %rax
movb $0x0, 0x38(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x30(%rbp), %rcx
movq 0xb1de(%rip), %rax      # 0xf928
movq %rcx, 0x48(%rax)
movq -0x30(%rbp), %rax
movq %rax, 0xb1cf(%rip)      # 0xf928
movl $0x1, -0x4(%rbp)
jmp 0x4769
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/zepl.c
// Function: eval_block
void eval_block()
{
	char *output;

	if (curbp->b_mark == NOMARK || curbp->b_mark >= curbp->b_point) {
		msg("no block defined");
		return;
	}

	copy_cut(FALSE, FALSE);
	assert(scrap != NULL);
	assert(strlen(scrap) > 0);

	reset_output_stream();
	output = call_lisp((char *)scrap);
	insert_string("\n");
	insert_string(output);
	reset_output_stream();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0xb389(%rip), %rax      # 0xfb48
cmpq $-0x1, (%rax)
je 0x47dc
movq 0xb37c(%rip), %rax      # 0xfb48
movq (%rax), %rax
movq 0xb372(%rip), %rcx      # 0xfb48
cmpq 0x8(%rcx), %rax
jl 0x47ec
leaq 0x69e1(%rip), %rdi      # 0xb1c4
movb $0x0, %al
callq 0x2560
jmp 0x4828
xorl %esi, %esi
movl %esi, %edi
callq 0x3d60
movb $0x0, %al
callq 0xa310
movq 0xb135(%rip), %rdi      # 0xf938
callq 0xa650
movq %rax, -0x8(%rbp)
leaq 0x682a(%rip), %rdi      # 0xb03d
callq 0x3f80
movq -0x8(%rbp), %rdi
callq 0x3f80
movb $0x0, %al
callq 0xa310
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/zepl.c
// Function: load_config
void load_config()
{
	char fname[300];
	char *output;
	int fd;

	reset_output_stream();
	(void)snprintf(fname, 300, "%s/%s", getenv("HOME"), E_INITFILE);

	if ((fd = open(fname, O_RDONLY)) == -1)
		fatal("failed to open " E_INITFILE " in HOME directory");

	reset_output_stream();
	output = load_file(fd);
	assert(output != NULL);
	close(fd);

	/* all exceptions start with the word error: */
	if (NULL != strstr(output, "error:"))
		fatal(output);
	reset_output_stream();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movb $0x0, %al
callq 0xa310
leaq -0x130(%rbp), %rax
movq %rax, -0x148(%rbp)
leaq 0x698b(%rip), %rdi      # 0xb1e2
callq 0x2030
movq -0x148(%rbp), %rdi
movq %rax, %rcx
movl $0x12c, %esi            # imm = 0x12C
leaq 0x696a(%rip), %rdx      # 0xb1dc
leaq 0x696e(%rip), %r8       # 0xb1e7
movb $0x0, %al
callq 0x2140
leaq -0x130(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x2280
movl %eax, -0x13c(%rbp)
cmpl $-0x1, %eax
jne 0x48a7
leaq 0x694d(%rip), %rdi      # 0xb1ef
callq 0x2520
movb $0x0, %al
callq 0xa310
movl -0x13c(%rbp), %edi
callq 0x8370
movq %rax, -0x138(%rbp)
movl -0x13c(%rbp), %edi
callq 0x2180
movq -0x138(%rbp), %rdi
leaq 0x68fc(%rip), %rsi      # 0xb1d5
callq 0x2350
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x48f4
movq -0x138(%rbp), %rdi
callq 0x2520
movb $0x0, %al
callq 0xa310
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/zepl.c
// Function: main
int main(int argc, char **argv)
{
	if (argc != 2) fatal("usage: " E_NAME " filename\n");

	setup_keys();
	(void)init_lisp();
	load_config();
	initscr();	
	raw();
	noecho();
	
	curbp = new_buffer();
	(void)insert_file(argv[1], FALSE);
	/* Save filename irregardless of load() success. */
	strncpy(curbp->b_fname, argv[1], MAX_FNAME);
	curbp->b_fname[MAX_FNAME] = '\0'; /* force truncation */

	if (!growgap(curbp, CHUNK)) fatal("Failed to allocate required memory.\n");

	while (!done) {
		display();
		input = get_key(khead, &key_return);

		if (key_return != NULL) {
			(key_return->k_func)();
		} else {
			/* allow TAB and NEWLINE, any other control char is 'Not Bound' */
			if (*input > 31 || *input == 10 || *input == 9)
				insert();
                        else {
				fflush(stdin);
				msg(E_NOT_BOUND);
			}
		}
	}

	noraw();
	endwin();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x4d68
leaq 0x66c4(%rip), %rdi      # 0xb427
callq 0x2520
callq 0x4910
callq 0xa560
callq 0x4830
callq 0x2150
callq 0x21e0
callq 0x2100
callq 0x2470
movq %rax, 0xadb6(%rip)      # 0xfb48
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x2aa0
movq 0xada0(%rip), %rdi      # 0xfb48
addq $0x4c, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x2070
movq 0xad83(%rip), %rax      # 0xfb48
movb $0x0, 0x14c(%rax)
movq 0xad75(%rip), %rdi      # 0xfb48
movl $0x1fa0, %esi           # imm = 0x1FA0
callq 0x26f0
cmpl $0x0, %eax
jne 0x4dee
leaq 0x6231(%rip), %rdi      # 0xb01a
callq 0x2520
jmp 0x4df0
cmpl $0x0, 0xb059(%rip)      # 0xfe50
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4e05
jmp 0x4e92
callq 0x3380
movq 0xab0f(%rip), %rdi      # 0xf920
leaq 0xb050(%rip), %rsi      # 0xfe68
callq 0x2c60
movq %rax, 0xb034(%rip)      # 0xfe58
cmpq $0x0, 0xb03c(%rip)      # 0xfe68
je 0x4e3a
movq 0xb033(%rip), %rax      # 0xfe68
callq *0x40(%rax)
jmp 0x4e8d
movq 0xb017(%rip), %rax      # 0xfe58
movzbl (%rax), %eax
cmpl $0x1f, %eax
jg 0x4e67
movq 0xb008(%rip), %rax      # 0xfe58
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0x4e67
movq 0xaff9(%rip), %rax      # 0xfe58
movzbl (%rax), %eax
cmpl $0x9, %eax
jne 0x4e6e
callq 0x3ac0
jmp 0x4e8b
movq 0xa153(%rip), %rax      # 0xefc8
movq (%rax), %rdi
callq 0x2230
leaq 0x630f(%rip), %rdi      # 0xb193
movb $0x0, %al
callq 0x2560
jmp 0x4e8d
jmp 0x4df0
callq 0x21d0
callq 0x2300
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: writeString
void writeString(char *str, Stream *stream)
{
   int len;
   char *new;

   switch (stream->type) {
   case STREAM_TYPE_FILE:
        len = strlen(str);
        len = write(stream->fd, str, len);
	return;

    case STREAM_TYPE_STRING:
    default:		
        len = strlen(str);
	new = realloc(stream->buffer, stream->length + len + 1);
	assert(new != NULL);
	memcpy(new + stream->length, str, len);
	stream->buffer = new;
	stream->length += len;
	new[stream->length] = '\0';
	return;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x4efe
jmp 0x4ecf
movl -0x24(%rbp), %eax
subl $0x1, %eax
jne 0x4f00
jmp 0x4ed9
movq -0x8(%rbp), %rdi
callq 0x20f0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edi
movq -0x8(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x20c0
movl %eax, -0x14(%rbp)
jmp 0x4f75
jmp 0x4f00
movq -0x8(%rbp), %rdi
callq 0x20f0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movslq -0x14(%rbp), %rax
addq %rax, %rsi
addq $0x1, %rsi
callq 0x2240
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
addq 0x18(%rax), %rdi
movq -0x8(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x2210
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movslq -0x14(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movb $0x0, (%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: writeFmt
void writeFmt(Stream *stream, char *format, ...)
{
    static char buf[WRITE_FMT_BUFSIZ];
    int nbytes;

    va_list args;
    va_start(args, format);
    nbytes = vsnprintf(buf, WRITE_FMT_BUFSIZ, format, args);
    va_end(args);

    switch (stream->type) {
    case STREAM_TYPE_FILE:
	nbytes = write(stream->fd, buf, nbytes);
	return;

    case STREAM_TYPE_STRING:
    default:
	writeString(buf, stream);
	return;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x4fb8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xe0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq -0x10(%rbp), %rdx
leaq 0xaea8(%rip), %rdi      # 0xfeb0
movl $0x800, %esi            # imm = 0x800
leaq -0x30(%rbp), %rcx
callq 0x20b0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xe4(%rbp)
testl %eax, %eax
je 0x5054
jmp 0x502b
movl -0xe4(%rbp), %eax
subl $0x1, %eax
jne 0x5056
jmp 0x5038
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edi
movslq -0x14(%rbp), %rdx
leaq 0xae66(%rip), %rsi      # 0xfeb0
callq 0x20c0
movl %eax, -0x14(%rbp)
jmp 0x5066
jmp 0x5056
movq -0x8(%rbp), %rsi
leaq 0xae4f(%rip), %rdi      # 0xfeb0
callq 0x4eb0
addq $0xf0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: writeChar
void writeChar(char ch, Stream *stream)
{
    char str[2];
    int i = 1;

    str[0] = ch;
    str[1] = '\0';
    
    switch (stream->type) {
    case STREAM_TYPE_FILE:
	i = write(stream->fd, str, i);
	return;

    case STREAM_TYPE_STRING:
    default:		
	writeString(str, stream);
	return;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x18(%rbp)
movb -0x1(%rbp), %al
movb %al, -0x12(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x50c5
jmp 0x50a2
movl -0x1c(%rbp), %eax
subl $0x1, %eax
jne 0x50c7
jmp 0x50ac
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edi
leaq -0x12(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0x20c0
movl %eax, -0x18(%rbp)
jmp 0x50d4
jmp 0x50c7
leaq -0x12(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4eb0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: exceptionWithObject
void exceptionWithObject(Object * object, char *format, ...)
{
	static char buf[WRITE_FMT_BUFSIZ];
	
	writeString("error: ", &ostream);

	if (object) {
		writeObject(object, true, &ostream);
		writeChar(' ', &ostream);
	}

	va_list args;
	va_start(args, format);
	vsnprintf(buf, WRITE_FMT_BUFSIZ, format, args);
	va_end(args);

	writeString(buf, &ostream);
	writeChar('\n', &ostream);

	longjmp(exceptionEnv, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x5118
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x6385(%rip), %rdi      # 0xb4c8
leaq 0xa096(%rip), %rsi      # 0xf1e0
callq 0x4eb0
cmpq $0x0, -0x8(%rbp)
je 0x517c
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0xa07a(%rip), %rdx      # 0xf1e0
callq 0x5200
movl $0x20, %edi
leaq 0xa069(%rip), %rsi      # 0xf1e0
callq 0x5070
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rcx
leaq 0xb501(%rip), %rdi      # 0x106b0
movl $0x800, %esi            # imm = 0x800
callq 0x20b0
leaq -0x30(%rbp), %rax
leaq 0xb4ec(%rip), %rdi      # 0x106b0
leaq 0xa015(%rip), %rsi      # 0xf1e0
callq 0x4eb0
movl $0xa, %edi
leaq 0xa004(%rip), %rsi      # 0xf1e0
callq 0x5070
leaq 0xbcc8(%rip), %rdi      # 0x10eb0
movl $0x1, %esi
callq 0x2250
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: gcMoveObject
Object *gcMoveObject(Object * object)
{
	// skip object if it is not within from-space (i.e. on the stack)
	if (object < (Object *) memory->fromSpace || object >= (Object *) ((char *)memory->fromSpace + memory->fromOffset))
		return object;

	// if the object has already been moved, return its new location
	if (object->type == (Type) - 1)
		return object->forward;

	// copy object to to-space
	Object *forward = (Object *) ((char *)memory->toSpace + memory->toOffset);
	memcpy(forward, object, object->size);
	memory->toOffset += object->size;

	// mark object as moved and set forwarding pointer
	object->type = (Type) - 1;
	object->forward = forward;

	return object->forward;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x9cc1(%rip), %rcx      # 0xf218
cmpq 0x18(%rcx), %rax
jb 0x557c
movq -0x10(%rbp), %rax
movq 0x9cb0(%rip), %rcx      # 0xf218
movq 0x18(%rcx), %rcx
movq 0x9ca5(%rip), %rdx      # 0xf218
addq 0x8(%rdx), %rcx
cmpq %rcx, %rax
jb 0x5586
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5605
movq -0x10(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x559d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x5605
movq 0x9c74(%rip), %rax      # 0xf218
movq 0x20(%rax), %rax
movq 0x9c69(%rip), %rcx      # 0xf218
addq 0x10(%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x2210
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0x9c3d(%rip), %rax      # 0xf218
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: memoryAllocObject
Object *memoryAllocObject(Type type, size_t size, GC_PARAM)
{
	size = memoryAlign(size, sizeof(void *));

	// allocate from- and to-space
	if (!memory->fromSpace) {
		if (!(memory->fromSpace = mmap(NULL, memory->capacity * 2, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)))
			exception("mmap() failed, %s", strerror(errno));

		memory->toSpace = (char *)memory->fromSpace + memory->capacity;
	}
	// run garbage collection if capacity exceeded
	if (memory->fromOffset + size >= memory->capacity)
		gc(GC_ROOTS);
	if (memory->fromOffset + size >= memory->capacity)
		exception("out of memory, %lu bytes", (unsigned long)size);

	// allocate object in from-space
	Object *object = (Object *) ((char *)memory->fromSpace + memory->fromOffset);
	object->type = type;
	object->size = size;
	memory->fromOffset += size;

	return object;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x5810
movq %rax, -0x10(%rbp)
movq 0x99ac(%rip), %rax      # 0xf218
cmpq $0x0, 0x18(%rax)
jne 0x58ef
movq 0x999e(%rip), %rax      # 0xf218
movq (%rax), %rsi
shlq %rsi
xorl %eax, %eax
movl %eax, %r9d
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x2110
movq 0x9974(%rip), %rcx      # 0xf218
movq %rax, 0x18(%rcx)
cmpq $0x0, %rax
jne 0x58cf
callq 0x2060
movl (%rax), %edi
callq 0x2320
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %edi
leaq 0x5c08(%rip), %rsi      # 0xb4d0
movb $0x0, %al
callq 0x50e0
movq 0x9942(%rip), %rax      # 0xf218
movq 0x18(%rax), %rcx
movq 0x9937(%rip), %rax      # 0xf218
addq (%rax), %rcx
movq 0x992d(%rip), %rax      # 0xf218
movq %rcx, 0x20(%rax)
movq 0x9922(%rip), %rax      # 0xf218
movq 0x8(%rax), %rax
addq -0x10(%rbp), %rax
movq 0x9913(%rip), %rcx      # 0xf218
cmpq (%rcx), %rax
jb 0x5913
movq -0x18(%rbp), %rdi
callq 0x5610
movq 0x98fe(%rip), %rax      # 0xf218
movq 0x8(%rax), %rax
addq -0x10(%rbp), %rax
movq 0x98ef(%rip), %rcx      # 0xf218
cmpq (%rcx), %rax
jb 0x5944
movq -0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %edi
leaq 0x5ba5(%rip), %rsi      # 0xb4e2
movb $0x0, %al
callq 0x50e0
movq 0x98cd(%rip), %rax      # 0xf218
movq 0x18(%rax), %rax
movq 0x98c2(%rip), %rcx      # 0xf218
addq 0x8(%rcx), %rax
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0x989a(%rip), %rax      # 0xf218
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: newObjectWithString
Object *newObjectWithString(Type type, size_t size, GC_PARAM)
{
	size = (size > sizeof(((Object *) NULL)->string))
	    ? size - sizeof(((Object *) NULL)->string)
	    : 0;
	return memoryAllocObject(type, sizeof(Object) + size, GC_ROOTS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x18, -0x10(%rbp)
jbe 0x5a88
movq -0x10(%rbp), %rax
subq $0x18, %rax
movq %rax, -0x20(%rbp)
jmp 0x5a90
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x5a90
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
movq -0x18(%rbp), %rdx
callq 0x5840
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: newCons
Object *newCons(Object ** car, Object ** cdr, GC_PARAM)
{
	Object *object = newObject(TYPE_CONS, GC_ROOTS);
	object->car = *car;
	object->cdr = *cdr;
	return object;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movl $0x3, %edi
callq 0x5990
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: newSymbolWithLength
Object *newSymbolWithLength(char *string, size_t length, GC_PARAM)
{
	for (Object * object = symbols; object != nil; object = object->cdr)
		if (memcmp(object->car->string, string, length) == 0 && object->car->string[length] == '\0')
			return object->car;

	GC_TRACE(gcObject, newObjectWithString(TYPE_SYMBOL, length + 1, GC_ROOTS));
	memcpy((*gcObject)->string, string, length);
	(*gcObject)->string[length] = '\0';

	symbols = newCons(gcObject, &symbols, GC_ROOTS);

	return *gcObject;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq 0xb1bd(%rip), %rax      # 0x10f78
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq 0x9456(%rip), %rax      # 0xf220
je 0x5e21
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x21a0
cmpl $0x0, %eax
jne 0x5e11
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movsbl 0x10(%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x5e11
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x5eb4
jmp 0x5e13
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x5dbf
movl $0x3, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
movq -0x20(%rbp), %rdx
movl $0x2, %edi
callq 0x5a60
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x50(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x58(%rbp), %rax
movq (%rax), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2210
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movb $0x0, 0x10(%rax,%rcx)
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0xb0db(%rip), %rsi      # 0x10f78
callq 0x5d50
movq %rax, 0xb0cf(%rip)      # 0x10f78
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: newObjectWithClosure
Object *newObjectWithClosure(Type type, Object ** params, Object ** body, Object ** env, GC_PARAM)
{
	Object *list;

	for (list = *params; list->type == TYPE_CONS; list = list->cdr) {
		if (list->car->type != TYPE_SYMBOL)
			exceptionWithObject(list->car, "is not a symbol");
		if (list->car == nil || list->car == t)
			exceptionWithObject(list->car, "cannot be used as a parameter");
	}

	if (list != nil && list->type != TYPE_SYMBOL)
		exceptionWithObject(list, "is not a symbol");

	Object *object = newObject(type, GC_ROOTS);
	object->params = *params;
	object->body = *body;
	object->env = *env;
	return object;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x5f9a
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x2, (%rax)
je 0x5f52
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x55b6(%rip), %rsi      # 0xb501
movb $0x0, %al
callq 0x50e0
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
cmpq 0x92bf(%rip), %rax      # 0xf220
je 0x5f74
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
cmpq 0x92b6(%rip), %rax      # 0xf228
jne 0x5f8a
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x558e(%rip), %rsi      # 0xb511
movb $0x0, %al
callq 0x50e0
jmp 0x5f8c
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x5f26
movq -0x30(%rbp), %rax
cmpq 0x927b(%rip), %rax      # 0xf220
je 0x5fc2
movq -0x30(%rbp), %rax
cmpl $0x2, (%rax)
je 0x5fc2
movq -0x30(%rbp), %rdi
leaq 0x5546(%rip), %rsi      # 0xb501
movb $0x0, %al
callq 0x50e0
movl -0x4(%rbp), %edi
movq -0x28(%rbp), %rsi
callq 0x5990
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: newPrimitive
Object *newPrimitive(int primitive, char *name, GC_PARAM)
{
	Object *object = newObject(TYPE_PRIMITIVE, GC_ROOTS);
	object->primitive = primitive;
	object->name = name;
	return object;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movl $0x6, %edi
callq 0x5990
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: streamSeek
Stream *streamSeek(Stream * stream, int offset)
{
	if (offset < 0 && -offset >= stream->offset)
		stream->offset = 0;
	else
		stream->offset += offset;
	return stream;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x6620
xorl %eax, %eax
subl -0xc(%rbp), %eax
cltq
movq -0x8(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jl 0x6620
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
jmp 0x6630
movslq -0xc(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: streamPeek
int streamPeek(Stream * stream)
{
	int ch = streamGetc(stream);
	if (ch != EOF)
		streamSeek(stream, -1);
	return ch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x62c0
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
je 0x666c
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x65f0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: readNext
int readNext(Stream * stream)
{
	for (;;) {
		int ch = streamGetc(stream);
		if (ch == ';')
			while ((ch = streamGetc(stream)) != EOF && ch != '\n');
		if (isspace(ch))
			continue;
		return ch;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x62c0
movl %eax, -0xc(%rbp)
cmpl $0x3b, -0xc(%rbp)
jne 0x66cf
jmp 0x66a0
movq -0x8(%rbp), %rdi
callq 0x62c0
movl %eax, %ecx
movl %ecx, -0xc(%rbp)
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0xd(%rbp)
je 0x66c2
cmpl $0xa, -0xc(%rbp)
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x66cb
jmp 0x66cd
jmp 0x66a0
jmp 0x66cf
callq 0x2360
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x66eb
jmp 0x668c
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: peekNext
int peekNext(Stream * stream)
{
	int ch = readNext(stream);
	if (ch != EOF)
		streamSeek(stream, -1);
	return ch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6680
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
je 0x672c
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x65f0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: readWhile
int readWhile(Stream * stream, int (*predicate) (int ch))
{
	for (;;) {
		int ch = streamPeek(stream);
		if (!predicate(ch))
			return ch;
		streamGetc(stream);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6640
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %edi
callq *%rax
cmpl $0x0, %eax
jne 0x6773
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
callq 0x62c0
jmp 0x6750
nop
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: readUnary
Object *readUnary(Stream * stream, char *symbol, GC_PARAM)
{
	if (peekNext(stream) == EOF)
		exception("unexpected end of stream in %s", symbol);

	GC_TRACE(gcSymbol, newSymbol(symbol, GC_ROOTS));
	GC_TRACE(gcObject, readExpr(stream, GC_ROOTS));

	*gcObject = newCons(gcObject, &nil, GC_ROOTS);
	*gcObject = newCons(gcSymbol, gcObject, GC_ROOTS);

	return *gcObject;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6700
cmpl $-0x1, %eax
jne 0x67bb
movq -0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %edi
leaq 0x4e02(%rip), %rsi      # 0xb5b6
movb $0x0, %al
callq 0x50e0
movl $0x3, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5ec0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x40(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x3, -0x70(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6880
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x70(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x78(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x89de(%rip), %rsi      # 0xf220
callq 0x5d50
movq %rax, %rcx
movq -0x78(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5d50
movq %rax, %rcx
movq -0x78(%rbp), %rax
movq %rcx, (%rax)
movq -0x78(%rbp), %rax
movq (%rax), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: readExpr
Object *readExpr(Stream * stream, GC_PARAM)
{
	for (;;) {

		int ch = readNext(stream);

		if (ch == EOF)
			return NULL;
		else if (ch == '\'')
			return readUnary(stream, "quote", GC_ROOTS);
		else if (ch == '"')
			return readString(stream, GC_ROOTS);
		else if (ch == '(')
			return readList(stream, GC_ROOTS);
		else if (isSymbolChar(ch)
			 && (ch != '.' || isSymbolChar(streamPeek(stream))))
			return readNumberOrSymbol(streamSeek(stream, -1), GC_ROOTS);
		else
			exception("unexpected character, `%c'", ch);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6680
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x68af
movq $0x0, -0x8(%rbp)
jmp 0x6961
cmpl $0x27, -0x1c(%rbp)
jne 0x68d2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x4de8(%rip), %rsi      # 0xb6ac
callq 0x6780
movq %rax, -0x8(%rbp)
jmp 0x6961
cmpl $0x22, -0x1c(%rbp)
jne 0x68eb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6970
movq %rax, -0x8(%rbp)
jmp 0x6961
cmpl $0x28, -0x1c(%rbp)
jne 0x6904
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6c80
movq %rax, -0x8(%rbp)
jmp 0x6961
movl -0x1c(%rbp), %edi
callq 0x6a30
cmpl $0x0, %eax
je 0x694c
cmpl $0x2e, -0x1c(%rbp)
jne 0x692c
movq -0x10(%rbp), %rdi
callq 0x6640
movl %eax, %edi
callq 0x6a30
cmpl $0x0, %eax
je 0x694c
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x65f0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x6a80
movq %rax, -0x8(%rbp)
jmp 0x6961
movl -0x1c(%rbp), %edx
xorl %eax, %eax
movl %eax, %edi
leaq 0x4d58(%rip), %rsi      # 0xb6b2
movb $0x0, %al
callq 0x50e0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: readString
Object *readString(Stream * stream, GC_PARAM)
{
	size_t offset = stream->offset;

	for (bool isEscaped = false;;) {
		int ch = streamGetc(stream);
		if (ch == EOF)
			exception("unexpected end of stream in string literal \"%.*s\"", (int)(stream->offset - offset), stream->buffer + offset);
		if (ch == '"' && !isEscaped)
			return newStringWithLength(stream->buffer + offset, stream->offset - offset - 1, GC_ROOTS);

		isEscaped = (ch == '\\' && !isEscaped);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x8(%rbp), %rdi
callq 0x62c0
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0x69ce
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
subq -0x18(%rbp), %rax
movl %eax, %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edi
leaq 0x4c0e(%rip), %rsi      # 0xb5d5
movb $0x0, %al
callq 0x50e0
cmpl $0x22, -0x20(%rbp)
jne 0x6a05
testb $0x1, -0x19(%rbp)
jne 0x6a05
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
addq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
subq -0x18(%rbp), %rsi
subq $0x1, %rsi
movq -0x10(%rbp), %rdx
callq 0x5ac0
addq $0x30, %rsp
popq %rbp
retq
xorl %eax, %eax
cmpl $0x5c, -0x20(%rbp)
movb %al, -0x21(%rbp)
jne 0x6a18
movb -0x19(%rbp), %al
xorb $-0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x6990
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: readNumberOrSymbol
Object *readNumberOrSymbol(Stream * stream, GC_PARAM)
{
	size_t offset = stream->offset;
	int ch = streamPeek(stream);

	// skip optional leading sign
	if (ch == '+' || ch == '-') {
		streamGetc(stream);
		ch = streamPeek(stream);
	}
	// try to read a number in integer or decimal format
	if (ch == '.' || isdigit(ch)) {
		if (isdigit(ch))
			ch = readWhile(stream, isdigit);
		if (!isSymbolChar(ch))
			return newNumber(strtol(stream->buffer + offset, NULL, 10), GC_ROOTS);
		if (ch == '.') {
			ch = streamGetc(stream);
			if (isdigit(streamPeek(stream))) {
				ch = readWhile(stream, isdigit);
				if (!isSymbolChar(ch))
					return newNumber(strtod(stream->buffer + offset, NULL), GC_ROOTS);
			}
		}
	}
	// non-numeric character encountered, read a symbol
	readWhile(stream, isSymbolChar);
	return newSymbolWithLength(stream->buffer + offset, stream->offset - offset, GC_ROOTS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6640
movl %eax, -0x24(%rbp)
cmpl $0x2b, -0x24(%rbp)
je 0x6ab4
cmpl $0x2d, -0x24(%rbp)
jne 0x6ac9
movq -0x10(%rbp), %rdi
callq 0x62c0
movq -0x10(%rbp), %rdi
callq 0x6640
movl %eax, -0x24(%rbp)
cmpl $0x2e, -0x24(%rbp)
je 0x6aed
callq 0x2360
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x6be4
callq 0x2360
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x6b1a
movq -0x10(%rbp), %rdi
movq 0x84a6(%rip), %rsi      # 0xefb8
callq 0x6740
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi
callq 0x6a30
cmpl $0x0, %eax
jne 0x6b58
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
addq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x2200
cvtsi2sd %rax, %xmm0
movq -0x18(%rbp), %rdi
callq 0x5a20
movq %rax, -0x8(%rbp)
jmp 0x6c19
cmpl $0x2e, -0x24(%rbp)
jne 0x6be2
movq -0x10(%rbp), %rdi
callq 0x62c0
movl %eax, -0x24(%rbp)
callq 0x2360
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6640
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x6be0
movq -0x10(%rbp), %rdi
movq 0x8413(%rip), %rsi      # 0xefb8
callq 0x6740
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi
callq 0x6a30
cmpl $0x0, %eax
jne 0x6bde
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
addq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20a0
movq -0x18(%rbp), %rdi
callq 0x5a20
movq %rax, -0x8(%rbp)
jmp 0x6c19
jmp 0x6be0
jmp 0x6be2
jmp 0x6be4
movq -0x10(%rbp), %rdi
leaq -0x1bf(%rip), %rsi      # 0x6a30
callq 0x6740
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
addq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
subq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5da0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: reverseList
Object *reverseList(Object * list)
{
	Object *object = nil;

	while (list != nil) {
		Object *swap = list;
		list = list->cdr;
		swap->cdr = object;
		object = swap;
	}

	return object;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq 0x85e1(%rip), %rax      # 0xf220
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq 0x85d2(%rip), %rax      # 0xf220
je 0x6c7a
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x6c43
movq -0x10(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: envLookup
Object *envLookup(Object * var, Object * env)
{
	for (; env != nil; env = env->parent) {
		Object *vars = env->vars, *vals = env->vals;

		for (; vars->type == TYPE_CONS; vars = vars->cdr, vals = vals->cdr)
			if (vars->car == var)
				return vals->car;

		if (vars == var)
			return vals;
	}

	exceptionWithObject(var, "has no value");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x8375(%rip), %rax      # 0xf220
je 0x6f31
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x6f0a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x6eee
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6f43
jmp 0x6ef0
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x6ec9
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x6f1e
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6f43
jmp 0x6f20
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6ea0
movq -0x10(%rbp), %rdi
leaq 0x47ce(%rip), %rsi      # 0xb70a
movb $0x0, %al
callq 0x50e0
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: envAdd
Object *envAdd(Object ** var, Object ** val, Object ** env, GC_PARAM)
{
	GC_TRACE(gcVars, newCons(var, &nil, GC_ROOTS));
	GC_TRACE(gcVals, newCons(val, &nil, GC_ROOTS));

	(*gcVars)->cdr = (*env)->vars, (*env)->vars = *gcVars;
	(*gcVals)->cdr = (*env)->vals, (*env)->vals = *gcVals;

	return *val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x3, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x8297(%rip), %rsi      # 0xf220
callq 0x5d50
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x48(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x3, -0x78(%rbp)
movq $0x0, -0x70(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x8254(%rip), %rsi      # 0xf220
callq 0x5d50
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x78(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rcx
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x50(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rcx
movq -0x80(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x80(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: envSet
Object *envSet(Object ** var, Object ** val, Object ** env, GC_PARAM)
{
	GC_TRACE(gcEnv, *env);

	for (;;) {
		Object *vars = (*gcEnv)->vars, *vals = (*gcEnv)->vals;

		for (; vars->type == TYPE_CONS; vars = vars->cdr, vals = vals->cdr) {
			if (vars->car == *var)
				return vals->car = *val;
			if (vars->cdr == *var)
				return vals->cdr = *val;
		}

		if ((*gcEnv)->parent == nil)
			return envAdd(var, val, gcEnv, GC_ROOTS);
		else
			*gcEnv = (*gcEnv)->parent;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x3, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x50(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x7140
movq -0x60(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x70fe
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x68(%rbp), %rcx
movq %rax, 0x10(%rcx)
movq %rax, -0x8(%rbp)
jmp 0x7186
movq -0x60(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x7124
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x68(%rbp), %rcx
movq %rax, 0x18(%rcx)
movq %rax, -0x8(%rbp)
jmp 0x7186
jmp 0x7126
movq -0x60(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x68(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x68(%rbp)
jmp 0x70cc
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
cmpq 0x80ce(%rip), %rax      # 0xf220
jne 0x716f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x6f50
movq %rax, -0x8(%rbp)
jmp 0x7186
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq -0x58(%rbp), %rax
movq %rcx, (%rax)
jmp 0x70ae
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: primitiveEq
Object *primitiveEq(Object ** args, GC_PARAM)
{
	Object *first = (*args)->car, *second = (*args)->cdr->car;

	if (first->type == TYPE_NUMBER && second->type == TYPE_NUMBER)
		return (first->number == second->number) ? t : nil;
	else if (first->type == TYPE_STRING && second->type == TYPE_STRING)
		return !strcmp(first->string, second->string) ? t : nil;
	else
		return (first == second) ? t : nil;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x724c
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x724c
movq -0x20(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x28(%rbp), %rax
ucomisd 0x10(%rax), %xmm0
jne 0x7237
jp 0x7237
movq 0x7ff7(%rip), %rax      # 0xf228
movq %rax, -0x30(%rbp)
jmp 0x7242
movq 0x7fe2(%rip), %rax      # 0xf220
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x72c4
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x729a
movq -0x28(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x729a
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
movq -0x28(%rbp), %rsi
addq $0x10, %rsi
callq 0x21c0
cmpl $0x0, %eax
jne 0x7285
movq 0x7fa9(%rip), %rax      # 0xf228
movq %rax, -0x38(%rbp)
jmp 0x7290
movq 0x7f94(%rip), %rax      # 0xf220
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x72c4
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x72b1
movq 0x7f7d(%rip), %rax      # 0xf228
movq %rax, -0x40(%rbp)
jmp 0x72bc
movq 0x7f68(%rip), %rax      # 0xf220
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: primitiveCar
Object *primitiveCar(Object ** args, GC_PARAM)
{
	Object *first = (*args)->car;

	if (first == nil)
		return nil;
	else if (first->type == TYPE_CONS)
		return first->car;
	else
		exceptionWithObject(first, "is not a list");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq 0x7f26(%rip), %rax      # 0xf220
jne 0x7309
movq 0x7f1d(%rip), %rax      # 0xf220
movq %rax, -0x8(%rbp)
jmp 0x7332
movq -0x20(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x7320
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x7332
movq -0x20(%rbp), %rdi
leaq 0x4204(%rip), %rsi      # 0xb52f
movb $0x0, %al
callq 0x50e0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)