LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/skinny_mutex.c
// Function: skinny_mutex_trylock
int skinny_mutex_trylock(skinny_mutex_t *skinny)
{
	for (;;) {
		struct common *head = skinny->val;
		struct fat_mutex *fat;
		int res;

		switch ((uintptr_t)head) {
		case 0:
			if (cas(&skinny->val, head, (void *)1))
				return 0;

			break;

		case 1:
			return EBUSY;

		default:
			res = fat_mutex_peg(skinny, head, &fat);
			if (res > 0)
				return res;
			else if (res < 0)
				/* skinny_mutex value changed under us, try
				   again. */
				break;

			res = EBUSY;
			if (!fat->held) {
				fat->held = 1;
				fat->refcount++;
				res = 0;
			}

			return recover(res,
				       pthread_mutex_unlock(&fat->mutex));
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %r15d
movq %rsp, %r14
movq (%rbx), %rsi
cmpq $0x1, %rsi
je 0x1632
movl %ecx, %ebp
testq %rsi, %rsi
jne 0x1639
xorl %ecx, %ecx
xorl %eax, %eax
lock
cmpxchgq %r15, (%rbx)
movl $0x0, %eax
je 0x167f
jmp 0x167b
movl $0x10, %ecx
jmp 0x1677
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1690
testl %eax, %eax
jg 0x1675
js 0x167b
movq (%rsp), %rdi
movl $0x10, %ebp
cmpb $0x0, 0x1(%rdi)
jne 0x1663
movb $0x1, 0x1(%rdi)
incq 0x10(%rdi)
xorl %ebp, %ebp
addq $0x18, %rdi
callq 0x1100
movl %ebp, %edi
movl %eax, %esi
callq 0x1793
movl %eax, %ecx
xorl %eax, %eax
jmp 0x167f
movb $0x1, %al
movl %ebp, %ecx
testb %al, %al
jne 0x1610
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/skinny_mutex.c
// Function: recover
static int recover(int res1, int res2)
{
	if (res2 == 0)
		return res1;

	if (res1 == 0)
		return res2;

	fprintf(stderr,
		"skinny_mutex: got error %d while recovering from %d\n",
		res2, res1);
	abort();
}

// Assembly:
movl %edi, %eax
testl %esi, %esi
je 0x17a1
movl %esi, %edx
testl %eax, %eax
jne 0x17a2
movl %edx, %eax
retq
pushq %rax
movq 0x384e(%rip), %rcx      # 0x4ff8
movq (%rcx), %rdi
leaq 0x1904(%rip), %rsi      # 0x30b8
movl %eax, %ecx
xorl %eax, %eax
callq 0x10e0
callq 0x1040
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/skinny_mutex.c
// Function: skinny_mutex_unlock_slow
int skinny_mutex_unlock_slow(skinny_mutex_t *skinny)
{
	struct fat_mutex *fat;
	int res = fat_mutex_get_held(skinny, &fat);

	if (res)
		return res;

	fat->held = 0;
	res = 0;
	if (fat->waiters)
		/* Wake a single waiter. */
		res = pthread_cond_signal(&fat->held_cond);

	return recover(res, fat_mutex_release(skinny, fat));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
callq 0x1820
testl %eax, %eax
je 0x17e4
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8(%rsp), %r14
movb $0x0, 0x1(%r14)
cmpq $0x0, 0x8(%r14)
je 0x1802
leaq 0x40(%r14), %rdi
callq 0x10d0
movl %eax, %ebp
jmp 0x1804
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1886
movl %ebp, %edi
movl %eax, %esi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1793
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/skinny_mutex.c
// Function: fat_mutex_get_held
static int fat_mutex_get_held(skinny_mutex_t *skinny, struct fat_mutex **fatp)
{
	for (;;) {
		int res;
		struct common *head = skinny->val;
		if (!head)
			return EPERM;

		res = fat_mutex_get(skinny, head, fatp);
		if (res == 0) {
			if ((*fatp)->held)
				return 0;

			res = pthread_mutex_unlock(&(*fatp)->mutex);
			if (res)
				return res;

			return EPERM;
		}

		if (res >= 0)
			return res;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%r14), %rsi
testq %rsi, %rsi
je 0x184d
movq %r14, %rdi
movq %rbx, %rdx
callq 0x142c
testl %eax, %eax
je 0x1856
movl %eax, %ecx
shrl $0x1f, %ecx
testl %eax, %eax
cmovnsl %eax, %ebp
jmp 0x1866
movl $0x1, %ebp
xorl %ecx, %ecx
jmp 0x1866
movq (%rbx), %rdi
xorl %ebp, %ebp
cmpb $0x0, 0x1(%rdi)
movl $0x0, %ecx
je 0x186c
testb %cl, %cl
jne 0x182a
jmp 0x187f
addq $0x18, %rdi
callq 0x1100
movl %eax, %ebp
cmpl $0x1, %eax
adcl $0x0, %ebp
jmp 0x1852
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/skinny_mutex.c
// Function: fat_mutex_release
static int fat_mutex_release(skinny_mutex_t *skinny, struct fat_mutex *fat)
{
	int keep, res;

	assert(!fat->held);

	/* If the decremented refcount reaches zero, then we know
	   there are no secondary peg chains or other threads pinning
	   the fat_mutex.  And if the skinny_mutex points to the
	   fat_mutex, then we know that there are no pegs on the
	   primary chain either.  So if the CAS succeeds in nulling
	   out the skinny_mutex, we can free the fat_mutex. */
	keep = (--fat->refcount || !strict_cas(&skinny->val, fat, NULL));

	res = pthread_mutex_unlock(&fat->mutex);
	if (keep || res)
		return res;

	res = pthread_mutex_destroy(&fat->mutex);
	if (res)
		return res;

	res = pthread_cond_destroy(&fat->held_cond);
	if (res)
		return res;

	free(fat);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpb $0x0, 0x1(%rsi)
jne 0x18e8
movq %rsi, %rbx
decq 0x10(%rsi)
movb $0x1, %bpl
jne 0x18aa
xorl %ecx, %ecx
movq %rbx, %rax
lock
cmpxchgq %rcx, (%rdi)
setne %bpl
leaq 0x18(%rbx), %r14
movq %r14, %rdi
callq 0x1100
testl %eax, %eax
setne %cl
orb %bpl, %cl
jne 0x18e3
movq %r14, %rdi
callq 0x1090
testl %eax, %eax
jne 0x18e3
leaq 0x40(%rbx), %rdi
callq 0x1160
testl %eax, %eax
jne 0x18e3
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x17fe(%rip), %rdi      # 0x30ed
leaq 0x174a(%rip), %rsi      # 0x3040
leaq 0x17fb(%rip), %rcx      # 0x30f8
movl $0x1c4, %edx            # imm = 0x1C4
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/skinny_mutex.c
// Function: skinny_mutex_cond_timedwait
int skinny_mutex_cond_timedwait(pthread_cond_t *cond, skinny_mutex_t *skinny,
				const struct timespec *abstime)
{
	struct cond_wait_cleanup c;
	int res = fat_mutex_get_held(skinny, &c.fat);
	if (res)
		return res;

	/* We will release the lock, so wake a waiter */
	if (c.fat->waiters) {
		res = pthread_cond_signal(&c.fat->held_cond);
		if (res) {
			pthread_mutex_unlock(&c.fat->mutex);
			return res;
		}
	}

       /* Relinquish the mutex.  But we leave our reference accounted
          for in fat->refcount in place, in order to pin the
          fat_mutex. */
	c.fat->held = 0;

	/* pthread_cond_wait is a cancellation point */
	pthread_cleanup_push(cond_wait_cleanup, &c);

	if (!abstime)
		res = pthread_cond_wait(cond, &c.fat->mutex);
	else
		res = pthread_cond_timedwait(cond, &c.fat->mutex, abstime);

	pthread_cleanup_pop(1);
	return recover(res, c.lock_res);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %r15
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1820
movl %eax, %ecx
testl %eax, %eax
jne 0x19c0
movq 0x10(%rsp), %rbx
cmpq $0x0, 0x8(%rbx)
je 0x195f
leaq 0x40(%rbx), %rdi
callq 0x10d0
testl %eax, %eax
je 0x195f
movl %eax, %ebp
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x1100
movl %ebp, %ecx
jmp 0x19c0
movb $0x0, 0x1(%rbx)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x1190
testl %eax, %eax
jne 0x19d0
leaq 0x20(%rsp), %rdi
callq 0x1170
leaq 0x18(%rbx), %rsi
movq %r15, %rdi
testq %r14, %r14
je 0x1993
movq %r14, %rdx
callq 0x1150
jmp 0x1998
callq 0x1060
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
callq 0x10a0
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x1517
movl %eax, 0x18(%rsp)
movl %ebp, %edi
movl %eax, %esi
callq 0x1793
movl %eax, %ecx
movl %ecx, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %rdi
callq 0x19e4
leaq 0x20(%rsp), %rdi
callq 0x1130
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/perf.c
// Function: measure
static void measure(void (*test)(struct test_results *res),
		    const char *name, int reps)
{
	struct test_results res;
	long long times[SETS];
	int i;

	printf("Measuring %s: ", name);
	fflush(stdout);

	res.reps = reps;

	for (i = 0; i < SETS; i++) {
		test(&res);
		times[i] = res.stop - res.start;
	}

	qsort(times, SETS, sizeof(long long), cmp_long_long);
	printf("best %dns, 50%%ile %dns\n", (int)(times[0] * 1000 / reps),
	       (int)(times[SETS / 2] * 1000 / reps));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edx, %ebx
movq %rdi, %r14
leaq 0x1737(%rip), %rdi      # 0x3183
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x1080
movq 0x357b(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
callq 0x1120
leaq 0x8(%rsp), %r15
movl %ebx, (%r15)
movq %r15, %rdi
callq *%r14
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp,%r12,8)
incq %r12
cmpq $0xa, %r12
jne 0x1a6d
leaq 0x4db(%rip), %rcx       # 0x1f6d
leaq 0x20(%rsp), %r14
movl $0xa, %esi
movl $0x8, %edx
movq %r14, %rdi
callq 0x1050
imulq $0x3e8, (%r14), %rax    # imm = 0x3E8
movl %ebx, %ecx
cqto
idivq %rcx
movq %rax, %rsi
imulq $0x3e8, 0x28(%r14), %rax # imm = 0x3E8
cqto
idivq %rcx
leaq 0x16c4(%rip), %rdi      # 0x3192
movl %eax, %edx
xorl %eax, %eax
callq 0x1080
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/perf.c
// Function: lock_unlock
static void lock_unlock(struct test_results *res)
{
	mutex_t mutex;
	int i;

	assert(!mutex_init(&mutex));

	res->start = now_usecs();

	for (i = res->reps; i--;) {
		assert(!mutex_lock(&mutex));
		assert(!mutex_unlock(&mutex));
	}

	res->stop = now_usecs();

	assert(!mutex_destroy(&mutex));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
callq 0x1f81
movq %rax, 0x8(%rbx)
movl (%rbx), %ebp
testl %ebp, %ebp
je 0x1b4b
xorl %r15d, %r15d
movl $0x1, %r12d
leaq 0x8(%rsp), %r14
xorl %eax, %eax
lock
cmpxchgq %r12, 0x8(%rsp)
jne 0x1b37
movl $0x1, %eax
lock
cmpxchgq %r15, 0x8(%rsp)
jne 0x1b41
decl %ebp
jne 0x1b18
jmp 0x1b4b
movq %r14, %rdi
callq 0x11d0
jmp 0x1b23
movq %r14, %rdi
callq 0x11f9
jmp 0x1b31
callq 0x1f81
movq %rax, 0x10(%rbx)
cmpq $0x0, 0x8(%rsp)
jne 0x1b69
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1694(%rip), %rdi      # 0x3204
leaq 0x1634(%rip), %rsi      # 0x31ab
leaq 0x1634(%rip), %rcx      # 0x31b2
movl $0x58, %edx
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O1/antonblanchard[P]will-it-scale/tests/futex1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	while (1) {
		unsigned int addr = 0;

		futex(&addr, FUTEX_WAKE, 1, NULL, NULL, 0);

		(*iterations)++;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0xc(%rsp), %r14
movl %r15d, 0xc(%rsp)
movl %r15d, (%rsp)
movl $0xca, %edi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x1160
incq (%rbx)
jmp 0x1c64
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/liball/../util/getopt.c
// Function: searchopt
static size_t
searchopt(const char * os)
{
	size_t i;

	/* Scan the array of options. */
	for (i = 0; i < nopts; i++) {
		/* Is there an option in this slot? */
		if (opts[i].os == NULL)
			continue;

		/* Does this match up to the length of the option string? */
		if (strncmp(opts[i].os, os, opts[i].olen))
			continue;

		/* Do we have <option>\0 or <option>= ? */
		if ((os[opts[i].olen] == '\0') || (os[opts[i].olen] == '='))
			return (i);
	}

	/* Not found. */
	return (opt_default);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x335d(%rip), %r12      # 0x50f0
testq %r12, %r12
je 0x1ddf
movq %rdi, %rbx
movq 0x3346(%rip), %r13      # 0x50e8
addq $0x8, %r13
xorl %r14d, %r14d
movq -0x8(%r13), %rdi
testq %rdi, %rdi
je 0x1dd3
movq (%r13), %r15
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1050
testl %eax, %eax
jne 0x1dd3
movzbl (%rbx,%r15), %eax
testl %eax, %eax
je 0x1de6
cmpl $0x3d, %eax
je 0x1de6
incq %r14
addq $0x18, %r13
cmpq %r14, %r12
jne 0x1da9
movq 0x32ea(%rip), %r14      # 0x50d0
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/liball/../util/getopt.c
// Function: getopt_lookup
size_t
getopt_lookup(const char * os)
{

	/*
	 * We only take this parameter so that we can assert that it's the
	 * same option string as we returned from getopt(); as such, it is
	 * unused in the absence of assertions.
	 */
	(void)os; /* UNUSED */

	/* Can't reset here. */
	if (optreset)
		DIE("Can't reset in the middle of getopt loop");

	/* We should only be called after initialization is complete. */
	assert(getopt_initialized);

	/* GETOPT_DUMMY should never get passed back to us. */
	assert(os != GETOPT_DUMMY);

	/*
	 * Make sure the option passed back to us corresponds to the one we
	 * found earlier.
	 */
	assert((opt_found == opt_missing) || (opt_found == opt_default) ||
	    ((opt_found < nopts) && (strcmp(os, opts[opt_found].os) == 0)));

	/* Return the option number we identified earlier. */
	return (opt_found);
}

// Assembly:
pushq %rbx
cmpl $0x0, 0x3295(%rip)      # 0x5090
jne 0x1e4e
cmpl $0x0, 0x32ac(%rip)      # 0x50b0
je 0x1e53
cmpq %rdi, 0x328b(%rip)      # 0x5098
je 0x1e72
movq 0x32b2(%rip), %rbx      # 0x50c8
cmpq 0x32bb(%rip), %rbx      # 0x50d8
je 0x1e49
cmpq 0x32aa(%rip), %rbx      # 0x50d0
je 0x1e49
cmpq 0x32c1(%rip), %rbx      # 0x50f0
jae 0x1e91
movq 0x32b0(%rip), %rax      # 0x50e8
leaq (%rbx,%rbx,2), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1090
testl %eax, %eax
jne 0x1e91
movq %rbx, %rax
popq %rbx
retq
callq 0x1307
leaq 0x143a(%rip), %rdi      # 0x3294
leaq 0x1370(%rip), %rsi      # 0x31d1
leaq 0x137a(%rip), %rcx      # 0x31e2
movl $0x113, %edx            # imm = 0x113
callq 0x1070
leaq 0x138c(%rip), %rdi      # 0x3205
leaq 0x1351(%rip), %rsi      # 0x31d1
leaq 0x135b(%rip), %rcx      # 0x31e2
movl $0x116, %edx            # imm = 0x116
callq 0x1070
leaq 0x1380(%rip), %rdi      # 0x3218
leaq 0x1332(%rip), %rsi      # 0x31d1
leaq 0x133c(%rip), %rcx      # 0x31e2
movl $0x11d, %edx            # imm = 0x11D
callq 0x1070
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/liball/../util/getopt.c
// Function: getopt_register_opt
void
getopt_register_opt(const char * os, size_t ln, int hasarg)
{

	/* Can't reset here. */
	if (optreset)
		DIE("Can't reset in the middle of getopt loop");

	/* We should only be called during initialization. */
	assert(!getopt_initialized);

	/* We should have space allocated for registering options. */
	assert(opts != NULL);

	/* We should not have registered an option here yet. */
	assert(opts[ln].os == NULL);

	/* Options should be "-X" or "--foo". */
	if ((os[0] != '-') || (os[1] == '\0') ||
	    ((os[1] == '-') && (os[2] == '\0')) ||
	    ((os[1] != '-') && (os[2] != '\0')))
		DIE("Not a valid command-line option: %s", os);

	/* Make sure we haven't already registered this option. */
	if (searchopt(os) != opt_default)
		DIE("Command-line option registered twice: %s", os);

	/* Record option. */
	opts[ln].os = os;
	opts[ln].olen = strlen(os);
	opts[ln].hasarg = hasarg;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x31d1(%rip)      # 0x5090
jne 0x1f5d
cmpl $0x0, 0x31e4(%rip)      # 0x50b0
jne 0x1f62
movq 0x320f(%rip), %r15      # 0x50e8
testq %r15, %r15
je 0x1f81
leaq (%rsi,%rsi,2), %r12
cmpq $0x0, (%r15,%r12,8)
jne 0x1fa0
movq %rdi, %r14
cmpb $0x2d, (%rdi)
jne 0x1f55
movl %edx, %ebx
movzbl 0x1(%r14), %eax
cmpl $0x2d, %eax
je 0x1f0b
testl %eax, %eax
jne 0x1f16
jmp 0x1f55
cmpb $0x0, 0x2(%r14)
je 0x1f55
cmpb $0x2d, %al
je 0x1f1d
cmpb $0x0, 0x2(%r14)
jne 0x1f55
movq %r14, %rdi
callq 0x1d83
cmpq 0x31a4(%rip), %rax      # 0x50d0
jne 0x1fbf
leaq (%r15,%r12,8), %r15
movq %r14, (%r15)
movq %r14, %rdi
callq 0x1060
movq %rax, 0x8(%r15)
movl %ebx, 0x10(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x13a9
callq 0x1358
leaq 0x132a(%rip), %rdi      # 0x3293
leaq 0x1261(%rip), %rsi      # 0x31d1
leaq 0x1330(%rip), %rcx      # 0x32a7
movl $0x12c, %edx            # imm = 0x12C
callq 0x1070
leaq 0x1353(%rip), %rdi      # 0x32db
leaq 0x1242(%rip), %rsi      # 0x31d1
leaq 0x1311(%rip), %rcx      # 0x32a7
movl $0x12f, %edx            # imm = 0x12F
callq 0x1070
leaq 0x1341(%rip), %rdi      # 0x32e8
leaq 0x1223(%rip), %rsi      # 0x31d1
leaq 0x12f2(%rip), %rcx      # 0x32a7
movl $0x132, %edx            # imm = 0x132
callq 0x1070
movq %r14, %rdi
callq 0x13ff
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/liball/../util/getopt.c
// Function: getopt_register_missing
void
getopt_register_missing(size_t ln)
{

	/* Can't reset here. */
	if (optreset)
		DIE("Can't reset in the middle of getopt loop");

	/* We should only be called during initialization. */
	assert(!getopt_initialized);

	/* Record missing-argument value. */
	opt_missing = ln;
}

// Assembly:
pushq %rax
cmpl $0x0, 0x30c1(%rip)      # 0x5090
jne 0x1fe3
cmpl $0x0, 0x30d8(%rip)      # 0x50b0
jne 0x1fe8
movq %rdi, 0x30f7(%rip)      # 0x50d8
popq %rax
retq
callq 0x1455
leaq 0x12a4(%rip), %rdi      # 0x3293
leaq 0x11db(%rip), %rsi      # 0x31d1
leaq 0x134c(%rip), %rcx      # 0x3349
movl $0x14d, %edx            # imm = 0x14D
callq 0x1070
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/liball/../util/getopt.c
// Function: getopt_setrange
void
getopt_setrange(size_t maxopts)
{
	size_t i;

	/* Can't reset here. */
	if (optreset)
		DIE("Can't reset in the middle of getopt loop");

	/* We should only be called during initialization. */
	assert(!getopt_initialized);

	/* Allocate space for (potential) options. */
	opts = malloc(maxopts * sizeof(struct opt));
	if ((maxopts > 0) && (opts == NULL))
		DIE("Failed to allocate memory in getopt");

	/* Initialize options. */
	for (i = 0; i < maxopts; i++)
		opts[i].os = NULL;

	/* Record the number of (potential) options. */
	nopts = maxopts;

	/* Record default missing-argument and no-such-option values. */
	opt_missing = opt_default = maxopts + 1;
}

// Assembly:
pushq %rbx
cmpl $0x0, 0x3081(%rip)      # 0x5090
jne 0x2077
cmpl $0x0, 0x3098(%rip)      # 0x50b0
jne 0x207c
movq %rdi, %rbx
leaq (,%rdi,8), %rax
leaq (%rax,%rax,2), %rdi
callq 0x10b0
movq %rax, 0x30b3(%rip)      # 0x50e8
testq %rbx, %rbx
setne %cl
testq %rax, %rax
sete %dl
testb %dl, %cl
jne 0x209b
testq %rbx, %rbx
je 0x205d
movq %rbx, %rcx
movq $0x0, (%rax)
addq $0x18, %rax
decq %rcx
jne 0x204d
movq %rbx, 0x308c(%rip)      # 0x50f0
incq %rbx
movq %rbx, 0x3062(%rip)      # 0x50d0
movq %rbx, 0x3063(%rip)      # 0x50d8
popq %rbx
retq
callq 0x14a6
leaq 0x1210(%rip), %rdi      # 0x3293
leaq 0x1147(%rip), %rsi      # 0x31d1
leaq 0x12dd(%rip), %rcx      # 0x336e
movl $0x15e, %edx            # imm = 0x15E
callq 0x1070
callq 0x14f7
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/schemer.c
// Function: abort_beh
BEH_DECL(abort_beh)
{
	char* s = cons_to_str(WHAT);

	DBUG_ENTER("abort_beh");
	DBUG_PRINT("", ("ABORT! %s", s));
	fprintf(stderr, "ABORT! %s\n", s);
	abort();
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq 0x30(%rdi), %rdi
callq 0x15225
movq %rax, %rdi
callq 0xf17c
movq %rax, %rbx
leaq 0x15884(%rip), %rax     # 0x18004
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1cb91(%rip), %r15     # 0x1f320
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x5e, 0xc(%rdi)
leaq 0x18236(%rip), %r14     # 0x1a9e0
movq %r14, 0x10(%rdi)
leaq 0x1c98b(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ef2
leaq 0x1d127(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x2804
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x16664
testl %eax, %eax
je 0x2804
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x5f, 0xc(%rax)
leaq 0x15814(%rip), %rdi     # 0x1800e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x16f63
movq 0x1c7ed(%rip), %rax     # 0x1eff8
movq (%rax), %rdi
leaq 0x15803(%rip), %rsi     # 0x18018
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2170
callq 0x2050
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/schemer.c
// Function: println_beh
BEH_DECL(println_beh)
{
	DBUG_ENTER("println_beh");
	DBUG_PRINT("", ("WHAT = %s", cons_to_str(WHAT)));
	if (!nilp(MINE)) {
		printf("%s ", cons_to_str(MINE));
	}
	printf("%s\n", cons_to_str(WHAT));
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x157ec(%rip), %rax     # 0x18023
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1cada(%rip), %r15     # 0x1f320
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x67, 0xc(%rdi)
leaq 0x1817f(%rip), %r14     # 0x1a9e0
movq %r14, 0x10(%rdi)
leaq 0x1c8d4(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ef2
leaq 0x1d070(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x28cc
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x16664
testl %eax, %eax
je 0x28cc
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x68, 0xc(%rax)
movq 0x30(%rbx), %rdi
callq 0x15225
movq %rax, %rdi
callq 0xf17c
leaq 0x1576d(%rip), %rdi     # 0x1802f
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f63
movq 0x30(%rbx), %rdi
callq 0x15186
movq %rax, %rdi
callq 0xd2f1
cmpq 0x1c6dc(%rip), %rax     # 0x1efc0
je 0x2910
movq 0x30(%rbx), %rdi
callq 0x15186
movq %rax, %rdi
callq 0xd2f1
movq %rax, %rdi
callq 0xf17c
leaq 0x15733(%rip), %rdi     # 0x18039
movq %rax, %rsi
xorl %eax, %eax
callq 0x20e0
movq 0x30(%rbx), %rdi
callq 0x15225
movq %rax, %rdi
callq 0xf17c
movq %rax, %rdi
callq 0x20a0
leaq 0x8(%rsp), %rdi
movl $0x6d, 0xc(%rdi)
callq 0x17077
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/schemer.c
// Function: one_shot_beh
BEH_DECL(one_shot_beh)
{
	DBUG_ENTER("one_shot_beh");
	SEND(MINE, WHAT);
	BECOME(sink_beh, NIL);
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
leaq 0x156e6(%rip), %rax     # 0x1803d
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
leaq 0x1c9ba(%rip), %rax     # 0x1f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rbx)
movl $0x7b, 0xc(%rbx)
leaq 0x1805f(%rip), %rcx     # 0x1a9e0
movq %rcx, 0x10(%rbx)
leaq 0x1c7b4(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rbx, %rdi
callq 0x16ef2
movq 0x30(%r14), %rdi
callq 0x15186
movq %rax, %rdi
callq 0xd2f1
movq %rax, %r15
movq 0x30(%r14), %rdi
callq 0x15225
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xdef7
movq 0x30(%r14), %rdi
callq 0x15186
leaq 0xa94d(%rip), %rsi      # 0xd324
leaq 0x1c8b2(%rip), %rdx     # 0x1f290
movq %rax, %rdi
callq 0xd500
movl $0x7e, 0xc(%rbx)
movq %rbx, %rdi
callq 0x17077
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/schemer.c
// Function: label_beh
BEH_DECL(label_beh)
{
	CONS* to = pr_head(MINE);
	CONS* label = pr_tail(MINE);
	CONS* value = WHAT;

	DBUG_ENTER("label_beh");
	SEND(to, mk_pair(label, value));
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x15186
movq %rax, %rdi
callq 0xd2f1
movq %rax, %rdi
callq 0x15186
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x15186
movq %rax, %rdi
callq 0xd2f1
movq %rax, %rdi
callq 0x15225
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x15225
movq %rax, %r13
leaq 0x155f0(%rip), %rax     # 0x1804a
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
leaq 0x1c8b7(%rip), %rax     # 0x1f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%r15)
movl $0x8d, 0xc(%r15)
leaq 0x17f5a(%rip), %rcx     # 0x1a9e0
movq %rcx, 0x10(%r15)
leaq 0x1c6af(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%r15)
movq %rax, 0x20(%r15)
movq %r15, %rdi
callq 0x16ef2
movq %r12, %rdi
movq %r13, %rsi
callq 0x15164
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xdef7
movl $0x8f, 0xc(%r15)
movq %r15, %rdi
callq 0x17077
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/schemer.c
// Function: command_beh
BEH_DECL(command_beh)
{
	DBUG_ENTER("command_beh");
	if (actorp(WHAT)) {
		SEND(WHAT, MINE);
	} else {
		DBUG_PRINT("", ("Ignored! %s", cons_to_str(WHAT)));
		abort();
	}
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x15569(%rip), %rax     # 0x18054
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1c826(%rip), %r15     # 0x1f320
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x9a, 0xc(%rdi)
leaq 0x17ecb(%rip), %r14     # 0x1a9e0
movq %r14, 0x10(%rdi)
leaq 0x1c620(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ef2
movq 0x30(%rbx), %rdi
callq 0x15225
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x2b84
movq 0x30(%rbx), %rdi
callq 0x15225
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x15186
movq %rax, %rdi
callq 0xd2f1
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xdef7
leaq 0x8(%rsp), %rdi
movl $0xa1, 0xc(%rdi)
callq 0x17077
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1cd65(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x2bd7
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x16664
testl %eax, %eax
je 0x2bd7
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x9e, 0xc(%rax)
movq 0x30(%rbx), %rdi
callq 0x15225
movq %rax, %rdi
callq 0xf17c
leaq 0x15493(%rip), %rdi     # 0x18060
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f63
callq 0x2050
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/schemer.c
// Function: boolean
static CONS*
boolean(BOOL p)
{
	if (true__value == false__value) {
		true__value = ATOM("#t");
		false__value = ATOM("#f");
		assert(true__value != false__value);
	}
	return (p ? true__value : false__value);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x1b61f(%rip), %rax     # 0x1f390
cmpq 0x1b620(%rip), %rax     # 0x1f398
jne 0x3da9
leaq 0x148a5(%rip), %rdi     # 0x18626
callq 0x1265c
movq %rax, 0x1b603(%rip)     # 0x1f390
leaq 0x14895(%rip), %rdi     # 0x18629
callq 0x1265c
movq %rax, 0x1b5f8(%rip)     # 0x1f398
cmpq %rax, 0x1b5e9(%rip)     # 0x1f390
je 0x3dc3
testq %rbx, %rbx
leaq 0x1b5dd(%rip), %rax     # 0x1f390
leaq 0x1b5de(%rip), %rcx     # 0x1f398
cmovneq %rax, %rcx
movq (%rcx), %rax
popq %rbx
retq
leaq 0x14f60(%rip), %rdi     # 0x18d2a
leaq 0x145ea(%rip), %rsi     # 0x183bb
leaq 0x14f6e(%rip), %rcx     # 0x18d46
movl $0x44, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/schemer.c
// Function: eval_lambda_beh
BEH_DECL(eval_lambda_beh)
{
	CONS* p;
	CONS* a;

	DBUG_ENTER("eval_lambda_beh");
	if (is_pair(WHAT) && is_pair(p = pr_tail(WHAT))) {
		CONS* to = pr_head(WHAT);
		CONS* expr = pr_head(p);
		CONS* env = pr_tail(p);

		DBUG_PRINT("", ("expr = %s", cons_to_str(expr)));
		a = ACTOR(lambda_beh, mk_pair(expr, env));
		SEND(to, a);
	} else {
		DBUG_PRINT("", ("Ignored! %s", cons_to_str(WHAT)));
		abort();
	}
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x140f1(%rip), %rax     # 0x181c5
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1b23f(%rip), %rbp     # 0x1f320
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x202, 0xc(%rdi)       # imm = 0x202
leaq 0x168e3(%rip), %r14     # 0x1a9e0
movq %r14, 0x10(%rdi)
leaq 0x1b038(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ef2
movq 0x30(%rbx), %rdi
callq 0x15225
testq %rax, %rax
je 0x4261
movq 0x30(%rbx), %rdi
callq 0x15225
testb $0x3, %al
jne 0x4261
movq 0x30(%rbx), %rdi
callq 0x15225
cmpq 0x1ae78(%rip), %rax     # 0x1efc0
je 0x4261
movq 0x30(%rbx), %rdi
callq 0x15225
movq %rax, %rdi
callq 0x15225
testq %rax, %rax
je 0x4261
movq 0x30(%rbx), %rdi
callq 0x15225
movq %rax, %rdi
callq 0x15225
testb $0x3, %al
jne 0x4261
movq 0x30(%rbx), %rdi
callq 0x15225
movq %rax, %rdi
callq 0x15225
cmpq 0x1ae27(%rip), %rax     # 0x1efc0
je 0x4261
movq %rax, %r13
movq 0x30(%rbx), %rdi
callq 0x15225
movq %rax, %rdi
callq 0x15186
movq %rax, %r15
movq %r13, %rdi
callq 0x15186
movq %rax, %r12
movq %r13, %rdi
callq 0x15225
movq %rax, %r13
leaq 0x1b71d(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x4218
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x16664
testl %eax, %eax
je 0x4218
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x208, 0xc(%rax)       # imm = 0x208
movq %r12, %rdi
callq 0xf17c
leaq 0x13ede(%rip), %rdi     # 0x180ec
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f63
movq %r12, %rdi
movq %r13, %rsi
callq 0x15164
leaq -0x448(%rip), %rsi      # 0x3de2
movq %rbx, %rdi
movq %rax, %rdx
callq 0xde1a
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xdef7
movq %rsp, %rdi
movl $0x20f, 0xc(%rdi)       # imm = 0x20F
callq 0x17077
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b688(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x42b6
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x16664
testl %eax, %eax
je 0x42b6
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x20c, 0xc(%rax)       # imm = 0x20C
movq 0x30(%rbx), %rdi
callq 0x15225
movq %rax, %rdi
callq 0xf17c
leaq 0x13db4(%rip), %rdi     # 0x18060
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f63
callq 0x2050
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/schemer.c
// Function: apply_form_beh
BEH_DECL(apply_form_beh)
{
	CONS* expr = WHAT;
	CONS* to = pr_head(MINE);
	CONS* env = pr_tail(MINE);
	CONS* msg;

	DBUG_ENTER("apply_form_beh");
	DBUG_PRINT("", ("expr = %s", cons_to_str(expr)));
	msg = mk_pair(expr, env);
	msg = mk_pair(to, msg);
	SEND(eval__actor, msg);
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x15225
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x15186
movq %rax, %rdi
callq 0xd2f1
movq %rax, %rdi
callq 0x15186
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x15186
movq %rax, %rdi
callq 0xd2f1
movq %rax, %rdi
callq 0x15225
movq %rax, %r12
leaq 0x13ebe(%rip), %rax     # 0x181d5
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1affc(%rip), %rbp     # 0x1f320
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x221, 0xc(%rdi)       # imm = 0x221
leaq 0x166a0(%rip), %r13     # 0x1a9e0
movq %r13, 0x10(%rdi)
leaq 0x1adf5(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ef2
leaq 0x1b591(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x43a4
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r13, 0x10(%rax)
movq %r13, %rdi
callq 0x16664
testl %eax, %eax
je 0x43a4
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x222, 0xc(%rax)       # imm = 0x222
movq %r14, %rdi
callq 0xf17c
leaq 0x13d52(%rip), %rdi     # 0x180ec
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f63
movq %r14, %rdi
movq %r12, %rsi
callq 0x15164
movq %r15, %rdi
movq %rax, %rsi
callq 0x15164
movq 0x1afb7(%rip), %rsi     # 0x1f378
movq %rbx, %rdi
movq %rax, %rdx
callq 0xdef7
movq %rsp, %rdi
movl $0x226, 0xc(%rdi)       # imm = 0x226
callq 0x17077
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/schemer.c
// Function: eval_form_beh
BEH_DECL(eval_form_beh)
{
	CONS* p;
	CONS* a;

	DBUG_ENTER("eval_form_beh");
	if (is_pair(WHAT) && is_pair(p = pr_tail(WHAT))) {
		CONS* to = pr_head(WHAT);
		CONS* expr = pr_head(p);
		CONS* env = pr_tail(p);

		DBUG_PRINT("", ("expr = %s", cons_to_str(expr)));
		a = ACTOR(form_beh, mk_pair(expr, env));
		SEND(to, a);
	} else {
		DBUG_PRINT("", ("Ignored! %s", cons_to_str(WHAT)));
		abort();
	}
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x13b0c(%rip), %rax     # 0x181ee
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1ac31(%rip), %rbp     # 0x1f320
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x261, 0xc(%rdi)       # imm = 0x261
leaq 0x162d5(%rip), %r14     # 0x1a9e0
movq %r14, 0x10(%rdi)
leaq 0x1aa2a(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ef2
movq 0x30(%rbx), %rdi
callq 0x15225
testq %rax, %rax
je 0x486f
movq 0x30(%rbx), %rdi
callq 0x15225
testb $0x3, %al
jne 0x486f
movq 0x30(%rbx), %rdi
callq 0x15225
cmpq 0x1a86a(%rip), %rax     # 0x1efc0
je 0x486f
movq 0x30(%rbx), %rdi
callq 0x15225
movq %rax, %rdi
callq 0x15225
testq %rax, %rax
je 0x486f
movq 0x30(%rbx), %rdi
callq 0x15225
movq %rax, %rdi
callq 0x15225
testb $0x3, %al
jne 0x486f
movq 0x30(%rbx), %rdi
callq 0x15225
movq %rax, %rdi
callq 0x15225
cmpq 0x1a819(%rip), %rax     # 0x1efc0
je 0x486f
movq %rax, %r13
movq 0x30(%rbx), %rdi
callq 0x15225
movq %rax, %rdi
callq 0x15186
movq %rax, %r15
movq %r13, %rdi
callq 0x15186
movq %rax, %r12
movq %r13, %rdi
callq 0x15225
movq %rax, %r13
leaq 0x1b10f(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x4826
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x16664
testl %eax, %eax
je 0x4826
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x267, 0xc(%rax)       # imm = 0x267
movq %r12, %rdi
callq 0xf17c
leaq 0x138d0(%rip), %rdi     # 0x180ec
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f63
movq %r12, %rdi
movq %r13, %rsi
callq 0x15164
leaq -0x44e(%rip), %rsi      # 0x43ea
movq %rbx, %rdi
movq %rax, %rdx
callq 0xde1a
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xdef7
movq %rsp, %rdi
movl $0x26e, 0xc(%rdi)       # imm = 0x26E
callq 0x17077
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b07a(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x48c4
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x16664
testl %eax, %eax
je 0x48c4
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x26b, 0xc(%rax)       # imm = 0x26B
movq 0x30(%rbx), %rdi
callq 0x15225
movq %rax, %rdi
callq 0xf17c
leaq 0x137a6(%rip), %rdi     # 0x18060
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f63
callq 0x2050
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/schemer.c
// Function: have_n_args
static BOOL
have_n_args(int n, CONS* args)
{
	while (!is_empty(args)) {
		if (!is_pair(args)) {
			return FALSE;
		}
		args = pr_tail(args);
		--n;
	}
	return ((n == 0) ? TRUE : FALSE);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
cmpq 0x19f3f(%rip), %rsi     # 0x1efc0
je 0x50aa
movq %rsi, %rax
xorl %ebx, %ebx
leaq 0x1a201(%rip), %r14     # 0x1f290
testq %rax, %rax
je 0x50b1
movl %eax, %ecx
andl $0x3, %ecx
jne 0x50b1
movq %rax, %rdi
callq 0x15225
decl %ebp
cmpq %r14, %rax
jne 0x508f
xorl %ebx, %ebx
testl %ebp, %ebp
sete %bl
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/schemer.c
// Function: eval_time_beh
BEH_DECL(eval_time_beh)
{
	CONS* p;

	DBUG_ENTER("eval_time_beh");
	if (is_pair(WHAT) && is_pair(p = pr_tail(WHAT))) {
		CONS* to = pr_head(WHAT);
/*		CONS* expr = pr_head(p); */
/*		CONS* env = pr_tail(p); */

		p = NOW;
		DBUG_PRINT("", ("now = %s", cons_to_str(p)));
		SEND(to, p);
	} else {
		DBUG_PRINT("", ("Ignored! %s", cons_to_str(WHAT)));
		abort();
	}
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x12f49(%rip), %rax     # 0x18248
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1a012(%rip), %r13     # 0x1f320
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x31a, 0xc(%rdi)       # imm = 0x31A
leaq 0x156b6(%rip), %r14     # 0x1a9e0
movq %r14, 0x10(%rdi)
leaq 0x19e0b(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ef2
movq 0x30(%rbx), %rdi
callq 0x15225
testq %rax, %rax
je 0x5469
movq 0x30(%rbx), %rdi
callq 0x15225
testb $0x3, %al
jne 0x5469
movq 0x30(%rbx), %rdi
callq 0x15225
cmpq 0x19c4b(%rip), %rax     # 0x1efc0
je 0x5469
movq 0x30(%rbx), %rdi
callq 0x15225
movq %rax, %rdi
callq 0x15225
testq %rax, %rax
je 0x5469
movq 0x30(%rbx), %rdi
callq 0x15225
movq %rax, %rdi
callq 0x15225
testb $0x3, %al
jne 0x5469
movq 0x30(%rbx), %rdi
callq 0x15225
movq %rax, %rdi
callq 0x15225
cmpq 0x19bfa(%rip), %rax     # 0x1efc0
je 0x5469
movq 0x30(%rbx), %rdi
callq 0x15225
movq %rax, %rdi
callq 0x15186
movq %rax, %r15
movq 0x50(%rbx), %rdi
movq 0x58(%rbx), %rsi
callq 0xd61b
movq %rax, %r12
leaq 0x1a4f9(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x543c
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x16664
testl %eax, %eax
je 0x543c
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x321, 0xc(%rax)       # imm = 0x321
movq %r12, %rdi
callq 0xf17c
leaq 0x12e24(%rip), %rdi     # 0x18256
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f63
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xdef7
leaq 0x8(%rsp), %rdi
movl $0x327, 0xc(%rdi)       # imm = 0x327
callq 0x17077
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1a480(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x54be
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x16664
testl %eax, %eax
je 0x54be
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x324, 0xc(%rax)       # imm = 0x324
movq 0x30(%rbx), %rdi
callq 0x15225
movq %rax, %rdi
callq 0xf17c
leaq 0x12bac(%rip), %rdi     # 0x18060
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f63
callq 0x2050
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/schemer.c
// Function: apply_define_beh
BEH_DECL(apply_define_beh)
{
	CONS* value = WHAT;
	CONS* to;
	CONS* name;
	CONS* env;
	CONS* p = MINE;
	CONS* msg;

	DBUG_ENTER("apply_define_beh");
	to = pr_head(p);
	p = pr_tail(p);
	name = pr_head(p);
	DBUG_PRINT("", ("name = %s", cons_to_str(name)));
	DBUG_PRINT("", ("value = %s", cons_to_str(value)));
	env = pr_tail(p);
	msg = mk_empty();
	msg = mk_list(value, msg);
	msg = mk_list(name, msg);
	msg = mk_list(ATOM("define"), msg);
	msg = mk_pair(msg, env);
	msg = mk_pair(to, msg);
	SEND(env, msg);
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x15225
movq %rax, %r15
movq %rbx, (%rsp)
movq 0x30(%rbx), %rdi
callq 0x15186
movq %rax, %rdi
callq 0xd2f1
movq %rax, %r12
leaq 0x12d60(%rip), %rax     # 0x1825f
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x19e12(%rip), %rbx     # 0x1f320
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x339, 0xc(%rdi)       # imm = 0x339
leaq 0x154b7(%rip), %rbp     # 0x1a9e0
movq %rbp, 0x10(%rdi)
leaq 0x19c0c(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ef2
movq %r12, %rdi
callq 0x15186
movq %rax, 0x8(%rsp)
movq %r12, %rdi
callq 0x15225
movq %rax, %r13
movq %rax, %rdi
callq 0x15186
movq %rax, %r12
leaq 0x1a385(%rip), %r14     # 0x1f8f0
cmpl $0x0, (%r14)
je 0x55af
movq (%rbx), %rax
movq 0x50(%rax), %rax
movq %rbp, 0x10(%rax)
movq %rbp, %rdi
callq 0x16664
testl %eax, %eax
je 0x55af
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0x33d, 0xc(%rax)       # imm = 0x33D
movq %r12, %rdi
callq 0xf17c
leaq 0x12af5(%rip), %rdi     # 0x1809a
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f63
cmpl $0x0, (%r14)
je 0x55f3
movq (%rbx), %rax
movq 0x50(%rax), %rax
movq %rbp, 0x10(%rax)
movq %rbp, %rdi
callq 0x16664
testl %eax, %eax
je 0x55f3
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0x33e, 0xc(%rax)       # imm = 0x33E
movq %r15, %rdi
callq 0xf17c
leaq 0x12abb(%rip), %rdi     # 0x180a4
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f63
movq %r13, %rdi
callq 0x15225
movq %rax, %r13
leaq 0x19c8b(%rip), %rsi     # 0x1f290
movq %r15, %rdi
callq 0x15164
movq %r12, %rdi
movq %rax, %rsi
callq 0x15164
movq %rax, %r14
leaq 0x12a8d(%rip), %rdi     # 0x180af
callq 0x1265c
movq %rax, %rdi
movq %r14, %rsi
callq 0x15164
movq %rax, %rdi
movq %r13, %rsi
callq 0x15164
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x15164
movq (%rsp), %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xdef7
leaq 0x10(%rsp), %rdi
movl $0x347, 0xc(%rdi)       # imm = 0x347
callq 0x17077
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/schemer.c
// Function: apply_set_beh
BEH_DECL(apply_set_beh)
{
	CONS* value = WHAT;
	CONS* to;
	CONS* name;
	CONS* env;
	CONS* p = MINE;
	CONS* msg;

	DBUG_ENTER("apply_set_beh");
	to = pr_head(p);
	p = pr_tail(p);
	name = pr_head(p);
	DBUG_PRINT("", ("name = %s", cons_to_str(name)));
	DBUG_PRINT("", ("value = %s", cons_to_str(value)));
	env = pr_tail(p);
	msg = mk_empty();
	msg = mk_list(value, msg);
	msg = mk_list(name, msg);
	msg = mk_list(ATOM("set!"), msg);
	msg = mk_pair(msg, env);
	msg = mk_pair(to, msg);
	SEND(env, msg);
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x15225
movq %rax, %r15
movq %rbx, (%rsp)
movq 0x30(%rbx), %rdi
callq 0x15186
movq %rax, %rdi
callq 0xd2f1
movq %rax, %r12
leaq 0x125b0(%rip), %rax     # 0x18287
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1963a(%rip), %rbx     # 0x1f320
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x3a6, 0xc(%rdi)       # imm = 0x3A6
leaq 0x14cdf(%rip), %rbp     # 0x1a9e0
movq %rbp, 0x10(%rdi)
leaq 0x19434(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ef2
movq %r12, %rdi
callq 0x15186
movq %rax, 0x8(%rsp)
movq %r12, %rdi
callq 0x15225
movq %rax, %r13
movq %rax, %rdi
callq 0x15186
movq %rax, %r12
leaq 0x19bad(%rip), %r14     # 0x1f8f0
cmpl $0x0, (%r14)
je 0x5d87
movq (%rbx), %rax
movq 0x50(%rax), %rax
movq %rbp, 0x10(%rax)
movq %rbp, %rdi
callq 0x16664
testl %eax, %eax
je 0x5d87
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0x3aa, 0xc(%rax)       # imm = 0x3AA
movq %r12, %rdi
callq 0xf17c
leaq 0x1231d(%rip), %rdi     # 0x1809a
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f63
cmpl $0x0, (%r14)
je 0x5dcb
movq (%rbx), %rax
movq 0x50(%rax), %rax
movq %rbp, 0x10(%rax)
movq %rbp, %rdi
callq 0x16664
testl %eax, %eax
je 0x5dcb
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0x3ab, 0xc(%rax)       # imm = 0x3AB
movq %r15, %rdi
callq 0xf17c
leaq 0x122e3(%rip), %rdi     # 0x180a4
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f63
movq %r13, %rdi
callq 0x15225
movq %rax, %r13
leaq 0x194b3(%rip), %rsi     # 0x1f290
movq %r15, %rdi
callq 0x15164
movq %r12, %rdi
movq %rax, %rsi
callq 0x15164
movq %rax, %r14
leaq 0x122bc(%rip), %rdi     # 0x180b6
callq 0x1265c
movq %rax, %rdi
movq %r14, %rsi
callq 0x15164
movq %rax, %rdi
movq %r13, %rsi
callq 0x15164
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x15164
movq (%rsp), %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xdef7
leaq 0x10(%rsp), %rdi
movl $0x3b4, 0xc(%rdi)       # imm = 0x3B4
callq 0x17077
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/schemer.c
// Function: join_list_beh
BEH_DECL(join_list_beh)
{
	CONS* list = WHAT;
	CONS* to;
	CONS* value;

	DBUG_ENTER("join_list_beh");
	to = pr_head(MINE);
	value = pr_tail(MINE);
	if (is_list(list)) {
		DBUG_PRINT("", ("list = %s", cons_to_str(list)));
		DBUG_PRINT("", ("value = %s", cons_to_str(value)));
		SEND(to, mk_list(value, list));
	} else {
		DBUG_PRINT("", ("Ignored! %s", cons_to_str(WHAT)));
		abort();
	}
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x15225
movq %rax, %r14
leaq 0x1200b(%rip), %rax     # 0x182a2
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1907c(%rip), %rax     # 0x1f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x3f5, 0xc(%rdi)       # imm = 0x3F5
leaq 0x14721(%rip), %r12     # 0x1a9e0
movq %r12, 0x10(%rdi)
leaq 0x18e76(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ef2
movq 0x30(%rbx), %rdi
callq 0x15186
movq %rax, %rdi
callq 0xd2f1
movq %rax, %rdi
callq 0x15186
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x15186
movq %rax, %rdi
callq 0xd2f1
movq %rax, %rdi
callq 0x15225
movq %rax, %r13
leaq 0x195da(%rip), %rbp     # 0x1f8f0
movl (%rbp), %eax
testq %r14, %r14
je 0x6407
movl %r14d, %ecx
andl $0x3, %ecx
jne 0x6407
testl %eax, %eax
je 0x637e
leaq 0x18fe7(%rip), %rax     # 0x1f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x16664
testl %eax, %eax
je 0x637e
leaq 0x18fc9(%rip), %rax     # 0x1f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x3f9, 0xc(%rax)       # imm = 0x3F9
movq %r14, %rdi
callq 0xf17c
leaq 0x11f3c(%rip), %rdi     # 0x182b0
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f63
cmpl $0x0, (%rbp)
je 0x63d0
leaq 0x18f95(%rip), %rax     # 0x1f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x16664
testl %eax, %eax
je 0x63d0
leaq 0x18f77(%rip), %rax     # 0x1f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x3fa, 0xc(%rax)       # imm = 0x3FA
movq %r13, %rdi
callq 0xf17c
leaq 0x11cde(%rip), %rdi     # 0x180a4
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f63
movq %r13, %rdi
movq %r14, %rsi
callq 0x15164
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xdef7
movq %rsp, %rdi
movl $0x400, 0xc(%rdi)       # imm = 0x400
callq 0x17077
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %eax, %eax
je 0x6460
leaq 0x18f0e(%rip), %rax     # 0x1f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x16664
testl %eax, %eax
je 0x6460
leaq 0x18ef0(%rip), %rax     # 0x1f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x3fd, 0xc(%rax)       # imm = 0x3FD
movq 0x30(%rbx), %rdi
callq 0x15225
movq %rax, %rdi
callq 0xf17c
leaq 0x11c0a(%rip), %rdi     # 0x18060
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f63
callq 0x2050