LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/kernel.c
// Function: file_sink
SINK*
file_sink(FILE* f)
{
	SINK* sink;

	DBUG_ENTER("file_sink");
	DBUG_PRINT("f", ("%p", f));
	sink = NEW(SINK);
	sink->context = MK_REF(f);
	sink->put = file_put;
	sink->put_cstr = generic_put_cstr;
	DBUG_RETURN sink;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x269da(%rip), %rax     # 0x2909d
movq %rax, -0x38(%rbp)
leaq 0x2cc52(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl $0x8e, -0x2c(%rbp)
leaq 0x26c86(%rip), %rax     # 0x2936f
movq %rax, -0x28(%rbp)
leaq 0x2ca4c(%rip), %rax     # 0x2f140
movq %rax, -0x20(%rbp)
leaq 0x2cc21(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28490
leaq 0x2d206(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0x2770
leaq 0x2cbfa(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x26a37(%rip), %rcx     # 0x2916b
movq %rcx, 0x10(%rax)
leaq 0x26a2c(%rip), %rdi     # 0x2916b
callq 0x278a0
cmpl $0x0, %eax
je 0x2770
leaq 0x2cbd0(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x8f, 0xc(%rax)
movq -0x8(%rbp), %rsi
leaq 0x288e4(%rip), %rdi     # 0x2b04d
movb $0x0, %al
callq 0x28540
jmp 0x2772
movl $0x18, %edi
movl $0x1, %esi
callq 0x2150
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
shlq $0x2, %rcx
orq $0x3, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq -0x443(%rip), %rcx      # 0x2360
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq -0x292(%rip), %rcx      # 0x2520
movq %rcx, 0x10(%rax)
movl $0x94, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28660
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/kernel.c
// Function: string_empty
CONS*
string_empty(SOURCE* src)
{
	char* s;

	DBUG_ENTER("string_empty");
	s = (char*)(MK_PTR(src->context));
	DBUG_PRINT("s", ((s ? "\"%s\"" : "NULL"), s));
	DBUG_RETURN ((s && *s) ? a_false : a_true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x268c4(%rip), %rax     # 0x290a7
movq %rax, -0x38(%rbp)
leaq 0x2cb32(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl $0xa6, -0x2c(%rbp)
leaq 0x26b66(%rip), %rax     # 0x2936f
movq %rax, -0x28(%rbp)
leaq 0x2c92c(%rip), %rax     # 0x2f140
movq %rax, -0x20(%rbp)
leaq 0x2cb01(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28490
movq -0x8(%rbp), %rax
movq (%rax), %rax
sarq $0x2, %rax
movq %rax, -0x10(%rbp)
leaq 0x2d0d7(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0x28b2
leaq 0x2cacb(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x27d03(%rip), %rcx     # 0x2a566
movq %rcx, 0x10(%rax)
leaq 0x27cf8(%rip), %rdi     # 0x2a566
callq 0x278a0
cmpl $0x0, %eax
je 0x28b2
leaq 0x2caa1(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0xa8, 0xc(%rax)
movq -0x10(%rbp), %rcx
leaq 0x28e82(%rip), %rdi     # 0x2b71a
leaq 0x267f9(%rip), %rax     # 0x29098
cmpq $0x0, %rcx
cmovneq %rax, %rdi
movq -0x10(%rbp), %rsi
movb $0x0, %al
callq 0x28540
jmp 0x28b4
movl $0xa9, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28660
cmpq $0x0, -0x10(%rbp)
je 0x28e4
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x28e4
movq 0x2ca92(%rip), %rax     # 0x2f370
movq %rax, -0x40(%rbp)
jmp 0x28ef
movq 0x2ca8d(%rip), %rax     # 0x2f378
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/kernel.c
// Function: string_get
CONS*
string_get(SOURCE* src)
{
	char* s;
	int c;

	DBUG_ENTER("string_get");
	if ((src->empty)(src) == a_true) {
		DBUG_PRINT("c", ("EOF"));
		DBUG_RETURN NUMBER(EOF);
	}
	s = (char*)(MK_PTR(src->context));
	c = *s;
	DBUG_PRINT("c", ((isprint(c) ? "%d '%c'" : "%d '\\x%X'"), c, c));
	DBUG_RETURN NUMBER(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x267a1(%rip), %rax     # 0x290b4
movq %rax, -0x48(%rbp)
leaq 0x2ca02(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x40(%rbp)
movl $0xb1, -0x3c(%rbp)
leaq 0x26a36(%rip), %rax     # 0x2936f
movq %rax, -0x38(%rbp)
leaq 0x2c7fc(%rip), %rax     # 0x2f140
movq %rax, -0x30(%rbp)
leaq 0x2c9d1(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x28490
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
cmpq 0x2ca00(%rip), %rax     # 0x2f378
jne 0x29f7
jmp 0x297c
leaq 0x2cf9d(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0x29d5
leaq 0x2c991(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x28187(%rip), %rcx     # 0x2ab24
movq %rcx, 0x10(%rax)
leaq 0x2817c(%rip), %rdi     # 0x2ab24
callq 0x278a0
cmpl $0x0, %eax
je 0x29d5
leaq 0x2c967(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0xb3, 0xc(%rax)
leaq 0x266f1(%rip), %rdi     # 0x290bf
movb $0x0, %al
callq 0x28540
jmp 0x29d7
movl $0xb4, -0x3c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x28660
movq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x2ab5
movq -0x10(%rbp), %rax
movq (%rax), %rax
sarq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
leaq 0x2cf09(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0x2a93
leaq 0x2c8fd(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x280f3(%rip), %rcx     # 0x2ab24
movq %rcx, 0x10(%rax)
leaq 0x280e8(%rip), %rdi     # 0x2ab24
callq 0x278a0
cmpl $0x0, %eax
je 0x2a93
leaq 0x2c8d3(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0xb8, 0xc(%rax)
callq 0x2250
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x4000, %ecx           # imm = 0x4000
leaq 0x265d4(%rip), %rdi     # 0x2904c
leaq 0x265c5(%rip), %rax     # 0x29044
cmpl $0x0, %ecx
cmovneq %rax, %rdi
movl -0x1c(%rbp), %esi
movl -0x1c(%rbp), %edx
movb $0x0, %al
callq 0x28540
jmp 0x2a95
movl $0xb9, -0x3c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x28660
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
orq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x265f0(%rip), %rax     # 0x290c3
movq %rax, -0x48(%rbp)
leaq 0x2c842(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x40(%rbp)
movl $0xc1, -0x3c(%rbp)
leaq 0x26876(%rip), %rax     # 0x2936f
movq %rax, -0x38(%rbp)
leaq 0x2c63c(%rip), %rax     # 0x2f140
movq %rax, -0x30(%rbp)
leaq 0x2c811(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x28490
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x20(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x20(%rbp)
jne 0x2b5f
movl $0xc4, -0x3c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x28660
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2c13
movq -0x10(%rbp), %rax
movq (%rax), %rax
sarq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
shlq $0x2, %rcx
orq $0x3, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
leaq 0x2cd90(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0x2bf9
leaq 0x2c784(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x279bc(%rip), %rcx     # 0x2a566
movq %rcx, 0x10(%rax)
leaq 0x279b1(%rip), %rdi     # 0x2a566
callq 0x278a0
cmpl $0x0, %eax
je 0x2bf9
leaq 0x2c75a(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0xc8, 0xc(%rax)
movq -0x18(%rbp), %rcx
leaq 0x28b3b(%rip), %rdi     # 0x2b71a
leaq 0x264b2(%rip), %rax     # 0x29098
cmpq $0x0, %rcx
cmovneq %rax, %rdi
movq -0x18(%rbp), %rsi
movb $0x0, %al
callq 0x28540
jmp 0x2bfb
movl $0xc9, -0x3c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x28660
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2649c(%rip), %rax     # 0x290cf
movq %rax, -0x38(%rbp)
leaq 0x2c6e2(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl $0xd0, -0x2c(%rbp)
leaq 0x26716(%rip), %rax     # 0x2936f
movq %rax, -0x28(%rbp)
leaq 0x2c4dc(%rip), %rax     # 0x2f140
movq %rax, -0x20(%rbp)
leaq 0x2c6b1(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28490
leaq 0x2cc96(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0x2cf3
leaq 0x2c68a(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x278c2(%rip), %rcx     # 0x2a566
movq %rcx, 0x10(%rax)
leaq 0x278b7(%rip), %rdi     # 0x2a566
callq 0x278a0
cmpl $0x0, %eax
je 0x2cf3
leaq 0x2c660(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0xd1, 0xc(%rax)
movq -0x8(%rbp), %rcx
leaq 0x28a41(%rip), %rdi     # 0x2b71a
leaq 0x263b8(%rip), %rax     # 0x29098
cmpq $0x0, %rcx
cmovneq %rax, %rdi
movq -0x8(%rbp), %rsi
movb $0x0, %al
callq 0x28540
jmp 0x2cf5
movl $0x20, %edi
movl $0x1, %esi
callq 0x2150
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
shlq $0x2, %rcx
orq $0x3, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq -0x556(%rip), %rcx      # 0x27d0
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq -0x435(%rip), %rcx      # 0x2900
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
leaq -0x284(%rip), %rcx      # 0x2ac0
movq %rcx, 0x18(%rax)
movl $0xd7, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28660
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/kernel.c
// Function: file_empty
CONS*
file_empty(SOURCE* src)
{
	CONS* d;

	DBUG_ENTER("file_empty");
	d = (src->get)(src);
	DBUG_RETURN ((d == NUMBER(EOF)) ? a_true : a_false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2635a(%rip), %rax     # 0x290dd
movq %rax, -0x38(%rbp)
leaq 0x2c592(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl $0xdf, -0x2c(%rbp)
leaq 0x265c6(%rip), %rax     # 0x2936f
movq %rax, -0x28(%rbp)
leaq 0x2c38c(%rip), %rax     # 0x2f140
movq %rax, -0x20(%rbp)
leaq 0x2c561(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28490
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq %rax, -0x10(%rbp)
movl $0xe1, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28660
movq $-0x1, %rax
cmpq %rax, -0x10(%rbp)
jne 0x2e0f
movq 0x2c56f(%rip), %rax     # 0x2f378
movq %rax, -0x40(%rbp)
jmp 0x2e1a
movq 0x2c55a(%rip), %rax     # 0x2f370
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x262a5(%rip), %rax     # 0x290e8
movq %rax, -0x40(%rbp)
leaq 0x2c4d2(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x38(%rbp)
movl $0xe9, -0x34(%rbp)
leaq 0x26506(%rip), %rax     # 0x2936f
movq %rax, -0x30(%rbp)
leaq 0x2c2cc(%rip), %rax     # 0x2f140
movq %rax, -0x28(%rbp)
leaq 0x2c4a1(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x28490
leaq 0x2ca86(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0x2efb
leaq 0x2c47a(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x2623d(%rip), %rcx     # 0x290f1
movq %rcx, 0x10(%rax)
leaq 0x26232(%rip), %rdi     # 0x290f1
callq 0x278a0
cmpl $0x0, %eax
je 0x2efb
leaq 0x2c450(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0xea, 0xc(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1d250
movq %rax, %rsi
leaq 0x27671(%rip), %rdi     # 0x2a565
movb $0x0, %al
callq 0x28540
jmp 0x2efd
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x25510
movq %rax, -0x10(%rbp)
leaq 0x2c37c(%rip), %rax     # 0x2f290
cmpq %rax, -0x10(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2f46
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x25510
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
sarq $0x2, %rax
movl %eax, -0x14(%rbp)
leaq 0x2c9c8(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0x2fd4
leaq 0x2c3bc(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x27bb2(%rip), %rcx     # 0x2ab24
movq %rcx, 0x10(%rax)
leaq 0x27ba7(%rip), %rdi     # 0x2ab24
callq 0x278a0
cmpl $0x0, %eax
je 0x2fd4
leaq 0x2c392(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0xf1, 0xc(%rax)
callq 0x2250
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x4000, %ecx           # imm = 0x4000
leaq 0x26093(%rip), %rdi     # 0x2904c
leaq 0x26084(%rip), %rax     # 0x29044
cmpl $0x0, %ecx
cmovneq %rax, %rdi
movl -0x14(%rbp), %esi
movl -0x14(%rbp), %edx
movb $0x0, %al
callq 0x28540
jmp 0x2fd6
movl $0xf2, -0x34(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x28660
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x260f6(%rip), %rax     # 0x290f9
movq %rax, -0x40(%rbp)
leaq 0x2c312(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x38(%rbp)
movl $0xfa, -0x34(%rbp)
leaq 0x26346(%rip), %rax     # 0x2936f
movq %rax, -0x30(%rbp)
leaq 0x2c10c(%rip), %rax     # 0x2f140
movq %rax, -0x28(%rbp)
leaq 0x2c2e1(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x28490
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x25510
movq %rax, -0x10(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x10(%rbp)
je 0x30d9
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x25380
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x2c2f5(%rip), %rcx     # 0x2f380
shlq $0x2, %rcx
orq $0x3, %rcx
cmpq %rcx, %rax
jne 0x30a5
movq 0x2c2e1(%rip), %rax     # 0x2f380
movq %rax, -0x18(%rbp)
jmp 0x30b1
movq -0x48(%rbp), %rax
sarq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2120
movq -0x50(%rbp), %rdi
movslq %eax, %rsi
shlq $0x2, %rsi
orq $0x3, %rsi
callq 0x256d0
movl $0x109, -0x34(%rbp)     # imm = 0x109
leaq -0x40(%rbp), %rdi
callq 0x28660
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq 0x2affd(%rip), %rdi     # 0x2f3b0
callq 0x25380
movq %rax, -0x18(%rbp)
leaq 0x253d5(%rip), %rax     # 0x29798
movq %rax, -0x40(%rbp)
leaq 0x2af52(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x38(%rbp)
movl $0x338, -0x34(%rbp)     # imm = 0x338
leaq 0x24f86(%rip), %rax     # 0x2936f
movq %rax, -0x30(%rbp)
leaq 0x2ad4c(%rip), %rax     # 0x2f140
movq %rax, -0x28(%rbp)
leaq 0x2af21(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x28490
leaq 0x2b506(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0x4478
leaq 0x2aefa(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x26ca0(%rip), %rcx     # 0x2b0d4
movq %rcx, 0x10(%rax)
leaq 0x26c95(%rip), %rdi     # 0x2b0d4
callq 0x278a0
cmpl $0x0, %eax
je 0x4478
leaq 0x2aed0(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x339, 0xc(%rax)       # imm = 0x339
movq -0x8(%rbp), %rdi
callq 0x1d250
movq %rax, %rsi
leaq 0x260f4(%rip), %rdi     # 0x2a565
movb $0x0, %al
callq 0x28540
jmp 0x447a
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x2ae07(%rip), %rdx     # 0x2f290
callq 0x25d30
movq %rax, -0x10(%rbp)
leaq 0x2adf7(%rip), %rax     # 0x2f290
cmpq %rax, -0x10(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x44ed
movq 0x2aedc(%rip), %rdi     # 0x2f390
movq -0x8(%rbp), %rdx
leaq 0x58a1(%rip), %rsi      # 0x9d60
callq 0x1b6f0
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x25e20
movq %rax, -0x18(%rbp)
movq 0x2aecc(%rip), %rdi     # 0x2f3b0
movq -0x18(%rbp), %rsi
callq 0x256a0
jmp 0x44ef
leaq 0x2b42a(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0x4554
leaq 0x2ae1e(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x2528c(%rip), %rcx     # 0x2979c
movq %rcx, 0x10(%rax)
leaq 0x25281(%rip), %rdi     # 0x2979c
callq 0x278a0
cmpl $0x0, %eax
je 0x4554
leaq 0x2adf4(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x340, 0xc(%rax)       # imm = 0x340
movq -0x10(%rbp), %rdi
callq 0x1d250
movq %rax, %rsi
leaq 0x26018(%rip), %rdi     # 0x2a565
movb $0x0, %al
callq 0x28540
jmp 0x4556
movl $0x341, -0x34(%rbp)     # imm = 0x341
leaq -0x40(%rbp), %rdi
callq 0x28660
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq 0x2ae2d(%rip), %rdi     # 0x2f3b0
callq 0x25510
movq %rax, -0x18(%rbp)
leaq 0x2524b(%rip), %rax     # 0x297de
movq %rax, -0x40(%rbp)
leaq 0x2ad82(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x38(%rbp)
movl $0x5c5, -0x34(%rbp)     # imm = 0x5C5
leaq 0x24db6(%rip), %rax     # 0x2936f
movq %rax, -0x30(%rbp)
leaq 0x2ab7c(%rip), %rax     # 0x2f140
movq %rax, -0x28(%rbp)
leaq 0x2ad51(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x28490
leaq 0x2b336(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0x4648
leaq 0x2ad2a(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x251e5(%rip), %rcx     # 0x297e9
movq %rcx, 0x10(%rax)
leaq 0x251da(%rip), %rdi     # 0x297e9
callq 0x278a0
cmpl $0x0, %eax
je 0x4648
leaq 0x2ad00(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x5c6, 0xc(%rax)       # imm = 0x5C6
movq -0x8(%rbp), %rdi
callq 0x1d250
movq %rax, %rsi
leaq 0x25f24(%rip), %rdi     # 0x2a565
movb $0x0, %al
callq 0x28540
jmp 0x464a
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x2ac37(%rip), %rdx     # 0x2f290
callq 0x25d30
movq %rax, -0x10(%rbp)
leaq 0x2ac27(%rip), %rax     # 0x2f290
cmpq %rax, -0x10(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x46bd
movq 0x2ad0c(%rip), %rdi     # 0x2f390
movq -0x8(%rbp), %rdx
leaq 0x66a1(%rip), %rsi      # 0xad30
callq 0x1b6f0
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x25e20
movq %rax, -0x18(%rbp)
movq 0x2acfc(%rip), %rdi     # 0x2f3b0
movq -0x18(%rbp), %rsi
callq 0x256d0
jmp 0x46bf
leaq 0x2b25a(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0x4724
leaq 0x2ac4e(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x25102(%rip), %rcx     # 0x297e2
movq %rcx, 0x10(%rax)
leaq 0x250f7(%rip), %rdi     # 0x297e2
callq 0x278a0
cmpl $0x0, %eax
je 0x4724
leaq 0x2ac24(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x5cd, 0xc(%rax)       # imm = 0x5CD
movq -0x10(%rbp), %rdi
callq 0x1d250
movq %rax, %rsi
leaq 0x25e48(%rip), %rdi     # 0x2a565
movb $0x0, %al
callq 0x28540
jmp 0x4726
movl $0x5ce, -0x34(%rbp)     # imm = 0x5CE
leaq -0x40(%rbp), %rdi
callq 0x28660
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/kernel.c
// Function: system_info
CONS*
system_info()
{
	CONS* info = NIL;

	info = map_put(info, ATOM("Program"), ATOM(_Program));
	info = map_put(info, ATOM("Version"), ATOM(_Version));
	info = map_put(info, ATOM("Copyright"), ATOM(_Copyright));
	return info;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x2a751(%rip), %rax     # 0x2f290
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x24725(%rip), %rdi     # 0x29277
callq 0x216e0
movq %rax, -0x30(%rbp)
leaq 0x2a5ee(%rip), %rdi     # 0x2f150
callq 0x216e0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x25e20
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x246f5(%rip), %rdi     # 0x2927f
callq 0x216e0
movq %rax, -0x20(%rbp)
leaq 0x2a5bd(%rip), %rdi     # 0x2f157
callq 0x216e0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x25e20
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x246c5(%rip), %rdi     # 0x29287
callq 0x216e0
movq %rax, -0x10(%rbp)
leaq 0x2a59e(%rip), %rdi     # 0x2f170
callq 0x216e0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq %rax, %rdx
callq 0x25e20
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x4c00
movq 0x29ee4(%rip), %rdi     # 0x2f390
leaq 0x60cd(%rip), %rsi      # 0xb580
leaq 0x29dd6(%rip), %rdx     # 0x2f290
callq 0x1b6f0
movq %rax, -0x18(%rbp)
movq 0x29ec6(%rip), %rax     # 0x2f390
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x24110(%rip), %rdi     # 0x295f5
callq 0x216e0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x25290
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x1b810
movq 0x29e83(%rip), %rdi     # 0x2f390
movq -0x10(%rbp), %rdx
leaq 0x61d8(%rip), %rsi      # 0xb6f0
callq 0x1b6f0
movq %rax, -0x18(%rbp)
movq 0x29e68(%rip), %rdi     # 0x2f390
movq -0x18(%rbp), %rdx
leaq 0x638d(%rip), %rsi      # 0xb8c0
callq 0x1b6f0
movq %rax, -0x18(%rbp)
movq 0x29e4d(%rip), %rax     # 0x2f390
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x24060(%rip), %rdi     # 0x295be
callq 0x216e0
movq %rax, %rdi
movq 0x29e4b(%rip), %rsi     # 0x2f3b8
callq 0x25290
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x25290
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x1b810
movl 0x29bfc(%rip), %edi     # 0x2f190
callq 0x4930
movq -0x18(%rbp), %rdi
callq 0x1a590
leaq 0x6457(%rip), %rcx      # 0xba00
cmpq %rcx, %rax
jne 0x55b0
jmp 0x55cf
leaq 0x2424f(%rip), %rdi     # 0x29806
leaq 0x23a5e(%rip), %rsi     # 0x2901c
movl $0xbc9, %edx            # imm = 0xBC9
leaq 0x24255(%rip), %rcx     # 0x2981f
callq 0x2100
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x24214(%rip), %rax     # 0x29bcb
movq %rax, -0x50(%rbp)
leaq 0x2995e(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x48(%rbp)
movl $0xb8b, -0x44(%rbp)     # imm = 0xB8B
leaq 0x23992(%rip), %rax     # 0x2936f
movq %rax, -0x40(%rbp)
leaq 0x29758(%rip), %rax     # 0x2f140
movq %rax, -0x38(%rbp)
leaq 0x2992d(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x28490
movq -0x10(%rbp), %rax
movq %rax, 0x2996e(%rip)     # 0x2f380
movq 0x29967(%rip), %rdi     # 0x2f380
callq 0x3100
movq %rax, 0x299a3(%rip)     # 0x2f3c8
cmpq $0x0, -0x18(%rbp)
je 0x5a31
callq 0x4c00
movq 0x29990(%rip), %rdi     # 0x2f3c8
callq 0x3340
movq %rax, -0x28(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x28(%rbp)
jne 0x5a6e
movl $0xb94, -0x44(%rbp)     # imm = 0xB94
leaq -0x50(%rbp), %rdi
callq 0x28660
movq 0x29933(%rip), %rax     # 0x2f398
movq %rax, -0x8(%rbp)
jmp 0x5b38
movq -0x28(%rbp), %rax
andq $0x3, %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x5aa7
movl $0xb96, -0x44(%rbp)     # imm = 0xB96
leaq -0x50(%rbp), %rdi
callq 0x28660
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5b38
jmp 0x5aa9
movq 0x29910(%rip), %rax     # 0x2f3c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5ad6
movq 0x298ce(%rip), %rdi     # 0x2f390
movq -0x20(%rbp), %rdx
leaq 0x5df3(%rip), %rsi      # 0xb8c0
callq 0x1b6f0
movq %rax, -0x20(%rbp)
movq 0x298b3(%rip), %rax     # 0x2f390
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq 0x23ac6(%rip), %rdi     # 0x295be
callq 0x216e0
movq %rax, %rdi
movq 0x298b1(%rip), %rsi     # 0x2f3b8
callq 0x25290
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x25290
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rdx
callq 0x1b810
movl 0x29662(%rip), %edi     # 0x2f190
callq 0x4740
jmp 0x5a25
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25510
movq %rax, %rdi
callq 0x1d250
movq %rax, -0x10(%rbp)
leaq 0x23a11(%rip), %rax     # 0x2958d
movq %rax, -0x38(%rbp)
leaq 0x29799(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl $0x37, -0x2c(%rbp)
leaq 0x237cd(%rip), %rax     # 0x2936f
movq %rax, -0x28(%rbp)
leaq 0x29593(%rip), %rax     # 0x2f140
movq %rax, -0x20(%rbp)
leaq 0x29768(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28490
leaq 0x29d4d(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0x5c29
leaq 0x29741(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x239aa(%rip), %rcx     # 0x29597
movq %rcx, 0x10(%rax)
leaq 0x2399f(%rip), %rdi     # 0x29597
callq 0x278a0
cmpl $0x0, %eax
je 0x5c29
leaq 0x29717(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x38, 0xc(%rax)
movq -0x10(%rbp), %rsi
leaq 0x24943(%rip), %rdi     # 0x2a565
movb $0x0, %al
callq 0x28540
jmp 0x5c2b
movq 0x29736(%rip), %rdi     # 0x2f368
movq -0x10(%rbp), %rdx
leaq 0x23960(%rip), %rsi     # 0x2959d
movb $0x0, %al
callq 0x2170
movq 0x2971d(%rip), %rdi     # 0x2f368
callq 0x21c0
movl $0x3b, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28660
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25380
movq %rax, %rdi
callq 0x1a600
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25510
movq %rax, -0x20(%rbp)
leaq 0x22065(%rip), %rax     # 0x29615
movq %rax, -0x48(%rbp)
leaq 0x27d65(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x40(%rbp)
movl $0x407, -0x3c(%rbp)     # imm = 0x407
leaq 0x21d99(%rip), %rax     # 0x2936f
movq %rax, -0x38(%rbp)
leaq 0x27b5f(%rip), %rax     # 0x2f140
movq %rax, -0x30(%rbp)
leaq 0x27d34(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x28490
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x49(%rbp)
je 0x761e
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x7665
leaq 0x27c5b(%rip), %rax     # 0x2f290
cmpq %rax, -0x10(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x7665
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x76df
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x1b28(%rip), %rsi     # 0x5b50
leaq 0x27c11(%rip), %rdx     # 0x2f290
callq 0x1b6f0
movq %rax, -0x58(%rbp)
leaq 0x21ec9(%rip), %rdi     # 0x29558
callq 0x216e0
movq %rax, -0x68(%rbp)
leaq 0x2197d(%rip), %rdi     # 0x2901c
callq 0x216e0
movq %rax, %rdi
movl $0x1023, %esi           # imm = 0x1023
callq 0x25290
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x25290
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rdx
callq 0x1b810
movl $0x408, -0x3c(%rbp)     # imm = 0x408
leaq -0x48(%rbp), %rdi
callq 0x28660
jmp 0x775b
movq -0x10(%rbp), %rdi
callq 0x25380
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq 0x21f18(%rip), %rdi     # 0x29623
callq 0x216e0
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0x25510
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x25290
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x25290
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq %rax, %rdx
callq 0x1b810
movl $0x411, -0x3c(%rbp)     # imm = 0x411
leaq -0x48(%rbp), %rdi
callq 0x28660
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25380
movq %rax, %rdi
callq 0x1a600
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25510
movq %rax, -0x18(%rbp)
leaq 0x21aca(%rip), %rax     # 0x29637
movq %rax, -0x40(%rbp)
leaq 0x277a8(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x38(%rbp)
movl $0x436, -0x34(%rbp)     # imm = 0x436
leaq 0x217dc(%rip), %rax     # 0x2936f
movq %rax, -0x30(%rbp)
leaq 0x275a2(%rip), %rax     # 0x2f140
movq %rax, -0x28(%rbp)
leaq 0x27777(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x28490
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x7c56
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x209c(%rip), %rsi     # 0x5b50
leaq 0x2769d(%rip), %rdx     # 0x2f290
callq 0x1b6f0
movq %rax, -0x48(%rbp)
leaq 0x21955(%rip), %rdi     # 0x29558
callq 0x216e0
movq %rax, -0x58(%rbp)
leaq 0x21409(%rip), %rdi     # 0x2901c
callq 0x216e0
movq %rax, %rdi
movl $0x10df, %esi           # imm = 0x10DF
callq 0x25290
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x25290
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x1b810
movl $0x437, -0x34(%rbp)     # imm = 0x437
leaq -0x40(%rbp), %rdi
callq 0x28660
jmp 0x7d03
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x59(%rbp)
je 0x7c74
movq -0x18(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x7cf3
leaq 0x27605(%rip), %rax     # 0x2f290
cmpq %rax, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x7cf3
movq -0x18(%rbp), %rax
andq $0x3, %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x7cf3
movq -0x18(%rbp), %rdi
callq 0x25380
cmpq 0x276cd(%rip), %rax     # 0x2f398
jne 0x7cf3
movq -0x18(%rbp), %rdi
callq 0x25510
cmpq 0x276bb(%rip), %rax     # 0x2f398
jne 0x7cf3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq 0x276aa(%rip), %rdx     # 0x2f398
callq 0x1b810
movl $0x43d, -0x34(%rbp)     # imm = 0x43D
leaq -0x40(%rbp), %rdi
callq 0x28660
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25380
movq %rax, %rdi
callq 0x1a600
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25510
movq %rax, -0x18(%rbp)
leaq 0x2157d(%rip), %rax     # 0x2975a
movq %rax, -0x40(%rbp)
leaq 0x27138(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x38(%rbp)
movl $0x44b, -0x34(%rbp)     # imm = 0x44B
leaq 0x2116c(%rip), %rax     # 0x2936f
movq %rax, -0x30(%rbp)
leaq 0x26f32(%rip), %rax     # 0x2f140
movq %rax, -0x28(%rbp)
leaq 0x27107(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x28490
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x82c6
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x270c(%rip), %rsi     # 0x5b50
leaq 0x2702d(%rip), %rdx     # 0x2f290
callq 0x1b6f0
movq %rax, -0x48(%rbp)
leaq 0x212e5(%rip), %rdi     # 0x29558
callq 0x216e0
movq %rax, -0x58(%rbp)
leaq 0x20d99(%rip), %rdi     # 0x2901c
callq 0x216e0
movq %rax, %rdi
movl $0x1133, %esi           # imm = 0x1133
callq 0x25290
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x25290
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x1b810
movl $0x44c, -0x34(%rbp)     # imm = 0x44C
leaq -0x40(%rbp), %rdi
callq 0x28660
jmp 0x836f
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x59(%rbp)
je 0x82e4
movq -0x18(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x835f
leaq 0x26f95(%rip), %rax     # 0x2f290
cmpq %rax, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x835f
movq -0x18(%rbp), %rax
andq $0x3, %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x835f
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x453a(%rip), %rsi     # 0x3e10
callq 0x1b6f0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq %rax, %rdx
callq 0x1b810
movl $0x450, -0x34(%rbp)     # imm = 0x450
leaq -0x40(%rbp), %rdi
callq 0x28660
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25380
movq %rax, %rdi
callq 0x1a600
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25510
movq %rax, -0x18(%rbp)
leaq 0x213ab(%rip), %rax     # 0x29768
movq %rax, -0x40(%rbp)
leaq 0x26f58(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x38(%rbp)
movl $0x45e, -0x34(%rbp)     # imm = 0x45E
leaq 0x20f8c(%rip), %rax     # 0x2936f
movq %rax, -0x30(%rbp)
leaq 0x26d52(%rip), %rax     # 0x2f140
movq %rax, -0x28(%rbp)
leaq 0x26f27(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x28490
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x84a6
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x28ec(%rip), %rsi     # 0x5b50
leaq 0x26e4d(%rip), %rdx     # 0x2f290
callq 0x1b6f0
movq %rax, -0x48(%rbp)
leaq 0x21105(%rip), %rdi     # 0x29558
callq 0x216e0
movq %rax, -0x58(%rbp)
leaq 0x20bb9(%rip), %rdi     # 0x2901c
callq 0x216e0
movq %rax, %rdi
movl $0x117f, %esi           # imm = 0x117F
callq 0x25290
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x25290
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x1b810
movl $0x45f, -0x34(%rbp)     # imm = 0x45F
leaq -0x40(%rbp), %rdi
callq 0x28660
jmp 0x854f
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x59(%rbp)
je 0x84c4
movq -0x18(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x853f
leaq 0x26db5(%rip), %rax     # 0x2f290
cmpq %rax, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x853f
movq -0x18(%rbp), %rax
andq $0x3, %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x853f
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x28ba(%rip), %rsi     # 0x5c70
callq 0x1b6f0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq %rax, %rdx
callq 0x1b810
movl $0x463, -0x34(%rbp)     # imm = 0x463
leaq -0x40(%rbp), %rdi
callq 0x28660
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25380
movq %rax, %rdi
callq 0x1a600
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25510
movq %rax, -0x18(%rbp)
leaq 0x2059a(%rip), %rax     # 0x296b7
movq %rax, -0x40(%rbp)
leaq 0x261f8(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x38(%rbp)
movl $0x1a1, -0x34(%rbp)     # imm = 0x1A1
leaq 0x2022c(%rip), %rax     # 0x2936f
movq %rax, -0x30(%rbp)
leaq 0x25ff2(%rip), %rax     # 0x2f140
movq %rax, -0x28(%rbp)
leaq 0x261c7(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x28490
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x918b
jmp 0x91aa
leaq 0x204e2(%rip), %rdi     # 0x29674
leaq 0x1fe83(%rip), %rsi     # 0x2901c
movl $0x1a2, %edx            # imm = 0x1A2
leaq 0x2051a(%rip), %rcx     # 0x296bf
callq 0x2100
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25380
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x25290
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x1b810
movl $0x1a4, -0x34(%rbp)     # imm = 0x1A4
leaq -0x40(%rbp), %rdi
callq 0x28660
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d250
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
andq $0x3, %rax
cmpq $0x2, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xa321
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20c0
movq %rax, %rsi
addq $0x1, %rsi
movl $0x1, %edi
callq 0x2150
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2090
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25380
movq %rax, %rdi
callq 0x1a600
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25510
movq %rax, -0x18(%rbp)
leaq 0x1ec00(%rip), %rax     # 0x297cd
movq %rax, -0x40(%rbp)
leaq 0x24748(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x38(%rbp)
movl $0x1e2, -0x34(%rbp)     # imm = 0x1E2
leaq 0x1e77c(%rip), %rax     # 0x2936f
movq %rax, -0x30(%rbp)
leaq 0x24542(%rip), %rax     # 0x2f140
movq %rax, -0x28(%rbp)
leaq 0x24717(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x28490
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0xacb3
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x50fc(%rip), %rsi     # 0x5b50
leaq 0x2463d(%rip), %rdx     # 0x2f290
callq 0x1b6f0
movq %rax, -0x50(%rbp)
leaq 0x1e8f5(%rip), %rdi     # 0x29558
callq 0x216e0
movq %rax, -0x60(%rbp)
leaq 0x1e3a9(%rip), %rdi     # 0x2901c
callq 0x216e0
movq %rax, %rdi
movl $0x78f, %esi            # imm = 0x78F
callq 0x25290
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x25290
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0x1b810
movl $0x1e3, -0x34(%rbp)     # imm = 0x1E3
leaq -0x40(%rbp), %rdi
callq 0x28660
jmp 0xad21
movq -0x18(%rbp), %rax
cmpq 0x246ba(%rip), %rax     # 0x2f378
jne 0xad00
movq 0x246e1(%rip), %rax     # 0x2f3a8
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x48(%rbp), %rdi
movl $0xa7, %esi
callq *%rax
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq %rax, %rdx
callq 0x1b810
jmp 0xad11
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1b810
movl $0x1eb, -0x34(%rbp)     # imm = 0x1EB
leaq -0x40(%rbp), %rdi
callq 0x28660
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)