LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/aes128poetv1aes4/ref/poet.c
// Function: process_header
void process_header(struct poet_ctx *ctx, const uint8_t  *header,
		    uint64_t header_len)
{
  block mask;
  block factor;
  block in;
  block out;
  block product;
  uint64_t offset=0;

  ctx->mlen=0;
  memset(factor,0,BLOCKLEN);
  memset(product,0,BLOCKLEN);
  memset(mask,0,BLOCKLEN);
  memset(ctx->tau,0,BLOCKLEN);

  product[0] = 0x80; // since 1000 0000 = 1
  factor[0]  = 0x40; // since 0100 0000 = 2

  while(header_len > BLOCKLEN)
    {
      gf_mul(mask, product, ctx->l);
      xor_block(in,header+offset,mask);
      AES_encrypt(in,out,&(ctx->aes_enc));
      xor_block(ctx->tau,out,ctx->tau);

      offset += BLOCKLEN;
      header_len -= BLOCKLEN;

      gf_mul(product,product,factor);
    }

  /* LASTBLOCK */
  if(header_len < 16)
    {
      factor[0]=0xA0; // 1010 0000 = 5 in Big Endian
      memset(in,0,BLOCKLEN);
      memcpy(in,header+offset,header_len);
      in[header_len]=0x80;
    }
  else
    {
      factor[0]=0xC0; // 1100 0000 = 3 in Big Endian
      memcpy(in,header+offset,BLOCKLEN);
    }

  gf_mul(product,product,factor);
  gf_mul(mask,product,ctx->l);
  xor_block(in,mask,in);

  xor_block(in,in,ctx->tau);
  AES_encrypt(in ,ctx->tau, &(ctx->aes_enc));

  memcpy(ctx->x, ctx->tau, BLOCKLEN);
  memcpy(ctx->y, ctx->tau, BLOCKLEN);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq $0x0, 0x450(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, 0x20(%rsp)
vmovaps %xmm0, 0x10(%rsp)
vmovaps %xmm0, 0x30(%rsp)
movq %rdx, %r14
movq %rsi, %r15
vmovups %xmm0, 0x440(%rdi)
movb $-0x80, 0x10(%rsp)
movb $0x40, 0x20(%rsp)
cmpq $0x11, %rdx
jb 0x3cbc
leaq 0x3f0(%rbx), %r12
xorl %r13d, %r13d
leaq 0x10(%rsp), %rbp
leaq 0x30(%rsp), %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x1030
vmovaps 0x30(%rsp), %xmm0
vxorps (%r15,%r13), %xmm0, %xmm0
vmovaps %xmm0, (%rsp)
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
movq %rbx, %rdx
callq 0x1050
vmovups 0x440(%rbx), %xmm0
vxorps 0x40(%rsp), %xmm0, %xmm0
vmovups %xmm0, 0x440(%rbx)
addq $0x10, %r13
addq $-0x10, %r14
movq %rbp, %rdi
movq %rbp, %rsi
leaq 0x20(%rsp), %rdx
callq 0x1030
cmpq $0x10, %r14
ja 0x3c55
jmp 0x3cbf
xorl %r13d, %r13d
leaq 0x440(%rbx), %r12
cmpq $0x10, %r14
jne 0x3cdb
vmovups (%r15,%r13), %xmm0
vmovaps %xmm0, (%rsp)
movb $-0x40, %al
jmp 0x3cfb
vxorps %xmm0, %xmm0, %xmm0
movq %rsp, %rdi
vmovaps %xmm0, (%rdi)
addq %r13, %r15
movq %r15, %rsi
movq %r14, %rdx
callq 0x1100
movb $-0x80, (%rsp,%r14)
movb $-0x60, %al
leaq 0x20(%rsp), %rdx
movb %al, (%rdx)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %r14, %rsi
callq 0x1030
leaq 0x3f0(%rbx), %rdx
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1030
movq %rsp, %rdi
vmovaps (%rdi), %xmm0
vxorps (%r15), %xmm0, %xmm0
vmovaps %xmm0, (%rdi)
vxorps 0x440(%rbx), %xmm0, %xmm0
vmovaps %xmm0, (%rdi)
movq %r12, %rsi
movq %rbx, %rdx
callq 0x1050
vmovups (%r12), %xmm0
vmovups %xmm0, 0x420(%rbx)
vmovups (%r12), %xmm0
vmovups %xmm0, 0x430(%rbx)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/aes128poetv1aes4/ref/poet.c
// Function: encrypt_block
void encrypt_block(struct poet_ctx *ctx, const uint8_t plaintext[16],
		   uint8_t ciphertext[16])
{
  block tmp;
  TOP_HASH;
  xor_block(ctx->x, plaintext,ctx->x);

  AES_encrypt(ctx->x, tmp, &(ctx->aes_enc));

  BOTTOM_HASH;
  xor_block(ciphertext, tmp,ctx->y);

  memcpy(ctx->y, tmp, BLOCKLEN);
  ctx->mlen+=BLOCKLEN_BITS;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x420(%rdi), %r15
leaq 0x1e8(%rdi), %rdx
movq %r15, %rdi
movq %r15, %rsi
callq 0x10f0
movl $0x420, %eax            # imm = 0x420
movb -0x420(%r12,%rax), %cl
xorb %cl, (%rbx,%rax)
incq %rax
cmpq $0x430, %rax            # imm = 0x430
jne 0x3dad
movq %rsp, %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1050
leaq 0x430(%rbx), %r15
leaq 0x2dc(%rbx), %rdx
movq %r15, %rdi
movq %r15, %rsi
callq 0x10f0
xorl %eax, %eax
movb (%r15,%rax), %cl
xorb (%rsp,%rax), %cl
movb %cl, (%r14,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x3dec
vmovaps (%rsp), %xmm0
vmovups %xmm0, (%r15)
subq $-0x80, 0x450(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/dpw[P]skinny-mutex/skinny_mutex.c
// Function: skinny_mutex_lock_slow
int skinny_mutex_lock_slow(skinny_mutex_t *skinny)
{
	for (;;) {
		struct common *head = skinny->val;
		if (head) {
			struct fat_mutex *fat;
			int res = fat_mutex_get(skinny, head, &fat);
			if (!res) {
				fat->refcount++;
				res = fat_mutex_lock(skinny, fat);
			}

			if (res >= 0)
				return res;

			/* skinny_mutex value changed under us, try
			   again. */
		}
		else {
			/* Recapitulate skinny_mutex_lock */
			if (cas(&skinny->val, head, (void *)1))
				return 0;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x1, %r15d
leaq 0x8(%rsp), %r14
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x1405
movq %rbx, %rdi
movq %r14, %rdx
callq 0x141c
movl %eax, %ecx
testl %eax, %eax
jne 0x13ff
movq 0x8(%rsp), %rsi
incq 0x10(%rsi)
movq %rbx, %rdi
callq 0x1507
movl %eax, %ecx
testl %ecx, %ecx
js 0x13d3
jmp 0x1410
xorl %ecx, %ecx
xorl %eax, %eax
lock
cmpxchgq %r15, (%rbx)
jne 0x13d3
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/dpw[P]skinny-mutex/skinny_mutex.c
// Function: fat_mutex_get
static int fat_mutex_get(skinny_mutex_t *skinny, struct common *head,
			 struct fat_mutex **fatp)
{
	if ((uintptr_t)head <= 1)
		return skinny_mutex_promote(skinny, head, fatp);
	else
		return fat_mutex_peg(skinny, head, fatp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq $0x1, %rsi
ja 0x14d5
movl $0x70, %edi
callq 0x1110
movq %rax, (%r14)
testq %rax, %rax
je 0x14f1
movq %rax, %rbx
movw $0x100, (%rax)          # imm = 0x100
movq $0x1, 0x10(%rax)
movq $0x0, 0x8(%rax)
leaq 0x18(%rax), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x11a0
movl %eax, %ebp
testl %eax, %eax
jne 0x14cb
movq %rbx, %r13
addq $0x40, %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x10f0
movl %eax, %ebp
testl %eax, %eax
jne 0x14c3
movq %r14, %rdi
callq 0x11b0
movl %eax, %ebp
testl %eax, %eax
jne 0x14bb
xorl %ebp, %ebp
movq %r15, %rax
lock
cmpxchgq %rbx, (%r12)
je 0x14f6
movq %r14, %rdi
callq 0x1100
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %r13, %rdi
callq 0x1160
movq %r14, %rdi
callq 0x1090
movq %rbx, %rdi
callq 0x1030
jmp 0x14f6
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1684
movl $0xc, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x157b
movq %rdi, 0x8(%rsp)
incq 0x8(%rbx)
leaq 0x40(%rbx), %r15
leaq 0x18(%rbx), %r12
leaq 0x4(%rsp), %r13
leaq 0x14(%rsp), %rbp
movl $0x1, %edi
movq %r13, %rsi
callq 0x1070
testl %eax, %eax
jne 0x15d6
movq %r15, %rdi
movq %r12, %rsi
callq 0x1060
movl %eax, %r14d
movl 0x4(%rsp), %edi
movq %rbp, %rsi
callq 0x1070
testl %eax, %eax
jne 0x15b7
testl %r14d, %r14d
jne 0x158d
cmpb $0x0, 0x1(%rbx)
jne 0x1539
decq 0x8(%rbx)
movb $0x1, 0x1(%rbx)
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x1100
jmp 0x15a8
decq 0x8(%rbx)
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x1854
movl %r14d, %edi
movl %eax, %esi
callq 0x1779
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1aca(%rip), %rdi      # 0x3088
leaq 0x1a7b(%rip), %rsi      # 0x3040
leaq 0x1a83(%rip), %rcx      # 0x304f
movl $0x1f3, %edx            # imm = 0x1F3
callq 0x10c0
leaq 0x1a27(%rip), %rdi      # 0x3004
leaq 0x1a5c(%rip), %rsi      # 0x3040
leaq 0x1a64(%rip), %rcx      # 0x304f
movl $0x1f1, %edx            # imm = 0x1F1
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x1, %r15d
leaq 0x8(%rsp), %r14
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x162d
cmpq $0x1, %rsi
je 0x163a
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1684
testl %eax, %eax
jg 0x1641
js 0x160c
jmp 0x164f
xorl %ecx, %ecx
xorl %eax, %eax
lock
cmpxchgq %r15, (%rbx)
jne 0x160c
jmp 0x1643
movl $0x10, %ecx
jmp 0x1643
movl %eax, %ecx
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rsp), %rdi
movl $0x10, %ebx
cmpb $0x0, 0x1(%rdi)
jne 0x1669
movb $0x1, 0x1(%rdi)
incq 0x10(%rdi)
xorl %ebx, %ebx
addq $0x18, %rdi
callq 0x1100
movl %ebx, %edi
movl %eax, %esi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1779
// File: /workspace/github_c_makefile_star2_O3/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 0x1787
movl %esi, %edx
testl %eax, %eax
jne 0x1788
movl %edx, %eax
retq
pushq %rax
movq 0x3868(%rip), %rcx      # 0x4ff8
movq (%rcx), %rdi
leaq 0x191e(%rip), %rsi      # 0x30b8
movl %eax, %ecx
xorl %eax, %eax
callq 0x10e0
callq 0x1040
// File: /workspace/github_c_makefile_star2_O3/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 0x1806
testl %eax, %eax
je 0x17ca
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8(%rsp), %r14
movb $0x0, 0x1(%r14)
cmpq $0x0, 0x8(%r14)
je 0x17e8
leaq 0x40(%r14), %rdi
callq 0x10d0
movl %eax, %ebp
jmp 0x17ea
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1854
movl %ebp, %edi
movl %eax, %esi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1779
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%r14), %rsi
testq %rsi, %rsi
je 0x182b
movq %r14, %rdi
movq %rbx, %rdx
callq 0x141c
testl %eax, %eax
je 0x1832
js 0x1810
jmp 0x184c
movl $0x1, %eax
jmp 0x184c
movq (%rbx), %rdi
xorl %eax, %eax
cmpb $0x0, 0x1(%rdi)
jne 0x184c
addq $0x18, %rdi
callq 0x1100
cmpl $0x1, %eax
adcl $0x0, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x18c6
movq %rsi, %rbx
decq 0x10(%rsi)
je 0x1877
addq $0x18, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1100
xorl %ecx, %ecx
movq %rbx, %rax
lock
cmpxchgq %rcx, (%rdi)
sete %bpl
leaq 0x18(%rbx), %r14
movq %r14, %rdi
callq 0x1100
testl %eax, %eax
sete %cl
andb %bpl, %cl
cmpb $0x1, %cl
jne 0x18c1
movq %r14, %rdi
callq 0x1090
testl %eax, %eax
jne 0x18c1
leaq 0x40(%rbx), %rdi
callq 0x1160
testl %eax, %eax
jne 0x18c1
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1820(%rip), %rdi      # 0x30ed
leaq 0x176c(%rip), %rsi      # 0x3040
leaq 0x181d(%rip), %rcx      # 0x30f8
movl $0x1c4, %edx            # imm = 0x1C4
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O3/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 0x1806
movl %eax, %ecx
testl %eax, %eax
jne 0x199a
movq 0x10(%rsp), %rbx
cmpq $0x0, 0x8(%rbx)
je 0x193d
leaq 0x40(%rbx), %rdi
callq 0x10d0
testl %eax, %eax
je 0x193d
movl %eax, %ebp
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x1100
movl %ebp, %ecx
jmp 0x199a
movb $0x0, 0x1(%rbx)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x1190
testl %eax, %eax
jne 0x19aa
leaq 0x20(%rsp), %rdi
callq 0x1170
leaq 0x18(%rbx), %rsi
movq %r15, %rdi
testq %r14, %r14
je 0x1971
movq %r14, %rdx
callq 0x1150
jmp 0x1976
callq 0x1060
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
callq 0x10a0
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x1507
movl %ebp, %edi
movl %eax, %esi
callq 0x1779
movl %eax, %ecx
movl %ecx, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %rdi
callq 0x19be
leaq 0x20(%rsp), %rdi
callq 0x1130
// File: /workspace/github_c_makefile_star2_O3/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 0x175b(%rip), %rdi      # 0x3183
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x1080
movq 0x359f(%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 0x1a49
leaq 0x4db(%rip), %rcx       # 0x1f49
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 0x16e8(%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_O3/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 0x1f5d
movq %rax, 0x8(%rbx)
movl (%rbx), %ebp
testl %ebp, %ebp
je 0x1b27
xorl %r15d, %r15d
movl $0x1, %r12d
leaq 0x8(%rsp), %r14
xorl %eax, %eax
lock
cmpxchgq %r12, 0x8(%rsp)
jne 0x1b13
movl $0x1, %eax
lock
cmpxchgq %r15, 0x8(%rsp)
jne 0x1b1d
decl %ebp
jne 0x1af4
jmp 0x1b27
movq %r14, %rdi
callq 0x11d0
jmp 0x1aff
movq %r14, %rdi
callq 0x11f9
jmp 0x1b0d
callq 0x1f5d
movq %rax, 0x10(%rbx)
cmpq $0x0, 0x8(%rsp)
jne 0x1b45
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16b8(%rip), %rdi      # 0x3204
leaq 0x1658(%rip), %rsi      # 0x31ab
leaq 0x1658(%rip), %rcx      # 0x31b2
movl $0x58, %edx
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O3/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 0x330d(%rip), %r12      # 0x50f0
testq %r12, %r12
je 0x1e2f
movq %rdi, %rbx
movq 0x32f6(%rip), %r13      # 0x50e8
addq $0x8, %r13
xorl %r14d, %r14d
movq -0x8(%r13), %rdi
testq %rdi, %rdi
je 0x1e23
movq (%r13), %r15
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1050
testl %eax, %eax
jne 0x1e23
movzbl (%rbx,%r15), %eax
testl %eax, %eax
je 0x1e36
cmpl $0x3d, %eax
je 0x1e36
incq %r14
addq $0x18, %r13
cmpq %r14, %r12
jne 0x1df9
movq 0x329a(%rip), %r14      # 0x50d0
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x3245(%rip)      # 0x5090
jne 0x1e9e
cmpl $0x0, 0x325c(%rip)      # 0x50b0
je 0x1ea3
cmpq %rdi, 0x323b(%rip)      # 0x5098
je 0x1ec2
movq 0x3262(%rip), %rbx      # 0x50c8
cmpq 0x326b(%rip), %rbx      # 0x50d8
je 0x1e99
cmpq 0x325a(%rip), %rbx      # 0x50d0
je 0x1e99
cmpq 0x3271(%rip), %rbx      # 0x50f0
jae 0x1ee1
movq 0x3260(%rip), %rax      # 0x50e8
leaq (%rbx,%rbx,2), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1090
testl %eax, %eax
jne 0x1ee1
movq %rbx, %rax
popq %rbx
retq
callq 0x1341
leaq 0x1426(%rip), %rdi      # 0x32d0
leaq 0x135c(%rip), %rsi      # 0x320d
leaq 0x1366(%rip), %rcx      # 0x321e
movl $0x113, %edx            # imm = 0x113
callq 0x1070
leaq 0x1378(%rip), %rdi      # 0x3241
leaq 0x133d(%rip), %rsi      # 0x320d
leaq 0x1347(%rip), %rcx      # 0x321e
movl $0x116, %edx            # imm = 0x116
callq 0x1070
leaq 0x136c(%rip), %rdi      # 0x3254
leaq 0x131e(%rip), %rsi      # 0x320d
leaq 0x1328(%rip), %rcx      # 0x321e
movl $0x11d, %edx            # imm = 0x11D
callq 0x1070
// File: /workspace/github_c_makefile_star2_O3/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, 0x3181(%rip)      # 0x5090
jne 0x1fa7
cmpl $0x0, 0x3194(%rip)      # 0x50b0
jne 0x1fac
movq 0x31bf(%rip), %r15      # 0x50e8
testq %r15, %r15
je 0x1fcb
leaq (%rsi,%rsi,2), %r12
cmpq $0x0, (%r15,%r12,8)
jne 0x1fea
movq %rdi, %r14
cmpb $0x2d, (%rdi)
jne 0x1f60
movl %edx, %ebx
movzbl 0x1(%r14), %eax
cmpl $0x2d, %eax
je 0x1f68
testl %eax, %eax
je 0x1f60
cmpb $0x0, 0x2(%r14)
je 0x1f6f
movq %r14, %rdi
callq 0x13e3
cmpb $0x0, 0x2(%r14)
je 0x1f60
movq %r14, %rdi
callq 0x1dd3
cmpq 0x3152(%rip), %rax      # 0x50d0
jne 0x2009
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
callq 0x1392
leaq 0x131c(%rip), %rdi      # 0x32cf
leaq 0x1253(%rip), %rsi      # 0x320d
leaq 0x1322(%rip), %rcx      # 0x32e3
movl $0x12c, %edx            # imm = 0x12C
callq 0x1070
leaq 0x1345(%rip), %rdi      # 0x3317
leaq 0x1234(%rip), %rsi      # 0x320d
leaq 0x1303(%rip), %rcx      # 0x32e3
movl $0x12f, %edx            # imm = 0x12F
callq 0x1070
leaq 0x1333(%rip), %rdi      # 0x3324
leaq 0x1215(%rip), %rsi      # 0x320d
leaq 0x12e4(%rip), %rcx      # 0x32e3
movl $0x132, %edx            # imm = 0x132
callq 0x1070
movq %r14, %rdi
callq 0x1439
// File: /workspace/github_c_makefile_star2_O3/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, 0x3077(%rip)      # 0x5090
jne 0x202d
cmpl $0x0, 0x308e(%rip)      # 0x50b0
jne 0x2032
movq %rdi, 0x30ad(%rip)      # 0x50d8
popq %rax
retq
callq 0x148f
leaq 0x1296(%rip), %rdi      # 0x32cf
leaq 0x11cd(%rip), %rsi      # 0x320d
leaq 0x133e(%rip), %rcx      # 0x3385
movl $0x14d, %edx            # imm = 0x14D
callq 0x1070
// File: /workspace/github_c_makefile_star2_O3/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, 0x3037(%rip)      # 0x5090
jne 0x2150
cmpl $0x0, 0x304a(%rip)      # 0x50b0
jne 0x2155
movq %rdi, %rbx
leaq (,%rdi,8), %rax
leaq (%rax,%rax,2), %rdi
callq 0x10b0
movq %rax, 0x3061(%rip)      # 0x50e8
testq %rbx, %rbx
setne %cl
testq %rax, %rax
sete %dl
testb %dl, %cl
jne 0x2174
testq %rbx, %rbx
je 0x2136
leaq 0x1(%rbx), %rcx
andq $-0x2, %rcx
leaq -0x1(%rbx), %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x108e(%rip), %xmm1     # 0x3150
movdqa 0x1096(%rip), %xmm2     # 0x3160
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x1096(%rip), %xmm4     # 0x3170
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %edx
notl %edx
testb $0x1, %dl
je 0x2112
movq $0x0, (%rax)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %edx
testb $0x1, %dl
je 0x2128
movq $0x0, 0x18(%rax)
paddq %xmm4, %xmm1
addq $0x30, %rax
addq $-0x2, %rcx
jne 0x20da
movq %rbx, 0x2fb3(%rip)      # 0x50f0
incq %rbx
movq %rbx, 0x2f89(%rip)      # 0x50d0
movq %rbx, 0x2f8a(%rip)      # 0x50d8
popq %rbx
retq
callq 0x14e0
leaq 0x1173(%rip), %rdi      # 0x32cf
leaq 0x10aa(%rip), %rsi      # 0x320d
leaq 0x1240(%rip), %rcx      # 0x33aa
movl $0x15e, %edx            # imm = 0x15E
callq 0x1070
callq 0x1531
// File: /workspace/github_c_makefile_star2_O3/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 0x1518d
movq %rax, %rdi
callq 0xf0bc
movq %rax, %rbx
leaq 0x158e4(%rip), %rax     # 0x18004
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1cbf1(%rip), %r15     # 0x1f320
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x5e, 0xc(%rdi)
leaq 0x18296(%rip), %r14     # 0x1a9e0
movq %r14, 0x10(%rdi)
leaq 0x1c9eb(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ea2
leaq 0x1d187(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x27a4
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x16604
testl %eax, %eax
je 0x27a4
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x5f, 0xc(%rax)
leaq 0x15874(%rip), %rdi     # 0x1800e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x16f13
movq 0x1c84d(%rip), %rax     # 0x1eff8
movq (%rax), %rdi
leaq 0x15863(%rip), %rsi     # 0x18018
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2170
callq 0x2050
// File: /workspace/github_c_makefile_star2_O3/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 0x1584c(%rip), %rax     # 0x18023
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1cb3a(%rip), %r15     # 0x1f320
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x67, 0xc(%rdi)
leaq 0x181df(%rip), %r14     # 0x1a9e0
movq %r14, 0x10(%rdi)
leaq 0x1c934(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ea2
leaq 0x1d0d0(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x286c
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x16604
testl %eax, %eax
je 0x286c
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x68, 0xc(%rax)
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %rdi
callq 0xf0bc
leaq 0x157cd(%rip), %rdi     # 0x1802f
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
movq 0x30(%rbx), %rdi
callq 0x150ee
movq %rax, %rdi
callq 0xd1e1
cmpq 0x1c73c(%rip), %rax     # 0x1efc0
je 0x28b0
movq 0x30(%rbx), %rdi
callq 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rax, %rdi
callq 0xf0bc
leaq 0x15793(%rip), %rdi     # 0x18039
movq %rax, %rsi
xorl %eax, %eax
callq 0x20e0
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %rdi
callq 0xf0bc
movq %rax, %rdi
callq 0x20a0
leaq 0x8(%rsp), %rdi
movl $0x6d, 0xc(%rdi)
callq 0x17027
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x15746(%rip), %rax     # 0x1803d
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
leaq 0x1ca1a(%rip), %rax     # 0x1f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rbx)
movl $0x7b, 0xc(%rbx)
leaq 0x180bf(%rip), %rcx     # 0x1a9e0
movq %rcx, 0x10(%rbx)
leaq 0x1c814(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rbx, %rdi
callq 0x16ea2
movq 0x30(%r14), %rdi
callq 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rax, %r15
movq 0x30(%r14), %rdi
callq 0x1518d
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xde17
movq 0x30(%r14), %rdi
callq 0x150ee
leaq 0xa89d(%rip), %rsi      # 0xd214
leaq 0x1c912(%rip), %rdx     # 0x1f290
movq %rax, %rdi
callq 0xd43a
movl $0x7e, 0xc(%rbx)
movq %rbx, %rdi
callq 0x17027
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rax, %rdi
callq 0x150ee
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rax, %rdi
callq 0x1518d
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %r13
leaq 0x15650(%rip), %rax     # 0x1804a
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
leaq 0x1c917(%rip), %rax     # 0x1f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%r15)
movl $0x8d, 0xc(%r15)
leaq 0x17fba(%rip), %rcx     # 0x1a9e0
movq %rcx, 0x10(%r15)
leaq 0x1c70f(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%r15)
movq %rax, 0x20(%r15)
movq %r15, %rdi
callq 0x16ea2
movq %r12, %rdi
movq %r13, %rsi
callq 0x150cc
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xde17
movl $0x8f, 0xc(%r15)
movq %r15, %rdi
callq 0x17027
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x155c9(%rip), %rax     # 0x18054
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1c886(%rip), %r15     # 0x1f320
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x9a, 0xc(%rdi)
leaq 0x17f2b(%rip), %r14     # 0x1a9e0
movq %r14, 0x10(%rdi)
leaq 0x1c680(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ea2
movq 0x30(%rbx), %rdi
callq 0x1518d
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x2b24
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xde17
leaq 0x8(%rsp), %rdi
movl $0xa1, 0xc(%rdi)
callq 0x17027
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1cdc5(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x2b77
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x16604
testl %eax, %eax
je 0x2b77
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x9e, 0xc(%rax)
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %rdi
callq 0xf0bc
leaq 0x154f3(%rip), %rdi     # 0x18060
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
callq 0x2050
// File: /workspace/github_c_makefile_star2_O3/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 0x1b6ed(%rip), %rcx     # 0x1f390
movq 0x1b6ee(%rip), %rax     # 0x1f398
cmpq %rax, %rcx
jne 0x3ce1
leaq 0x14970(%rip), %rdi     # 0x18626
callq 0x1257b
movq %rax, 0x1b6ce(%rip)     # 0x1f390
leaq 0x14960(%rip), %rdi     # 0x18629
callq 0x1257b
movq %rax, 0x1b6c3(%rip)     # 0x1f398
movq 0x1b6b4(%rip), %rcx     # 0x1f390
cmpq %rax, %rcx
je 0x3cea
testq %rbx, %rbx
cmovneq %rcx, %rax
popq %rbx
retq
leaq 0x15039(%rip), %rdi     # 0x18d2a
leaq 0x146c3(%rip), %rsi     # 0x183bb
leaq 0x15047(%rip), %rcx     # 0x18d46
movl $0x44, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x141ca(%rip), %rax     # 0x181c5
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1b318(%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 0x169bc(%rip), %r14     # 0x1a9e0
movq %r14, 0x10(%rdi)
leaq 0x1b111(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ea2
movq 0x30(%rbx), %rdi
callq 0x1518d
testq %rax, %rax
je 0x4188
movq 0x30(%rbx), %rdi
callq 0x1518d
testb $0x3, %al
jne 0x4188
movq 0x30(%rbx), %rdi
callq 0x1518d
cmpq 0x1af51(%rip), %rax     # 0x1efc0
je 0x4188
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %rdi
callq 0x1518d
testq %rax, %rax
je 0x4188
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %rdi
callq 0x1518d
testb $0x3, %al
jne 0x4188
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %rdi
callq 0x1518d
cmpq 0x1af00(%rip), %rax     # 0x1efc0
je 0x4188
movq %rax, %r13
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %rdi
callq 0x150ee
movq %rax, %r15
movq %r13, %rdi
callq 0x150ee
movq %rax, %r12
movq %r13, %rdi
callq 0x1518d
movq %rax, %r13
leaq 0x1b7f6(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x413f
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x16604
testl %eax, %eax
je 0x413f
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x208, 0xc(%rax)       # imm = 0x208
movq %r12, %rdi
callq 0xf0bc
leaq 0x13fb7(%rip), %rdi     # 0x180ec
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
movq %r12, %rdi
movq %r13, %rsi
callq 0x150cc
leaq -0x448(%rip), %rsi      # 0x3d09
movq %rbx, %rdi
movq %rax, %rdx
callq 0xdd3a
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xde17
movq %rsp, %rdi
movl $0x20f, 0xc(%rdi)       # imm = 0x20F
callq 0x17027
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b761(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x41dd
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x16604
testl %eax, %eax
je 0x41dd
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x20c, 0xc(%rax)       # imm = 0x20C
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %rdi
callq 0xf0bc
leaq 0x13e8d(%rip), %rdi     # 0x18060
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
callq 0x2050
// File: /workspace/github_c_makefile_star2_O3/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 0x1518d
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rax, %rdi
callq 0x150ee
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rax, %rdi
callq 0x1518d
movq %rax, %r12
leaq 0x13f97(%rip), %rax     # 0x181d5
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1b0d5(%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 0x16779(%rip), %r13     # 0x1a9e0
movq %r13, 0x10(%rdi)
leaq 0x1aece(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ea2
leaq 0x1b66a(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x42cb
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r13, 0x10(%rax)
movq %r13, %rdi
callq 0x16604
testl %eax, %eax
je 0x42cb
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x222, 0xc(%rax)       # imm = 0x222
movq %r14, %rdi
callq 0xf0bc
leaq 0x13e2b(%rip), %rdi     # 0x180ec
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
movq %r14, %rdi
movq %r12, %rsi
callq 0x150cc
movq %r15, %rdi
movq %rax, %rsi
callq 0x150cc
movq 0x1b090(%rip), %rsi     # 0x1f378
movq %rbx, %rdi
movq %rax, %rdx
callq 0xde17
movq %rsp, %rdi
movl $0x226, 0xc(%rdi)       # imm = 0x226
callq 0x17027
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x13be5(%rip), %rax     # 0x181ee
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1ad0a(%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 0x163ae(%rip), %r14     # 0x1a9e0
movq %r14, 0x10(%rdi)
leaq 0x1ab03(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ea2
movq 0x30(%rbx), %rdi
callq 0x1518d
testq %rax, %rax
je 0x4796
movq 0x30(%rbx), %rdi
callq 0x1518d
testb $0x3, %al
jne 0x4796
movq 0x30(%rbx), %rdi
callq 0x1518d
cmpq 0x1a943(%rip), %rax     # 0x1efc0
je 0x4796
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %rdi
callq 0x1518d
testq %rax, %rax
je 0x4796
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %rdi
callq 0x1518d
testb $0x3, %al
jne 0x4796
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %rdi
callq 0x1518d
cmpq 0x1a8f2(%rip), %rax     # 0x1efc0
je 0x4796
movq %rax, %r13
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %rdi
callq 0x150ee
movq %rax, %r15
movq %r13, %rdi
callq 0x150ee
movq %rax, %r12
movq %r13, %rdi
callq 0x1518d
movq %rax, %r13
leaq 0x1b1e8(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x474d
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x16604
testl %eax, %eax
je 0x474d
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x267, 0xc(%rax)       # imm = 0x267
movq %r12, %rdi
callq 0xf0bc
leaq 0x139a9(%rip), %rdi     # 0x180ec
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
movq %r12, %rdi
movq %r13, %rsi
callq 0x150cc
leaq -0x44e(%rip), %rsi      # 0x4311
movq %rbx, %rdi
movq %rax, %rdx
callq 0xdd3a
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xde17
movq %rsp, %rdi
movl $0x26e, 0xc(%rdi)       # imm = 0x26E
callq 0x17027
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b153(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x47eb
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x16604
testl %eax, %eax
je 0x47eb
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x26b, 0xc(%rax)       # imm = 0x26B
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %rdi
callq 0xf0bc
leaq 0x1387f(%rip), %rdi     # 0x18060
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
callq 0x2050
// File: /workspace/github_c_makefile_star2_O3/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 0x1a01e(%rip), %rsi     # 0x1efc0
je 0x4fcb
movq %rsi, %rax
xorl %ebx, %ebx
leaq 0x1a2e0(%rip), %r14     # 0x1f290
testq %rax, %rax
je 0x4fd2
movl %eax, %ecx
andl $0x3, %ecx
jne 0x4fd2
movq %rax, %rdi
callq 0x1518d
decl %ebp
cmpq %r14, %rax
jne 0x4fb0
xorl %ebx, %ebx
testl %ebp, %ebp
sete %bl
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x13028(%rip), %rax     # 0x18248
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1a0f1(%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 0x15795(%rip), %r14     # 0x1a9e0
movq %r14, 0x10(%rdi)
leaq 0x19eea(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ea2
movq 0x30(%rbx), %rdi
callq 0x1518d
testq %rax, %rax
je 0x538a
movq 0x30(%rbx), %rdi
callq 0x1518d
testb $0x3, %al
jne 0x538a
movq 0x30(%rbx), %rdi
callq 0x1518d
cmpq 0x19d2a(%rip), %rax     # 0x1efc0
je 0x538a
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %rdi
callq 0x1518d
testq %rax, %rax
je 0x538a
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %rdi
callq 0x1518d
testb $0x3, %al
jne 0x538a
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %rdi
callq 0x1518d
cmpq 0x19cd9(%rip), %rax     # 0x1efc0
je 0x538a
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %rdi
callq 0x150ee
movq %rax, %r15
movq 0x50(%rbx), %rdi
movq 0x58(%rbx), %rsi
callq 0xd555
movq %rax, %r12
leaq 0x1a5d8(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x535d
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x16604
testl %eax, %eax
je 0x535d
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x321, 0xc(%rax)       # imm = 0x321
movq %r12, %rdi
callq 0xf0bc
leaq 0x12f03(%rip), %rdi     # 0x18256
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xde17
leaq 0x8(%rsp), %rdi
movl $0x327, 0xc(%rdi)       # imm = 0x327
callq 0x17027
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1a55f(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x53df
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x16604
testl %eax, %eax
je 0x53df
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x324, 0xc(%rax)       # imm = 0x324
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %rdi
callq 0xf0bc
leaq 0x12c8b(%rip), %rdi     # 0x18060
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
callq 0x2050