LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
callq 0x4d60
cmpl $-0x1, %eax
je 0x4e4d
pushq $0x3
popq %rbp
leaq 0x38(%rsp), %rbx
movl %ebp, -0x10(%rbx)
andq $0x0, -0x8(%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0x4926
movq %rax, (%rbx)
movq %r12, 0x8(%rbx)
leaq 0x10(%rsp), %r15
movl %ebp, -0x10(%r15)
andq $0x0, -0x8(%r15)
leaq 0x28(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x4e60
movq %rax, (%r15)
movq %r12, 0x8(%r15)
leaq 0x73e8(%rip), %rsi      # 0xc208
movq %rsp, %r14
movq %r15, %rdi
movq %r14, %rdx
callq 0x4825
movq %rax, 0x10(%r14)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4825
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2722(%rip), %rsi      # 0x7576
xorl %edi, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0x4186
// File: /workspace/github_c_makefile_star2_O2/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 0x4d1c
cmpl $-0x1, %eax
je 0x4eb9
movl %eax, %ebp
cmpl $0x22, %eax
je 0x4e9b
cmpl $0x28, %ebp
je 0x4eaa
cmpl $0x27, %ebp
jne 0x4ec0
leaq 0x27e0(%rip), %rsi      # 0x766c
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x4db3
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x4f1a
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x5109
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl %ebp, %edi
callq 0x4f96
testl %eax, %eax
je 0x4f08
cmpl $0x2e, %ebp
jne 0x4ee3
movq %r14, %rdi
callq 0x4cf6
movl %eax, %edi
callq 0x4f96
testl %eax, %eax
je 0x4f08
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 0x4fcd
leaq 0x2763(%rip), %rsi      # 0x7672
xorl %edi, %edi
movl %ebp, %edx
xorl %eax, %eax
callq 0x4186
// File: /workspace/github_c_makefile_star2_O2/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 0x4b0e
cmpl $0x22, %eax
je 0x4f41
cmpl $-0x1, %eax
jne 0x4f47
jmp 0x4f79
testb $0x1, %bpl
je 0x4f56
cmpl $0x5c, %eax
sete %al
xorb $0x1, %bpl
andb %al, %bpl
jmp 0x4f2d
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 0x470b
movl 0x28(%r14), %edx
subl %ebx, %edx
addq 0x8(%r14), %rbx
leaq 0x260b(%rip), %rsi      # 0x7595
xorl %edi, %edi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x4186
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq 0x28(%rdi), %r14
callq 0x4cf6
cmpl $0x2d, %eax
je 0x4ff0
movl %eax, %ebp
cmpl $0x2b, %eax
jne 0x5002
movq %r15, %rdi
callq 0x4b0e
movq %r15, %rdi
callq 0x4cf6
movl %eax, %ebp
callq 0x2340
movq %rax, %r12
cmpl $0x2e, %ebp
jne 0x5014
pushq $0x2e
popq %rax
jmp 0x5022
movq (%r12), %rcx
movslq %ebp, %rax
testb $0x8, 0x1(%rcx,%rax,2)
je 0x5086
movq (%r12), %rcx
testb $0x8, 0x1(%rcx,%rax,2)
je 0x503e
movq 0x6f84(%rip), %rsi      # 0xbfb8
movq %r15, %rdi
callq 0x4d86
movl %eax, %ebp
movl %ebp, %edi
callq 0x4f96
testl %eax, %eax
je 0x50b3
cmpl $0x2e, %ebp
jne 0x5086
movq %r15, %rdi
callq 0x4b0e
movq (%r12), %r12
movq %r15, %rdi
callq 0x4cf6
cltq
testb $0x8, 0x1(%r12,%rax,2)
je 0x5086
movq 0x6f45(%rip), %rsi      # 0xbfb8
movq %r15, %rdi
callq 0x4d86
movl %eax, %edi
callq 0x4f96
testl %eax, %eax
je 0x50d9
leaq -0xf7(%rip), %rsi       # 0x4f96
movq %r15, %rdi
callq 0x4d86
movq 0x8(%r15), %rdi
addq %r14, %rdi
movq 0x28(%r15), %rsi
subq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4850
addq 0x8(%r15), %r14
pushq $0xa
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x21d0
cvtsi2sd %rax, %xmm0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x46dc
addq 0x8(%r15), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x2090
jmp 0x50c9
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]zepl/lisp.c
// Function: readList
Object *readList(Stream * stream, GC_PARAM)
{
	GC_TRACE(gcList, nil);
	GC_TRACE(gcLast, nil);

	for (;;) {
		int ch = readNext(stream);
		if (ch == EOF)
			exception("unexpected end of stream in list");
		else if (ch == ')')
			return reverseList(*gcList);
		else if (ch == '.' && !isSymbolChar(streamPeek(stream))) {
			if (*gcLast == nil)
				exception("unexpected dot at start of list");
			if ((ch = peekNext(stream)) == ')')
				exception("expected object at end of dotted list");
			if (!(*gcLast = readExpr(stream, GC_ROOTS)))
				exception("unexpected end of stream in dotted list");
			if ((ch = peekNext(stream)) != ')')
				exception("unexpected object at end of dotted list");
			readNext(stream);
			Object *list = reverseList(*gcList);
			(*gcList)->cdr = *gcLast;

			return list;
		} else {
			*gcLast = readExpr(streamSeek(stream, -1), GC_ROOTS);
			*gcList = newCons(gcLast, gcList, GC_ROOTS);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
pushq $0x3
popq %rax
leaq 0x38(%rsp), %r14
movl %eax, -0x10(%r14)
andq $0x0, -0x8(%r14)
movq 0x70d7(%rip), %rcx      # 0xc208
movq %rcx, (%r14)
movq %rsi, 0x8(%r14)
leaq 0x10(%rsp), %r15
movl %eax, -0x10(%r15)
andq $0x0, -0x8(%r15)
movq %rcx, (%r15)
leaq 0x28(%rsp), %rax
movq %rax, 0x8(%r15)
xorl %r13d, %r13d
movq %rsp, %r12
movq %rbx, %rdi
callq 0x4d1c
cmpl $0x2e, %eax
je 0x5174
cmpl $0x29, %eax
je 0x51c0
cmpl $-0x1, %eax
jne 0x5187
jmp 0x5239
movq %rbx, %rdi
callq 0x4cf6
movl %eax, %edi
callq 0x4f96
testl %eax, %eax
je 0x51cc
movq 0x28(%rbx), %rax
leaq -0x1(%rax), %rcx
cmpq $0x2, %rax
cmovlq %r13, %rcx
movq %rcx, 0x28(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4e60
movq %rax, 0x10(%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4825
movq %rax, 0x38(%rsp)
jmp 0x5158
movq 0x38(%rsp), %rdi
callq 0x50e9
jmp 0x522b
movq 0x10(%rsp), %rax
cmpq 0x7030(%rip), %rax      # 0xc208
je 0x5249
movq %rbx, %rdi
callq 0x4d60
cmpl $0x29, %eax
je 0x5252
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e60
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x525b
movq %rbx, %rdi
callq 0x4d60
cmpl $0x29, %eax
jne 0x5264
movq %rbx, %rdi
callq 0x4d1c
movq 0x38(%rsp), %rdi
callq 0x50e9
movq 0x10(%rsp), %rcx
movq 0x38(%rsp), %rdx
movq %rcx, 0x18(%rdx)
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x239b(%rip), %rsi      # 0x75db
xorl %edi, %edi
xorl %eax, %eax
callq 0x4186
leaq 0x23ac(%rip), %rsi      # 0x75fc
jmp 0x5240
leaq 0x23ed(%rip), %rsi      # 0x7646
jmp 0x5240
leaq 0x23ba(%rip), %rsi      # 0x761c
jmp 0x5240
leaq 0x23d9(%rip), %rsi      # 0x7644
jmp 0x5240
// File: /workspace/github_c_makefile_star2_O2/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 0x6f93(%rip), %rcx      # 0xc208
cmpq %rcx, %rsi
je 0x52aa
leaq 0x20(%rsi), %rax
movq %rsi, %rdx
movq (%rax), %rax
movq 0x18(%rdx), %rdx
cmpl $0x3, (%rdx)
jne 0x5299
cmpq %rdi, 0x10(%rdx)
je 0x52a4
addq $0x18, %rax
jmp 0x5281
cmpq %rdi, %rdx
je 0x52a8
movq 0x10(%rsi), %rsi
jmp 0x5275
movq 0x10(%rax), %rax
popq %rcx
retq
leaq 0x2419(%rip), %rsi      # 0x76ca
xorl %eax, %eax
callq 0x4186
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x8(%rsp), %r12
movl $0x3, (%r12)
andq $0x0, 0x8(%r12)
leaq 0x6f20(%rip), %r13      # 0xc208
movq %r13, %rsi
movq %rcx, %rdx
callq 0x4825
movq %rax, 0x10(%r12)
movq %r15, 0x18(%r12)
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x4825
movq (%r14), %rcx
movq 0x18(%rcx), %rcx
movq 0x10(%r12), %rdx
movq %rcx, 0x18(%rdx)
movq (%r14), %rcx
movq %rdx, 0x18(%rcx)
movq (%r14), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq (%r14), %rcx
movq %rax, 0x20(%rcx)
movq (%rbx), %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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)
andq $0x0, -0x8(%rdx)
movq (%rax), %rax
movq %rax, (%rdx)
movq %rcx, 0x8(%rdx)
movq 0x6e9a(%rip), %rcx      # 0xc208
movq 0x18(%rax), %r9
leaq 0x20(%rax), %r8
cmpl $0x3, (%r9)
jne 0x5397
movq (%r8), %r8
movq (%rdi), %r10
cmpq %r10, 0x10(%r9)
je 0x53a7
movq 0x18(%r9), %r9
cmpq %r10, %r9
je 0x53b0
addq $0x18, %r8
jmp 0x5376
movq 0x10(%rax), %rax
cmpq %rcx, %rax
je 0x53bc
movq %rax, 0x10(%rsp)
jmp 0x536e
movq (%rsi), %rax
movq %rax, 0x10(%r8)
jmp 0x53b7
movq (%rsi), %rax
movq %rax, 0x18(%r8)
addq $0x28, %rsp
retq
movq %rsp, %rcx
callq 0x52b8
jmp 0x53b7
// File: /workspace/github_c_makefile_star2_O2/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 0x541b
testl %eax, %eax
jne 0x5431
cmpl $0x0, (%rsi)
jne 0x5431
movsd 0x10(%rsi), %xmm0
cmpeqsd 0x10(%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x5437
cmpl $0x1, (%rsi)
jne 0x5431
addq $0x10, %rdi
addq $0x10, %rsi
callq 0x2190
testl %eax, %eax
jmp 0x5434
cmpq %rsi, %rdi
sete %al
leaq 0x6dd2(%rip), %rcx      # 0xc210
leaq 0x6dc3(%rip), %rdx      # 0xc208
testb %al, %al
cmovneq %rcx, %rdx
movq (%rdx), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6daa(%rip), %rax      # 0xc208
cmpq %rax, %rdi
je 0x546c
cmpl $0x3, (%rdi)
jne 0x546d
movq 0x10(%rdi), %rax
retq
pushq %rax
leaq 0x207a(%rip), %rsi      # 0x74ef
xorl %eax, %eax
callq 0x4186
// File: /workspace/github_c_makefile_star2_O2/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 0x6d7e(%rip), %rax      # 0xc208
cmpq %rax, %rdi
je 0x5498
cmpl $0x3, (%rdi)
jne 0x5499
movq 0x18(%rdi), %rax
retq
pushq %rax
leaq 0x204e(%rip), %rsi      # 0x74ef
xorl %eax, %eax
callq 0x4186
// File: /workspace/github_c_makefile_star2_O2/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 0x6cc5(%rip), %r14      # 0xc1d0
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x4158
movq (%rbx), %rax
movq 0x10(%rax), %rdi
pushq $0x1
popq %rsi
movq %r14, %rdx
callq 0x4287
pushq $0x20
popq %rdi
movq %r14, %rsi
callq 0x4158
movq (%rbx), %rax
movq 0x10(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5836
movq 0x18(%rax), %rax
movq 0x10(%rax), %r14
cmpl $0x1, (%r14)
jne 0x5842
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 0x470b
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 0x1e9a(%rip), %rsi      # 0x76d7
movq %r15, %rdi
jmp 0x584c
leaq 0x1e8e(%rip), %rsi      # 0x76d7
movq %r14, %rdi
xorl %eax, %eax
callq 0x4186
// File: /workspace/github_c_makefile_star2_O2/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 0x5933
movq 0x18(%rax), %rax
movq 0x10(%rax), %r15
cmpl $0x0, (%r15)
jne 0x593f
movq 0x18(%rax), %rax
movq 0x10(%rax), %r12
cmpl $0x0, (%r12)
jne 0x5948
cvttsd2si 0x10(%r15), %ebp
testl %ebp, %ebp
js 0x592a
movq %rsi, %rbx
cvttsd2si 0x10(%r12), %r13d
addq $0x10, %r14
movq %r14, %rdi
callq 0x20e0
cmpl %ebp, %eax
jle 0x592a
testl %r13d, %r13d
js 0x5951
cmpl %r13d, %eax
jle 0x5951
subl %ebp, %r13d
jb 0x595d
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 0x470b
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 0x1dc6(%rip), %rsi      # 0x76f7
jmp 0x5964
leaq 0x1d9d(%rip), %rsi      # 0x76d7
movq %r14, %rdi
jmp 0x5967
leaq 0x1da1(%rip), %rsi      # 0x76e7
jmp 0x5964
leaq 0x1d98(%rip), %rsi      # 0x76e7
jmp 0x5958
leaq 0x1d9f(%rip), %rsi      # 0x76f7
movq %r12, %rdi
jmp 0x5967
leaq 0x1da4(%rip), %rsi      # 0x7708
movq %r15, %rdi
xorl %eax, %eax
callq 0x4186
// File: /workspace/github_c_makefile_star2_O2/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
movq (%rdi), %rax
movq 0x10(%rax), %rdi
cmpl $0x1, (%rdi)
jne 0x59b1
movq %rsi, %rbx
addq $0x10, %rdi
callq 0x20e0
movq %rax, %xmm1
punpckldq 0x1acc(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1ad4(%rip), %xmm1     # 0x7470
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
popq %rbx
jmp 0x46dc
leaq 0x1d1f(%rip), %rsi      # 0x76d7
xorl %eax, %eax
callq 0x4186
// File: /workspace/github_c_makefile_star2_O2/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
movq (%rdi), %rax
movq 0x10(%rax), %rdi
cmpl $0x1, (%rdi)
jne 0x5a82
movq %rsi, %rbx
addq $0x10, %rdi
xorl %esi, %esi
callq 0x2090
movq %rbx, %rdi
popq %rbx
jmp 0x46dc
leaq 0x1c4e(%rip), %rsi      # 0x76d7
xorl %eax, %eax
callq 0x4186
// File: /workspace/github_c_makefile_star2_O2/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 0x5b02
movq %rsi, %rbx
movsd 0x10(%rdi), %xmm0
cvttsd2si %xmm0, %rdx
cvtsi2sd %rdx, %xmm1
ucomisd %xmm1, %xmm0
jne 0x5ad0
jp 0x5ad0
leaq 0x1c67(%rip), %rsi      # 0x772b
movq %rsp, %rdi
xorl %eax, %eax
callq 0x22b0
jmp 0x5ae1
leaq 0x1c58(%rip), %rsi      # 0x772f
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 0x470b
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x1bde(%rip), %rsi      # 0x76e7
xorl %eax, %eax
callq 0x4186
// File: /workspace/github_c_makefile_star2_O2/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 0x5b60
movq %rsi, %rbx
addq $0x10, %rdi
callq 0x2030
testq %rax, %rax
je 0x5b51
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 0x470b
movq 0x66b0(%rip), %rax      # 0xc208
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1b70(%rip), %rsi      # 0x76d7
xorl %eax, %eax
callq 0x4186
// File: /workspace/github_c_makefile_star2_O2/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
movq (%rdi), %rax
movq 0x10(%rax), %rdi
cmpl $0x0, (%rdi)
jne 0x5ba8
movq %rsi, %rbx
movq 0x18(%rax), %rax
movq 0x10(%rax), %rsi
cmpl $0x1, (%rsi)
jne 0x5bb1
cvttsd2si 0x10(%rdi), %rdi
addq $0x10, %rsi
callq 0x3697
cvtsi2sd %rax, %xmm0
movq %rbx, %rdi
popq %rbx
jmp 0x46dc
leaq 0x1b38(%rip), %rsi      # 0x76e7
jmp 0x5bb8
leaq 0x1b1f(%rip), %rsi      # 0x76d7
xorl %eax, %eax
callq 0x4186
// File: /workspace/github_c_makefile_star2_O2/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 0x6402(%rip), %rax      # 0xbfd0
movq (%rax), %rdi
callq 0x20c0
leaq 0xe(%rsp), %rdi
movb %al, (%rdi)
movb $0x0, 0x1(%rdi)
pushq $0x1
popq %rsi
movq %rbx, %rdx
callq 0x470b
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5c1c
movq %rsi, %rdx
cvttsd2si 0x10(%rdi), %eax
leaq 0x6(%rsp), %rdi
movb %al, (%rdi)
movb $0x0, 0x1(%rdi)
pushq $0x1
popq %rsi
callq 0x470b
popq %rcx
retq
leaq 0x1ac4(%rip), %rsi      # 0x76e7
xorl %eax, %eax
callq 0x4186
// File: /workspace/github_c_makefile_star2_O2/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 0x5c4e
movb 0x10(%rdi), %al
testb %al, %al
je 0x5c57
movsbl %al, %eax
cvtsi2sd %eax, %xmm0
movq %rsi, %rdi
popq %rax
jmp 0x46dc
leaq 0x1a92(%rip), %rsi      # 0x76e7
jmp 0x5c5e
leaq 0x1ad5(%rip), %rsi      # 0x7733
xorl %eax, %eax
callq 0x4186
// File: /workspace/github_c_makefile_star2_O2/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 0x5d14
addq $0x10, %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x2260
cmpl $-0x1, %eax
je 0x5cce
movl %eax, %ebp
movl %eax, %edi
callq 0x5d25
movq %rax, %rbx
movl %ebp, %edi
callq 0x2150
leaq 0x1503(%rip), %rsi      # 0x71af
movq %rbx, %rdi
callq 0x2330
testq %rax, %rax
leaq 0x6552(%rip), %rax      # 0xc210
leaq 0x6543(%rip), %rcx      # 0xc208
cmoveq %rax, %rcx
movq (%rcx), %rax
jmp 0x5d0b
leaq 0x1a67(%rip), %rdx      # 0x773c
movq %rsp, %r14
pushq $0x50
popq %rsi
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2120
movb $0x0, 0x50(%r14)
leaq 0x64dc(%rip), %rsi      # 0xc1d0
movq %r14, %rdi
callq 0x4010
pushq $-0x1
popq %rdi
callq 0x2150
movq 0x64fd(%rip), %rax      # 0xc208
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x19bc(%rip), %rsi      # 0x76d7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4186
// File: /workspace/github_c_makefile_star2_O2/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)
andq $0x0, 0x30(%rdx)
movaps %xmm0, 0x20(%rdx)
movl $0x1, (%rdx)
movl %edi, 0x10(%rdx)
movq 0x81e9(%rip), %rsi      # 0xdf38
callq 0x6ced
movq 0x647d(%rip), %rax      # 0xc1d8
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5ddd
cvttsd2si 0x10(%rdi), %rdi
callq 0x35a4
movq 0x6435(%rip), %rax      # 0xc210
popq %rcx
retq
leaq 0x1903(%rip), %rsi      # 0x76e7
xorl %eax, %eax
callq 0x4186
// File: /workspace/github_c_makefile_star2_O2/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)
andq $0x0, -0x8(%rdi)
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0x8(%rsp), %rdx
callq 0x63e3
movq %rax, %rcx
movq 0x5aa0(%rip), %rax      # 0xc208
movq (%rbx), %rdx
movq 0x18(%rdx), %rdx
cmpq %rax, %rcx
jne 0x677d
movq 0x18(%rdx), %rdx
cmpq %rcx, %rdx
je 0x6781
movq 0x10(%rdx), %rax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5a6c(%rip), %rax      # 0xc208
cmpq %rax, %rcx
je 0x6853
movq %rdi, %r14
movq 0x10(%rcx), %rdi
cmpl $0x3, (%rdi)
jne 0x685f
movq %rsi, %rbx
pushq $0x3
popq %rcx
leaq 0x60(%rsp), %rax
movl %ecx, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq 0x10(%rdi), %rsi
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
movq %rsp, %r15
movl %ecx, (%r15)
andq $0x0, 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 0x63e3
movq %rax, 0x10(%r12)
movq 0x59ff(%rip), %rcx      # 0xc208
cmpq %rcx, %rax
je 0x6827
cmpq %rcx, 0x10(%rsp)
je 0x6853
leaq 0x10(%rsp), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x66a8
jmp 0x6853
leaq 0x38(%rsp), %rdi
movl $0x3, -0x10(%rdi)
andq $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 0x6787
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xc89(%rip), %rsi       # 0x74ef
xorl %eax, %eax
callq 0x4186
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x78, %rsp
movq %rdx, %r14
movq %rdi, %r15
pushq $0x3
popq %rbp
leaq 0x60(%rsp), %rbx
movl %ebp, -0x10(%rbx)
andq $0x0, -0x8(%rbx)
callq 0x4a2f
leaq 0x38(%rsp), %rdi
movl %ebp, -0x10(%rdi)
andq $0x0, -0x8(%rdi)
movq %rax, (%rbx)
movq %r14, 0x8(%rbx)
movq (%r15), %rax
movq 0x18(%rax), %rax
movq %rax, (%rdi)
leaq 0x50(%rsp), %rax
movq %rax, 0x8(%rdi)
leaq 0x10(%rsp), %r14
movl %ebp, -0x10(%r14)
andq $0x0, -0x8(%r14)
leaq 0x28(%rsp), %r15
movq %rbx, %rsi
movq %r15, %rdx
callq 0x66a8
movq %rax, (%r14)
movq %r15, 0x8(%r14)
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x63e3
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movl $0x3, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movq %rcx, %rdx
callq 0x691d
movq %rax, 0x18(%rsp)
movq %r14, 0x20(%rsp)
cmpl $0x3, (%rax)
jne 0x69ec
movq 0x10(%rax), %rcx
movq (%rbx), %rdx
movq %rcx, 0x10(%rdx)
movq 0x18(%rax), %rax
jmp 0x6a1e
leaq 0x18(%rsp), %r14
leaq 0xd5c(%rip), %rdi       # 0x7754
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x4926
movq (%rbx), %rcx
movq %rax, 0x10(%rcx)
leaq 0x57f5(%rip), %rsi      # 0xc208
movq %r14, %rdi
movq %r15, %rdx
callq 0x4825
movq (%rbx), %rcx
movq %rax, 0x18(%rcx)
movq (%rbx), %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq (%rdi), %rax
cmpl $0x3, (%rax)
jne 0x6ac8
pushq $0x3
popq %rcx
leaq 0x38(%rsp), %r14
movl %ecx, -0x10(%r14)
andq $0x0, -0x8(%r14)
movq 0x10(%rax), %rsi
movq %rsi, (%r14)
movq %rdx, 0x8(%r14)
leaq 0x10(%rsp), %r15
movl %ecx, -0x10(%r15)
andq $0x0, -0x8(%r15)
movq 0x18(%rax), %rax
movq %rax, (%r15)
leaq 0x28(%rsp), %r13
movq %r13, 0x8(%r15)
movq %rsp, %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x63e3
movq %rax, 0x10(%r13)
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x6a32
movq %rax, 0x10(%r12)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4825
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rbx, %rsi
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x63e3
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]zepl/lisp.c
// Function: newRootEnv
Object *newRootEnv(GC_PARAM)
{
	GC_TRACE(gcEnv, newEnv(&nil, &nil, GC_ROOTS));
	GC_TRACE(gcVar, nil);
	GC_TRACE(gcVal, nil);

	// add constants
	envSet(&nil, &nil, gcEnv, GC_ROOTS);
	envSet(&t, &t, gcEnv, GC_ROOTS);

	// add primitives
	int nPrimitives = sizeof(primitives) / sizeof(primitives[0]);

	for (int i = 0; i < nPrimitives; ++i) {
		*gcVar = newSymbol(primitives[i].name, GC_ROOTS);
		*gcVal = newPrimitive(i, primitives[i].name, GC_ROOTS);

		envSet(gcVar, gcVal, gcEnv, GC_ROOTS);
	}

	// add standard library
	Stream stream = { STREAM_TYPE_STRING,.buffer = stdlib };
	GC_TRACE(gcObject, nil);

	while (peekNext(&stream) != EOF) {
		*gcObject = nil;
		*gcObject = readExpr(&stream, GC_ROOTS);
		evalExpr(gcObject, gcEnv, GC_ROOTS);
	}

	return *gcEnv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %r14
pushq $0x3
popq %rbp
leaq 0x88(%rsp), %rbx
movl %ebp, -0x10(%rbx)
andq $0x0, -0x8(%rbx)
leaq 0x56fd(%rip), %r13      # 0xc208
movq %r13, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x4a2f
movq %rax, (%rbx)
movq %r14, 0x8(%rbx)
leaq 0x60(%rsp), %r14
movl %ebp, -0x10(%r14)
andq $0x0, -0x8(%r14)
movq 0x56d3(%rip), %rax      # 0xc208
movq %rax, (%r14)
leaq 0x38(%rsp), %r12
movl %ebp, -0x10(%r12)
leaq 0x78(%rsp), %rcx
andq $0x0, -0x8(%r12)
movq %rcx, 0x8(%r14)
movq %rax, (%r12)
leaq 0x50(%rsp), %rax
movq %rax, 0x8(%r12)
leaq 0x28(%rsp), %r15
movq %r13, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x5345
leaq 0x5694(%rip), %rdi      # 0xc210
movq %rdi, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x5345
leaq 0x568f(%rip), %rbp      # 0xc220
xorl %r13d, %r13d
cmpq $0x43, %r13
je 0x6bd9
movq (%rbp), %rdi
movq %r15, %rsi
callq 0x4926
movq %rax, 0x60(%rsp)
movq (%rbp), %rsi
movl %r13d, %edi
movq %r15, %rdx
callq 0x4a0e
movq %rax, 0x38(%rsp)
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x5345
incq %r13
addq $0x18, %rbp
jmp 0x6b94
xorps %xmm0, %xmm0
leaq 0xa0(%rsp), %r14
movaps %xmm0, (%r14)
movaps %xmm0, 0x20(%r14)
andq $0x0, 0x30(%r14)
movaps %xmm0, 0x10(%r14)
leaq 0xdce(%rip), %rax       # 0x79cc
movq %rax, 0x8(%r14)
leaq 0x10(%rsp), %r12
movl $0x3, -0x10(%r12)
andq $0x0, -0x8(%r12)
movq 0x55eb(%rip), %rax      # 0xc208
movq %rax, (%r12)
movq %r15, 0x8(%r12)
movq %rsp, %r15
movq %r14, %rdi
callq 0x4d60
cmpl $-0x1, %eax
je 0x6c62
movq 0x55cb(%rip), %rax      # 0xc208
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4e60
movq %rax, 0x10(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x63e3
jmp 0x6c29
movq 0x88(%rsp), %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]zepl/lisp.c
// Function: reset_output_stream
void reset_output_stream()
{
	Stream *stream = &ostream; /* we only want 1 output stream */
	stream->type = STREAM_TYPE_STRING;
	stream->length = 0;
	if (stream->buffer != NULL) {
		free(stream->buffer);
		stream->buffer = NULL;
	}
}

// Assembly:
andl $0x0, 0x550a(%rip)      # 0xc1d0
andq $0x0, 0x551a(%rip)      # 0xc1e8
movq 0x5503(%rip), %rdi      # 0xc1d8
testq %rdi, %rdi
je 0x6cec
pushq %rax
callq 0x2050
andq $0x0, 0x54f0(%rip)      # 0xc1d8
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]zepl/lisp.c
// Function: load_file_body
void load_file_body(Object ** env, GC_PARAM, Stream *input_stream)
{
	//debug("load_file_body\n");
	GC_TRACE(gcObject, nil);

	if (setjmp(exceptionEnv))
		return;

	while (peekNext(input_stream) != EOF) {
		*gcObject = nil;
		*gcObject = readExpr(input_stream, GC_ROOTS);
		*gcObject = evalExpr(gcObject, theEnv, GC_ROOTS);
		writeObject(*gcObject, true, &ostream);
		writeChar('\n', &ostream);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movl $0x3, (%rsp)
andq $0x0, 0x8(%rsp)
movq 0x54f6(%rip), %rax      # 0xc208
movq %rax, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
leaq 0x713d(%rip), %rdi      # 0xde60
callq 0x2180
testl %eax, %eax
je 0x6d3b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%rsp), %r14
movq %rsp, %r15
leaq 0x5486(%rip), %r12      # 0xc1d0
pushq $0x1
popq %rbp
pushq $0xa
popq %r13
movq %rbx, %rdi
callq 0x4d60
cmpl $-0x1, %eax
je 0x6d2c
movq 0x54a3(%rip), %rax      # 0xc208
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4e60
movq %rax, 0x10(%rsp)
movq 0x71af(%rip), %rsi      # 0xdf30
movq %r14, %rdi
movq %r15, %rdx
callq 0x63e3
movq %rax, 0x10(%rsp)
movq %rax, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x4287
movl %r13d, %edi
movq %r12, %rsi
callq 0x4158
jmp 0x6d51
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]zepl/lisp.c
// Function: call_lisp_body
void call_lisp_body(Object ** env, GC_PARAM, Stream *input_stream)
{
	GC_TRACE(gcObject, nil);

	for (;;) {
		if (setjmp(exceptionEnv))
			return;

		*gcObject = nil;

		if (peekNext(input_stream) == EOF) {
			writeChar('\n', &ostream);
			return;
		}

		*gcObject = readExpr(input_stream, GC_ROOTS);
		*gcObject = evalExpr(gcObject, env, GC_ROOTS);
		writeObject(*gcObject, true, &ostream);
		writeChar('\n', &ostream);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movl $0x3, -0x10(%r15)
andq $0x0, -0x8(%r15)
movq 0x5430(%rip), %rax      # 0xc208
movq %rax, (%r15)
movq %rsi, 0x8(%r15)
leaq 0x707a(%rip), %r12      # 0xde60
movq %rsp, %r13
leaq 0x53e0(%rip), %rbp      # 0xc1d0
movq %r12, %rdi
callq 0x2180
testl %eax, %eax
jne 0x6e62
movq 0x5405(%rip), %rax      # 0xc208
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
callq 0x4d60
cmpl $-0x1, %eax
je 0x6e53
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4e60
movq %rax, 0x10(%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x63e3
movq %rax, 0x10(%rsp)
movq %rax, %rdi
pushq $0x1
popq %rsi
movq %rbp, %rdx
callq 0x4287
pushq $0xa
popq %rdi
movq %rbp, %rsi
callq 0x4158
jmp 0x6df0
leaq 0x5376(%rip), %rsi      # 0xc1d0
pushq $0xa
popq %rdi
callq 0x4158
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]zepl/lisp.c
// Function: init_lisp
int init_lisp()
{
	theRoot = nil;

	//set_stream_file(&istream, STDIN_FILENO);
	set_stream_file(&ostream, STDOUT_FILENO);

	if (setjmp(exceptionEnv))
		return 1;

	symbols = nil;
	symbols = newCons(&nil, &symbols, theRoot);
	symbols = newCons(&t, &symbols, theRoot);

	temp_root.type = TYPE_CONS;
	temp_root.car = newRootEnv(theRoot);
	temp_root.cdr = theRoot;

	theEnv = &temp_root.car;
	theRoot = &temp_root;
	return 0;
}

// Assembly:
pushq %rbx
movq 0x538f(%rip), %rax      # 0xc208
movq %rax, 0x70b8(%rip)      # 0xdf38
pushq $0x1
popq %rbx
movl %ebx, 0x5347(%rip)      # 0xc1d0
movl %ebx, 0x5351(%rip)      # 0xc1e0
leaq 0x6fca(%rip), %rdi      # 0xde60
callq 0x2180
movl %ebx, %ecx
testl %eax, %eax
jne 0x6f3d
leaq 0x535c(%rip), %rdi      # 0xc208
movq 0x5355(%rip), %rax      # 0xc208
movq %rax, 0x706e(%rip)      # 0xdf28
leaq 0x7067(%rip), %rbx      # 0xdf28
movq 0x7070(%rip), %rdx      # 0xdf38
movq %rbx, %rsi
callq 0x4825
movq %rax, 0x7051(%rip)      # 0xdf28
movq 0x705a(%rip), %rdx      # 0xdf38
leaq 0x532b(%rip), %rdi      # 0xc210
movq %rbx, %rsi
callq 0x4825
movq %rax, 0x7034(%rip)      # 0xdf28
movl $0x3, 0x7042(%rip)      # 0xdf40
leaq 0x703b(%rip), %rbx      # 0xdf40
movq 0x702c(%rip), %rdi      # 0xdf38
callq 0x6add
movq %rax, 0x7038(%rip)      # 0xdf50
leaq 0x7031(%rip), %rax      # 0xdf50
movq 0x7012(%rip), %rcx      # 0xdf38
movq %rcx, 0x702b(%rip)      # 0xdf58
movq %rax, 0x6ffc(%rip)      # 0xdf30
movq %rbx, 0x6ffd(%rip)      # 0xdf38
xorl %ecx, %ecx
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]zepl/lisp.c
// Function: call_lisp
char *call_lisp(char *input)
{
	assert(input != NULL);
	Stream is = { .type = STREAM_TYPE_STRING };

	//debug("call_lisp()\n");
	set_input_stream_buffer(&is, input);
	call_lisp_body(theEnv, theRoot, &is);
	//debug("call_lisp() done\n");
	return ostream.buffer;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rsi
xorps %xmm0, %xmm0
movq %rsp, %rbx
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
andq $0x0, 0x30(%rbx)
movq %rbx, %rdi
callq 0x6c86
movq 0x6fc2(%rip), %rdi      # 0xdf30
movq 0x6fc3(%rip), %rsi      # 0xdf38
movq %rbx, %rdx
callq 0x6dab
movq 0x5254(%rip), %rax      # 0xc1d8
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/stevenmherring[P]DNS/fine-trie.c
// Function: new_leaf
struct trie_node * new_leaf (const char *string, size_t strlen, int32_t ip4_address) {
    struct trie_node *new_node = malloc(sizeof(struct trie_node));
    if (!new_node) {
      printf ("WARNING: Node memory allocation failed.  Results may be bogus.\n");
      return NULL;
    }

    assert(strlen < 64);
    assert(strlen > 0);
    new_node->next = NULL;
    new_node->strlen = strlen;
    strncpy(new_node->key, string, strlen);
    new_node->key[strlen] = '\0';
    new_node->ip4_address = ip4_address;
    new_node->children = NULL;
    int rv = pthread_mutex_init(&(new_node->lock), NULL);
    assert(rv == 0);
    rv = pthread_cond_init(&(new_node->c), NULL);
    assert(rv == 0);
    new_node->waiting = 0;
    return new_node;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movl $0xb8, %edi
callq 0x1120
movq %rax, %rbx
testq %rax, %rax
je 0x135b
cmpq $0x40, %r14
jae 0x1375
testq %r14, %r14
je 0x138e
andq $0x0, (%rbx)
movl %r14d, 0x8(%rbx)
leaq 0x18(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1050
movb $0x0, 0x18(%rbx,%r14)
movl %ebp, 0xc(%rbx)
andq $0x0, 0x10(%rbx)
leaq 0x58(%rbx), %rdi
xorl %esi, %esi
callq 0x11c0
testl %eax, %eax
jne 0x13a7
movq %rbx, %rdi
subq $-0x80, %rdi
xorl %esi, %esi
callq 0x10f0
testl %eax, %eax
jne 0x13c0
andl $0x0, 0xb0(%rbx)
jmp 0x1367
leaq 0x30b9(%rip), %rdi      # 0x441b
callq 0x1080
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d7b(%rip), %rdi      # 0x40f7
leaq 0x2c81(%rip), %rsi      # 0x4004
leaq 0x2c86(%rip), %rcx      # 0x4010
pushq $0x21
jmp 0x13d7
leaq 0x2ebc(%rip), %rdi      # 0x4251
leaq 0x2c68(%rip), %rsi      # 0x4004
leaq 0x2c6d(%rip), %rcx      # 0x4010
pushq $0x22
jmp 0x13d7
leaq 0x2c9c(%rip), %rdi      # 0x404a
leaq 0x2c4f(%rip), %rsi      # 0x4004
leaq 0x2c54(%rip), %rcx      # 0x4010
pushq $0x2a
jmp 0x13d7
leaq 0x2c83(%rip), %rdi      # 0x404a
leaq 0x2c36(%rip), %rsi      # 0x4004
leaq 0x2c3b(%rip), %rcx      # 0x4010
pushq $0x2c
popq %rdx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/stevenmherring[P]DNS/fine-trie.c
// Function: compare_keys
int compare_keys (const char *string1, int len1, const char *string2, int len2, int *pKeylen) {
    int keylen, offset1, offset2;
    keylen = len1 < len2 ? len1 : len2;
    offset1 = len1 - keylen;
    offset2 = len2 - keylen;
    assert (keylen > 0);
    if (pKeylen)
    *pKeylen = keylen;
    return strncmp(&string1[offset1], &string2[offset2], keylen);
  }

// Assembly:
cmpl %ecx, %esi
movl %ecx, %eax
cmovll %esi, %eax
testl %eax, %eax
jle 0x140d
testq %r8, %r8
je 0x13f0
movl %eax, (%r8)
subl %eax, %ecx
subl %eax, %esi
movslq %esi, %rsi
addq %rsi, %rdi
movslq %ecx, %rcx
addq %rcx, %rdx
movl %eax, %eax
movq %rdx, %rsi
movq %rax, %rdx
jmp 0x1060
pushq %rax
leaq 0x2c3d(%rip), %rdi      # 0x4052
leaq 0x2be8(%rip), %rsi      # 0x4004
leaq 0x2c3a(%rip), %rcx      # 0x405d
pushq $0x36
popq %rdx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/stevenmherring[P]DNS/fine-trie.c
// Function: init
void init(int numthreads) {
    //Initialization function, set root node to null, initialize the lock we will use for root.
    root = NULL;
    int rv = pthread_mutex_init(&root_lock, NULL);
    assert(rv == 0);
  }

// Assembly:
pushq %rax
andq $0x0, 0x5cdc(%rip)      # 0x7110
leaq 0x5cdd(%rip), %rdi      # 0x7118
xorl %esi, %esi
callq 0x11c0
testl %eax, %eax
jne 0x1448
popq %rax
retq
leaq 0x2bfb(%rip), %rdi      # 0x404a
leaq 0x2bae(%rip), %rsi      # 0x4004
leaq 0x2c3e(%rip), %rcx      # 0x409b
pushq $0x40
popq %rdx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/stevenmherring[P]DNS/fine-trie.c
// Function: search
int search  (const char *string, size_t strlen, int32_t *ip4_address) {
    //Search Controller
    //main thread communicates directly with this and this pushes us where to go.
    int32_t found;
    int rc;
    // Skip strings of length 0
    if (strlen == 0)
    return 0;
    struct trie_node *node = root;

    if(node == NULL)
    return 0;
    rc = pthread_mutex_lock(&(node->lock));
    assert(rc == 0);

    found = _search(node, string, strlen);

    if (found >= 0 && ip4_address)
    *ip4_address = found;

    return (found >= 0);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %eax, %eax
testq %rsi, %rsi
je 0x1ad2
movq 0x567e(%rip), %r12      # 0x7110
testq %r12, %r12
je 0x1ad2
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x58(%r12), %rdi
callq 0x11d0
testl %eax, %eax
jne 0x1ade
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1465
testl %eax, %eax
sets %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
jne 0x1acd
movl %eax, (%rbx)
notl %eax
shrl $0x1f, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2628(%rip), %rdi      # 0x410d
leaq 0x2518(%rip), %rsi      # 0x4004
leaq 0x2691(%rip), %rcx      # 0x4184
movl $0x127, %edx            # imm = 0x127
callq 0x10b0