LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/kernel.c
// Function: string_source
SOURCE*
string_source(char* s)
{
	SOURCE* src;

	DBUG_ENTER("string_source");
	DBUG_PRINT("s", ((s ? "\"%s\"" : "NULL"), s));
	src = NEW(SOURCE);
	src->context = MK_REF(s);
	src->empty = string_empty;
	src->get = string_get;
	src->next = string_next;
	DBUG_RETURN src;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x19208(%rip), %rax     # 0x1c0cf
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x2045c(%rip), %r14     # 0x23330
movq (%r14), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xd0, 0xc(%rdi)
leaq 0x1945b(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x20256(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
leaq 0x20a22(%rip), %rax     # 0x23930
cmpl $0x0, (%rax)
je 0x2f5b
movq (%r14), %rax
movq 0x50(%rax), %rax
leaq 0x1a634(%rip), %rdi     # 0x1d555
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x2f5b
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0xd1, 0xc(%rax)
testq %rbx, %rbx
leaq 0x1b758(%rip), %rax     # 0x1e69e
leaq 0x1914b(%rip), %rdi     # 0x1c098
cmoveq %rax, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1ba97
movl $0x20, %edi
movl $0x1, %esi
callq 0x2160
movq %rax, %r14
leaq 0x3(,%rbx,4), %rax
movq %rax, (%r14)
leaq -0x3f2(%rip), %rax      # 0x2b8d
movq %rax, 0x8(%r14)
leaq -0x310(%rip), %rax      # 0x2c7a
movq %rax, 0x10(%r14)
leaq -0x1ce(%rip), %rax      # 0x2dc7
movq %rax, 0x18(%r14)
movq %rsp, %rdi
movl $0xd7, 0xc(%rdi)
callq 0x1bbab
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/kernel.c
// Function: file_get
CONS*
file_get(SOURCE* src)
{
	CONS* d;
	int c;

	DBUG_ENTER("file_get");
	DBUG_PRINT("context", ("%s", cons_to_str(src->context)));
	d = tl(src->context);
	if (nilp(d)) {
		(src->next)(src);
		d = tl(src->context);
	}
	c = MK_INT(d);
	DBUG_PRINT("c", ((isprint(c) ? "%d '%c'" : "%d '\\x%X'"), c, c));
	DBUG_RETURN d;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x19090(%rip), %rax     # 0x1c0e8
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x202cb(%rip), %r15     # 0x23330
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xe9, 0xc(%rdi)
leaq 0x192ca(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x200c5(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
leaq 0x20891(%rip), %r12     # 0x23930
cmpl $0x0, (%r12)
je 0x30e8
movq (%r15), %rax
movq 0x50(%rax), %rax
leaq 0x1903d(%rip), %rdi     # 0x1c0f1
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x30e8
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0xea, 0xc(%rax)
movq (%rbx), %rdi
callq 0x13c40
leaq 0x1a476(%rip), %rdi     # 0x1d554
movq %rax, %rsi
xorl %eax, %eax
callq 0x1ba97
movq (%rbx), %rdi
callq 0x19d11
movq %rax, %r14
cmpq 0x1fec6(%rip), %rax     # 0x22fc0
jne 0x310d
movq %rbx, %rdi
callq *0x18(%rbx)
movq (%rbx), %rdi
callq 0x19d11
movq %rax, %r14
cmpl $0x0, (%r12)
je 0x3172
movq (%r15), %rax
movq 0x50(%rax), %rax
leaq 0x1aa09(%rip), %rdi     # 0x1db2b
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x3172
movq %r14, %rbx
shrq $0x2, %rbx
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0xf1, 0xc(%rax)
callq 0x2260
movq (%rax), %rax
movslq %ebx, %rdx
movzwl (%rax,%rdx,2), %eax
btl $0xe, %eax
leaq 0x18eee(%rip), %rax     # 0x1c04c
leaq 0x18edf(%rip), %rdi     # 0x1c044
cmovaeq %rax, %rdi
movl %edx, %esi
xorl %eax, %eax
callq 0x1ba97
movq %rsp, %rdi
movl $0xf2, 0xc(%rdi)
callq 0x1bbab
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/kernel.c
// Function: file_next
CONS*
file_next(SOURCE* src)
{
	CONS* d;
	FILE* f;

	DBUG_ENTER("file_next");
	d = tl(src->context);
	if (d != NUMBER(EOF)) {
		CONS* r = hd(src->context);
		
		XDBUG_PRINT("stdin", ("%p", stdin));
		XDBUG_PRINT("input_file", ("%p", input_file));
		if (r == MK_REF(input_file)) {
			f = input_file;  /* FIXME: WORKAROUND FOR FILE* ENCODING */
		} else {
			f = (FILE*)(MK_PTR(r));
		}
		XDBUG_PRINT("f", ("%p", f));
		rplacd(src->context, NUMBER(fgetc(f)));
	}
	DBUG_RETURN d;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18f58(%rip), %rax     # 0x1c0f9
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x20182(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xfa, 0xc(%rdi)
leaq 0x19181(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1ff7c(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
movq (%rbx), %rdi
callq 0x19d11
movq %rax, %r14
cmpq $-0x1, %rax
je 0x3231
movq (%rbx), %rdi
callq 0x19c72
movq 0x2018f(%rip), %rcx     # 0x23390
leaq 0x3(,%rcx,4), %rdx
movq %rax, %rdi
sarq $0x2, %rdi
cmpq %rdx, %rax
cmoveq %rcx, %rdi
movq (%rbx), %rbx
callq 0x2120
cltq
leaq 0x3(,%rax,4), %rsi
movq %rbx, %rdi
callq 0x19dbe
movq %rsp, %rdi
movl $0x109, 0xc(%rdi)       # imm = 0x109
callq 0x1bbab
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/kernel.c
// Function: file_source
SOURCE*
file_source(FILE* f)
{
	SOURCE* src;

	DBUG_ENTER("file_source");
	assert(f != NULL);
	DBUG_PRINT("f", ("%p", f));
	src = NEW(SOURCE);
	src->context = pr(MK_REF(f), NIL);
	DBUG_PRINT("f'", ("%p", MK_PTR(hd(src->context))));
	src->empty = file_empty;
	src->get = file_get;
	src->next = file_next;
	DBUG_PRINT("context", ("%s", cons_to_str(src->context)));
	DBUG_RETURN src;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x18ea3(%rip), %rax     # 0x1c103
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x200c3(%rip), %r15     # 0x23330
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x110, 0xc(%rdi)       # imm = 0x110
leaq 0x190c2(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1febd(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
testq %r14, %r14
je 0x3419
leaq 0x20680(%rip), %r12     # 0x23930
cmpl $0x0, (%r12)
je 0x32f1
movq (%r15), %rax
movq 0x50(%rax), %rax
leaq 0x18ea6(%rip), %rdi     # 0x1c16b
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x32f1
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x112, 0xc(%rax)       # imm = 0x112
leaq 0x1ad59(%rip), %rdi     # 0x1e040
movq %r14, %rsi
xorl %eax, %eax
callq 0x1ba97
movl $0x20, %edi
movl $0x1, %esi
callq 0x2160
movq %rax, %rbx
leaq 0x3(,%r14,4), %rdi
leaq 0x1ff8e(%rip), %rsi     # 0x232a0
callq 0x19c50
movq %rax, (%rbx)
cmpl $0x0, (%r12)
je 0x33da
movq %rax, %r14
movq (%r15), %rax
movq 0x50(%rax), %rax
leaq 0x18df5(%rip), %rdi     # 0x1c12b
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x336e
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x115, 0xc(%rax)       # imm = 0x115
movq %r14, %rdi
callq 0x19c72
sarq $0x2, %rax
leaq 0x1acdc(%rip), %rdi     # 0x1e040
movq %rax, %rsi
xorl %eax, %eax
callq 0x1ba97
leaq -0x3c2(%rip), %rax      # 0x2fb3
cmpl $0x0, (%r12)
movq %rax, 0x8(%rbx)
leaq -0x342(%rip), %rax      # 0x3043
movq %rax, 0x10(%rbx)
leaq -0x200(%rip), %rax      # 0x3190
movq %rax, 0x18(%rbx)
je 0x33fb
movq (%r15), %rax
movq 0x50(%rax), %rax
leaq 0x18d4d(%rip), %rdi     # 0x1c0f1
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x33fb
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x119, 0xc(%rax)       # imm = 0x119
movq %r14, %rdi
callq 0x13c40
leaq 0x1a186(%rip), %rdi     # 0x1d554
movq %rax, %rsi
xorl %eax, %eax
callq 0x1ba97
jmp 0x33fb
leaq -0x42e(%rip), %rax      # 0x2fb3
movq %rax, 0x8(%rbx)
leaq -0x3a9(%rip), %rax      # 0x3043
movq %rax, 0x10(%rbx)
leaq -0x267(%rip), %rax      # 0x3190
movq %rax, 0x18(%rbx)
movq %rsp, %rdi
movl $0x11a, 0xc(%rdi)       # imm = 0x11A
callq 0x1bbab
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1b279(%rip), %rdi     # 0x1e699
leaq 0x18bf5(%rip), %rsi     # 0x1c01c
leaq 0x18ce1(%rip), %rcx     # 0x1c10f
movl $0x111, %edx            # imm = 0x111
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/kernel.c
// Function: get_const
static CONS*
get_const(CONS* value)  /* USE FACTORY TO INTERN INSTANCES */
{
	CONS* constant;
	CONS* const_map = car(intern_map);

	DBUG_ENTER("get_const");
	DBUG_PRINT("value", ("%s", cons_to_str(value)));
	constant = map_get_def(const_map, value, NIL);
	if (nilp(constant)) {
		constant = ACTOR(const_type, value);
		const_map = map_put(const_map, value, constant);
		rplaca(intern_map, const_map);
	}
	DBUG_PRINT("const", ("%s", cons_to_str(constant)));
	DBUG_RETURN constant;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x1f537(%rip), %rdi     # 0x233c0
callq 0x19c72
movq %rax, %r14
leaq 0x188db(%rip), %rax     # 0x1c773
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1f48b(%rip), %r13     # 0x23330
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x338, 0xc(%rdi)       # imm = 0x338
leaq 0x18489(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1f284(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
leaq 0x1fa50(%rip), %rbp     # 0x23930
cmpl $0x0, (%rbp)
je 0x3f2a
movq (%r13), %rax
movq 0x50(%rax), %rax
leaq 0x1a1d2(%rip), %rdi     # 0x1e0c7
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x3f2a
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x339, 0xc(%rax)       # imm = 0x339
movq %rbx, %rdi
callq 0x13c40
leaq 0x19634(%rip), %rdi     # 0x1d554
movq %rax, %rsi
xorl %eax, %eax
callq 0x1ba97
leaq 0x1f36f(%rip), %r12     # 0x232a0
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1a146
movq %rax, %r15
cmpq %r12, %rax
jne 0x3f7d
movq 0x1f452(%rip), %rdi     # 0x233a0
leaq 0x434d(%rip), %rsi      # 0x82a2
movq %rbx, %rdx
callq 0x128be
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1a1b8
movq 0x1f44b(%rip), %rdi     # 0x233c0
movq %rax, %rsi
callq 0x19db0
cmpl $0x0, (%rbp)
je 0x3fc7
movq (%r13), %rax
movq 0x50(%rax), %rax
leaq 0x187e5(%rip), %rdi     # 0x1c777
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x3fc7
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x340, 0xc(%rax)       # imm = 0x340
movq %r15, %rdi
callq 0x13c40
leaq 0x19597(%rip), %rdi     # 0x1d554
movq %rax, %rsi
xorl %eax, %eax
callq 0x1ba97
movq %rsp, %rdi
movl $0x341, 0xc(%rdi)       # imm = 0x341
callq 0x1bbab
movq %r15, %rax
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/kernel.c
// Function: get_symbol
static CONS*
get_symbol(CONS* name)  /* USE FACTORY TO INTERN INSTANCES */
{
	CONS* symbol;
	CONS* symbol_map = cdr(intern_map);

	DBUG_ENTER("get_symbol");
	DBUG_PRINT("name", ("%s", cons_to_str(name)));
	symbol = map_get_def(symbol_map, name, NIL);
	if (nilp(symbol)) {
		symbol = ACTOR(symbol_type, name);
		symbol_map = map_put(symbol_map, name, symbol);
		rplacd(intern_map, symbol_map);
	}
	DBUG_PRINT("symbol", ("%s", cons_to_str(symbol)));
	DBUG_RETURN symbol;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x1f3c0(%rip), %rdi     # 0x233c0
callq 0x19d11
movq %rax, %r14
leaq 0x187aa(%rip), %rax     # 0x1c7b9
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1f314(%rip), %r13     # 0x23330
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x5c5, 0xc(%rdi)       # imm = 0x5C5
leaq 0x18312(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1f10d(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
leaq 0x1f8d9(%rip), %rbp     # 0x23930
cmpl $0x0, (%rbp)
je 0x40a1
movq (%r13), %rax
movq 0x50(%rax), %rax
leaq 0x18758(%rip), %rdi     # 0x1c7c4
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x40a1
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x5c6, 0xc(%rax)       # imm = 0x5C6
movq %rbx, %rdi
callq 0x13c40
leaq 0x194bd(%rip), %rdi     # 0x1d554
movq %rax, %rsi
xorl %eax, %eax
callq 0x1ba97
leaq 0x1f1f8(%rip), %r12     # 0x232a0
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1a146
movq %rax, %r15
cmpq %r12, %rax
jne 0x40f4
movq 0x1f2db(%rip), %rdi     # 0x233a0
leaq 0x4b5d(%rip), %rsi      # 0x8c29
movq %rbx, %rdx
callq 0x128be
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1a1b8
movq 0x1f2d4(%rip), %rdi     # 0x233c0
movq %rax, %rsi
callq 0x19dbe
cmpl $0x0, (%rbp)
je 0x413e
movq (%r13), %rax
movq 0x50(%rax), %rax
leaq 0x186b4(%rip), %rdi     # 0x1c7bd
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x413e
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x5cd, 0xc(%rax)       # imm = 0x5CD
movq %r15, %rdi
callq 0x13c40
leaq 0x19420(%rip), %rdi     # 0x1d554
movq %rax, %rsi
xorl %eax, %eax
callq 0x1ba97
movq %rsp, %rdi
movl $0x5ce, 0xc(%rdi)       # imm = 0x5CE
callq 0x1bbab
movq %r15, %rax
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/kernel.c
// Function: run_repl
void
run_repl(int batch)
{
	CONFIG* cfg = CFG;  /* USE GLOBAL CONFIGURATION */

	for (;;) {
		int remain = run_configuration(cfg, batch);

		if (remain < 0) {
			DBUG_PRINT("", ("%d messages queued (limit %d).", cfg->q_count, cfg->q_limit));
			break;		/* abnormal return */
		}
		DBUG_PRINT("", ("%d messages delivered (batch %d).", (batch - remain), batch));
		if (remain == 0) {
			fprintf(stderr, "\nMessage limit of %d exceeded!\n", batch);
			fprintf(stderr, "%d undelivered message(s)\n", cfg->q_count);
		}
		if (cfg->t_count > 0) {
			DBUG_PRINT("", ("waiting for timed event..."));
			sleep(1);
		} else {
			return;		/* no more work to do! */
		}
	}
	fprintf(stderr, "\nOutstanding messages exceeded limit of %d\n", cfg->q_limit);
	abort();	/* abnormal termination */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebp
movq 0x1f22d(%rip), %rbx     # 0x233a0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1300f
testl %eax, %eax
js 0x426c
movl %eax, %r14d
leaq 0x28(%rbx), %rax
movq %rax, (%rsp)
leaq 0x1f799(%rip), %r12     # 0x23930
leaq 0x1f192(%rip), %r13     # 0x23330
leaq 0x181a5(%rip), %r15     # 0x1c34a
cmpl $0x0, (%r12)
je 0x41e8
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0x1b188
testl %eax, %eax
je 0x41e8
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0xb17, 0xc(%rax)       # imm = 0xB17
movl %ebp, %esi
subl %r14d, %esi
leaq 0x17fb5(%rip), %rdi     # 0x1c194
movl %ebp, %edx
xorl %eax, %eax
callq 0x1ba97
testl %r14d, %r14d
je 0x4250
cmpl $0x0, 0x68(%rbx)
jle 0x425d
cmpl $0x0, (%r12)
je 0x422f
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0x1b188
testl %eax, %eax
je 0x422f
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0xb1d, 0xc(%rax)       # imm = 0xB1D
leaq 0x17fc9(%rip), %rdi     # 0x1c1f1
xorl %eax, %eax
callq 0x1ba97
movl $0x1, %edi
callq 0x2250
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1300f
movl %eax, %r14d
testl %eax, %eax
jns 0x41a5
jmp 0x426c
movl %ebp, %edi
movq (%rsp), %rsi
callq 0x2280
jmp 0x41ed
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x22bb
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/kernel.c
// Function: run_test
void
run_test(int limit)
{
	CONFIG* cfg = CFG;  /* USE GLOBAL CONFIGURATION */

	for (;;) {
		int remain = run_configuration(cfg, limit);

		if (remain < 0) {
			DBUG_PRINT("", ("%d messages queued (limit %d).", cfg->q_count, cfg->q_limit));
			break;		/* abnormal return */
		}
		DBUG_PRINT("", ("%d messages delivered (limit %d).", (limit - remain), limit));
		if (cfg->q_count > 0) {
			DBUG_PRINT("", ("%d messages remain in queue.", cfg->q_count));
			break;		/* excessive messaging */
		}
		if (cfg->t_count > 0) {
			DBUG_PRINT("", ("waiting for timed event..."));
			sleep(1);
		} else {
			return;		/* no more work to do! */
		}
	}
	abort();	/* terminate test run */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebp
movq 0x1f118(%rip), %rbx     # 0x233a0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1300f
testl %eax, %eax
js 0x4360
movl %eax, %r13d
leaq 0x1f68c(%rip), %r12     # 0x23930
leaq 0x1f085(%rip), %r15     # 0x23330
leaq 0x18098(%rip), %r14     # 0x1c34a
cmpl $0x0, (%r12)
je 0x42f3
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1b188
testl %eax, %eax
je 0x42f3
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0xb33, 0xc(%rax)       # imm = 0xB33
movl %ebp, %esi
subl %r13d, %esi
leaq 0x17f4e(%rip), %rdi     # 0x1c238
movl %ebp, %edx
xorl %eax, %eax
callq 0x1ba97
cmpl $0x0, 0x28(%rbx)
jg 0x43c8
cmpl $0x0, 0x68(%rbx)
jle 0x43b9
cmpl $0x0, (%r12)
je 0x4341
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1b188
testl %eax, %eax
je 0x4341
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0xb39, 0xc(%rax)       # imm = 0xB39
leaq 0x17eb7(%rip), %rdi     # 0x1c1f1
xorl %eax, %eax
callq 0x1ba97
movl $0x1, %edi
callq 0x2250
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1300f
movl %eax, %r13d
testl %eax, %eax
jns 0x42b2
leaq 0x1f5c9(%rip), %rax     # 0x23930
cmpl $0x0, (%rax)
je 0x4405
leaq 0x1efb9(%rip), %r14     # 0x23330
movq (%r14), %rax
movq 0x50(%rax), %rax
leaq 0x17fc5(%rip), %rdi     # 0x1c34a
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x4405
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0xb30, 0xc(%rax)       # imm = 0xB30
movl 0x28(%rbx), %esi
movl 0x40(%rbx), %edx
leaq 0x17dc8(%rip), %rdi     # 0x1c175
xorl %eax, %eax
callq 0x1ba97
callq 0x2050
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, (%r12)
je 0x4405
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1b188
testl %eax, %eax
je 0x4405
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0xb35, 0xc(%rax)       # imm = 0xB35
movl 0x28(%rbx), %esi
leaq 0x17e5c(%rip), %rdi     # 0x1c25a
xorl %eax, %eax
callq 0x1ba97
callq 0x2050
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/kernel.c
// Function: assert_eval
static void
assert_eval(CONS* expr, CONS* expect)
{
	CONS* cust;

	prompt();
	cust = ACTOR(newline_beh, NIL);
	SEND(expr, pr(cust, ATOM("write")));  /* echo expr to console */
	cust = ACTOR(assert_beh, expect);
	cust = ACTOR(report_beh, cust);
	SEND(expr, pr(cust, pr(ATOM("eval"), a_ground_env)));
	run_test(M_limit);
	assert(_THIS(cust) == abort_beh);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x1e800(%rip), %rcx     # 0x23378
leaq 0x17712(%rip), %rdi     # 0x1c291
movl $0x3, %esi
movl $0x1, %edx
callq 0x2240
movq 0x1e7e3(%rip), %rdi     # 0x23378
callq 0x21c0
movq 0x1e7ff(%rip), %rdi     # 0x233a0
leaq 0x44dd(%rip), %rsi      # 0x9085
leaq 0x1e6f1(%rip), %rdx     # 0x232a0
callq 0x128be
movq %rax, %r15
movq 0x1e7e2(%rip), %r12     # 0x233a0
leaq 0x17a0b(%rip), %rdi     # 0x1c5d0
callq 0x170ff
movq %r15, %rdi
movq %rax, %rsi
callq 0x19c50
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1299b
movq 0x1e7b6(%rip), %rdi     # 0x233a0
leaq 0x457c(%rip), %rsi      # 0x916d
movq %r14, %rdx
callq 0x128be
movq 0x1e7a0(%rip), %rdi     # 0x233a0
leaq 0x4682(%rip), %rsi      # 0x9289
movq %rax, %rdx
callq 0x128be
movq %rax, %r14
movq 0x1e787(%rip), %r15     # 0x233a0
leaq 0x17979(%rip), %rdi     # 0x1c599
callq 0x170ff
movq 0x1e79c(%rip), %rsi     # 0x233c8
movq %rax, %rdi
callq 0x19c50
movq %r14, %rdi
movq %rax, %rsi
callq 0x19c50
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1299b
movl 0x1e54d(%rip), %edi     # 0x231a0
callq 0x4274
movq %r14, %rdi
callq 0x11d2c
leaq 0x471c(%rip), %rcx      # 0x9383
cmpq %rcx, %rax
jne 0x4c78
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x17b62(%rip), %rdi     # 0x1c7e1
leaq 0x17396(%rip), %rsi     # 0x1c01c
leaq 0x17b6d(%rip), %rcx     # 0x1c7fa
movl $0xbc9, %edx            # imm = 0xBC9
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/kernel.c
// Function: read_eval_print_loop
static CONS*
read_eval_print_loop(FILE* f, BOOL interactive)
{
	CONS* cust;
	CONS* expr;
	
	DBUG_ENTER("read_eval_print_loop");
	input_file = f;
	current_source = file_source(input_file);
	for (;;) {
		if (interactive) {
			prompt();
		}
		expr = read_sexpr(current_source);
		if (expr == NUMBER(EOF)) {
			DBUG_RETURN a_inert;  /* end of input */
		} else if (!actorp(expr)) {
			DBUG_RETURN expr;  /* error */
		}
		cust = a_sink;
		if (interactive) {
			cust = ACTOR(report_beh, cust);
		}
		SEND(expr, pr(cust, pr(ATOM("eval"), a_ground_env)));  /* evaluate */
		run_repl(M_limit);  /* actor dispatch loop */
	}	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1713b(%rip), %rax     # 0x1cba6
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1d8b8(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xb8b, 0xc(%rdi)       # imm = 0xB8B
leaq 0x168b7(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1d6b2(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
movq %r14, 0x1d8de(%rip)     # 0x23390
movq %r14, %rdi
callq 0x324b
movq %rax, 0x1d917(%rip)     # 0x233d8
leaq 0x16ad1(%rip), %r14     # 0x1c599
leaq 0x167c2(%rip), %r12     # 0x1c291
testq %rbx, %rbx
je 0x5af9
movq 0x1d89d(%rip), %rcx     # 0x23378
movl $0x3, %esi
movl $0x1, %edx
movq %r12, %rdi
callq 0x2240
movq 0x1d884(%rip), %rdi     # 0x23378
callq 0x21c0
movq 0x1d8d8(%rip), %rdi     # 0x233d8
callq 0x3438
cmpq $-0x1, %rax
je 0x5b82
movq %rax, %r13
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x5b89
movq 0x1d8b3(%rip), %rbp     # 0x233d0
testq %rbx, %rbx
je 0x5b3b
movq 0x1d877(%rip), %rdi     # 0x233a0
leaq 0x3759(%rip), %rsi      # 0x9289
movq %rbp, %rdx
callq 0x128be
movq %rax, %rbp
movq 0x1d85e(%rip), %r15     # 0x233a0
movq %r14, %rdi
callq 0x170ff
movq 0x1d877(%rip), %rsi     # 0x233c8
movq %rax, %rdi
callq 0x19c50
movq %rbp, %rdi
movq %rax, %rsi
callq 0x19c50
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x1299b
movl 0x1d628(%rip), %edi     # 0x231a0
callq 0x415f
jmp 0x5acf
movl $0xb94, %eax            # imm = 0xB94
jmp 0x5b8e
movl $0xb96, %eax            # imm = 0xB96
movq %rsp, %rdi
movl %eax, 0xc(%rdi)
callq 0x1bbab
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/kernel.c
// Function: throw_beh
static
BEH_DECL(throw_beh)
{
	char* msg = cons_to_str(WHAT);

	DBUG_ENTER("throw_beh");
	DBUG_PRINT("FAIL!", ("%s", msg));
	fprintf(output_file, "FAIL! %s\n", msg);
	fflush(output_file);
	DBUG_RETURN;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x30(%rdi), %rdi
callq 0x19d11
movq %rax, %rdi
callq 0x13c40
movq %rax, %rbx
leaq 0x1699e(%rip), %rax     # 0x1c568
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1d759(%rip), %r14     # 0x23330
movq (%r14), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x37, 0xc(%rdi)
leaq 0x16758(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1d553(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
leaq 0x1dd1f(%rip), %rax     # 0x23930
cmpl $0x0, (%rax)
je 0x5c50
movq (%r14), %rax
movq 0x50(%rax), %rax
leaq 0x1694e(%rip), %rdi     # 0x1c572
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x5c50
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0x38, 0xc(%rax)
leaq 0x1790e(%rip), %rdi     # 0x1d554
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1ba97
movq 0x1d721(%rip), %rdi     # 0x23378
leaq 0x1691a(%rip), %rsi     # 0x1c578
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2180
movq 0x1d709(%rip), %rdi     # 0x23378
callq 0x21c0
movq %rsp, %rdi
movl $0x3b, 0xc(%rdi)
callq 0x1bbab
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/kernel.c
// Function: pair_comb_beh
static
BEH_DECL(pair_comb_beh)
{
	CONS* state = MINE;
	CONS* cust;
/*
	CONS* right;
	CONS* env;
*/
	CONS* comb = WHAT;

	DBUG_ENTER("pair_comb_beh");
	ENSURE(is_pr(state));
	cust = hd(state);
/*
	ENSURE(is_pr(tl(state)));
	right = hd(tl(state));
	env = tl(tl(state));
	SEND(cust, pr(cust, pr(ATOM("comb"), pr(right, env))));
*/
	SEND(comb, pr(cust, pr(ATOM("comb"), tl(state))));
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x19c72
movq %rax, %rdi
callq 0x11d65
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x19d11
movq %rax, %r14
leaq 0x15d72(%rip), %rax     # 0x1c5f0
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1caa3(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x407, 0xc(%rdi)       # imm = 0x407
leaq 0x15aa2(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1c89d(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
cmpq 0x1c6f9(%rip), %r15     # 0x22fc0
je 0x6923
testq %r15, %r15
je 0x6923
movl %r15d, %eax
andl $0x3, %eax
jne 0x6923
movq %r15, %rdi
callq 0x19c72
movq %rax, %r12
leaq 0x15d16(%rip), %rdi     # 0x1c5fe
callq 0x170ff
movq %rax, %r13
movq %r15, %rdi
callq 0x19d11
movq %r13, %rdi
movq %rax, %rsi
callq 0x19c50
movq %r12, %rdi
movq %rax, %rsi
callq 0x19c50
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1299b
movl $0x411, %eax            # imm = 0x411
jmp 0x6982
leaq -0xd82(%rip), %rsi      # 0x5ba8
leaq 0x1c96f(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x128be
movq %rax, %r14
leaq 0x15bf0(%rip), %rdi     # 0x1c533
callq 0x170ff
movq %rax, %r15
leaq 0x156ca(%rip), %rdi     # 0x1c01c
callq 0x170ff
movl $0x1023, %esi           # imm = 0x1023
movq %rax, %rdi
callq 0x19c50
movq %r15, %rdi
movq %rax, %rsi
callq 0x19c50
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1299b
movl $0x408, %eax            # imm = 0x408
leaq 0x8(%rsp), %rdi
movl %eax, 0xc(%rdi)
callq 0x1bbab
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/kernel.c
// Function: pair_match_beh
static
BEH_DECL(pair_match_beh)
{
	CONS* cust = MINE;
	CONS* msg = WHAT;

	DBUG_ENTER("pair_match_beh");
	ENSURE(actorp(cust));
	if (is_pr(msg)
	&& (hd(msg) == a_inert)
	&& (tl(msg) == a_inert)) {
		SEND(cust, a_inert);
	}
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x19c72
movq %rax, %rdi
callq 0x11d65
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x19d11
movq %rax, %r15
leaq 0x1599a(%rip), %rax     # 0x1c612
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1c6ab(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x436, 0xc(%rdi)       # imm = 0x436
leaq 0x156aa(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1c4a5(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
movl %r14d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x6d20
movl $0x43d, %ebp            # imm = 0x43D
cmpq 0x1c2f1(%rip), %r15     # 0x22fc0
je 0x6d7f
testq %r15, %r15
je 0x6d7f
movl %r15d, %eax
andl $0x3, %eax
jne 0x6d7f
movq %r15, %rdi
callq 0x19c72
cmpq 0x1c6af(%rip), %rax     # 0x233a8
jne 0x6d7f
movq %r15, %rdi
callq 0x19d11
movq 0x1c69a(%rip), %rdx     # 0x233a8
cmpq %rdx, %rax
jne 0x6d7f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1299b
jmp 0x6d7f
leaq -0x117f(%rip), %rsi     # 0x5ba8
leaq 0x1c572(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x128be
movq %rax, %r14
leaq 0x157f3(%rip), %rdi     # 0x1c533
callq 0x170ff
movq %rax, %r15
leaq 0x152cd(%rip), %rdi     # 0x1c01c
callq 0x170ff
movl $0x10df, %esi           # imm = 0x10DF
movq %rax, %rdi
callq 0x19c50
movq %r15, %rdi
movq %rax, %rsi
callq 0x19c50
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1299b
movl $0x437, %ebp            # imm = 0x437
movq %rsp, %rdi
movl %ebp, 0xc(%rdi)
callq 0x1bbab
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/kernel.c
// Function: pair_copy_beh
static
BEH_DECL(pair_copy_beh)
{
	CONS* cust = MINE;
	CONS* head_tail = WHAT;

	DBUG_ENTER("pair_copy_beh");
	ENSURE(actorp(cust));
	if (is_pr(head_tail)) {
		SEND(cust, ACTOR(pair_type, head_tail));  /* immutable */
	}
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x19c72
movq %rax, %rdi
callq 0x11d65
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x19d11
movq %rax, %r15
leaq 0x15672(%rip), %rax     # 0x1c735
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1c260(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x44b, 0xc(%rdi)       # imm = 0x44B
leaq 0x1525f(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1c05a(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
movl %r14d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x7157
movl $0x450, %ebp            # imm = 0x450
cmpq 0x1bea6(%rip), %r15     # 0x22fc0
je 0x71b6
testq %r15, %r15
je 0x71b6
movl %r15d, %eax
andl $0x3, %eax
jne 0x71b6
leaq -0x35c8(%rip), %rsi     # 0x3b74
movq %rbx, %rdi
movq %r15, %rdx
callq 0x128be
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1299b
jmp 0x71b6
leaq -0x15b6(%rip), %rsi     # 0x5ba8
leaq 0x1c13b(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x128be
movq %rax, %r14
leaq 0x153bc(%rip), %rdi     # 0x1c533
callq 0x170ff
movq %rax, %r15
leaq 0x14e96(%rip), %rdi     # 0x1c01c
callq 0x170ff
movl $0x1133, %esi           # imm = 0x1133
movq %rax, %rdi
callq 0x19c50
movq %r15, %rdi
movq %rax, %rsi
callq 0x19c50
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1299b
movl $0x44c, %ebp            # imm = 0x44C
movq %rsp, %rdi
movl %ebp, 0xc(%rdi)
callq 0x1bbab
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/kernel.c
// Function: pair_map_beh
static
BEH_DECL(pair_map_beh)
{
	CONS* cust = MINE;
	CONS* head_tail = WHAT;

	DBUG_ENTER("pair_map_beh");
	ENSURE(actorp(cust));
	if (is_pr(head_tail)) {
		SEND(cust, ACTOR(cons_type, head_tail));  /* mutable */
	}
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x19c72
movq %rax, %rdi
callq 0x11d65
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x19d11
movq %rax, %r15
leaq 0x15543(%rip), %rax     # 0x1c743
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1c123(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x45e, 0xc(%rdi)       # imm = 0x45E
leaq 0x15122(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1bf1d(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
movl %r14d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x7294
movl $0x463, %ebp            # imm = 0x463
cmpq 0x1bd69(%rip), %r15     # 0x22fc0
je 0x72f3
testq %r15, %r15
je 0x72f3
movl %r15d, %eax
andl $0x3, %eax
jne 0x72f3
leaq -0x15ee(%rip), %rsi     # 0x5c8b
movq %rbx, %rdi
movq %r15, %rdx
callq 0x128be
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1299b
jmp 0x72f3
leaq -0x16f3(%rip), %rsi     # 0x5ba8
leaq 0x1bffe(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x128be
movq %rax, %r14
leaq 0x1527f(%rip), %rdi     # 0x1c533
callq 0x170ff
movq %rax, %r15
leaq 0x14d59(%rip), %rdi     # 0x1c01c
callq 0x170ff
movl $0x117f, %esi           # imm = 0x117F
movq %rax, %rdi
callq 0x19c50
movq %r15, %rdi
movq %rax, %rsi
callq 0x19c50
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1299b
movl $0x45f, %ebp            # imm = 0x45F
movq %rsp, %rdi
movl %ebp, 0xc(%rdi)
callq 0x1bbab
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/kernel.c
// Function: tag_beh
static
BEH_DECL(tag_beh)
{
	CONS* cust = MINE;
	CONS* msg = WHAT;

	DBUG_ENTER("tag_beh");
	assert(actorp(cust));
	SEND(cust, pr(SELF, msg));
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x19c72
movq %rax, %rdi
callq 0x11d65
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x19d11
movq %rax, %r15
leaq 0x14bda(%rip), %rax     # 0x1c692
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1b869(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x1a1, 0xc(%rdi)       # imm = 0x1A1
leaq 0x14868(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1b663(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
movl %r14d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x7b42
movq 0x30(%rbx), %rdi
callq 0x19c72
movq %rax, %rdi
movq %r15, %rsi
callq 0x19c50
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1299b
leaq 0x8(%rsp), %rdi
movl $0x1a4, 0xc(%rdi)       # imm = 0x1A4
callq 0x1bbab
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x14b06(%rip), %rdi     # 0x1c64f
leaq 0x144cc(%rip), %rsi     # 0x1c01c
leaq 0x14b43(%rip), %rcx     # 0x1c69a
movl $0x1a2, %edx            # imm = 0x1A2
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/kernel.c
// Function: join_beh
static
BEH_DECL(join_beh)
{
	CONS* state = MINE;
	CONS* cust;
	CONS* k_first;
	CONS* k_rest;
	CONS* msg = WHAT;

	DBUG_ENTER("join_beh");
	assert(is_pr(state));
	cust = hd(state);
	assert(actorp(cust));
	assert(is_pr(tl(state)));
	k_first = hd(tl(state));
	k_rest = tl(tl(state));

	if (is_pr(msg)) {
		if (hd(msg) == k_first) {
			BECOME(join_rest_beh, pr(cust, pr(k_rest, tl(msg))));
		} else if (hd(msg) == k_rest) {
			BECOME(join_first_beh, pr(cust, pr(k_first, tl(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 0x19c72
movq %rax, %rdi
callq 0x11d65
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x19d11
movq %rax, %r14
leaq 0x14b18(%rip), %rax     # 0x1c6b1
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1b78a(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x187, 0xc(%rdi)       # imm = 0x187
leaq 0x14789(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1b584(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
cmpq 0x1b3e0(%rip), %r12     # 0x22fc0
je 0x7d3a
testq %r12, %r12
je 0x7d3a
movl %r12d, %eax
andl $0x3, %eax
jne 0x7d3a
movq %r12, %rdi
callq 0x19c72
movq %rax, %r15
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x7d59
movq %r12, %rdi
callq 0x19d11
testq %rax, %rax
je 0x7d1b
movq %r12, %rdi
callq 0x19d11
testb $0x3, %al
jne 0x7d1b
movq %r12, %rdi
callq 0x19d11
cmpq 0x1b37e(%rip), %rax     # 0x22fc0
je 0x7d1b
movq %r12, %rdi
callq 0x19d11
andl $0x3, %eax
cmpl $0x1, %eax
je 0x7d1b
movq %r12, %rdi
callq 0x19d11
movq %rax, %rdi
callq 0x19c72
movq %rax, %r13
movq %r12, %rdi
callq 0x19d11
movq %rax, %rdi
callq 0x19d11
cmpq 0x1b33a(%rip), %r14     # 0x22fc0
je 0x7cfd
testq %r14, %r14
je 0x7cfd
movq %rax, %r12
movl %r14d, %eax
andl $0x3, %eax
jne 0x7cfd
movq %r14, %rdi
callq 0x19c72
cmpq %r13, %rax
je 0x7cbe
movq %r14, %rdi
callq 0x19c72
cmpq %r12, %rax
jne 0x7cfd
leaq 0x354(%rip), %rbp       # 0x800d
movq %r13, %r12
jmp 0x7cc5
leaq 0xb3(%rip), %rbp        # 0x7d78
movq 0x30(%rbx), %rdi
callq 0x19c72
movq %rax, %rbx
movq %r14, %rdi
callq 0x19d11
movq %r12, %rdi
movq %rax, %rsi
callq 0x19c50
movq %r15, %rdi
movq %rax, %rsi
callq 0x19c50
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x11fbe
movq %rsp, %rdi
movl $0x196, 0xc(%rdi)       # imm = 0x196
callq 0x1bbab
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1493a(%rip), %rdi     # 0x1c65c
leaq 0x142f3(%rip), %rsi     # 0x1c01c
leaq 0x1498a(%rip), %rcx     # 0x1c6ba
movl $0x18b, %edx            # imm = 0x18B
callq 0x2100
leaq 0x148e9(%rip), %rdi     # 0x1c62a
leaq 0x142d4(%rip), %rsi     # 0x1c01c
leaq 0x1496b(%rip), %rcx     # 0x1c6ba
movl $0x188, %edx            # imm = 0x188
callq 0x2100
leaq 0x148ef(%rip), %rdi     # 0x1c64f
leaq 0x142b5(%rip), %rsi     # 0x1c01c
leaq 0x1494c(%rip), %rcx     # 0x1c6ba
movl $0x18a, %edx            # imm = 0x18A
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/kernel.c
// Function: printable
static char*
printable(CONS* p)		/* WARNING! you must free this storage manually */
{
	char* s;
	char* t;
	
	s = cons_to_str(p);  /* pointer to static buffer */
	if (atomp(p)) { ++s; }  /* skip leading '#' */
	t = NEWxN(char, strlen(s) + 1);
	return strcpy(t, s);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x13c40
andl $0x3, %ebx
xorl %r14d, %r14d
cmpl $0x2, %ebx
sete %r14b
addq %rax, %r14
movq %r14, %rdi
callq 0x20d0
leaq 0x1(%rax), %rsi
movl $0x1, %edi
callq 0x2160
movq %rax, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2090
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/kernel.c
// Function: dotted_tail_beh
static
BEH_DECL(dotted_tail_beh)
{
	CONS* state = MINE;
	CONS* cust;
	CONS* last;
	CONS* ok = WHAT;

	DBUG_ENTER("dotted_tail_beh");
	ENSURE(is_pr(state));
	cust = hd(state);
	ENSURE(actorp(cust));
	last = tl(state);
	
	if (ok == a_true) {
		CONS* k_close = ACTOR(dotted_close_beh, cust);
		SEND(last, pr(k_close, ATOM("write")));
	} else {
		SEND(cust, ok);
	}
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x19c72
movq %rax, %rdi
callq 0x11d65
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x19d11
movq %rax, %r14
leaq 0x13e43(%rip), %rax     # 0x1c798
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1a9ce(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x200, 0xc(%rdi)       # imm = 0x200
leaq 0x139cd(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1a7c8(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
cmpq 0x1a624(%rip), %r15     # 0x22fc0
je 0x89e5
testq %r15, %r15
je 0x89e5
movl %r15d, %eax
andl $0x3, %eax
jne 0x89e5
movq %r15, %rdi
callq 0x19c72
movq %rax, %r12
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x8a49
movq %r15, %rdi
callq 0x19d11
cmpq 0x1a9b7(%rip), %r14     # 0x23388
je 0x8aaa
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
jmp 0x8ae2
leaq -0x2e44(%rip), %rsi     # 0x5ba8
leaq 0x1a8ad(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x128be
movq %rax, %r14
leaq 0x13b2e(%rip), %rdi     # 0x1c533
callq 0x170ff
movq %rax, %r15
leaq 0x13608(%rip), %rdi     # 0x1c01c
callq 0x170ff
movl $0x807, %esi            # imm = 0x807
movq %rax, %rdi
callq 0x19c50
movq %r15, %rdi
movq %rax, %rsi
callq 0x19c50
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1299b
movl $0x201, %eax            # imm = 0x201
jmp 0x8aec
leaq -0x2ea8(%rip), %rsi     # 0x5ba8
leaq 0x1a849(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x128be
movq %rax, %r14
leaq 0x13aca(%rip), %rdi     # 0x1c533
callq 0x170ff
movq %rax, %r15
leaq 0x135a4(%rip), %rdi     # 0x1c01c
callq 0x170ff
movl $0x80f, %esi            # imm = 0x80F
movq %rax, %rdi
callq 0x19c50
movq %r15, %rdi
movq %rax, %rsi
callq 0x19c50
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1299b
movl $0x203, %eax            # imm = 0x203
jmp 0x8aec
movq %rax, %r15
leaq 0x4f(%rip), %rsi        # 0x8b03
movq %rbx, %rdi
movq %r12, %rdx
callq 0x128be
movq %rax, %r14
leaq 0x13b07(%rip), %rdi     # 0x1c5d0
callq 0x170ff
movq %r14, %rdi
movq %rax, %rsi
callq 0x19c50
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1299b
movl $0x20c, %eax            # imm = 0x20C
movq %rsp, %rdi
movl %eax, 0xc(%rdi)
callq 0x1bbab
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/kernel.c
// Function: dotted_close_beh
static
BEH_DECL(dotted_close_beh)
{
	CONS* cust = MINE;
	CONS* ok = WHAT;

	DBUG_ENTER("dotted_close_beh");
	ENSURE(actorp(cust));
	
	if (ok == a_true) {
		SINK* sink = current_sink;
		SEND(cust, (sink->put)(sink, NUMBER(')')));
	} else {
		SEND(cust, ok);
	}
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x19c72
movq %rax, %rdi
callq 0x11d65
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x19d11
movq %rax, %r15
leaq 0x13c72(%rip), %rax     # 0x1c7a8
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1a7eb(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x1e2, 0xc(%rdi)       # imm = 0x1E2
leaq 0x137ea(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1a5e5(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
movl %r14d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x8bb3
cmpq 0x1a7fe(%rip), %r15     # 0x23388
jne 0x8b9e
movq 0x1a825(%rip), %rdi     # 0x233b8
movl $0xa7, %esi
callq *0x8(%rdi)
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1299b
movl $0x1eb, %eax            # imm = 0x1EB
jmp 0x8c12
leaq -0x3012(%rip), %rsi     # 0x5ba8
leaq 0x1a6df(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x128be
movq %rax, %r14
leaq 0x13960(%rip), %rdi     # 0x1c533
callq 0x170ff
movq %rax, %r15
leaq 0x1343a(%rip), %rdi     # 0x1c01c
callq 0x170ff
movl $0x78f, %esi            # imm = 0x78F
movq %rax, %rdi
callq 0x19c50
movq %r15, %rdi
movq %rax, %rsi
callq 0x19c50
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1299b
movl $0x1e3, %eax            # imm = 0x1E3
leaq 0x8(%rsp), %rdi
movl %eax, 0xc(%rdi)
callq 0x1bbab
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/kernel.c
// Function: newline_beh
static
BEH_DECL(newline_beh)
{
	CONS* state = MINE;
	
	DBUG_ENTER("newline_beh");
	fputc('\n', output_file);
	fflush(output_file);
	if (is_pr(state) && actorp(hd(state))) {
		SEND(hd(state), tl(state));
	}
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x19c72
movq %rax, %rdi
callq 0x11d65
movq %rax, %r14
leaq 0x1376f(%rip), %rax     # 0x1c81b
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1a275(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xb68, 0xc(%rdi)       # imm = 0xB68
leaq 0x13274(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1a06f(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
movq 0x1a283(%rip), %rsi     # 0x23378
movl $0xa, %edi
callq 0x2130
movq 0x1a272(%rip), %rdi     # 0x23378
callq 0x21c0
cmpq 0x19eae(%rip), %r14     # 0x22fc0
je 0x9152
testq %r14, %r14
je 0x9152
movl %r14d, %eax
andl $0x3, %eax
jne 0x9152
movq %r14, %rdi
callq 0x19c72
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x9152
movq %r14, %rdi
callq 0x19c72
movq %rax, %r15
movq %r14, %rdi
callq 0x19d11
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1299b
leaq 0x8(%rsp), %rdi
movl $0xb6e, 0xc(%rdi)       # imm = 0xB6E
callq 0x1bbab
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/kernel.c
// Function: assert_beh
static
BEH_DECL(assert_beh)
{
	CONS* expect = MINE;
	CONS* actual = WHAT;

	DBUG_ENTER("assert_beh");
	DBUG_PRINT("", ("expect=%s", cons_to_str(expect)));
	if (equal(expect, actual)) {
		BECOME(abort_beh, NIL);
	} else {
		DBUG_PRINT("", ("actual=%s", cons_to_str(actual)));
		fprintf(stderr, "assert_beh: FAIL!\n");
		abort();
	}
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x19c72
movq %rax, %rdi
callq 0x11d65
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x19d11
movq %rax, %r14
leaq 0x13683(%rip), %rax     # 0x1c827
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1a17d(%rip), %r13     # 0x23330
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xbb1, 0xc(%rdi)       # imm = 0xBB1
leaq 0x1317b(%rip), %r12     # 0x1c34a
movq %r12, 0x10(%rdi)
leaq 0x19f76(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
leaq 0x1a742(%rip), %rax     # 0x23930
cmpl $0x0, (%rax)
je 0x9233
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x1b188
testl %eax, %eax
je 0x9233
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0xbb2, 0xc(%rax)       # imm = 0xBB2
movq %r15, %rdi
callq 0x13c40
leaq 0x13609(%rip), %rdi     # 0x1c832
movq %rax, %rsi
xorl %eax, %eax
callq 0x1ba97
movq %r15, %rdi
movq %r14, %rsi
callq 0x19dcc
testq %rax, %rax
je 0x9281
movq 0x30(%rbx), %rdi
callq 0x19c72
leaq 0x130(%rip), %rsi       # 0x9383
leaq 0x1a046(%rip), %rdx     # 0x232a0
movq %rax, %rdi
callq 0x11fbe
leaq 0x8(%rsp), %rdi
movl $0xbba, 0xc(%rdi)       # imm = 0xBBA
callq 0x1bbab
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x2332
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/kernel.c
// Function: report_beh
static
BEH_DECL(report_beh)
{
	CONS* cust = MINE;
	CONS* value = WHAT;
	
	DBUG_ENTER("report_beh");
	cust = ACTOR(newline_beh, pr(cust, value));
	SEND(value, pr(cust, ATOM("write")));
	BECOME(abort_beh, NIL);
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x19c72
movq %rax, %rdi
callq 0x11d65
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x19d11
movq %rax, %r15
leaq 0x1359b(%rip), %rax     # 0x1c859
movq %rsp, %r14
movq %rax, (%r14)
leaq 0x1a065(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%r14)
movl $0xb7e, 0xc(%r14)       # imm = 0xB7E
leaq 0x13062(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%r14)
leaq 0x19e5d(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%r14)
movq %rax, 0x20(%r14)
movq %r14, %rdi
callq 0x1ba26
movq %r12, %rdi
movq %r15, %rsi
callq 0x19c50
leaq -0x290(%rip), %rsi      # 0x9085
movq %rbx, %rdi
movq %rax, %rdx
callq 0x128be
movq %rax, %r12
leaq 0x132a6(%rip), %rdi     # 0x1c5d0
callq 0x170ff
movq %r12, %rdi
movq %rax, %rsi
callq 0x19c50
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1299b
movq 0x30(%rbx), %rdi
callq 0x19c72
leaq 0x2b(%rip), %rsi        # 0x9383
leaq 0x19f41(%rip), %rdx     # 0x232a0
movq %rax, %rdi
callq 0x11fbe
movl $0xb82, 0xc(%r14)       # imm = 0xB82
movq %r14, %rdi
callq 0x1bbab
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/kernel.c
// Function: abort_beh
static
BEH_DECL(abort_beh)
{
	char* msg = cons_to_str(WHAT);

	DBUG_ENTER("abort_beh");
	DBUG_PRINT("ABORT!", ("%s", msg));
	fprintf(stderr, "ABORT! %s\n", msg);
	abort();
	DBUG_RETURN;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x30(%rdi), %rdi
callq 0x19d11
movq %rax, %rdi
callq 0x13c40
movq %rax, %rbx
leaq 0x1344b(%rip), %rax     # 0x1c7f0
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x19f7e(%rip), %r14     # 0x23330
movq (%r14), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x48, 0xc(%rdi)
leaq 0x12f7d(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x19d78(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
leaq 0x1a544(%rip), %rax     # 0x23930
cmpl $0x0, (%rax)
je 0x942b
movq (%r14), %rax
movq 0x50(%rax), %rax
leaq 0x13465(%rip), %rdi     # 0x1c864
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x942b
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0x49, 0xc(%rax)
leaq 0x14133(%rip), %rdi     # 0x1d554
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1ba97
movq 0x19bc6(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
leaq 0x1342f(%rip), %rsi     # 0x1c86b
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2180
callq 0x2050