LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: pp_setvec
cell pp_setvec(cell x) {
	cell	fill = cadddr(x);
	int	i, k = vector_len(car(x));
	int	p0 = integer_value("setvec", cadr(x));
	int	pn = integer_value("setvec", caddr(x));
	cell	*v = vector(car(x));
	cell	n;

	if (p0 < 0 || p0 > k || pn < p0 || pn > k) {
		n = node(caddr(x), NIL);
		n = node(cadr(x), n);
		return error("setvec: bad range", n);
	}
	for (i=p0; i<pn; i++)
		v[i] = fill;
	return car(x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc978(%rip), %rax      # 0x1e170
movq 0xcdc1(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rdi,8), %rdx
movq (%rcx,%rdx,8), %rsi
movq (%rcx,%rsi,8), %rsi
movq (%rax,%rsi,8), %r12
movq 0xcdd2(%rip), %rsi      # 0x1e5e8
movq (%rax,%rdi,8), %rdi
movq (%rcx,%rdi,8), %rcx
movq -0x8(%rsi,%rcx,8), %r13
movq (%rax,%rdx,8), %rsi
leaq 0x5693(%rip), %r15      # 0x16ec1
movq %r15, %rdi
callq 0x4341
movq %rax, %r14
movq 0xc930(%rip), %rax      # 0x1e170
movq 0xcd79(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rsi
movq %r15, %rdi
callq 0x4341
movq 0xcd5e(%rip), %rdx      # 0x1e5c0
movq 0xc907(%rip), %rcx      # 0x1e170
testl %r14d, %r14d
js 0x118c1
addq $0x7, %r13
shrq $0x3, %r13
cmpl %r13d, %r14d
jg 0x118c1
cmpl %r14d, %eax
jl 0x118c1
cmpl %r13d, %eax
jg 0x118c1
cmpl %eax, %r14d
jge 0x118bb
movq (%rcx,%rbx,8), %rsi
movq (%rdx,%rsi,8), %rdx
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
leaq (,%r14,8), %rsi
leaq (%rsi,%rdx,8), %rdx
addq 0xcd3c(%rip), %rdx      # 0x1e5e8
movq %r12, (%rdx)
addq $0x8, %rdx
incl %r14d
cmpl %eax, %r14d
jl 0x118ac
movq (%rcx,%rbx,8), %rax
jmp 0x11911
movq (%rdx,%rbx,8), %rax
movq (%rdx,%rax,8), %rax
movq (%rcx,%rax,8), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0xc88e(%rip), %rcx      # 0x1e170
movq 0xccd7(%rip), %rdx      # 0x1e5c0
movq (%rdx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
leaq 0x55c6(%rip), %rdi      # 0x16ec8
movq %rax, %rsi
callq 0x33eb
movq $-0x5, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: close_stream
void close_stream(int stream) {
	if (stream < 0 || stream >= MAX_STREAMS)
		return;
	if (Streams[stream] == NULL) {
		Stream_flags[stream] = 0;
		return;
	}
	fclose(Streams[stream]); /* already closed? don't care */
	Streams[stream] = NULL;
	Stream_flags[stream] = 0;
}

// Assembly:
cmpl $0x1f, %edi
ja 0x1195a
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0xc84b(%rip), %r14      # 0x1e180
movq (%r14,%rbx,8), %rdi
testq %rdi, %rdi
je 0x1194b
callq 0x3090
movq $0x0, (%r14,%rbx,8)
leaq 0xccae(%rip), %rax      # 0x1e600
movb $0x0, (%rbx,%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: make_stream
cell make_stream(int sid, cell type) {
	cell	n;
	int	pf;

	pf = Stream_flags[sid];
	Stream_flags[sid] |= LOCK_TAG;
	n = new_atom(sid, NIL);
	n = node3(type, n, ATOM_TAG|STREAM_TAG);
	Stream_flags[sid] = pf;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movslq %edi, %r14
leaq 0xcc2b(%rip), %r15      # 0x1e600
movb (%r14,%r15), %r12b
movl %r12d, %eax
orb $-0x80, %al
movb %al, (%r14,%r15)
movq %r14, %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rbx, %rdi
movq %rax, %rsi
movl $0x21, %edx
callq 0x36e8
movb %r12b, (%r14,%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: pp_print
cell pp_print(cell x) {
	Displaying = 1;
	print_form(car(x));
	Displaying = 0;
	return UNIT;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, 0xcc9f(%rip)      # 0x1e6c0
movq 0xc748(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %rdi
xorl %esi, %esi
callq 0x91f0
movl $0x0, 0xcc83(%rip)      # 0x1e6c0
movq $-0x6, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: new_stream
int new_stream(void) {
	int	i, tries;

	for (tries=0; tries<2; tries++) {
		for (i=0; i<MAX_STREAMS; i++) {
			if (Streams[i] == NULL) {
				return i;
			}
		}
		if (tries == 0)
			gc();
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
xorl %r14d, %r14d
leaq 0xc6cf(%rip), %rbx      # 0x1e180
movq %rbx, %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
je 0x11ae4
incq %rax
addq $0x8, %rcx
cmpq $0x20, %rax
jne 0x11ab6
testl %r14d, %r14d
jne 0x11ad3
callq 0x3ef8
leal 0x1(%r14), %eax
testl %r14d, %r14d
movl %eax, %r14d
je 0x11ab1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: open_stream
int open_stream(char *path, char *mode) {
	int	i = new_stream();

	if (i < 0)
		return -1;
	Streams[i] = fopen(path, mode);
	if (Streams[i] == NULL)
		return -1;
	else
		return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x11aa0
testl %eax, %eax
js 0x11b2b
movl %eax, %ebx
movq %r15, %rdi
movq %r14, %rsi
callq 0x31c0
movq %rax, %rcx
movl %ebx, %eax
leaq 0xc665(%rip), %rdx      # 0x1e180
movq %rcx, (%rdx,%rax,8)
xorl %eax, %eax
cmpq $0x1, %rcx
sbbl %eax, %eax
orl %ebx, %eax
jmp 0x11b30
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: eval
cell eval(cell x) {
	reset_calltrace();
	save(x);
	x = expand_syntax(x);
	unsave(1);
	x = xeval(x, 0);
	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xc541(%rip), %rdi      # 0x1e290
movl $0x320, %edx            # imm = 0x320
movl $0xff, %esi
callq 0x30d0
movq 0xc3c3(%rip), %rsi      # 0x1e128
movq %rbx, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0xc3b2(%rip)      # 0x1e128
movq %rbx, %rdi
callq 0x13c76
movq %rax, %rbx
movl $0x1, %edi
callq 0x3851
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x13030
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: pp_load
cell pp_load(cell x) {
	char	file[TOKEN_LENGTH+1];

	if (string_len(car(x)) > TOKEN_LENGTH-3)
		return error("load: path too long", car(x));
	strcpy(file, string(car(x)));
	if (load(file) < 0) {
		strcat(file, ".m");
		if (load(file) < 0)
			return error("load: cannot open file", car(x));
	}
	return UNIT;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq 0xc836(%rip), %rax      # 0x1e5e8
movq 0xc807(%rip), %rcx      # 0x1e5c0
movq 0xc3b0(%rip), %rdx      # 0x1e170
movq (%rdx,%rdi,8), %rsi
movq (%rcx,%rsi,8), %rcx
cmpq $0x3fe, -0x8(%rax,%rcx,8) # imm = 0x3FE
jl 0x11de8
leaq 0x5100(%rip), %rdi      # 0x16eda
callq 0x33eb
movq $-0x5, %r14
jmp 0x11e3e
movq %rdi, %rbx
leaq (%rax,%rcx,8), %rsi
leaq -0x420(%rbp), %r14
movq %r14, %rdi
callq 0x3060
movq %r14, %rdi
callq 0x11b3b
movq $-0x6, %r14
testl %eax, %eax
jns 0x11e3e
leaq -0x420(%rbp), %r15
movq %r15, %rdi
callq 0x30a0
movw $0x6d2e, -0x420(%rbp,%rax) # imm = 0x6D2E
movb $0x0, -0x41e(%rbp,%rax)
movq %r15, %rdi
callq 0x11b3b
testl %eax, %eax
js 0x11e4f
movq %r14, %rax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xc31a(%rip), %rax      # 0x1e170
movq (%rax,%rbx,8), %rsi
leaq 0x508d(%rip), %rdi      # 0x16eee
jmp 0x11dda
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: pp_instream
cell pp_instream(cell x) {
	int	p;

	p = open_stream(string(car(x)), "r");
	if (p < 0)
		return error("instream: could not open file", car(x));
	return make_stream(p, T_INSTREAM);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc74a(%rip), %rax      # 0x1e5c0
movq 0xc2f3(%rip), %rcx      # 0x1e170
movq (%rcx,%rdi,8), %rcx
movq (%rax,%rcx,8), %rdi
shlq $0x3, %rdi
addq 0xc758(%rip), %rdi      # 0x1e5e8
leaq 0x51ad(%rip), %rsi      # 0x17044
callq 0x11ae9
testl %eax, %eax
js 0x11eb4
movl %eax, %edi
movq $-0x17, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x119bd
movq 0xc2b5(%rip), %rax      # 0x1e170
movq (%rax,%rbx,8), %rsi
leaq 0x503f(%rip), %rdi      # 0x16f05
callq 0x33eb
movq $-0x5, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: pp_outstream
cell pp_outstream(cell x) {
	int	p;

	p = open_stream(string(car(x)), "w");
	if (p < 0)
		return error("outstream: could not open file", car(x));
	return make_stream(p, T_OUTSTREAM);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc6d7(%rip), %rax      # 0x1e5c0
movq 0xc280(%rip), %rcx      # 0x1e170
movq (%rcx,%rdi,8), %rcx
movq (%rax,%rcx,8), %rdi
shlq $0x3, %rdi
addq 0xc6e5(%rip), %rdi      # 0x1e5e8
leaq 0x523d(%rip), %rsi      # 0x17147
callq 0x11ae9
testl %eax, %eax
js 0x11f27
movl %eax, %edi
movq $-0x19, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x119bd
movq 0xc242(%rip), %rax      # 0x1e170
movq (%rax,%rbx,8), %rsi
leaq 0x4fea(%rip), %rdi      # 0x16f23
callq 0x33eb
movq $-0x5, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: pp_appendstream
cell pp_appendstream(cell x) {
	int	p;

	p = open_stream(string(car(x)), "a");
	if (p < 0)
		return error("append_stream: could not open file", car(x));
	return make_stream(p, T_OUTSTREAM);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc664(%rip), %rax      # 0x1e5c0
movq 0xc20d(%rip), %rcx      # 0x1e170
movq (%rcx,%rdi,8), %rcx
movq (%rax,%rcx,8), %rdi
shlq $0x3, %rdi
addq 0xc672(%rip), %rdi      # 0x1e5e8
leaq 0x58d4(%rip), %rsi      # 0x17851
callq 0x11ae9
testl %eax, %eax
js 0x11f9a
movl %eax, %edi
movq $-0x19, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x119bd
movq 0xc1cf(%rip), %rax      # 0x1e170
movq (%rax,%rbx,8), %rsi
leaq 0x4f96(%rip), %rdi      # 0x16f42
callq 0x33eb
movq $-0x5, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: pp_peekc
cell pp_peekc(cell x) {
	int	c;

	c = read_c();
	if (c == EOF)
		return END_OF_FILE;
	ungetc(c, Streams[Instream]);
	return make_char(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movslq 0xc6cb(%rip), %rax      # 0x1e698
leaq 0xc1ac(%rip), %r14      # 0x1e180
movq (%r14,%rax,8), %rdi
callq 0x3220
cmpl $-0x1, %eax
je 0x12022
movl %eax, %ebx
movslq 0xc6ad(%rip), %rax      # 0x1e698
movq (%r14,%rax,8), %rsi
movl %ebx, %edi
callq 0x3170
movzbl %bl, %edi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x16, %rdi
movq %rax, %rsi
movl $0x1, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x36e8
movq $-0x4, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: pp_readc
cell pp_readc(cell x) {
	int	c;

	c = read_c();
	if (c == EOF)
		return END_OF_FILE;
	return make_char(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0xc65f(%rip), %rax      # 0x1e698
leaq 0xc140(%rip), %rcx      # 0x1e180
movq (%rcx,%rax,8), %rdi
callq 0x3220
cmpl $-0x1, %eax
je 0x12077
movzbl %al, %edi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x16, %rdi
movq %rax, %rsi
movl $0x1, %edx
popq %rbp
jmp 0x36e8
movq $-0x4, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: pp_readln
cell pp_readln(cell x) {
	static char	buf[TOKEN_LENGTH+1];
	int		k;

	if (fgets(buf, TOKEN_LENGTH, Streams[Instream]) == NULL)
		return END_OF_FILE;
	k = strlen(buf);
	if (buf[k-1] == '\n')
		buf[--k] = 0;
	return make_string(buf, k);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movslq 0xc60a(%rip), %rax      # 0x1e698
leaq 0xc0eb(%rip), %rcx      # 0x1e180
movq (%rcx,%rax,8), %rdx
leaq 0xc710(%rip), %r14      # 0x1e7b0
movq %r14, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x3100
testq %rax, %rax
je 0x1210e
movq %r14, %rdi
callq 0x30a0
movq %rax, %rbx
decl %eax
cltq
cmpb $0xa, (%rax,%r14)
jne 0x120d4
movslq %ebx, %rbx
movb $0x0, -0x1(%rbx,%r14)
decq %rbx
incl %ebx
movq $-0x21, %rdi
movl %ebx, %esi
callq 0x417e
movq %rax, %r14
movq 0xc4d2(%rip), %rax      # 0x1e5c0
movq (%rax,%r14,8), %rdi
shlq $0x3, %rdi
addq 0xc4eb(%rip), %rdi      # 0x1e5e8
movslq %ebx, %rdx
leaq 0xc6a9(%rip), %rsi      # 0x1e7b0
callq 0x3050
jmp 0x12115
movq $-0x4, %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: copy_string
char *copy_string(char *s) {
	char	*new;

	new = malloc(strlen(s)+1);
	if (s == NULL)
		fatal("copy_string(): out of memory");
	strcpy(new, s);
	return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x30a0
leaq 0x1(%rax), %rdi
callq 0x3150
testq %rbx, %rbx
je 0x1214a
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3060
leaq 0x4e14(%rip), %rdi      # 0x16f65
callq 0x3ab5
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: pp_dump_image
cell pp_dump_image(cell x) {
	char	*path = copy_string(string(car(x)));
	FILE	*f;

	f = fopen(string(car(x)), "r");
	if (f != NULL) {
		fclose(f);
		return error("dump_image: file exists", car(x));
	}
	dump_image(path);
	free(path);
	return UNIT;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xc459(%rip), %rax      # 0x1e5c0
movq 0xc002(%rip), %rcx      # 0x1e170
movq (%rcx,%rdi,8), %rcx
movq (%rax,%rcx,8), %rdi
shlq $0x3, %rdi
addq 0xc467(%rip), %rdi      # 0x1e5e8
callq 0x1211d
movq %rax, %r14
movq 0xc430(%rip), %rax      # 0x1e5c0
movq 0xbfd9(%rip), %rcx      # 0x1e170
movq (%rcx,%rbx,8), %rcx
movq (%rax,%rcx,8), %rdi
shlq $0x3, %rdi
addq 0xc43e(%rip), %rdi      # 0x1e5e8
leaq 0x4e93(%rip), %rsi      # 0x17044
callq 0x31c0
testq %rax, %rax
je 0x121e3
movq %rax, %rdi
callq 0x3090
movq 0xbfa6(%rip), %rax      # 0x1e170
movq (%rax,%rbx,8), %rsi
leaq 0x4dad(%rip), %rdi      # 0x16f82
callq 0x33eb
movq $-0x5, %rax
jmp 0x121fa
movq %r14, %rdi
callq 0x121ff
movq %r14, %rdi
callq 0x3040
movq $-0x6, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: pp_gensym
cell pp_gensym(cell x) {
	char	pre[101];
	int	k;

	if (x == NIL) {
		strcpy(pre, "g");
		k = 1;
	}
	else if (string_p(car(x))) {
		memcpy(pre, string(car(x)), 100);
		k = string_len(car(x));
	}
	else if (symbol_p(car(x))) {
		memcpy(pre, symbol_name(car(x)), 100);
		k = symbol_len(car(x));
	}
	else
		return error("gensym: expected str/id, got",
				car(x));
	if (k > 100)
		return error("gensym: prefix too long", car(x));
	pre[100] = 0;
	return gensym(pre);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
cmpq $-0x1, %rdi
je 0x1254e
movq 0xbc97(%rip), %r14      # 0x1e170
movq (%r14,%rbx,8), %rsi
testq %rsi, %rsi
js 0x12545
movq 0xc0f7(%rip), %rax      # 0x1e5e0
testb $0x10, (%rax,%rsi)
je 0x124f6
cmpq $-0x21, (%r14,%rsi,8)
je 0x1250f
testq %rsi, %rsi
js 0x12545
movq 0xc0de(%rip), %rax      # 0x1e5e0
testb $0x10, (%rax,%rsi)
je 0x12545
cmpq $-0x22, (%r14,%rsi,8)
jne 0x12545
movq 0xc0d2(%rip), %r15      # 0x1e5e8
movq 0xc0a3(%rip), %r12      # 0x1e5c0
movq (%r12,%rsi,8), %rax
leaq (%r15,%rax,8), %rsi
leaq -0x90(%rbp), %rdi
movl $0x64, %edx
callq 0x3130
movq (%r14,%rbx,8), %rax
movq (%r12,%rax,8), %rax
movl -0x8(%r15,%rax,8), %eax
jmp 0x1255c
leaq 0x4a54(%rip), %rdi      # 0x16fa0
jmp 0x12573
movw $0x67, -0x90(%rbp)
movl $0x1, %eax
cmpl $0x65, %eax
jl 0x12581
movq 0xbc08(%rip), %rax      # 0x1e170
movq (%rax,%rbx,8), %rsi
leaq 0x4a4a(%rip), %rdi      # 0x16fbd
callq 0x33eb
movq $-0x5, %rax
jmp 0x12591
leaq -0x90(%rbp), %rdi
movb $0x0, 0x64(%rdi)
callq 0xc2d2
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: pp_stats
cell pp_stats(cell x) {
	cell	n, m;
	int	o_run_stats;

	gcv(); /* start from a known state */
	reset_counter(&Reductions);
	reset_counter(&Conses);
	reset_counter(&Nodes);
	reset_counter(&Collections);
	o_run_stats = Run_stats;
	Run_stats = 1;
	Cons_stats = 0;
	n = eval(car(x));
	save(n);
	Run_stats = o_run_stats;
	n = counter_to_list(&Collections);
	n = node(n, NIL);
	save(n);
	car(Stack) = n;
	m = counter_to_list(&Nodes);
	n = node(m, n);
	car(Stack) = n;
	m = counter_to_list(&Conses);
	n = node(m, n);
	car(Stack) = n;
	m = counter_to_list(&Reductions);
	n = node(m, n);
	n = node(unsave(2), n);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
callq 0x408a
xorps %xmm0, %xmm0
movups %xmm0, 0xc602(%rip)     # 0x1ebc0
xorl %eax, %eax
movl %eax, 0xc60a(%rip)      # 0x1ebd0
movups %xmm0, 0xc08b(%rip)     # 0x1e658
movl %eax, 0xc095(%rip)      # 0x1e668
leaq 0xc07e(%rip), %r14      # 0x1e658
movups %xmm0, 0xc05f(%rip)     # 0x1e640
movl %eax, 0xc069(%rip)      # 0x1e650
leaq 0xc052(%rip), %r15      # 0x1e640
movups %xmm0, 0xc02f(%rip)     # 0x1e624
movl %eax, 0xc039(%rip)      # 0x1e634
leaq 0xc022(%rip), %r13      # 0x1e624
movl 0xc018(%rip), %ebx      # 0x1e620
movl $0x1, 0xc00e(%rip)      # 0x1e620
movl %eax, 0xc03c(%rip)      # 0x1e654
movq 0xbb51(%rip), %rax      # 0x1e170
movq (%rax,%r12,8), %rdi
callq 0x11d3f
movq 0xbaf9(%rip), %rsi      # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0xbae8(%rip)      # 0x1e128
movl %ebx, 0xbfda(%rip)      # 0x1e620
movq %r13, %rdi
callq 0x3534
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %r12
movq 0xbabf(%rip), %rsi      # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0xbaae(%rip)      # 0x1e128
movq 0xbaef(%rip), %rcx      # 0x1e170
movq %r12, (%rcx,%rax,8)
movq %r15, %rdi
callq 0x3534
movq %rax, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %r15
movq 0xbacc(%rip), %rax      # 0x1e170
movq 0xba7d(%rip), %rcx      # 0x1e128
movq %r15, (%rax,%rcx,8)
movq %r14, %rdi
callq 0x3534
movq %rax, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %r14
movq 0xbaa2(%rip), %rax      # 0x1e170
movq 0xba53(%rip), %rcx      # 0x1e128
movq %r14, (%rax,%rcx,8)
leaq 0xc4e0(%rip), %rdi      # 0x1ebc0
callq 0x3534
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movl $0x2, %edi
callq 0x3851
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x36e8
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: pp_argv
cell pp_argv(cell x) {
	cell	n;
	char	**cl;

	if (Command_line == NULL || *Command_line == NULL)
		return FALSE;
	n = integer_value("argv", car(x));
	cl = Command_line;
	for (; n--; cl++)
		if (*cl == NULL)
			return FALSE;
	return *cl == NULL? FALSE: make_string(*cl, strlen(*cl));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0xc4ad(%rip), %rax      # 0x1ebd8
movq $-0x3, %rbx
testq %rax, %rax
je 0x127c9
cmpq $0x0, (%rax)
je 0x127c9
movq 0xba24(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %rsi
leaq 0x487e(%rip), %rdi      # 0x16fd5
callq 0x4341
movq 0xc475(%rip), %rcx      # 0x1ebd8
testq %rax, %rax
je 0x12780
leaq (%rcx,%rax,8), %rdx
xorl %esi, %esi
cmpq $0x0, (%rcx,%rsi,8)
je 0x127c9
incq %rsi
cmpq %rsi, %rax
jne 0x1276e
movq %rdx, %rcx
movq (%rcx), %r14
testq %r14, %r14
je 0x127c9
movq %r14, %rdi
callq 0x30a0
movq %rax, %r15
incl %r15d
movq $-0x21, %rdi
movl %r15d, %esi
callq 0x417e
movq %rax, %rbx
movq 0xbe11(%rip), %rax      # 0x1e5c0
movq (%rax,%rbx,8), %rdi
shlq $0x3, %rdi
addq 0xbe2a(%rip), %rdi      # 0x1e5e8
movslq %r15d, %rdx
movq %r14, %rsi
callq 0x3050
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: pp_environ
cell pp_environ(cell x) {
	char	*s;

	s = getenv(string(car(x)));
	if (s == NULL)
		return FALSE;
	return make_string(s, strlen(s));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0xbdd8(%rip), %rax      # 0x1e5c0
movq 0xb981(%rip), %rcx      # 0x1e170
movq (%rcx,%rdi,8), %rcx
movq (%rax,%rcx,8), %rdi
shlq $0x3, %rdi
addq 0xbde6(%rip), %rdi      # 0x1e5e8
callq 0x3030
testq %rax, %rax
je 0x12852
movq %rax, %rbx
movq %rax, %rdi
callq 0x30a0
movq %rax, %r15
incl %r15d
movq $-0x21, %rdi
movl %r15d, %esi
callq 0x417e
movq %rax, %r14
movq 0xbd8a(%rip), %rax      # 0x1e5c0
movq (%rax,%r14,8), %rdi
shlq $0x3, %rdi
addq 0xbda3(%rip), %rdi      # 0x1e5e8
movslq %r15d, %rdx
movq %rbx, %rsi
callq 0x3050
jmp 0x12859
movq $-0x3, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: expected
cell expected(cell who, char *what, cell got) {
	char	msg[100];
	PRIM	*p;

	p = &Primitives[cadr(who)];
	sprintf(msg, "%s: expected %s, got", p->name, what);
	return error(msg, got);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdx, %rbx
movq %rsi, %rcx
movq 0xbdf3(%rip), %rax      # 0x1e6c8
movq 0xb894(%rip), %rdx      # 0x1e170
movq 0xbcdd(%rip), %rsi      # 0x1e5c0
movq (%rsi,%rdi,8), %rsi
movq (%rdx,%rsi,8), %rdx
leaq (%rdx,%rdx,4), %rdx
movq (%rax,%rdx,8), %rdx
leaq 0x44d7(%rip), %rsi      # 0x16dd1
leaq -0x80(%rbp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x31f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x33eb
movq $-0x5, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: uses_transformer_p
int uses_transformer_p(cell x) {
	cell	y;

	if (atom_p(x) || car(x) == S_quote)
		return 0;
	if (tuple_p(x) && symbol_p(car(x))) {
		y = lookup(car(x), Environment, 0);
		if (y != NIL && syntax_p(binding_value(y)))
			return 1;
	}
	while (tuple_p(x)) {
		if (uses_transformer_p(car(x)))
			return 1;
		x = cdr(x);
	}
	return 0;
}

// Assembly:
testq %rdi, %rdi
js 0x12dfb
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb8a7(%rip), %rax      # 0x1e5e0
movzbl (%rax,%rdi), %edx
testb $0x11, %dl
jne 0x12df2
movq 0xb423(%rip), %rcx      # 0x1e170
movq (%rcx,%rbx,8), %rdi
cmpq 0xb950(%rip), %rdi      # 0x1e6a8
je 0x12df2
andl $0x8, %edx
shrl $0x3, %edx
testq %rdi, %rdi
sets %sil
orb %dl, %sil
jne 0x12dc1
testb $0x10, (%rax,%rdi)
je 0x12dc1
cmpq $-0x22, (%rcx,%rdi,8)
jne 0x12dc1
movq 0xb384(%rip), %rsi      # 0x1e108
xorl %edx, %edx
callq 0xdd28
cmpq $-0x1, %rax
je 0x12dc1
movq 0xb828(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rax,8), %rcx
testq %rcx, %rcx
js 0x12dc1
movq 0xb838(%rip), %rax      # 0x1e5e0
testb $0x1, (%rax,%rcx)
je 0x12dc1
movq 0xb3bb(%rip), %rdx      # 0x1e170
movl $0x1, %eax
cmpq $-0x23, (%rdx,%rcx,8)
je 0x12df4
movq 0xb818(%rip), %rax      # 0x1e5e0
testb $0x19, (%rax,%rbx)
jne 0x12df2
movq 0xb39b(%rip), %rax      # 0x1e170
movq (%rax,%rbx,8), %rdi
callq 0x12d20
testl %eax, %eax
jne 0x12dfe
movq 0xb7d7(%rip), %rax      # 0x1e5c0
movq (%rax,%rbx,8), %rbx
testq %rbx, %rbx
jns 0x12dc1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
retq
movl $0x1, %eax
jmp 0x12df4
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: expand_syntax
cell expand_syntax(cell x) {
	if (Error_flag || atom_p(x) || car(x) == S_quote)
		return x;
	save(x);
	while (!Error_flag) {
		if (!uses_transformer_p(x))
			break;
		x = expand_syntax_1(x);
		car(Stack) = x;
	}
	unsave(1);
	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xa92f(%rip), %eax      # 0x1e5b4
testq %rdi, %rdi
js 0x13d05
testl %eax, %eax
jne 0x13d05
movq 0xa94b(%rip), %rax      # 0x1e5e0
testb $0x11, (%rax,%rbx)
jne 0x13d05
movq 0xa4ce(%rip), %rax      # 0x1e170
movq (%rax,%rbx,8), %rax
cmpq 0xa9fb(%rip), %rax      # 0x1e6a8
je 0x13d05
movq 0xa472(%rip), %rsi      # 0x1e128
movq %rbx, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0xa461(%rip)      # 0x1e128
cmpl $0x0, 0xa8e6(%rip)      # 0x1e5b4
jne 0x13cfb
movq %rbx, %rdi
callq 0x12d20
testl %eax, %eax
je 0x13cfb
movq %rbx, %rdi
callq 0x12e05
movq %rax, %rbx
movq 0xa482(%rip), %rax      # 0x1e170
movq 0xa433(%rip), %rcx      # 0x1e128
movq %rbx, (%rax,%rcx,8)
jmp 0x13cc7
movl $0x1, %edi
callq 0x3851
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: restore_state
cell restore_state(void) {
	cell	v;

	if (State_stack == NIL)
		fatal("restore_state: stack underflow");
	v = car(State_stack);
	State_stack = cdr(State_stack);
	return v;
}

// Assembly:
cmpq $-0x1, 0xa421(%rip)     # 0x1e138
je 0x13d3e
movq 0xa450(%rip), %rax      # 0x1e170
movq 0xa411(%rip), %rcx      # 0x1e138
movq (%rax,%rcx,8), %rax
movq 0xa88e(%rip), %rdx      # 0x1e5c0
movq (%rdx,%rcx,8), %rcx
movq %rcx, 0xa3fb(%rip)      # 0x1e138
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x33e1(%rip), %rdi      # 0x1712a
callq 0x3ab5
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: next_case
cell next_case(cell app, cell cas) {
	cell	n, f;

	f = car(app);
	n = node(caddr(f), cas);
	n = node(cadr(f), n);
	n = node3(T_FUNCTION, n, ATOM_TAG);
	return node(n, cdr(app));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xa197(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %r14
movq 0xa5dc(%rip), %rcx      # 0x1e5c0
movq (%rcx,%r14,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rdi
xorl %edx, %edx
callq 0x36e8
movq 0xa172(%rip), %rcx      # 0x1e170
movq 0xa5bb(%rip), %rdx      # 0x1e5c0
movq (%rdx,%r14,8), %rdx
movq (%rcx,%rdx,8), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq $-0x1e, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq 0xa58e(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rbx,8), %rsi
movq %rax, %rdi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x36e8
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: tail_call
int tail_call(void) {
	if (State_stack == NIL || car(State_stack) != EV_BETA)
		return 0;
	Tmp = unsave(1);
	Environment = car(Stack);
	unsave(2);
	restore_state();
	save(Tmp);
	Tmp = NIL;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x9f11(%rip), %rax      # 0x1e138
xorl %ebx, %ebx
cmpq $-0x1, %rax
je 0x142a2
movq 0x9f3a(%rip), %rcx      # 0x1e170
cmpq $0x2, (%rcx,%rax,8)
jne 0x142a2
movl $0x1, %ebx
movl $0x1, %edi
callq 0x3851
movq %rax, 0x9ebd(%rip)      # 0x1e110
movq 0x9f16(%rip), %rax      # 0x1e170
movq 0x9ec7(%rip), %rcx      # 0x1e128
movq (%rax,%rcx,8), %rax
movq %rax, 0x9e9c(%rip)      # 0x1e108
movl $0x2, %edi
callq 0x3851
callq 0x13d0f
movq 0x9e8e(%rip), %rdi      # 0x1e110
movq 0x9e9f(%rip), %rsi      # 0x1e128
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x9e91(%rip)      # 0x1e128
movq $-0x1, 0x9e6e(%rip) # 0x1e110
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: raise_exception
cell raise_exception(cell e) {
	cell	cs, n, p, fn;

	for (p = Exnstack; p != NIL; p = cdr(p)) {
		fn = cdar(p);
		for (cs = cddr(fn); cs != NIL; cs = cdr(cs)) {
			if (caar(cs) == e) {
				Exnstack = cdr(p);
				n = node(e, NIL);
				n = node(fn, n);
				n = node(n, NIL);
				n = node(caar(p), n);
				return n;
			}
		}
	}
	return error("unhandled exception", e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rsi
movq 0x9eac(%rip), %r14      # 0x1e168
cmpq $-0x1, %r14
je 0x142fc
movq 0xa2f7(%rip), %rax      # 0x1e5c0
movq 0x9ea0(%rip), %rcx      # 0x1e170
movq (%rcx,%r14,8), %rdx
movq (%rax,%rdx,8), %rbx
movq (%rax,%rbx,8), %rdx
movq (%rax,%rdx,8), %rdx
cmpq $-0x1, %rdx
je 0x142f2
movq (%rcx,%rdx,8), %rdi
cmpq %rsi, (%rcx,%rdi,8)
jne 0x142dc
jmp 0x14314
movq (%rax,%r14,8), %r14
cmpq $-0x1, %r14
jne 0x142d0
leaq 0x2e4f(%rip), %rdi      # 0x17152
callq 0x33eb
movq $-0x5, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq (%rax,%r14,8), %rax
movq %rax, 0x9e49(%rip)      # 0x1e168
movq %rsi, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x9e1b(%rip), %rcx      # 0x1e170
movq (%rcx,%r14,8), %rdx
movq (%rcx,%rdx,8), %rdi
movq %rax, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x36e8
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: keyboard_interrupt
void keyboard_interrupt(int sig) {
	Instream = 0;
	Outstream = 1;
	error("interrupted", NOEXPR);
	signal(SIGINT, keyboard_interrupt);
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0xa2dd(%rip)      # 0x1e698
movl $0x1, 0x9ebb(%rip)      # 0x1e280
leaq 0x2db7(%rip), %rdi      # 0x17183
movq $-0x8, %rsi
callq 0x33eb
leaq -0x32(%rip), %rsi       # 0x143ad
movl $0x2, %edi
popq %rbp
jmp 0x3120
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: get_library_path
cell get_library_path(void) {
	char	*s;

	s = getenv("MLITE_LIBRARY_PATH");
	if (s == NULL)
		s = DEFAULT_LIBRARY_PATH;
	return make_string(s, (int) strlen(s));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x29c5(%rip), %rdi      # 0x17391
callq 0x3030
testq %rax, %rax
leaq 0x29c9(%rip), %rbx      # 0x173a4
cmovneq %rax, %rbx
movq %rbx, %rdi
callq 0x30a0
movq %rax, %r14
incl %r14d
movq $-0x21, %rdi
movl %r14d, %esi
callq 0x417e
movq %rax, %r15
movq 0x9bba(%rip), %rax      # 0x1e5c0
movq (%rax,%r15,8), %rdi
shlq $0x3, %rdi
addq 0x9bd3(%rip), %rdi      # 0x1e5e8
movslq %r14d, %rdx
movq %rbx, %rsi
callq 0x3050
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: libname
char *libname(char *argv0) {
	char	*name;

	if (argv0 == NULL || argv0[0] == 0)
		argv0 = "mlite";
	name = strrchr(argv0, '/');
	name = name? &name[1]: argv0;
	return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x14a41
movq %rdi, %rbx
cmpb $0x0, (%rdi)
jne 0x14a48
leaq 0x2987(%rip), %rbx      # 0x173cf
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x30c0
leaq 0x1(%rax), %rcx
testq %rax, %rax
cmoveq %rbx, %rcx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: grow_primitives
void grow_primitives(void) {
	Max_prims += PRIM_SEG_SIZE;
	Primitives = (PRIM *) realloc(Primitives, sizeof(PRIM) * Max_prims);
	if (Primitives == NULL)
		fatal("grow_primitives: out of physical memory");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0x9f37(%rip), %rax      # 0x1ec14
leaq 0x100(%rax), %rcx
movl %ecx, 0x9f2a(%rip)      # 0x1ec14
movq 0x99d7(%rip), %rdi      # 0x1e6c8
leaq 0x800(,%rax,8), %rax
leaq (%rax,%rax,4), %rsi
callq 0x3190
movq %rax, 0x99bf(%rip)      # 0x1e6c8
testq %rax, %rax
je 0x14d10
popq %rbp
retq
leaq 0x271c(%rip), %rdi      # 0x17433
callq 0x3ab5
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: add_primitives
void add_primitives(char *name, PRIM *p) {
	cell	v, n, new;
	int	i;

	if (name) {
		n = symbol_ref(name);
		set(box_value(S_extensions), node(n, box_value(S_extensions)));
	}
	for (i=0; p && p && p[i].name; i++) {
		if (Callcc_magic < 0 && !strcmp(p[i].name, "call/cc"))
			Callcc_magic = Last_prim;
		v = symbol_ref(p[i].name);
		n = new_atom(Last_prim, NIL);
		n = new_atom(T_PRIMITIVE, n);
		if (Last_prim >= Max_prims)
			grow_primitives();
		memcpy(&Primitives[Last_prim], &p[i], sizeof(PRIM));
		Last_prim++;
		Environment = extend(v, n, Environment);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
testq %rdi, %rdi
je 0x14d65
callq 0x729e
movq 0x9882(%rip), %rcx      # 0x1e5c0
movq 0x9ebb(%rip), %rdx      # 0x1ec00
movq (%rcx,%rdx,8), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq 0x9866(%rip), %rcx      # 0x1e5c0
movq 0x9e9f(%rip), %rdx      # 0x1ec00
movq %rax, (%rcx,%rdx,8)
testq %r14, %r14
je 0x14e52
movq %r14, %rbx
movq (%rbx), %r15
testq %r15, %r15
je 0x14e52
cmpq $0x0, 0x9e63(%rip)      # 0x1ebe8
jns 0x14da8
movq %r15, %rdi
leaq 0x2260(%rip), %rsi      # 0x16ff1
callq 0x3110
testl %eax, %eax
jne 0x14da8
movslq 0x9e6f(%rip), %rax      # 0x1ec10
movq %rax, 0x9e40(%rip)      # 0x1ebe8
movq %r15, %rdi
callq 0x729e
movq %rax, %r15
movslq 0x9e56(%rip), %rdi      # 0x1ec10
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x1d, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %r12
movl 0x9e28(%rip), %eax      # 0x1ec10
cmpl 0x9e26(%rip), %eax      # 0x1ec14
jl 0x14df5
callq 0x14cd2
movq 0x98cc(%rip), %rax      # 0x1e6c8
movslq 0x9e0d(%rip), %rcx      # 0x1ec10
leaq (%rcx,%rcx,4), %rdx
movq 0x20(%rbx), %rsi
movq %rsi, 0x20(%rax,%rdx,8)
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x10(%rax,%rdx,8)
movups %xmm0, (%rax,%rdx,8)
leal 0x1(%rcx), %eax
movl %eax, 0x9de7(%rip)      # 0x1ec10
movq 0x92d8(%rip), %r13      # 0x1e108
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xdba0
addq $0x28, %rbx
movq %r13, 0x92bf(%rip)      # 0x1e108
testq %r14, %r14
jne 0x14d71
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: make_initial_env
void make_initial_env(void) {
	cell	new;

	Environment = node(NIL, NIL);
	Environment = extend(symbol_ref("it"), NIL, Environment);
	S_it = cadr(Environment);
	Environment = extend(symbol_ref("*extensions*"), NIL, Environment);
	S_extensions = cadr(Environment);
	Environment = extend(symbol_ref("*library-path*"), NIL, Environment);
	S_library_path = cadr(Environment);
	set(box_value(S_library_path), get_library_path());
	Environment = extend(symbol_ref("*loading*"), FALSE, Environment);
	S_loading = cadr(Environment);
	Callcc_magic = -1;
	Last_prim = 0;
	Max_prims = 0;
	grow_primitives();
	add_primitives(NULL, Core_primitives);
	Environment = node(Environment, NIL);
	Program = TRUE; /* or rehash() will not work */
	rehash(car(Environment));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
xorl %r14d, %r14d
movq $-0x1, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x9281(%rip)      # 0x1e108
leaq 0x13d2(%rip), %rdi      # 0x16260
callq 0x729e
movq 0x926e(%rip), %rbx      # 0x1e108
movq %rax, %rdi
movq $-0x1, %rsi
movq %rbx, %rdx
callq 0xdba0
movq %rbx, 0x9255(%rip)      # 0x1e108
movq 0x92b6(%rip), %rax      # 0x1e170
movq 0x96ff(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rbx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x9d20(%rip)      # 0x1ebf0
leaq 0x2584(%rip), %rdi      # 0x1745b
callq 0x729e
movq 0x9225(%rip), %rbx      # 0x1e108
movq %rax, %rdi
movq $-0x1, %rsi
movq %rbx, %rdx
callq 0xdba0
movq %rbx, 0x920c(%rip)      # 0x1e108
movq 0x926d(%rip), %rax      # 0x1e170
movq 0x96b6(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rbx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x9ce7(%rip)      # 0x1ec00
leaq 0x2548(%rip), %rdi      # 0x17468
callq 0x729e
movq 0x91dc(%rip), %rbx      # 0x1e108
movq %rax, %rdi
movq $-0x1, %rsi
movq %rbx, %rdx
callq 0xdba0
movq %rbx, 0x91c3(%rip)      # 0x1e108
movq 0x9224(%rip), %rax      # 0x1e170
movq 0x966d(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rbx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x9ca6(%rip)      # 0x1ec08
callq 0x149bb
movq 0x9652(%rip), %rcx      # 0x1e5c0
movq 0x9c93(%rip), %rdx      # 0x1ec08
movq %rax, (%rcx,%rdx,8)
leaq 0x24f7(%rip), %rdi      # 0x17477
callq 0x729e
movq 0x917c(%rip), %rbx      # 0x1e108
movq %rax, %rdi
movq $-0x3, %rsi
movq %rbx, %rdx
callq 0xdba0
movq %rbx, 0x9163(%rip)      # 0x1e108
movq 0x91c4(%rip), %rax      # 0x1e170
movq 0x960d(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rbx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x9606(%rip)      # 0x1e5c8
movq $-0x1, 0x9c1b(%rip) # 0x1ebe8
movl %r14d, 0x9c3c(%rip)     # 0x1ec10
movl %r14d, 0x9c39(%rip)     # 0x1ec14
callq 0x14cd2
leaq 0x8329(%rip), %rsi      # 0x1d310
xorl %edi, %edi
callq 0x14d1c
movq 0x9113(%rip), %rdi      # 0x1e108
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x90fe(%rip)      # 0x1e108
movq $-0x2, 0x90e3(%rip) # 0x1e0f8
movq 0x9154(%rip), %rcx      # 0x1e170
movq (%rcx,%rax,8), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xda64
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: init_extensions
void init_extensions(void) {
	cell	e, n;
	char	initproc[TOKEN_LENGTH+2];
	char	*s;
	char	*mlite = "mlite";

	e = box_value(S_extensions);
	while (mlite || e != NIL) {
		s = mlite? mlite: string(car(e));
		if (strlen(s)*2+1 >= TOKEN_LENGTH)
			fatal("init_extension(): procedure name too long");
		sprintf(initproc, "%s:%s", s, s);
		n = find_symbol(initproc);
		if (n != NIL) {
			n = node(n, NIL);
			eval(n);
		}
		e = mlite? e: cdr(e);
		mlite = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq 0x90f8(%rip), %rax      # 0x1e5c0
movq 0x9731(%rip), %rcx      # 0x1ec00
movq (%rax,%rcx,8), %r12
movb $0x1, %r13b
leaq 0x1ef2(%rip), %r15      # 0x173cf
leaq 0x2027(%rip), %rbx      # 0x1750b
leaq -0x430(%rbp), %r14
testb $0x1, %r13b
jne 0x15512
movq 0x90c8(%rip), %rax      # 0x1e5c0
movq 0x8c71(%rip), %rcx      # 0x1e170
movq (%rcx,%r12,8), %rcx
movq (%rax,%rcx,8), %r15
shlq $0x3, %r15
addq 0x90d6(%rip), %r15      # 0x1e5e8
movq %r15, %rdi
callq 0x30a0
movabsq $0x7ffffffffffffe00, %rcx # imm = 0x7FFFFFFFFFFFFE00
testq %rcx, %rax
jne 0x15599
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x31f0
movq %r14, %rdi
callq 0x71eb
cmpq $-0x1, %rax
je 0x15563
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rdi
callq 0x11d3f
testb $0x1, %r13b
jne 0x15574
movq 0x9050(%rip), %rax      # 0x1e5c0
movq (%rax,%r12,8), %r12
xorl %r15d, %r15d
movl $0x0, %r13d
cmpq $-0x1, %r12
jne 0x154eb
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f41(%rip), %rdi      # 0x174e1
callq 0x3ab5
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: usage
void usage(int quit) {
	pr("Usage: mlite [-h?] [-i name] [-gqv] [-f prog [args]] ");
	pr("[-m size[m]]");
	nl();
	pr("             [-l prog] [-t count] [-d image] [-- [args]]");
	nl();
	if (quit) bye(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0x1f5c(%rip), %rdi      # 0x17511
callq 0x3965
leaq 0x1f86(%rip), %rdi      # 0x17547
callq 0x3965
leaq 0x2328(%rip), %r14      # 0x178f5
movq %r14, %rdi
callq 0x3965
leaq 0x1f78(%rip), %rdi      # 0x17554
callq 0x3965
movq %r14, %rdi
callq 0x3965
testl %ebx, %ebx
jne 0x155f2
popq %rbx
popq %r14
popq %rbp
retq
movl $0x1, %edi
callq 0x3200
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: long_usage
void long_usage() {
	nl();
	usage(0);
	nl();
	pr("-h              display this summary (also -?)"); nl();
	pr("-i name         base name of image file (must be first option!)");
	nl();
	pr("-i -            ignore image, load mlite.m instead"); nl();
	pr("-d file         dump heap image to file and exit"); nl();
	pr("-f file [args]  run program and exit (implies -q)"); nl();
	pr("-g              print GC summaries (-gg = more)"); nl();
	pr("-l file         load program (may be repeated)"); nl();
	pr("-m n[m]         set memory limit to nK (or nM) nodes"); nl();
	pr("-q              be quiet (no banner, no prompt, exit on errors)");
	nl();
	pr("-t n            list up to N procedures in call traces"); nl();
	pr("-v              print version and exit"); nl();
	pr("-- [args]       pass subsequent arguments to program"); nl();
	nl();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x22ec(%rip), %rbx      # 0x178f5
movq %rbx, %rdi
callq 0x3965
xorl %edi, %edi
callq 0x155a5
movq %rbx, %rdi
callq 0x3965
leaq 0x1f66(%rip), %rdi      # 0x1758d
callq 0x3965
movq %rbx, %rdi
callq 0x3965
leaq 0x1f81(%rip), %rdi      # 0x175bc
callq 0x3965
movq %rbx, %rdi
callq 0x3965
leaq 0x1fad(%rip), %rdi      # 0x175fc
callq 0x3965
movq %rbx, %rdi
callq 0x3965
leaq 0x1fcc(%rip), %rdi      # 0x1762f
callq 0x3965
movq %rbx, %rdi
callq 0x3965
leaq 0x1fe9(%rip), %rdi      # 0x17660
callq 0x3965
movq %rbx, %rdi
callq 0x3965
leaq 0x2007(%rip), %rdi      # 0x17692
callq 0x3965
movq %rbx, %rdi
callq 0x3965
leaq 0x2023(%rip), %rdi      # 0x176c2
callq 0x3965
movq %rbx, %rdi
callq 0x3965
leaq 0x203e(%rip), %rdi      # 0x176f1
callq 0x3965
movq %rbx, %rdi
callq 0x3965
leaq 0x205f(%rip), %rdi      # 0x17726
callq 0x3965
movq %rbx, %rdi
callq 0x3965
leaq 0x208b(%rip), %rdi      # 0x17766
callq 0x3965
movq %rbx, %rdi
callq 0x3965
leaq 0x20ae(%rip), %rdi      # 0x1779d
callq 0x3965
movq %rbx, %rdi
callq 0x3965
leaq 0x20c1(%rip), %rdi      # 0x177c4
callq 0x3965
movq %rbx, %rdi
callq 0x3965
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3965
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: get_size_k
long get_size_k(char *s) {
	int	c;
	long	n;

	c = s[strlen(s)-1];
	n = atol(s);
	if (isdigit(c))
		;
	else if (c == 'M' || c == 'm')
		n *= 1024L;
	else
		usage(1);
	return n * 1024;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x30a0
movsbq -0x1(%rbx,%rax), %r14
movq %rbx, %rdi
callq 0x31b0
movq %rax, %rbx
callq 0x3230
movq (%rax), %rax
testb $0x8, 0x1(%rax,%r14,2)
jne 0x159bc
andb $-0x21, %r14b
cmpb $0x4d, %r14b
jne 0x159b2
shlq $0xa, %rbx
jmp 0x159bc
movl $0x1, %edi
callq 0x155a5
shlq $0xa, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sguerrini97[P]ps3linux-ps3vuart-tools/ps3sm/dev.c
// Function: dev_read
int
dev_read(void *buf, size_t len)
{
	char tmp[4096];
	struct ps3sm_header *hdr;
	int ret;

	if (fd < 0)
		return (-1);

	hdr = (struct ps3sm_header *) tmp;

	while (1) {
		ret = read(fd, hdr, sizeof(*hdr));
		if (ret < 0) {
			if (errno != EAGAIN)
				return (-1);
		} else if (ret > 0) {
			break;
		}
	}

	while (1) {
		ret = read(fd, hdr + 1, hdr->payload_length);
		if (ret < 0) {
			if (errno != EAGAIN)
				return (-1);
		} else if (ret > 0) {
			break;
		}
	}

	if (len > (sizeof(*hdr) + hdr->payload_length))
		len = sizeof(*hdr) + hdr->payload_length;

	memcpy(buf, tmp, len);

	return (len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x0, 0x2d5d(%rip)      # 0x41b0
js 0x14cc
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %r12
movl 0x2d4c(%rip), %edi      # 0x41b0
movl $0x10, %edx
movq %r12, %rsi
callq 0x1090
testl %eax, %eax
js 0x1479
je 0x145e
jmp 0x1485
callq 0x1030
cmpl $0xb, (%rax)
je 0x145e
jmp 0x14cc
leaq 0x10(%rsp), %r12
movl 0x2d20(%rip), %edi      # 0x41b0
movl 0x4(%rsp), %edx
movq %r12, %rsi
callq 0x1090
testl %eax, %eax
js 0x14a4
je 0x148a
jmp 0x14b0
callq 0x1030
cmpl $0xb, (%rax)
je 0x148a
jmp 0x14cc
movq %rsp, %rsi
movl 0x4(%rsi), %ebx
addq $0x10, %rbx
cmpq %r15, %rbx
cmovaeq %r15, %rbx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x10c0
movl %ebx, %eax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/sguerrini97[P]ps3linux-ps3vuart-tools/ps3sm/cmd/cmd_ctl_led.c
// Function: cmd_ctl_led_exec
int
cmd_ctl_led_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3sm_ctl_led ctl_led;
	uint32_t arg1, arg2, arg3, arg4;
	char *endptr;
	int ret;

	arg1 = strtoul(argv[0], &endptr, 0);
	if (*endptr != '\0' || arg1 > 0xff)
		return (CMD_EINVAL);

	arg2 = strtoul(argv[1], &endptr, 0);
	if (*endptr != '\0' || arg2 > 0xff)
		return (CMD_EINVAL);

	arg3 = strtoul(argv[2], &endptr, 0);
	if (*endptr != '\0' || arg3 > 0xff)
		return (CMD_EINVAL);

	arg4 = strtoul(argv[3], &endptr, 0);
	if (*endptr != '\0' || arg4 > 0xff)
		return (CMD_EINVAL);

	ps3sm_init_header(PS3SM_HDR(&ctl_led),
	    sizeof(ctl_led) - sizeof(struct ps3sm_header),
	    PS3SM_SID_CTL_LED, 0);

	ctl_led.version = PS3SM_CTL_LED_VERSION;
	ctl_led.arg1 = arg1;
	ctl_led.arg2 = arg2;
	ctl_led.arg3 = arg3;
	ctl_led.arg4 = arg4;

	ret = dev_write(&ctl_led, sizeof(ctl_led));
	if (ret != sizeof(ctl_led))
		return (CMD_EIO);

	return (CMD_EOK);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq (%rcx), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x10f0
movq %rax, %rbx
movq (%r14), %rax
cmpb $0x0, (%rax)
setne %al
testl $0xffffff00, %ebx       # imm = 0xFFFFFF00
setne %cl
orb %al, %cl
movl $0x2, %ebp
jne 0x15f2
movq 0x8(%r15), %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
xorl %edx, %edx
callq 0x10f0
movq %rax, %r14
movq (%r12), %rax
cmpb $0x0, (%rax)
setne %al
testl $0xffffff00, %r14d      # imm = 0xFFFFFF00
setne %cl
orb %al, %cl
jne 0x15f2
movq 0x10(%r15), %rdi
leaq 0x8(%rsp), %r13
movq %r13, %rsi
xorl %edx, %edx
callq 0x10f0
movq %rax, %r12
movq (%r13), %rax
cmpb $0x0, (%rax)
setne %al
testl $0xffffff00, %r12d      # imm = 0xFFFFFF00
setne %cl
orb %al, %cl
jne 0x15f2
movq 0x18(%r15), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
xorl %edx, %edx
callq 0x10f0
movq (%r15), %rcx
cmpb $0x0, (%rcx)
setne %cl
testl $0xffffff00, %eax       # imm = 0xFFFFFF00
setne %dl
orb %cl, %dl
jne 0x15f2
leaq 0x10(%rsp), %rdi
movw $0x1001, (%rdi)         # imm = 0x1001
movl $0x8, 0x4(%rdi)
movw $0xc, 0x8(%rdi)
movl $0x0, 0xc(%rdi)
movb $0x1, 0x10(%rdi)
movb %bl, 0x11(%rdi)
movb %r14b, 0x12(%rdi)
movb %r12b, 0x14(%rdi)
movb %al, 0x15(%rdi)
movl $0x18, %esi
callq 0x1418
xorl %ecx, %ecx
cmpl $0x18, %eax
setne %cl
leal (%rcx,%rcx,2), %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/sguerrini97[P]ps3linux-ps3vuart-tools/ps3sm/cmd/cmd_get_inter_lpar_param.c
// Function: cmd_get_inter_lpar_param_exec
int
cmd_get_inter_lpar_param_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3sm_get_inter_lpar_param get_inter_lpar_param;
	struct ps3sm_get_inter_lpar_param_reply get_inter_lpar_param_reply;
	uint32_t arg;
	char *endptr;
	int ret;

	arg = strtoul(argv[0], &endptr, 0);
	if (*endptr != '\0' || arg < 1 || arg > 2)
		return (CMD_EINVAL);

	ps3sm_init_header(PS3SM_HDR(&get_inter_lpar_param),
	    sizeof(get_inter_lpar_param) - sizeof(struct ps3sm_header),
	    PS3SM_SID_GET_INTER_LPAR_PARAM, 0);

	get_inter_lpar_param.version = PS3SM_GET_INTER_LPAR_PARAM_VERSION;
	get_inter_lpar_param.arg = arg;

	ret = dev_write(&get_inter_lpar_param, sizeof(get_inter_lpar_param));
	if (ret != sizeof(get_inter_lpar_param))
		return (CMD_EIO);

	ret = dev_read(&get_inter_lpar_param_reply, sizeof(get_inter_lpar_param_reply));
	if (ret < 0)
		return (CMD_EIO);

	if (arg == 1)
		hex_fprintf(stdout, (char *) get_inter_lpar_param_reply.u.arg1.data,
		    sizeof(PS3SM_HDR(&get_inter_lpar_param_reply)->payload_length));
	else
		fprintf(stdout, "%02x %02x %02x %02x %08x %016llx\n",
		    get_inter_lpar_param_reply.u.arg2.val1,
		    get_inter_lpar_param_reply.u.arg2.val2,
		    get_inter_lpar_param_reply.u.arg2.val3,
		    get_inter_lpar_param_reply.u.arg2.val4,
		    get_inter_lpar_param_reply.u.arg2.val5,
		    get_inter_lpar_param_reply.u.arg2.val6);

	return (CMD_EOK);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x630, %rsp            # imm = 0x630
movq (%rcx), %rdi
movq %rsp, %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x10f0
movq %rax, %rbx
movq (%r14), %rax
cmpb $0x0, (%rax)
setne %al
leal -0x3(%rbx), %ecx
cmpl $-0x2, %ecx
setb %cl
orb %al, %cl
movl $0x2, %ebp
jne 0x16e4
leaq 0x8(%rsp), %rdi
movw $0x1001, (%rdi)         # imm = 0x1001
movl $0x8, 0x4(%rdi)
movw $0x9, 0x8(%rdi)
movl $0x0, 0xc(%rdi)
movb $0x1, 0x10(%rdi)
movb %bl, 0x11(%rdi)
movl $0x18, %esi
callq 0x1418
movl $0x3, %ebp
cmpl $0x18, %eax
jne 0x16e4
leaq 0x20(%rsp), %rdi
movl $0x610, %esi            # imm = 0x610
callq 0x1439
testl %eax, %eax
js 0x16e4
movq 0x2934(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
cmpl $0x1, %ebx
jne 0x16af
leaq 0x30(%rsp), %rsi
movl $0x4, %edx
callq 0x1c65
xorl %ebp, %ebp
jmp 0x16e4
movzbl 0x30(%rsp), %edx
movzbl 0x31(%rsp), %ecx
movzbl 0x32(%rsp), %r8d
movzbl 0x33(%rsp), %r9d
movl 0x34(%rsp), %r10d
leaq 0xa6f(%rip), %rsi       # 0x2140
xorl %ebp, %ebp
xorl %eax, %eax
pushq 0x38(%rsp)
pushq %r10
callq 0x10b0
addq $0x10, %rsp
movl %ebp, %eax
addq $0x630, %rsp            # imm = 0x630
popq %rbx
popq %r14
popq %rbp
retq
nop