LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq 0x7eb6(%rip), %rax      # 0xf220
jne 0x7379
movq 0x7ead(%rip), %rax      # 0xf220
movq %rax, -0x8(%rbp)
jmp 0x73a2
movq -0x20(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x7390
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x73a2
movq -0x20(%rbp), %rdi
leaq 0x4194(%rip), %rsi      # 0xb52f
movb $0x0, %al
callq 0x50e0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xa, %edi
leaq 0x7d74(%rip), %rsi      # 0xf1e0
callq 0x5070
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
movl $0x1, %esi
leaq 0x7d58(%rip), %rdx      # 0xf1e0
callq 0x5200
movl $0x20, %edi
leaq 0x7d47(%rip), %rsi      # 0xf1e0
callq 0x5070
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
je 0x7a9d
movq -0x18(%rbp), %rdi
leaq 0x3c81(%rip), %rsi      # 0xb717
movb $0x0, %al
callq 0x50e0
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
je 0x7ab8
movq -0x20(%rbp), %rdi
leaq 0x3c66(%rip), %rsi      # 0xb717
movb $0x0, %al
callq 0x50e0
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x20f0
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x20f0
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x2310
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %eax
addl -0x28(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x2240
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x24(%rbp), %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
movslq -0x28(%rbp), %rdx
callq 0x2210
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %eax
addl -0x28(%rbp), %eax
movslq %eax, %rsi
movq -0x10(%rbp), %rdx
callq 0x5ac0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2050
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
je 0x7d3a
movq -0x18(%rbp), %rdi
leaq 0x39e4(%rip), %rsi      # 0xb717
movb $0x0, %al
callq 0x50e0
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x20f0
movq %rax, %xmm0
movaps 0x374d(%rip), %xmm1     # 0xb4a0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x3751(%rip), %xmm1     # 0xb4b0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq -0x10(%rbp), %rdi
callq 0x5a20
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
je 0x7eea
movq -0x18(%rbp), %rdi
leaq 0x3834(%rip), %rsi      # 0xb717
movb $0x0, %al
callq 0x50e0
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20a0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rdi
callq 0x5a20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7f5a
movq -0x48(%rbp), %rdi
leaq 0x37d4(%rip), %rsi      # 0xb727
movb $0x0, %al
callq 0x50e0
movq -0x48(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x48(%rbp), %rax
cvttsd2si 0x10(%rax), %rax
cvtsi2sd %rax, %xmm1
ucomisd %xmm1, %xmm0
jne 0x7f98
jp 0x7f98
leaq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rax
cvttsd2si 0x10(%rax), %rdx
leaq 0x37dc(%rip), %rsi      # 0xb76b
movb $0x0, %al
callq 0x22d0
jmp 0x7fb3
leaq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rax
movsd 0x10(%rax), %xmm0
leaq 0x37c3(%rip), %rsi      # 0xb76f
movb $0x1, %al
callq 0x22d0
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x20f0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0x5ac0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
je 0x801a
movq -0x20(%rbp), %rdi
leaq 0x3704(%rip), %rsi      # 0xb717
movb $0x0, %al
callq 0x50e0
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x2030
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x803f
movq 0x71e7(%rip), %rax      # 0xf220
movq %rax, -0x8(%rbp)
jmp 0x8064
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20f0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x5ac0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x80bd
movq -0x18(%rbp), %rdi
leaq 0x3671(%rip), %rsi      # 0xb727
movb $0x0, %al
callq 0x50e0
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
je 0x80d8
movq -0x18(%rbp), %rdi
leaq 0x3646(%rip), %rsi      # 0xb717
movb $0x0, %al
callq 0x50e0
movq -0x18(%rbp), %rax
cvttsd2si 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
callq 0x4360
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movq -0x10(%rbp), %rdi
callq 0x5a20
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x818a
movq -0x20(%rbp), %rdi
leaq 0x35a4(%rip), %rsi      # 0xb727
movb $0x0, %al
callq 0x50e0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jb 0x819f
movq -0x20(%rbp), %rax
cmpl $0xff, (%rax)
jbe 0x81b1
movq -0x20(%rbp), %rdi
leaq 0x35c9(%rip), %rsi      # 0xb773
movb $0x0, %al
callq 0x50e0
movq -0x20(%rbp), %rax
cvttsd2si 0x10(%rax), %eax
movb %al, -0x12(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x1, %esi
callq 0x5ac0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
je 0x821a
movq -0x18(%rbp), %rdi
leaq 0x3514(%rip), %rsi      # 0xb727
movb $0x0, %al
callq 0x50e0
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x20f0
cmpq $0x1, %rax
jae 0x823f
movq -0x18(%rbp), %rdi
leaq 0x3551(%rip), %rsi      # 0xb789
movb $0x0, %al
callq 0x50e0
movq -0x18(%rbp), %rax
movsbl 0x10(%rax), %eax
cvtsi2sd %eax, %xmm0
movq -0x10(%rbp), %rdi
callq 0x5a20
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
cmpl $0x1, (%rax)
je 0x829d
movq -0x78(%rbp), %rdi
leaq 0x3481(%rip), %rsi      # 0xb717
movb $0x0, %al
callq 0x50e0
movq -0x78(%rbp), %rdi
addq $0x10, %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x2280
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
jne 0x82fe
leaq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rcx
addq $0x10, %rcx
movl $0x50, %esi
leaq 0x34c4(%rip), %rdx      # 0xb792
movb $0x0, %al
callq 0x2140
movb $0x0, -0x20(%rbp)
leaq -0x70(%rbp), %rdi
leaq 0x6efc(%rip), %rsi      # 0xf1e0
callq 0x4eb0
movl -0x1c(%rbp), %edi
callq 0x2180
movq 0x6f28(%rip), %rax      # 0xf220
movq %rax, -0x8(%rbp)
jmp 0x8355
movl -0x1c(%rbp), %edi
callq 0x8370
movq %rax, -0x80(%rbp)
movl -0x1c(%rbp), %edi
callq 0x2180
movq -0x80(%rbp), %rdi
leaq 0x2eb8(%rip), %rsi      # 0xb1d5
callq 0x2350
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x833c
movq 0x6ef5(%rip), %rax      # 0xf228
movq %rax, -0x88(%rbp)
jmp 0x834a
movq 0x6edd(%rip), %rax      # 0xf220
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x2170
movl $0x1, -0x40(%rbp)
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0xa270
movq 0x8bd4(%rip), %rdi      # 0x10f80
movq 0x8bd5(%rip), %rsi      # 0x10f88
leaq -0x40(%rbp), %rdx
callq 0xa370
movq 0x6e25(%rip), %rax      # 0xf1e8
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x84ca
movq -0x18(%rbp), %rdi
leaq 0x3264(%rip), %rsi      # 0xb727
movb $0x0, %al
callq 0x50e0
movq -0x18(%rbp), %rax
cvttsd2si 0x10(%rax), %rdi
callq 0x41e0
movq 0x6d48(%rip), %rax      # 0xf228
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x3, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x48(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x9220
cmpq 0x58da(%rip), %rax      # 0xf220
je 0x995d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9999
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
cmpq 0x58ad(%rip), %rax      # 0xf220
je 0x998e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9999
movq 0x588b(%rip), %rax      # 0xf220
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq 0x584b(%rip), %rax      # 0xf220
jne 0x99e7
movq 0x5842(%rip), %rax      # 0xf220
movq %rax, -0x8(%rbp)
jmp 0x9b59
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
cmpl $0x3, (%rax)
je 0x9a10
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
leaq 0x1b26(%rip), %rsi      # 0xb52f
movb $0x0, %al
callq 0x50e0
movl $0x3, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x48(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x3, -0x78(%rbp)
movq $0x0, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x78(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x9220
movq -0x50(%rbp), %rcx
movq %rax, (%rcx)
cmpq 0x5775(%rip), %rax      # 0xf220
je 0x9af2
movq -0x80(%rbp), %rax
movq (%rax), %rax
cmpq 0x5765(%rip), %rax      # 0xf220
je 0x9ad7
movq -0x80(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x97d0
movq %rax, -0xb8(%rbp)
jmp 0x9ae5
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9b59
movl $0x3, -0xa8(%rbp)
movq $0x0, -0xa0(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0xa8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0xb0(%rbp)
leaq -0xa8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0xb0(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x99b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x3, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x60e0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x40(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x3, -0x70(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x70(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x3, -0xa0(%rbp)
movq $0x0, -0x98(%rbp)
movq -0x78(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x97d0
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0xa0(%rbp), %rax
addq $0x10, %rax
movq %rax, -0xa8(%rbp)
leaq -0xa0(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0xa8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x9220
movq %rax, %rcx
movq -0xa8(%rbp), %rax
movq %rcx, (%rax)
movq -0xa8(%rbp), %rax
movq (%rax), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x3, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x9cd0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x48(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x50(%rbp), %rax
movq (%rax), %rax
cmpl $0x3, (%rax)
jne 0x9e82
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x9ec2
movq -0x20(%rbp), %rsi
leaq 0x191d(%rip), %rdi      # 0xb7aa
callq 0x5ec0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x5371(%rip), %rsi      # 0xf220
callq 0x5d50
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x3, (%rax)
je 0x9f0d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x9220
movq %rax, -0x8(%rbp)
jmp 0x9fcc
movl $0x3, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x48(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x3, -0x78(%rbp)
movq $0x0, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x78(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x9220
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, (%rax)
movq -0x80(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x9ed0
movq %rax, %rcx
movq -0x80(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5d50
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]zepl/lisp.c
// Function: set_input_stream_buffer
void set_input_stream_buffer(Stream *stream, char *buffer)
{
	assert(stream != NULL);
	assert(buffer != NULL);
	assert(strlen(buffer) > 0);

	stream->type = STREAM_TYPE_STRING;
	stream->buffer = buffer;
	stream->length = strlen(buffer);
	stream->capacity = strlen(buffer);
	stream->offset = 0;
	stream->size = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x20f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x20f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x4ec1(%rip), %rax      # 0xf1e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xa35d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x3, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq 0x4e86(%rip), %rax      # 0xf220
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x40(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x6aef(%rip), %rdi      # 0x10eb0
callq 0x21b0
cmpl $0x0, %eax
je 0xa3cd
jmp 0xa44b
jmp 0xa3cf
movq -0x18(%rbp), %rdi
callq 0x6700
cmpl $-0x1, %eax
je 0xa44b
movq 0x4e3c(%rip), %rcx      # 0xf220
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6880
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rdi
movq 0x6b73(%rip), %rsi      # 0x10f80
movq -0x10(%rbp), %rdx
callq 0x9220
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
leaq 0x4dad(%rip), %rdx      # 0xf1e0
callq 0x5200
movl $0xa, %edi
leaq 0x4d9c(%rip), %rsi      # 0xf1e0
callq 0x5070
jmp 0xa3cf
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x3, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq 0x4d96(%rip), %rax      # 0xf220
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x40(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x69ff(%rip), %rdi      # 0x10eb0
callq 0x21b0
cmpl $0x0, %eax
je 0xa4c0
jmp 0xa54f
movq 0x4d59(%rip), %rcx      # 0xf220
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x6700
cmpl $-0x1, %eax
jne 0xa4ef
movl $0xa, %edi
leaq 0x4cf8(%rip), %rsi      # 0xf1e0
callq 0x5070
jmp 0xa54f
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6880
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x9220
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
leaq 0x4cac(%rip), %rdx      # 0xf1e0
callq 0x5200
movl $0xa, %edi
leaq 0x4c9b(%rip), %rsi      # 0xf1e0
callq 0x5070
jmp 0xa4aa
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x4cb1(%rip), %rax      # 0xf220
movq %rax, 0x6a12(%rip)      # 0x10f88
leaq 0x4c63(%rip), %rdi      # 0xf1e0
movl $0x1, %esi
callq 0xa270
leaq 0x6922(%rip), %rdi      # 0x10eb0
callq 0x21b0
cmpl $0x0, %eax
je 0xa5a4
movl $0x1, -0x4(%rbp)
jmp 0xa646
movq 0x4c75(%rip), %rax      # 0xf220
movq %rax, 0x69c6(%rip)      # 0x10f78
movq 0x69cf(%rip), %rdx      # 0x10f88
leaq 0x4c60(%rip), %rdi      # 0xf220
leaq 0x69b1(%rip), %rsi      # 0x10f78
callq 0x5d50
movq %rax, 0x69a5(%rip)      # 0x10f78
movq 0x69ae(%rip), %rdx      # 0x10f88
leaq 0x4c47(%rip), %rdi      # 0xf228
leaq 0x6990(%rip), %rsi      # 0x10f78
callq 0x5d50
movq %rax, 0x6984(%rip)      # 0x10f78
movl $0x3, 0x6992(%rip)      # 0x10f90
movq 0x6983(%rip), %rdi      # 0x10f88
callq 0x9fe0
movq %rax, 0x698f(%rip)      # 0x10fa0
movq 0x6970(%rip), %rax      # 0x10f88
movq %rax, 0x6989(%rip)      # 0x10fa8
leaq 0x696a(%rip), %rax      # 0x10f90
addq $0x10, %rax
movq %rax, 0x694f(%rip)      # 0x10f80
leaq 0x6958(%rip), %rax      # 0x10f90
movq %rax, 0x6949(%rip)      # 0x10f88
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x2170
movq -0x8(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0xa2a0
movq 0x6900(%rip), %rdi      # 0x10f80
movq 0x6901(%rip), %rsi      # 0x10f88
leaq -0x40(%rbp), %rdx
callq 0xa460
movq 0x4b51(%rip), %rax      # 0xf1e8
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0xb8, %edi
callq 0x1120
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1323
leaq 0x3cf5(%rip), %rdi      # 0x5004
movb $0x0, %al
callq 0x1090
movq $0x0, -0x8(%rbp)
jmp 0x1452
cmpq $0x40, -0x18(%rbp)
jae 0x132c
jmp 0x134b
leaq 0x3e04(%rip), %rdi      # 0x5137
leaq 0x3d0a(%rip), %rsi      # 0x5044
movl $0x21, %edx
leaq 0x3d0a(%rip), %rcx      # 0x5050
callq 0x10a0
cmpq $0x0, -0x18(%rbp)
jbe 0x1354
jmp 0x1373
leaq 0x3f36(%rip), %rdi      # 0x5291
leaq 0x3ce2(%rip), %rsi      # 0x5044
movl $0x22, %edx
leaq 0x3ce2(%rip), %rcx      # 0x5050
callq 0x10a0
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1050
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, 0x18(%rax,%rcx)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x28(%rbp), %rdi
addq $0x58, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11c0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x13df
jmp 0x13fe
leaq 0x3ca4(%rip), %rdi      # 0x508a
leaq 0x3c57(%rip), %rsi      # 0x5044
movl $0x2a, %edx
leaq 0x3c57(%rip), %rcx      # 0x5050
callq 0x10a0
movq -0x28(%rbp), %rdi
addq $0x80, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10f0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x141d
jmp 0x143c
leaq 0x3c66(%rip), %rdi      # 0x508a
leaq 0x3c19(%rip), %rsi      # 0x5044
movl $0x2c, %edx
leaq 0x3c19(%rip), %rcx      # 0x5050
callq 0x10a0
movq -0x28(%rbp), %rax
movl $0x0, 0xb0(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x148a
movl -0xc(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x1490
movl -0x1c(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
subl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
subl -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x14b0
jmp 0x14cf
leaq 0x3bdb(%rip), %rdi      # 0x5092
leaq 0x3b86(%rip), %rsi      # 0x5044
movl $0x36, %edx
leaq 0x3bd3(%rip), %rcx      # 0x509d
callq 0x10a0
cmpq $0x0, -0x28(%rbp)
je 0x14df
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movslq -0x30(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movslq -0x34(%rbp), %rax
addq %rax, %rsi
movslq -0x2c(%rbp), %rdx
callq 0x1060
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq $0x0, 0x5bea(%rip) # 0x7110
leaq 0x5beb(%rip), %rdi      # 0x7118
xorl %eax, %eax
movl %eax, %esi
callq 0x11c0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x1541
jmp 0x1560
leaq 0x3b42(%rip), %rdi      # 0x508a
leaq 0x3af5(%rip), %rsi      # 0x5044
movl $0x40, %edx
leaq 0x3b80(%rip), %rcx      # 0x50db
callq 0x10a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1db7
movl $0x0, -0x4(%rbp)
jmp 0x1e42
movq 0x5352(%rip), %rax      # 0x7110
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1dd2
movl $0x0, -0x4(%rbp)
jmp 0x1e42
movq -0x30(%rbp), %rdi
addq $0x58, %rdi
callq 0x11d0
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x1dea
jmp 0x1e09
leaq 0x335c(%rip), %rdi      # 0x514d
leaq 0x324c(%rip), %rsi      # 0x5044
movl $0x127, %edx            # imm = 0x127
leaq 0x33c0(%rip), %rcx      # 0x51c4
callq 0x10a0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1570
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x1e33
cmpq $0x0, -0x20(%rbp)
je 0x1e33
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x24(%rbp)
setge %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stevenmherring[P]DNS/fine-trie.c
// Function: search_and_squat
int search_and_squat  (const char *string, size_t strlen, int32_t ip4_address) {
    int32_t found;
    int rc;
    // Skip strings of length 0
    if (strlen == 0)
    return 0;

    // in case the node was removed between trying to insert and squatting
    rc = pthread_mutex_lock(&(root_lock));
    assert(rc == 0);
    if(root != NULL)
    {
      found = _insert(string, strlen, ip4_address, root, NULL, NULL);
    }
    else
    {
      root = new_leaf (string, strlen, ip4_address);
      found = 1;
    }
    rc = pthread_mutex_unlock(&(root_lock));
    assert(rc == 0);

    while(!found)
    {
      rc = pthread_mutex_lock(&(root->lock));
      assert(rc == 0);


      found = _search_and_squat(root, string, strlen, ip4_address);

      // in case the node was removed between trying to insert and squatting
      if(!found)
      {
        found = insert(string, strlen, ip4_address);
      }
    }



    return (found >= 0);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1e76
movl $0x0, -0x4(%rbp)
jmp 0x1fbd
leaq 0x529b(%rip), %rdi      # 0x7118
callq 0x11d0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x1e8d
jmp 0x1eac
leaq 0x32b9(%rip), %rdi      # 0x514d
leaq 0x31a9(%rip), %rsi      # 0x5044
movl $0x13b, %edx            # imm = 0x13B
leaq 0x3349(%rip), %rcx      # 0x51f0
callq 0x10a0
cmpq $0x0, 0x525c(%rip)      # 0x7110
je 0x1eda
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq 0x5248(%rip), %rcx      # 0x7110
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %r8
callq 0x1fd0
movl %eax, -0x20(%rbp)
jmp 0x1ef8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x12e0
movq %rax, 0x521f(%rip)      # 0x7110
movl $0x1, -0x20(%rbp)
leaq 0x5219(%rip), %rdi      # 0x7118
callq 0x1110
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x1f0f
jmp 0x1f2e
leaq 0x3237(%rip), %rdi      # 0x514d
leaq 0x3127(%rip), %rsi      # 0x5044
movl $0x146, %edx            # imm = 0x146
leaq 0x32c7(%rip), %rcx      # 0x51f0
callq 0x10a0
jmp 0x1f30
cmpl $0x0, -0x20(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1f3f
jmp 0x1fae
movq 0x51ca(%rip), %rdi      # 0x7110
addq $0x58, %rdi
callq 0x11d0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x1f5a
jmp 0x1f79
leaq 0x31ec(%rip), %rdi      # 0x514d
leaq 0x30dc(%rip), %rsi      # 0x5044
movl $0x14b, %edx            # imm = 0x14B
leaq 0x327c(%rip), %rcx      # 0x51f0
callq 0x10a0
movq 0x5190(%rip), %rdi      # 0x7110
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x1930
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x1fac
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x2a70
movl %eax, -0x20(%rbp)
jmp 0x1f30
cmpl $0x0, -0x20(%rbp)
setge %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stevenmherring[P]DNS/fine-trie.c
// Function: insert
int insert (const char *string, size_t strlen, int32_t ip4_address) {
        // Skip strings of length 0
        int rc;
        if (strlen == 0)
        return 0;
        int rv;
        // get root lock
        rc = pthread_mutex_lock(&(root_lock));
        assert(rc == 0);
        if (root == NULL) {
          root = new_leaf (string, strlen, ip4_address);
          rv =  1;
          rc = pthread_mutex_unlock(&(root_lock));
          assert(rc == 0);
        }
        else
        {
          rv = _insert (string, strlen, ip4_address, root, NULL, NULL);
          rc = pthread_mutex_unlock(&(root_lock));
          assert(rc == 0);
          if (!rv && allow_squatting)
          {
            search_and_squat(string, strlen, ip4_address);
          }
        }
        return rv;
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2a96
movl $0x0, -0x4(%rbp)
jmp 0x2bae
leaq 0x467b(%rip), %rdi      # 0x7118
callq 0x11d0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x2aad
jmp 0x2acc
leaq 0x2699(%rip), %rdi      # 0x514d
leaq 0x2589(%rip), %rsi      # 0x5044
movl $0x262, %edx            # imm = 0x262
leaq 0x2847(%rip), %rcx      # 0x530e
callq 0x10a0
cmpq $0x0, 0x463c(%rip)      # 0x7110
jne 0x2b2c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x12e0
movq %rax, 0x4623(%rip)      # 0x7110
movl $0x1, -0x24(%rbp)
leaq 0x461d(%rip), %rdi      # 0x7118
callq 0x1110
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x2b0b
jmp 0x2b2a
leaq 0x263b(%rip), %rdi      # 0x514d
leaq 0x252b(%rip), %rsi      # 0x5044
movl $0x267, %edx            # imm = 0x267
leaq 0x27e9(%rip), %rcx      # 0x530e
callq 0x10a0
jmp 0x2ba8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq 0x45d2(%rip), %rcx      # 0x7110
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %r8
callq 0x1fd0
movl %eax, -0x24(%rbp)
leaq 0x45c3(%rip), %rdi      # 0x7118
callq 0x1110
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x2b65
jmp 0x2b84
leaq 0x25e1(%rip), %rdi      # 0x514d
leaq 0x24d1(%rip), %rsi      # 0x5044
movl $0x26d, %edx            # imm = 0x26D
leaq 0x278f(%rip), %rcx      # 0x530e
callq 0x10a0
cmpl $0x0, -0x24(%rbp)
jne 0x2ba6
leaq 0x45af(%rip), %rax      # 0x7140
cmpl $0x0, (%rax)
je 0x2ba6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x1e50
jmp 0x2ba8
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stevenmherring[P]DNS/fine-trie.c
// Function: delete
int delete  (const char *string, size_t strlen) {
          // Skip strings of length 0
          if (strlen == 0)
          return 0;
          int rc;

          rc = pthread_mutex_lock(&root_lock);
          assert(rc == 0);
          struct trie_node *parent = _delete(root, string, strlen);

          rc = pthread_mutex_unlock(&root_lock);
          assert(rc == 0);
          // release root lock

          int rv =(NULL != parent);

          if(parent != NULL && parent != ((struct trie_node *) 0x100100))
          {
            rc = pthread_mutex_unlock(&(parent->lock));
            assert(rc == 0);

          }


          return rv;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x32b3
movl $0x0, -0x4(%rbp)
jmp 0x3399
leaq 0x3e5e(%rip), %rdi      # 0x7118
callq 0x11d0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x32ca
jmp 0x32e9
leaq 0x1e7c(%rip), %rdi      # 0x514d
leaq 0x1d6c(%rip), %rsi      # 0x5044
movl $0x353, %edx            # imm = 0x353
leaq 0x20c4(%rip), %rcx      # 0x53a8
callq 0x10a0
movq 0x3e20(%rip), %rdi      # 0x7110
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2bc0
movq %rax, -0x28(%rbp)
leaq 0x3e10(%rip), %rdi      # 0x7118
callq 0x1110
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x3318
jmp 0x3337
leaq 0x1e2e(%rip), %rdi      # 0x514d
leaq 0x1d1e(%rip), %rsi      # 0x5044
movl $0x357, %edx            # imm = 0x357
leaq 0x2076(%rip), %rcx      # 0x53a8
callq 0x10a0
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3393
movl $0x100100, %eax         # imm = 0x100100
cmpq %rax, -0x28(%rbp)
je 0x3393
movq -0x28(%rbp), %rdi
addq $0x58, %rdi
callq 0x1110
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x3372
jmp 0x3391
leaq 0x1dd4(%rip), %rdi      # 0x514d
leaq 0x1cc4(%rip), %rsi      # 0x5044
movl $0x35f, %edx            # imm = 0x35F
leaq 0x201c(%rip), %rcx      # 0x53a8
callq 0x10a0
jmp 0x3393
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stevenmherring[P]DNS/fine-trie.c
// Function: print
void print() {
          // TODO get root lock
          printf ("Root is at %p\n", root);
          struct trie_node *node = root;
          // relese root lock

          if(node)
          {
            _print(node,0 ,0);
          }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x3c01(%rip), %rsi      # 0x7110
leaq 0x1fb9(%rip), %rdi      # 0x54cf
movb $0x0, %al
callq 0x1090
movq 0x3bec(%rip), %rax      # 0x7110
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x353c
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x33b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_02/read.c
// Function: main
int main(void)
{
	int fd;
	int nr, nw;
	char buf[BUF_SIZE];

	fd = open(TMP_FILE, O_RDONLY);
	if (fd < 0) {
		perror("open");
		return -1;
	}

	do {
		nr = read(fd, buf, BUF_SIZE);
		if (nr < 0) {
			perror("read");
			return -1;
		}

		nw = writen(STDOUT_FILENO, buf, nr);
		if (nw < nr) {
			perror("write");
			return -1;
		}

		sleep(1);
	} while (nr > 0);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xe5e(%rip), %rdi       # 0x2004
xorl %esi, %esi
movb $0x0, %al
callq 0x1060
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x11cd
leaq 0xe4f(%rip), %rdi       # 0x200e
callq 0x1070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1247
jmp 0x11cf
movl -0x8(%rbp), %edi
leaq -0x20(%rbp), %rsi
movl $0x10, %edx
callq 0x1050
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x11fe
leaq 0xe23(%rip), %rdi       # 0x2013
callq 0x1070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1247
leaq -0x20(%rbp), %rsi
movslq -0xc(%rbp), %rdx
movl $0x1, %edi
callq 0x12f0
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1230
leaq 0xdf6(%rip), %rdi       # 0x2018
callq 0x1070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1247
movl $0x1, %edi
callq 0x1080
cmpl $0x0, -0xc(%rbp)
jg 0x11cf
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq