LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x6, %rax
ja 0x577a
movq -0x28(%rbp), %rax
leaq 0x5b23(%rip), %rcx      # 0xb294
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x3400
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x5b23(%rip), %rsi      # 0xb2be
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x587b
movsbl -0x11(%rbp), %esi
leaq 0x5b13(%rip), %rdi      # 0xb2cc
movb $0x0, %al
callq 0x30a0
jmp 0x5874
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movsbl -0x11(%rbp), %edx
leaq 0x5afe(%rip), %rdi      # 0xb2d6
movb $0x0, %al
callq 0x30a0
jmp 0x5874
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movsbl -0x11(%rbp), %edx
leaq 0x5ae5(%rip), %rdi      # 0xb2dc
movb $0x0, %al
callq 0x30a0
jmp 0x5874
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movb -0x11(%rbp), %al
movq -0x20(%rbp), %rdx
movsbl %al, %esi
callq 0x5890
jmp 0x5874
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movb -0x11(%rbp), %al
movq -0x20(%rbp), %rdx
movsbl %al, %esi
callq 0x5950
jmp 0x5874
movq -0x10(%rbp), %rax
movb 0x8(%rax), %cl
leaq 0x5aad(%rip), %rsi      # 0xb2ed
leaq 0x5aa1(%rip), %rax      # 0xb2e8
testb $0x1, %cl
cmovneq %rax, %rsi
movsbl -0x11(%rbp), %edx
leaq 0x5a8a(%rip), %rdi      # 0xb2e3
movb $0x0, %al
callq 0x30a0
jmp 0x5874
movsbl -0x11(%rbp), %esi
leaq 0x5a86(%rip), %rdi      # 0xb2f3
movb $0x0, %al
callq 0x30a0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/show.c
// Function: show_list
static int show_list(struct list_head *h, char tc, struct cy_token *st)
{
	struct cy_list_value *lv;
	int ret;

	printf("( ");
	list_for_each_entry(lv, h, l) {
		ret = show_value(&lv->v, ' ', st);
		if (ret <= 0)
			return ret;
	}
	printf(")%c", tc);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x5a50(%rip), %rdi      # 0xb2fd
movb $0x0, %al
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x5921
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movq -0x20(%rbp), %rdx
movl $0x20, %esi
callq 0x5740
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jg 0x5901
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x593a
jmp 0x5903
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x58d0
movsbl -0x11(%rbp), %esi
leaq 0x59d4(%rip), %rdi      # 0xb300
movb $0x0, %al
callq 0x30a0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/show.c
// Function: show_map
static int show_map(struct rb_root *r, char tc, struct cy_token *st)
{
	struct rb_node *n;
	int ret;

	printf("[ ");
	for (n = rb_first(r); n != NULL; n = rb_next(n)) {
		struct cy_map_value *mv;

		mv = rb_entry(n, struct cy_map_value, n);
		printf("%s ", mv->key);
		ret = show_value(&mv->v, ' ', st);
		if (ret <= 0)
			return ret;
	}
	printf("]%c", tc);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x5997(%rip), %rdi      # 0xb304
movb $0x0, %al
callq 0x30a0
movq -0x10(%rbp), %rdi
callq 0x8fa0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x59f1
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rsi
leaq 0x5955(%rip), %rdi      # 0xb307
movb $0x0, %al
callq 0x30a0
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
movq -0x20(%rbp), %rdx
movl $0x20, %esi
callq 0x5740
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jg 0x59e0
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5a0a
jmp 0x59e2
movq -0x28(%rbp), %rdi
callq 0x9040
movq %rax, -0x28(%rbp)
jmp 0x5981
movsbl -0x11(%rbp), %esi
leaq 0x590f(%rip), %rdi      # 0xb30b
movb $0x0, %al
callq 0x30a0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5b00
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x5b40
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x5b40
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x5bc7
movl $0x20, %edi
callq 0x3170
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5f00
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x5b6c
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jge 0x5c0c
movq 0x9406(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x5717(%rip), %rsi      # 0xb313
movb $0x0, %al
callq 0x3110
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5c43
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %esi
callq 0x5c50
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5c3c
movq -0x20(%rbp), %rdi
callq 0x5ce0
movl $0x1, -0x4(%rbp)
jmp 0x5c43
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/list.c
// Function: cy_list_find
static struct cy_list_value *cy_list_find(struct cy_value *lst, int idx)
{
	struct cy_list_value *lv;

	list_for_each_entry(lv, &lst->v_list->h, l) {
		if (idx-- != 0)
			continue;

		return lv;
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq %rcx, %rax
je 0x5cc6
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0x5c9e
jmp 0x5ca8
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5cce
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x5c7b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x5d80
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x38(%rbp), %rsi
movl $0xa, %edx
callq 0x3130
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x5d58
cmpl $0x0, -0x2c(%rbp)
jge 0x5d7e
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x55d2(%rip), %rsi      # 0xb33d
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5e0c
jmp 0x5dc9
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x5d96
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, -0x2c(%rbp)
jmp 0x5dc7
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
callq 0x3400
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0x5598(%rip), %rsi      # 0xb34f
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5e0c
jmp 0x5dc9
movq -0x18(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x5c50
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5dfa
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x20(%rax)
jmp 0x5e05
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/list.c
// Function: check_in_list
bool check_in_list(struct cy_list *l, struct cy_value *v)
{
	struct cy_list_value *lv;

	list_for_each_entry(lv, &l->h, l)
		if (cy_compare(v, &lv->v))
			return true;

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq %rcx, %rax
je 0x5e96
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
callq 0x7a60
testb $0x1, %al
jne 0x5e70
jmp 0x5e76
movb $0x1, -0x1(%rbp)
jmp 0x5e9a
jmp 0x5e78
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x5e4c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x5b00
movl 0xa1a5(%rip), %eax      # 0x10198
addl $0x1, %eax
movl %eax, 0xa19c(%rip)      # 0x10198
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x64a0
cmpl $0x0, %eax
jg 0x6029
movl 0xa184(%rip), %eax      # 0x10198
addl $-0x1, %eax
movl %eax, 0xa17b(%rip)      # 0x10198
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x60aa
movl -0x28(%rbp), %eax
andl $0x70000000, %eax       # imm = 0x70000000
cmpl $0x0, %eax
je 0x6072
movl 0xa15c(%rip), %eax      # 0x10198
addl $-0x1, %eax
movl %eax, 0xa153(%rip)      # 0x10198
cmpl $0x70000003, -0x28(%rbp) # imm = 0x70000003
jne 0x6057
movl $0x1, -0x4(%rbp)
jmp 0x60aa
leaq -0x40(%rbp), %rdi
leaq 0x538d(%rip), %rsi      # 0xb3ef
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x60aa
movl $0x20, %edi
callq 0x3170
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x5f00
jmp 0x5ffc
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/list.c
// Function: eval_list_end
static int eval_list_end(struct cy_token *t, struct cy_file *f)
{
	if (list_depth > 0) {
		t->v.t = CY_V_LIST_END;
		return 1;
	}

	show_token_err(t, "Dangling list terminator");
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpl $0x0, 0xa0c1(%rip)      # 0x10198
jbe 0x60ed
movq -0x10(%rbp), %rax
movl $0x70000003, 0x18(%rax) # imm = 0x70000003
movl $0x1, -0x4(%rbp)
jmp 0x6106
movq -0x10(%rbp), %rdi
leaq 0x530d(%rip), %rsi      # 0xb405
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/list.c
// Function: eval_list_cut
static int eval_list_cut(struct cy_token *t, struct cy_file *f)
{
	int i, from, to;
	struct cy_token lht, ct;
	struct cy_list_value *lv;

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

	if (cy_eval_next_x(f, &ct, CY_V_NUMBER) <= 0)
		return -1;

	if (t->typ->priv == OP_CUT_BOTH) {
		struct cy_token ct2;

		if (cy_eval_next_x(f, &ct2, CY_V_NUMBER) <= 0)
			return -1;

		from = ct.v.v_i;
		to = ct2.v.v_i;
	} else if (t->typ->priv == OP_CUT_HEAD) {
		from = ct.v.v_i;
		to = 0x7fffffff;
	} else {
		from = 0;
		to = ct.v.v_i;
	}

	make_list(&t->v);

	i = 0;
	list_for_each_entry(lv, &lht.v.v_list->h, l) {
		struct cy_list_value *nv;

		if (i < from) {
			i++;
			continue;
		}

		if (i >= to)
			break;

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

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x3, %edx
callq 0x6520
cmpl $0x0, %eax
jg 0x6176
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x62f7
movq -0x18(%rbp), %rdi
leaq -0x78(%rbp), %rsi
movl $0x1, %edx
callq 0x6520
cmpl $0x0, %eax
jg 0x6199
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x62f7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x3, 0x10(%rax)
jne 0x61e1
movq -0x18(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
movl $0x1, %edx
callq 0x6520
cmpl $0x0, %eax
jg 0x61ce
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x62f7
movq -0x58(%rbp), %rax
movl %eax, -0x20(%rbp)
movq -0x88(%rbp), %rax
movl %eax, -0x24(%rbp)
jmp 0x6210
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x1, 0x10(%rax)
jne 0x6200
movq -0x58(%rbp), %rax
movl %eax, -0x20(%rbp)
movl $0x7fffffff, -0x24(%rbp) # imm = 0x7FFFFFFF
jmp 0x620e
movl $0x0, -0x20(%rbp)
movq -0x58(%rbp), %rax
movl %eax, -0x24(%rbp)
jmp 0x6210
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x5b00
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq %rcx, %rax
je 0x62f0
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x6270
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x62c3
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jl 0x627a
jmp 0x62f0
movl $0x20, %edi
callq 0x3170
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rax
movq -0x80(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0xc0(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x5f00
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x80(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0xd0(%rbp), %rax
movq %rax, -0x80(%rbp)
jmp 0x624c
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x3, %edx
callq 0x6520
cmpl $0x0, %eax
jg 0x6340
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x63af
movq -0x18(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x64a0
cmpl $0x0, %eax
jg 0x635b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x63af
movl $0x20, %edi
callq 0x3170
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x1, 0x10(%rax)
jne 0x639b
movq -0x70(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x65a0
jmp 0x63a8
movq -0x70(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5f00
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x3, %edx
callq 0x6520
cmpl $0x0, %eax
jg 0x63f3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x648e
movq -0x20(%rbp), %rdi
callq 0x65d0
cmpl $0x0, %eax
je 0x6415
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x648e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x1, 0x10(%rax)
jne 0x6442
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x645d
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x5ce0
movq -0x10(%rbp), %rax
movq -0x48(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq -0x48(%rbp), %rdi
callq 0x3030
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x66e9
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3100
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
jne 0x66a6
testb $0x1, -0x21(%rbp)
jne 0x6683
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6739
movq -0x50(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x20(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x28(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x6739
cmpl $0x0, -0x54(%rbp)
jle 0x66c9
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rax
movq %rax, -0x40(%rbp)
jmp 0x66e4
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
jmp 0x6626
movl $0x30, %edi
callq 0x3170
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x20(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x8, %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0x6750
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x683d
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x67f5
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x3050
movl %eax, -0x34(%rbp)
jmp 0x6808
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3100
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x6818
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6845
cmpl $0x0, -0x34(%rbp)
jle 0x682c
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x6838
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x67ae
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
je 0x6888
movq -0x10(%rbp), %rdi
leaq 0x4ba6(%rip), %rsi      # 0xb41e
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x68d6
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
xorl %edx, %edx
callq 0x6790
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x68c4
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x20(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x28(%rcx), %rcx
movq %rcx, 0x20(%rax)
jmp 0x68cf
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
xorl %edx, %edx
callq 0x6790
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x6923
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x693b
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0x89f0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x6b10
movl 0x97c9(%rip), %eax      # 0x1019c
addl $0x1, %eax
movl %eax, 0x97c0(%rip)      # 0x1019c
movq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6b60
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x69f4
jmp 0x6a59
cmpl $0x0, -0x1c(%rbp)
jne 0x6a12
movl 0x979c(%rip), %eax      # 0x1019c
addl $-0x1, %eax
movl %eax, 0x9793(%rip)      # 0x1019c
movl $0x1, -0x4(%rbp)
jmp 0x6a81
movq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x6c70
cmpl $0x0, %eax
jg 0x6a26
jmp 0x6a59
movl -0x38(%rbp), %eax
andl $0x70000000, %eax       # imm = 0x70000000
cmpl $0x0, %eax
je 0x6a35
jmp 0x6a59
movq -0x28(%rbp), %rdi
leaq -0x50(%rbp), %rsi
addq $0x18, %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
xorl %ecx, %ecx
callq 0x65f0
cmpl $0x0, %eax
jge 0x6a57
jmp 0x6a59
jmp 0x69dc
movq -0x10(%rbp), %rdi
leaq 0x49fe(%rip), %rsi      # 0xb462
movb $0x0, %al
callq 0x3310
movl 0x972b(%rip), %eax      # 0x1019c
addl $-0x1, %eax
movl %eax, 0x9722(%rip)      # 0x1019c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/map.c
// Function: eval_map_end
static int eval_map_end(struct cy_token *t, struct cy_file *f)
{
	if (map_depth > 0) {
		t->v.t = CY_V_MAP_END;
		return 1;
	}

	show_token_err(t, "Dangling map terminator");
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpl $0x0, 0x96f5(%rip)      # 0x1019c
jbe 0x6abd
movq -0x10(%rbp), %rax
movl $0x70000004, 0x18(%rax) # imm = 0x70000004
movl $0x1, -0x4(%rbp)
jmp 0x6ad6
movq -0x10(%rbp), %rdi
leaq 0x49f2(%rip), %rsi      # 0xb4ba
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/map.c
// Function: map_key
static int map_key(struct cy_file *f, const char **keyp)
{
	int ret;
	struct cy_token kt;

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

	/*
	 * Symbols as keys are accepted as is, w/o derefernece,
	 * for simplicity and nicety in declaring objects. To
	 * push dereferenced string as key use + operator.
	 */

	if (is_symbol_token(&kt)) {
		*keyp = kt.v.v_sym;
		return 1;
	}

	if (kt.typ->eval) {
		ret = kt.typ->eval(&kt, f);
		if (ret <= 0)
			return -1;
	}

	if (kt.v.t & CY_V_TERMINATOR) {
		if (kt.v.t == CY_V_MAP_END)
			return 0;
		else {
			show_token_err(&kt, "Unexpected map terminator");
			return -1;
		}
	}

	if (kt.v.t != CY_V_STRING) {
		show_token_err(&kt, "Expected string as map key, got %s", vtype2s(kt.v.t));
		return -1;
	}

	*keyp = kt.v.v_str;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3e30
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0x6b92
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6c61
leaq -0x48(%rbp), %rdi
callq 0x4ae0
testb $0x1, %al
jne 0x6ba1
jmp 0x6bb8
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x6c61
movq -0x40(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6be9
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq *%rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0x6be7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6c61
jmp 0x6be9
movl -0x30(%rbp), %eax
andl $0x70000000, %eax       # imm = 0x70000000
cmpl $0x0, %eax
je 0x6c23
cmpl $0x70000004, -0x30(%rbp) # imm = 0x70000004
jne 0x6c08
movl $0x0, -0x4(%rbp)
jmp 0x6c61
leaq -0x48(%rbp), %rdi
leaq 0x486a(%rip), %rsi      # 0xb47d
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6c61
cmpl $0x2, -0x30(%rbp)
je 0x6c4f
movl -0x30(%rbp), %edi
callq 0x3400
movq %rax, %rdx
leaq -0x48(%rbp), %rdi
leaq 0x4858(%rip), %rsi      # 0xb497
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6c61
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x2, %edx
callq 0x6f00
cmpl $0x0, %eax
jg 0x6e33
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6ef7
movq -0x18(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movl $0x2, %edx
callq 0x6f00
cmpl $0x0, %eax
jg 0x6e56
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6ef7
movq -0x48(%rbp), %rdi
callq 0x3080
movl %eax, -0x6c(%rbp)
movq -0x10(%rbp), %rax
movl $0x6, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x1, 0x10(%rax)
jne 0x6ea0
movq -0x20(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl -0x6c(%rbp), %eax
movl %eax, %edx
callq 0x3050
cmpl $0x0, %eax
sete %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
jmp 0x6ef0
movq -0x20(%rbp), %rdi
callq 0x3080
movl %eax, -0x70(%rbp)
movl -0x70(%rbp), %eax
cmpl -0x6c(%rbp), %eax
jae 0x6ebe
movq -0x10(%rbp), %rax
movb $0x0, 0x20(%rax)
jmp 0x6eee
movq -0x20(%rbp), %rdi
movl -0x70(%rbp), %eax
addq %rax, %rdi
movl -0x6c(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movq -0x48(%rbp), %rsi
callq 0x3100
cmpl $0x0, %eax
sete %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
jmp 0x6ef0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/string.c
// Function: format_string
static int format_string(struct cy_token *st, struct cy_value *sv)
{
	const char *s = st->v.v_str;
	char *aux;

	sv->t = CY_V_STRING;

	while (1) {
		aux = strchrnul(s, '\\');
		append_buf(s, aux - s);

		if (*aux == '\0')
			break;

		if (aux[0] == '\\' && aux[1] == '(') {
			if (format_one(aux + 1, &aux, st) < 0) {
				drop_buf();
				return -1;
			}
		}

		s = aux + 1;
	}

	sv->v_str = fixup_buf();
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movq -0x20(%rbp), %rdi
movl $0x5c, %esi
callq 0x3070
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movl %eax, %esi
callq 0x70d0
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x6fdc
jmp 0x7030
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x701f
movq -0x28(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x28, %eax
jne 0x701f
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
movq -0x10(%rbp), %rdx
leaq -0x28(%rbp), %rsi
callq 0x7140
cmpl $0x0, %eax
jge 0x701d
callq 0x7320
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7047
jmp 0x701f
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6fa6
callq 0x7340
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/string.c
// Function: fixup_buf
static char *fixup_buf(void)
{
	char *ret = fmt_tmp_buf;

	ret[tmp_buf_len] = '\0';
	fmt_tmp_buf = NULL;
	tmp_buf_len = 0;

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8e55(%rip), %rax      # 0x101a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movslq 0x8e4e(%rip), %rcx      # 0x101a8
movb $0x0, (%rax,%rcx)
movq $0x0, 0x8e37(%rip) # 0x101a0
movl $0x0, 0x8e35(%rip)      # 0x101a8
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/string.c
// Function: decode_string
static int decode_string(struct cy_token *st, struct cy_value *v)
{
	char *end;

	v->t = CY_V_NUMBER;
	v->v_i = strtol(st->v.v_str, &end, 0);
	if (*end != '\0') {
		show_token_err(st, "Not a number");
		return -1; /* XXX -- errors */
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
leaq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x3130
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x73df
movq -0x10(%rbp), %rdi
leaq 0x4166(%rip), %rsi      # 0xb535
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x73e6
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/string.c
// Function: split_string
static int split_string(const char *str, struct cy_value *v)
{
	const char *aux = NULL;

	make_list(v);

	while (*str != '\0') {
		if (is_space_at(str)) {
			str++;
			continue;
		}

		aux = str + 1;
		while (*aux != '\0') {
			if (!is_space_at(aux)) {
				aux++;
				continue;
			}

			break;
		}

		{
			struct cy_list_value *lv;

			lv = malloc(sizeof(*lv));
			lv->v.t = CY_V_STRING;
			lv->v.v_str = strndup(str, aux - str);

			list_add_tail(&lv->l, &v->v_list->h);
		}

		if (*aux != '\0')
			str = aux + 1;
		else
			str = aux;
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x74f0
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x74e3
movq -0x8(%rbp), %rdi
callq 0x7530
testb $0x1, %al
jne 0x7430
jmp 0x743e
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x7411
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x7473
movq -0x18(%rbp), %rdi
callq 0x7530
testb $0x1, %al
jne 0x7471
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x744a
jmp 0x7473
movl $0x20, %edi
callq 0x3170
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x2, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
subq %rax, %rsi
callq 0x30e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x7580
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x74d6
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x74de
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7411
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/cblock.c
// Function: cy_call_cblock
int cy_call_cblock(struct cy_token *ct, struct cy_file *f, struct cy_value *rv)
{
	int ret;
	struct cy_cblock *c_list;
	struct cy_ctoken *c_nxt;

	c_list = f->main;
	c_nxt = f->nxt;
	init_tokenizer(f, ct->v.v_cblk);

	while (1) {
		struct cy_token t = {};

		ret = cy_eval_next(f, &t);
		if (ret == 1) {
			if (ct->typ->priv == OP_CBLOCK_SHORT)
				ret = 2;
			else
				continue;
		}
		if (ret == 0)
			ret = 1;
		if (ret == 2)
			*rv = t.v;
		break;
	}

	f->main = c_list;
	f->nxt = c_nxt;

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x3da0
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x30b0
movq -0x10(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x76f0
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0x76a2
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x70000005, 0x10(%rax) # imm = 0x70000005
jne 0x769e
movl $0x2, -0x1c(%rbp)
jmp 0x76a0
jmp 0x765d
jmp 0x76a2
cmpl $0x0, -0x1c(%rbp)
jne 0x76af
movl $0x1, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
jne 0x76c8
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x76ca
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movl -0x1c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/cblock.c
// Function: eval_call
static int eval_call(struct cy_token *t, struct cy_file *f)
{
	int ret;
	struct cy_token ct, mt;
	struct cy_value os = { .t = CY_V_NOVALUE };

	if (cy_eval_next_x(f, &ct, CY_V_CBLOCK) <= 0)
		return -1;
	if (cy_eval_next_x(f, &mt, CY_V_MAP) <= 0)
		return -1;

	if (mt.v.v_map != symbols.v_map) {
		os = symbols;
		symbols = mt.v;
	}

	ret = cy_call_cblock(&ct, f, &t->v);
	if (os.t != CY_V_NOVALUE)
		symbols = os;
	if (ret < 0)
		return ret;

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30b0
movq -0x18(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movl $0x5, %edx
callq 0x79e0
cmpl $0x0, %eax
jg 0x7826
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x78cf
movq -0x18(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl $0x4, %edx
callq 0x79e0
cmpl $0x0, %eax
jg 0x7849
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x78cf
movq -0x50(%rbp), %rax
leaq 0x8934(%rip), %rcx      # 0x10188
cmpq 0x8(%rcx), %rax
je 0x7886
leaq 0x8927(%rip), %rax      # 0x10188
movq (%rax), %rcx
movq %rcx, -0x80(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x78(%rbp)
leaq 0x8911(%rip), %rax      # 0x10188
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x18, %rdx
leaq -0x48(%rbp), %rdi
callq 0x7620
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x80(%rbp)
je 0x78ba
leaq 0x88dd(%rip), %rax      # 0x10188
movq -0x80(%rbp), %rcx
movq %rcx, (%rax)
movq -0x78(%rbp), %rcx
movq %rcx, 0x8(%rax)
cmpl $0x0, -0x1c(%rbp)
jge 0x78c8
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x78cf
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/cblock.c
// Function: eval_return
static int eval_return(struct cy_token *t, struct cy_file *f)
{
	struct cy_token rt;

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

	t->v = rt.v;
	return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x76f0
cmpl $0x0, %eax
jg 0x790b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7926
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/cblock.c
// Function: eval_value_return
static int eval_value_return(struct cy_token *t, struct cy_file *f)
{
	struct cy_token rt;

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

	if (rt.v.t == CY_V_NOVALUE)
		return 1;

	t->v = rt.v;
	return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x76f0
cmpl $0x0, %eax
jg 0x795b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7985
cmpl $0x0, -0x28(%rbp)
jne 0x796a
movl $0x1, -0x4(%rbp)
jmp 0x7985
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/cond.c
// Function: cy_compare
bool cy_compare(struct cy_value *v1, struct cy_value *v2)
{
	int cr;

	if (v1->t != v2->t)
		return false;

	if (cy_compare_t(v1, v2, &cr) < 0)
		return false;

	return cr == 0 ? true : false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x7a84
movb $0x0, -0x1(%rbp)
jmp 0x7abb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x7ad0
cmpl $0x0, %eax
jge 0x7aa0
movb $0x0, -0x1(%rbp)
jmp 0x7abb
movl -0x1c(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/cond.c
// Function: cy_compare_t
static int cy_compare_t(struct cy_value *v1, struct cy_value *v2, int *cr)
{
	switch (v1->t) {
	case CY_V_NUMBER:
		*cr = v1->v_i - v2->v_i;
		return 0;
	case CY_V_STRING:
		*cr = strcmp(v1->v_str, v2->v_str);
		return 0;
	default:
		return -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x1, %eax
je 0x7afe
jmp 0x7af4
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x7b1f
jmp 0x7b45
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
subq 0x8(%rcx), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x7b4c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3100
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x7b4c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/cond.c
// Function: eval_compare
static int eval_compare(struct cy_token *t, struct cy_file *f)
{
	int cr;
	struct cy_token a, b;

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

	t->v.t = CY_V_BOOL;
	if (cy_compare_t(&a.v, &b.v, &cr) < 0) {
		show_token_err(t, "Comparison of %ss not possible", vtype2s(a.v.t));
		return -1;
	}

	switch (t->typ->priv) {
	case OP_EQ: t->v.v_bool = (cr == 0); break;
	case OP_NE: t->v.v_bool = (cr != 0); break;
	case OP_GT: t->v.v_bool = (cr >  0); break;
	case OP_GE: t->v.v_bool = (cr >= 0); break;
	case OP_LT: t->v.v_bool = (cr <  0); break;
	case OP_LE: t->v.v_bool = (cr <= 0); break;
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x7ed0
cmpl $0x0, %eax
jg 0x7bb1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7cd4
movq -0x18(%rbp), %rdi
movl -0x30(%rbp), %edx
leaq -0x70(%rbp), %rsi
callq 0x7f50
cmpl $0x0, %eax
jg 0x7bd2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7cd4
movq -0x10(%rbp), %rax
movl $0x6, 0x18(%rax)
leaq -0x48(%rbp), %rdi
addq $0x18, %rdi
leaq -0x70(%rbp), %rsi
addq $0x18, %rsi
leaq -0x1c(%rbp), %rdx
callq 0x7ad0
cmpl $0x0, %eax
jge 0x7c2c
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x30(%rbp), %edi
callq 0x3400
movq -0x78(%rbp), %rdi
movq %rax, %rdx
leaq 0x39ea(%rip), %rsi      # 0xb603
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7cd4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
decq %rax
movq %rax, -0x80(%rbp)
subq $0x5, %rax
ja 0x7ccd
movq -0x80(%rbp), %rax
leaq 0x396c(%rip), %rcx      # 0xb5c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x0, -0x1c(%rbp)
sete %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
jmp 0x7ccd
cmpl $0x0, -0x1c(%rbp)
setne %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
jmp 0x7ccd
cmpl $0x0, -0x1c(%rbp)
setg %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
jmp 0x7ccd
cmpl $0x0, -0x1c(%rbp)
setge %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
jmp 0x7ccd
cmpl $0x0, -0x1c(%rbp)
setl %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
jmp 0x7ccd
cmpl $0x0, -0x1c(%rbp)
setle %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq