LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/aryth.c
// Function: eval_sub
static int eval_sub(struct cy_token *t, struct cy_file *f)
{
	struct cy_token a, b;

	if (cy_eval_next(f, &a) <= 0)
		return -1;

	if (a.v.t == CY_V_LIST) {
		if (cy_eval_next_x(f, &b, CY_V_NUMBER) <= 0)
			return -1;

		return cy_list_del(&a.v, &b.v);
	}

	if (a.v.t == CY_V_MAP) {
		if (cy_eval_next_x(f, &b, CY_V_STRING) <= 0)
			return -1;

		return cy_map_del(&a.v, &b.v);
	}

	if (a.v.t == CY_V_NUMBER) {
		if (cy_eval_next_x(f, &b, CY_V_NUMBER) <= 0)
			return -1;

		t->v.t = CY_V_NUMBER;
		t->v.v_i = a.v.v_i - b.v.v_i;
		return 1;
	}

	show_token_err(t, "Bad op for sub");
	return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %r12
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x42c4
testl %eax, %eax
js 0x460e
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
je 0x4600
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x447d
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq *%rax
testl %eax, %eax
jle 0x4600
movl 0x48(%rsp), %eax
cmpl $0x1, %eax
je 0x4537
leaq 0x48(%rsp), %r15
cmpl $0x4, %eax
je 0x44e9
cmpl $0x3, %eax
jne 0x45aa
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x42c4
testl %eax, %eax
js 0x461d
je 0x4600
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x44d0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
cmpl $0x1, %eax
jne 0x45ef
cmpl $0x1, 0x20(%rsp)
jne 0x4576
jmp 0x45f1
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x42c4
testl %eax, %eax
js 0x4613
je 0x4600
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x451c
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
cmpl $0x1, %eax
jne 0x45bd
cmpl $0x2, 0x20(%rsp)
je 0x45bf
movl $0x2, %edi
jmp 0x457b
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x42c4
testl %eax, %eax
js 0x4618
je 0x4600
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x456a
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
cmpl $0x1, %eax
jne 0x45ce
cmpl $0x1, 0x20(%rsp)
je 0x45d0
movl $0x1, %edi
callq 0x3bbc
movq %rax, %r14
leaq 0x8(%rsp), %r15
movl 0x18(%r15), %edi
callq 0x3bbc
leaq 0x3bb7(%rip), %rsi      # 0x814f
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
jmp 0x4600
leaq 0x3bb8(%rip), %rsi      # 0x8169
movq %r12, %rdi
xorl %eax, %eax
callq 0x3240
jmp 0x4600
jl 0x4600
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x5baf
jmp 0x45fe
jl 0x4600
movl $0x1, 0x18(%r12)
movq 0x50(%rsp), %rax
subq 0x28(%rsp), %rax
movq %rax, 0x20(%r12)
movl $0x1, %ebx
jmp 0x4600
jl 0x4600
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x53ad
movl %eax, %ebx
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x33c6
callq 0x337c
callq 0x3357
callq 0x33a1
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/aryth.c
// Function: eval_nr_op
static int eval_nr_op(struct cy_token *t, struct cy_file *f)
{
	int ret;
	struct cy_token a, b;

	ret = eval_2arg_math(&a, &b, f);
	if (ret <= 0)
		return -1;

	t->v.t = a.v.t;

	switch (a.v.t) {
	case CY_V_NUMBER:
		if (t->typ->priv == OP_MUL) {
			t->v.v_i = a.v.v_i * b.v.v_i;
		} else {
			if (b.v.v_i == 0) {
				show_token_err(t, "Division by zero");
				return -1;
			}

			if (t->typ->priv == OP_DIV)
				t->v.v_i = a.v.v_i / b.v.v_i;
			else
				t->v.v_i = a.v.v_i % b.v.v_i;
		}
		break;
	default:
		show_token_err(t, "Can't DIV %s", vtype2s(a.v.t));
		return -1;
	}

	return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x481e
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x46ab
movl 0x20(%rsp), %edi
movl %edi, 0x18(%rbx)
cmpl $0x1, %edi
jne 0x466d
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rcx
cmpq $0x3, %rcx
jne 0x4688
movq 0x50(%rsp), %rax
imulq 0x28(%rsp), %rax
jmp 0x46a2
callq 0x3bbc
leaq 0x3b10(%rip), %rsi      # 0x8189
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3240
jmp 0x46ab
movq 0x50(%rsp), %rsi
testq %rsi, %rsi
je 0x46b4
movq 0x28(%rsp), %rax
cqto
idivq %rsi
cmpq $0x1, %rcx
jne 0x46c7
movq %rax, 0x20(%rbx)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3abd(%rip), %rsi      # 0x8178
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3240
jmp 0x46ab
movq %rdx, 0x20(%rbx)
jmp 0x46a6
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/aryth.c
// Function: eval_bool_op
static int eval_bool_op(struct cy_token *t, struct cy_file *f)
{
	int ret;
	struct cy_token a, b;

	ret = eval_2arg_math(&a, &b, f);
	if (ret <= 0)
		return -1;

	t->v.t = a.v.t;

	switch (t->v.t) {
	case CY_V_BOOL:
		switch (t->typ->priv) {
		case OP_AND: t->v.v_bool = a.v.v_bool && b.v.v_bool; break;
		case OP_OR:  t->v.v_bool = a.v.v_bool || b.v.v_bool; break;
		case OP_XOR: t->v.v_bool = a.v.v_bool ^  b.v.v_bool; break;
		}
		break;
	default:
		show_token_err(t, "Bool command on %s", vtype2s(a.v.t));
		return -1;
	}

	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rdx
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x481e
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x4767
movl 0x20(%rsp), %edi
movl %edi, 0x18(%r14)
cmpl $0x6, %edi
jne 0x4729
movq 0x8(%r14), %rax
movq 0x10(%rax), %rax
movl $0x1, %ebx
cmpq $0x4, %rax
je 0x475a
cmpq $0x2, %rax
je 0x4744
cmpq $0x1, %rax
jne 0x4767
xorl %eax, %eax
cmpb $0x0, 0x28(%rsp)
jne 0x4750
jmp 0x4754
callq 0x3bbc
leaq 0x3a61(%rip), %rsi      # 0x8196
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3240
jmp 0x4767
cmpb $0x0, 0x28(%rsp)
movl $0x1, %eax
jne 0x4754
movl 0x50(%rsp), %eax
movb %al, 0x20(%r14)
jmp 0x4767
movb 0x28(%rsp), %al
cmpb 0x50(%rsp), %al
setne 0x20(%r14)
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/aryth.c
// Function: eval_bool_not
static int eval_bool_not(struct cy_token *t, struct cy_file *f)
{
	struct cy_token a;

	if (cy_eval_next_x(f, &a, CY_V_BOOL) <= 0)
		return -1;

	t->v.t = CY_V_BOOL;
	t->v.v_bool = !a.v.v_bool;
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x42c4
testl %eax, %eax
js 0x4819
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
je 0x480d
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x47b4
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq *%rcx
cmpl $0x1, %eax
jne 0x47f4
cmpl $0x6, 0x20(%rsp)
je 0x47f6
movl $0x6, %edi
callq 0x3bbc
movq %rax, %r14
leaq 0x8(%rsp), %r15
movl 0x18(%r15), %edi
callq 0x3bbc
leaq 0x396d(%rip), %rsi      # 0x814f
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
jmp 0x480d
jl 0x480d
movl $0x6, 0x18(%r14)
movb 0x28(%rsp), %al
xorb $0x1, %al
movb %al, 0x20(%r14)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x33eb
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/syms.c
// Function: try_resolve_sym
int try_resolve_sym(struct cy_token *t)
{
	if (try_resolve_number(t))
		return 1;

	if (t->val[0] == '"' || t->val[0] == '\'') {
		t->typ = &cy_string;
		t->v.t = CY_V_STRING;
		t->v.v_str = t->val + 1;
		return 1;
	}

	if (try_resolve_symbol(t))
		return 1;

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq %rdi, (%rsp)
movb (%rdi), %cl
movq %rdi, %rax
cmpb $0x2d, %cl
jne 0x4913
leaq 0x1(%rdi), %rax
movq %rax, (%rsp)
movb 0x1(%rdi), %cl
movl $0xa, %edx
cmpb $0x30, %cl
jne 0x492d
xorl %ecx, %ecx
cmpb $0x78, 0x1(%rax)
sete %cl
leal 0x8(,%rcx,8), %edx
movq %rsp, %r14
movq %r14, %rsi
callq 0x3140
movq %rax, 0x20(%rbx)
movq (%r14), %rax
cmpb $0x0, (%rax)
je 0x496f
movq (%rbx), %rax
movzbl (%rax), %ecx
cmpl $0x27, %ecx
je 0x4954
cmpl $0x22, %ecx
jne 0x4988
leaq 0x79f5(%rip), %rcx      # 0xc350
movq %rcx, 0x8(%rbx)
movl $0x2, 0x18(%rbx)
incq %rax
movq %rax, 0x20(%rbx)
jmp 0x4981
leaq 0x79f2(%rip), %rax      # 0xc368
movq %rax, 0x8(%rbx)
movl $0x1, 0x18(%rbx)
movl $0x1, %eax
jmp 0x4999
movq %rbx, %rdi
callq 0x49ce
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/declare.c
// Function: try_resolve_symbol
int try_resolve_symbol(struct cy_token *t)
{
	const char *val = t->val, *aux;
	struct cy_type *ret;

	t->v.v_sym = val;

	if (val[0] == '_') {
		if (val[1] == '.')
			/*
			 * this is a _.... construciton which
			 * is valid nested symbol, but requires
			 * additional checking
			 */
			goto sym;

		if (val[1] == '\0') {
			t->typ = &cy_cursor;
			return 1;
		}

		if (val[1] == '_' && val[2] == '\0') {
			t->typ = &cy_curns;
			return 1;
		}

		if (try_resolve_cvalue(t))
			return 1;

		if (try_resolve_stream(t))
			return 1;

		return 0;
	}

	if (!is_alpha(val[0]))
		return 0;

sym:
	ret = &cy_sym;
	aux = val; /* sym len counting */
	for (val++; *val != '\0'; val++) {
		if (val - aux >= MAX_SYM_LEN) {
			show_token_err(t, "Too long symbol");
			return 0;
		}

		if (is_alpha(*val))
			continue;
		if (is_num(*val))
			continue;
		if (*val == '_')
			continue;
		if (*val == '.') {
			aux = val;
			continue;
		}

		return 0;
	}

	t->typ = ret;
	return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq %rax, 0x20(%rdi)
movb (%rax), %cl
cmpb $0x5f, %cl
jne 0x4a05
movzbl 0x1(%rax), %ecx
cmpl $0x5f, %ecx
je 0x4a8d
cmpl $0x2e, %ecx
je 0x4a1d
testl %ecx, %ecx
jne 0x4a93
leaq 0x7995(%rip), %rax      # 0xc398
jmp 0x4a6d
andb $-0x21, %cl
addb $-0x41, %cl
xorl %ebp, %ebp
cmpb $0x19, %cl
ja 0x4ac1
movb 0x1(%rax), %cl
testb %cl, %cl
je 0x4a66
leaq 0x1(%rax), %rdx
movq %rdx, %rsi
movq %rdx, %rdi
subq %rax, %rdi
cmpq $0x40, %rdi
jge 0x4a78
leal -0x30(%rcx), %edi
cmpb $0xa, %dil
jb 0x4a59
movl %ecx, %edi
andb $-0x21, %dil
addb $-0x41, %dil
cmpb $0x1a, %dil
jb 0x4a59
cmpb $0x5f, %cl
je 0x4a59
movzbl %cl, %eax
cmpl $0x2e, %eax
jne 0x4abf
movq %rsi, %rax
movb 0x1(%rsi), %cl
incq %rsi
incq %rdx
testb %cl, %cl
jne 0x4a24
leaq 0x7913(%rip), %rax      # 0xc380
movq %rax, 0x8(%rbx)
movl $0x1, %ebp
jmp 0x4ac1
leaq 0x3732(%rip), %rsi      # 0x81b1
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3240
jmp 0x4ac1
cmpb $0x0, 0x2(%rax)
je 0x4ab6
movq %rbx, %rdi
callq 0x754c
movl $0x1, %ebp
testl %eax, %eax
jne 0x4ac1
movq %rbx, %rdi
callq 0x7a00
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
jmp 0x4ac1
leaq 0x78f3(%rip), %rax      # 0xc3b0
jmp 0x4a6d
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/declare.c
// Function: try_deref_symbol
int try_deref_symbol(const char *val, struct cy_value *sv, bool strict)
{
	struct cy_token ft;

	ft.val = val;
	if (!try_resolve_symbol(&ft))
		return -1;

	if (strict && !is_symbol_token(&ft)) {
		fprintf(stderr, "Nested resolve is not a symbol");
		return -1;
	}

	if (ft.typ->eval(&ft, NULL) < 0)
		return -1;

	*sv = ft.v;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebp
movq %rsi, %r14
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
movq %rax, %rdi
callq 0x49ce
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x4b23
movq 0x10(%rsp), %rax
leaq 0x7884(%rip), %rcx      # 0xc380
cmpq %rcx, %rax
setne %cl
andb %bpl, %cl
cmpb $0x1, %cl
je 0x4b2e
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq *0x8(%rax)
testl %eax, %eax
js 0x4b23
movups 0x20(%rsp), %xmm0
movups %xmm0, (%r14)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x345a
jmp 0x4b23
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/declare.c
// Function: dereference
static int dereference(struct cy_token *t, struct cy_value *into, struct cy_value *last, char *buf)
{
	struct cy_value sv = symbols;
	const char *aux;

	if (last)
		last->t = CY_V_NOVALUE;
	aux = t->v.v_sym;
	if (aux[0] == '_') {
		if (cursor.t == CY_V_NOVALUE) {
			show_token_err(t, "Use of cursor outside of loop");
			return -1;
		}

		sv = cursor;
		aux++;
		if (*aux == '.')
			aux++;
	}

	while (*aux != '\0') {
		const char *nxt;
		struct cy_value kv;
		int ret;

		nxt = nest_get_key(aux, &kv, buf);
		if (nxt == NULL)
			return -1;

		if (last != NULL && *nxt == '\0') {
			*last = kv;
			break;
		}

		switch (sv.t) {
		case CY_V_LIST:
			ret = dereference_list_elem(t, &sv, &kv);
			break;
		case CY_V_MAP:
			ret = dereference_map_elem(t, &sv, &kv);
			break;
		default:
			show_token_err(t, "Unknown symbol (%s) for nesting", vtype2s(sv.t));
			ret = -1;
			break;
		}

		if (ret <= 0)
			return -1;

		sv = t->v;
		aux = nxt;
	}

	*into = sv;
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, 0x40(%rsp)
movq %rdx, %r15
movq %rsi, 0x28(%rsp)
movq %rdi, %r13
movups 0x8597(%rip), %xmm0     # 0xd138
movaps %xmm0, (%rsp)
testq %rdx, %rdx
je 0x4bb1
movl $0x0, (%r15)
movq 0x20(%r13), %rbp
movb (%rbp), %bl
cmpb $0x5f, %bl
jne 0x4bee
cmpl $0x0, 0x8564(%rip)      # 0xd128
je 0x4cda
movups 0x8557(%rip), %xmm0     # 0xd128
movaps %xmm0, (%rsp)
leaq 0x2(%rbp), %rax
xorl %ecx, %ecx
cmpb $0x2e, 0x1(%rbp)
sete %cl
movb 0x1(%rcx,%rbp), %bl
leaq 0x1(%rbp), %rbp
cmoveq %rax, %rbp
testb %bl, %bl
je 0x4cf6
leaq 0x18(%r13), %r14
movq %r15, 0x38(%rsp)
movq %r14, 0x30(%rsp)
xorl %r12d, %r12d
cmpb $0x2e, %bl
sete %r12b
addq %rbp, %r12
movq %r12, %rdi
movl $0x2e, %esi
callq 0x3080
movq %rax, %rbp
cmpb $0x2e, (%rax)
jne 0x4c5a
movq %r13, %r15
movq %rbp, %r13
subq %r12, %r13
movq 0x40(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x3040
movb $0x0, (%r14,%r13)
movq %r15, %r13
movq 0x38(%rsp), %r15
incq %rbp
movq %r14, %r12
movq 0x30(%rsp), %r14
cmpb $0x2e, %bl
jne 0x4c7a
movq %r12, %rdi
leaq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x4aca
testl %eax, %eax
jns 0x4c87
jmp 0x4d22
movl $0x2, 0x18(%rsp)
movq %r12, 0x20(%rsp)
testq %r15, %r15
je 0x4c92
cmpb $0x0, (%rbp)
je 0x4ced
movl (%rsp), %edi
cmpl $0x4, %edi
je 0x4cb1
cmpl $0x3, %edi
jne 0x4d09
movq %r13, %rdi
movq %rsp, %rsi
leaq 0x18(%rsp), %rdx
callq 0x5407
jmp 0x4cc1
movq %r13, %rdi
movq %rsp, %rsi
leaq 0x18(%rsp), %rdx
callq 0x5b60
testl %eax, %eax
jle 0x4d22
movups (%r14), %xmm0
movaps %xmm0, (%rsp)
movb (%rbp), %bl
testb %bl, %bl
jne 0x4c04
jmp 0x4cf6
leaq 0x34ff(%rip), %rsi      # 0x81e0
movq %r13, %rdi
xorl %eax, %eax
callq 0x3240
jmp 0x4d22
movups 0x18(%rsp), %xmm0
movups %xmm0, (%r15)
movaps (%rsp), %xmm0
movq 0x28(%rsp), %rax
movups %xmm0, (%rax)
movl $0x1, %eax
jmp 0x4d27
callq 0x3bbc
leaq 0x34e9(%rip), %rsi      # 0x81fe
movq %r13, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/declare.c
// Function: eval_declare
static int eval_declare(struct cy_token *t, struct cy_file *f)
{
	struct cy_token st, vt;
	struct cy_value in, last;
	char buf[MAX_SYM_LEN + 1];

	if (cy_next(f, &st) <= 0)
		return -1;

	if (!is_symbol_token(&st)) {
		show_token_err(t, "Declaration to non-symbol");
		return -1;
	}

	if (dereference(&st, &in, &last, buf) <= 0)
		return -1;

	if (last.t != CY_V_STRING) {
		show_token_err(t, "Last sym is not a string");
		return -1;
	}

	if (in.t != CY_V_MAP) {
		show_token_err(t, "Can't declare in non-map");
		return -1;
	}

	if (t->typ->priv) { /* swap */
		struct cy_map_value *mv;

		mv = find_in_map(&in.v_map->r, last.v_str, 0);
		if (mv == NULL)
			goto set;

		set_cursor(&mv->v);
		if (cy_eval_next(f, &vt) <= 0)
			return -1;

		set_cursor(NULL);
		t->v = mv->v;
		mv->v = vt.v;

		return 1;
	}

set:
	if (cy_eval_next(f, &vt) <= 0)
		return -1;

	if (map_add_value(strdup(last.v_str), &vt.v, &in.v_map->r, true) < 0)
		return -1;

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
callq 0x42c4
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x4d90
leaq 0x7608(%rip), %rax      # 0xc380
cmpq %rax, 0x50(%rsp)
je 0x4da1
leaq 0x34d5(%rip), %rsi      # 0x825b
movq %r14, %rdi
xorl %eax, %eax
callq 0x3240
movl %ebx, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rsp, %rdx
leaq 0x70(%rsp), %rcx
callq 0x4b7c
testl %eax, %eax
jle 0x4d90
cmpl $0x2, (%rsp)
jne 0x4e35
cmpl $0x4, 0x10(%rsp)
jne 0x4e41
movq 0x8(%r14), %rax
cmpq $0x0, 0x10(%rax)
je 0x4e4d
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x5afe
testq %rax, %rax
je 0x4e4d
movq %rax, %r12
movups 0x20(%rax), %xmm0
movups %xmm0, 0x8330(%rip)     # 0xd128
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x503f
testl %eax, %eax
jle 0x4d90
addq $0x20, %r12
movl $0x0, 0x8311(%rip)      # 0xd128
movups (%r12), %xmm0
movups %xmm0, 0x18(%r14)
movups 0x38(%rsp), %xmm0
movups %xmm0, (%r12)
movl $0x1, %ebx
jmp 0x4d90
leaq 0x3439(%rip), %rsi      # 0x8275
jmp 0x4d86
leaq 0x3446(%rip), %rsi      # 0x828e
jmp 0x4d86
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x42c4
testl %eax, %eax
js 0x4eb2
je 0x4d90
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x4e84
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq *%rax
testl %eax, %eax
jle 0x4d90
movq 0x8(%rsp), %rdi
callq 0x3220
leaq 0x38(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rdi
movl $0x1, %ecx
callq 0x5a48
movl %eax, %ebx
sarl $0x1f, %ebx
orl $0x1, %ebx
jmp 0x4d90
callq 0x347c
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/declare.c
// Function: eval_nsenter
static int eval_nsenter(struct cy_token *t, struct cy_file *f)
{
	struct cy_token nst;

	if (cy_eval_next_x(f, &nst, CY_V_MAP) <= 0)
		return -1;

	symbols = nst.v;
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x42c4
testl %eax, %eax
js 0x4f52
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
je 0x4f46
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x4ef3
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
cmpl $0x1, %eax
jne 0x4f33
cmpl $0x4, 0x20(%rsp)
je 0x4f35
movl $0x4, %edi
callq 0x3bbc
movq %rax, %r14
leaq 0x8(%rsp), %r15
movl 0x18(%r15), %edi
callq 0x3bbc
leaq 0x322e(%rip), %rsi      # 0x814f
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
jmp 0x4f46
jl 0x4f46
movups 0x20(%rsp), %xmm0
movups %xmm0, 0x81f7(%rip)     # 0xd138
movl $0x1, %ebx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x34a1
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/declare.c
// Function: eval_deref
static int eval_deref(struct cy_token *t, struct cy_file *f)
{
	struct cy_token st, kt;
	int ret;

	if (cy_eval_next(f, &st) <= 0)
		return -1;
	if (cy_eval_next(f, &kt) <= 0)
		return -1;

	switch (st.v.t) {
		case CY_V_LIST:
			ret = dereference_list_elem(t, &st.v, &kt.v);
			break;
		case CY_V_MAP:
			ret = dereference_map_elem(t, &st.v, &kt.v);
			break;
		default:
			show_token_err(t, "Unknown symbol (%s) for nesting", vtype2s(st.v.t));
			ret = -1;
			break;
	}

	if (ret <= 0)
		return -1;

	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x42c4
testl %eax, %eax
js 0x5035
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
je 0x502a
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x4fa5
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq *%rax
testl %eax, %eax
jle 0x502a
movq %rsp, %rsi
movq %r14, %rdi
callq 0x42c4
testl %eax, %eax
js 0x503a
je 0x502a
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x4fd4
movq %rsp, %rdi
movq %r14, %rsi
callq *%rax
testl %eax, %eax
jle 0x502a
leaq 0x40(%rsp), %rsi
movl (%rsi), %edi
cmpl $0x4, %edi
je 0x4ff4
cmpl $0x3, %edi
jne 0x500c
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x5407
jmp 0x5001
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x5b60
movl $0x1, %ebp
testl %eax, %eax
jg 0x502a
jmp 0x5025
callq 0x3bbc
leaq 0x31e6(%rip), %rsi      # 0x81fe
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x34eb
callq 0x34c6
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/./cy.h
// Function: cy_eval_next
static inline int cy_eval_next(struct cy_file *f, struct cy_token *t)
{
	int ret;

	ret = cy_next(f, t);
	if (ret < 0) {
		fprintf(stderr, "FATAL: Next token error\n");
		exit(1);
	}

	if (ret > 0 && t->typ->eval)
		ret = t->typ->eval(t, f);

	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x42c4
testl %eax, %eax
js 0x507a
je 0x5070
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x5072
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x3510
nop
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/show.c
// Function: eval_show
static int eval_show(struct cy_token *t, struct cy_file *f)
{
	struct cy_token st;

	if (cy_eval_next(f, &st) <= 0)
		return -1;

	return show_value(&st.v, '\n', t);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x42c4
testl %eax, %eax
js 0x50ed
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
je 0x50e2
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x50ce
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *%rax
testl %eax, %eax
jle 0x50e2
leaq 0x20(%rsp), %rdi
movl $0xa, %esi
movq %rbx, %rdx
callq 0x5190
movl %eax, %ebp
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x3535
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/show.c
// Function: eval_print
static int eval_print(struct cy_token *t, struct cy_file *f)
{
	struct cy_token st;

	if (cy_eval_next_x(f, &st, CY_V_STRING) <= 0)
		return -1;

	printf("%s\n", st.v.v_str);
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x42c4
testl %eax, %eax
js 0x518b
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
je 0x517f
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x512e
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
cmpl $0x1, %eax
jne 0x516e
cmpl $0x2, 0x20(%rsp)
je 0x5170
movl $0x2, %edi
callq 0x3bbc
movq %rax, %r14
leaq 0x8(%rsp), %r15
movl 0x18(%r15), %edi
callq 0x3bbc
leaq 0x2ff3(%rip), %rsi      # 0x814f
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
jmp 0x517f
jl 0x517f
movq 0x28(%rsp), %rdi
callq 0x3060
movl $0x1, %ebx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x355a
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/show.c
// Function: show_value
static int show_value(struct cy_value *v, char tc, struct cy_token *st)
{
	switch (v->t) {
	default:
		show_token_err(st, "Can't show %s", vtype2s(v->t));
		return -1;
	case CY_V_NOVALUE:
		printf("NOVALUE%c", tc);
		break;
	case CY_V_NUMBER:
		printf("%li%c", v->v_i, tc);
		break;
	case CY_V_STRING:
		printf("\"%s\"%c", v->v_str, tc);
		break;
	case CY_V_LIST:
		show_list(&v->v_list->h, tc, st);
		break;
	case CY_V_MAP:
		show_map(&v->v_map->r, tc, st);
		break;
	case CY_V_BOOL:
		printf("%s%c", v->v_bool ? "TRUE" : "FALSE", tc);
		break;
	case CY_V_CBLOCK:
		printf("$CBLOCK%c", tc);
		break;
	}

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl (%rdi), %eax
cmpq $0x6, %rax
ja 0x5281
movl %esi, %ebx
leaq 0x30f8(%rip), %rcx      # 0x82a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzbl %bl, %esi
leaq 0x311d(%rip), %rdi      # 0x82e0
jmp 0x52f2
movq 0x8(%rdi), %r15
leaq 0x3145(%rip), %rdi      # 0x8318
xorl %eax, %eax
callq 0x30b0
movq %r15, %rdi
callq 0x7453
testq %rax, %rax
je 0x5228
movq %rax, %r15
leaq 0x312a(%rip), %r12      # 0x831b
movq -0x8(%r15), %rsi
movq %r12, %rdi
xorl %eax, %eax
callq 0x30b0
leaq 0x18(%r15), %rdi
movl $0x20, %esi
movq %r14, %rdx
callq 0x5190
testl %eax, %eax
jle 0x52f9
movq %r15, %rdi
callq 0x7483
movq %rax, %r15
testq %rax, %rax
jne 0x51f1
movzbl %bl, %esi
leaq 0x30ed(%rip), %rdi      # 0x831f
jmp 0x52f2
movq 0x8(%rdi), %rsi
movzbl %bl, %edx
leaq 0x30ab(%rip), %rdi      # 0x82f0
jmp 0x52df
movq 0x8(%rdi), %r15
leaq 0x30bc(%rip), %rdi      # 0x8311
xorl %eax, %eax
callq 0x30b0
movq %r15, %r12
movq 0x8(%r12), %r12
cmpq %r15, %r12
je 0x52e8
leaq 0x10(%r12), %rdi
movl $0x20, %esi
movq %r14, %rdx
callq 0x5190
testl %eax, %eax
jg 0x525f
jmp 0x52f9
movl %eax, %edi
callq 0x3bbc
leaq 0x3043(%rip), %rsi      # 0x82d2
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x52fe
movq 0x8(%rdi), %rsi
movzbl %bl, %edx
leaq 0x3039(%rip), %rdi      # 0x82ea
jmp 0x52df
movzbl %bl, %esi
leaq 0x304a(%rip), %rdi      # 0x8307
jmp 0x52f2
leaq 0x3036(%rip), %rax      # 0x82fc
cmpb $0x0, 0x8(%rdi)
leaq 0x3030(%rip), %rsi      # 0x8301
cmovneq %rax, %rsi
movzbl %bl, %edx
leaq 0x3018(%rip), %rdi      # 0x82f7
xorl %eax, %eax
callq 0x30b0
jmp 0x52f9
movzbl %bl, %esi
leaq 0x3022(%rip), %rdi      # 0x8314
xorl %eax, %eax
callq 0x30b0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/list.c
// Function: cy_list_splice
int cy_list_splice(struct cy_value *l1, struct cy_value *l2, struct cy_value *r)
{
	make_list(r);

	copy_list(&l1->v_list->h, &r->v_list->h);
	copy_list(&l2->v_list->h, &r->v_list->h);

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x3, (%rdx)
movl $0x10, %edi
callq 0x3180
movq %rax, 0x8(%rbx)
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq 0x8(%r15), %rdi
movq %rax, %rsi
callq 0x5359
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x5359
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/list.c
// Function: copy_list
static void copy_list(struct list_head *from, struct list_head *to)
{
	struct cy_list_value *lf, *lt;

	list_for_each_entry(lf, from, l) {
		lt = malloc(sizeof(*lt));
		lt->v = lf->v;
		list_add_tail(&lt->l, to);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r15
cmpq %rdi, %r15
je 0x53a1
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r12
movl $0x20, %edi
callq 0x3180
movups 0x10(%r15), %xmm0
movups %xmm0, 0x10(%rax)
movq %rax, (%rbx)
movq %rbx, 0x8(%rax)
movq %r12, (%rax)
movq %rax, 0x8(%r12)
movq 0x8(%r15), %r15
movq %rax, %r12
cmpq %r14, %r15
jne 0x5373
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/list.c
// Function: cy_list_del
int cy_list_del(struct cy_value *l, struct cy_value *i)
{
	struct cy_list_value *lv;

	if (i->v_i < 0) {
		fprintf(stderr, "List removal should be by positive index\n");
		return -1;
	}

	lv = cy_list_find(l, i->v_i);
	if (lv) {
		list_del_init(&lv->l);
		return 1;
	}

	return -1;
}

// Assembly:
pushq %rax
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
js 0x53fb
movq 0x8(%rdi), %rsi
movq 0x8(%rsi), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rsi, %rcx
je 0x5405
incl %edx
decl %edx
je 0x53da
movq 0x8(%rcx), %rcx
cmpq %rsi, %rcx
jne 0x53cb
jmp 0x5405
testq %rcx, %rcx
je 0x5405
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
movq %rax, (%rdx)
movq %rdx, 0x8(%rax)
movq %rcx, 0x8(%rcx)
movq %rcx, (%rcx)
movl $0x1, %eax
jmp 0x5405
callq 0x357f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/list.c
// Function: dereference_list_elem
int dereference_list_elem(struct cy_token *t, struct cy_value *l, struct cy_value *kv)
{
	struct cy_list_value *lv;
	int n;
	char *end;

	if (kv->t == CY_V_STRING) {
		n = strtol(kv->v_str, &end, 10);
		if (*end != '\0' || n < 0) {
			show_token_err(t, "Bad list index %s", kv->v_str);
			return -1;
		}
	} else if (kv->t == CY_V_NUMBER)
		n = kv->v_i;
	else {
		show_token_err(t, "Bad list deref %s", vtype2s(kv->t));
		return -1;
	}

	lv = cy_list_find(l, n);
	if (lv)
		t->v = lv->v;
	else
		t->v.t = CY_V_NOVALUE;

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdx), %edi
cmpl $0x1, %edi
je 0x545e
cmpl $0x2, %edi
jne 0x5480
movq 0x8(%r15), %rdi
movq %rsp, %r12
movq %r12, %rsi
movl $0xa, %edx
callq 0x3140
movq (%r12), %rcx
cmpb $0x0, (%rcx)
setne %cl
testl %eax, %eax
sets %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x5462
movq 0x8(%r15), %rdx
leaq 0x2ef4(%rip), %rsi      # 0x834d
movq %rbx, %rdi
jmp 0x5492
movl 0x8(%r15), %eax
movq 0x8(%r14), %rdx
movq 0x8(%rdx), %rcx
cmpq %rdx, %rcx
je 0x54af
incl %eax
decl %eax
je 0x54a0
movq 0x8(%rcx), %rcx
cmpq %rdx, %rcx
jne 0x5471
jmp 0x54af
callq 0x3bbc
leaq 0x2ed3(%rip), %rsi      # 0x835f
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x54bb
testq %rcx, %rcx
je 0x54af
movups 0x10(%rcx), %xmm0
movups %xmm0, 0x18(%rbx)
jmp 0x54b6
movl $0x0, 0x18(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/list.c
// Function: eval_list
static int eval_list(struct cy_token *t, struct cy_file *f)
{
	make_list(&t->v);
	list_depth++;
	while (1) {
		struct cy_token vt;
		struct cy_list_value *lv;

		if (cy_eval_next(f, &vt) <= 0) {
			list_depth--;
			return -1;
		}

		if (vt.v.t & CY_V_TERMINATOR) {
			list_depth--;
			if (vt.v.t == CY_V_LIST_END)
				return 1;
			else {
				show_token_err(&vt, "Unexpected terminator");
				return -1;
			}
		}

		lv = malloc(sizeof(*lv));
		lv->v = vt.v;
		list_add_tail(&lv->l, &t->v.v_list->h);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x3, 0x18(%rdi)
movl $0x10, %edi
callq 0x3180
movq %rax, 0x20(%r14)
movq %rax, 0x8(%rax)
movq %rax, (%rax)
incl 0x7c0f(%rip)            # 0xd148
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x42c4
testl %eax, %eax
js 0x55b1
leaq 0x18(%rsp), %r12
movq %rsp, %r15
testl %eax, %eax
je 0x55b6
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x556e
movq %r15, %rdi
movq %rbx, %rsi
callq *%rax
testl %eax, %eax
jle 0x55b6
movl 0x18(%rsp), %ecx
testl $0x70000000, %ecx       # imm = 0x70000000
jne 0x55be
movl $0x20, %edi
callq 0x3180
movups (%r12), %xmm0
movups %xmm0, 0x10(%rax)
movq 0x20(%r14), %rcx
movq (%rcx), %rdx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
movq %rdx, (%rax)
movq %rax, 0x8(%rdx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x42c4
testl %eax, %eax
jns 0x5550
callq 0x359b
decl 0x7b8c(%rip)            # 0xd148
jmp 0x55e2
decl 0x7b84(%rip)            # 0xd148
movl $0x1, %eax
cmpl $0x70000003, %ecx       # imm = 0x70000003
je 0x55e7
leaq 0x2e27(%rip), %rsi      # 0x83ff
movq %rsp, %rdi
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/list.c
// Function: eval_list_add
static int eval_list_add(struct cy_token *t, struct cy_file *f)
{
	struct cy_token lst, vt;
	struct cy_list_value *lv;

	if (cy_eval_next_x(f, &lst, CY_V_LIST) <= 0)
		return -1;

	if (cy_eval_next(f, &vt) <= 0)
		return -1;

	lv = malloc(sizeof(*lv));
	lv->v = vt.v;

	if (t->typ->priv == OP_LIST_HEAD)
		list_add(&lv->l, &lst.v.v_list->h);
	else
		list_add_tail(&lv->l, &lst.v.v_list->h);

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %rsi
movq %r15, %rdi
callq 0x42c4
testl %eax, %eax
js 0x595a
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
je 0x594e
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x5892
movq %rsp, %rdi
movq %r15, %rsi
callq *%rcx
cmpl $0x1, %eax
jne 0x58d0
cmpl $0x3, 0x18(%rsp)
je 0x58d2
movl $0x3, %edi
callq 0x3bbc
movq %rax, %r14
movq %rsp, %r15
movl 0x18(%r15), %edi
callq 0x3bbc
leaq 0x2891(%rip), %rsi      # 0x814f
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
jmp 0x594e
jl 0x594e
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x42c4
testl %eax, %eax
js 0x595f
je 0x594e
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x5901
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq *%rax
testl %eax, %eax
jle 0x594e
movl $0x20, %edi
callq 0x3180
movups 0x40(%rsp), %xmm0
movups %xmm0, 0x10(%rax)
movq 0x8(%r14), %rcx
cmpq $0x1, 0x10(%rcx)
movq 0x20(%rsp), %rcx
jne 0x5938
movq 0x8(%rcx), %rdx
movq %rax, (%rdx)
movq %rdx, 0x8(%rax)
movq %rcx, (%rax)
movq %rax, 0x8(%rcx)
jmp 0x5949
movq (%rcx), %rdx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
movq %rdx, (%rax)
movq %rax, 0x8(%rdx)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x3654
callq 0x362f
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/list.c
// Function: eval_list_pop
static int eval_list_pop(struct cy_token *t, struct cy_file *f)
{
	struct cy_token lst;
	struct cy_list_value *lv;

	if (cy_eval_next_x(f, &lst, CY_V_LIST) <= 0)
		return -1;

	if (list_empty(&lst.v.v_list->h)) {
		t->v.t = CY_V_NOVALUE;
		return 1;
	}

	if (t->typ->priv == OP_LIST_HEAD)
		lv = list_entry(lst.v.v_list->h.next, struct cy_list_value, l);
	else
		lv = list_entry(lst.v.v_list->h.prev, struct cy_list_value, l);

	list_del_init(&lv->l);
	t->v = lv->v;
	free(lv);

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x42c4
testl %eax, %eax
js 0x5a41
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
je 0x5a35
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x59ab
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq *%rcx
cmpl $0x1, %eax
jne 0x59eb
cmpl $0x3, 0x20(%rsp)
je 0x59ed
movl $0x3, %edi
callq 0x3bbc
movq %rax, %r14
leaq 0x8(%rsp), %r15
movl 0x18(%r15), %edi
callq 0x3bbc
leaq 0x2776(%rip), %rsi      # 0x814f
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
jmp 0x5a35
jl 0x5a35
movq 0x28(%rsp), %rax
cmpq %rax, 0x8(%rax)
je 0x5a28
movq 0x8(%r14), %rcx
xorl %edx, %edx
cmpq $0x1, 0x10(%rcx)
sete %dl
movq (%rax,%rdx,8), %rdi
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
movups 0x10(%rdi), %xmm0
movups %xmm0, 0x18(%r14)
callq 0x3030
jmp 0x5a30
movl $0x0, 0x18(%r14)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x3679
nop
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/map.c
// Function: map_add_value
int map_add_value(const char *key, struct cy_value *v, struct rb_root *root, bool upsert)
{
	struct rb_node *node = root->rb_node, *parent = NULL;
	struct rb_node **new = &root->rb_node;
	struct cy_map_value *mv;

	while (node) {
		struct cy_map_value *this;
		int r;

		parent = *new;
		this = rb_entry(node, struct cy_map_value, n);
		r = strcmp(this->key, key);
		if (r == 0) {
			if (!upsert)
				return -1;

			this->v = *v;
			return 0;
		}
		if (r > 0)
			node = node->rb_left, new = &((*new)->rb_left);
		else
			node = node->rb_right, new = &((*new)->rb_right);
	}

	mv = malloc(sizeof(*mv));
	mv->key = key;
	mv->v = *v;

	rb_link_and_balance(root, &mv->n, parent, new);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdx), %r13
testq %r13, %r13
je 0x5a9c
movl %ecx, 0x4(%rsp)
movq %rbx, %r12
movq -0x8(%r13), %rdi
movq %r15, %rsi
callq 0x3110
testl %eax, %eax
je 0x5ae5
movq (%r12), %rbp
setg %al
movzbl %al, %eax
leaq 0x8(,%rax,8), %r12
addq %rbp, %r12
movq 0x8(%r13,%rax,8), %r13
testq %r13, %r13
jne 0x5a6b
jmp 0x5aa1
xorl %ebp, %ebp
movq %rbx, %r12
movl $0x30, %edi
callq 0x3180
movq %r15, (%rax)
movups (%r14), %xmm0
movups %xmm0, 0x20(%rax)
leaq 0x8(%rax), %rdi
movq %rbp, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %rdi, (%r12)
movq %rbx, %rsi
callq 0x7044
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x0, 0x4(%rsp)
je 0x5ad6
movups (%r14), %xmm0
movups %xmm0, 0x18(%r13)
xorl %eax, %eax
jmp 0x5ad6
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/map.c
// Function: find_in_map
struct cy_map_value *find_in_map(struct rb_root *root, const char *key, unsigned klen)
{
	struct rb_node *node = root->rb_node;

	while (node) {
		struct cy_map_value *this;
		int r;

		this = rb_entry(node, struct cy_map_value, n);
		if (klen)
			r = strncmp(this->key, key, klen);
		else
			r = strcmp(this->key, key);
		if (r == 0)
			return this;

		if (r > 0)
			node = node->rb_left;
		else
			node = node->rb_right;
	}

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %r12
testq %r12, %r12
je 0x5b49
movl %edx, %ebp
movq %rsi, %r14
movl %edx, %r15d
xorl %ebx, %ebx
movq -0x8(%r12), %rdi
movq %r14, %rsi
testl %ebp, %ebp
je 0x5b2e
movq %r15, %rdx
callq 0x3050
jmp 0x5b33
callq 0x3110
testl %eax, %eax
je 0x5b4d
setg %al
movzbl %al, %eax
movq 0x8(%r12,%rax,8), %r12
testq %r12, %r12
jne 0x5b18
jmp 0x5b54
xorl %ebx, %ebx
jmp 0x5b54
addq $-0x8, %r12
movq %r12, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/map.c
// Function: dereference_map_elem
int dereference_map_elem(struct cy_token *t, struct cy_value *m, struct cy_value *kv)
{
	struct cy_map_value *mv;

	if (kv->t != CY_V_STRING) {
		show_token_err(t, "Nested map resolve is not a string");
		return -1;
	}

	mv = find_in_map(&m->v_map->r, kv->v_str, 0);
	if (mv)
		t->v = mv->v;
	else
		t->v.t = CY_V_NOVALUE;

	return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x2, (%rdx)
jne 0x5b8a
movq 0x8(%rsi), %rdi
movq 0x8(%rdx), %rsi
xorl %edx, %edx
callq 0x5afe
addq $0x18, %rbx
testq %rax, %rax
je 0x5ba2
movups 0x20(%rax), %xmm0
movups %xmm0, (%rbx)
jmp 0x5ba8
leaq 0x289d(%rip), %rsi      # 0x842e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x5bad
movl $0x0, (%rbx)
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/map.c
// Function: cy_map_del
int cy_map_del(struct cy_value *m, struct cy_value *k)
{
	struct rb_root *root = &m->v_map->r;
	struct cy_map_value *mv;

	mv = find_in_map(root, k->v_str, 0);
	if (!mv)
		return -1;

	rb_erase(&mv->n, root);
	return 1;
}

// Assembly:
pushq %rbx
movq 0x8(%rdi), %rbx
movq 0x8(%rsi), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5afe
testq %rax, %rax
je 0x5bdd
addq $0x8, %rax
movq %rax, %rdi
movq %rbx, %rsi
callq 0x71dc
movl $0x1, %eax
jmp 0x5be2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/map.c
// Function: eval_map
static int eval_map(struct cy_token *t, struct cy_file *f)
{
	make_map(&t->v);
	map_depth++;
	while (1) {
		int ret;
		const char *key;
		struct cy_token vt;

		ret = map_key(f, &key);
		if (ret < 0)
			goto er;
		if (ret == 0) {
			map_depth--;
			return 1;
		}

		if (cy_eval_next(f, &vt) <= 0)
			goto er;

		if (vt.v.t & CY_V_TERMINATOR)
			goto er;

		if (map_add_value(key, &vt.v, &t->v.v_map->r, false) < 0)
			goto er;

		continue;

er:
		show_token_err(t, "Error processing map entry");
		map_depth--;
		return -1;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x4, 0x18(%rdi)
movl $0x8, %edi
callq 0x3180
movq %rax, 0x20(%rbx)
movq $0x0, (%rax)
incl 0x7526(%rip)            # 0xd14c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x42c4
testl %eax, %eax
jle 0x5d2d
leaq 0x48(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x30(%rsp), %r13
movq %r12, %rdi
callq 0x49bf
testb %al, %al
jne 0x5c85
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x5c74
movq %r12, %rdi
movq %r14, %rsi
callq *%rax
testl %eax, %eax
jle 0x5d2d
movl 0x20(%rsp), %edi
testl $0x70000000, %edi       # imm = 0x70000000
jne 0x5cee
cmpl $0x2, %edi
jne 0x5cfd
movq 0x28(%rsp), %rbp
movq %r14, %rdi
movq %r13, %rsi
callq 0x42c4
testl %eax, %eax
js 0x5d58
je 0x5d2d
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x5cbd
movq %r13, %rdi
movq %r14, %rsi
callq *%rax
testl %eax, %eax
jle 0x5d2d
testb $0x70, 0x4b(%rsp)
jne 0x5d2d
movq 0x20(%rbx), %rdx
movq %rbp, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x5a48
testl %eax, %eax
js 0x5d2d
movq %r14, %rdi
movq %r12, %rsi
callq 0x42c4
testl %eax, %eax
jg 0x5c4a
jmp 0x5d2d
cmpl $0x70000004, %edi       # imm = 0x70000004
jne 0x5d1a
movl $0x1, %eax
jmp 0x5d43
callq 0x3bbc
leaq 0x279e(%rip), %rsi      # 0x84a7
leaq 0x8(%rsp), %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3240
jmp 0x5d2d
leaq 0x276c(%rip), %rsi      # 0x848d
leaq 0x8(%rsp), %rdi
xorl %eax, %eax
callq 0x3240
leaq 0x273e(%rip), %rsi      # 0x8472
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
decl 0x7403(%rip)            # 0xd14c
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x369e
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/string.c
// Function: eval_format
static int eval_format(struct cy_token *t, struct cy_file *f)
{
	struct cy_token st;

	if (cy_eval_next_x(f, &st, CY_V_STRING) <= 0)
		return -1;

	return format_string(&st, &t->v);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x42c4
testl %eax, %eax
js 0x5f25
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
je 0x5f14
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x5e0c
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
cmpl $0x1, %eax
jne 0x5e4f
cmpl $0x2, 0x28(%rsp)
je 0x5e55
movl $0x2, %edi
callq 0x3bbc
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movl 0x18(%r14), %edi
callq 0x3bbc
leaq 0x2315(%rip), %rsi      # 0x814f
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
jmp 0x5f14
jl 0x5f14
leaq 0x10(%rsp), %r14
movq 0x20(%r14), %r13
movl $0x2, 0x18(%rbx)
leaq 0x8(%rsp), %r15
movq %r13, %rdi
movl $0x5c, %esi
callq 0x3080
movq %rax, %r12
movq %rax, 0x8(%rsp)
movl %r12d, %esi
subl %r13d, %esi
movq %r13, %rdi
callq 0x62c8
movzbl (%r12), %eax
cmpl $0x5c, %eax
je 0x5e9d
testl %eax, %eax
jne 0x5ebf
jmp 0x5ec7
cmpb $0x28, 0x1(%r12)
jne 0x5ebf
incq %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x631f
testl %eax, %eax
js 0x5ef9
movq 0x8(%rsp), %r12
incq %r12
movq %r12, %r13
jmp 0x5e6a
movq 0x7282(%rip), %rax      # 0xd150
movslq 0x7283(%rip), %rcx      # 0xd158
movb $0x0, (%rax,%rcx)
movq $0x0, 0x726c(%rip) # 0xd150
movl $0x0, 0x726a(%rip)      # 0xd158
movq %rax, 0x20(%rbx)
movl $0x1, %ebp
jmp 0x5f14
movq 0x7250(%rip), %rdi      # 0xd150
callq 0x3030
movl $0x0, 0x7249(%rip)      # 0xd158
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x36c3
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/string.c
// Function: eval_atoi
static int eval_atoi(struct cy_token *t, struct cy_file *f)
{
	struct cy_token st;

	if (cy_eval_next_x(f, &st, CY_V_STRING) <= 0)
		return -1;

	return decode_string(&st, &t->v);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %rsi
movq %r15, %rdi
callq 0x42c4
testl %eax, %eax
js 0x5ffe
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
je 0x5ff2
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x5f6d
movq %rsp, %rdi
movq %r15, %rsi
callq *%rcx
cmpl $0x1, %eax
jne 0x5fab
cmpl $0x2, 0x18(%rsp)
je 0x5fad
movl $0x2, %edi
callq 0x3bbc
movq %rax, %r14
movq %rsp, %r15
movl 0x18(%r15), %edi
callq 0x3bbc
leaq 0x21b6(%rip), %rsi      # 0x814f
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
jmp 0x5ff2
jl 0x5ff2
movl $0x1, 0x18(%r14)
movq 0x20(%rsp), %rdi
leaq 0x28(%rsp), %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3140
movq %rax, 0x20(%r14)
movq (%rbx), %rax
cmpb $0x0, (%rax)
je 0x5fed
leaq 0x2569(%rip), %rsi      # 0x8545
movq %rsp, %rdi
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x5ff2
movl $0x1, %ebx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x36e8
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/string.c
// Function: eval_split
static int eval_split(struct cy_token *t, struct cy_file *f)
{
	struct cy_token st;

	if (cy_eval_next_x(f, &st, CY_V_STRING) <= 0)
		return -1;

	return split_string(st.v.v_str, &t->v);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rsi
movq %r14, %rdi
callq 0x42c4
testl %eax, %eax
js 0x6157
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
je 0x6146
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x604b
movq %rsp, %rdi
movq %r14, %rsi
callq *%rcx
cmpl $0x1, %eax
jne 0x608c
cmpl $0x2, 0x18(%rsp)
je 0x6092
movl $0x2, %edi
callq 0x3bbc
movq %rax, %rbx
movq %rsp, %r14
movl 0x18(%r14), %edi
callq 0x3bbc
leaq 0x20d8(%rip), %rsi      # 0x814f
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
jmp 0x6146
jl 0x6146
movq 0x20(%rsp), %r14
movl $0x3, 0x18(%rbx)
movl $0x10, %edi
callq 0x3180
movq %rax, 0x20(%rbx)
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movabsq $0x100000601, %r13      # imm = 0x100000601
movzbl (%r14), %eax
leal -0x9(%rax), %ecx
cmpl $0x2, %ecx
jb 0x6139
cmpl $0x20, %eax
je 0x6139
testl %eax, %eax
je 0x6141
xorl %r15d, %r15d
movzbl 0x1(%r14,%r15), %eax
incq %r15
cmpq $0x20, %rax
ja 0x60d5
btq %rax, %r13
jae 0x60d5
movl $0x20, %edi
callq 0x3180
movq %rax, %r12
movl $0x2, 0x10(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x30f0
movq %rax, 0x18(%r12)
movq 0x20(%rbx), %rax
movq (%rax), %rcx
movq %r12, (%rax)
movq %rax, 0x8(%r12)
movq %rcx, (%r12)
movq %r12, 0x8(%rcx)
leaq (%r14,%r15), %rax
incq %rax
addq %r15, %r14
cmpb $0x0, -0x1(%rax)
cmovneq %rax, %r14
jmp 0x60bd
incq %r14
jmp 0x60bd
movl $0x1, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x370d
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/string.c
// Function: eval_chk_match
static int eval_chk_match(struct cy_token *t, struct cy_file *f)
{
	struct cy_token st, pt;
	unsigned len;

	if (cy_eval_next_x(f, &st, CY_V_STRING) <= 0)
		return -1;
	if (cy_eval_next_x(f, &pt, CY_V_STRING) <= 0)
		return -1;

	len = strlen(pt.v.v_str);
	t->v.t = CY_V_BOOL;

	if (t->typ->priv == OP_CHK_PREFIX)
		t->v.v_bool = (strncmp(st.v.v_str, pt.v.v_str, len) == 0);
	else {
		unsigned slen;

		slen = strlen(st.v.v_str);
		if (slen < len)
			t->v.v_bool = false;
		else
			t->v.v_bool = (strcmp(st.v.v_str + slen - len, pt.v.v_str) == 0);
	}

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x42c4
testl %eax, %eax
js 0x62be
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
je 0x62b0
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x61a5
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq *%rcx
cmpl $0x1, %eax
jne 0x61c5
cmpl $0x2, 0x20(%rsp)
je 0x61cb
movl $0x2, %edi
callq 0x3bbc
movq %rax, %r14
leaq 0x8(%rsp), %r15
jmp 0x621c
jl 0x62b0
leaq 0x30(%rsp), %rsi
movq %r15, %rdi
callq 0x42c4
testl %eax, %eax
js 0x62c3
je 0x62b0
movq 0x38(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x61fe
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq *%rcx
cmpl $0x1, %eax
jne 0x623e
cmpl $0x2, 0x48(%rsp)
je 0x6240
movl $0x2, %edi
callq 0x3bbc
movq %rax, %r14
leaq 0x30(%rsp), %r15
movl 0x18(%r15), %edi
callq 0x3bbc
leaq 0x1f23(%rip), %rsi      # 0x814f
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
jmp 0x62b0
jl 0x62b0
movq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0x3090
movq %rax, %r15
movl $0x6, 0x18(%r14)
movq 0x8(%r14), %rax
cmpq $0x1, 0x10(%rax)
jne 0x6275
movq 0x28(%rsp), %rdi
movl %r15d, %edx
movq %rbx, %rsi
callq 0x3050
jmp 0x62a4
movq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x3090
cmpl %r15d, %eax
jae 0x628e
movb $0x0, 0x20(%r14)
jmp 0x62ab
movl %eax, %eax
addq %rax, %r12
movl %r15d, %eax
subq %rax, %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3110
testl %eax, %eax
sete 0x20(%r14)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x3757
callq 0x3732