LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/actor.c
// Function: tv_create
CONS*
tv_create(time_t s, time_t us)
/*
 * Create a time tuple from raw time components (seconds and microseconds)
 */
{
	CONS* t = NIL;
	while (us > TICK_FREQ) {	/* normalize seconds */
		++s;
		us -= TICK_FREQ;
	}
	t = map_put(t, ATOM("us"), NUMBER(us));
	t = map_put(t, ATOM("s"), NUMBER(s));
	return t;
/*
	return cons(cons(ATOM("s"), NUMBER(tv->tv_sec)),
			cons(cons(ATOM("us"), NUMBER(tv->tv_usec)), NIL));
*/
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0xf4241, %rsi          # imm = 0xF4241
jl 0x12094
movl $0x1e8480, %eax         # imm = 0x1E8480
cmpq %rax, %r14
cmovlq %r14, %rax
negq %rax
addq %r14, %rax
addq $0xf423f, %rax          # imm = 0xF423F
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
mulq %rcx
shrq $0x12, %rdx
imulq $-0xf4240, %rdx, %rax   # imm = 0xFFF0BDC0
addq %rdx, %rbx
incq %rbx
movq $-0xf4240, %rcx         # imm = 0xFFF0BDC0
addq %r14, %rcx
addq %rax, %rcx
movq %rcx, %r14
leaq 0xac33(%rip), %rdi      # 0x1ccce
callq 0x1707c
leaq 0x3(,%r14,4), %rdx
leaq 0x111f1(%rip), %rdi     # 0x232a0
movq %rax, %rsi
callq 0x1a0ec
movq %rax, %r14
leaq 0xb494(%rip), %rdi      # 0x1d555
callq 0x1707c
leaq 0x3(,%rbx,4), %rdx
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1a0ec
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/actor.c
// Function: tv_increment
CONS*
tv_increment(time_t s, time_t us, time_t d)
/*
 * Create a time tuple offset by d ticks (usecs) from raw time components
 */
{
	while (d > TICK_FREQ) {	/* avoid overflow */
		++s;
		d -= TICK_FREQ;
	}
	return tv_create(s, us + d);
}

// Assembly:
movq %rdx, %rcx
cmpq $0xf4241, %rdx          # imm = 0xF4241
jl 0x12132
movl $0x1e8480, %eax         # imm = 0x1E8480
cmpq %rax, %rcx
cmovlq %rcx, %rax
negq %rax
addq %rcx, %rax
addq $0xf423f, %rax          # imm = 0xF423F
movabsq $0x431bde82d7b634db, %rdx # imm = 0x431BDE82D7B634DB
mulq %rdx
shrq $0x12, %rdx
imulq $-0xf4240, %rdx, %rax   # imm = 0xFFF0BDC0
addq %rdx, %rdi
incq %rdi
movq $-0xf4240, %rdx         # imm = 0xFFF0BDC0
addq %rcx, %rdx
addq %rax, %rdx
movq %rdx, %rcx
addq %rsi, %rcx
movq %rcx, %rsi
jmp 0x1203b
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/actor.c
// Function: cfg_add_gc_root
void
cfg_add_gc_root(CONFIG* cfg, CONS* root)
/*
 * Add root to list of references preserved during garbage-collection.
 */
{
	DBUG_ENTER("cfg_add_gc_root");
	DBUG_PRINT("", ("root=@%p", root));
	cfg->gc_root = cons(root, cfg->gc_root);
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa96a(%rip), %rax      # 0x1ccd1
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x10fbc(%rip), %r12     # 0x23330
movq (%r12), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xf6, 0xc(%rdi)
leaq 0x9fba(%rip), %r15      # 0x1c34a
movq %r15, 0x10(%rdi)
leaq 0x10e0d(%rip), %rcx     # 0x231a8
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
leaq 0x11581(%rip), %rax     # 0x23930
cmpl $0x0, (%rax)
je 0x123ec
movq (%r12), %rax
movq 0x50(%rax), %rax
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0x1b084
testl %eax, %eax
je 0x123ec
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0xf7, 0xc(%rax)
leaq 0xa8ff(%rip), %rdi      # 0x1cce1
movq %r14, %rsi
xorl %eax, %eax
callq 0x1b983
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x19b84
movq %rax, 0x20(%rbx)
movq %rsp, %rdi
movl $0xf9, 0xc(%rdi)
callq 0x1ba97
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/actor.c
// Function: cfg_force_gc
void
cfg_force_gc(CONFIG* cfg)
/*
 * Force immediate garbage-collection. (WARNING: NOT CONCURRENT!)
 */
{
	CONS* root;

	DBUG_ENTER("cfg_force_gc");
	root = cfg_gather_roots(cfg);
	DBUG_PRINT("", ("length(root)=%d", length(root)));
	gc_full_collection(root);
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0xa8c0(%rip), %rax      # 0x1ccea
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x10ef7(%rip), %r15     # 0x23330
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x12a, 0xc(%rdi)       # imm = 0x12A
leaq 0x9ef6(%rip), %r14      # 0x1c34a
movq %r14, 0x10(%rdi)
leaq 0x10d49(%rip), %rcx     # 0x231a8
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
movq %rbx, %rdi
callq 0x124e3
movq %rax, %rbx
leaq 0x114b2(%rip), %rax     # 0x23930
cmpl $0x0, (%rax)
je 0x124c0
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1b084
testl %eax, %eax
je 0x124c0
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x12c, 0xc(%rax)       # imm = 0x12C
movq %rbx, %rdi
callq 0x19edf
leaq 0xa840(%rip), %rdi      # 0x1ccf7
movl %eax, %esi
xorl %eax, %eax
callq 0x1b983
movq %rbx, %rdi
callq 0x17c4e
leaq 0x8(%rsp), %rdi
movl $0x12e, 0xc(%rdi)       # imm = 0x12E
callq 0x1ba97
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/actor.c
// Function: cfg_start_gc
void
cfg_start_gc(CONFIG* cfg)
/*
 * Start concurrent actor-based garbage-collection process.
 */
{
	CONS* root;

	DBUG_ENTER("cfg_start_gc");
	root = cfg_gather_roots(cfg);
	DBUG_PRINT("", ("length(root)=%d", length(root)));
	gc_actor_collection(cfg, root);
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xa58a(%rip), %rax      # 0x1cd07
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x10ba6(%rip), %r12     # 0x23330
movq (%r12), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x139, 0xc(%rdi)       # imm = 0x139
leaq 0x9ba4(%rip), %r15      # 0x1c34a
movq %r15, 0x10(%rdi)
leaq 0x109f7(%rip), %rcx     # 0x231a8
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
movq %rbx, %rdi
callq 0x124e3
movq %rax, %r14
leaq 0x11160(%rip), %rax     # 0x23930
cmpl $0x0, (%rax)
je 0x12814
movq (%r12), %rax
movq 0x50(%rax), %rax
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0x1b084
testl %eax, %eax
je 0x12814
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x13b, 0xc(%rax)       # imm = 0x13B
movq %r14, %rdi
callq 0x19edf
leaq 0xa4ec(%rip), %rdi      # 0x1ccf7
movl %eax, %esi
xorl %eax, %eax
callq 0x1b983
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17f90
movq %rsp, %rdi
movl $0x13d, 0xc(%rdi)       # imm = 0x13D
callq 0x1ba97
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/actor.c
// Function: abe__actor
CONS*
abe__actor(CONFIG* cfg, BEH beh, CONS* state)
/*
 * Create a new actor with specified state/behavior.
 */
{
	CONS* actor = NIL;

	DBUG_ENTER("actor");
	XDBUG_PRINT("", ("beh=@%p state=@%p", beh, state));
	XDBUG_PRINT("", ("state=%s", cons_to_str(state)));
	actor = MK_ACTOR(cons(MK_FUNC(beh), state));
	DBUG_PRINT("", ("actor=%s", cons_to_str(actor)));
	DBUG_RETURN actor;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
leaq 0xb3d3(%rip), %rax      # 0x1dc25
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x10ad1(%rip), %r12     # 0x23330
movq (%r12), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x148, 0xc(%rdi)       # imm = 0x148
leaq 0x9acf(%rip), %r14      # 0x1c34a
movq %r14, 0x10(%rdi)
leaq 0x10922(%rip), %rcx     # 0x231a8
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
leaq 0x3(,%r15,4), %rdi
movq %rbx, %rsi
callq 0x19b84
movq %rax, %rbx
andq $-0x4, %rbx
incq %rbx
leaq 0x1107c(%rip), %rax     # 0x23930
cmpl $0x0, (%rax)
je 0x128f9
movq (%r12), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1b084
testl %eax, %eax
je 0x128f9
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x14c, 0xc(%rax)       # imm = 0x14C
movq %rbx, %rdi
callq 0x13b9c
leaq 0xa425(%rip), %rdi      # 0x1cd14
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b983
movq %rsp, %rdi
movl $0x14d, 0xc(%rdi)       # imm = 0x14D
callq 0x1ba97
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/actor.c
// Function: abe__send
void
abe__send(CONFIG* cfg, CONS* target, CONS* msg)
/*
 * Queue an asynchronous message for the target actor.
 */
{
	CONS* entry = NIL;
	CONS* cq = CONFIG_QUEUE(cfg);

	DBUG_ENTER("send");
	DBUG_PRINT("", ("target=%s", cons_to_str(target)));
	assert(actorp(target));
	DBUG_PRINT("", ("msg=%s", cons_to_str(msg)));
	entry = cq_cons(target, msg);
	CQ_PUT(cq, cq_cons(entry, NIL));
	XDBUG_PRINT("", ("queue=%s", cons_to_str(CQ_PEEK(cq))));
	++cfg->q_count;
	DBUG_PRINT("", ("%d message(s) queued", cfg->q_count));
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xa41e(%rip), %rax      # 0x1cd53
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x109ee(%rip), %r13     # 0x23330
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x167, 0xc(%rdi)       # imm = 0x167
leaq 0x99ec(%rip), %r14      # 0x1c34a
movq %r14, 0x10(%rdi)
leaq 0x1083f(%rip), %rcx     # 0x231a8
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
leaq 0x10fb3(%rip), %rbp     # 0x23930
cmpl $0x0, (%rbp)
je 0x129c3
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1b084
testl %eax, %eax
je 0x129c3
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x168, 0xc(%rax)       # imm = 0x168
movq %r12, %rdi
callq 0x13b9c
leaq 0xa39f(%rip), %rdi      # 0x1cd58
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b983
movl %r12d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x12ae2
cmpl $0x0, (%rbp)
je 0x12a18
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1b084
testl %eax, %eax
je 0x12a18
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x16a, 0xc(%rax)       # imm = 0x16A
movq %r15, %rdi
callq 0x13b9c
leaq 0xa38c(%rip), %rdi      # 0x1cd9a
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b983
movq %r12, %rdi
movq %r15, %rsi
callq 0x12b01
movq %rax, %r15
movq %rbx, %rdi
callq 0x19ba6
cmpq 0x1058b(%rip), %rax     # 0x22fc0
je 0x12a5e
movq %rbx, %rdi
callq 0x19c45
movq %rax, %r12
leaq 0x10857(%rip), %rsi     # 0x232a0
movq %r15, %rdi
callq 0x12b01
movq %r12, %rdi
movq %rax, %rsi
callq 0x19cf2
jmp 0x12a78
leaq 0x1083b(%rip), %rsi     # 0x232a0
movq %r15, %rdi
callq 0x12b01
movq %rbx, %rdi
movq %rax, %rsi
callq 0x19ce4
movq %rbx, %rdi
movq %rax, %rsi
callq 0x19cf2
incl 0x28(%rbx)
cmpl $0x0, (%rbp)
je 0x12ac4
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1b084
testl %eax, %eax
je 0x12ac4
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x16f, 0xc(%rax)       # imm = 0x16F
movl 0x28(%rbx), %esi
leaq 0xa2e4(%rip), %rdi      # 0x1cda1
xorl %eax, %eax
callq 0x1b983
movq %rsp, %rdi
movl $0x170, 0xc(%rdi)       # imm = 0x170
callq 0x1ba97
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa279(%rip), %rdi      # 0x1cd62
leaq 0xa0e8(%rip), %rsi      # 0x1cbd8
leaq 0xa27a(%rip), %rcx      # 0x1cd71
movl $0x169, %edx            # imm = 0x169
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/actor.c
// Function: cq_cons
static CONS*
cq_cons(CONS* a, CONS* d)	/* allocate recycleable cell */
{
	CONS* p;

	XDBUG_ENTER("cq_cons");
	if (!nilp(free_config)) {
		assert(consp(free_config));
		p = free_config;
		free_config = cdr(p);
		rplaca(p, a);
		rplacd(p, d);
	} else {
		p = gc_perm(a, d);		/* non-garbage-collected cell allocation */
	}
	if (++free_config_cnt > free_config_max) {
		free_config_max = free_config_cnt;
	}
	XDBUG_RETURN p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x106a5(%rip), %rbx     # 0x231b8
cmpq 0x104a6(%rip), %rbx     # 0x22fc0
je 0x12b4f
testq %rbx, %rbx
je 0x12b83
movl %ebx, %eax
andl $0x3, %eax
jne 0x12b83
movq %rbx, %rdi
callq 0x19c45
movq %rax, 0x10681(%rip)     # 0x231b8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19ce4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19cf2
jmp 0x12b5d
movq %r15, %rdi
movq %r14, %rsi
callq 0x18064
movq %rax, %rbx
movl 0x10885(%rip), %ecx     # 0x233e8
leal 0x1(%rcx), %eax
movl %eax, 0x1087c(%rip)     # 0x233e8
cmpl 0x1087a(%rip), %ecx     # 0x233ec
jl 0x12b7a
movl %eax, 0x10872(%rip)     # 0x233ec
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xa4b8(%rip), %rdi      # 0x1d042
leaq 0xa047(%rip), %rsi      # 0x1cbd8
leaq 0xa4bd(%rip), %rcx      # 0x1d055
movl $0x76, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/actor.c
// Function: cq_free
static CONS*
cq_free(CONS* p)				/* recycle cell */
{
	XDBUG_ENTER("cq_free");
	if (!nilp(p)) {
		rplaca(p, NIL);
		rplacd(p, free_config);
		free_config = p;
		--free_config_cnt;
	} else {
		DBUG_PRINT("cq_free", ("ALERT! cq_free(NIL)"));
	}
	XDBUG_RETURN NIL;
}

// Assembly:
pushq %rbx
cmpq 0xf49f(%rip), %rdi      # 0x22fc0
je 0x13b50
movq %rdi, %rbx
leaq 0xf773(%rip), %rsi      # 0x232a0
callq 0x19ce4
movq 0xf67f(%rip), %rsi      # 0x231b8
movq %rbx, %rdi
callq 0x19cf2
movq %rbx, 0xf670(%rip)      # 0x231b8
decl 0xf89a(%rip)            # 0x233e8
popq %rbx
retq
leaq 0xfdd9(%rip), %rax      # 0x23930
cmpl $0x0, (%rax)
je 0x13b4e
leaq 0xf7cd(%rip), %rbx      # 0x23330
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x9502(%rip), %rdi      # 0x1d073
movq %rdi, 0x10(%rax)
callq 0x1b084
testl %eax, %eax
je 0x13b4e
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0x8e, 0xc(%rax)
leaq 0x94e8(%rip), %rdi      # 0x1d07b
xorl %eax, %eax
popq %rbx
jmp 0x1b983
nop
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/emit.c
// Function: xcons_to_str
char*
xcons_to_str(CONS* cons)		/* warning: returns pointer to static buffer, do not nest calls! */
{
	XDBUG_ENTER("xcons_to_str");
	if (cons == NULL) {
		XDBUG_RETURN "<NULL>";
	}
	if (cons_sbuf == NULL) {
		cons_sbuf = new_sbuf(1024);		/* allocate 1K string buffer */
	}
	clear_sbuf(cons_sbuf);
	emit_cons(cons, 0, sbuf_emit, cons_sbuf);
	XDBUG_RETURN cons_sbuf->buf;
}

// Assembly:
testq %rdi, %rdi
je 0x14709
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0xf12b(%rip)      # 0x237f0
jne 0x146d8
movl $0x400, %edi            # imm = 0x400
callq 0x1af78
movq %rax, 0xf118(%rip)      # 0x237f0
movq 0xf111(%rip), %rdi      # 0x237f0
callq 0x1afd6
movq 0xf105(%rip), %rcx      # 0x237f0
leaq 0x6916(%rip), %rdx      # 0x1b008
movq %rbx, %rdi
xorl %esi, %esi
callq 0x14711
movq 0xf0ed(%rip), %rax      # 0x237f0
movq 0x10(%rax), %rax
popq %rbx
retq
leaq 0x8bf4(%rip), %rax      # 0x1d304
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/emit.c
// Function: child_to_str
static void
child_to_str(int depth, char* buf, CONS* cons)
{
	char tmp[CONS_BUFSZ];
	int n;
	
	XDBUG_ENTER("child_to_str");
	n = strlen(buf);
	XDBUG_PRINT("", ("n = %d", n));
	if (n < (CONS_BUFSZ - 4)) {
		depth_to_str(depth, tmp, cons);
		strncpy(buf + n, tmp, (CONS_BUFSZ - n));
/*		buf[CONS_BUFSZ - 1] = '\0'; */
		strcpy((buf + CONS_BUFSZ - 4), ":::");
	}
	XDBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
movq %rsi, %rdi
callq 0x20d0
movq %rax, %r15
cmpl $0x3fb, %r15d           # imm = 0x3FB
jg 0x16de1
movq %rsp, %r12
movl %ebp, %edi
movq %r12, %rsi
movq %r14, %rdx
callq 0x13bb9
movslq %r15d, %rax
leaq (%rbx,%rax), %rdi
movl $0x400, %edx            # imm = 0x400
subl %eax, %edx
movq %r12, %rsi
callq 0x2070
movl $0x3a3a3a, 0x3fc(%rbx)  # imm = 0x3A3A3A
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/emit.c
// Function: tail_to_str
static void
tail_to_str(int depth, int length, char* buf, CONS* cons)
{
	int n;

	XDBUG_ENTER("tail_to_str");
#if 0
	child_to_str((depth - 1), buf, car(cons));
	n = strlen(buf);
	if (n < (CONS_BUFSZ - 3)) {
		buf[n++] = ',';
		buf[n++] = ' ';
		buf[n] = '\0';
	}
	child_to_str((depth - 1), buf, cdr(cons));
#else
	if (length < 0) {			/* length limit */
		n = strlen(buf);
		if (n < (CONS_BUFSZ - 4)) {
			buf[n++] = '.';
			buf[n++] = '.';
			buf[n++] = '.';
			buf[n] = '\0';
		}
	} else {
		child_to_str((depth - 1), buf, car(cons));
		n = strlen(buf);
		if (n < (CONS_BUFSZ - 3)) {
			buf[n++] = ',';
			buf[n++] = ' ';
			buf[n] = '\0';
		}
		cons = cdr(cons);	/* advance to tail */
		if (nilp(cons) || actorp(cons) || !consp(cons)) {
			child_to_str((depth - 1), buf, cons);
		} else {
			tail_to_str(depth, (length - 1), buf, cons);
		}
	}
#endif
	XDBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %r15d
movl %edi, %ebp
movabsq $0x100000000, %r13      # imm = 0x100000000
decl %ebp
leaq 0xc486(%rip), %r12      # 0x232a0
testl %r15d, %r15d
js 0x16ebe
movq %r14, %rdi
callq 0x19ba6
movl %ebp, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x16d86
movq %rbx, %rdi
callq 0x20d0
cmpl $0x3fc, %eax            # imm = 0x3FC
jg 0x16e75
movq %rax, %rcx
shlq $0x20, %rcx
cltq
movb $0x2c, (%rbx,%rax)
leaq (%rcx,%r13), %rax
sarq $0x20, %rax
movb $0x20, (%rbx,%rax)
movabsq $0x200000000, %rax      # imm = 0x200000000
addq %rax, %rcx
sarq $0x20, %rcx
movb $0x0, (%rbx,%rcx)
movq %r14, %rdi
callq 0x19c45
movq %rax, %r14
cmpq %r12, %rax
je 0x16ea3
movl %r14d, %eax
andl $0x3, %eax
cmpq $0x1, %rax
je 0x16ea3
testq %r14, %r14
je 0x16ea3
testq %rax, %rax
jne 0x16ea3
decl %r15d
jmp 0x16e1a
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x16d86
movq %rbx, %rdi
callq 0x20d0
cmpl $0x3fb, %eax            # imm = 0x3FB
jg 0x16f0f
movq %rax, %rcx
shlq $0x20, %rcx
cltq
movb $0x2e, %dl
movb %dl, (%rbx,%rax)
addq %rcx, %r13
sarq $0x20, %r13
movb %dl, (%rbx,%r13)
movabsq $0x200000000, %rax      # imm = 0x200000000
addq %rcx, %rax
sarq $0x20, %rax
movb %dl, (%rbx,%rax)
movabsq $0x300000000, %rax      # imm = 0x300000000
addq %rcx, %rax
sarq $0x20, %rax
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/atom.c
// Function: lu_extend_atom
CONS*
lu_extend_atom(CONS* atom, int c)
/* return <atom> + <c> as a new atom, or atom of <c> if <atom> is NIL */
{
	CONS* root;
	CONS* node;
	CONS* ch = NUMBER(c);

	XDBUG_ENTER("lu_extend_atom");
	XDBUG_PRINT("", ("atom@%p = %s", atom, atom_str(atom)));
	XDBUG_PRINT("", ("c = %c(%d)", (isprint(c)?c:' '), c));
	if (lu_atom_root == NULL) {
		root = lu_cons(NIL, NIL);
		XDBUG_PRINT("", ("lu_atom_root = %p[%p;%p]", root, car(root), cdr(root)));
		lu_atom_root = MK_ATOM(root);
	}
	if ((atom == NULL) || nilp(atom)) {
		atom = lu_atom_root;
	}
	assert(atomp(atom));
	root = MK_CONS(atom);
	XDBUG_PRINT("", ("root = %p[%p;%p]", root, car(root), cdr(root)));
	node = cdr(root);
	for (;;) {
		XDBUG_PRINT("", ("node = %p[%p;%p]", node, car(node), cdr(node)));
		if (nilp(node)) {
			/* suffix not found, extend suffix list with new character */
			XDBUG_PRINT("", ("extending suffix list"));
			node = lu_cons(ch, car(root));
			node = lu_cons(node, NIL);
			rplacd(root, lu_cons(node, cdr(root)));
			break;
		}
		if (car(car(car(node))) == ch) {
			/* suffix found, return "atom" node */
			XDBUG_PRINT("", ("matched suffix list"));
			node = car(node);
			break;
		}
		node = cdr(node);
	}
	atom = MK_ATOM(node);
	assert(atomp(atom));
	XDBUG_RETURN atom;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
cmpq $0x0, 0xc8d5(%rip)      # 0x23818
jne 0x16f69
leaq 0xc354(%rip), %rdi      # 0x232a0
movq %rdi, %rsi
callq 0x18064
incl 0xc8b6(%rip)            # 0x23810
andq $-0x4, %rax
orq $0x2, %rax
movq %rax, 0xc8af(%rip)      # 0x23818
cmpq 0xc050(%rip), %r14      # 0x22fc0
movq 0xc8a1(%rip), %rax      # 0x23818
movq %r14, %rbx
cmoveq %rax, %rbx
testq %r14, %r14
cmoveq %rax, %rbx
movl %ebx, %eax
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x1705d
movslq %ebp, %rax
leaq 0x3(,%rax,4), %r14
andq $-0x4, %rbx
movq %rbx, %rdi
callq 0x19c45
cmpq 0xc00f(%rip), %rax      # 0x22fc0
je 0x16fea
movq %rax, %r15
leaq 0xc2e3(%rip), %r12      # 0x232a0
movq %r15, %rdi
callq 0x19ba6
movq %rax, %rdi
callq 0x19ba6
movq %rax, %rdi
callq 0x19ba6
movq %r15, %rdi
cmpq %r14, %rax
je 0x17041
callq 0x19c45
movq %rax, %r15
cmpq %r12, %rax
jne 0x16fbd
movq %rbx, %rdi
callq 0x19ba6
movq %r14, %rdi
movq %rax, %rsi
callq 0x18064
incl 0xc80d(%rip)            # 0x23810
leaq 0xc296(%rip), %rsi      # 0x232a0
movq %rax, %rdi
callq 0x18064
movq %rax, %r14
incl 0xc7f5(%rip)            # 0x23810
movq %rbx, %rdi
callq 0x19c45
movq %r14, %rdi
movq %rax, %rsi
callq 0x18064
incl 0xc7dc(%rip)            # 0x23810
movq %rbx, %rdi
movq %rax, %rsi
callq 0x19cf2
jmp 0x17049
callq 0x19ba6
movq %rax, %r14
andq $-0x4, %r14
orq $0x2, %r14
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x68f8(%rip), %rdi      # 0x1d95c
leaq 0x68fd(%rip), %rsi      # 0x1d968
leaq 0x68fd(%rip), %rcx      # 0x1d96f
movl $0x2e, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/atom.c
// Function: lu_atom
CONS*
lu_atom(char* s)
/* lookup (or create) atom for 
 */
{
	CONS* atom;
	int c;
	
	XDBUG_ENTER("lu_atom");
	XDBUG_PRINT("", ("s@%p=%s", s, s));
	if ((s == NULL) || (*s == '\0')) {
		XDBUG_PRINT("", ("returning NIL"));
		XDBUG_RETURN NIL;
	}
	atom = NIL;
	while ((c = *s++) != '\0') {
		atom = lu_extend_atom(atom, c);
	}
	assert(atomp(atom));
	XDBUG_PRINT("", ("@%p = %s", atom, atom_str(atom)));
	XDBUG_RETURN atom;
}

// Assembly:
pushq %rbx
leaq 0xc21c(%rip), %rax      # 0x232a0
testq %rdi, %rdi
je 0x170c8
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x170c8
movb (%rbx), %cl
testb %cl, %cl
je 0x170b7
incq %rbx
leaq 0xc1ff(%rip), %rax      # 0x232a0
movsbl %cl, %esi
movq %rax, %rdi
callq 0x16f2e
movb (%rbx), %cl
incq %rbx
testb %cl, %cl
jne 0x170a1
jmp 0x170be
leaq 0xc1e2(%rip), %rax      # 0x232a0
movl %eax, %ecx
andl $0x3, %ecx
cmpl $0x2, %ecx
jne 0x170ca
popq %rbx
retq
leaq 0x688b(%rip), %rdi      # 0x1d95c
leaq 0x6890(%rip), %rsi      # 0x1d968
leaq 0x68b2(%rip), %rcx      # 0x1d991
movl $0x5a, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/atom.c
// Function: atom_str
char*
atom_str(CONS* atom)	/* warning: returns pointer to static buffer, do not nest calls! */
/* return a string representation of an atom */
{
	static char s[256];
	CONS* p;
	int n;
	
	if ((atom == NULL) || !atomp(atom)) {
		return "";
	}
	p = MK_CONS(atom);
	p = car(p);
	n = length(p);
	while (n >= sizeof(s)) {	/* atom too long... truncate it, silently */
		p = cdr(p);
		--n;
	}
	s[n] = '\0';
	while (--n >= 0) {
		s[n] = MK_INT(car(p));
		p = cdr(p);
	}
	assert(nilp(p));
	return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x5253(%rip), %r14      # 0x1c34a
testq %rdi, %rdi
je 0x1719d
movl %edi, %eax
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x1719d
andq $-0x4, %rdi
callq 0x19ba6
movq %rax, %rbx
movq %rax, %rdi
callq 0x19edf
movl %eax, %ebp
cmpl $0x100, %eax            # imm = 0x100
jb 0x1714c
movl %ebp, %r14d
movq %rbx, %rdi
callq 0x19c45
movq %rax, %rbx
decl %r14d
cmpl $0xff, %r14d
ja 0x1712e
movl $0xff, %eax
jmp 0x1714e
movl %ebp, %eax
movl %eax, %ecx
leaq 0xc6c9(%rip), %r14      # 0x23820
movb $0x0, (%rcx,%r14)
testl %eax, %eax
je 0x17194
movl $0xff, %r15d
cmpl %r15d, %ebp
cmovbl %ebp, %r15d
incq %r15
movq %rbx, %rdi
callq 0x19ba6
shrl $0x2, %eax
movb %al, -0x2(%r15,%r14)
movq %rbx, %rdi
callq 0x19c45
movq %rax, %rbx
decq %r15
cmpq $0x1, %r15
jg 0x17170
cmpq 0xbe25(%rip), %rbx      # 0x22fc0
jne 0x171ab
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5d7f(%rip), %rdi      # 0x1cf31
leaq 0x67af(%rip), %rsi      # 0x1d968
leaq 0x67e7(%rip), %rcx      # 0x1d9a7
movl $0x76, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/gc.c
// Function: gc_insert_before
void
gc_insert_before(CELL* p, CELL* item)
/* insert <item> before <p> in list */
{
	GC_SET_NEXT(item, p);
	GC_SET_PREV(item, GC_PREV(p));
	GC_SET_NEXT(GC_PREV(p), item);
	GC_SET_PREV(p, item);
}

// Assembly:
movq %rdi, %rax
sarq $0x2, %rax
movq %rax, 0x18(%rsi)
movq 0x10(%rdi), %rax
shlq $0x2, %rax
sarq $0x2, %rax
movq 0x10(%rsi), %rcx
andl $0xc0000000, %ecx       # imm = 0xC0000000
orq %rax, %rcx
movq %rcx, 0x10(%rsi)
sarq $0x2, %rsi
movq 0x10(%rdi), %rax
movq %rsi, 0x18(,%rax,4)
andl $0xc0000000, %eax       # imm = 0xC0000000
orq %rsi, %rax
movq %rax, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/gc.c
// Function: gc_insert_after
void
gc_insert_after(CELL* p, CELL* item)
/* insert <item> after <p> in list */
{
	GC_SET_PREV(item, p);
	GC_SET_NEXT(item, GC_NEXT(p));
	GC_SET_PREV(GC_NEXT(p), item);
	GC_SET_NEXT(p, item);
}

// Assembly:
movq %rdi, %rax
sarq $0x2, %rax
movq 0x10(%rsi), %rcx
andl $0xc0000000, %ecx       # imm = 0xC0000000
orq %rax, %rcx
movq %rcx, 0x10(%rsi)
movq 0x18(%rdi), %rax
shlq $0x2, %rax
sarq $0x2, %rax
movq %rax, 0x18(%rsi)
sarq $0x2, %rsi
movq 0x18(%rdi), %rax
movq 0x10(,%rax,4), %rcx
andl $0xc0000000, %ecx       # imm = 0xC0000000
orq %rsi, %rcx
movq %rcx, 0x10(,%rax,4)
movq %rsi, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/gc.c
// Function: gc_extract
CELL*
gc_extract(CELL* item)
/* extract <item> from list */
{
	GC_SET_NEXT(GC_PREV(item), GC_NEXT(item));
	GC_SET_PREV(GC_NEXT(item), GC_PREV(item));
	GC_SET_NEXT(item, item);	/* for safety */
	GC_SET_PREV(item, item);	/* for safety */
	return item;
}

// Assembly:
movq %rdi, %rax
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
shlq $0x2, %rdx
sarq $0x2, %rdx
movq %rdx, 0x18(,%rcx,4)
shlq $0x2, %rcx
sarq $0x2, %rcx
movq 0x18(%rdi), %rdx
movq 0x10(,%rdx,4), %rsi
andl $0xc0000000, %esi       # imm = 0xC0000000
orq %rcx, %rsi
movq %rsi, 0x10(,%rdx,4)
movq %rdi, %rcx
sarq $0x2, %rcx
movq %rcx, 0x18(%rdi)
movq 0x10(%rdi), %rdx
andl $0xc0000000, %edx       # imm = 0xC0000000
orq %rcx, %rdx
movq %rdx, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/gc.c
// Function: gc_pop
CELL*
gc_pop(CELL* list)
/* extract <item> from the beginning of <list> */
{
	CELL* p = GC_NEXT(list);
	
	if (p == list) {
		return NULL;		/* error - list empty */
	}
	GC_SET_SIZE(list, GC_SIZE(list) - 1);
	return gc_extract(p);
}

// Assembly:
movq 0x18(%rdi), %rax
shlq $0x2, %rax
cmpq %rdi, %rax
je 0x1785b
decq (%rdi)
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rdx
shlq $0x2, %rdx
sarq $0x2, %rdx
movq %rdx, 0x18(,%rcx,4)
shlq $0x2, %rcx
sarq $0x2, %rcx
movq 0x18(%rax), %rdx
movq 0x10(,%rdx,4), %rsi
andl $0xc0000000, %esi       # imm = 0xC0000000
orq %rcx, %rsi
movq %rsi, 0x10(,%rdx,4)
movq %rax, %rcx
sarq $0x2, %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rax), %rdx
andl $0xc0000000, %edx       # imm = 0xC0000000
orq %rcx, %rdx
movq %rdx, 0x10(%rax)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/gc.c
// Function: gc_append_list
void
gc_append_list(CELL* to, CELL* from)
/* append <from> at the end of <to> */
{
	if (GC_NEXT(from) == from) {
		return;			/* no-op - from empty */
	}
	GC_SET_SIZE(to, GC_SIZE(to) + GC_SIZE(from));
	GC_SET_SIZE(from, 0);
	GC_SET_NEXT(GC_PREV(from), to);
	GC_SET_PREV(GC_NEXT(from), GC_PREV(to));
	GC_SET_NEXT(GC_PREV(to), GC_NEXT(from));
	GC_SET_PREV(to, GC_PREV(from));
	GC_SET_NEXT(from, from);
	GC_SET_PREV(from, from);
}

// Assembly:
movq 0x18(%rsi), %rax
shlq $0x2, %rax
cmpq %rsi, %rax
je 0x179ba
movq (%rsi), %rax
addq %rax, (%rdi)
movq $0x0, (%rsi)
movq %rdi, %rax
sarq $0x2, %rax
movq 0x10(%rsi), %rcx
movq %rax, 0x18(,%rcx,4)
movq 0x10(%rdi), %rax
shlq $0x2, %rax
sarq $0x2, %rax
movq 0x18(%rsi), %rcx
leaq (,%rcx,4), %rdx
movq 0x10(,%rcx,4), %r8
andl $0xc0000000, %r8d       # imm = 0xC0000000
orq %rax, %r8
movq %r8, 0x10(,%rcx,4)
sarq $0x2, %rdx
movq 0x10(%rdi), %rax
movq %rdx, 0x18(,%rax,4)
movq 0x10(%rsi), %rcx
shlq $0x2, %rcx
sarq $0x2, %rcx
andl $0xc0000000, %eax       # imm = 0xC0000000
orq %rcx, %rax
movq %rax, 0x10(%rdi)
movq %rsi, %rax
sarq $0x2, %rax
movq %rax, 0x18(%rsi)
movq 0x10(%rsi), %rcx
andl $0xc0000000, %ecx       # imm = 0xC0000000
orq %rax, %rcx
movq %rcx, 0x10(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/gc.c
// Function: gc_full_collection
void
gc_full_collection(CONS* root)
/* perform a full garbage collection (NOT CONCURRENT!) */
{
	DBUG_ENTER("gc_full_collection");
	gc_age_cells();
	assert(consp(root));
	if (!nilp(root)) {
		gc_scan_cell(as_cell(root));	/* scan "root" */
	}
	while (gc_refresh_cell() == TRUE)
		;
	gc_free_cells();
	DBUG_RETURN;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x5f7d(%rip), %rax      # 0x1dbda
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0xb6c4(%rip), %rax      # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x119, 0xc(%rdi)       # imm = 0x119
leaq 0x46c3(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0xb5ee(%rip), %rcx      # 0x23280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
callq 0x194e2
testq %rbx, %rbx
je 0x17ce8
movl %ebx, %eax
andl $0x3, %eax
jne 0x17ce8
cmpq 0xb309(%rip), %rbx      # 0x22fc0
je 0x17cc1
movq %rbx, %rdi
callq 0x17d07
callq 0x1969d
cmpq $0x1, %rax
je 0x17cc1
callq 0x198f6
leaq 0x8(%rsp), %rdi
movl $0x122, 0xc(%rdi)       # imm = 0x122
callq 0x1ba97
addq $0x30, %rsp
popq %rbx
retq
leaq 0x5efe(%rip), %rdi      # 0x1dbed
leaq 0x5e32(%rip), %rsi      # 0x1db28
leaq 0x5efc(%rip), %rcx      # 0x1dbf9
movl $0x11b, %edx            # imm = 0x11B
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/gc.c
// Function: gc_scan_cell
static void
gc_scan_cell(CELL* p)
/* move a live cell (from the "aged" list) to the "scan" list */
{
	WORD mark;

	DBUG_ENTER("gc_scan_cell");
	DBUG_PRINT("gc", ("p = %p", p));
	mark = GC_MARK(p);
	if (mark == gc_phase__mark) {
		DBUG_PRINT("gc", ("cell already marked"));
		DBUG_RETURN;		/* cell already marked in this phase */
	}
	assert(mark == gc_phase__prev);
	GC_SET_SIZE(GC_AGED_LIST, GC_SIZE(GC_AGED_LIST) - 1);
	p = gc_extract(p);	
	GC_SET_MARK(p, gc_phase__mark);
	gc_put(GC_SCAN_LIST, p);
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x6315(%rip), %rax      # 0x1e02f
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0xb607(%rip), %r14      # 0x23330
movq (%r14), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xd0, 0xc(%rdi)
leaq 0x4606(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0xb531(%rip), %rcx      # 0x23280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
leaq 0xbbcd(%rip), %r15      # 0x23930
cmpl $0x0, (%r15)
je 0x17da3
movq (%r14), %rax
movq 0x50(%rax), %rax
leaq 0x4f7d(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1b084
testl %eax, %eax
je 0x17da3
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0xd1, 0xc(%rax)
leaq 0x62a3(%rip), %rdi      # 0x1e03c
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1b983
movq 0x10(%rbx), %rcx
movl %ecx, %edx
andl $0xc0000000, %edx       # imm = 0xC0000000
movq 0xb4e2(%rip), %rax      # 0x23298
cmpq %rax, %rdx
jne 0x17e0a
movl $0xd5, %ebx
cmpl $0x0, (%r15)
je 0x17ec5
movq (%r14), %rax
movq 0x50(%rax), %rax
leaq 0x4f1c(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1b084
testl %eax, %eax
je 0x17ec5
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0xd4, 0xc(%rax)
leaq 0x6245(%rip), %rdi      # 0x1e043
xorl %eax, %eax
callq 0x1b983
jmp 0x17ec5
cmpq 0xb47f(%rip), %rdx      # 0x23290
jne 0x17edc
decq 0xb3c2(%rip)            # 0x231e0
movq 0x18(%rbx), %rdx
shlq $0x2, %rdx
sarq $0x2, %rdx
movq %rdx, 0x18(,%rcx,4)
shlq $0x2, %rcx
sarq $0x2, %rcx
movq 0x18(%rbx), %rdx
movq 0x10(,%rdx,4), %rsi
andl $0xc0000000, %esi       # imm = 0xC0000000
orq %rcx, %rsi
movq %rsi, 0x10(,%rdx,4)
movq %rbx, %rcx
sarq $0x2, %rcx
movq %rcx, 0x18(%rbx)
movl %ecx, %edx
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
orq %rax, %rdx
movq %rdx, 0x10(%rbx)
incq 0xb388(%rip)            # 0x23200
leaq 0xb381(%rip), %rdx      # 0x23200
sarq $0x2, %rdx
movq %rdx, 0x18(%rbx)
movq 0xb382(%rip), %rdx      # 0x23210
shlq $0x2, %rdx
sarq $0x2, %rdx
andl $0xc0000000, %eax       # imm = 0xC0000000
orq %rdx, %rax
movq %rax, 0x10(%rbx)
movq 0xb367(%rip), %rax      # 0x23210
movq %rcx, 0x18(,%rax,4)
andl $0xc0000000, %eax       # imm = 0xC0000000
orq %rcx, %rax
movq %rax, 0xb350(%rip)      # 0x23210
movl $0xdc, %ebx
leaq 0x8(%rsp), %rdi
movl %ebx, 0xc(%rdi)
callq 0x1ba97
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x6174(%rip), %rdi      # 0x1e057
leaq 0x5c3e(%rip), %rsi      # 0x1db28
leaq 0x617d(%rip), %rcx      # 0x1e06e
movl $0xd7, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/gc.c
// Function: gc_scanning_actor
BEH_DECL(gc_scanning_actor)
{
	DBUG_ENTER("gc_scanning_actor");
	if (gc_refresh_cell() == TRUE) {
		SEND(SELF, NIL);			/* more aged cells to scan */
	} else {
		gc_free_cells();			/* scanning complete */
	}
	DBUG_RETURN;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x5d0f(%rip), %rax      # 0x1dc19
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0xb417(%rip), %rax      # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x133, 0xc(%rdi)       # imm = 0x133
leaq 0x4416(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0xb341(%rip), %rcx      # 0x23280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
callq 0x1969d
cmpq $0x1, %rax
je 0x17f5e
callq 0x198f6
jmp 0x17f79
movq 0x30(%rbx), %rdi
callq 0x19ba6
leaq 0xb332(%rip), %rdx      # 0x232a0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x12917
leaq 0x8(%rsp), %rdi
movl $0x139, 0xc(%rdi)       # imm = 0x139
callq 0x1ba97
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/gc.c
// Function: gc_actor_collection
void
gc_actor_collection(CONFIG* cfg, CONS* root)
/* initiate actor-based (CONCURRENT) garbage collection */
{
	CONS* actor;

	DBUG_ENTER("gc_actor_collection");
	gc_age_cells();			/* cells allocated after this are "fresh" */
	assert(consp(root));
	if (!nilp(root)) {
		gc_scan_cell(as_cell(root));	/* scan "root" */
	}
	actor = CFG_ACTOR(cfg, gc_scanning_actor, NIL);
	CFG_SEND(cfg, actor, NIL);
	DBUG_RETURN;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x5c87(%rip), %rax      # 0x1dc2b
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0xb37f(%rip), %rax      # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x142, 0xc(%rdi)       # imm = 0x142
leaq 0x437e(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0xb2a9(%rip), %rcx      # 0x23280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
callq 0x194e2
testq %r14, %r14
je 0x18045
movl %r14d, %eax
andl $0x3, %eax
jne 0x18045
cmpq 0xafc3(%rip), %r14      # 0x22fc0
je 0x18007
movq %r14, %rdi
callq 0x17d07
leaq -0x113(%rip), %rsi      # 0x17efb
leaq 0xb28b(%rip), %r14      # 0x232a0
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1283a
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x12917
movq %rsp, %rdi
movl $0x14a, 0xc(%rdi)       # imm = 0x14A
callq 0x1ba97
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x5ba1(%rip), %rdi      # 0x1dbed
leaq 0x5ad5(%rip), %rsi      # 0x1db28
leaq 0x5be5(%rip), %rcx      # 0x1dc3f
movl $0x144, %edx            # imm = 0x144
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/gc.c
// Function: gc_perm
CONS*
gc_perm(CONS* first, CONS* rest)
/* allocate and initialize a permanent cell (never garbage collected) */
{
	CELL* p;
	CONS* s;

	if (GC_SIZE(GC_PERM_LIST) == 0) {
		gc_allocate_cells(GC_PERM_LIST);
	}
	p = gc_pop(GC_PERM_LIST);
	assert(p != NULL);
	GC_SET_MARK(p, GC_PHASE_X);
	GC_SET_FIRST(p, first);
	GC_SET_REST(p, rest);
	s = as_cons(p);
	assert(consp(s));
	return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0xb1ea(%rip)      # 0x23260
jne 0x18084
leaq 0xb1e1(%rip), %rdi      # 0x23260
callq 0x180fb
leaq 0xb1d5(%rip), %rdi      # 0x23260
callq 0x177f1
testq %rax, %rax
je 0x180bd
movq 0x10(%rax), %rcx
andl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
orq $0x40000000, %rcx       # imm = 0x40000000
movq %rcx, 0x10(%rax)
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
testb $0x3, %al
jne 0x180dc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x6257(%rip), %rdi      # 0x1e31b
leaq 0x5a5d(%rip), %rsi      # 0x1db28
leaq 0x5b98(%rip), %rcx      # 0x1dc6a
movl $0x175, %edx            # imm = 0x175
callq 0x2100
leaq 0x5ba5(%rip), %rdi      # 0x1dc88
leaq 0x5a3e(%rip), %rsi      # 0x1db28
leaq 0x5b79(%rip), %rcx      # 0x1dc6a
movl $0x17a, %edx            # imm = 0x17A
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/gc.c
// Function: gc_allocate_cells
static void
gc_allocate_cells(CELL* list_head)
/* allocate a new block of free cells */
{
	size_t n;
	CELL* p;
	char* tag;

	DBUG_ENTER("gc_alloc_cells");
	gc_initialize();
	tag = ((list_head == GC_FREE_LIST) ? "free" : "permanent");
#if 1
	n = ((1 << 12) / sizeof(CELL));		/* 4Kb allocation */
#else
	n = ((1 << 8) / sizeof(CELL));		/* 256b allocation */
#endif
	p = NEWxN(CELL, n + 1);
	p = as_cell((as_word(p) + (sizeof(CELL) >> 1)) & ~(sizeof(CELL) - 1));
	DBUG_PRINT("gc", ("%u %s cells allocated starting at %p", n, tag, p));
	while (n > 0) {
		--n;
		GC_SET_MARK(p, GC_PHASE_Z);
		gc_put(list_head, p);
		++p;
	}
	DBUG_PRINT("gc", ("%u cells available in %s list", GC_SIZE(list_head), tag));
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x5ffb(%rip), %rax      # 0x1e10d
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0xb20f(%rip), %r12      # 0x23330
movq (%r12), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x155, 0xc(%rdi)       # imm = 0x155
leaq 0x420d(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0xb138(%rip), %rcx      # 0x23280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
callq 0x19a2d
leaq 0xb0df(%rip), %rax      # 0x23240
cmpq %rax, %rbx
leaq 0x4f0b(%rip), %rax      # 0x1d076
leaq 0x5faa(%rip), %r14      # 0x1e11c
cmoveq %rax, %r14
movl $0x20, %edi
movl $0x81, %esi
callq 0x2160
movq %rax, %r15
addq $0x10, %r15
andq $-0x20, %r15
leaq 0xb799(%rip), %r13      # 0x23930
cmpl $0x0, (%r13)
je 0x181e2
movq (%r12), %rax
movq 0x50(%rax), %rax
leaq 0x4b47(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1b084
testl %eax, %eax
je 0x181e2
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x15f, 0xc(%rax)       # imm = 0x15F
leaq 0x5f56(%rip), %rdi      # 0x1e126
movl $0x80, %esi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1b983
movq %rbx, %rcx
sarq $0x2, %rcx
movq (%rbx), %rax
xorl %edx, %edx
leaq (%r15,%rdx), %rsi
andq $0x3fffffff, 0x10(%r15,%rdx) # imm = 0x3FFFFFFF
movq %rcx, 0x18(%r15,%rdx)
movq 0x10(%rbx), %rdi
shlq $0x2, %rdi
sarq $0x2, %rdi
movq %rdi, 0x10(%r15,%rdx)
sarq $0x2, %rsi
movq 0x10(%rbx), %rdi
movq %rsi, 0x18(,%rdi,4)
andl $0xc0000000, %edi       # imm = 0xC0000000
orq %rsi, %rdi
movq %rdi, 0x10(%rbx)
addq $0x20, %rdx
cmpq $0x1000, %rdx           # imm = 0x1000
jne 0x181ee
subq $-0x80, %rax
movq %rax, (%rbx)
cmpl $0x0, (%r13)
je 0x18288
movq (%r12), %rax
movq 0x50(%rax), %rax
leaq 0x4a9c(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1b084
testl %eax, %eax
je 0x18288
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x166, 0xc(%rax)       # imm = 0x166
movq (%rbx), %rsi
leaq 0x5ecd(%rip), %rdi      # 0x1e14b
movq %r14, %rdx
xorl %eax, %eax
callq 0x1b983
leaq 0x8(%rsp), %rdi
movl $0x167, 0xc(%rdi)       # imm = 0x167
callq 0x1ba97
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/gc.c
// Function: gc_cons
CONS*
gc_cons(CONS* first, CONS* rest)
/* allocate and initialize a new "cons" cell */
{
	CELL* p;
	CONS* s;

	if (GC_SIZE(GC_FREE_LIST) == 0) {
		gc_allocate_cells(GC_FREE_LIST);
	}
	p = gc_pop(GC_FREE_LIST);
	assert(p != NULL);
	GC_SET_MARK(p, gc_phase__mark);
	GC_SET_FIRST(p, first);
	GC_SET_REST(p, rest);
	gc_put(GC_FRESH_LIST, p);
	/* FIXME: start gc scan if too few free cells remain */
	s = as_cons(p);
	assert(consp(s));
	return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0xaf87(%rip)      # 0x23240
jne 0x182c7
leaq 0xaf7e(%rip), %rdi      # 0x23240
callq 0x180fb
leaq 0xaf72(%rip), %rdi      # 0x23240
callq 0x177f1
testq %rax, %rax
je 0x1835f
movq 0x10(%rax), %rcx
andl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
movq 0xafab(%rip), %rdx      # 0x23298
orq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
leaq 0xaf1e(%rip), %rcx      # 0x23220
incq 0xaf17(%rip)            # 0x23220
sarq $0x2, %rcx
movq %rcx, 0x18(%rax)
movq 0xaf18(%rip), %rcx      # 0x23230
shlq $0x2, %rcx
sarq $0x2, %rcx
andl $0xc0000000, %edx       # imm = 0xC0000000
orq %rcx, %rdx
movq %rdx, 0x10(%rax)
movq %rax, %rcx
sarq $0x2, %rcx
movq 0xaef5(%rip), %rdx      # 0x23230
movq %rcx, 0x18(,%rdx,4)
andl $0xc0000000, %edx       # imm = 0xC0000000
orq %rcx, %rdx
movq %rdx, 0xaedd(%rip)      # 0x23230
testb $0x3, %al
jne 0x1837e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5fb5(%rip), %rdi      # 0x1e31b
leaq 0x57bb(%rip), %rsi      # 0x1db28
leaq 0x591d(%rip), %rcx      # 0x1dc91
movl $0x189, %edx            # imm = 0x189
callq 0x2100
leaq 0x5903(%rip), %rdi      # 0x1dc88
leaq 0x579c(%rip), %rsi      # 0x1db28
leaq 0x58fe(%rip), %rcx      # 0x1dc91
movl $0x190, %edx            # imm = 0x190
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/gc.c
// Function: gc_check_access
static CELL*
gc_check_access(CONS* cell)
/* ensure that accessed cells are considered "live" */
{
	CELL* p;

	assert(consp(cell));
	p = as_cell(cell);
	if (GC_MARK(p) == gc_phase__prev) {
		gc_scan_cell(p);	/* any "aged" cell accessed must be "live", so scan it */
	}
	return p;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x183e6
movq %rdi, %rbx
movl %ebx, %eax
andl $0x3, %eax
jne 0x183e6
movq 0x10(%rbx), %rax
andl $0xc0000000, %eax       # imm = 0xC0000000
cmpq 0xaeb9(%rip), %rax      # 0x23290
jne 0x183e1
movq %rbx, %rdi
callq 0x17d07
movq %rbx, %rax
popq %rbx
retq
leaq 0x5d7c(%rip), %rdi      # 0x1e169
leaq 0x5734(%rip), %rsi      # 0x1db28
leaq 0x5d7a(%rip), %rcx      # 0x1e175
movl $0x19a, %edx            # imm = 0x19A
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/gc.c
// Function: gc_age_cells
static void
gc_age_cells()
/* move "fresh" cells to the "aged" list for possible collection */
{
	DBUG_ENTER("gc_age_cells");
	DBUG_PRINT("gc", ("%u cells available in free list", GC_SIZE(GC_FREE_LIST)));
	DBUG_PRINT("gc", ("moving %u cells from fresh to aged", GC_SIZE(GC_FRESH_LIST)));
	gc_append_list(GC_AGED_LIST, GC_FRESH_LIST);
	DBUG_PRINT("gc", ("%u cells on aged list to be scanned", GC_SIZE(GC_AGED_LIST)));
	if (gc_phase__mark == GC_PHASE_0) {
		gc_phase__prev = GC_PHASE_0;
		gc_phase__mark = GC_PHASE_1;
	} else {
		gc_phase__prev = GC_PHASE_1;
		gc_phase__mark = GC_PHASE_0;
	}
	DBUG_PRINT("gc", ("gc_phase = 0x%x", gc_phase__mark));
	DBUG_RETURN;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x4acb(%rip), %rax      # 0x1dfbb
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x9e33(%rip), %rbx      # 0x23330
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xba, 0xc(%rdi)
leaq 0x2e32(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x9d5d(%rip), %rcx      # 0x23280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
leaq 0xa3f9(%rip), %r14      # 0x23930
cmpl $0x0, (%r14)
je 0x1957b
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x37a9(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1b084
testl %eax, %eax
je 0x1957b
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0xbb, 0xc(%rax)
movq 0x9cd3(%rip), %rsi      # 0x23240
leaq 0x4a54(%rip), %rdi      # 0x1dfc8
xorl %eax, %eax
callq 0x1b983
cmpl $0x0, (%r14)
je 0x195bf
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x3765(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1b084
testl %eax, %eax
je 0x195bf
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0xbc, 0xc(%rax)
movq 0x9c6f(%rip), %rsi      # 0x23220
leaq 0x4a30(%rip), %rdi      # 0x1dfe8
xorl %eax, %eax
callq 0x1b983
leaq 0x9c1a(%rip), %rdi      # 0x231e0
leaq 0x9c53(%rip), %rsi      # 0x23220
callq 0x17913
cmpl $0x0, (%r14)
je 0x19616
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x370e(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1b084
testl %eax, %eax
je 0x19616
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0xbe, 0xc(%rax)
movq 0x9bd8(%rip), %rsi      # 0x231e0
leaq 0x49fc(%rip), %rdi      # 0x1e00b
xorl %eax, %eax
callq 0x1b983
movq 0x9c7b(%rip), %rax      # 0x23298
movl $0x80000000, %ecx       # imm = 0x80000000
leaq 0x40000000(%rcx), %rdx
cmpq %rcx, %rax
cmovneq %rdx, %rax
cmoveq %rdx, %rcx
movq %rax, 0x9c55(%rip)      # 0x23290
movq %rcx, 0x9c56(%rip)      # 0x23298
cmpl $0x0, (%r14)
je 0x19686
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x369e(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1b084
testl %eax, %eax
je 0x19686
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0xc6, 0xc(%rax)
movq 0x9c20(%rip), %rsi      # 0x23298
leaq 0x4699(%rip), %rdi      # 0x1dd18
xorl %eax, %eax
callq 0x1b983
movq %rsp, %rdi
movl $0xc7, 0xc(%rdi)
callq 0x1ba97
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/gc.c
// Function: gc_refresh_cell
static BOOL
gc_refresh_cell()
/* process a cell from the "scan" list, return FALSE if none remain */
{
	CELL* p;

	DBUG_ENTER("gc_refresh_cell");
	if (GC_SIZE(GC_SCAN_LIST) == 0) {
		DBUG_PRINT("gc", ("empty scan list"));
		DBUG_RETURN FALSE;
	}
	p = gc_pop(GC_SCAN_LIST);
	assert(p != NULL);
	gc_scan_value(GC_FIRST(p));
	gc_scan_value(GC_REST(p));
	gc_push(GC_FRESH_LIST, p);
	DBUG_RETURN TRUE;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
leaq 0x49de(%rip), %rax      # 0x1e088
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x9c79(%rip), %rbx      # 0x23330
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xf7, 0xc(%rdi)
leaq 0x2c78(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x9ba3(%rip), %rcx      # 0x23280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
cmpq $0x0, 0x9b0e(%rip)      # 0x23200
je 0x1978e
leaq 0x9b01(%rip), %rdi      # 0x23200
callq 0x177f1
testq %rax, %rax
je 0x197f1
movq %rax, %rbx
movq (%rax), %rdi
callq 0x19810
movq 0x8(%rbx), %rdi
callq 0x19810
incq 0x9af8(%rip)            # 0x23220
leaq 0x9af1(%rip), %rax      # 0x23220
sarq $0x2, %rax
movq 0x10(%rbx), %rcx
andl $0xc0000000, %ecx       # imm = 0xC0000000
orq %rax, %rcx
movq %rcx, 0x10(%rbx)
movq 0x9aed(%rip), %rax      # 0x23238
shlq $0x2, %rax
sarq $0x2, %rax
movq %rax, 0x18(%rbx)
sarq $0x2, %rbx
movq 0x9ad6(%rip), %rax      # 0x23238
movq 0x10(,%rax,4), %rcx
andl $0xc0000000, %ecx       # imm = 0xC0000000
orq %rbx, %rcx
movq %rcx, 0x10(,%rax,4)
movq %rbx, 0x9ab6(%rip)      # 0x23238
movl $0x1, %ebx
movl $0x101, %ebp            # imm = 0x101
jmp 0x197dc
leaq 0xa19b(%rip), %rax      # 0x23930
movl $0xfa, %ebp
cmpl $0x0, (%rax)
je 0x197da
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x3547(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1b084
testl %eax, %eax
je 0x197da
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0xf9, 0xc(%rax)
leaq 0x48c9(%rip), %rdi      # 0x1e098
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1b983
jmp 0x197dc
xorl %ebx, %ebx
movq %rsp, %rdi
movl %ebp, 0xc(%rdi)
callq 0x1ba97
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
leaq 0x4b23(%rip), %rdi      # 0x1e31b
leaq 0x4329(%rip), %rsi      # 0x1db28
leaq 0x48a2(%rip), %rcx      # 0x1e0a8
movl $0xfd, %edx
callq 0x2100