LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/xemul[P]cylang/map.c
// Function: map_add_value
int map_add_value(const char *key, struct cy_value *v, struct rb_root *root, bool upsert)
{
	struct rb_node *node = root->rb_node, *parent = NULL;
	struct rb_node **new = &root->rb_node;
	struct cy_map_value *mv;

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, 0x4(%rsp)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
movq %rdx, %r12
movq %rdx, %rax
movq (%rax), %rbp
testq %rbp, %rbp
je 0x4e77
movq -0x8(%rbp), %rdi
movq %r15, %rsi
callq 0x3110
testl %eax, %eax
je 0x4ea9
movq (%r12), %r13
setg %al
movzbl %al, %eax
leaq 0x8(,%rax,8), %r12
addq %r13, %r12
leaq 0x8(,%rax,8), %rax
addq %rbp, %rax
jmp 0x4e3d
pushq $0x30
popq %rdi
callq 0x3180
movq %r15, (%rax)
movups (%r14), %xmm0
movups %xmm0, 0x20(%rax)
leaq 0x8(%rax), %rdi
movq %r13, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %rdi, (%r12)
movq %rbx, %rsi
callq 0x5f68
pushq $0x1
jmp 0x4ebe
cmpb $0x0, 0x4(%rsp)
je 0x4ebc
movups (%r14), %xmm0
movups %xmm0, 0x18(%rbp)
xorl %eax, %eax
jmp 0x4ebf
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/xemul[P]cylang/map.c
// Function: find_in_map
struct cy_map_value *find_in_map(struct rb_root *root, const char *key, unsigned klen)
{
	struct rb_node *node = root->rb_node;

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

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

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

	return NULL;
}

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

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

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

	return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x2, (%rdx)
jne 0x4f54
movq 0x8(%rsi), %rdi
movq 0x8(%rdx), %rsi
xorl %edx, %edx
callq 0x4ece
addq $0x18, %rbx
testq %rax, %rax
je 0x4f69
movups 0x20(%rax), %xmm0
movups %xmm0, (%rbx)
jmp 0x4f6c
leaq 0x24d3(%rip), %rsi      # 0x742e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x332c
pushq $-0x1
jmp 0x4f6e
andl $0x0, (%rbx)
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/xemul[P]cylang/map.c
// Function: cy_map_del
int cy_map_del(struct cy_value *m, struct cy_value *k)
{
	struct rb_root *root = &m->v_map->r;
	struct cy_map_value *mv;

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

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

// Assembly:
pushq %rbx
movq 0x8(%rdi), %rbx
movq 0x8(%rsi), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4ece
testq %rax, %rax
je 0x4f9c
addq $0x8, %rax
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6100
pushq $0x1
jmp 0x4f9e
pushq $-0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/xemul[P]cylang/map.c
// Function: eval_map
static int eval_map(struct cy_token *t, struct cy_file *f)
{
	make_map(&t->v);
	map_depth++;
	while (1) {
		int ret;
		const char *key;
		struct cy_token vt;

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

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

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

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

		continue;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x5146
incl 0x717c(%rip)            # 0xc14c
leaq 0x48(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x30(%rsp), %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0x3a7d
testl %eax, %eax
jle 0x50bf
movq %r12, %rdi
callq 0x3fdc
testb %al, %al
jne 0x502d
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x501c
movq %r12, %rdi
movq %r14, %rsi
callq *%rax
testl %eax, %eax
jle 0x50bf
movl 0x20(%rsp), %edi
testl $0x70000000, %edi       # imm = 0x70000000
jne 0x5083
cmpl $0x2, %edi
jne 0x508f
movq 0x28(%rsp), %rbp
movq %r14, %rdi
movq %r13, %rsi
callq 0x3a7d
testl %eax, %eax
js 0x50e8
je 0x50bf
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x5061
movq %r13, %rdi
movq %r14, %rsi
callq *%rax
testl %eax, %eax
jle 0x50bf
testb $0x70, 0x4b(%rsp)
jne 0x50bf
movq 0x20(%rbx), %rdx
movq %rbp, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x4e1c
testl %eax, %eax
jns 0x4fdf
jmp 0x50bf
cmpl $0x70000004, %edi       # imm = 0x70000004
jne 0x50ac
pushq $0x1
jmp 0x50d2
callq 0x33ef
leaq 0x240c(%rip), %rsi      # 0x74a7
leaq 0x8(%rsp), %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x332c
jmp 0x50bf
leaq 0x23da(%rip), %rsi      # 0x748d
leaq 0x8(%rsp), %rdi
xorl %eax, %eax
callq 0x332c
leaq 0x23ac(%rip), %rsi      # 0x7472
movq %rbx, %rdi
xorl %eax, %eax
callq 0x332c
pushq $-0x1
popq %rax
decl 0x7073(%rip)            # 0xc14c
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x5f09(%rip), %rax      # 0xaff8
movq (%rax), %rcx
leaq 0x203d(%rip), %rdi      # 0x7136
pushq $0x18
popq %rsi
pushq $0x1
popq %rdx
callq 0x3210
pushq $0x1
popq %rdi
callq 0x3200
// File: /workspace/github_c_makefile_star2_O2/xemul[P]cylang/string.c
// Function: eval_format
static int eval_format(struct cy_token *t, struct cy_file *f)
{
	struct cy_token st;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x5456
testl %eax, %eax
jle 0x5247
leaq 0x10(%rsp), %r14
movq 0x20(%r14), %r13
movl $0x2, 0x18(%rbx)
pushq $0x5c
popq %rbp
leaq 0x8(%rsp), %r15
movq %r13, %rdi
movl %ebp, %esi
callq 0x3080
movq %rax, %r12
movq %rax, 0x8(%rsp)
movl %r12d, %esi
subl %r13d, %esi
movq %r13, %rdi
callq 0x54ec
movzbl (%r12), %eax
cmpl $0x5c, %eax
je 0x51e1
testl %eax, %eax
jne 0x5203
jmp 0x520b
cmpb $0x28, 0x1(%r12)
jne 0x5203
incq %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x5543
testl %eax, %eax
js 0x5234
movq 0x8(%rsp), %r12
incq %r12
movq %r12, %r13
jmp 0x51b1
movq 0x6f3e(%rip), %rax      # 0xc150
movslq 0x6f3f(%rip), %rcx      # 0xc158
movb $0x0, (%rax,%rcx)
andq $0x0, 0x6f2b(%rip)      # 0xc150
andl $0x0, 0x6f2c(%rip)      # 0xc158
movq %rax, 0x20(%rbx)
pushq $0x1
jmp 0x5249
movq 0x6f15(%rip), %rdi      # 0xc150
callq 0x3030
andl $0x0, 0x6f11(%rip)      # 0xc158
pushq $-0x1
popq %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x5456
testl %eax, %eax
jle 0x52b1
movl $0x1, 0x18(%rbx)
movq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x3140
movq %rax, 0x20(%rbx)
movq (%r14), %rax
cmpb $0x0, (%rax)
je 0x52b5
leaq 0x22a0(%rip), %rsi      # 0x7545
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x332c
pushq $-0x1
jmp 0x52b7
pushq $0x1
popq %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/xemul[P]cylang/string.c
// Function: eval_split
static int eval_split(struct cy_token *t, struct cy_file *f)
{
	struct cy_token st;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq %rsp, %rsi
movq %rax, %rdi
callq 0x5456
testl %eax, %eax
jle 0x5395
movq 0x20(%rsp), %r14
movl $0x3, 0x18(%rbx)
pushq $0x10
popq %rdi
callq 0x3180
movq %rax, 0x20(%rbx)
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movabsq $0x100000601, %rbp      # imm = 0x100000601
pushq $0x20
popq %r15
movzbl (%r14), %eax
leal -0x9(%rax), %ecx
cmpl $0x2, %ecx
jb 0x538c
cmpl $0x20, %eax
je 0x538c
testl %eax, %eax
je 0x5391
xorl %r12d, %r12d
movzbl 0x1(%r14,%r12), %eax
incq %r12
cmpq $0x20, %rax
ja 0x532c
btq %rax, %rbp
jae 0x532c
movq %r15, %rdi
callq 0x3180
movq %rax, %r13
movl $0x2, 0x10(%rax)
movq %r14, %rdi
movq %r12, %rsi
callq 0x30f0
movq %rax, 0x18(%r13)
movq 0x20(%rbx), %rax
movq (%rax), %rcx
movq %r13, (%rax)
movq %rax, 0x8(%r13)
movq %rcx, (%r13)
movq %r13, 0x8(%rcx)
leaq (%r14,%r12), %rax
incq %rax
addq %r12, %r14
cmpb $0x0, -0x1(%rax)
cmovneq %rax, %r14
jmp 0x5314
incq %r14
jmp 0x5314
pushq $0x1
jmp 0x5397
pushq $-0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5456
pushq $-0x1
popq %rbp
testl %eax, %eax
jle 0x5447
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x5456
testl %eax, %eax
jle 0x5447
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 0x5410
movq 0x20(%rsp), %rdi
movl %r15d, %edx
movq %r14, %rsi
callq 0x3050
jmp 0x543e
movq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x3090
cmpl %r15d, %eax
jae 0x5428
movb $0x0, 0x20(%rbx)
jmp 0x5444
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)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x29
popq %rsi
callq 0x30a0
movq %rax, (%r15)
testq %rax, %rax
je 0x55bf
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)
pushq $0x3a
popq %rsi
movq %r15, %rdi
callq 0x30a0
testq %rax, %rax
je 0x55d8
movq %rax, %r14
movb $0x0, (%rax)
incq %r14
jmp 0x55db
leaq 0x1f4a(%rip), %rsi      # 0x7510
movq %rbx, %rdi
xorl %eax, %eax
callq 0x332c
pushq $-0x1
popq %rax
jmp 0x565a
xorl %r14d, %r14d
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x40cd
testl %eax, %eax
js 0x5654
movl -0x38(%rbp), %edi
cmpl $0x1, %edi
je 0x560d
cmpl $0x2, %edi
jne 0x563b
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x3090
movq %rbx, %rdi
movl %eax, %esi
jmp 0x5632
testq %r14, %r14
leaq 0x1f0f(%rip), %rsi      # 0x7526
cmovneq %r14, %rsi
movq -0x30(%rbp), %rdx
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x31f0
movq %rbx, %rdi
movl %eax, %esi
callq 0x54ec
xorl %eax, %eax
jmp 0x5657
callq 0x33ef
leaq 0x1ee3(%rip), %rsi      # 0x752a
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x332c
pushq $-0x1
popq %rax
movq %r13, %rsp
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_O2/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 %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movups 0x28(%rsi), %xmm0
movaps %xmm0, (%rsp)
movq 0x20(%rdi), %rsi
movq %rbx, %rdi
callq 0x3a67
leaq 0x10(%rsp), %r12
pushq $0x2
popq %rbp
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x30(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x56fb
cmpl $0x1, %eax
jne 0x56d0
movq 0x8(%r15), %rax
cmpq $0x70000005, 0x10(%rax) # imm = 0x70000005
jne 0x569d
jmp 0x56db
pushq $0x1
popq %rbp
cmpl $0x2, %eax
cmovael %eax, %ebp
jne 0x56e4
movups 0x28(%rsp), %xmm0
movups %xmm0, (%r14)
movaps (%rsp), %xmm0
movups %xmm0, 0x28(%rbx)
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x68, %rsp
movq %rsi, %rbx
andl $0x0, 0x10(%rsp)
movq %rdi, %r14
andq $0x0, 0x8(%rsp)
leaq 0x40(%rsp), %rsi
pushq $0x5
popq %rdx
movq %rbx, %rdi
callq 0x58e2
pushq $-0x1
popq %rbp
testl %eax, %eax
jle 0x5837
leaq 0x18(%rsp), %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x58e2
testl %eax, %eax
jle 0x5837
movq 0x38(%rsp), %rax
leaq 0x695c(%rip), %r15      # 0xc138
cmpq 0x8(%r15), %rax
je 0x5801
movl (%r15), %ebp
movq 0x4(%r15), %rax
movq %rax, 0x8(%rsp)
movl 0xc(%r15), %eax
movl %eax, 0x10(%rsp)
movups 0x30(%rsp), %xmm0
movups %xmm0, (%r15)
jmp 0x5803
xorl %ebp, %ebp
addq $0x18, %r14
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x566c
testl %ebp, %ebp
je 0x582f
movl %ebp, (%r15)
movq 0x8(%rsp), %rcx
movq %rcx, 0x4(%r15)
movl 0x10(%rsp), %ecx
movl %ecx, 0xc(%r15)
testl %eax, %eax
pushq $0x1
popq %rbp
cmovsl %eax, %ebp
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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), %eax
cmpl $0x2, %eax
je 0x5971
cmpl $0x1, %eax
jne 0x5984
movl 0x8(%rdi), %eax
subl 0x8(%rsi), %eax
jmp 0x597e
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
callq 0x3110
movl %eax, (%rbx)
xorl %eax, %eax
jmp 0x5987
pushq $-0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x5e31
pushq $-0x1
popq %rbx
testl %eax, %eax
jle 0x5a3e
movl 0x28(%rsp), %edx
leaq 0x38(%rsp), %rsi
movq %r15, %rdi
callq 0x5e90
testl %eax, %eax
jle 0x5a3e
leaq 0x28(%rsp), %rdi
movl $0x6, 0x18(%r14)
leaq 0x50(%rsp), %rsi
leaq 0xc(%rsp), %rdx
callq 0x5959
testl %eax, %eax
js 0x5a21
movq 0x8(%r14), %rax
movq 0x10(%rax), %rax
pushq $0x1
popq %rbx
decq %rax
cmpq $0x5, %rax
ja 0x5a3e
leaq 0x1bc4(%rip), %rcx      # 0x75d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x0, 0xc(%rsp)
sete 0x20(%r14)
jmp 0x5a3e
movl 0x28(%rsp), %edi
callq 0x33ef
leaq 0x1c0a(%rip), %rsi      # 0x763b
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x332c
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x0, 0xc(%rsp)
setle 0x20(%r14)
jmp 0x5a3e
cmpl $0x0, 0xc(%rsp)
setns 0x20(%r14)
jmp 0x5a3e
cmpl $0x0, 0xc(%rsp)
setg 0x20(%r14)
jmp 0x5a3e
cmpl $0x0, 0xc(%rsp)
setne 0x20(%r14)
jmp 0x5a3e
movl 0xc(%rsp), %eax
shrl $0x1f, %eax
movb %al, 0x20(%r14)
jmp 0x5a3e
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x78(%rsp), %rsi
movq %rbx, %rdi
callq 0x5e31
pushq $-0x1
popq %rbp
testl %eax, %eax
jle 0x5bf9
movl 0x90(%rsp), %eax
cmpl $0x5, %eax
je 0x5b56
cmpl $0x6, %eax
jne 0x5be8
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5edd
pushq $-0x1
popq %rbp
testl %eax, %eax
jle 0x5bf9
movq %rsp, %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x5edd
testl %eax, %eax
jle 0x5bf9
addq $0x18, %r14
cmpb $0x0, 0x98(%rsp)
cmovneq %r15, %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x5f32
jmp 0x5bde
addq $0x18, %r14
movups 0x28(%rbx), %xmm0
movaps %xmm0, 0x60(%rsp)
movq 0x98(%rsp), %rsi
movq %rbx, %rdi
callq 0x3a67
leaq 0x30(%rsp), %r15
pushq $0x6
popq %rbp
movq %rsp, %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
andq $0x0, 0x50(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
andq $0x0, 0x20(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x5e90
testl %eax, %eax
jle 0x5bd5
movq %r12, %rdi
movq %rbx, %rsi
callq 0x5edd
testl %eax, %eax
jle 0x5bd5
cmpb $0x1, 0x50(%rsp)
jne 0x5b7e
movq %rsp, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x5f32
movaps 0x60(%rsp), %xmm0
movups %xmm0, 0x28(%rbx)
testl %eax, %eax
pushq $0x1
popq %rbp
cmovsl %eax, %ebp
jmp 0x5bf9
leaq 0x1a6b(%rip), %rsi      # 0x765a
movq %r14, %rdi
xorl %eax, %eax
callq 0x332c
movl %ebp, %eax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/xemul[P]cylang/cond.c
// Function: eval_loop
static int eval_loop(struct cy_token *t, struct cy_file *f)
{
	struct cy_token lt, bt;

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

	if (lt.v.t == CY_V_CBLOCK)
		return eval_cblock_loop(t, &lt, f);

	if (get_branch(&bt, f) <= 0)
		return -1;

	switch (lt.v.t) {
	case CY_V_LIST:
		return eval_list_loop(t, &lt, &bt, f);
	case CY_V_MAP:
		return eval_map_loop(t, &lt, &bt, f);
	case CY_V_NUMBER:
		return eval_nuber_loop(t, &lt, &bt, f);
	}

	show_token_err(t, "Bad loop object");
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x5e31
pushq $-0x1
popq %rbp
testl %eax, %eax
jle 0x5dff
cmpl $0x5, 0x40(%rsp)
jne 0x5c79
leaq 0x28(%rsp), %r15
leaq 0x50(%rsp), %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x566c
testl %eax, %eax
jle 0x5dff
cmpl $0x2, %eax
jne 0x5c48
movaps 0x50(%rsp), %xmm0
movups %xmm0, 0x18(%rbx)
jmp 0x5dfc
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x5edd
testl %eax, %eax
jle 0x5dff
movl 0x40(%rsp), %eax
cmpl $0x1, %eax
je 0x5d7a
cmpl $0x4, %eax
je 0x5d08
cmpl $0x3, %eax
jne 0x5dda
movq 0x48(%rsp), %rax
leaq 0x50(%rsp), %r15
movq %rsp, %r12
movq %rax, %r13
movq 0x8(%r13), %r13
cmpq %rax, %r13
je 0x5df5
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
leaq 0x10(%r13), %rdi
callq 0x3fc4
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x5f32
movl %eax, %ebp
testl %eax, %eax
js 0x5dff
cmpl $0x2, %ebp
je 0x5ded
cmpq %r13, 0x8(%r13)
je 0x5df5
movq 0x48(%rsp), %rax
jmp 0x5cb9
movq 0x48(%rsp), %rdi
callq 0x6377
movq %rax, %r15
leaq 0x50(%rsp), %r13
movq %rsp, %r12
testq %r15, %r15
je 0x5df5
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movups 0x18cc(%rip), %xmm0     # 0x7600
movaps %xmm0, 0x10(%rsp)
movq -0x8(%r15), %rax
movq %rax, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x3fc4
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x5f32
movl %eax, %ebp
testl %eax, %eax
js 0x5dff
cmpl $0x2, %ebp
je 0x5ded
movq %r15, %rdi
callq 0x63a7
movq %rax, %r15
jmp 0x5d1d
movq $0x1, (%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x48(%rsp), %rax
testq %rax, %rax
jle 0x5e10
movslq %eax, %r15
pushq $0x1
popq %r12
xorl %eax, %eax
pushq $0x1
popq %rbp
leaq 0x10(%rsp), %r13
movq %rax, 0x8(%rsp)
cmpq %r15, %rax
je 0x5dff
movq %rsp, %rdi
callq 0x3fc4
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x5f32
testl %eax, %eax
js 0x5e22
cmpl $0x2, %eax
je 0x5e26
movq 0x8(%rsp), %rax
addq %r12, %rax
jmp 0x5da5
leaq 0x18b7(%rip), %rsi      # 0x7698
movq %rbx, %rdi
xorl %eax, %eax
callq 0x332c
jmp 0x5dff
movaps (%rsp), %xmm0
movups %xmm0, 0x18(%rbx)
xorl %edi, %edi
callq 0x3fc4
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jns 0x5dfc
negl %eax
cltq
pushq $-0x1
popq %r12
xorl %r15d, %r15d
jmp 0x5d9d
movl %eax, %ebp
jmp 0x5dff
movaps 0x10(%rsp), %xmm0
movups %xmm0, 0x18(%rbx)
jmp 0x5dff
// File: /workspace/github_c_makefile_star2_O2/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 %rdi, %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x5e31
pushq $-0x1
popq %r14
testl %eax, %eax
jle 0x5f28
pushq $0x1
popq %rbp
cmpl $0x5, 0x18(%rbx)
je 0x5f2b
movq %rbx, %rdi
callq 0x575a
testb %al, %al
jne 0x5f2b
movl 0x18(%rbx), %edi
callq 0x33ef
leaq 0x175a(%rip), %rsi      # 0x7675
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x332c
movl %r14d, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6071
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 0x6096
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_O2/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 0x64ad
cmpl $0x2d, %edx
je 0x648f
cmpl $0x2b, %edx
jne 0x648e
cmpb $0x0, 0x2(%rcx)
je 0x64c0
retq
cmpb $0x0, 0x2(%rcx)
jne 0x648e
leaq 0x5834(%rip), %rax      # 0xbcd0
movq %rax, 0x8(%rdi)
movl $0x6, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
jmp 0x64d6
cmpb $0x0, 0x2(%rcx)
jne 0x648e
leaq 0x582e(%rip), %rax      # 0xbce8
movq %rax, 0x8(%rdi)
jmp 0x64d6
leaq 0x5809(%rip), %rax      # 0xbcd0
movq %rax, 0x8(%rdi)
movl $0x6, 0x18(%rdi)
movb $0x1, 0x20(%rdi)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %rsi
movq %r15, %rdi
callq 0x67d8
pushq $-0x1
popq %rbx
testl %eax, %eax
jle 0x6583
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x67d8
testl %eax, %eax
jle 0x6583
movl $0x6, 0x18(%r14)
movl 0x18(%rsp), %edi
cmpl $0x3, %edi
jne 0x656a
movq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x4a51
movb %al, 0x20(%r14)
pushq $0x1
popq %rbx
jmp 0x6583
callq 0x33ef
leaq 0x1198(%rip), %rsi      # 0x770e
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x332c
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq %rsp, %rsi
movq %rax, %rdi
callq 0x67d8
pushq $-0x1
popq %rbp
testl %eax, %eax
jle 0x6641
movl $0x1, 0x18(%rbx)
movl 0x18(%rsp), %edi
cmpl $0x4, %edi
je 0x6603
cmpl $0x3, %edi
je 0x65de
cmpl $0x2, %edi
jne 0x6628
movq 0x20(%rsp), %rdi
callq 0x3090
movq %rax, 0x20(%rbx)
pushq $0x1
popq %rbp
jmp 0x6641
andq $0x0, 0x20(%rbx)
pushq $0x1
popq %rax
movq 0x20(%rsp), %rcx
pushq $0x1
popq %rbp
movq %rcx, %rdx
movq 0x8(%rdx), %rdx
cmpq %rcx, %rdx
je 0x6641
movq %rax, 0x20(%rbx)
incq %rax
jmp 0x65f1
andq $0x0, 0x20(%rbx)
movq 0x20(%rsp), %rdi
callq 0x6377
pushq $0x1
popq %rbp
testq %rax, %rax
je 0x6641
incq 0x20(%rbx)
movq %rax, %rdi
callq 0x63a7
jmp 0x6615
callq 0x33ef
leaq 0x10fa(%rip), %rsi      # 0x772e
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x332c
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/xemul[P]cylang/misc.c
// Function: eval_default_value
static int eval_default_value(struct cy_token *t, struct cy_file *f)
{
	struct cy_token a, b;

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

	t->v = (a.v.t != CY_V_NOVALUE ? a.v : b.v);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x67d8
pushq $-0x1
popq %rbp
testl %eax, %eax
jle 0x6696
movq %rsp, %rsi
movq %r14, %rdi
callq 0x67d8
testl %eax, %eax
jle 0x6696
leaq 0x40(%rsp), %rax
cmpl $0x0, (%rax)
leaq 0x18(%rsp), %rcx
cmovneq %rax, %rcx
movups (%rcx), %xmm0
movups %xmm0, 0x18(%rbx)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/xemul[P]cylang/misc.c
// Function: eval_empty_is_novalue
static int eval_empty_is_novalue(struct cy_token *t, struct cy_file *f)
{
	struct cy_token vt;

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

	if (!is_empty_value(&vt.v))
		t->v = vt.v;

	return 1;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x67d8
testl %eax, %eax
jle 0x66e4
movl 0x20(%rsp), %ecx
pushq $0x1
popq %rax
cmpq $0x6, %rcx
ja 0x66f3
leaq 0xfd7(%rip), %rdx       # 0x76a8
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
cmpq $0x0, 0x28(%rsp)
jne 0x66f3
jmp 0x66ff
pushq $-0x1
popq %rax
jmp 0x66ff
movq 0x28(%rsp), %rcx
cmpb $0x0, (%rcx)
je 0x66ff
leaq 0x20(%rsp), %rcx
movups (%rcx), %xmm0
movups %xmm0, 0x18(%rbx)
addq $0x30, %rsp
popq %rbx
retq
cmpb $0x1, 0x28(%rsp)
je 0x66f3
jmp 0x66ff
movq 0x28(%rsp), %rcx
cmpq %rcx, 0x8(%rcx)
jne 0x66f3
jmp 0x66ff
movq 0x28(%rsp), %rcx
cmpq $0x0, (%rcx)
jne 0x66f3
jmp 0x66ff
// File: /workspace/github_c_makefile_star2_O2/xemul[P]cylang/misc.c
// Function: eval_eval
static int eval_eval(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;

	st.val = st.v.v_str;
	st.v.t = CY_V_NOVALUE;

	if (cy_resolve(&st) < 0)
		return -1;

	if (st.typ->eval && st.typ->eval(&st, f) <= 0)
		return -1;

	t->v = st.v;
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x67d8
pushq $-0x1
popq %rbx
cmpl $0x1, %eax
jne 0x6785
cmpl $0x2, 0x20(%rsp)
je 0x6787
pushq $0x2
popq %rdi
callq 0x33ef
movq %rax, %r14
leaq 0x8(%rsp), %r15
movl 0x18(%r15), %edi
callq 0x33ef
leaq 0x9dc(%rip), %rsi       # 0x714f
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x332c
jmp 0x67cc
jl 0x67cc
leaq 0x8(%rsp), %rdi
movq 0x20(%rdi), %rax
movq %rax, (%rdi)
andl $0x0, 0x18(%rdi)
callq 0x35c8
testl %eax, %eax
js 0x67cc
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x67bc
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq *%rax
testl %eax, %eax
jle 0x67cc
leaq 0x20(%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, 0x18(%r14)
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/xemul[P]cylang/stream.c
// Function: try_resolve_stream
int try_resolve_stream(struct cy_token *t)
{
	FILE *std = NULL;

	if (t->val[1] == '<' && t->val[2] == '\0')
		std = stdin;
	else if (t->val[1] == '>') {
		if (t->val[2] == '\0')
			std = stdout;
		else if (t->val[2] == '!' && t->val[3] == '\0')
			std = stderr;
	}

	if (std == NULL)
		return 0;

	t->typ = &cy_stdio;
	set_stream(t, std);
	return 1;
}

// Assembly:
movq (%rdi), %rcx
movzbl 0x1(%rcx), %edx
xorl %eax, %eax
cmpl $0x3e, %edx
je 0x6852
cmpl $0x3c, %edx
jne 0x6851
cmpb $0x0, 0x2(%rcx)
je 0x686e
retq
movzbl 0x2(%rcx), %edx
testl %edx, %edx
je 0x6877
cmpl $0x21, %edx
jne 0x6851
cmpb $0x0, 0x3(%rcx)
jne 0x6851
movq 0x478c(%rip), %rcx      # 0xaff8
jmp 0x687e
movq 0x4763(%rip), %rcx      # 0xafd8
jmp 0x687e
movq 0x4752(%rip), %rcx      # 0xafd0
movq (%rcx), %rsi
testq %rsi, %rsi
je 0x6851
pushq %rax
leaq 0x5592(%rip), %rax      # 0xbe20
movq %rax, 0x8(%rdi)
callq 0x689f
pushq $0x1
popq %rax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/xemul[P]cylang/stream.c
// Function: eval_open
static int eval_open(struct cy_token *t, struct cy_file *f)
{
	FILE *file;
	struct cy_token ft;

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

	file = fopen(ft.v.v_str, (char *)t->typ->priv);
	if (file == NULL) {
		t->v.t = CY_V_NOVALUE;
		return 1;
	}

	set_stream(t, file);
	return 1;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
pushq $0x2
popq %rdx
movq %rax, %rdi
callq 0x69e9
testl %eax, %eax
jle 0x6916
movq 0x28(%rsp), %rdi
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rsi
callq 0x31b0
testq %rax, %rax
je 0x691a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x689f
jmp 0x691e
pushq $-0x1
jmp 0x6920
andl $0x0, 0x18(%rbx)
pushq $0x1
popq %rax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/xemul[P]cylang/stream.c
// Function: eval_read
static int eval_read(struct cy_token *t, struct cy_file *f)
{
	struct cy_token ft, sft;
	struct stream_format *sf;

	if (cy_eval_next_x(f, &ft, CY_V_STREAM) <= 0)
		return -1;
	if (cy_eval_next_x(f, &sft, CY_V_STRING) <= 0)
		return -1;

	if (feof(ft.v.v_stream->f))
		return 1;

	sf = get_format(sft.v.v_str);
	if (!sf) {
		show_token_err(t, "Unknown read format %s", sft.v.v_str);
		return -1;
	}

	return sf->read(ft.v.v_stream, &t->v);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
pushq $0x7
popq %rdx
movq %r15, %rdi
callq 0x69e9
pushq $-0x1
popq %rbx
testl %eax, %eax
jle 0x69c7
leaq 0x30(%rsp), %rsi
pushq $0x2
popq %rdx
movq %r15, %rdi
callq 0x69e9
testl %eax, %eax
jle 0x69c7
movq 0x28(%rsp), %rax
movq (%rax), %rdi
callq 0x3130
testl %eax, %eax
je 0x6979
pushq $0x1
popq %rbx
jmp 0x69c7
leaq 0x4400(%rip), %r12      # 0xad80
movq 0x50(%rsp), %r15
movq (%r12), %rdi
testq %rdi, %rdi
je 0x69b3
movq %r15, %rsi
callq 0x3110
addq $0x10, %r12
testl %eax, %eax
jne 0x6985
movq 0x28(%rsp), %rdi
addq $0x18, %r14
movq %r14, %rsi
callq *-0x8(%r12)
movl %eax, %ebx
jmp 0x69c7
leaq 0xddc(%rip), %rsi       # 0x7796
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x332c
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/xemul[P]cylang/stream.c
// Function: read_line
static int read_line(struct cy_stream *st, struct cy_value *v)
{
	char *str = NULL;
	size_t len = 0;
	ssize_t sz;

	sz = getline(&str, &len, st->f);
	if (sz <= 0)
		return feof(st->f) ? 1 : -1;

	v->t = CY_V_STRING;
	v->v_str = str;
	str[sz - 1] = '\0';
	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
andq $0x0, (%rdi)
leaq 0x10(%rsp), %rsi
andq $0x0, (%rsi)
movq (%r14), %rdx
callq 0x31e0
testq %rax, %rax
jle 0x6ac1
movl $0x2, (%rbx)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rbx)
movb $0x0, -0x1(%rcx,%rax)
pushq $0x1
popq %rax
jmp 0x6ad5
movq (%r14), %rdi
callq 0x3130
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
sbbl %eax, %eax
orl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/redis-force[P]rpm/module/rpm.c
// Function: rpm_context_destroy
static void rpm_context_destroy(RedisModuleCtx *ctx, rpm_context *rpm) {
  char **argv;
  if (rpm->worker != NULL) {
    rpm_worker_suicide(ctx, rpm->worker);
    rpm_worker_destroy(ctx, rpm, rpm->worker);
  }
  if (rpm->command_timeout != NULL) {
    hash_map_destroy(rpm->command_timeout);
  }
  if (rpm->restart_timer != -1) {
    RedisModule_DeleteTimeEvent(ctx, rpm->restart_timer);
  }
  allocator_destroy(rpm->allocator);
  for (argv = rpm->argv; *argv != NULL; ++argv) {
    RedisModule_Free(*argv);
  }
  RedisModule_Free(rpm->argv);
  RedisModule_Free(rpm->shutdown_command);
  RedisModule_Free(rpm);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
je 0x61e8
movq %r14, %rdi
callq 0x739f
movq 0x10(%rbx), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7159
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x61f6
callq 0x5120
movq 0x50(%rbx), %rsi
cmpq $-0x1, %rsi
je 0x620c
movq 0x7a69(%rip), %rax      # 0xdc70
movq %r14, %rdi
callq *(%rax)
movq 0x20(%rbx), %rdi
callq 0x5050
movq (%rbx), %r14
movq 0x79f9(%rip), %r15      # 0xdc18
movq (%r14), %rdi
movq (%r15), %rax
testq %rdi, %rdi
je 0x6232
callq *%rax
addq $0x8, %r14
jmp 0x621f
movq (%rbx), %rdi
callq *%rax
movq 0x48(%rbx), %rdi
callq *(%r15)
movq %rbx, %rdi
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
jmpq *(%rax)
// File: /workspace/github_c_makefile_star2_O2/redis-force[P]rpm/module/rpm.c
// Function: rpm_context_string_config_parser
static void rpm_context_string_config_parser(void *field, RedisModuleString **argv) {
  size_t len;
  char *copy;
  const char *arg = RedisModule_StringPtrLen(argv[0], &len);
  copy = RedisModule_Alloc(len + 1);
  memcpy(copy, arg, len);
  copy[len] = '\0';
  *((char **) field) = copy;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x743b(%rip), %rax      # 0xdfd8
movq (%rsi), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq *(%rax)
movq %rax, %r15
movq 0x71be(%rip), %rax      # 0xdd70
movq (%r14), %rdi
incq %rdi
callq *(%rax)
movq %rax, %r12
movq (%r14), %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x5220
movq (%r14), %rax
movb $0x0, (%r12,%rax)
movq %r12, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/redis-force[P]rpm/module/rpm.c
// Function: rpm_worker_command_on_reply
static int rpm_worker_command_on_reply(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
  void *data = RedisModule_GetBlockedClientPrivateData(ctx);
  REDISMODULE_NOT_USED(argv);
  REDISMODULE_NOT_USED(argc);
  if (data == RPM_BAD_GATEWAY) {
    RedisModule_ReplyWithError(ctx, RPM_BAD_GATEWAY);
  } else {
    redis_response *reply = data;
    rpm_worker_command_on_reply_item(ctx, reply->payload.array.array[2]);
  }
  return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x7213(%rip), %rax      # 0xde00
callq *(%rax)
movq 0x7322(%rip), %rcx      # 0xdf18
movq (%rcx), %rsi
cmpq %rsi, %rax
je 0x6c10
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
movq %rbx, %rdi
callq 0x6cdb
jmp 0x6c1c
movq 0x7289(%rip), %rax      # 0xdea0
movq %rbx, %rdi
callq *(%rax)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/redis-force[P]rpm/module/rpm.c
// Function: rpm_worker_command_on_timeout
static int rpm_worker_command_on_timeout(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
  size_t tmp;
  rpm_context *rpm = rpm_context_get(ctx);
  long long request_id, client_id = RedisModule_GetClientId(ctx);
  REDISMODULE_NOT_USED(argv);
  REDISMODULE_NOT_USED(argc);
  if (hash_map_find(rpm->worker->client_id_to_request_id, hash_map_int_ptr(client_id), sizeof(client_id), (const void **) &request_id, &tmp) == 0) {
    hash_map_remove(rpm->worker->client_id_to_request_id, hash_map_int_ptr(client_id), sizeof(client_id));
    hash_map_remove(rpm->worker->request_id_to_client, hash_map_int_ptr(request_id), sizeof(request_id));
  }
  return RedisModule_ReplyWithError(ctx, RPM_REQUEST_TIMEOUT);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x6fd3(%rip), %rax      # 0xdc08
xorl %esi, %esi
xorl %edx, %edx
callq *(%rax)
movq %rax, %r14
movq 0x71a3(%rip), %rax      # 0xdde8
movq %rbx, %rdi
callq *(%rax)
movq %rax, %r15
movq 0x10(%r14), %rax
movq 0xa0(%rax), %rdi
pushq $0x8
popq %rdx
leaq 0x8(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %r15, %rsi
callq 0x51d0
testl %eax, %eax
jne 0x6ca3
movq 0x10(%r14), %rax
movq 0xa0(%rax), %rdi
pushq $0x8
popq %r12
movq %r15, %rsi
movq %r12, %rdx
callq 0x5400
movq 0x10(%r14), %rax
movq 0x98(%rax), %rdi
movq 0x8(%rsp), %rsi
movq %r12, %rdx
callq 0x5400
movq 0x71f6(%rip), %rax      # 0xdea0
movq 0x70f7(%rip), %rcx      # 0xdda8
movq (%rcx), %rsi
movq %rbx, %rdi
callq *(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/redis-force[P]rpm/module/rpm.c
// Function: rpm_worker_command_on_reply_item
static int rpm_worker_command_on_reply_item(RedisModuleCtx *ctx, redis_response *item) {
  size_t idx;
  switch (item->type) {
    case REDIS_RESPONSE_STRING:
      RedisModule_ReplyWithStringBuffer(ctx, item->payload.string.str, item->payload.string.length);
      break;
    case REDIS_RESPONSE_ARRAY:
      RedisModule_ReplyWithArray(ctx, item->payload.array.length);
      for (idx = 0; idx < item->payload.array.length; ++idx) {
        rpm_worker_command_on_reply_item(ctx, item->payload.array.array[idx]);
      }
      break;
    case REDIS_RESPONSE_INTEGER:
      RedisModule_ReplyWithLongLong(ctx, item->payload.integer);
      break;
    case REDIS_RESPONSE_NIL:
      RedisModule_ReplyWithNull(ctx);
      break;
    case REDIS_RESPONSE_STATUS:
      RedisModule_ReplyWithSimpleString(ctx, item->payload.string.str);
      break;
    case REDIS_RESPONSE_ERROR:
      RedisModule_ReplyWithError(ctx, item->payload.string.str);
      break;
    default:
      assert(0);
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl (%rsi), %eax
decl %eax
cmpl $0x5, %eax
ja 0x6d8e
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3306(%rip), %rcx      # 0xa000
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x6fb6(%rip), %rax      # 0xdcc0
movq (%rax), %rax
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
movq 0x6f6a(%rip), %rax      # 0xdc90
jmp 0x6d7d
movq 0x6f39(%rip), %rax      # 0xdc68
jmp 0x6d7d
movq 0x72b0(%rip), %rax      # 0xdfe8
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *(%rax)
movq 0x7227(%rip), %rax      # 0xdf70
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq *(%rax)
xorl %r15d, %r15d
cmpq 0x18(%r14), %r15
jae 0x6d70
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x6cdb
incq %r15
jmp 0x6d55
popq %rbx
popq %r14
popq %r15
retq
movq 0x7123(%rip), %rax      # 0xdea0
movq (%rax), %rax
movq 0x10(%r14), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
leaq 0x40ed(%rip), %rdi      # 0xae82
leaq 0x40e8(%rip), %rsi      # 0xae84
leaq 0x40e7(%rip), %rcx      # 0xae8a
movl $0xfc, %edx
callq 0x5100
// File: /workspace/github_c_makefile_star2_O2/redis-force[P]rpm/module/rpm.c
// Function: rpm_worker_upstream_buffer_write
static void rpm_worker_upstream_buffer_write(RedisModuleCtx *ctx, int fd, void *client_data, int mask) {
  worker_pipe *pipe = client_data;
  chained_buffer *current = pipe->read_buffer;
  int wr = 0, count = 0, available;
  REDISMODULE_NOT_USED(ctx);
  REDISMODULE_NOT_USED(mask);
  while (current != NULL) {
    available = current->size - current->offset;
    if ((wr = write(fd, current->buffer + current->offset, available)) < available) {
      /* there are data leftover inside current buffer */
      if (wr > 0) {
        current->offset += wr;
      }
      break;
    }
    ++count;
    current = current->next;
  }

  chained_buffer_destroy(&pipe->read_buffer, count);
  pipe->num_buffers -= count;
  if (pipe->read_buffer == NULL) {
    rpm_worker_pipe_buffer_reset(pipe);
    RedisModule_DeleteFileEvent(ctx, fd, REDISMODULE_WRITE);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, (%rsp)
leaq 0x8(%rdx), %r14
xorl %r13d, %r13d
movq %r14, %r12
movq (%r12), %r12
testq %r12, %r12
je 0x6e05
movslq 0xc(%r12), %rbp
movslq 0x8(%r12), %rax
subq %rax, %rbp
leaq (%r12,%rax), %rsi
addq $0x20, %rsi
movl %ebx, %edi
movq %rbp, %rdx
callq 0x5090
cmpl %eax, %ebp
jg 0x6dfc
incq %r13
jmp 0x6dcb
testl %eax, %eax
jle 0x6e05
addl %eax, 0x8(%r12)
movq %r14, %rdi
movq %r13, %rsi
callq 0x50e0
subl %r13d, 0x20(%r15)
cmpq $0x0, 0x8(%r15)
je 0x6e2a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%r15), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq %rax, 0x18(%r15)
andl $0x0, 0x20(%r15)
movq 0x6dcb(%rip), %rax      # 0xdc10
movq (%rax), %rax
pushq $0x2
popq %rdx
movq (%rsp), %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/redis-force[P]rpm/module/rpm.c
// Function: rpm_worker_pipe_init
static int rpm_worker_pipe_init(RedisModuleCtx *ctx, worker_process *worker, worker_pipe *p, RedisModuleFileProc read, int spair) {
  if (spair) {
    if (socketpair(AF_UNIX,SOCK_STREAM, 0, p->pipe) < 0) {
      return REDISMODULE_ERR;
    }
  } else {
    if (pipe(p->pipe) != 0) {
      return REDISMODULE_ERR;
    }
  }
  RedisModule_EnableNonBlock(ctx, p->pipe[0]);
  rpm_worker_pipe_buffer_reset(p);
  p->worker = worker;

  if (read != NULL) {
    return RedisModule_CreateFileEvent(ctx, p->pipe[0], REDISMODULE_READ, read, p);
  }
  return REDISMODULE_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
leaq 0x24(%rdx), %rcx
testl %r8d, %r8d
je 0x6e92
pushq $0x1
popq %rbp
movl %ebp, %edi
movl %ebp, %esi
xorl %edx, %edx
callq 0x5230
testl %eax, %eax
jns 0x6ea3
jmp 0x6ef2
movq %rcx, %rdi
callq 0x5150
testl %eax, %eax
je 0x6ea3
pushq $0x1
popq %rbp
jmp 0x6ef2
movq 0x6f06(%rip), %rax      # 0xddb0
movl 0x24(%rbx), %esi
movq %r15, %rdi
callq *(%rax)
leaq 0x10(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq %rax, 0x18(%rbx)
andl $0x0, 0x20(%rbx)
movq %r12, (%rbx)
testq %r14, %r14
je 0x6ef0
movq 0x6cd4(%rip), %rax      # 0xdba8
movq (%rax), %rax
movl 0x24(%rbx), %esi
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rcx
movq %rbx, %r8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq