LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]zepl/lisp.c
// Function: gc
void gc(GC_PARAM)
{
	memory->toOffset = 0;

	// move symbols and root objects
	symbols = gcMoveObject(symbols);

	for (Object * object = GC_ROOTS; object != nil; object = object->cdr)
		object->car = gcMoveObject(object->car);

	// iterate over objects in to-space and move all objects they reference
	for (Object * object = memory->toSpace; object < (Object *) ((char *)memory->toSpace + memory->toOffset); object = (Object *) ((char *)object + object->size)) {

		switch (object->type) {
		case TYPE_NUMBER:
		case TYPE_STRING:
		case TYPE_SYMBOL:
		case TYPE_PRIMITIVE:
			break;
		case TYPE_CONS:
			object->car = gcMoveObject(object->car);
			object->cdr = gcMoveObject(object->cdr);
			break;
		case TYPE_LAMBDA:
		case TYPE_MACRO:
			object->params = gcMoveObject(object->params);
			object->body = gcMoveObject(object->body);
			object->env = gcMoveObject(object->env);
			break;
		case TYPE_ENV:
			object->parent = gcMoveObject(object->parent);
			object->vars = gcMoveObject(object->vars);
			object->vals = gcMoveObject(object->vals);
			break;
		}
	}

	// swap from- and to-space
	void *swap = memory->fromSpace;
	memory->fromSpace = memory->toSpace;
	memory->toSpace = swap;
	memory->fromOffset = memory->toOffset;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq $0x0, 0xa84a(%rip) # 0xef70
movq 0xa7fb(%rip), %rdi      # 0xef28
callq 0x46a7
movq %rax, 0xa7ef(%rip)      # 0xef28
cmpq %rbx, 0x8ac8(%rip)      # 0xd208
je 0x475c
movq 0x10(%rbx), %rdi
callq 0x46a7
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rbx
cmpq 0x8aae(%rip), %rbx      # 0xd208
jne 0x4742
movq 0xa81d(%rip), %rbx      # 0xef80
movq 0xa806(%rip), %rax      # 0xef70
testq %rax, %rax
jle 0x47e1
movl (%rbx), %eax
leal -0x4(%rax), %ecx
cmpl $0x2, %ecx
jb 0x4783
cmpl $0x3, %eax
je 0x479e
cmpl $0x7, %eax
jne 0x47c4
movq 0x10(%rbx), %rdi
callq 0x46a7
movq %rax, 0x10(%rbx)
movl $0x20, %r14d
movl $0x18, %r15d
jmp 0x47aa
movl $0x18, %r14d
movl $0x10, %r15d
movq (%rbx,%r15), %rdi
callq 0x46a7
movq %rax, (%rbx,%r15)
movq (%rbx,%r14), %rdi
callq 0x46a7
movq %rax, (%rbx,%r14)
addq 0x8(%rbx), %rbx
movq 0xa7b1(%rip), %rcx      # 0xef80
movq 0xa79a(%rip), %rax      # 0xef70
leaq (%rcx,%rax), %rdx
cmpq %rdx, %rbx
jb 0x476f
jmp 0x47e4
movq %rbx, %rcx
movq 0xa78d(%rip), %rdx      # 0xef78
movq %rcx, 0xa786(%rip)      # 0xef78
movq %rdx, 0xa787(%rip)      # 0xef80
movq %rax, 0xa768(%rip)      # 0xef68
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
cmpq $0x0, 0xa750(%rip)      # 0xef78
jne 0x4862
movl $0x40000, %esi          # imm = 0x40000
xorl %edi, %edi
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x2100
movq %rax, 0xa728(%rip)      # 0xef78
testq %rax, %rax
je 0x48c7
addq $0x20000, %rax          # imm = 0x20000
movq %rax, 0xa71e(%rip)      # 0xef80
addq $0x7, %rbx
andq $-0x8, %rbx
movq 0xa6f7(%rip), %rcx      # 0xef68
leaq (%rcx,%rbx), %rdx
cmpq $0x20000, %rdx          # imm = 0x20000
jb 0x489a
movq %r14, %rdi
callq 0x4713
movq 0xa6db(%rip), %rcx      # 0xef68
leaq (%rcx,%rbx), %rdx
cmpq $0x20000, %rdx          # imm = 0x20000
jae 0x48b9
movq 0xa6d7(%rip), %rsi      # 0xef78
leaq (%rsi,%rcx), %rax
movl %ebp, (%rsi,%rcx)
movq %rbx, 0x8(%rsi,%rcx)
movq %rdx, 0xa6b4(%rip)      # 0xef68
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3bea(%rip), %rsi      # 0x84aa
xorl %edi, %edi
movq %rbx, %rdx
jmp 0x48df
callq 0x2060
movl (%rax), %edi
callq 0x2300
leaq 0x3bbe(%rip), %rsi      # 0x8498
xorl %edi, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4380
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]zepl/lisp.c
// Function: newStringWithLength
Object *newStringWithLength(char *string, size_t length, GC_PARAM)
{
	int nEscapes = 0;

	for (int i = 1; i < length; ++i)
		if (string[i - 1] == '\\' && strchr("\\\"trn", string[i]))
			++i, ++nEscapes;

	Object *object = newObjectWithString(TYPE_STRING,
					     length - nEscapes + 1, GC_ROOTS);

	for (int r = 1, w = 0; r <= length; ++r) {
		if (string[r - 1] == '\\' && r < length) {
			switch (string[r]) {
			case '\\':
				object->string[w++] = '\\';
				r++;
				break;
			case '"':
				object->string[w++] = '"';
				r++;
				break;
			case 't':
				object->string[w++] = '\t';
				r++;
				break;
			case 'r':
				object->string[w++] = '\r';
				r++;
				break;
			case 'n':
				object->string[w++] = '\n';
				r++;
				break;
			default:
				object->string[w++] = '\\';
				break;
			}
		} else
			object->string[w++] = string[r - 1];
	}

	object->string[length - nEscapes] = '\0';
	return object;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
cmpq $0x2, %rsi
jb 0x49ab
movl $0x1, %ebp
movl $0x1, %eax
leaq 0x3b49(%rip), %r12      # 0x84c3
cmpb $0x5c, -0x1(%r14,%rax)
jne 0x499e
movsbl (%r14,%rax), %esi
movl $0x6, %edx
movq %r12, %rdi
callq 0x2160
testq %rax, %rax
je 0x499e
incl %ebp
incl %r13d
incl %ebp
movslq %ebp, %rax
cmpq %rbx, %rax
jb 0x497a
movslq %r13d, %r13
movq %rbx, %r12
subq %r13, %r12
negq %r13
leaq (%rbx,%r13), %rax
incq %rax
xorl %esi, %esi
subq $0x18, %rax
cmovaeq %rax, %rsi
addq $0x28, %rsi
movl $0x1, %ebp
movl $0x1, %edi
movq %r15, %rdx
callq 0x4814
testq %rbx, %rbx
je 0x4a5a
movq %rax, %rcx
addq $0x10, %rcx
movl $0x1, %edx
movb -0x1(%r14,%rdx), %sil
cmpb $0x5c, %sil
setne %dil
cmpq %rbx, %rdx
setae %r8b
orb %dil, %r8b
jne 0x4a23
movzbl (%r14,%rdx), %edx
cmpl $0x6d, %edx
jle 0x4a28
cmpl $0x6e, %edx
je 0x4a37
cmpl $0x72, %edx
je 0x4a3c
cmpl $0x74, %edx
jne 0x4a55
movb $0x9, (%rcx)
jmp 0x4a44
movb %sil, (%rcx)
jmp 0x4a46
cmpl $0x22, %edx
je 0x4a41
cmpl $0x5c, %edx
jne 0x4a55
movb $0x5c, (%rcx)
jmp 0x4a44
movb $0xa, (%rcx)
jmp 0x4a44
movb $0xd, (%rcx)
jmp 0x4a44
movb $0x22, (%rcx)
incl %ebp
incl %ebp
movslq %ebp, %rdx
incq %rcx
cmpq %rbx, %rdx
jbe 0x49ec
jmp 0x4a5a
movb $0x5c, (%rcx)
jmp 0x4a46
movb $0x0, 0x10(%rax,%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x28, %esi
movl $0x3, %edi
callq 0x4814
movq (%r14), %rcx
movq %rcx, 0x10(%rax)
movq (%rbx), %rcx
movq %rcx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8726(%rip), %rbp      # 0xd208
movq 0xa43f(%rip), %r15      # 0xef28
cmpq %rbp, %r15
je 0x4b1b
movq 0x10(%r15), %r12
leaq 0x10(%r12), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2210
testl %eax, %eax
jne 0x4b15
cmpb $0x0, (%r13,%rbx)
je 0x4ba0
movq 0x18(%r15), %r15
jmp 0x4ae9
leaq 0x10(%rsp), %r12
movl $0x3, (%r12)
xorl %eax, %eax
movq %rax, 0x8(%r12)
leaq 0x1(%rbx), %rsi
subq $0x18, %rsi
cmovbq %rax, %rsi
addq $0x28, %rsi
movl $0x2, %edi
movq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x4814
movq %rax, %r13
movq %rax, 0x10(%r12)
movq %r15, 0x18(%r12)
leaq 0x10(%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x21e0
movb $0x0, 0x10(%r13,%rbx)
movl $0x28, %esi
movl $0x3, %edi
movq %r12, %rdx
callq 0x4814
movq 0x10(%r12), %r12
movq %r12, 0x10(%rax)
movq 0xa393(%rip), %rcx      # 0xef28
movq %rcx, 0x18(%rax)
movq %rax, 0xa388(%rip)      # 0xef28
movq %r12, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %eax
movq (%rsi), %rdi
movl (%rdi), %ecx
movq 0x8616(%rip), %rdx      # 0xd208
cmpl $0x3, %ecx
jne 0x4c1c
movq 0x8612(%rip), %rsi      # 0xd210
movq 0x10(%rdi), %rcx
cmpl $0x2, (%rcx)
jne 0x4c5f
cmpq %rdx, %rcx
je 0x4c56
cmpq %rsi, %rcx
je 0x4c56
movq 0x18(%rdi), %rdi
movl (%rdi), %ecx
cmpl $0x3, %ecx
je 0x4bfe
cmpq %rdx, %rdi
sete %dl
cmpl $0x2, %ecx
sete %cl
orb %dl, %cl
je 0x4c70
movl $0x28, %esi
movl %eax, %edi
movq %r8, %rdx
callq 0x4814
movq (%r15), %rcx
movq %rcx, 0x10(%rax)
movq (%r14), %rcx
movq %rcx, 0x18(%rax)
movq (%rbx), %rcx
movq %rcx, 0x20(%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x387c(%rip), %rsi      # 0x84d9
jmp 0x4c66
leaq 0x3863(%rip), %rsi      # 0x84c9
movq %rcx, %rdi
xorl %eax, %eax
callq 0x4380
leaq 0x3852(%rip), %rsi      # 0x84c9
jmp 0x4c69
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x28, %esi
movl $0x6, %edi
callq 0x4814
movl %ebp, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]zepl/lisp.c
// Function: newEnv
Object *newEnv(Object ** func, Object ** vals, GC_PARAM)
{
	Object *object = newObject(TYPE_ENV, GC_ROOTS);

	if ((*func) == nil)
		object->parent = object->vars = object->vals = nil;
	else {
		Object *param = (*func)->params, *val = *vals;

		for (int nArgs = 0;; param = param->cdr, val = val->cdr, ++nArgs) {
			if (param == nil && val == nil)
				break;
			else if (param != nil && param->type == TYPE_SYMBOL)
				break;
			else if (val != nil && val->type != TYPE_CONS)
				exceptionWithObject(val, "is not a list");
			else if (param == nil && val != nil)
				exceptionWithObject(*func, "expects at most %d arguments", nArgs);
			else if (param != nil && val == nil) {
				for (; param->type == TYPE_CONS; param = param->cdr, ++nArgs);
				exceptionWithObject(*func, "expects at least %d arguments", nArgs);
			}
		}

		object->parent = (*func)->env;
		object->vars = (*func)->params;
		object->vals = *vals;
	}

	return object;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x28, %esi
movl $0x7, %edi
callq 0x4814
movq (%r14), %rdi
movq 0x851b(%rip), %r8       # 0xd208
cmpq %r8, %rdi
je 0x4d88
movq (%rbx), %rcx
movq 0x10(%rdi), %rsi
cmpq %r8, %rsi
sete %r10b
cmpq %r8, %rcx
sete %r9b
testb %r9b, %r10b
jne 0x4d58
xorl %edx, %edx
testb $0x1, %r10b
jne 0x4d1d
cmpl $0x2, (%rsi)
je 0x4d58
testb $0x1, %r9b
je 0x4d2a
cmpq %r8, %rsi
je 0x4d34
jmp 0x4d7a
cmpl $0x3, (%rcx)
jne 0x4d9c
cmpq %r8, %rsi
je 0x4dad
incl %edx
movq 0x18(%rcx), %rcx
movq 0x18(%rsi), %rsi
cmpq %r8, %rsi
sete %r10b
cmpq %r8, %rcx
sete %r9b
movl %r10d, %r11d
andb %r9b, %r11b
cmpb $0x1, %r11b
jne 0x4d12
movq 0x20(%rdi), %rcx
movq %rcx, 0x10(%rax)
movq (%r14), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq (%rbx), %rcx
movq %rcx, 0x20(%rax)
jmp 0x4d94
movq 0x18(%rsi), %rsi
incl %edx
cmpl $0x3, (%rsi)
je 0x4d74
leaq 0x379c(%rip), %rsi      # 0x8522
jmp 0x4db4
movq %r8, 0x20(%rax)
movq %r8, 0x18(%rax)
movq %r8, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3754(%rip), %rsi      # 0x84f7
movq %rcx, %rdi
xorl %eax, %eax
callq 0x4380
leaq 0x3751(%rip), %rsi      # 0x8505
xorl %eax, %eax
callq 0x4380
// File: /workspace/github_c_makefile_star2_O3/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:
movq %rdi, %rax
testl %esi, %esi
js 0x4f92
movq 0x28(%rax), %rcx
jmp 0x4f9f
movl %esi, %edx
negl %edx
movq 0x28(%rax), %rcx
cmpq %rdx, %rcx
jle 0x4faa
movslq %esi, %rdx
addq %rcx, %rdx
movq %rdx, 0x28(%rax)
retq
movq $0x0, 0x28(%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
callq 0x4dbb
cmpl $-0x1, %eax
je 0x4fd7
movq 0x28(%rbx), %rcx
leaq -0x1(%rcx), %rdx
xorl %esi, %esi
cmpq $0x2, %rcx
cmovgeq %rdx, %rsi
movq %rsi, 0x28(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rbx, %rdi
callq 0x4dbb
movl %eax, %ebp
cmpl $0x3b, %eax
jne 0x5002
movq %rbx, %rdi
callq 0x4dbb
movl %eax, %ebp
cmpl $0xa, %eax
je 0x5002
cmpl $-0x1, %ebp
jne 0x4fee
callq 0x2340
movq (%rax), %rax
movslq %ebp, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x4fdf
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
callq 0x4fd9
cmpl $-0x1, %eax
je 0x5041
movq 0x28(%rbx), %rcx
leaq -0x1(%rcx), %rdx
xorl %esi, %esi
cmpq $0x2, %rcx
cmovgeq %rdx, %rsi
movq %rsi, 0x28(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x4dbb
movl %eax, %ebp
cmpl $-0x1, %eax
je 0x5076
movq 0x28(%r14), %rax
leaq -0x1(%rax), %rcx
cmpq $0x2, %rax
cmovlq %r15, %rcx
movq %rcx, 0x28(%r14)
movl %ebp, %edi
callq *%rbx
testl %eax, %eax
je 0x5088
movq %r14, %rdi
callq 0x4dbb
jmp 0x5053
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
callq 0x4fd9
cmpl $-0x1, %eax
je 0x5178
movq 0x28(%r14), %rax
leaq -0x1(%rax), %rcx
xorl %r13d, %r13d
cmpq $0x2, %rax
cmovlq %r13, %rcx
movq %rcx, 0x28(%r14)
movl $0x3, %ebp
leaq 0x30(%rsp), %rbx
movl %ebp, (%rbx)
movq %r13, 0x8(%rbx)
movq %r15, %rdi
callq 0x20e0
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x4ac2
movq %rax, 0x10(%rbx)
movq %r12, 0x18(%rbx)
leaq 0x8(%rsp), %r15
movl %ebp, (%r15)
movq %r13, 0x8(%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x518b
movq %rax, 0x10(%r15)
movq %rbx, 0x18(%r15)
movl $0x28, %esi
movl $0x3, %edi
movq %r15, %rdx
callq 0x4814
movq 0x10(%r15), %rcx
movq %rcx, 0x10(%rax)
movq 0x80c9(%rip), %rcx      # 0xd208
movq %rcx, 0x18(%rax)
movq %rax, 0x10(%r15)
movl $0x28, %esi
movl $0x3, %edi
movq %r15, %rdx
callq 0x4814
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%r15), %rcx
movq %rcx, 0x18(%rax)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x33ff(%rip), %rsi      # 0x857e
xorl %edi, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0x4380
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4fd9
movl %eax, %ebp
cmpl $0x26, %eax
jg 0x51be
cmpl $-0x1, %ebp
je 0x5245
cmpl $0x22, %ebp
jne 0x51e2
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x527d
cmpl $0x28, %ebp
je 0x524c
cmpl $0x27, %ebp
jne 0x51e2
leaq 0x34a1(%rip), %rsi      # 0x8674
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x5095
movl %ebp, %edi
callq 0x52f9
testl %eax, %eax
je 0x525b
cmpl $0x2e, %ebp
jne 0x5220
movq %r14, %rdi
callq 0x4dbb
cmpl $-0x1, %eax
je 0x5215
movq 0x28(%r14), %rcx
leaq -0x1(%rcx), %rdx
xorl %esi, %esi
cmpq $0x2, %rcx
cmovgeq %rdx, %rsi
movq %rsi, 0x28(%r14)
movl %eax, %edi
callq 0x52f9
testl %eax, %eax
je 0x5268
movq 0x28(%r14), %rax
leaq -0x1(%rax), %rcx
xorl %edx, %edx
cmpq $0x2, %rax
cmovgeq %rcx, %rdx
movq %rdx, 0x28(%r14)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x5332
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x557d
leaq 0x3418(%rip), %rsi      # 0x867a
xorl %edi, %edi
movl %ebp, %edx
jmp 0x5276
leaq 0x340b(%rip), %rsi      # 0x867a
xorl %edi, %edi
movl $0x2e, %edx
xorl %eax, %eax
callq 0x4380
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq 0x28(%rdi), %rbx
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x4dbb
cmpl $0x22, %eax
je 0x52a4
cmpl $-0x1, %eax
jne 0x52aa
jmp 0x52dc
testb $0x1, %bpl
je 0x52b9
cmpl $0x5c, %eax
sete %al
xorb $0x1, %bpl
andb %al, %bpl
jmp 0x5290
movq 0x8(%r14), %rdi
addq %rbx, %rdi
notq %rbx
addq 0x28(%r14), %rbx
movq %rbx, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x494c
movl 0x28(%r14), %edx
subl %ebx, %edx
addq 0x8(%r14), %rbx
leaq 0x32b0(%rip), %rsi      # 0x859d
xorl %edi, %edi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x4380
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x7cab(%rip), %rcx      # 0xd208
cmpq %rdi, %rcx
je 0x5579
movq %rcx, %rdx
movq %rdi, %rax
movq 0x18(%rdi), %rdi
movq %rdx, 0x18(%rax)
movq %rax, %rdx
cmpq %rcx, %rdi
jne 0x5565
retq
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movq 0x7a6d(%rip), %rcx      # 0xd208
cmpq %rsi, %rcx
je 0x57cb
movq 0x18(%rsi), %rdx
movq 0x20(%rsi), %rax
cmpl $0x3, (%rdx)
jne 0x57bd
cmpq %rdi, 0x10(%rdx)
je 0x57d9
movq 0x18(%rax), %rax
movq 0x18(%rdx), %rdx
jmp 0x57a8
cmpq %rdi, %rdx
je 0x57dd
movq 0x10(%rsi), %rsi
cmpq %rcx, %rsi
jne 0x57a0
leaq 0x2f00(%rip), %rsi      # 0x86d2
xorl %eax, %eax
callq 0x4380
movq 0x10(%rax), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
subq $0x28, %rsp
movq %rdx, %rax
leaq 0x10(%rsp), %rdx
movl $0x3, -0x10(%rdx)
movq $0x0, -0x8(%rdx)
movq (%rax), %rax
movq %rax, (%rdx)
movq %rcx, 0x8(%rdx)
movq 0x7946(%rip), %rcx      # 0xd208
movq 0x18(%rax), %r8
cmpl $0x3, (%r8)
jne 0x58ef
leaq 0x20(%rax), %r9
movq (%rdi), %r10
movq (%r9), %r9
cmpq %r10, 0x10(%r8)
je 0x58ff
movq 0x18(%r8), %r8
cmpq %r10, %r8
je 0x5908
addq $0x18, %r9
cmpl $0x3, (%r8)
je 0x58d3
movq 0x10(%rax), %rax
cmpq %rcx, %rax
je 0x5914
movq %rax, 0x10(%rsp)
jmp 0x58c2
movq (%rsi), %rax
movq %rax, 0x10(%r9)
jmp 0x590f
movq (%rsi), %rax
movq %rax, 0x18(%r9)
addq $0x28, %rsp
retq
movq %rsp, %rcx
callq 0x57df
jmp 0x590f
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movq (%rdi), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rax), %rax
movq 0x10(%rax), %rsi
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x5973
testl %eax, %eax
jne 0x5989
cmpl $0x0, (%rsi)
jne 0x5989
movsd 0x10(%rsi), %xmm0
cmpeqsd 0x10(%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x598f
cmpl $0x1, (%rsi)
jne 0x5989
addq $0x10, %rdi
addq $0x10, %rsi
callq 0x2190
testl %eax, %eax
jmp 0x598c
cmpq %rsi, %rdi
sete %al
leaq 0x787a(%rip), %rcx      # 0xd210
leaq 0x786b(%rip), %rdx      # 0xd208
testb %al, %al
cmovneq %rcx, %rdx
movq (%rdx), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq (%rdi), %rax
movq 0x10(%rax), %rdi
movq 0x7852(%rip), %rax      # 0xd208
cmpq %rax, %rdi
je 0x59c4
cmpl $0x3, (%rdi)
jne 0x59c5
movq 0x10(%rdi), %rax
retq
pushq %rax
leaq 0x2b2a(%rip), %rsi      # 0x84f7
xorl %eax, %eax
callq 0x4380
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]zepl/lisp.c
// Function: primitiveCdr
Object *primitiveCdr(Object ** args, GC_PARAM)
{
	Object *first = (*args)->car;

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

// Assembly:
movq (%rdi), %rax
movq 0x10(%rax), %rdi
movq 0x7826(%rip), %rax      # 0xd208
cmpq %rax, %rdi
je 0x59f0
cmpl $0x3, (%rdi)
jne 0x59f1
movq 0x18(%rdi), %rax
retq
pushq %rax
leaq 0x2afe(%rip), %rsi      # 0x84f7
xorl %eax, %eax
callq 0x4380
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]zepl/lisp.c
// Function: primitivePrint
Object *primitivePrint(Object ** args, GC_PARAM)
{
	writeChar('\n', &ostream);
	writeObject((*args)->car, true, &ostream);
	writeChar(' ', &ostream);
	return (*args)->car;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7754(%rip), %r14      # 0xd1d0
movl $0xa, %edi
movq %r14, %rsi
callq 0x4350
movq (%rbx), %rax
movq 0x10(%rax), %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x4489
movl $0x20, %edi
movq %r14, %rsi
callq 0x4350
movq (%rbx), %rax
movq 0x10(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]zepl/lisp.c
// Function: stringAppend
Object *stringAppend(Object ** args, GC_PARAM)
{
	TWO_STRING_ARGS();

	int len1 = strlen(first->string);
	int len2 = strlen(second->string);
	char *new = strdup(first->string);
	new = realloc(new, len1 + len2 + 1);
	assert(new != NULL);
	memcpy(new + len1, second->string, len2);
	new[len1 + len2] = '\0';

	Object *obj = newStringWithLength(new, len1 + len2, GC_ROOTS);	
	free(new);

	return obj;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x10(%rax), %r15
cmpl $0x1, (%r15)
jne 0x5df4
movq 0x18(%rax), %rax
movq 0x10(%rax), %r14
cmpl $0x1, (%r14)
jne 0x5e00
movq %rsi, %rbx
addq $0x10, %r15
movq %r15, %rdi
callq 0x20e0
movq %rax, %r12
addq $0x10, %r14
movq %r14, %rdi
callq 0x20e0
movq %rax, %r13
movq %r15, %rdi
callq 0x22f0
leal (%r12,%r13), %ebp
leal (%r12,%r13), %ecx
incl %ecx
movslq %ecx, %rsi
movq %rax, %rdi
callq 0x2220
movq %rax, %r15
movslq %r12d, %rdi
addq %rax, %rdi
movslq %r13d, %rdx
movq %r14, %rsi
callq 0x21e0
movslq %ebp, %rsi
movb $0x0, (%r15,%rsi)
movq %r15, %rdi
movq %rbx, %rdx
callq 0x494c
movq %rax, %rbx
movq %r15, %rdi
callq 0x2050
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28e4(%rip), %rsi      # 0x86df
movq %r15, %rdi
jmp 0x5e0a
leaq 0x28d8(%rip), %rsi      # 0x86df
movq %r14, %rdi
xorl %eax, %eax
callq 0x4380
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]zepl/lisp.c
// Function: stringSubstring
Object *stringSubstring(Object ** args, GC_PARAM)
{
	Object *first = (*args)->car;
	Object *second = (*args)->cdr->car;
	Object *third = (*args)->cdr->cdr->car;

	if (first->type != TYPE_STRING)
	    exceptionWithObject(first, "is not a string");
	if (second->type != TYPE_NUMBER)
	    exceptionWithObject(second, "is not a number");  
	if (third->type != TYPE_NUMBER)
	    exceptionWithObject(third, "is not a number");  

	int start = (int)(second->number);
	int end = (int)(third->number);
	int len = strlen(first->string);

	if (start < 0 || start > len -1)
	    exceptionWithObject(second, "is out of bounds");
	if (end < 0 || end > len -1)
	    exceptionWithObject(third, "is out of bounds");
	if (start > end)
	    exceptionWithObject(second, "start index greater than end index");

	char *sub = strdup(first->string);
	int newlen = end - start + 1;

	memcpy(sub, (first->string + start), newlen);
	*(sub + newlen) = '\0';
	Object *obj = newStringWithLength(sub, newlen, GC_ROOTS);
	free(sub);

	return obj;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x10(%rax), %r14
cmpl $0x1, (%r14)
jne 0x5ef1
movq 0x18(%rax), %rax
movq 0x10(%rax), %r15
cmpl $0x0, (%r15)
jne 0x5efd
movq 0x18(%rax), %rax
movq 0x10(%rax), %r12
cmpl $0x0, (%r12)
jne 0x5f06
cvttsd2si 0x10(%r15), %ebp
testl %ebp, %ebp
js 0x5ee8
movq %rsi, %rbx
cvttsd2si 0x10(%r12), %r13d
addq $0x10, %r14
movq %r14, %rdi
callq 0x20e0
cmpl %ebp, %eax
jle 0x5ee8
testl %r13d, %r13d
js 0x5f0f
cmpl %r13d, %eax
jle 0x5f0f
subl %ebp, %r13d
jb 0x5f1b
movq %r14, %rdi
callq 0x22f0
movq %rax, %r15
movslq %r13d, %r13
leaq 0x1(%r13), %r12
movl %ebp, %esi
addq %r14, %rsi
movq %rax, %rdi
movq %r12, %rdx
callq 0x21e0
movb $0x0, 0x1(%r15,%r13)
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x494c
movq %rax, %rbx
movq %r15, %rdi
callq 0x2050
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2810(%rip), %rsi      # 0x86ff
jmp 0x5f22
leaq 0x27e7(%rip), %rsi      # 0x86df
movq %r14, %rdi
jmp 0x5f25
leaq 0x27eb(%rip), %rsi      # 0x86ef
jmp 0x5f22
leaq 0x27e2(%rip), %rsi      # 0x86ef
jmp 0x5f16
leaq 0x27e9(%rip), %rsi      # 0x86ff
movq %r12, %rdi
jmp 0x5f25
leaq 0x27ee(%rip), %rsi      # 0x8710
movq %r15, %rdi
xorl %eax, %eax
callq 0x4380
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]zepl/lisp.c
// Function: stringLength
Object *stringLength(Object ** args, GC_PARAM)
{
	Object *first = (*args)->car;
	if (first->type != TYPE_STRING)
	    exceptionWithObject(first, "is not a string");

	return newNumber(strlen(first->string), GC_ROOTS);	
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rax
movq 0x10(%rax), %rdi
cmpl $0x1, (%rdi)
jne 0x5f8d
movq %rsi, %rbx
addq $0x10, %rdi
callq 0x20e0
movq %rax, %xmm0
punpckldq 0x250a(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2512(%rip), %xmm0     # 0x8470
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
movl $0x28, %esi
xorl %edi, %edi
movq %rbx, %rdx
callq 0x4814
movaps (%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
addq $0x10, %rsp
popq %rbx
retq
leaq 0x274b(%rip), %rsi      # 0x86df
xorl %eax, %eax
callq 0x4380
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]zepl/lisp.c
// Function: stringToNumber
Object *stringToNumber(Object ** args, GC_PARAM)
{
	Object *first = (*args)->car;

	if (first->type != TYPE_STRING)
	    exceptionWithObject(first, "is not a string");

	double num = strtod(first->string, NULL);
	return newNumber(num, GC_ROOTS);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rax
movq 0x10(%rax), %rdi
cmpl $0x1, (%rdi)
jne 0x607f
movq %rsi, %rbx
addq $0x10, %rdi
xorl %esi, %esi
callq 0x2090
movsd %xmm0, 0x8(%rsp)
movl $0x28, %esi
xorl %edi, %edi
movq %rbx, %rdx
callq 0x4814
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
addq $0x10, %rsp
popq %rbx
retq
leaq 0x2659(%rip), %rsi      # 0x86df
xorl %eax, %eax
callq 0x4380
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]zepl/lisp.c
// Function: numberToString
Object *numberToString(Object ** args, GC_PARAM)
{
	char buf[40];
	Object *first = (*args)->car;

	if (first->type != TYPE_NUMBER)
	    exceptionWithObject(first, "is not a number");

	if (first->number == (long)first->number)
		sprintf(buf, "%ld", (long)first->number);
	else
		sprintf(buf, "%lf", first->number);

	return newStringWithLength(buf, strlen(buf), GC_ROOTS);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
movq 0x10(%rax), %rdi
cmpl $0x0, (%rdi)
jne 0x60ff
movq %rsi, %rbx
movsd 0x10(%rdi), %xmm0
cvttsd2si %xmm0, %rdx
cvtsi2sd %rdx, %xmm1
ucomisd %xmm1, %xmm0
jne 0x60cd
jp 0x60cd
leaq 0x2672(%rip), %rsi      # 0x8733
movq %rsp, %rdi
xorl %eax, %eax
callq 0x22b0
jmp 0x60de
leaq 0x2663(%rip), %rsi      # 0x8737
movq %rsp, %rdi
movb $0x1, %al
callq 0x22b0
movq %rsp, %r14
movq %r14, %rdi
callq 0x20e0
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x494c
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x25e9(%rip), %rsi      # 0x86ef
xorl %eax, %eax
callq 0x4380
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]zepl/lisp.c
// Function: os_getenv
Object *os_getenv(Object ** args, GC_PARAM)
{
	ONE_STRING_ARG();

	char *e = getenv(first->string);
	if (e == NULL) return nil;
	return newStringWithLength(e, strlen(e), GC_ROOTS);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x10(%rax), %rdi
cmpl $0x1, (%rdi)
jne 0x615d
movq %rsi, %rbx
addq $0x10, %rdi
callq 0x2030
testq %rax, %rax
je 0x614e
movq %rax, %r14
movq %rax, %rdi
callq 0x20e0
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x494c
movq 0x70b3(%rip), %rax      # 0xd208
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x257b(%rip), %rsi      # 0x86df
xorl %eax, %eax
callq 0x4380
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]zepl/lisp.c
// Function: e_search_forward
Object *e_search_forward(Object ** args, GC_PARAM)
{
	Object *first = (*args)->car;
	Object *second = (*args)->cdr->car;

	if (first->type != TYPE_NUMBER)
	    exceptionWithObject(first, "is not a number");
	if (second->type != TYPE_STRING)
	    exceptionWithObject(first, "is not a string");

	double num = search_forward_curbp((point_t)first->number, second->string);
	return newNumber(num, GC_ROOTS);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rax
movq 0x10(%rax), %rdi
cmpl $0x0, (%rdi)
jne 0x61c6
movq %rsi, %rbx
movq 0x18(%rax), %rax
movq 0x10(%rax), %rsi
cmpl $0x1, (%rsi)
jne 0x61cf
cvttsd2si 0x10(%rdi), %rdi
addq $0x10, %rsi
callq 0x37fb
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
movl $0x28, %esi
xorl %edi, %edi
movq %rbx, %rdx
callq 0x4814
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
addq $0x10, %rsp
popq %rbx
retq
leaq 0x2522(%rip), %rsi      # 0x86ef
jmp 0x61d6
leaq 0x2509(%rip), %rsi      # 0x86df
xorl %eax, %eax
callq 0x4380
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]zepl/lisp.c
// Function: e_getch
Object *e_getch(Object ** args, GC_PARAM)
{
	char ch[2];
	ch[0] = (unsigned char)getch();
	ch[1] = '\0';
	return newStringWithLength(ch, 1, GC_ROOTS);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq 0x6de4(%rip), %rax      # 0xcfd0
movq (%rax), %rdi
callq 0x20c0
leaq 0xe(%rsp), %rdi
movb %al, (%rdi)
movb $0x0, 0x1(%rdi)
movl $0x1, %esi
movq %rbx, %rdx
callq 0x494c
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]zepl/lisp.c
// Function: asciiToString
Object *asciiToString(Object ** args, GC_PARAM)
{
	char ch[2];
	Object *first = (*args)->car;

	if (first->type != TYPE_NUMBER)
	    exceptionWithObject(first, "is not a number");
	if (first->type < 0 || first->type > 255)
	    exceptionWithObject(first, "is not in range 0-255");

	ch[0] = (unsigned char)first->number;
	ch[1] = '\0';
	return newStringWithLength(ch, 1, GC_ROOTS);
}

// Assembly:
pushq %rax
movq (%rdi), %rax
movq 0x10(%rax), %rdi
cmpl $0x0, (%rdi)
jne 0x623e
movq %rsi, %rdx
cvttsd2si 0x10(%rdi), %eax
leaq 0x6(%rsp), %rdi
movb %al, (%rdi)
movb $0x0, 0x1(%rdi)
movl $0x1, %esi
callq 0x494c
popq %rcx
retq
leaq 0x24aa(%rip), %rsi      # 0x86ef
xorl %eax, %eax
callq 0x4380
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]zepl/lisp.c
// Function: asciiToNumber
Object *asciiToNumber(Object ** args, GC_PARAM)
{
	Object *first = (*args)->car;

	if (first->type != TYPE_STRING)
	    exceptionWithObject(first, "is not a number");
	if (strlen(first->string) < 1)
	    exceptionWithObject(first, "is empty");

	return newNumber((double)*first->string, GC_ROOTS);
}

// Assembly:
pushq %rax
movq (%rdi), %rax
movq 0x10(%rax), %rdi
cmpl $0x1, (%rdi)
jne 0x6287
movb 0x10(%rdi), %al
testb %al, %al
je 0x6290
movq %rsi, %rdx
movsbl %al, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, (%rsp)
movl $0x28, %esi
xorl %edi, %edi
callq 0x4814
movsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
popq %rcx
retq
leaq 0x2461(%rip), %rsi      # 0x86ef
jmp 0x6297
leaq 0x24a4(%rip), %rsi      # 0x873b
xorl %eax, %eax
callq 0x4380
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]zepl/lisp.c
// Function: e_load
Object *e_load(Object ** args, GC_PARAM)
{
	int fd;
	char ebuf[81];
	Object *first = (*args)->car;
	if (first->type != TYPE_STRING)
	    exceptionWithObject(first, "is not a string");

	if ((fd = open(first->string, O_RDONLY)) == -1) {
		snprintf(ebuf, 80, "failed to open %s\n", first->string);
		ebuf[80] ='\0';
		writeString(ebuf, &ostream);
		close(fd);
		return nil;
	}

	char *out = load_file(fd);
	close(fd);
	return (NULL == strstr(out, "error:")) ? t : nil;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq (%rdi), %rax
movq 0x10(%rax), %rbx
cmpl $0x1, (%rbx)
jne 0x637c
addq $0x10, %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x2260
cmpl $-0x1, %eax
je 0x6332
movl %eax, %ebp
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, 0x20(%rdx)
movq $0x0, 0x30(%rdx)
movl $0x1, (%rdx)
movl %eax, 0x10(%rdx)
movq 0x8c42(%rip), %rsi      # 0xef38
callq 0x7552
movq 0x6ed6(%rip), %rbx      # 0xd1d8
movl %ebp, %edi
callq 0x2150
leaq 0x1e9f(%rip), %rsi      # 0x81af
movq %rbx, %rdi
callq 0x2330
testq %rax, %rax
leaq 0x6eee(%rip), %rax      # 0xd210
leaq 0x6edf(%rip), %rcx      # 0xd208
cmoveq %rax, %rcx
movq (%rcx), %rax
jmp 0x6373
leaq 0x240b(%rip), %rdx      # 0x8744
movq %rsp, %r14
movl $0x50, %esi
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2120
movb $0x0, 0x50(%r14)
leaq 0x6e76(%rip), %rsi      # 0xd1d0
movq %r14, %rdi
callq 0x4208
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2150
movq 0x6e95(%rip), %rax      # 0xd208
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x235c(%rip), %rsi      # 0x86df
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4380
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]zepl/lisp.c
// Function: load_file
char *load_file(int infd)
{
	//debug("load_file fd=%d\n", infd);
	Stream input_stream = { .type = STREAM_TYPE_FILE, .fd = -1 };
	set_stream_file(&input_stream, infd);
	load_file_body(theEnv, theRoot, &input_stream);
	return ostream.buffer;
}

// Assembly:
subq $0x38, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, 0x20(%rdx)
movq $0x0, 0x30(%rdx)
movl $0x1, (%rdx)
movl %edi, 0x10(%rdx)
movq 0x8b7e(%rip), %rsi      # 0xef38
callq 0x7552
movq 0x6e12(%rip), %rax      # 0xd1d8
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]zepl/lisp.c
// Function: e_set_point
Object *e_set_point(Object ** args, GC_PARAM)
{
	Object *first = (*args)->car;
	if (first->type != TYPE_NUMBER)
	    exceptionWithObject(first, "is not a number");
	set_point(first->number);
	return t;
}

// Assembly:
pushq %rax
movq (%rdi), %rax
movq 0x10(%rax), %rdi
cmpl $0x0, (%rdi)
jne 0x6448
cvttsd2si 0x10(%rdi), %rdi
callq 0x3724
movq 0x6dca(%rip), %rax      # 0xd210
popq %rcx
retq
leaq 0x22a0(%rip), %rsi      # 0x86ef
xorl %eax, %eax
callq 0x4380
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]zepl/lisp.c
// Function: evalIf
Object *evalIf(Object ** args, Object ** env, GC_PARAM)
{
	GC_TRACE(gcObject, (*args)->car);

	if (evalExpr(gcObject, env, GC_ROOTS) != nil)
		return (*args)->cdr->car;
	else if ((*args)->cdr->cdr != nil)
		return (*args)->cdr->cdr->car;
	else
		return nil;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rdi
movl $0x3, -0x10(%rdi)
movq $0x0, -0x8(%rdi)
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0x8(%rsp), %rdx
callq 0x6b25
movq %rax, %rcx
movq 0x62bd(%rip), %rax      # 0xd208
movq (%rbx), %rdx
movq 0x18(%rdx), %rdx
cmpq %rax, %rcx
jne 0x6f60
movq 0x18(%rdx), %rdx
cmpq %rcx, %rdx
je 0x6f64
movq 0x10(%rdx), %rax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]zepl/lisp.c
// Function: evalCond
Object *evalCond(Object ** args, Object ** env, GC_PARAM)
{
	if (*args == nil)
		return nil;
	else if ((*args)->car->type != TYPE_CONS)
		exceptionWithObject((*args)->car, "is not a list");
	else {
		GC_TRACE(gcCar, (*args)->car->car);
		GC_TRACE(gcCdr, (*args)->car->cdr);

		if ((*gcCar = evalExpr(gcCar, env, GC_ROOTS)) != nil)
			return (*gcCdr != nil) ? evalProgn(gcCdr, env, GC_ROOTS) : *gcCar;
		else {
			GC_TRACE(gcArgs, (*args)->cdr);
			return evalCond(gcArgs, env, GC_ROOTS);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq (%rdi), %rcx
movq 0x6289(%rip), %rax      # 0xd208
cmpq %rax, %rcx
je 0x703b
movq %rdi, %r14
movq 0x10(%rcx), %rdi
cmpl $0x3, (%rdi)
jne 0x7047
movq %rsi, %rbx
movl $0x3, %ecx
leaq 0x60(%rsp), %rax
movl %ecx, -0x10(%rax)
xorl %esi, %esi
movq %rsi, -0x8(%rax)
movq 0x10(%rdi), %r8
movq %r8, (%rax)
movq %rdx, 0x8(%rax)
movq %rsp, %r15
movl %ecx, (%r15)
movq %rsi, 0x8(%r15)
movq 0x18(%rdi), %rcx
movq %rcx, 0x10(%r15)
leaq 0x50(%rsp), %r12
movq %r12, 0x18(%r15)
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x6b25
movq %rax, 0x10(%r12)
movq 0x621a(%rip), %rcx      # 0xd208
cmpq %rcx, %rax
je 0x700c
cmpq %rcx, 0x10(%rsp)
je 0x703b
leaq 0x10(%rsp), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x6e85
jmp 0x703b
leaq 0x38(%rsp), %rdi
movl $0x3, -0x10(%rdi)
movq $0x0, -0x8(%rdi)
movq (%r14), %rax
movq 0x18(%rax), %rax
movq %rax, (%rdi)
movq %r15, 0x8(%rdi)
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0x6f6a
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x14a9(%rip), %rsi      # 0x84f7
xorl %eax, %eax
callq 0x4380
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]zepl/lisp.c
// Function: expandMacro
Object *expandMacro(Object ** macro, Object ** args, GC_PARAM)
{
	GC_TRACE(gcEnv, newEnv(macro, args, GC_ROOTS));
	GC_TRACE(gcBody, (*macro)->body);

	GC_TRACE(gcObject, evalProgn(gcBody, gcEnv, GC_ROOTS));
	*gcObject = evalExpr(gcObject, gcEnv, GC_ROOTS);

	return *gcObject;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %r14
movq %rdi, %r15
movl $0x3, %ebp
leaq 0x68(%rsp), %rbx
movl %ebp, -0x10(%rbx)
xorl %r12d, %r12d
movq %r12, -0x8(%rbx)
callq 0x4cca
movq %rax, (%rbx)
movq %r14, 0x8(%rbx)
leaq 0x40(%rsp), %rdi
movl %ebp, -0x10(%rdi)
movq %r12, -0x8(%rdi)
movq (%r15), %rax
movq 0x18(%rax), %rax
movq %rax, (%rdi)
leaq 0x58(%rsp), %rax
movq %rax, 0x8(%rdi)
leaq 0x18(%rsp), %r14
movl %ebp, -0x10(%r14)
movq %r12, -0x8(%r14)
leaq 0x30(%rsp), %r15
movq %rbx, %rsi
movq %r15, %rdx
callq 0x6e85
movq %rax, (%r14)
movq %r15, 0x8(%r14)
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6b25
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]zepl/lisp.c
// Function: expandMacroTo
Object *expandMacroTo(Object ** macro, Object ** args, Object ** cons, GC_PARAM)
{
	GC_TRACE(gcObject, expandMacro(macro, args, GC_ROOTS));

	if ((*gcObject)->type == TYPE_CONS) {
		(*cons)->car = (*gcObject)->car;
		(*cons)->cdr = (*gcObject)->cdr;
	} else {
		(*cons)->car = newSymbol("progn", GC_ROOTS);
		(*cons)->cdr = newCons(gcObject, &nil, GC_ROOTS);
	}

	return *cons;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movl $0x3, (%rsp)
movq $0x0, 0x8(%rsp)
movq %rcx, %rdx
callq 0x7107
movq %rax, 0x10(%rsp)
movq %r14, 0x18(%rsp)
cmpl $0x3, (%rax)
jne 0x71e4
movq 0x10(%rax), %rcx
movq (%rbx), %rdx
movq %rcx, 0x10(%rdx)
movq 0x18(%rax), %rax
jmp 0x7227
leaq 0x1571(%rip), %rdi      # 0x875c
movq %rsp, %r14
movl $0x5, %esi
movq %r14, %rdx
callq 0x4ac2
movq (%rbx), %rcx
movq %rax, 0x10(%rcx)
movl $0x28, %esi
movl $0x3, %edi
movq %r14, %rdx
callq 0x4814
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rax)
movq 0x5fe5(%rip), %rcx      # 0xd208
movq %rcx, 0x18(%rax)
movq (%rbx), %rcx
movq %rax, 0x18(%rcx)
movq (%rbx), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]zepl/lisp.c
// Function: evalList
Object *evalList(Object ** args, Object ** env, GC_PARAM)
{
	if ((*args)->type != TYPE_CONS)
		return evalExpr(args, env, GC_ROOTS);
	else {
		GC_TRACE(gcObject, (*args)->car);
		GC_TRACE(gcArgs, (*args)->cdr);

		*gcObject = evalExpr(gcObject, env, GC_ROOTS);
		*gcArgs = evalList(gcArgs, env, GC_ROOTS);

		return newCons(gcObject, gcArgs, GC_ROOTS);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq (%rdi), %rax
cmpl $0x3, (%rax)
jne 0x72e4
movl $0x3, %ecx
leaq 0x40(%rsp), %rdi
movl %ecx, -0x10(%rdi)
xorl %esi, %esi
movq %rsi, -0x8(%rdi)
movq 0x10(%rax), %r8
movq %r8, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0x18(%rsp), %r14
movl %ecx, -0x10(%r14)
movq %rsi, -0x8(%r14)
movq 0x18(%rax), %rax
movq %rax, (%r14)
leaq 0x30(%rsp), %r12
movq %r12, 0x8(%r14)
leaq 0x8(%rsp), %r15
movq %rbx, %rsi
movq %r15, %rdx
callq 0x6b25
movq %rax, 0x10(%r12)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x7239
movq %rax, 0x10(%r15)
movl $0x28, %esi
movl $0x3, %edi
movq %r15, %rdx
callq 0x4814
movq 0x10(%r12), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%r15), %rcx
movq %rcx, 0x18(%rax)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rsi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6b25