LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/dpw[P]skinny-mutex/skinny_mutex.c
// Function: fat_mutex_lock
static int fat_mutex_lock(skinny_mutex_t *skinny, struct fat_mutex *fat)
{
	if (fat->held) {
		/* The mutex is already held, so we have to wait for
		 * it. */
		fat->waiters++;

		do {
			int res, old_state, old_state2;

			/* skinny_mutex_lock is not a cancellation
			   point, but pthread_cond_wait is, so we need
			   to defer cancellation around it. */
			assert(!pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,
						       &old_state));
			res = pthread_cond_wait(&fat->held_cond, &fat->mutex);
			assert(!pthread_setcancelstate(old_state, &old_state2));

			if (res) {
				fat->waiters--;
				return recover(res,
					       fat_mutex_release(skinny, fat));
			}
		} while (fat->held);

		fat->waiters--;
	}

	fat->held = 1;
	return pthread_mutex_unlock(&fat->mutex);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
cmpb $0x0, 0x1(%rsi)
je 0x146c
movq %rdi, 0x8(%rsp)
incq 0x8(%rbx)
leaq 0x40(%rbx), %r15
leaq 0x18(%rbx), %r12
leaq 0x4(%rsp), %r13
leaq 0x14(%rsp), %r14
pushq $0x1
popq %rdi
movq %r13, %rsi
callq 0x1070
testl %eax, %eax
jne 0x14c6
movq %r15, %rdi
movq %r12, %rsi
callq 0x1060
movl %eax, %ebp
movl 0x4(%rsp), %edi
movq %r14, %rsi
callq 0x1070
testl %eax, %eax
jne 0x14a7
testl %ebp, %ebp
jne 0x147e
cmpb $0x0, 0x1(%rbx)
jne 0x142e
decq 0x8(%rbx)
movb $0x1, 0x1(%rbx)
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x1100
jmp 0x1498
decq 0x8(%rbx)
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x172c
movl %ebp, %edi
movl %eax, %esi
callq 0x1650
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bda(%rip), %rdi      # 0x3088
leaq 0x1b8b(%rip), %rsi      # 0x3040
leaq 0x1b93(%rip), %rcx      # 0x304f
movl $0x1f3, %edx            # imm = 0x1F3
callq 0x10c0
leaq 0x1b37(%rip), %rdi      # 0x3004
leaq 0x1b6c(%rip), %rsi      # 0x3040
leaq 0x1b74(%rip), %rcx      # 0x304f
movl $0x1f1, %edx            # imm = 0x1F1
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x10
popq %rbp
pushq $0x1
popq %r15
movq %rsp, %r14
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x151a
cmpq $0x1, %rsi
je 0x1527
movq %rbx, %rdi
movq %r14, %rdx
callq 0x156f
testl %eax, %eax
jg 0x152b
js 0x14f9
jmp 0x153a
xorl %ecx, %ecx
xorl %eax, %eax
lock
cmpxchgq %r15, (%rbx)
jne 0x14f9
jmp 0x152d
movl %ebp, %ecx
jmp 0x152d
movl %eax, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rdi
cmpb $0x0, 0x1(%rdi)
je 0x1549
pushq $0x10
popq %rbx
jmp 0x1553
movb $0x1, 0x1(%rdi)
incq 0x10(%rdi)
xorl %ebx, %ebx
addq $0x18, %rdi
callq 0x1100
movl %ebx, %edi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1650
// File: /workspace/github_c_makefile_star2_O2/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 0x165e
movl %esi, %edx
testl %eax, %eax
jne 0x165f
movl %edx, %eax
retq
pushq %rax
movq 0x3991(%rip), %rcx      # 0x4ff8
movq (%rcx), %rdi
leaq 0x1a47(%rip), %rsi      # 0x30b8
movl %eax, %ecx
xorl %eax, %eax
callq 0x10e0
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/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 0x16dd
testl %eax, %eax
je 0x16a1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8(%rsp), %r14
movb $0x0, 0x1(%r14)
cmpq $0x0, 0x8(%r14)
je 0x16bf
leaq 0x40(%r14), %rdi
callq 0x10d0
movl %eax, %ebp
jmp 0x16c1
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x172c
movl %ebp, %edi
movl %eax, %esi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1650
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rbx
movq (%r15), %rsi
testq %rsi, %rsi
je 0x1713
movq %r15, %rdi
movq %r14, %rdx
callq 0x131a
testl %eax, %eax
je 0x1708
js 0x16eb
movl %eax, %ebx
jmp 0x1713
movq (%r14), %rdi
xorl %ebx, %ebx
cmpb $0x0, 0x1(%rdi)
je 0x171b
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
addq $0x18, %rdi
callq 0x1100
cmpl $0x1, %eax
adcl $0x0, %eax
jmp 0x1715
// File: /workspace/github_c_makefile_star2_O2/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 0x178e
movq %rsi, %rbx
decq 0x10(%rsi)
movb $0x1, %bpl
jne 0x1750
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 0x1789
movq %r14, %rdi
callq 0x1090
testl %eax, %eax
jne 0x1789
leaq 0x40(%rbx), %rdi
callq 0x1160
testl %eax, %eax
jne 0x1789
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1958(%rip), %rdi      # 0x30ed
leaq 0x18a4(%rip), %rsi      # 0x3040
leaq 0x1955(%rip), %rcx      # 0x30f8
movl $0x1c4, %edx            # imm = 0x1C4
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x16dd
movl %eax, %ecx
testl %eax, %eax
jne 0x1867
movq 0x10(%rsp), %r15
cmpq $0x0, 0x8(%r15)
je 0x1804
leaq 0x40(%r15), %rdi
callq 0x10d0
testl %eax, %eax
je 0x1804
movl %eax, %ebx
movq %r15, %rdi
addq $0x18, %rdi
callq 0x1100
movl %ebx, %ecx
jmp 0x1867
movb $0x0, 0x1(%r15)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x1190
testl %eax, %eax
jne 0x1876
leaq 0x20(%rsp), %rdi
callq 0x1170
movq %r15, %rsi
addq $0x18, %rsi
movq %r14, %rdi
testq %rbx, %rbx
je 0x183c
movq %rbx, %rdx
callq 0x1150
jmp 0x1841
callq 0x1060
movl %eax, %ebx
leaq 0x20(%rsp), %rdi
callq 0x10a0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x188a
movl 0x10(%r14), %esi
movl %ebx, %edi
callq 0x1650
movl %eax, %ecx
movl %ecx, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %rdi
callq 0x188a
leaq 0x20(%rsp), %rdi
callq 0x1130
// File: /workspace/github_c_makefile_star2_O2/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 0x188f(%rip), %rdi      # 0x3183
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x1080
movq 0x36d3(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
callq 0x1120
leaq 0x8(%rsp), %r15
movl %ebx, (%r15)
cmpq $0xa, %r12
je 0x1935
movq %r15, %rdi
callq *%r14
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp,%r12,8)
incq %r12
jmp 0x1915
leaq 0x4c4(%rip), %rcx       # 0x1e00
leaq 0x20(%rsp), %r14
pushq $0xa
popq %rsi
pushq $0x8
popq %rdx
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 0x181e(%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_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
callq 0x1e12
movq %rax, 0x8(%rbx)
movl (%rbx), %ebp
incl %ebp
decl %ebp
je 0x19df
movq %r14, %rdi
callq 0x1e56
testl %eax, %eax
jne 0x19f9
movq %r14, %rdi
callq 0x1e69
testl %eax, %eax
je 0x19aa
leaq 0x1821(%rip), %rdi      # 0x31ee
leaq 0x17d7(%rip), %rsi      # 0x31ab
leaq 0x17d7(%rip), %rcx      # 0x31b2
pushq $0x53
jmp 0x1a10
callq 0x1e12
movq %rax, 0x10(%rbx)
cmpq $0x0, 0x8(%rsp)
jne 0x1a16
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x17da(%rip), %rdi      # 0x31da
leaq 0x17a4(%rip), %rsi      # 0x31ab
leaq 0x17a4(%rip), %rcx      # 0x31b2
pushq $0x52
popq %rdx
callq 0x10c0
leaq 0x17e7(%rip), %rdi      # 0x3204
leaq 0x1787(%rip), %rsi      # 0x31ab
leaq 0x1787(%rip), %rcx      # 0x31b2
pushq $0x58
jmp 0x1a10
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
pushq $0x1
popq %rbp
andl $0x0, 0xc(%rsp)
andl $0x0, (%rsp)
movl $0xca, %edi
movq %r14, %rsi
movl %ebp, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x1160
incq (%rbx)
jmp 0x1bc3
// File: /workspace/github_c_makefile_star2_O2/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 %rdi, %r14
movq 0x35cc(%rip), %r12      # 0x50f0
movq 0x35bd(%rip), %r13      # 0x50e8
addq $0x8, %r13
xorl %ebx, %ebx
cmpq %rbx, %r12
je 0x1b69
movq -0x8(%r13), %rdi
testq %rdi, %rdi
je 0x1b60
movq (%r13), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x1050
testl %eax, %eax
jne 0x1b60
movzbl (%r14,%r15), %eax
testl %eax, %eax
je 0x1b70
cmpl $0x3d, %eax
je 0x1b70
incq %rbx
addq $0x18, %r13
jmp 0x1b31
movq 0x3560(%rip), %rbx      # 0x50d0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x350b(%rip)      # 0x5090
jne 0x1be8
cmpl $0x0, 0x3522(%rip)      # 0x50b0
je 0x1c38
cmpq %rdi, 0x34fd(%rip)      # 0x5098
je 0x1c57
movq 0x3520(%rip), %rbx      # 0x50c8
cmpq 0x3529(%rip), %rbx      # 0x50d8
je 0x1be3
cmpq 0x3518(%rip), %rbx      # 0x50d0
je 0x1be3
cmpq 0x352f(%rip), %rbx      # 0x50f0
jae 0x1c76
movq 0x351a(%rip), %rax      # 0x50e8
imulq $0x18, %rbx, %rcx
movq (%rax,%rcx), %rsi
callq 0x1090
testl %eax, %eax
jne 0x1c76
movq %rbx, %rax
popq %rbx
retq
movq 0x34f1(%rip), %rdx      # 0x50e0
testq %rdx, %rdx
je 0x1c0c
movq 0x33fd(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1547(%rip), %rsi      # 0x314c
xorl %eax, %eax
callq 0x10a0
movq 0x33e5(%rip), %rbx      # 0x4ff8
movq (%rbx), %rcx
leaq 0x158b(%rip), %rdi      # 0x31a8
pushq $0x28
popq %rsi
pushq $0x1
popq %rdx
callq 0x10e0
movq (%rbx), %rsi
pushq $0xa
popq %rdi
callq 0x1080
callq 0x1040
leaq 0x1655(%rip), %rdi      # 0x3294
leaq 0x158b(%rip), %rsi      # 0x31d1
leaq 0x1595(%rip), %rcx      # 0x31e2
movl $0x113, %edx            # imm = 0x113
callq 0x1070
leaq 0x15a7(%rip), %rdi      # 0x3205
leaq 0x156c(%rip), %rsi      # 0x31d1
leaq 0x1576(%rip), %rcx      # 0x31e2
movl $0x116, %edx            # imm = 0x116
callq 0x1070
leaq 0x159b(%rip), %rdi      # 0x3218
leaq 0x154d(%rip), %rsi      # 0x31d1
leaq 0x1557(%rip), %rcx      # 0x31e2
movl $0x11d, %edx            # imm = 0x11D
callq 0x1070
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
cmpl $0x0, 0x3229(%rip)      # 0x5090
jne 0x1e7b
cmpl $0x0, 0x3240(%rip)      # 0x50b0
jne 0x1ecb
movq %rdi, 0x325f(%rip)      # 0x50d8
popq %rbx
retq
movq 0x325e(%rip), %rdx      # 0x50e0
testq %rdx, %rdx
je 0x1e9f
movq 0x316a(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x12b4(%rip), %rsi      # 0x314c
xorl %eax, %eax
callq 0x10a0
movq 0x3152(%rip), %rbx      # 0x4ff8
movq (%rbx), %rcx
leaq 0x12f8(%rip), %rdi      # 0x31a8
pushq $0x28
popq %rsi
pushq $0x1
popq %rdx
callq 0x10e0
movq (%rbx), %rsi
pushq $0xa
popq %rdi
callq 0x1080
callq 0x1040
leaq 0x13c1(%rip), %rdi      # 0x3293
leaq 0x12f8(%rip), %rsi      # 0x31d1
leaq 0x1469(%rip), %rcx      # 0x3349
movl $0x14d, %edx            # imm = 0x14D
callq 0x1070
// File: /workspace/github_c_makefile_star2_O2/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, 0x319e(%rip)      # 0x5090
jne 0x1f55
cmpl $0x0, 0x31b5(%rip)      # 0x50b0
jne 0x1f8e
movq %rdi, %rbx
imulq $0x18, %rdi, %rdi
callq 0x10b0
movq %rax, 0x31d4(%rip)      # 0x50e8
testq %rbx, %rbx
setne %cl
testq %rax, %rax
sete %dl
testb %dl, %cl
jne 0x1fad
movq %rbx, %rcx
subq $0x1, %rcx
jb 0x1f3b
andq $0x0, (%rax)
addq $0x18, %rax
jmp 0x1f2b
movq %rbx, 0x31ae(%rip)      # 0x50f0
incq %rbx
movq %rbx, 0x3184(%rip)      # 0x50d0
movq %rbx, 0x3185(%rip)      # 0x50d8
popq %rbx
retq
movq 0x3184(%rip), %rdx      # 0x50e0
testq %rdx, %rdx
je 0x1f79
movq 0x3090(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x11da(%rip), %rsi      # 0x314c
xorl %eax, %eax
callq 0x10a0
movq 0x3078(%rip), %rbx      # 0x4ff8
movq (%rbx), %rcx
leaq 0x121e(%rip), %rdi      # 0x31a8
pushq $0x28
jmp 0x1fe4
leaq 0x12fe(%rip), %rdi      # 0x3293
leaq 0x1235(%rip), %rsi      # 0x31d1
leaq 0x13cb(%rip), %rcx      # 0x336e
movl $0x15e, %edx            # imm = 0x15E
callq 0x1070
movq 0x312c(%rip), %rdx      # 0x50e0
testq %rdx, %rdx
je 0x1fd1
movq 0x3038(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1182(%rip), %rsi      # 0x314c
xorl %eax, %eax
callq 0x10a0
movq 0x3020(%rip), %rbx      # 0x4ff8
movq (%rbx), %rcx
leaq 0x13a9(%rip), %rdi      # 0x338b
pushq $0x23
popq %rsi
pushq $0x1
popq %rdx
callq 0x10e0
movq (%rbx), %rsi
pushq $0xa
popq %rdi
callq 0x1080
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/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 0x14906
movq %rax, %rdi
callq 0xed08
movq %rax, %rbx
leaq 0x14c84(%rip), %rax     # 0x17004
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1bf91(%rip), %r15     # 0x1e320
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x5e, 0xc(%rdi)
leaq 0x17612(%rip), %r14     # 0x199bc
movq %r14, 0x10(%rdi)
leaq 0x1bd8b(%rip), %rcx     # 0x1e140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16679
leaq 0x1c527(%rip), %rax     # 0x1e8f0
cmpl $0x0, (%rax)
je 0x2404
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x15df4
testl %eax, %eax
je 0x2404
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x5f, 0xc(%rax)
leaq 0x14c14(%rip), %rdi     # 0x1700e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x166f0
movq 0x1bbed(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
leaq 0x14c03(%rip), %rsi     # 0x17018
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2170
callq 0x2050
// File: /workspace/github_c_makefile_star2_O2/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 0x14bec(%rip), %rax     # 0x17023
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1beda(%rip), %r15     # 0x1e320
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x67, 0xc(%rdi)
leaq 0x1755b(%rip), %r14     # 0x199bc
movq %r14, 0x10(%rdi)
leaq 0x1bcd4(%rip), %rcx     # 0x1e140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16679
leaq 0x1c470(%rip), %rax     # 0x1e8f0
cmpl $0x0, (%rax)
je 0x24cc
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x15df4
testl %eax, %eax
je 0x24cc
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x68, 0xc(%rax)
movq 0x30(%rbx), %rdi
callq 0x14906
movq %rax, %rdi
callq 0xed08
leaq 0x14b6d(%rip), %rdi     # 0x1702f
movq %rax, %rsi
xorl %eax, %eax
callq 0x166f0
movq 0x30(%rbx), %rdi
callq 0x147fb
movq %rax, %rdi
callq 0xcd5b
cmpq 0x1badc(%rip), %rax     # 0x1dfc0
je 0x2510
movq 0x30(%rbx), %rdi
callq 0x147fb
movq %rax, %rdi
callq 0xcd5b
movq %rax, %rdi
callq 0xed08
leaq 0x14b33(%rip), %rdi     # 0x17039
movq %rax, %rsi
xorl %eax, %eax
callq 0x20e0
movq 0x30(%rbx), %rdi
callq 0x14906
movq %rax, %rdi
callq 0xed08
movq %rax, %rdi
callq 0x20a0
leaq 0x8(%rsp), %rdi
movl $0x6d, 0xc(%rdi)
callq 0x167f2
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x14ae6(%rip), %rax     # 0x1703d
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
leaq 0x1bdba(%rip), %rax     # 0x1e320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rbx)
movl $0x7b, 0xc(%rbx)
leaq 0x1743b(%rip), %rcx     # 0x199bc
movq %rcx, 0x10(%rbx)
leaq 0x1bbb4(%rip), %rcx     # 0x1e140
movq %rcx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rbx, %rdi
callq 0x16679
movq 0x30(%r14), %rdi
callq 0x147fb
movq %rax, %rdi
callq 0xcd5b
movq %rax, %r15
movq 0x30(%r14), %rdi
callq 0x14906
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xda94
movq 0x30(%r14), %rdi
callq 0x147fb
leaq 0xa7b5(%rip), %rsi      # 0xcd8c
leaq 0x1bcb2(%rip), %rdx     # 0x1e290
movq %rax, %rdi
callq 0xd116
movl $0x7e, 0xc(%rbx)
movq %rbx, %rdi
callq 0x167f2
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x147fb
movq %rax, %rdi
callq 0xcd5b
movq %rax, %rdi
callq 0x147fb
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x147fb
movq %rax, %rdi
callq 0xcd5b
movq %rax, %rdi
callq 0x14906
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x14906
movq %rax, %r13
leaq 0x149f0(%rip), %rax     # 0x1704a
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
leaq 0x1bcb7(%rip), %rax     # 0x1e320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%r15)
movl $0x8d, 0xc(%r15)
leaq 0x17336(%rip), %rcx     # 0x199bc
movq %rcx, 0x10(%r15)
leaq 0x1baaf(%rip), %rcx     # 0x1e140
movq %rcx, 0x18(%r15)
movq %rax, 0x20(%r15)
movq %r15, %rdi
callq 0x16679
movq %r12, %rdi
movq %r13, %rsi
callq 0x14764
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xda94
movl $0x8f, 0xc(%r15)
movq %r15, %rdi
callq 0x167f2
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x14969(%rip), %rax     # 0x17054
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1bc26(%rip), %r15     # 0x1e320
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x9a, 0xc(%rdi)
leaq 0x172a7(%rip), %r14     # 0x199bc
movq %r14, 0x10(%rdi)
leaq 0x1ba20(%rip), %rcx     # 0x1e140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16679
movq 0x30(%rbx), %rdi
callq 0x14906
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x2784
movq 0x30(%rbx), %rdi
callq 0x14906
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x147fb
movq %rax, %rdi
callq 0xcd5b
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xda94
leaq 0x8(%rsp), %rdi
movl $0xa1, 0xc(%rdi)
callq 0x167f2
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1c165(%rip), %rax     # 0x1e8f0
cmpl $0x0, (%rax)
je 0x27d7
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x15df4
testl %eax, %eax
je 0x27d7
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x9e, 0xc(%rax)
movq 0x30(%rbx), %rdi
callq 0x14906
movq %rax, %rdi
callq 0xed08
leaq 0x14893(%rip), %rdi     # 0x17060
movq %rax, %rsi
xorl %eax, %eax
callq 0x166f0
callq 0x2050
// File: /workspace/github_c_makefile_star2_O2/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 0x1aa8f(%rip), %rcx     # 0x1e390
movq 0x1aa90(%rip), %rax     # 0x1e398
cmpq %rax, %rcx
jne 0x393f
leaq 0x13d12(%rip), %rdi     # 0x17626
callq 0x11f1f
movq %rax, 0x1aa70(%rip)     # 0x1e390
leaq 0x13d02(%rip), %rdi     # 0x17629
callq 0x11f1f
movq %rax, 0x1aa65(%rip)     # 0x1e398
movq 0x1aa56(%rip), %rcx     # 0x1e390
cmpq %rax, %rcx
je 0x3948
testq %rbx, %rbx
cmovneq %rcx, %rax
popq %rbx
retq
leaq 0x143db(%rip), %rdi     # 0x17d2a
leaq 0x13a65(%rip), %rsi     # 0x173bb
leaq 0x143e9(%rip), %rcx     # 0x17d46
pushq $0x44
popq %rdx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 0x1356e(%rip), %rax     # 0x171c5
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1a6bc(%rip), %rbp     # 0x1e320
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x202, 0xc(%rdi)       # imm = 0x202
leaq 0x15d3c(%rip), %r14     # 0x199bc
movq %r14, 0x10(%rdi)
leaq 0x1a4b5(%rip), %rcx     # 0x1e140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16679
movq 0x30(%rbx), %rdi
callq 0x14906
testq %rax, %rax
je 0x3de4
movq 0x30(%rbx), %rdi
callq 0x14906
testb $0x3, %al
jne 0x3de4
movq 0x30(%rbx), %rdi
callq 0x14906
cmpq 0x1a2f5(%rip), %rax     # 0x1dfc0
je 0x3de4
movq 0x30(%rbx), %rdi
callq 0x14906
movq %rax, %rdi
callq 0x14906
testq %rax, %rax
je 0x3de4
movq 0x30(%rbx), %rdi
callq 0x14906
movq %rax, %rdi
callq 0x14906
testb $0x3, %al
jne 0x3de4
movq 0x30(%rbx), %rdi
callq 0x14906
movq %rax, %rdi
callq 0x14906
cmpq 0x1a2a4(%rip), %rax     # 0x1dfc0
je 0x3de4
movq %rax, %r13
movq 0x30(%rbx), %rdi
callq 0x14906
movq %rax, %rdi
callq 0x147fb
movq %rax, %r15
movq %r13, %rdi
callq 0x147fb
movq %rax, %r12
movq %r13, %rdi
callq 0x14906
movq %rax, %r13
leaq 0x1ab9a(%rip), %rax     # 0x1e8f0
cmpl $0x0, (%rax)
je 0x3d9b
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x15df4
testl %eax, %eax
je 0x3d9b
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x208, 0xc(%rax)       # imm = 0x208
movq %r12, %rdi
callq 0xed08
leaq 0x1335b(%rip), %rdi     # 0x170ec
movq %rax, %rsi
xorl %eax, %eax
callq 0x166f0
movq %r12, %rdi
movq %r13, %rsi
callq 0x14764
leaq -0x448(%rip), %rsi      # 0x3965
movq %rbx, %rdi
movq %rax, %rdx
callq 0xd9b7
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xda94
movq %rsp, %rdi
movl $0x20f, 0xc(%rdi)       # imm = 0x20F
callq 0x167f2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ab05(%rip), %rax     # 0x1e8f0
cmpl $0x0, (%rax)
je 0x3e39
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x15df4
testl %eax, %eax
je 0x3e39
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x20c, 0xc(%rax)       # imm = 0x20C
movq 0x30(%rbx), %rdi
callq 0x14906
movq %rax, %rdi
callq 0xed08
leaq 0x13231(%rip), %rdi     # 0x17060
movq %rax, %rsi
xorl %eax, %eax
callq 0x166f0
callq 0x2050
// File: /workspace/github_c_makefile_star2_O2/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 0x14906
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x147fb
movq %rax, %rdi
callq 0xcd5b
movq %rax, %rdi
callq 0x147fb
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x147fb
movq %rax, %rdi
callq 0xcd5b
movq %rax, %rdi
callq 0x14906
movq %rax, %r12
leaq 0x1333b(%rip), %rax     # 0x171d5
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1a479(%rip), %rbp     # 0x1e320
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x221, 0xc(%rdi)       # imm = 0x221
leaq 0x15af9(%rip), %r13     # 0x199bc
movq %r13, 0x10(%rdi)
leaq 0x1a272(%rip), %rcx     # 0x1e140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16679
leaq 0x1aa0e(%rip), %rax     # 0x1e8f0
cmpl $0x0, (%rax)
je 0x3f27
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r13, 0x10(%rax)
movq %r13, %rdi
callq 0x15df4
testl %eax, %eax
je 0x3f27
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x222, 0xc(%rax)       # imm = 0x222
movq %r14, %rdi
callq 0xed08
leaq 0x131cf(%rip), %rdi     # 0x170ec
movq %rax, %rsi
xorl %eax, %eax
callq 0x166f0
movq %r14, %rdi
movq %r12, %rsi
callq 0x14764
movq %r15, %rdi
movq %rax, %rsi
callq 0x14764
movq 0x1a434(%rip), %rsi     # 0x1e378
movq %rbx, %rdi
movq %rax, %rdx
callq 0xda94
movq %rsp, %rdi
movl $0x226, 0xc(%rdi)       # imm = 0x226
callq 0x167f2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12f89(%rip), %rax     # 0x171ee
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1a0ae(%rip), %rbp     # 0x1e320
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x261, 0xc(%rdi)       # imm = 0x261
leaq 0x1572e(%rip), %r14     # 0x199bc
movq %r14, 0x10(%rdi)
leaq 0x19ea7(%rip), %rcx     # 0x1e140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16679
movq 0x30(%rbx), %rdi
callq 0x14906
testq %rax, %rax
je 0x43f2
movq 0x30(%rbx), %rdi
callq 0x14906
testb $0x3, %al
jne 0x43f2
movq 0x30(%rbx), %rdi
callq 0x14906
cmpq 0x19ce7(%rip), %rax     # 0x1dfc0
je 0x43f2
movq 0x30(%rbx), %rdi
callq 0x14906
movq %rax, %rdi
callq 0x14906
testq %rax, %rax
je 0x43f2
movq 0x30(%rbx), %rdi
callq 0x14906
movq %rax, %rdi
callq 0x14906
testb $0x3, %al
jne 0x43f2
movq 0x30(%rbx), %rdi
callq 0x14906
movq %rax, %rdi
callq 0x14906
cmpq 0x19c96(%rip), %rax     # 0x1dfc0
je 0x43f2
movq %rax, %r13
movq 0x30(%rbx), %rdi
callq 0x14906
movq %rax, %rdi
callq 0x147fb
movq %rax, %r15
movq %r13, %rdi
callq 0x147fb
movq %rax, %r12
movq %r13, %rdi
callq 0x14906
movq %rax, %r13
leaq 0x1a58c(%rip), %rax     # 0x1e8f0
cmpl $0x0, (%rax)
je 0x43a9
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x15df4
testl %eax, %eax
je 0x43a9
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x267, 0xc(%rax)       # imm = 0x267
movq %r12, %rdi
callq 0xed08
leaq 0x12d4d(%rip), %rdi     # 0x170ec
movq %rax, %rsi
xorl %eax, %eax
callq 0x166f0
movq %r12, %rdi
movq %r13, %rsi
callq 0x14764
leaq -0x44e(%rip), %rsi      # 0x3f6d
movq %rbx, %rdi
movq %rax, %rdx
callq 0xd9b7
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xda94
movq %rsp, %rdi
movl $0x26e, 0xc(%rdi)       # imm = 0x26E
callq 0x167f2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a4f7(%rip), %rax     # 0x1e8f0
cmpl $0x0, (%rax)
je 0x4447
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x15df4
testl %eax, %eax
je 0x4447
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x26b, 0xc(%rax)       # imm = 0x26B
movq 0x30(%rbx), %rdi
callq 0x14906
movq %rax, %rdi
callq 0xed08
leaq 0x12c23(%rip), %rdi     # 0x17060
movq %rax, %rsi
xorl %eax, %eax
callq 0x166f0
callq 0x2050
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %rax
movl %edi, %ebp
leaq 0x19695(%rip), %r14     # 0x1e290
xorl %ebx, %ebx
cmpq %r14, %rax
je 0x4c1a
testq %rax, %rax
je 0x4c21
movl %eax, %ecx
andl $0x3, %ecx
jne 0x4c21
movq %rax, %rdi
callq 0x14906
decl %ebp
jmp 0x4bfd
xorl %ebx, %ebx
testl %ebp, %ebp
sete %bl
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x123d9(%rip), %rax     # 0x17248
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x194a2(%rip), %r13     # 0x1e320
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x31a, 0xc(%rdi)       # imm = 0x31A
leaq 0x14b22(%rip), %r14     # 0x199bc
movq %r14, 0x10(%rdi)
leaq 0x1929b(%rip), %rcx     # 0x1e140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16679
movq 0x30(%rbx), %rdi
callq 0x14906
testq %rax, %rax
je 0x4fd9
movq 0x30(%rbx), %rdi
callq 0x14906
testb $0x3, %al
jne 0x4fd9
movq 0x30(%rbx), %rdi
callq 0x14906
cmpq 0x190db(%rip), %rax     # 0x1dfc0
je 0x4fd9
movq 0x30(%rbx), %rdi
callq 0x14906
movq %rax, %rdi
callq 0x14906
testq %rax, %rax
je 0x4fd9
movq 0x30(%rbx), %rdi
callq 0x14906
movq %rax, %rdi
callq 0x14906
testb $0x3, %al
jne 0x4fd9
movq 0x30(%rbx), %rdi
callq 0x14906
movq %rax, %rdi
callq 0x14906
cmpq 0x1908a(%rip), %rax     # 0x1dfc0
je 0x4fd9
movq 0x30(%rbx), %rdi
callq 0x14906
movq %rax, %rdi
callq 0x147fb
movq %rax, %r15
movq 0x50(%rbx), %rdi
movq 0x58(%rbx), %rsi
callq 0xd231
movq %rax, %r12
leaq 0x19989(%rip), %rax     # 0x1e8f0
cmpl $0x0, (%rax)
je 0x4fac
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x15df4
testl %eax, %eax
je 0x4fac
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x321, 0xc(%rax)       # imm = 0x321
movq %r12, %rdi
callq 0xed08
leaq 0x122b4(%rip), %rdi     # 0x17256
movq %rax, %rsi
xorl %eax, %eax
callq 0x166f0
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xda94
leaq 0x8(%rsp), %rdi
movl $0x327, 0xc(%rdi)       # imm = 0x327
callq 0x167f2
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x19910(%rip), %rax     # 0x1e8f0
cmpl $0x0, (%rax)
je 0x502e
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x15df4
testl %eax, %eax
je 0x502e
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x324, 0xc(%rax)       # imm = 0x324
movq 0x30(%rbx), %rdi
callq 0x14906
movq %rax, %rdi
callq 0xed08
leaq 0x1203c(%rip), %rdi     # 0x17060
movq %rax, %rsi
xorl %eax, %eax
callq 0x166f0
callq 0x2050
// File: /workspace/github_c_makefile_star2_O2/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 0x14906
movq %rax, (%rsp)
movq 0x30(%rbx), %rdi
callq 0x147fb
movq %rax, %rdi
callq 0xcd5b
movq %rax, %r12
leaq 0x121f3(%rip), %rax     # 0x1725f
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x192a5(%rip), %r15     # 0x1e320
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x339, 0xc(%rdi)       # imm = 0x339
leaq 0x14926(%rip), %rbp     # 0x199bc
movq %rbp, 0x10(%rdi)
leaq 0x1909f(%rip), %rcx     # 0x1e140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16679
movq %r12, %rdi
callq 0x147fb
movq %rax, 0x8(%rsp)
movq %r12, %rdi
callq 0x14906
movq %rax, %r13
movq %rax, %rdi
callq 0x147fb
movq %rax, %r12
leaq 0x19818(%rip), %r14     # 0x1e8f0
cmpl $0x0, (%r14)
je 0x5165
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %rbp, 0x10(%rax)
movq %rbp, %rdi
callq 0x15df4
testl %eax, %eax
je 0x5120
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x33d, 0xc(%rax)       # imm = 0x33D
movq %r12, %rdi
callq 0xed08
leaq 0x11f84(%rip), %rdi     # 0x1709a
movq %rax, %rsi
xorl %eax, %eax
callq 0x166f0
cmpl $0x0, (%r14)
je 0x5165
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %rbp, 0x10(%rax)
movq %rbp, %rdi
callq 0x15df4
testl %eax, %eax
je 0x5165
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x33e, 0xc(%rax)       # imm = 0x33E
movq (%rsp), %rdi
callq 0xed08
leaq 0x11f49(%rip), %rdi     # 0x170a4
movq %rax, %rsi
xorl %eax, %eax
callq 0x166f0
movq %r13, %rdi
callq 0x14906
movq %rax, %r13
leaq 0x19119(%rip), %rsi     # 0x1e290
movq (%rsp), %rdi
callq 0x14764
movq %r12, %rdi
movq %rax, %rsi
callq 0x14764
movq %rax, %r14
leaq 0x11f1a(%rip), %rdi     # 0x170af
callq 0x11f1f
movq %rax, %rdi
movq %r14, %rsi
callq 0x14764
movq %rax, %rdi
movq %r13, %rsi
callq 0x14764
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x14764
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xda94
leaq 0x10(%rsp), %rdi
movl $0x347, 0xc(%rdi)       # imm = 0x347
callq 0x167f2
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x14906
movq %rax, (%rsp)
movq 0x30(%rbx), %rdi
callq 0x147fb
movq %rax, %rdi
callq 0xcd5b
movq %rax, %r12
leaq 0x11a53(%rip), %rax     # 0x17287
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x18add(%rip), %r15     # 0x1e320
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x3a6, 0xc(%rdi)       # imm = 0x3A6
leaq 0x1415e(%rip), %rbp     # 0x199bc
movq %rbp, 0x10(%rdi)
leaq 0x188d7(%rip), %rcx     # 0x1e140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16679
movq %r12, %rdi
callq 0x147fb
movq %rax, 0x8(%rsp)
movq %r12, %rdi
callq 0x14906
movq %rax, %r13
movq %rax, %rdi
callq 0x147fb
movq %rax, %r12
leaq 0x19050(%rip), %r14     # 0x1e8f0
cmpl $0x0, (%r14)
je 0x592d
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %rbp, 0x10(%rax)
movq %rbp, %rdi
callq 0x15df4
testl %eax, %eax
je 0x58e8
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x3aa, 0xc(%rax)       # imm = 0x3AA
movq %r12, %rdi
callq 0xed08
leaq 0x117bc(%rip), %rdi     # 0x1709a
movq %rax, %rsi
xorl %eax, %eax
callq 0x166f0
cmpl $0x0, (%r14)
je 0x592d
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %rbp, 0x10(%rax)
movq %rbp, %rdi
callq 0x15df4
testl %eax, %eax
je 0x592d
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x3ab, 0xc(%rax)       # imm = 0x3AB
movq (%rsp), %rdi
callq 0xed08
leaq 0x11781(%rip), %rdi     # 0x170a4
movq %rax, %rsi
xorl %eax, %eax
callq 0x166f0
movq %r13, %rdi
callq 0x14906
movq %rax, %r13
leaq 0x18951(%rip), %rsi     # 0x1e290
movq (%rsp), %rdi
callq 0x14764
movq %r12, %rdi
movq %rax, %rsi
callq 0x14764
movq %rax, %r14
leaq 0x11759(%rip), %rdi     # 0x170b6
callq 0x11f1f
movq %rax, %rdi
movq %r14, %rsi
callq 0x14764
movq %rax, %rdi
movq %r13, %rsi
callq 0x14764
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x14764
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xda94
leaq 0x10(%rsp), %rdi
movl $0x3b4, 0xc(%rdi)       # imm = 0x3B4
callq 0x167f2
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x14906
movq %rax, %r14
leaq 0x114ab(%rip), %rax     # 0x172a2
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1851c(%rip), %rax     # 0x1e320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x3f5, 0xc(%rdi)       # imm = 0x3F5
leaq 0x13b9d(%rip), %rcx     # 0x199bc
movq %rcx, 0x10(%rdi)
leaq 0x18316(%rip), %rcx     # 0x1e140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16679
movq 0x30(%rbx), %rdi
callq 0x147fb
movq %rax, %rdi
callq 0xcd5b
movq %rax, %rdi
callq 0x147fb
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x147fb
movq %rax, %rdi
callq 0xcd5b
movq %rax, %rdi
callq 0x14906
movq %rax, %r13
leaq 0x18a7a(%rip), %rbp     # 0x1e8f0
movl (%rbp), %eax
testq %r14, %r14
je 0x5f6c
movl %r14d, %ecx
andl $0x3, %ecx
jne 0x5f6c
testl %eax, %eax
je 0x5f35
leaq 0x18483(%rip), %r15     # 0x1e320
movq (%r15), %rax
movq 0x50(%rax), %rax
leaq 0x13b11(%rip), %rdi     # 0x199bc
movq %rdi, 0x10(%rax)
callq 0x15df4
testl %eax, %eax
je 0x5edf
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x3f9, 0xc(%rax)       # imm = 0x3F9
movq %r14, %rdi
callq 0xed08
leaq 0x113db(%rip), %rdi     # 0x172b0
movq %rax, %rsi
xorl %eax, %eax
callq 0x166f0
cmpl $0x0, (%rbp)
je 0x5f35
leaq 0x18434(%rip), %rax     # 0x1e320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x13ac2(%rip), %rdi     # 0x199bc
movq %rdi, 0x10(%rax)
callq 0x15df4
testl %eax, %eax
je 0x5f35
leaq 0x18412(%rip), %rax     # 0x1e320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x3fa, 0xc(%rax)       # imm = 0x3FA
movq %r13, %rdi
callq 0xed08
leaq 0x11179(%rip), %rdi     # 0x170a4
movq %rax, %rsi
xorl %eax, %eax
callq 0x166f0
movq %r13, %rdi
movq %r14, %rsi
callq 0x14764
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xda94
movq %rsp, %rdi
movl $0x400, 0xc(%rdi)       # imm = 0x400
callq 0x167f2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %eax, %eax
je 0x5fc9
leaq 0x183a9(%rip), %rax     # 0x1e320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x13a37(%rip), %rdi     # 0x199bc
movq %rdi, 0x10(%rax)
callq 0x15df4
testl %eax, %eax
je 0x5fc9
leaq 0x18387(%rip), %rax     # 0x1e320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x3fd, 0xc(%rax)       # imm = 0x3FD
movq 0x30(%rbx), %rdi
callq 0x14906
movq %rax, %rdi
callq 0xed08
leaq 0x110a1(%rip), %rdi     # 0x17060
movq %rax, %rsi
xorl %eax, %eax
callq 0x166f0
callq 0x2050