LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./utf.c
// Function: jsU_islowerrune
int
islowerrune(Rune c)
{
	const Rune *p;

	p = ucd_bsearch(c, ucd_toupper2, nelem(ucd_toupper2)/3, 3);
	if(p && c >= p[0] && c <= p[1])
		return 1;
	p = ucd_bsearch(c, ucd_toupper1, nelem(ucd_toupper1)/2, 2);
	if(p && c == p[0])
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
leaq 0x17f7b(%rip), %rsi     # 0x35c10
movl $0x35, %edx
movl $0x3, %ecx
callq 0x1db40
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1dccf
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x1dccf
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jg 0x1dccf
movl $0x1, -0x4(%rbp)
jmp 0x1dd0e
movl -0x8(%rbp), %edi
leaq 0x181b7(%rip), %rsi     # 0x35e90
movl $0x27d, %edx            # imm = 0x27D
movl $0x2, %ecx
callq 0x1db40
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1dd07
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x1dd07
movl $0x1, -0x4(%rbp)
jmp 0x1dd0e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./utf.c
// Function: jsU_isupperrune
int
isupperrune(Rune c)
{
	const Rune *p;

	p = ucd_bsearch(c, ucd_tolower2, nelem(ucd_tolower2)/3, 3);
	if(p && c >= p[0] && c <= p[1])
		return 1;
	p = ucd_bsearch(c, ucd_tolower1, nelem(ucd_tolower1)/2, 2);
	if(p && c == p[0])
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
leaq 0x168fb(%rip), %rsi     # 0x34630
movl $0x34, %edx
movl $0x3, %ecx
callq 0x1db40
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1dd6f
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x1dd6f
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jg 0x1dd6f
movl $0x1, -0x4(%rbp)
jmp 0x1ddae
movl -0x8(%rbp), %edi
leaq 0x16b27(%rip), %rsi     # 0x348a0
movl $0x26e, %edx            # imm = 0x26E
movl $0x2, %ecx
callq 0x1db40
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1dda7
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x1dda7
movl $0x1, -0x4(%rbp)
jmp 0x1ddae
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./utf.c
// Function: jsU_isalpharune
int
isalpharune(Rune c)
{
	const Rune *p;

	p = ucd_bsearch(c, ucd_alpha2, nelem(ucd_alpha2)/2, 2);
	if(p && c >= p[0] && c <= p[1])
		return 1;
	p = ucd_bsearch(c, ucd_alpha1, nelem(ucd_alpha1), 1);
	if(p && c == p[0])
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
leaq 0x194ab(%rip), %rsi     # 0x37280
movl $0x20b, %edx            # imm = 0x20B
movl $0x2, %ecx
callq 0x1db40
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1de0f
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x1de0f
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jg 0x1de0f
movl $0x1, -0x4(%rbp)
jmp 0x1de4e
movl -0x8(%rbp), %edi
leaq 0x1a4c7(%rip), %rsi     # 0x382e0
movl $0xa7, %edx
movl $0x1, %ecx
callq 0x1db40
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1de47
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x1de47
movl $0x1, -0x4(%rbp)
jmp 0x1de4e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./utf.c
// Function: jsU_tolowerrune_full
const Rune *
tolowerrune_full(Rune c)
{
	const Rune *p;
	p = ucd_bsearch(c, ucd_tolower_full, nelem(ucd_tolower_full)/4, 4);
	if(p && c == p[0])
		return p + 1;
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0x1a70b(%rip), %rsi     # 0x38580
movl $0x1c, %edx
movl $0x4, %ecx
callq 0x1db40
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1dea8
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x1dea8
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
jmp 0x1deb0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./utf.c
// Function: jsU_toupperrune_full
const Rune *
toupperrune_full(Rune c)
{
	const Rune *p;
	p = ucd_bsearch(c, ucd_toupper_full, nelem(ucd_toupper_full)/5, 5);
	if(p && c == p[0])
		return p + 1;
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0x1a86b(%rip), %rsi     # 0x38740
movl $0x66, %edx
movl $0x5, %ecx
callq 0x1db40
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1df08
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x1df08
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
jmp 0x1df10
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsarray.c
// Function: Ap_sort_heapsort
static void Ap_sort_heapsort(js_State *J, int n)
{
	int i;
	for (i = n / 2 - 1; i >= 0; --i)
		Ap_sort_sift(J, i, n);
	for (i = n - 1; i > 0; --i) {
		Ap_sort_swap(J, 0, i);
		Ap_sort_sift(J, 0, i);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
subl $0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jl 0x1df60
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x1dfa0
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1df40
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0x1df96
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
xorl %esi, %esi
callq 0x1e020
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
xorl %esi, %esi
callq 0x1dfa0
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1df69
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsarray.c
// Function: Ap_sort_sift
static void Ap_sort_sift(js_State *J, int i, int end)
{
	int j = Ap_sort_leaf(J, i, end);
	while (Ap_sort_cmp(J, i, j) > 0)
		j = (j - 1) >> 1; /* parent */
	while (j > i) {
		Ap_sort_swap(J, i, j);
		j = (j - 1) >> 1; /* parent */
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x1e180
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x1e210
cmpl $0x0, %eax
jle 0x1dfe5
movl -0x14(%rbp), %eax
subl $0x1, %eax
sarl %eax
movl %eax, -0x14(%rbp)
jmp 0x1dfc4
jmp 0x1dfe7
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x1e00b
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x1e020
movl -0x14(%rbp), %eax
subl $0x1, %eax
sarl %eax
movl %eax, -0x14(%rbp)
jmp 0x1dfe7
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsarray.c
// Function: Ap_sort_swap
static void Ap_sort_swap(js_State *J, int idx_a, int idx_b)
{
	js_Object *obj = js_tovalue(J, 0)->u.object;
	if (obj->u.a.simple) {
		js_Value tmp = obj->u.a.array[idx_a];
		obj->u.a.array[idx_a] = obj->u.a.array[idx_b];
		obj->u.a.array[idx_b] = tmp;
	} else {
		int has_a = js_hasindex(J, 0, idx_a);
		int has_b = js_hasindex(J, 0, idx_b);
		if (has_a && has_b) {
			js_setindex(J, 0, idx_a);
			js_setindex(J, 0, idx_b);
		} else if (has_a && !has_b) {
			js_delindex(J, 0, idx_a);
			js_setindex(J, 0, idx_b);
		} else if (!has_a && has_b) {
			js_delindex(J, 0, idx_b);
			js_setindex(J, 0, idx_a);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x15020
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x24(%rax)
je 0x1e0cb
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x18(%rbp), %rcx
movq 0x30(%rcx), %rcx
movslq -0x10(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x1e16f
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
xorl %esi, %esi
callq 0x17b20
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
xorl %esi, %esi
callq 0x17b20
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x1e117
cmpl $0x0, -0x30(%rbp)
je 0x1e117
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
xorl %esi, %esi
callq 0x13bb0
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
xorl %esi, %esi
callq 0x13bb0
jmp 0x1e16d
cmpl $0x0, -0x2c(%rbp)
je 0x1e141
cmpl $0x0, -0x30(%rbp)
jne 0x1e141
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
xorl %esi, %esi
callq 0x17cc0
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
xorl %esi, %esi
callq 0x13bb0
jmp 0x1e16b
cmpl $0x0, -0x2c(%rbp)
jne 0x1e169
cmpl $0x0, -0x30(%rbp)
je 0x1e169
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
xorl %esi, %esi
callq 0x17cc0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
xorl %esi, %esi
callq 0x13bb0
jmp 0x1e16b
jmp 0x1e16d
jmp 0x1e16f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsarray.c
// Function: Ap_sort_leaf
static int Ap_sort_leaf(js_State *J, int i, int end)
{
	int j = i;
	int lc = (j << 1) + 1; /* left child */
	int rc = (j << 1) + 2; /* right child */
	while (rc < end) {
		if (Ap_sort_cmp(J, rc, lc) > 0)
			j = rc;
		else
			j = lc;
		lc = (j << 1) + 1;
		rc = (j << 1) + 2;
	}
	if (lc < end)
		j = lc;
	return j;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
shll %eax
addl $0x2, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x1e1f0
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x1e210
cmpl $0x0, %eax
jle 0x1e1d2
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x1e1d8
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
shll %eax
addl $0x2, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1e1ae
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x1e1fe
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jsbuiltin.c
// Function: Encode
static void Encode(js_State *J, const char *str_, const char *unescaped)
{
	/* NOTE: volatile to silence GCC warning about longjmp clobbering a variable */
	const char * volatile str = str_;
	js_Buffer *sb = NULL;

	static const char *HEX = "0123456789ABCDEF";

	if (js_try(J)) {
		js_free(J, sb);
		js_throw(J);
	}

	while (*str) {
		int c = (unsigned char) *str++;
		if (strchr(unescaped, c))
			js_putc(J, &sb, c);
		else {
			js_putc(J, &sb, '%');
			js_putc(J, &sb, HEX[(c >> 4) & 0xf]);
			js_putc(J, &sb, HEX[c & 0xf]);
		}
	}
	js_putc(J, &sb, 0);

	js_pushstring(J, sb ? sb->s : "");
	js_endtry(J);
	js_free(J, sb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14270
movq %rax, %rdi
callq 0x30e0
cmpl $0x0, %eax
je 0x1e870
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xd710
movq -0x8(%rbp), %rdi
callq 0x8cb0
jmp 0x1e872
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1e914
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x3280
cmpq $0x0, %rax
je 0x1e8b8
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %edx
leaq -0x28(%rbp), %rsi
callq 0xd910
jmp 0x1e90f
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0x25, %edx
callq 0xd910
movq -0x8(%rbp), %rdi
movq 0x29383(%rip), %rax     # 0x47c58
movl -0x2c(%rbp), %ecx
sarl $0x4, %ecx
andl $0xf, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edx
leaq -0x28(%rbp), %rsi
callq 0xd910
movq -0x8(%rbp), %rdi
movq 0x2935f(%rip), %rax     # 0x47c58
movl -0x2c(%rbp), %ecx
andl $0xf, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edx
leaq -0x28(%rbp), %rsi
callq 0xd910
jmp 0x1e872
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0xd910
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1e940
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
jmp 0x1e94d
leaq 0x1e0f5(%rip), %rax     # 0x3ca3c
movq %rax, -0x40(%rbp)
jmp 0x1e94d
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x13880
movq -0x8(%rbp), %rdi
callq 0x14a10
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xd710
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jscompile.c
// Function: cparams
static void cparams(JF, js_Ast *list, js_Ast *fname)
{
	F->numparams = listlength(list);
	while (list) {
		checkfutureword(J, F, list->a);
		addlocal(J, F, list->a, 0);
		list = list->b;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1f230
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x1ec0b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x1ee80
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
xorl %ecx, %ecx
callq 0x1f000
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1ebca
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jscompile.c
// Function: cvardecs
static void cvardecs(JF, js_Ast *node)
{
	if (node->type == AST_LIST) {
		while (node) {
			cvardecs(J, F, node->a);
			node = node->b;
		}
		return;
	}

	if (isfun(node->type))
		return; /* stop at inner functions */

	if (node->type == EXP_VAR) {
		checkfutureword(J, F, node->a);
		addlocal(J, F, node->a, 1);
	}

	if (node->a) cvardecs(J, F, node->a);
	if (node->b) cvardecs(J, F, node->b);
	if (node->c) cvardecs(J, F, node->c);
	if (node->d) cvardecs(J, F, node->d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x1ec6e
jmp 0x1ec3f
cmpq $0x0, -0x18(%rbp)
je 0x1ec69
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x1ec20
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1ec3f
jmp 0x1ed3b
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x1f270
cmpl $0x0, %eax
je 0x1ec83
jmp 0x1ed3b
movq -0x18(%rbp), %rax
cmpl $0x46, (%rax)
jne 0x1ecbb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x1ee80
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
movl $0x1, %ecx
callq 0x1f000
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1ecdb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x1ec20
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1ecfb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x1ec20
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1ed1b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x1ec20
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1ed3b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdx
callq 0x1ec20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jscompile.c
// Function: cfundecs
static void cfundecs(JF, js_Ast *list)
{
	while (list) {
		js_Ast *stm = list->a;
		if (stm->type == AST_FUNDEC) {
			emitline(J, F, stm);
			emitfunction(J, F, newfun(J, stm->line, stm->a, stm->b, stm->c, 0, F->strict, 0));
			emitline(J, F, stm);
			emit(J, F, OP_SETLOCAL);
			emitarg(J, F, addlocal(J, F, stm->a, 1));
			emit(J, F, OP_POP);
		}
		list = list->b;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1ee72
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x1ee61
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1f2b0
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x20(%rax), %r8
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
xorl %r9d, %r9d
movl %eax, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x8ed0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x1f2d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1f2b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x14, %edx
callq 0x1ef90
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
movl $0x1, %ecx
callq 0x1f000
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl %eax, %edx
callq 0x1efd0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x1ef90
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1ed64
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jscompile.c
// Function: checkfutureword
static void checkfutureword(JF, js_Ast *exp)
{
	if (jsY_findword(exp->string, futurewords, nelem(futurewords)) >= 0)
		jsC_error(J, exp, "'%s' is a future reserved word", exp->string);
	if (F->strict) {
		if (jsY_findword(exp->string, strictfuturewords, nelem(strictfuturewords)) >= 0)
			jsC_error(J, exp, "'%s' is a strict mode future reserved word", exp->string);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
leaq 0x28dbd(%rip), %rsi     # 0x47c60
movl $0x7, %edx
callq 0xde40
cmpl $0x0, %eax
jl 0x1eed0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rcx
leaq 0x1d597(%rip), %rdx     # 0x3c460
movb $0x0, %al
callq 0x8b80
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x1ef18
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
leaq 0x28db7(%rip), %rsi     # 0x47ca0
movl $0x9, %edx
callq 0xde40
cmpl $0x0, %eax
jl 0x1ef16
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rcx
leaq 0x1d570(%rip), %rdx     # 0x3c47f
movb $0x0, %al
callq 0x8b80
jmp 0x1ef18
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jscompile.c
// Function: findlocal
static int findlocal(JF, const char *name)
{
	int i;
	for (i = F->varlen; i > 0; --i)
		if (!strcmp(F->vartab[i-1], name))
			return i;
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x4c(%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x1ef7c
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
movq -0x20(%rbp), %rsi
callq 0x32d0
cmpl $0x0, %eax
jne 0x1ef6f
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1ef83
jmp 0x1ef71
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1ef3e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jscompile.c
// Function: addfunction
static int addfunction(JF, js_Function *value)
{
	if (F->funlen >= F->funcap) {
		F->funcap = F->funcap ? F->funcap * 2 : 16;
		F->funtab = js_realloc(J, F->funtab, F->funcap * sizeof *F->funtab);
	}
	F->funtab[F->funlen] = value;
	return F->funlen++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jl 0x1f3ba
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
je 0x1f37c
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
shll %eax
movl %eax, -0x1c(%rbp)
jmp 0x1f386
movl $0x10, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1f386
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x38(%rax), %rax
shlq $0x3, %rax
movl %eax, %edx
callq 0xda20
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x3c(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rcx
movl 0x3c(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x3c(%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jscompile.c
// Function: emitraw
static void emitraw(JF, int value)
{
	if (value != (js_Instruction)value)
		js_syntaxerror(J, "integer overflow in instruction coding");
	if (F->codelen >= F->codecap) {
		F->codecap = F->codecap ? F->codecap * 2 : 64;
		F->code = js_realloc(J, F->code, F->codecap * sizeof *F->code);
	}
	F->code[F->codelen++] = value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0x14(%rbp), %ecx
movzwl %cx, %ecx
cmpl %ecx, %eax
je 0x1f422
movq -0x8(%rbp), %rdi
leaq 0x1d0fd(%rip), %rsi     # 0x3c518
movb $0x0, %al
callq 0xbee0
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jl 0x1f487
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0x1f44a
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
shll %eax
movl %eax, -0x18(%rbp)
jmp 0x1f454
movl $0x40, %eax
movl %eax, -0x18(%rbp)
jmp 0x1f454
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x28(%rax), %rax
shlq %rax
movl %eax, %edx
callq 0xda20
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0x14(%rbp), %eax
movw %ax, %dx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rsi
movl 0x2c(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x2c(%rsi)
movslq %ecx, %rcx
movw %dx, (%rax,%rcx,2)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jscompile.c
// Function: cvarinit
static void cvarinit(JF, js_Ast *list)
{
	while (list) {
		js_Ast *var = list->a;
		if (var->b) {
			cexp(J, F, var->b);
			emitline(J, F, var);
			emitlocal(J, F, OP_SETLOCAL, OP_SETVAR, var->a);
			emit(J, F, OP_POP);
		}
		list = list->b;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x20214
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x20206
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x20220
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1f2b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %r8
movl $0x14, %edx
movl $0x18, %ecx
callq 0x21bb0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x1ef90
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x20194
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jscompile.c
// Function: emitjump
static int emitjump(JF, int opcode)
{
	int inst;
	emit(J, F, opcode);
	inst = F->codelen;
	emitarg(J, F, 0);
	return inst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x1ef90
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x1efd0
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jscompile.c
// Function: emitjumpto
static void emitjumpto(JF, int opcode, int dest)
{
	emit(J, F, opcode);
	if (dest != (js_Instruction)dest)
		js_syntaxerror(J, "jump address integer overflow");
	emitarg(J, F, dest);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x1ef90
movl -0x18(%rbp), %eax
movl -0x18(%rbp), %ecx
movzwl %cx, %ecx
cmpl %ecx, %eax
je 0x20eb5
movq -0x8(%rbp), %rdi
leaq 0x1b947(%rip), %rsi     # 0x3c7f5
movb $0x0, %al
callq 0xbee0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %edx
callq 0x1efd0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jscompile.c
// Function: labeljumps
static void labeljumps(JF, js_Ast *stm, int baddr, int caddr)
{
	js_JumpList *jump = stm->jumps;
	while (jump) {
		js_JumpList *next = jump->next;
		if (jump->type == STM_BREAK)
			labelto(J, F, jump->inst, baddr);
		if (jump->type == STM_CONTINUE)
			labelto(J, F, jump->inst, caddr);
		js_free(J, jump);
		jump = next;
	}
	stm->jumps = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x20f61
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x52, (%rax)
jne 0x20f2a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %edx
movl -0x1c(%rbp), %ecx
callq 0x22ca0
movq -0x28(%rbp), %rax
cmpl $0x51, (%rax)
jne 0x20f4a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %edx
movl -0x20(%rbp), %ecx
callq 0x22ca0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xd710
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x20ef7
movq -0x18(%rbp), %rax
movq $0x0, 0x40(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jscompile.c
// Function: breaktarget
static js_Ast *breaktarget(JF, js_Ast *node, const char *label)
{
	while (node) {
		if (isfun(node->type))
			break;
		if (!label) {
			if (isloop(node->type) || node->type == STM_SWITCH)
				return node;
		} else {
			if (matchlabel(node->parent, label))
				return node;
		}
		node = node->parent;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2143d
movq -0x20(%rbp), %rax
movl (%rax), %edi
callq 0x1f270
cmpl $0x0, %eax
je 0x213e1
jmp 0x2143d
cmpq $0x0, -0x28(%rbp)
jne 0x2140d
movq -0x20(%rbp), %rax
movl (%rax), %edi
callq 0x21350
cmpl $0x0, %eax
jne 0x21401
movq -0x20(%rbp), %rax
cmpl $0x55, (%rax)
jne 0x2140b
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x21445
jmp 0x2142f
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x22d00
cmpl $0x0, %eax
je 0x2142d
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x21445
jmp 0x2142f
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x213c8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jscompile.c
// Function: addjump
static void addjump(JF, enum js_AstType type, js_Ast *target, int inst)
{
	js_JumpList *jump = js_malloc(J, sizeof *jump);
	jump->type = type;
	jump->inst = inst;
	jump->next = target->jumps;
	target->jumps = jump;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl $0x10, %esi
callq 0xd9d0
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x40(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jscompile.c
// Function: continuetarget
static js_Ast *continuetarget(JF, js_Ast *node, const char *label)
{
	while (node) {
		if (isfun(node->type))
			break;
		if (isloop(node->type)) {
			if (!label)
				return node;
			else if (matchlabel(node->parent, label))
				return node;
		}
		node = node->parent;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x21764
movq -0x20(%rbp), %rax
movl (%rax), %edi
callq 0x1f270
cmpl $0x0, %eax
je 0x21711
jmp 0x21764
movq -0x20(%rbp), %rax
movl (%rax), %edi
callq 0x21350
cmpl $0x0, %eax
je 0x21756
cmpq $0x0, -0x28(%rbp)
jne 0x21732
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2176c
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x22d00
cmpl $0x0, %eax
je 0x21752
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2176c
jmp 0x21754
jmp 0x21756
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x216f8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jscompile.c
// Function: returntarget
static js_Ast *returntarget(JF, js_Ast *node)
{
	while (node) {
		if (isfun(node->type))
			return node;
		node = node->parent;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x217c3
movq -0x20(%rbp), %rax
movl (%rax), %edi
callq 0x1f270
cmpl $0x0, %eax
je 0x217b5
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x217cb
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x21794
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jscompile.c
// Function: ctrycatch
static void ctrycatch(JF, js_Ast *trystm, js_Ast *catchvar, js_Ast *catchstm)
{
	int L1, L2;
	L1 = emitjump(J, F, OP_TRY);
	{
		/* if we get here, we have caught an exception in the try block */
		checkfutureword(J, F, catchvar);
		if (F->strict) {
			if (!strcmp(catchvar->string, "arguments"))
				jsC_error(J, catchvar, "redefining 'arguments' is not allowed in strict mode");
			if (!strcmp(catchvar->string, "eval"))
				jsC_error(J, catchvar, "redefining 'eval' is not allowed in strict mode");
		}
		emitline(J, F, catchvar);
		emitstring(J, F, OP_CATCH, catchvar->string);
		cstm(J, F, catchstm);
		emit(J, F, OP_ENDCATCH);
		L2 = emitjump(J, F, OP_JUMP); /* skip past the try block */
	}
	label(J, F, L1);
	cstm(J, F, trystm);
	emit(J, F, OP_ENDTRY);
	label(J, F, L2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x4a, %edx
callq 0x20dd0
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1ee80
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x21a5c
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
leaq 0x1ab34(%rip), %rsi     # 0x3c53f
callq 0x32d0
cmpl $0x0, %eax
jne 0x21a2b
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x1ab25(%rip), %rdx     # 0x3c549
movb $0x0, %al
callq 0x8b80
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
leaq 0x1ab44(%rip), %rsi     # 0x3c57e
callq 0x32d0
cmpl $0x0, %eax
jne 0x21a5a
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x1ab30(%rip), %rdx     # 0x3c583
movb $0x0, %al
callq 0x8b80
jmp 0x21a5c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1f2b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rcx
movl $0x4c, %edx
callq 0x21d10
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x1f4c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x4d, %edx
callq 0x1ef90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x51, %edx
callq 0x20dd0
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x20e20
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1f4c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x4b, %edx
callq 0x1ef90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x30(%rbp), %edx
callq 0x20e20
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jscompile.c
// Function: ctryfinally
static void ctryfinally(JF, js_Ast *trystm, js_Ast *finallystm)
{
	int L1;
	L1 = emitjump(J, F, OP_TRY);
	{
		/* if we get here, we have caught an exception in the try block */
		cstm(J, F, finallystm); /* inline finally block */
		emit(J, F, OP_THROW); /* rethrow exception */
	}
	label(J, F, L1);
	cstm(J, F, trystm);
	emit(J, F, OP_ENDTRY);
	cstm(J, F, finallystm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x4a, %edx
callq 0x20dd0
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1f4c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x49, %edx
callq 0x1ef90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x20e20
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1f4c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x4b, %edx
callq 0x1ef90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1f4c0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jscompile.c
// Function: emitlocal
static void emitlocal(JF, int oploc, int opvar, js_Ast *ident)
{
	int is_arguments = !strcmp(ident->string, "arguments");
	int is_eval = !strcmp(ident->string, "eval");
	int i;

	if (is_arguments) {
		F->lightweight = 0;
		F->arguments = 1;
	}

	checkfutureword(J, F, ident);
	if (F->strict && oploc == OP_SETLOCAL) {
		if (is_arguments)
			jsC_error(J, ident, "'arguments' is read-only in strict mode");
		if (is_eval)
			jsC_error(J, ident, "'eval' is read-only in strict mode");
	}
	if (is_eval)
		js_evalerror(J, "%s:%d: invalid use of 'eval'", J->filename, ident->line);

	i = findlocal(J, F, ident->string);
	if (i < 0) {
		emitstring(J, F, opvar, ident->string);
	} else {
		emit(J, F, oploc);
		emitarg(J, F, i);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
leaq 0x1a966(%rip), %rsi     # 0x3c53f
callq 0x32d0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
leaq 0x1a981(%rip), %rsi     # 0x3c57e
callq 0x32d0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x21c2e
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x14(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1ee80
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x21c89
cmpl $0x14, -0x14(%rbp)
jne 0x21c89
cmpl $0x0, -0x24(%rbp)
je 0x21c6b
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x1aa59(%rip), %rdx     # 0x3c6bd
movb $0x0, %al
callq 0x8b80
cmpl $0x0, -0x28(%rbp)
je 0x21c87
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x1aa65(%rip), %rdx     # 0x3c6e5
movb $0x0, %al
callq 0x8b80
jmp 0x21c89
cmpl $0x0, -0x28(%rbp)
je 0x21cb0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdx
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
leaq 0x1a90a(%rip), %rsi     # 0x3c5b3
movb $0x0, %al
callq 0xbc10
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdx
callq 0x1ef20
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x21ce8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rcx
callq 0x21d10
jmp 0x21d08
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x1ef90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x1efd0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jscompile.c
// Function: emitstring
static void emitstring(JF, int opcode, const char *str)
{
#define N (sizeof(str) / sizeof(js_Instruction))
	js_Instruction x[N];
	size_t i;
	emit(J, F, opcode);
	memcpy(x, &str, sizeof(str));
	for (i = 0; i < N; ++i)
		emitarg(J, F, x[i]);
#undef N
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x1ef90
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x4, -0x30(%rbp)
jae 0x21d72
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rax
movzwl -0x28(%rbp,%rax,2), %edx
callq 0x1efd0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x21d47
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jscompile.c
// Function: emitnumber
static void emitnumber(JF, double num)
{
	if (num == 0) {
		emit(J, F, OP_INTEGER);
		emitarg(J, F, 32768);
		if (signbit(num))
			emit(J, F, OP_NEG);
	} else if (num >= SHRT_MIN && num <= SHRT_MAX && num == (int)num) {
		emit(J, F, OP_INTEGER);
		emitarg(J, F, num + 32768);
	} else {
#define N (sizeof(num) / sizeof(js_Instruction))
		js_Instruction x[N];
		size_t i;
		emit(J, F, OP_NUMBER);
		memcpy(x, &num, sizeof(num));
		for (i = 0; i < N; ++i)
			emitarg(J, F, x[i]);
#undef N
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x21df0
jp 0x21df0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x6, %edx
callq 0x1ef90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x8000, %edx           # imm = 0x8000
callq 0x1efd0
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
cmpq $0x0, %rax
jge 0x21deb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x2d, %edx
callq 0x1ef90
jmp 0x21eab
movsd -0x18(%rbp), %xmm0
movsd 0x116f3(%rip), %xmm1    # 0x334f0
ucomisd %xmm1, %xmm0
jb 0x21e5a
movsd 0x116ed(%rip), %xmm0    # 0x334f8
ucomisd -0x18(%rbp), %xmm0
jb 0x21e5a
movsd -0x18(%rbp), %xmm0
cvttsd2si -0x18(%rbp), %eax
cvtsi2sd %eax, %xmm1
ucomisd %xmm1, %xmm0
jne 0x21e5a
jp 0x21e5a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x6, %edx
callq 0x1ef90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsd 0x116b6(%rip), %xmm0    # 0x33500
addsd -0x18(%rbp), %xmm0
cvttsd2si %xmm0, %edx
callq 0x1efd0
jmp 0x21ea9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x7, %edx
callq 0x1ef90
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x4, -0x28(%rbp)
jae 0x21ea7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
movzwl -0x20(%rbp,%rax,2), %edx
callq 0x1efd0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x21e7c
jmp 0x21ea9
jmp 0x21eab
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jscompile.c
// Function: carray
static void carray(JF, js_Ast *list)
{
	while (list) {
		emitline(J, F, list->a);
		if (list->a->type == EXP_ELISION) {
			emit(J, F, OP_SKIPARRAY);
		} else {
			cexp(J, F, list->a);
			emit(J, F, OP_INITARRAY);
		}
		list = list->b;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x221a6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x1f2b0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x7, (%rax)
jne 0x22171
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1b, %edx
callq 0x1ef90
jmp 0x22198
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x20220
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1c, %edx
callq 0x1ef90
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x22134
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jscompile.c
// Function: ccall
static void ccall(JF, js_Ast *fun, js_Ast *args)
{
	int n;
	switch (fun->type) {
	case EXP_INDEX:
		cexp(J, F, fun->a);
		emit(J, F, OP_DUP);
		cexp(J, F, fun->b);
		emit(J, F, OP_GETPROP);
		emit(J, F, OP_ROT2);
		break;
	case EXP_MEMBER:
		cexp(J, F, fun->a);
		emit(J, F, OP_DUP);
		emitstring(J, F, OP_GETPROP_S, fun->b->string);
		emit(J, F, OP_ROT2);
		break;
	case EXP_IDENTIFIER:
		if (!strcmp(fun->string, "eval")) {
			ceval(J, F, fun, args);
			return;
		}
		/* fallthrough */
	default:
		cexp(J, F, fun);
		emit(J, F, OP_UNDEF);
		break;
	}
	n = cargs(J, F, args);
	emit(J, F, OP_CALL);
	emitarg(J, F, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
subl $0x3, %eax
je 0x222b1
jmp 0x221dc
movl -0x28(%rbp), %eax
subl $0x12, %eax
je 0x221f3
jmp 0x221e6
movl -0x28(%rbp), %eax
subl $0x13, %eax
je 0x22258
jmp 0x222e3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x20220
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x1ef90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x20220
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x20, %edx
callq 0x1ef90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x3, %edx
callq 0x1ef90
jmp 0x22306
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x20220
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x1ef90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x38(%rax), %rcx
movl $0x21, %edx
callq 0x21d10
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x3, %edx
callq 0x1ef90
jmp 0x22306
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
leaq 0x1a2be(%rip), %rsi     # 0x3c57e
callq 0x32d0
cmpl $0x0, %eax
jne 0x222e1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x22c00
jmp 0x2233c
jmp 0x222e3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x20220
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xd, %edx
callq 0x1ef90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x22350
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x29, %edx
callq 0x1ef90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x1efd0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jscompile.c
// Function: cargs
static int cargs(JF, js_Ast *list)
{
	int n = 0;
	while (list) {
		cexp(J, F, list->a);
		list = list->b;
		++n;
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2239e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x20220
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2236b
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/./jscompile.c
// Function: cdelete
static void cdelete(JF, js_Ast *exp)
{
	js_Ast *arg = exp->a;
	switch (arg->type) {
	case EXP_IDENTIFIER:
		if (F->strict)
			jsC_error(J, exp, "delete on an unqualified name is not allowed in strict mode");
		emitline(J, F, exp);
		emitlocal(J, F, OP_DELLOCAL, OP_DELVAR, arg);
		break;
	case EXP_INDEX:
		cexp(J, F, arg->a);
		cexp(J, F, arg->b);
		emitline(J, F, exp);
		emit(J, F, OP_DELPROP);
		break;
	case EXP_MEMBER:
		cexp(J, F, arg->a);
		emitline(J, F, exp);
		emitstring(J, F, OP_DELPROP_S, arg->b->string);
		break;
	default:
		jsC_error(J, exp, "invalid l-value in delete expression");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x3, %eax
je 0x223fb
jmp 0x223e0
movl -0x24(%rbp), %eax
subl $0x12, %eax
je 0x2244c
jmp 0x223ea
movl -0x24(%rbp), %eax
subl $0x13, %eax
je 0x2249b
jmp 0x224e1
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x2241b
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x1a362(%rip), %rdx     # 0x3c776
movb $0x0, %al
callq 0x8b80
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1f2b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %r8
movl $0x15, %edx
movl $0x19, %ecx
callq 0x21bb0
jmp 0x224f7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x20220
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x20220
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1f2b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x24, %edx
callq 0x1ef90
jmp 0x224f7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x20220
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1f2b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x38(%rax), %rcx
movl $0x25, %edx
callq 0x21d10
jmp 0x224f7
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x1a2c2(%rip), %rdx     # 0x3c7b2
movb $0x0, %al
callq 0x8b80
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)