LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/kernel.c
// Function: string_next
CONS*
string_next(SOURCE* src)
{
	char* s;
	CONS* c;

	DBUG_ENTER("string_next");
	c = (src->get)(src);
	if (c == NUMBER(EOF)) {
		DBUG_RETURN c;
	}
	s = (char*)(MK_PTR(src->context));
	src->context = MK_REF(++s);
	DBUG_PRINT("s", ((s ? "\"%s\"" : "NULL"), s));
	DBUG_RETURN c;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
leaq 0x197b0(%rip), %rax     # 0x1c0c3
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x21a0e(%rip), %r12     # 0x24330
movq (%r12), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xc1, 0xc(%rdi)
leaq 0x19a0c(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x21807(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
movq %r14, %rdi
callq *0x10(%r14)
movq %rax, %rbx
cmpq $-0x1, %rax
je 0x29ca
movq (%r14), %r15
sarq $0x2, %r15
leaq 0x7(,%r15,4), %rax
movq %rax, (%r14)
leaq 0x21fb1(%rip), %rax     # 0x24930
movl $0xc9, %ebp
cmpl $0x0, (%rax)
je 0x29cf
movq (%r12), %rax
movq 0x50(%rax), %rax
leaq 0x1ab9d(%rip), %rdi     # 0x1d535
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x29cf
incq %r15
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0xc8, 0xc(%rax)
leaq 0x196da(%rip), %rdi     # 0x1c098
movq %r15, %rsi
xorl %eax, %eax
callq 0x1b0f0
jmp 0x29cf
movl $0xc4, %ebp
leaq 0x8(%rsp), %rdi
movl %ebp, 0xc(%rdi)
callq 0x1b1f2
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x196d2(%rip), %rax     # 0x1c0cf
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x21926(%rip), %r14     # 0x24330
movq (%r14), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xd0, 0xc(%rdi)
leaq 0x19925(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x21720(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
leaq 0x21eec(%rip), %rax     # 0x24930
cmpl $0x0, (%rax)
je 0x2a91
movq (%r14), %rax
movq 0x50(%rax), %rax
leaq 0x1aade(%rip), %rdi     # 0x1d535
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x2a91
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0xd1, 0xc(%rax)
testq %rbx, %rbx
leaq 0x1bc02(%rip), %rax     # 0x1e67e
leaq 0x19615(%rip), %rdi     # 0x1c098
cmoveq %rax, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1b0f0
pushq $0x20
popq %rdi
pushq $0x1
popq %rsi
callq 0x2160
movq %rax, %r14
leaq 0x3(,%rbx,4), %rax
movq %rax, (%r14)
leaq -0x3ea(%rip), %rax      # 0x26c7
movq %rax, 0x8(%r14)
leaq -0x308(%rip), %rax      # 0x27b4
movq %rax, 0x10(%r14)
leaq -0x1ca(%rip), %rax      # 0x28fd
movq %rax, 0x18(%r14)
movq %rsp, %rdi
movl $0xd7, 0xc(%rdi)
callq 0x1b1f2
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1955e(%rip), %rax     # 0x1c0e8
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x21799(%rip), %r15     # 0x24330
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xe9, 0xc(%rdi)
leaq 0x19798(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x21593(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
leaq 0x21d5f(%rip), %r12     # 0x24930
cmpl $0x0, (%r12)
je 0x2c1a
movq (%r15), %rax
movq 0x50(%rax), %rax
leaq 0x1950b(%rip), %rdi     # 0x1c0f1
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x2c1a
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0xea, 0xc(%rax)
movq (%rbx), %rdi
callq 0x13708
leaq 0x1a924(%rip), %rdi     # 0x1d534
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b0f0
movq (%rbx), %rdi
callq 0x19306
movq %rax, %r14
cmpq 0x21394(%rip), %rax     # 0x23fc0
jne 0x2c3f
movq %rbx, %rdi
callq *0x18(%rbx)
movq (%rbx), %rdi
callq 0x19306
movq %rax, %r14
cmpl $0x0, (%r12)
je 0x2ca4
movq (%r15), %rax
movq 0x50(%rax), %rax
leaq 0x1aeb7(%rip), %rdi     # 0x1db0b
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x2ca4
movq %r14, %rbx
shrq $0x2, %rbx
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0xf1, 0xc(%rax)
callq 0x2270
movq (%rax), %rax
movslq %ebx, %rdx
movzwl (%rax,%rdx,2), %eax
btl $0xe, %eax
leaq 0x193bc(%rip), %rax     # 0x1c04c
leaq 0x193ad(%rip), %rdi     # 0x1c044
cmovaeq %rax, %rdi
movl %edx, %esi
xorl %eax, %eax
callq 0x1b0f0
movq %rsp, %rdi
movl $0xf2, 0xc(%rdi)
callq 0x1b1f2
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x19426(%rip), %rax     # 0x1c0f9
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x21650(%rip), %rax     # 0x24330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xfa, 0xc(%rdi)
leaq 0x1964f(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x2144a(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
movq (%rbx), %rdi
callq 0x19306
movq %rax, %r14
cmpq $-0x1, %rax
je 0x2d63
movq (%rbx), %rdi
callq 0x191fb
movq 0x2165d(%rip), %rcx     # 0x24390
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 0x1941f
movq %rsp, %rdi
movl $0x109, 0xc(%rdi)       # imm = 0x109
callq 0x1b1f2
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x19371(%rip), %rax     # 0x1c103
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x21591(%rip), %r15     # 0x24330
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x110, 0xc(%rdi)       # imm = 0x110
leaq 0x19590(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x2138b(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
testq %r14, %r14
je 0x2f47
leaq 0x21b4e(%rip), %r12     # 0x24930
cmpl $0x0, (%r12)
je 0x2e23
movq (%r15), %rax
movq 0x50(%rax), %rax
leaq 0x19374(%rip), %rdi     # 0x1c16b
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x2e23
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x112, 0xc(%rax)       # imm = 0x112
leaq 0x1b207(%rip), %rdi     # 0x1e020
movq %r14, %rsi
xorl %eax, %eax
callq 0x1b0f0
pushq $0x20
popq %rdi
pushq $0x1
popq %rsi
callq 0x2160
movq %rax, %rbx
leaq 0x3(,%r14,4), %rdi
leaq 0x21460(%rip), %rsi     # 0x242a0
callq 0x19164
movq %rax, (%rbx)
cmpl $0x0, (%r12)
je 0x2f08
movq %rax, %r14
movq (%r15), %rax
movq 0x50(%rax), %rax
leaq 0x192c7(%rip), %rdi     # 0x1c12b
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x2e9c
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x115, 0xc(%rax)       # imm = 0x115
movq %r14, %rdi
callq 0x191fb
sarq $0x2, %rax
leaq 0x1b18e(%rip), %rdi     # 0x1e020
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b0f0
cmpl $0x0, (%r12)
leaq -0x3c3(%rip), %rax      # 0x2ae5
movq %rax, 0x8(%rbx)
leaq -0x33e(%rip), %rax      # 0x2b75
movq %rax, 0x10(%rbx)
leaq -0x1fc(%rip), %rax      # 0x2cc2
movq %rax, 0x18(%rbx)
je 0x2f29
movq (%r15), %rax
movq 0x50(%rax), %rax
leaq 0x1921f(%rip), %rdi     # 0x1c0f1
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x2f29
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x119, 0xc(%rax)       # imm = 0x119
movq %r14, %rdi
callq 0x13708
leaq 0x1a638(%rip), %rdi     # 0x1d534
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b0f0
jmp 0x2f29
leaq -0x42a(%rip), %rax      # 0x2ae5
movq %rax, 0x8(%rbx)
leaq -0x3a5(%rip), %rax      # 0x2b75
movq %rax, 0x10(%rbx)
leaq -0x263(%rip), %rax      # 0x2cc2
movq %rax, 0x18(%rbx)
movq %rsp, %rdi
movl $0x11a, 0xc(%rdi)       # imm = 0x11A
callq 0x1b1f2
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1b72b(%rip), %rdi     # 0x1e679
leaq 0x190c7(%rip), %rsi     # 0x1c01c
leaq 0x191b3(%rip), %rcx     # 0x1c10f
movl $0x111, %edx            # imm = 0x111
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 0x20a40(%rip), %rdi     # 0x243c0
callq 0x191fb
movq %rax, %r14
leaq 0x18de4(%rip), %rax     # 0x1c773
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x20994(%rip), %r13     # 0x24330
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x338, 0xc(%rdi)       # imm = 0x338
leaq 0x18992(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x2078d(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
leaq 0x20f59(%rip), %rbp     # 0x24930
cmpl $0x0, (%rbp)
je 0x3a21
movq (%r13), %rax
movq 0x50(%rax), %rax
leaq 0x1a6bb(%rip), %rdi     # 0x1e0a7
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x3a21
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x339, 0xc(%rax)       # imm = 0x339
movq %rbx, %rdi
callq 0x13708
leaq 0x19b1d(%rip), %rdi     # 0x1d534
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b0f0
leaq 0x20878(%rip), %r12     # 0x242a0
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x19787
movq %rax, %r15
cmpq %r12, %rax
jne 0x3a74
movq 0x2095b(%rip), %rdi     # 0x243a0
leaq 0x4250(%rip), %rsi      # 0x7c9c
movq %rbx, %rdx
callq 0x123b7
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x197f9
movq 0x20954(%rip), %rdi     # 0x243c0
movq %rax, %rsi
callq 0x19411
cmpl $0x0, (%rbp)
je 0x3abe
movq (%r13), %rax
movq 0x50(%rax), %rax
leaq 0x18cee(%rip), %rdi     # 0x1c777
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x3abe
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x340, 0xc(%rax)       # imm = 0x340
movq %r15, %rdi
callq 0x13708
leaq 0x19a80(%rip), %rdi     # 0x1d534
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b0f0
movq %rsp, %rdi
movl $0x341, 0xc(%rdi)       # imm = 0x341
callq 0x1b1f2
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_O2/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 0x208c9(%rip), %rdi     # 0x243c0
callq 0x19306
movq %rax, %r14
leaq 0x18cb3(%rip), %rax     # 0x1c7b9
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x2081d(%rip), %r13     # 0x24330
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x5c5, 0xc(%rdi)       # imm = 0x5C5
leaq 0x1881b(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x20616(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
leaq 0x20de2(%rip), %rbp     # 0x24930
cmpl $0x0, (%rbp)
je 0x3b98
movq (%r13), %rax
movq 0x50(%rax), %rax
leaq 0x18c61(%rip), %rdi     # 0x1c7c4
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x3b98
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x5c6, 0xc(%rax)       # imm = 0x5C6
movq %rbx, %rdi
callq 0x13708
leaq 0x199a6(%rip), %rdi     # 0x1d534
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b0f0
leaq 0x20701(%rip), %r12     # 0x242a0
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x19787
movq %rax, %r15
cmpq %r12, %rax
jne 0x3beb
movq 0x207e4(%rip), %rdi     # 0x243a0
leaq 0x4a4f(%rip), %rsi      # 0x8612
movq %rbx, %rdx
callq 0x123b7
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x197f9
movq 0x207dd(%rip), %rdi     # 0x243c0
movq %rax, %rsi
callq 0x1941f
cmpl $0x0, (%rbp)
je 0x3c35
movq (%r13), %rax
movq 0x50(%rax), %rax
leaq 0x18bbd(%rip), %rdi     # 0x1c7bd
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x3c35
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x5cd, 0xc(%rax)       # imm = 0x5CD
movq %r15, %rdi
callq 0x13708
leaq 0x19909(%rip), %rdi     # 0x1d534
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b0f0
movq %rsp, %rdi
movl $0x5ce, 0xc(%rdi)       # imm = 0x5CE
callq 0x1b1f2
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_O2/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 0x20736(%rip), %rbx     # 0x243a0
leaq 0x20cbf(%rip), %r13     # 0x24930
leaq 0x206b8(%rip), %r12     # 0x24330
leaq 0x186cb(%rip), %r14     # 0x1c34a
movq %rbx, %rdi
movl %ebp, %esi
callq 0x12ae7
movl %eax, %r15d
movl (%r13), %eax
testl %r15d, %r15d
js 0x3d6c
testl %eax, %eax
je 0x3cd9
movq (%r12), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1a7f4
testl %eax, %eax
je 0x3cd9
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0xb17, 0xc(%rax)       # imm = 0xB17
movl %ebp, %esi
subl %r15d, %esi
leaq 0x184c4(%rip), %rdi     # 0x1c194
movl %ebp, %edx
xorl %eax, %eax
callq 0x1b0f0
testl %r15d, %r15d
je 0x3d2d
cmpl $0x0, 0x68(%rbx)
jle 0x3d5d
cmpl $0x0, (%r13)
je 0x3d20
movq (%r12), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1a7f4
testl %eax, %eax
je 0x3d20
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0xb1d, 0xc(%rax)       # imm = 0xB1D
leaq 0x184d8(%rip), %rdi     # 0x1c1f1
xorl %eax, %eax
callq 0x1b0f0
pushq $0x1
popq %rdi
callq 0x2260
jmp 0x3c7f
movq 0x202c4(%rip), %r15     # 0x23ff8
movq (%r15), %rdi
leaq 0x18478(%rip), %rsi     # 0x1c1b6
movl %ebp, %edx
xorl %eax, %eax
callq 0x2180
movq (%r15), %rdi
movl 0x28(%rbx), %edx
leaq 0x18482(%rip), %rsi     # 0x1c1d6
xorl %eax, %eax
callq 0x2180
jmp 0x3cde
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %eax, %eax
je 0x3dab
movq (%r12), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1a7f4
testl %eax, %eax
je 0x3dab
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0xb14, 0xc(%rax)       # imm = 0xB14
movl 0x28(%rbx), %esi
movl 0x40(%rbx), %edx
leaq 0x183d1(%rip), %rdi     # 0x1c175
xorl %eax, %eax
callq 0x1b0f0
movq 0x20246(%rip), %rax     # 0x23ff8
movq (%rax), %rdi
movl 0x40(%rbx), %edx
leaq 0x1844d(%rip), %rsi     # 0x1c20c
xorl %eax, %eax
callq 0x2180
callq 0x2050
// File: /workspace/github_c_makefile_star2_O2/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 0x205c1(%rip), %rbx     # 0x243a0
leaq 0x20b4a(%rip), %r15     # 0x24930
leaq 0x20543(%rip), %r13     # 0x24330
leaq 0x18556(%rip), %r14     # 0x1c34a
movq %rbx, %rdi
movl %ebp, %esi
callq 0x12ae7
movl %eax, %r12d
movl (%r15), %eax
testl %r12d, %r12d
js 0x3eb4
testl %eax, %eax
je 0x3e4d
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1a7f4
testl %eax, %eax
je 0x3e4d
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0xb33, 0xc(%rax)       # imm = 0xB33
movl %ebp, %esi
subl %r12d, %esi
leaq 0x183f4(%rip), %rdi     # 0x1c238
movl %ebp, %edx
xorl %eax, %eax
callq 0x1b0f0
cmpl $0x0, 0x28(%rbx)
jg 0x3ef8
cmpl $0x0, 0x68(%rbx)
jle 0x3ea5
cmpl $0x0, (%r15)
je 0x3e98
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1a7f4
testl %eax, %eax
je 0x3e98
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0xb39, 0xc(%rax)       # imm = 0xB39
leaq 0x18360(%rip), %rdi     # 0x1c1f1
xorl %eax, %eax
callq 0x1b0f0
pushq $0x1
popq %rdi
callq 0x2260
jmp 0x3df4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %eax, %eax
je 0x3f36
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1a7f4
testl %eax, %eax
je 0x3f36
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0xb30, 0xc(%rax)       # imm = 0xB30
movl 0x28(%rbx), %esi
movl 0x40(%rbx), %edx
leaq 0x18289(%rip), %rdi     # 0x1c175
xorl %eax, %eax
callq 0x1b0f0
callq 0x2050
cmpl $0x0, (%r15)
je 0x3f36
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1a7f4
testl %eax, %eax
je 0x3f36
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0xb35, 0xc(%rax)       # imm = 0xB35
movl 0x28(%rbx), %esi
leaq 0x1832b(%rip), %rdi     # 0x1c25a
xorl %eax, %eax
callq 0x1b0f0
callq 0x2050
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x3fcb
movq 0x1fd00(%rip), %rdi     # 0x243a0
leaq 0x43c7(%rip), %rsi      # 0x8a6e
leaq 0x1fbf2(%rip), %rdx     # 0x242a0
callq 0x123b7
movq %rax, %r15
movq 0x1fce3(%rip), %r12     # 0x243a0
leaq 0x17f0c(%rip), %rdi     # 0x1c5d0
callq 0x1691f
movq %r15, %rdi
movq %rax, %rsi
callq 0x19164
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x12494
movq 0x1fcb7(%rip), %rdi     # 0x243a0
leaq 0x4464(%rip), %rsi      # 0x8b54
movq %r14, %rdx
callq 0x123b7
movq 0x1fca1(%rip), %rdi     # 0x243a0
leaq 0x45c8(%rip), %rsi      # 0x8cce
movq %rax, %rdx
callq 0x123b7
movq %rax, %r14
movq 0x1fc88(%rip), %r15     # 0x243a0
leaq 0x17e7a(%rip), %rdi     # 0x1c599
callq 0x1691f
movq 0x1fc9d(%rip), %rsi     # 0x243c8
movq %rax, %rdi
callq 0x19164
movq %r14, %rdi
movq %rax, %rsi
callq 0x19164
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x12494
movl 0x1fa4e(%rip), %edi     # 0x241a0
callq 0x3dcb
movq %r14, %rdi
callq 0x11724
leaq 0x4662(%rip), %rcx      # 0x8dc8
cmpq %rcx, %rax
jne 0x4777
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x18063(%rip), %rdi     # 0x1c7e1
leaq 0x17897(%rip), %rsi     # 0x1c01c
leaq 0x1806e(%rip), %rcx     # 0x1c7fa
movl $0xbc9, %edx            # imm = 0xBC9
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 0x176f3(%rip), %rax     # 0x1cba6
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1ee70(%rip), %rax     # 0x24330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xb8b, 0xc(%rdi)       # imm = 0xB8B
leaq 0x16e6f(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1ec6a(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
movq %r14, 0x1ee96(%rip)     # 0x24390
movq %r14, %rdi
callq 0x2d7d
movq %rax, 0x1eecf(%rip)     # 0x243d8
leaq 0x17089(%rip), %r14     # 0x1c599
leaq 0x37b7(%rip), %r15      # 0x8cce
testq %rbx, %rbx
je 0x5521
callq 0x3fcb
movq 0x1eeb0(%rip), %rdi     # 0x243d8
callq 0x2f66
cmpq $-0x1, %rax
je 0x55a6
movq %rax, %r12
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x55ad
movq 0x1ee8b(%rip), %r13     # 0x243d0
testq %rbx, %rbx
je 0x555f
movq 0x1ee4f(%rip), %rdi     # 0x243a0
movq %r15, %rsi
movq %r13, %rdx
callq 0x123b7
movq %rax, %r13
movq 0x1ee3a(%rip), %rbp     # 0x243a0
movq %r14, %rdi
callq 0x1691f
movq 0x1ee53(%rip), %rsi     # 0x243c8
movq %rax, %rdi
callq 0x19164
movq %r13, %rdi
movq %rax, %rsi
callq 0x19164
movq %rbp, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x12494
movl 0x1ec04(%rip), %edi     # 0x241a0
callq 0x3c56
jmp 0x5517
movl $0xb94, %eax            # imm = 0xB94
jmp 0x55b2
movl $0xb96, %eax            # imm = 0xB96
movq %rsp, %rdi
movl %eax, 0xc(%rdi)
callq 0x1b1f2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/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 0x19306
movq %rax, %rdi
callq 0x13708
movq %rax, %rbx
leaq 0x16f7a(%rip), %rax     # 0x1c568
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1ed35(%rip), %r14     # 0x24330
movq (%r14), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x37, 0xc(%rdi)
leaq 0x16d34(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1eb2f(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
leaq 0x1f2fb(%rip), %rax     # 0x24930
cmpl $0x0, (%rax)
je 0x5674
movq (%r14), %rax
movq 0x50(%rax), %rax
leaq 0x16f2a(%rip), %rdi     # 0x1c572
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x5674
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0x38, 0xc(%rax)
leaq 0x17eca(%rip), %rdi     # 0x1d534
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1b0f0
movq 0x1ecfd(%rip), %rdi     # 0x24378
leaq 0x16ef6(%rip), %rsi     # 0x1c578
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2180
movq 0x1ece5(%rip), %rdi     # 0x24378
callq 0x21c0
movq %rsp, %rdi
movl $0x3b, 0xc(%rdi)
callq 0x1b1f2
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x191fb
movq %rax, %rdi
callq 0x1175b
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x19306
movq %rax, %r14
leaq 0x16378(%rip), %rax     # 0x1c5f0
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1e0a9(%rip), %rax     # 0x24330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x407, 0xc(%rdi)       # imm = 0x407
leaq 0x160a8(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1dea3(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
cmpq 0x1dcff(%rip), %r15     # 0x23fc0
je 0x631d
testq %r15, %r15
je 0x631d
movl %r15d, %eax
andl $0x3, %eax
jne 0x631d
movq %r15, %rdi
callq 0x191fb
movq %rax, %r12
leaq 0x1631c(%rip), %rdi     # 0x1c5fe
callq 0x1691f
movq %rax, %r13
movq %r15, %rdi
callq 0x19306
movq %r13, %rdi
movq %rax, %rsi
callq 0x19164
movq %r12, %rdi
movq %rax, %rsi
callq 0x19164
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12494
movl $0x411, %eax            # imm = 0x411
jmp 0x637c
leaq -0xd58(%rip), %rsi      # 0x55cc
leaq 0x1df75(%rip), %rdx     # 0x242a0
movq %rbx, %rdi
callq 0x123b7
movq %rax, %r14
leaq 0x161f6(%rip), %rdi     # 0x1c533
callq 0x1691f
movq %rax, %r15
leaq 0x15cd0(%rip), %rdi     # 0x1c01c
callq 0x1691f
movl $0x1023, %esi           # imm = 0x1023
movq %rax, %rdi
callq 0x19164
movq %r15, %rdi
movq %rax, %rsi
callq 0x19164
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12494
movl $0x408, %eax            # imm = 0x408
leaq 0x8(%rsp), %rdi
movl %eax, 0xc(%rdi)
callq 0x1b1f2
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/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 0x191fb
movq %rax, %rdi
callq 0x1175b
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x19306
movq %rax, %r15
leaq 0x15fa0(%rip), %rax     # 0x1c612
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1dcb1(%rip), %rax     # 0x24330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x436, 0xc(%rdi)       # imm = 0x436
leaq 0x15cb0(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1daab(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
movl %r14d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x671a
movl $0x43d, %ebp            # imm = 0x43D
cmpq 0x1d8f7(%rip), %r15     # 0x23fc0
je 0x6779
testq %r15, %r15
je 0x6779
movl %r15d, %eax
andl $0x3, %eax
jne 0x6779
movq %r15, %rdi
callq 0x191fb
cmpq 0x1dcb5(%rip), %rax     # 0x243a8
jne 0x6779
movq %r15, %rdi
callq 0x19306
movq 0x1dca0(%rip), %rdx     # 0x243a8
cmpq %rdx, %rax
jne 0x6779
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12494
jmp 0x6779
leaq -0x1155(%rip), %rsi     # 0x55cc
leaq 0x1db78(%rip), %rdx     # 0x242a0
movq %rbx, %rdi
callq 0x123b7
movq %rax, %r14
leaq 0x15df9(%rip), %rdi     # 0x1c533
callq 0x1691f
movq %rax, %r15
leaq 0x158d3(%rip), %rdi     # 0x1c01c
callq 0x1691f
movl $0x10df, %esi           # imm = 0x10DF
movq %rax, %rdi
callq 0x19164
movq %r15, %rdi
movq %rax, %rsi
callq 0x19164
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12494
movl $0x437, %ebp            # imm = 0x437
movq %rsp, %rdi
movl %ebp, 0xc(%rdi)
callq 0x1b1f2
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x191fb
movq %rax, %rdi
callq 0x1175b
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x19306
movq %rax, %r15
leaq 0x15c78(%rip), %rax     # 0x1c735
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1d866(%rip), %rax     # 0x24330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x44b, 0xc(%rdi)       # imm = 0x44B
leaq 0x15865(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1d660(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
movl %r14d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x6b51
movl $0x450, %ebp            # imm = 0x450
cmpq 0x1d4ac(%rip), %r15     # 0x23fc0
je 0x6bb0
testq %r15, %r15
je 0x6bb0
movl %r15d, %eax
andl $0x3, %eax
jne 0x6bb0
leaq -0x34cb(%rip), %rsi     # 0x366b
movq %rbx, %rdi
movq %r15, %rdx
callq 0x123b7
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12494
jmp 0x6bb0
leaq -0x158c(%rip), %rsi     # 0x55cc
leaq 0x1d741(%rip), %rdx     # 0x242a0
movq %rbx, %rdi
callq 0x123b7
movq %rax, %r14
leaq 0x159c2(%rip), %rdi     # 0x1c533
callq 0x1691f
movq %rax, %r15
leaq 0x1549c(%rip), %rdi     # 0x1c01c
callq 0x1691f
movl $0x1133, %esi           # imm = 0x1133
movq %rax, %rdi
callq 0x19164
movq %r15, %rdi
movq %rax, %rsi
callq 0x19164
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12494
movl $0x44c, %ebp            # imm = 0x44C
movq %rsp, %rdi
movl %ebp, 0xc(%rdi)
callq 0x1b1f2
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x191fb
movq %rax, %rdi
callq 0x1175b
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x19306
movq %rax, %r15
leaq 0x15b49(%rip), %rax     # 0x1c743
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1d729(%rip), %rax     # 0x24330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x45e, 0xc(%rdi)       # imm = 0x45E
leaq 0x15728(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1d523(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
movl %r14d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x6c8e
movl $0x463, %ebp            # imm = 0x463
cmpq 0x1d36f(%rip), %r15     # 0x23fc0
je 0x6ced
testq %r15, %r15
je 0x6ced
movl %r15d, %eax
andl $0x3, %eax
jne 0x6ced
leaq -0x15c4(%rip), %rsi     # 0x56af
movq %rbx, %rdi
movq %r15, %rdx
callq 0x123b7
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12494
jmp 0x6ced
leaq -0x16c9(%rip), %rsi     # 0x55cc
leaq 0x1d604(%rip), %rdx     # 0x242a0
movq %rbx, %rdi
callq 0x123b7
movq %rax, %r14
leaq 0x15885(%rip), %rdi     # 0x1c533
callq 0x1691f
movq %rax, %r15
leaq 0x1535f(%rip), %rdi     # 0x1c01c
callq 0x1691f
movl $0x117f, %esi           # imm = 0x117F
movq %rax, %rdi
callq 0x19164
movq %r15, %rdi
movq %rax, %rsi
callq 0x19164
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12494
movl $0x45f, %ebp            # imm = 0x45F
movq %rsp, %rdi
movl %ebp, 0xc(%rdi)
callq 0x1b1f2
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x191fb
movq %rax, %rdi
callq 0x1175b
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x19306
movq %rax, %r15
leaq 0x151e0(%rip), %rax     # 0x1c692
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1ce6f(%rip), %rax     # 0x24330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x1a1, 0xc(%rdi)       # imm = 0x1A1
leaq 0x14e6e(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1cc69(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
movl %r14d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x753c
movq 0x30(%rbx), %rdi
callq 0x191fb
movq %rax, %rdi
movq %r15, %rsi
callq 0x19164
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12494
leaq 0x8(%rsp), %rdi
movl $0x1a4, 0xc(%rdi)       # imm = 0x1A4
callq 0x1b1f2
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1510c(%rip), %rdi     # 0x1c64f
leaq 0x14ad2(%rip), %rsi     # 0x1c01c
leaq 0x15149(%rip), %rcx     # 0x1c69a
movl $0x1a2, %edx            # imm = 0x1A2
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 0x191fb
movq %rax, %rdi
callq 0x1175b
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x19306
movq %rax, %r14
leaq 0x1511e(%rip), %rax     # 0x1c6b1
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1cd90(%rip), %rax     # 0x24330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x187, 0xc(%rdi)       # imm = 0x187
leaq 0x14d8f(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1cb8a(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
cmpq 0x1c9e6(%rip), %r12     # 0x23fc0
je 0x7734
testq %r12, %r12
je 0x7734
movl %r12d, %eax
andl $0x3, %eax
jne 0x7734
movq %r12, %rdi
callq 0x191fb
movq %rax, %r15
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x7753
movq %r12, %rdi
callq 0x19306
testq %rax, %rax
je 0x7715
movq %r12, %rdi
callq 0x19306
testb $0x3, %al
jne 0x7715
movq %r12, %rdi
callq 0x19306
cmpq 0x1c984(%rip), %rax     # 0x23fc0
je 0x7715
movq %r12, %rdi
callq 0x19306
andl $0x3, %eax
cmpl $0x1, %eax
je 0x7715
movq %r12, %rdi
callq 0x19306
movq %rax, %rdi
callq 0x191fb
movq %rax, %r13
movq %r12, %rdi
callq 0x19306
movq %rax, %rdi
callq 0x19306
cmpq 0x1c940(%rip), %r14     # 0x23fc0
je 0x76f7
testq %r14, %r14
je 0x76f7
movq %rax, %r12
movl %r14d, %eax
andl $0x3, %eax
jne 0x76f7
movq %r14, %rdi
callq 0x191fb
cmpq %r13, %rax
je 0x76b8
movq %r14, %rdi
callq 0x191fb
cmpq %r12, %rax
jne 0x76f7
leaq 0x354(%rip), %rbp       # 0x7a07
movq %r13, %r12
jmp 0x76bf
leaq 0xb3(%rip), %rbp        # 0x7772
movq 0x30(%rbx), %rdi
callq 0x191fb
movq %rax, %rbx
movq %r14, %rdi
callq 0x19306
movq %r12, %rdi
movq %rax, %rsi
callq 0x19164
movq %r15, %rdi
movq %rax, %rsi
callq 0x19164
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x11b16
movq %rsp, %rdi
movl $0x196, 0xc(%rdi)       # imm = 0x196
callq 0x1b1f2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14f40(%rip), %rdi     # 0x1c65c
leaq 0x148f9(%rip), %rsi     # 0x1c01c
leaq 0x14f90(%rip), %rcx     # 0x1c6ba
movl $0x18b, %edx            # imm = 0x18B
callq 0x2100
leaq 0x14eef(%rip), %rdi     # 0x1c62a
leaq 0x148da(%rip), %rsi     # 0x1c01c
leaq 0x14f71(%rip), %rcx     # 0x1c6ba
movl $0x188, %edx            # imm = 0x188
callq 0x2100
leaq 0x14ef5(%rip), %rdi     # 0x1c64f
leaq 0x148bb(%rip), %rsi     # 0x1c01c
leaq 0x14f52(%rip), %rcx     # 0x1c6ba
movl $0x18a, %edx            # imm = 0x18A
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 0x13708
andl $0x3, %ebx
xorl %r14d, %r14d
cmpl $0x2, %ebx
sete %r14b
addq %rax, %r14
movq %r14, %rdi
callq 0x20d0
leaq 0x1(%rax), %rsi
pushq $0x1
popq %rdi
callq 0x2160
movq %rax, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2090
// File: /workspace/github_c_makefile_star2_O2/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 0x191fb
movq %rax, %rdi
callq 0x1175b
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x19306
movq %rax, %r14
leaq 0x1445a(%rip), %rax     # 0x1c798
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1bfe5(%rip), %rax     # 0x24330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x200, 0xc(%rdi)       # imm = 0x200
leaq 0x13fe4(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1bddf(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
cmpq 0x1bc3b(%rip), %r15     # 0x23fc0
je 0x83ce
testq %r15, %r15
je 0x83ce
movl %r15d, %eax
andl $0x3, %eax
jne 0x83ce
movq %r15, %rdi
callq 0x191fb
movq %rax, %r12
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x8432
movq %r15, %rdi
callq 0x19306
cmpq 0x1bfce(%rip), %r14     # 0x24388
je 0x8493
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
jmp 0x84cb
leaq -0x2e09(%rip), %rsi     # 0x55cc
leaq 0x1bec4(%rip), %rdx     # 0x242a0
movq %rbx, %rdi
callq 0x123b7
movq %rax, %r14
leaq 0x14145(%rip), %rdi     # 0x1c533
callq 0x1691f
movq %rax, %r15
leaq 0x13c1f(%rip), %rdi     # 0x1c01c
callq 0x1691f
movl $0x807, %esi            # imm = 0x807
movq %rax, %rdi
callq 0x19164
movq %r15, %rdi
movq %rax, %rsi
callq 0x19164
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12494
movl $0x201, %eax            # imm = 0x201
jmp 0x84d5
leaq -0x2e6d(%rip), %rsi     # 0x55cc
leaq 0x1be60(%rip), %rdx     # 0x242a0
movq %rbx, %rdi
callq 0x123b7
movq %rax, %r14
leaq 0x140e1(%rip), %rdi     # 0x1c533
callq 0x1691f
movq %rax, %r15
leaq 0x13bbb(%rip), %rdi     # 0x1c01c
callq 0x1691f
movl $0x80f, %esi            # imm = 0x80F
movq %rax, %rdi
callq 0x19164
movq %r15, %rdi
movq %rax, %rsi
callq 0x19164
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12494
movl $0x203, %eax            # imm = 0x203
jmp 0x84d5
movq %rax, %r15
leaq 0x4f(%rip), %rsi        # 0x84ec
movq %rbx, %rdi
movq %r12, %rdx
callq 0x123b7
movq %rax, %r14
leaq 0x1411e(%rip), %rdi     # 0x1c5d0
callq 0x1691f
movq %r14, %rdi
movq %rax, %rsi
callq 0x19164
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x12494
movl $0x20c, %eax            # imm = 0x20C
movq %rsp, %rdi
movl %eax, 0xc(%rdi)
callq 0x1b1f2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x191fb
movq %rax, %rdi
callq 0x1175b
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x19306
movq %rax, %r15
leaq 0x14289(%rip), %rax     # 0x1c7a8
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1be02(%rip), %rax     # 0x24330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x1e2, 0xc(%rdi)       # imm = 0x1E2
leaq 0x13e01(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1bbfc(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
movl %r14d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x859c
cmpq 0x1be15(%rip), %r15     # 0x24388
jne 0x8587
movq 0x1be3c(%rip), %rdi     # 0x243b8
movl $0xa7, %esi
callq *0x8(%rdi)
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x12494
movl $0x1eb, %eax            # imm = 0x1EB
jmp 0x85fb
leaq -0x2fd7(%rip), %rsi     # 0x55cc
leaq 0x1bcf6(%rip), %rdx     # 0x242a0
movq %rbx, %rdi
callq 0x123b7
movq %rax, %r14
leaq 0x13f77(%rip), %rdi     # 0x1c533
callq 0x1691f
movq %rax, %r15
leaq 0x13a51(%rip), %rdi     # 0x1c01c
callq 0x1691f
movl $0x78f, %esi            # imm = 0x78F
movq %rax, %rdi
callq 0x19164
movq %r15, %rdi
movq %rax, %rsi
callq 0x19164
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12494
movl $0x1e3, %eax            # imm = 0x1E3
leaq 0x8(%rsp), %rdi
movl %eax, 0xc(%rdi)
callq 0x1b1f2
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x191fb
movq %rax, %rdi
callq 0x1175b
movq %rax, %r14
leaq 0x13d86(%rip), %rax     # 0x1c81b
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1b88c(%rip), %rax     # 0x24330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xb68, 0xc(%rdi)       # imm = 0xB68
leaq 0x1388b(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1b686(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
movq 0x1b89a(%rip), %rsi     # 0x24378
pushq $0xa
popq %rdi
callq 0x2130
movq 0x1b88b(%rip), %rdi     # 0x24378
callq 0x21c0
cmpq 0x1b4c7(%rip), %r14     # 0x23fc0
je 0x8b39
testq %r14, %r14
je 0x8b39
movl %r14d, %eax
andl $0x3, %eax
jne 0x8b39
movq %r14, %rdi
callq 0x191fb
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x8b39
movq %r14, %rdi
callq 0x191fb
movq %rax, %r15
movq %r14, %rdi
callq 0x19306
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x12494
leaq 0x8(%rsp), %rdi
movl $0xb6e, 0xc(%rdi)       # imm = 0xB6E
callq 0x1b1f2
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x30(%rdi), %rdi
callq 0x191fb
movq %rax, %rdi
callq 0x1175b
movq %rax, %r15
movq 0x30(%r14), %rdi
callq 0x19306
movq %rax, %rbx
leaq 0x13c9b(%rip), %rax     # 0x1c827
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1b797(%rip), %r13     # 0x24330
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xbb1, 0xc(%rdi)       # imm = 0xBB1
leaq 0x13795(%rip), %r12     # 0x1c34a
movq %r12, 0x10(%rdi)
leaq 0x1b590(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
leaq 0x1bd5c(%rip), %rbp     # 0x24930
cmpl $0x0, (%rbp)
je 0x8c1a
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x1a7f4
testl %eax, %eax
je 0x8c1a
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0xbb2, 0xc(%rax)       # imm = 0xBB2
movq %r15, %rdi
callq 0x13708
leaq 0x13c22(%rip), %rdi     # 0x1c832
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b0f0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1942d
testq %rax, %rax
je 0x8c67
movq 0x30(%r14), %rdi
callq 0x191fb
leaq 0x18e(%rip), %rsi       # 0x8dc8
leaq 0x1b65f(%rip), %rdx     # 0x242a0
movq %rax, %rdi
callq 0x11b16
movq %rsp, %rdi
movl $0xbba, 0xc(%rdi)       # imm = 0xBBA
callq 0x1b1f2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, (%rbp)
je 0x8cad
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x1a7f4
testl %eax, %eax
je 0x8cad
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0xbb6, 0xc(%rax)       # imm = 0xBB6
movq %rbx, %rdi
callq 0x13708
leaq 0x13b99(%rip), %rdi     # 0x1c83c
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b0f0
movq 0x1b344(%rip), %rax     # 0x23ff8
movq (%rax), %rcx
leaq 0x13b88(%rip), %rdi     # 0x1c846
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
callq 0x2250
callq 0x2050