LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x54bd
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 0x548f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rcx
testq %rcx, %rcx
js 0x5512
movq 0x8(%rdi), %rdx
movq 0x8(%rdx), %rax
cmpq %rdx, %rax
je 0x54ef
incl %ecx
decl %ecx
je 0x54f1
movq 0x8(%rax), %rax
cmpq %rdx, %rax
jne 0x54e2
xorl %eax, %eax
testq %rax, %rax
je 0x5517
movq (%rax), %rcx
movq 0x8(%rax), %rdx
movq %rcx, (%rdx)
movq %rdx, 0x8(%rcx)
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movl $0x1, %eax
jmp 0x551c
callq 0x35b2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5575
cmpl $0x2, %edi
jne 0x55a9
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 0x5579
movq 0x8(%r15), %rdx
leaq 0x3de5(%rip), %rsi      # 0x9355
movq %rbx, %rdi
jmp 0x55bb
movl 0x8(%r15), %eax
movq 0x8(%r14), %rdx
movq 0x8(%rdx), %rcx
cmpq %rdx, %rcx
je 0x5595
incl %eax
decl %eax
je 0x5597
movq 0x8(%rcx), %rcx
cmpq %rdx, %rcx
jne 0x5588
xorl %ecx, %ecx
addq $0x18, %rbx
testq %rcx, %rcx
je 0x55c9
movups 0x10(%rcx), %xmm0
movups %xmm0, (%rbx)
jmp 0x55cf
callq 0x3bfc
leaq 0x3db2(%rip), %rsi      # 0x9367
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x55d4
movl $0x0, (%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
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)
incl 0x8af6(%rip)            # 0xe148
movq %rax, (%rax)
leaq 0x18(%rsp), %r13
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x42fd
testl %eax, %eax
js 0x571f
je 0x568a
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x568c
movq %r15, %rdi
movq %rbx, %rsi
callq *%rcx
jmp 0x568c
xorl %eax, %eax
testl %eax, %eax
jle 0x56af
movl 0x18(%rsp), %eax
testl $0x70000000, %eax       # imm = 0x70000000
je 0x56bf
decl 0x8aa7(%rip)            # 0xe148
cmpl $0x70000003, %eax       # imm = 0x70000003
jne 0x56ec
movl $0x1, %ebp
jmp 0x56ba
decl 0x8a93(%rip)            # 0xe148
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %r12d, %r12d
jmp 0x5705
movl $0x20, %edi
callq 0x3180
movups (%r13), %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)
movb $0x1, %r12b
jmp 0x5705
xorl %r12d, %r12d
movq %r15, %rdi
leaq 0x3d0e(%rip), %rsi      # 0x9407
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testb %r12b, %r12b
jne 0x565d
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x35ce
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x5b05
je 0x5a19
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x5a1b
movq %rsp, %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x5a1b
xorl %eax, %eax
cmpl $0x1, %eax
jne 0x5a62
movl $0x1, %eax
cmpl $0x3, 0x18(%rsp)
je 0x5a62
movl $0x3, %edi
callq 0x3bfc
movq %rax, %r15
movq %rsp, %r12
movl 0x18(%r12), %edi
callq 0x3bfc
leaq 0x370b(%rip), %rsi      # 0x9158
movq %r12, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x5af6
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x5b0a
je 0x5aa0
movq 0x30(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x5aa2
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x5aa2
xorl %eax, %eax
testl %eax, %eax
jle 0x5af6
movl $0x20, %edi
callq 0x3180
movups 0x40(%rsp), %xmm0
movups %xmm0, 0x10(%rax)
movq 0x8(%rbx), %rcx
cmpq $0x1, 0x10(%rcx)
movq 0x20(%rsp), %rdx
jne 0x5add
leaq 0x8(%rdx), %rcx
movq 0x8(%rdx), %rsi
movq %rax, (%rsi)
movq %rsi, 0x8(%rax)
movq %rdx, (%rax)
jmp 0x5aee
movq (%rdx), %rcx
movq %rax, (%rdx)
movq %rdx, 0x8(%rax)
movq %rcx, (%rax)
addq $0x8, %rcx
movq %rax, (%rcx)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x3687
callq 0x3662
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x5bfb
je 0x5b4f
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x5b51
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x5b51
xorl %eax, %eax
cmpl $0x1, %eax
jne 0x5b99
movl $0x1, %eax
cmpl $0x3, 0x20(%rsp)
je 0x5b99
movl $0x3, %edi
callq 0x3bfc
movq %rax, %r14
leaq 0x8(%rsp), %r15
movl 0x18(%r15), %edi
callq 0x3bfc
leaq 0x35d4(%rip), %rsi      # 0x9158
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x5bde
movq 0x28(%rsp), %rax
cmpq %rax, 0x8(%rax)
je 0x5be5
movq 0x8(%rbx), %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)
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movups 0x10(%rdi), %xmm0
movups %xmm0, 0x18(%rbx)
callq 0x3030
jmp 0x5bec
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x5bf1
movl $0x0, 0x18(%rbx)
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x36ac
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %r15
movq (%rdx), %r14
testq %r14, %r14
je 0x5c7c
movl %ecx, %ebp
movq %rdx, 0x10(%rsp)
movq %rdx, %r13
movq (%r13), %rbx
movq -0x8(%r14), %rdi
movq %r15, %rsi
callq 0x3110
testl %eax, %eax
je 0x5c51
setg %cl
movzbl %cl, %ecx
leaq (%rbx,%rcx,8), %r13
addq $0x8, %r13
movq 0x8(%r14,%rcx,8), %r14
jmp 0x5c6c
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testb %bpl, %bpl
je 0x5c6c
movq 0x8(%rsp), %rcx
movups (%rcx), %xmm0
movups %xmm0, 0x18(%r14)
xorl %r12d, %r12d
testl %eax, %eax
je 0x5cbe
testq %r14, %r14
jne 0x5c28
movq 0x10(%rsp), %r14
jmp 0x5c84
xorl %ebx, %ebx
movq %rdx, %r13
movq %rdx, %r14
movl $0x30, %edi
callq 0x3180
movq %r15, (%rax)
movq 0x8(%rsp), %rcx
movups (%rcx), %xmm0
movups %xmm0, 0x20(%rax)
leaq 0x8(%rax), %rdi
movq %rbx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %rdi, (%r13)
movq %r14, %rsi
callq 0x7320
movl $0x1, %r12d
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq (%rdi), %r13
movl %edx, %r15d
testq %r13, %r13
je 0x5d1e
movq -0x8(%r13), %rdi
movq %r14, %rsi
testl %ebx, %ebx
je 0x5cfe
movq %r15, %rdx
callq 0x3050
jmp 0x5d03
callq 0x3110
testl %eax, %eax
je 0x5d14
setg %cl
movzbl %cl, %ecx
movq 0x8(%r13,%rcx,8), %r13
jmp 0x5d18
leaq -0x8(%r13), %r12
testl %eax, %eax
jne 0x5ce4
jmp 0x5d21
xorl %r12d, %r12d
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, (%rdx)
jne 0x5d77
movq 0x8(%rsi), %rax
movq 0x8(%rdx), %r14
movq (%rax), %r12
testq %r12, %r12
je 0x5d8f
movq -0x8(%r12), %rdi
movq %r14, %rsi
callq 0x3110
testl %eax, %eax
je 0x5d6c
setg %cl
movzbl %cl, %ecx
movq 0x8(%r12,%rcx,8), %r12
jmp 0x5d71
leaq -0x8(%r12), %r15
testl %eax, %eax
jne 0x5d49
jmp 0x5d92
leaq 0x36b8(%rip), %rsi      # 0x9436
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x5db0
xorl %r15d, %r15d
addq $0x18, %rbx
testq %r15, %r15
je 0x5da5
movups 0x20(%r15), %xmm0
movups %xmm0, (%rbx)
jmp 0x5dab
movl $0x0, (%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
movq 0x8(%rsi), %r15
movq (%rbx), %r12
testq %r12, %r12
je 0x5dfd
movq -0x8(%r12), %rdi
movq %r15, %rsi
callq 0x3110
testl %eax, %eax
je 0x5df2
setg %cl
movzbl %cl, %ecx
movq 0x8(%r12,%rcx,8), %r12
jmp 0x5df7
leaq -0x8(%r12), %r14
testl %eax, %eax
jne 0x5dcf
jmp 0x5e00
xorl %r14d, %r14d
testq %r14, %r14
je 0x5e1b
addq $0x8, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x74c8
movl $0x1, %eax
jmp 0x5e20
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, %rbx
movq %rdi, %r14
movl $0x4, 0x18(%rdi)
movl $0x8, %edi
callq 0x3180
movq %rax, 0x20(%r14)
incl 0x82e5(%rip)            # 0xe14c
movq $0x0, (%rax)
leaq 0x30(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x42fd
movb $0x1, %r13b
testl %eax, %eax
jle 0x5e9d
movq %r12, %rdi
callq 0x4a83
testb %al, %al
je 0x5edc
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
xorl %r13d, %r13d
xorl %r15d, %r15d
testb %r13b, %r13b
je 0x5ebd
movq %r14, %rdi
leaq 0x35cb(%rip), %rsi      # 0x947a
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x5ec7
movl $0x1, %eax
testb %r15b, %r15b
je 0x5f16
decl 0x827f(%rip)            # 0xe14c
movb $0x1, %r15b
movl %eax, %ebp
testb %r15b, %r15b
je 0x5e73
jmp 0x5fc6
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x5ef6
movq %r12, %rdi
movq %rbx, %rsi
callq *%rax
testl %eax, %eax
jle 0x5e9d
movl 0x48(%rsp), %edi
testl $0x70000000, %edi       # imm = 0x70000000
je 0x5f80
cmpl $0x70000004, %edi       # imm = 0x70000004
jne 0x5faa
movb $0x1, %r15b
xorl %r13d, %r13d
jmp 0x5ea0
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0x42fd
testl %eax, %eax
js 0x5fd7
je 0x5f47
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x5f49
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq *%rcx
jmp 0x5f49
xorl %eax, %eax
testl %eax, %eax
jle 0x5ea5
testb $0x70, 0x23(%rsp)
jne 0x5ea5
movq 0x20(%r14), %rdx
xorl %r15d, %r15d
movq (%rsp), %rdi
leaq 0x20(%rsp), %rsi
xorl %ecx, %ecx
callq 0x5c00
testl %eax, %eax
jns 0x5ed2
jmp 0x5ea5
cmpl $0x2, %edi
je 0x5e91
callq 0x3bfc
xorl %r15d, %r15d
movq %r12, %rdi
leaq 0x3514(%rip), %rsi      # 0x94af
movq %rax, %rdx
xorl %eax, %eax
callq 0x3240
jmp 0x5ea0
xorl %r15d, %r15d
movq %r12, %rdi
leaq 0x34de(%rip), %rsi      # 0x9495
xorl %eax, %eax
callq 0x3240
movb $0x1, %r13b
jmp 0x5ea0
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x36d1
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x619c
je 0x6084
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x6086
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x6086
xorl %eax, %eax
cmpl $0x1, %eax
jne 0x60ce
movl $0x1, %eax
cmpl $0x2, 0x20(%rsp)
je 0x60ce
movl $0x2, %edi
callq 0x3bfc
movq %rax, %r14
leaq 0x8(%rsp), %r15
movl 0x18(%r15), %edi
callq 0x3bfc
leaq 0x309f(%rip), %rsi      # 0x9158
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x6189
leaq 0x8(%rsp), %r14
movq 0x20(%r14), %r13
movl $0x2, 0x18(%rbx)
movq %rsp, %r15
movq %r13, %rdi
movl $0x5c, %esi
callq 0x3080
movq %rax, %r12
movq %rax, (%rsp)
movl %r12d, %esi
subl %r13d, %esi
movq %r13, %rdi
callq 0x657a
movzbl (%r12), %eax
cmpl $0x5c, %eax
je 0x611b
testl %eax, %eax
jne 0x6138
jmp 0x6141
cmpb $0x28, 0x1(%r12)
jne 0x6138
incq %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x65d1
testl %eax, %eax
js 0x6173
movq (%rsp), %r13
incq %r13
jmp 0x60e9
movq 0x8008(%rip), %rax      # 0xe150
movslq 0x8009(%rip), %rcx      # 0xe158
movb $0x0, (%rax,%rcx)
movq $0x0, 0x7ff2(%rip) # 0xe150
movl $0x0, 0x7ff0(%rip)      # 0xe158
movq %rax, 0x20(%rbx)
movl $0x1, %eax
jmp 0x618e
movq 0x7fd6(%rip), %rdi      # 0xe150
callq 0x3030
movl $0x0, 0x7fcf(%rip)      # 0xe158
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x36f6
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq %rdi, %rbx
movq %rsp, %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x6277
je 0x61dd
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x61df
movq %rsp, %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x61df
xorl %eax, %eax
cmpl $0x1, %eax
jne 0x6225
movl $0x1, %eax
cmpl $0x2, 0x18(%rsp)
je 0x6225
movl $0x2, %edi
callq 0x3bfc
movq %rax, %r14
movq %rsp, %r15
movl 0x18(%r15), %edi
callq 0x3bfc
leaq 0x2f48(%rip), %rsi      # 0x9158
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x6261
movl $0x1, 0x18(%rbx)
movq 0x20(%rsp), %rdi
leaq 0x28(%rsp), %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x3140
movq %rax, 0x20(%rbx)
movq (%r14), %rax
cmpb $0x0, (%rax)
je 0x6268
leaq 0x32f6(%rip), %rsi      # 0x954d
movq %rsp, %rdi
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x626d
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x371b
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x63db
je 0x62c0
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x62c2
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x62c2
xorl %eax, %eax
cmpl $0x1, %eax
jne 0x630a
movl $0x1, %eax
cmpl $0x2, 0x20(%rsp)
je 0x630a
movl $0x2, %edi
callq 0x3bfc
movq %rax, %r14
leaq 0x8(%rsp), %r15
movl 0x18(%r15), %edi
callq 0x3bfc
leaq 0x2e63(%rip), %rsi      # 0x9158
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x63c8
movq 0x28(%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 0x63b9
cmpl $0x20, %eax
je 0x63b9
testl %eax, %eax
je 0x63c1
xorl %r15d, %r15d
movzbl 0x1(%r14,%r15), %eax
incq %r15
cmpq $0x20, %rax
ja 0x6355
btq %rax, %r13
jae 0x6355
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 0x633d
incq %r14
jmp 0x633d
movl $0x1, %eax
jmp 0x63cd
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x3740
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x6570
je 0x641f
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x6421
movq %rsp, %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x6421
xorl %eax, %eax
cmpl $0x1, %eax
jne 0x6468
movl $0x1, %eax
cmpl $0x2, 0x18(%rsp)
je 0x6468
movl $0x2, %edi
callq 0x3bfc
movq %rax, %r15
movq %rsp, %r12
movl 0x18(%r12), %edi
callq 0x3bfc
leaq 0x2d05(%rip), %rsi      # 0x9158
movq %r12, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x6561
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x6575
je 0x64a6
movq 0x30(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x64a8
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x64a8
xorl %eax, %eax
cmpl $0x1, %eax
jne 0x64f0
movl $0x1, %eax
cmpl $0x2, 0x40(%rsp)
je 0x64f0
movl $0x2, %edi
callq 0x3bfc
movq %rax, %r14
leaq 0x28(%rsp), %r15
movl 0x18(%r15), %edi
callq 0x3bfc
leaq 0x2c7d(%rip), %rsi      # 0x9158
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x6561
movq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x3090
movq %rax, %r15
movl $0x6, 0x18(%rbx)
movq 0x8(%rbx), %rax
cmpq $0x1, 0x10(%rax)
jne 0x6528
movq 0x20(%rsp), %rdi
movl %r15d, %edx
movq %r14, %rsi
callq 0x3050
jmp 0x6556
movq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x3090
cmpl %r15d, %eax
jae 0x6540
movb $0x0, 0x20(%rbx)
jmp 0x655c
movl %eax, %eax
addq %rax, %r12
movl %r15d, %eax
subq %rax, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3110
testl %eax, %eax
sete 0x20(%rbx)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x378a
callq 0x3765
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/string.c
// Function: format_one
static int format_one(char *str, char **end, struct cy_token *st)
{
	int len, ret;

	*end = strchr(str, ')');
	if (*end == NULL) {
		show_token_err(st, "Error scanning format");
		return -1;
	}

	len = *end - str - 1;

	{
		char fbuf[len + 1], *fmt;
		struct cy_value cv;
		char i_aux[32];

		strncpy(fbuf, str + 1, len);
		fbuf[len] = '\0';

		fmt = strchr(fbuf, ':');
		if (fmt != NULL) {
			*fmt = '\0';
			fmt++;
		}

		if (try_deref_symbol(fbuf, &cv, false) < 0)
			return -1;

		switch (cv.t) {
		case CY_V_STRING:
			append_buf(cv.v_str, strlen(cv.v_str));
			break;
		case CY_V_NUMBER:
			if (fmt == NULL)
				fmt = "%li";
			ret = sprintf(i_aux, fmt, cv.v_i);
			append_buf(i_aux, ret);
			break;
		default:
			show_token_err(st, "Bad symbol (%s) for format", vtype2s(cv.t));
			return -1;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x29, %esi
callq 0x30a0
movq %rax, (%r15)
testq %rax, %rax
je 0x6651
movq %rsp, %r13
movl %r14d, %ecx
notl %ecx
addl %eax, %ecx
subl %r14d, %eax
addq $0xf, %rax
andq $-0x10, %rax
movq %rsp, %r15
subq %rax, %r15
movq %r15, %rsp
incq %r14
movslq %ecx, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x3040
movb $0x0, (%r12,%r15)
movq %r15, %rdi
movl $0x3a, %esi
callq 0x30a0
testq %rax, %rax
je 0x666d
movq %rax, %r12
movb $0x0, (%rax)
incq %r12
jmp 0x6670
leaq 0x2ec0(%rip), %rsi      # 0x9518
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x66fb
xorl %r12d, %r12d
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x4b95
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x66f8
movl -0x38(%rbp), %edi
cmpl $0x1, %edi
je 0x66b0
cmpl $0x2, %edi
jne 0x66df
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x3090
movq %rbx, %rdi
movl %eax, %esi
callq 0x657a
xorl %r14d, %r14d
jmp 0x66f8
testq %r12, %r12
leaq 0x2e74(%rip), %rsi      # 0x952e
cmovneq %r12, %rsi
movq -0x30(%rbp), %rdx
xorl %r14d, %r14d
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x31f0
movq %rbx, %rdi
movl %eax, %esi
callq 0x657a
jmp 0x66f8
callq 0x3bfc
leaq 0x2e47(%rip), %rsi      # 0x9532
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3240
movq %r13, %rsp
movl %r14d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x28(%rsi), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsi), %rax
movq %rax, (%rsp)
movq 0x20(%rdi), %rsi
movq %rbx, %rdi
callq 0x42e7
leaq 0x28(%rsp), %r13
leaq 0x10(%rsp), %r12
movl $0x1, %ebp
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x30(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x42fd
testl %eax, %eax
js 0x67ec
je 0x6792
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x6794
movq %r12, %rdi
movq %rbx, %rsi
callq *%rcx
jmp 0x6794
xorl %eax, %eax
cmpl $0x1, %eax
jne 0x67ac
movq 0x8(%r15), %rcx
movl $0x2, %eax
cmpq $0x70000005, 0x10(%rcx) # imm = 0x70000005
jne 0x67c1
cmpl $0x2, %eax
cmovbl %ebp, %eax
jne 0x67bd
movups (%r13), %xmm0
movups %xmm0, (%r14)
xorl %ecx, %ecx
jmp 0x67c8
movb $0x1, %cl
movl $0x1, %eax
testb %cl, %cl
jne 0x6753
movq 0x8(%rsp), %rcx
movq %rcx, 0x28(%rbx)
movq (%rsp), %rcx
movq %rcx, 0x30(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x37af
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
leaq 0x38(%rsp), %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x69c4
je 0x6876
movq 0x40(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x6878
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x6878
xorl %eax, %eax
cmpl $0x1, %eax
jne 0x68c1
movl $0x1, %eax
cmpl $0x5, 0x50(%rsp)
je 0x68c1
movl $0x5, %edi
callq 0x3bfc
movq %rax, %r15
leaq 0x38(%rsp), %r12
movl 0x18(%r12), %edi
callq 0x3bfc
leaq 0x28ac(%rip), %rsi      # 0x9158
movq %r12, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x69b5
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x69c9
je 0x68ff
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x6901
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x6901
xorl %eax, %eax
cmpl $0x1, %eax
jne 0x694a
movl $0x1, %eax
cmpl $0x4, 0x28(%rsp)
je 0x694a
movl $0x4, %edi
callq 0x3bfc
movq %rax, %r15
leaq 0x10(%rsp), %r12
movl 0x18(%r12), %edi
callq 0x3bfc
leaq 0x2823(%rip), %rsi      # 0x9158
movq %r12, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x69b5
movq 0x30(%rsp), %rax
leaq 0x77de(%rip), %r15      # 0xe138
cmpq 0x8(%r15), %rax
je 0x697e
movl (%r15), %ebp
movq 0x4(%r15), %rax
movq %rax, (%rsp)
movl 0xc(%r15), %eax
movl %eax, 0x8(%rsp)
movups 0x28(%rsp), %xmm0
movups %xmm0, (%r15)
jmp 0x6980
xorl %ebp, %ebp
addq $0x18, %rbx
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6710
testl %ebp, %ebp
je 0x69ab
movl %ebp, (%r15)
movq (%rsp), %rcx
movq %rcx, 0x4(%r15)
movl 0x8(%rsp), %ecx
movl %ecx, 0xc(%r15)
testl %eax, %eax
movl $0x1, %ebp
cmovsl %eax, %ebp
movl %ebp, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x37f9
callq 0x37d4
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x6a27
je 0x6a04
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x6a06
movq %rsp, %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x6a06
xorl %eax, %eax
testl %eax, %eax
jle 0x6a1a
movups 0x18(%rsp), %xmm0
movups %xmm0, 0x18(%rbx)
movl $0x2, %eax
jmp 0x6a1f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x28, %rsp
popq %rbx
popq %r14
retq
callq 0x381e
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x6a96
je 0x6a62
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x6a64
movq %rsp, %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x6a64
xorl %eax, %eax
testl %eax, %eax
jle 0x6a82
cmpl $0x0, 0x18(%rsp)
je 0x6a89
leaq 0x18(%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, 0x18(%rbx)
movl $0x2, %eax
jmp 0x6a8e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x6a8e
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
callq 0x3843
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/cblock.c
// Function: eval_novalue_return
static int eval_novalue_return(struct cy_token *t, struct cy_file *f)
{
	struct cy_token rt;

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

	return rt.v.t == CY_V_NOVALUE ? 2 : 1;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x42fd
testl %eax, %eax
js 0x6aef
xorl %ebp, %ebp
movl $0x0, %ecx
testl %eax, %eax
je 0x6ad6
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x6ad4
movq %rsp, %rdi
movq %rbx, %rsi
callq *%rcx
movl %eax, %ecx
cmpl $0x1, 0x18(%rsp)
adcl $0x1, %ebp
testl %ecx, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovgl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
callq 0x3868
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdx, %rbx
movl (%rdi), %ecx
cmpl $0x2, %ecx
je 0x6b3a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x1, %ecx
jne 0x6b4b
movl 0x8(%rdi), %eax
subl 0x8(%rsi), %eax
jmp 0x6b47
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
callq 0x3110
movl %eax, (%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x6ce5
je 0x6b9a
movq 0x38(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x6b9c
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x6b9c
xorl %eax, %eax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x6c82
movl 0x48(%rsp), %r15d
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x6cea
je 0x6bdf
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x6be1
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x6be1
xorl %eax, %eax
cmpl $0x1, %eax
jne 0x6c27
movl $0x1, %eax
cmpl %r15d, 0x20(%rsp)
je 0x6c27
movl %r15d, %edi
callq 0x3bfc
movq %rax, %r14
leaq 0x8(%rsp), %r15
movl 0x18(%r15), %edi
callq 0x3bfc
leaq 0x2546(%rip), %rsi      # 0x9158
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x6c82
movl $0x6, 0x18(%rbx)
movl 0x48(%rsp), %r14d
cmpl $0x2, %r14d
je 0x6c4d
cmpl $0x1, %r14d
jne 0x6c60
movl 0x50(%rsp), %eax
subl 0x28(%rsp), %eax
jmp 0x6c5c
movq 0x50(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x3110
xorl %ecx, %ecx
jmp 0x6c62
movb $0x1, %cl
testb %cl, %cl
je 0x6c8f
movl %r14d, %edi
callq 0x3bfc
leaq 0x29d6(%rip), %rsi      # 0x964b
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3240
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rcx
movq 0x10(%rcx), %rcx
movl $0x1, %ebp
decq %rcx
cmpq $0x5, %rcx
ja 0x6c82
leaq 0x292c(%rip), %rdx      # 0x95d8
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
testl %eax, %eax
sete 0x20(%rbx)
jmp 0x6c82
testl %eax, %eax
setle 0x20(%rbx)
jmp 0x6c82
testl %eax, %eax
setns 0x20(%rbx)
jmp 0x6c82
testl %eax, %eax
setg 0x20(%rbx)
jmp 0x6c82
testl %eax, %eax
setne 0x20(%rbx)
jmp 0x6c82
shrl $0x1f, %eax
movb %al, 0x20(%rbx)
jmp 0x6c82
callq 0x38b2
callq 0x388d
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/cond.c
// Function: eval_is_novalue
static int eval_is_novalue(struct cy_token *t, struct cy_file *f)
{
	struct cy_token nt;

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

	t->v.t = CY_V_BOOL;
	t->v.v_bool = (nt.v.t == CY_V_NOVALUE);
	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x6d4f
je 0x6d25
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x6d27
movq %rsp, %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x6d27
xorl %eax, %eax
testl %eax, %eax
jle 0x6d42
movl $0x6, 0x18(%rbx)
cmpl $0x0, 0x18(%rsp)
sete 0x20(%rbx)
movl $0x1, %eax
jmp 0x6d47
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x28, %rsp
popq %rbx
popq %r14
retq
callq 0x38d7
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/cond.c
// Function: eval_cond
static int eval_cond(struct cy_token *t, struct cy_file *f)
{
	struct cy_token tn;

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

	if (tn.v.t == CY_V_BOOL)
		return eval_if(t, &tn, f);
	if (tn.v.t == CY_V_CBLOCK)
		return eval_select(t, &tn, f);

	show_token_err(t, "Bad argument for condition");
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x6f8e
je 0x6d9c
movq 0x40(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x6d9e
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x6d9e
xorl %eax, %eax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x6f4b
movl 0x50(%rsp), %eax
cmpl $0x5, %eax
je 0x6e11
cmpl $0x6, %eax
jne 0x6f3a
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x729e
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x6f4b
leaq 0x60(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x729e
testl %eax, %eax
jle 0x6f4b
cmpb $0x1, 0x58(%rsp)
jne 0x6f5f
movq %r15, %rdi
callq 0x67f1
movl %eax, %ecx
movl $0x1, %eax
jmp 0x6f71
addq $0x18, %rbx
movq 0x28(%r14), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%r14), %rax
movq %rax, (%rsp)
movq 0x58(%rsp), %rsi
movq %r14, %rdi
callq 0x42e7
xorl %r12d, %r12d
leaq 0x10(%rsp), %r15
leaq 0x60(%rsp), %r13
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq %r12, 0x30(%rsp)
movq %r12, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x42fd
testl %eax, %eax
js 0x6f89
je 0x6e91
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x6e93
movq %r15, %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x6e93
xorl %eax, %eax
cmpl $0x1, %eax
jne 0x6ed6
movl $0x1, %eax
cmpl $0x6, 0x28(%rsp)
je 0x6ed6
movl $0x6, %edi
callq 0x3bfc
movq %rax, %rbp
movl 0x28(%rsp), %edi
callq 0x3bfc
movq %r15, %rdi
leaq 0x2294(%rip), %rsi      # 0x9158
movq %rbp, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x6f13
movq %r13, %rdi
movq %r14, %rsi
callq 0x729e
testl %eax, %eax
jle 0x6f13
movb $0x1, %cl
cmpb $0x1, 0x30(%rsp)
jne 0x6f15
movq %r13, %rdi
callq 0x67f1
testb %al, %al
je 0x6f05
movl $0x1, %eax
jmp 0x6f13
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6710
xorl %ecx, %ecx
testb %cl, %cl
jne 0x6e40
movq 0x8(%rsp), %rcx
movq %rcx, 0x28(%r14)
movq (%rsp), %rcx
movq %rcx, 0x30(%r14)
testl %eax, %eax
movl $0x1, %ebp
cmovsl %eax, %ebp
jmp 0x6f4b
leaq 0x2729(%rip), %rsi      # 0x966a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3240
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0x67f1
movl %eax, %ecx
movl $0x1, %eax
movq %r12, %r15
testb %cl, %cl
jne 0x6f2e
addq $0x18, %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6710
jmp 0x6f2e
callq 0x38fc
callq 0x3921
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/cond.c
// Function: get_branch
static int get_branch(struct cy_token *t, struct cy_file *f)
{
	if (cy_eval_next(f, t) <= 0)
		return -1;

	if ((t->v.t != CY_V_CBLOCK) && !is_nop_token(t)) {
		show_token_err(t, "Expected cblock/nop branch, got %s", vtype2s(t->v.t));
		return -1;
	}

	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x42fd
testl %eax, %eax
js 0x731a
je 0x72d0
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x72d2
movq %rbx, %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x72d2
xorl %eax, %eax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x7313
movl $0x1, %ebp
cmpl $0x5, 0x18(%rbx)
je 0x7313
movq %rbx, %rdi
callq 0x67f1
testb %al, %al
jne 0x7313
movl 0x18(%rbx), %edi
callq 0x3bfc
leaq 0x2384(%rip), %rsi      # 0x9685
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x396b
nop
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/rbtree.c
// Function: _rb_rotate_left
static void __rb_rotate_left(struct rb_node *node, struct rb_root *root)
{
	struct rb_node *right = node->rb_right;
	struct rb_node *parent = rb_parent(node);

	node->rb_right = right->rb_left;
	if (node->rb_right)
		rb_set_parent(right->rb_left, node);
	right->rb_left = node;

	rb_set_parent(right, parent);

	if (parent) {
		if (node == parent->rb_left)
			parent->rb_left = right;
		else
			parent->rb_right = right;
	} else
		root->rb_node = right;
	rb_set_parent(node, right);
}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
andq $-0x4, %rcx
movq 0x10(%rax), %rdx
movq %rdx, 0x8(%rdi)
testq %rdx, %rdx
je 0x7439
movq (%rdx), %r8
andl $0x3, %r8d
orq %rdi, %r8
movq %r8, (%rdx)
movq %rdi, 0x10(%rax)
movq (%rax), %rdx
andl $0x3, %edx
orq %rcx, %rdx
movq %rdx, (%rax)
testq %rcx, %rcx
je 0x745e
leaq 0x10(%rcx), %rdx
leaq 0x8(%rcx), %rsi
cmpq %rdi, 0x10(%rcx)
cmoveq %rdx, %rsi
movq %rax, (%rsi)
movq (%rdi), %rcx
andl $0x3, %ecx
orq %rax, %rcx
movq %rcx, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/misc.c
// Function: try_resolve_cvalue
int try_resolve_cvalue(struct cy_token *t)
{
	const char *val = t->val;

	if (val[1] == '+' && val[2] == '\0') {
		t->typ = &cy_const;
		t->v.t = CY_V_BOOL;
		t->v.v_bool = true;
		return 1;
	}

	if (val[1] == '-' && val[2] == '\0') {
		t->typ = &cy_const;
		t->v.t = CY_V_BOOL;
		t->v.v_bool = false;
		return 1;
	}

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

	return 0;
}

// Assembly:
movq (%rdi), %rcx
movzbl 0x1(%rcx), %edx
xorl %eax, %eax
cmpl $0x3f, %edx
je 0x7847
cmpl $0x2d, %edx
je 0x783c
cmpl $0x2b, %edx
jne 0x784d
cmpb $0x0, 0x2(%rcx)
je 0x7873
cmpl $0x3f, %edx
je 0x7847
cmpl $0x2d, %edx
jne 0x784d
cmpb $0x0, 0x2(%rcx)
je 0x785b
cmpl $0x3f, %edx
jne 0x784d
cmpb $0x0, 0x2(%rcx)
je 0x784e
retq
leaq 0x6493(%rip), %rax      # 0xdce8
movq %rax, 0x8(%rdi)
jmp 0x7889
leaq 0x646e(%rip), %rax      # 0xdcd0
movq %rax, 0x8(%rdi)
movl $0x6, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
jmp 0x7889
leaq 0x6456(%rip), %rax      # 0xdcd0
movq %rax, 0x8(%rdi)
movl $0x6, 0x18(%rdi)
movb $0x1, 0x20(%rdi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/misc.c
// Function: eval_in
static int eval_in(struct cy_token *t, struct cy_file *f)
{
	struct cy_token it, ct;

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

	t->v.t = CY_V_BOOL;

	if (it.v.t == CY_V_LIST) {
		t->v.v_bool = check_in_list(it.v.v_list, &ct.v);
		return 1;
	}

	if (it.v.t == CY_V_MAP) {
		;
		/*
		 * What to check in map? Key or value? Py does check key,
		 * but that's equivalent to just dereferencing the map
		 * element. Also, checking value makes it similar to
		 * checking the list, by re-using the cy_compare() thing.
		 */
	}

	show_token_err(t, "Bad object %s to check value in", vtype2s(it.v.t));
	return -1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x798c
je 0x7901
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x7903
movq %rsp, %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x7903
xorl %eax, %eax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x7981
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x7991
je 0x7939
movq 0x30(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x793b
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x793b
xorl %eax, %eax
testl %eax, %eax
jle 0x7981
movl $0x6, 0x18(%rbx)
movl 0x18(%rsp), %edi
cmpl $0x3, %edi
jne 0x7968
movq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x55e0
movb %al, 0x20(%rbx)
movl $0x1, %ebp
jmp 0x7981
callq 0x3bfc
leaq 0x1daa(%rip), %rsi      # 0x971e
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3240
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x39b5
callq 0x3990
// File: /workspace/github_c_makefile_star2_O1/xemul[P]cylang/misc.c
// Function: eval_sizeof
static int eval_sizeof(struct cy_token *t, struct cy_file *f)
{
	struct cy_token at;

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

	t->v.t = CY_V_NUMBER;

	if (at.v.t == CY_V_STRING) {
		t->v.v_i = strlen(at.v.v_str);
		return 1;
	}

	if (at.v.t == CY_V_LIST) {
		struct cy_list_value *lv;

		t->v.v_i = 0;
		list_for_each_entry(lv, &at.v.v_list->h, l)
			t->v.v_i++;

		return 1;
	}

	if (at.v.t == CY_V_MAP) {
		struct rb_node *n;

		t->v.v_i = 0;
		for (n = rb_first(&at.v.v_map->r); n; n = rb_next(n))
			t->v.v_i++;

		return 1;
	}

	show_token_err(t, "Can't get size of a %s", vtype2s(at.v.t));
	return -1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x7a95
je 0x79d5
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x79d7
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x79d7
xorl %eax, %eax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x7a8a
movl $0x1, 0x18(%rbx)
movl 0x20(%rsp), %edi
cmpl $0x4, %edi
je 0x7a47
cmpl $0x3, %edi
je 0x7a13
cmpl $0x2, %edi
jne 0x7a71
movq 0x28(%rsp), %rdi
callq 0x3090
movq %rax, 0x20(%rbx)
movl $0x1, %ebp
jmp 0x7a8a
movq $0x0, 0x20(%rbx)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rcx
movl $0x1, %ebp
cmpq %rax, %rcx
je 0x7a8a
movq 0x20(%rbx), %rdx
incq %rdx
movq %rdx, 0x20(%rbx)
movq 0x8(%rcx), %rcx
incq %rdx
cmpq %rax, %rcx
jne 0x7a35
jmp 0x7a8a
movq $0x0, 0x20(%rbx)
movq 0x28(%rsp), %rdi
callq 0x771c
movl $0x1, %ebp
testq %rax, %rax
je 0x7a8a
incq 0x20(%rbx)
movq %rax, %rdi
callq 0x774c
jmp 0x7a5e
callq 0x3bfc
leaq 0x1cc1(%rip), %rsi      # 0x973e
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3240
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x39da