LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x639f
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 0x63ba
movq %rax, %r14
movb $0x0, (%rax)
incq %r14
jmp 0x63bd
leaq 0x216a(%rip), %rsi      # 0x8510
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x643e
xorl %r14d, %r14d
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x4aca
testl %eax, %eax
js 0x6436
movl -0x38(%rbp), %edi
cmpl $0x1, %edi
je 0x63ef
cmpl $0x2, %edi
jne 0x641d
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x3090
movq %rbx, %rdi
movl %eax, %esi
jmp 0x6414
testq %r14, %r14
leaq 0x212d(%rip), %rsi      # 0x8526
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 0x62c8
xorl %eax, %eax
jmp 0x643b
callq 0x3bbc
leaq 0x2101(%rip), %rsi      # 0x852a
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
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_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movups 0x28(%rsi), %xmm0
movaps %xmm0, 0x30(%rsp)
movq 0x20(%rdi), %rsi
movq %rbx, %rdi
callq 0x42ae
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movq $0x0, 0x20(%rsi)
movq %rbx, %rdi
callq 0x42c4
testl %eax, %eax
js 0x64ee
movq %rsp, %r12
testl %eax, %eax
je 0x64f3
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x64b7
movq %r12, %rdi
movq %rbx, %rsi
callq *%rcx
cmpl $0x1, %eax
jne 0x64fa
movq 0x8(%r15), %rax
cmpq $0x70000005, 0x10(%rax) # imm = 0x70000005
je 0x6509
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq $0x0, 0x20(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x42c4
testl %eax, %eax
jns 0x649d
callq 0x377c
movl $0x1, %ecx
jmp 0x6517
movl $0x1, %ecx
cmpl $0x2, %eax
cmovael %eax, %ecx
je 0x650e
jmp 0x6517
movl $0x2, %ecx
movups 0x18(%rsp), %xmm0
movups %xmm0, (%r14)
movaps 0x30(%rsp), %xmm0
movups %xmm0, 0x28(%rbx)
movl %ecx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r15
movq %rdi, %r14
leaq 0x40(%rsp), %rsi
movq %r15, %rdi
callq 0x42c4
testl %eax, %eax
js 0x66c6
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
je 0x66b9
movq 0x48(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x65a8
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
callq *%rcx
cmpl $0x1, %eax
jne 0x65c8
cmpl $0x5, 0x58(%rsp)
je 0x65ce
movl $0x5, %edi
callq 0x3bbc
movq %rax, %r14
leaq 0x40(%rsp), %r15
jmp 0x661f
jl 0x66b9
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x42c4
testl %eax, %eax
js 0x66cb
je 0x66b9
movq 0x20(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x6601
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq *%rcx
cmpl $0x1, %eax
jne 0x6641
cmpl $0x4, 0x30(%rsp)
je 0x6643
movl $0x4, %edi
callq 0x3bbc
movq %rax, %r14
leaq 0x18(%rsp), %r15
movl 0x18(%r15), %edi
callq 0x3bbc
leaq 0x1b20(%rip), %rsi      # 0x814f
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
jmp 0x66b9
jl 0x66b9
movq 0x38(%rsp), %rax
leaq 0x6ae9(%rip), %rbx      # 0xd138
cmpq 0x8(%rbx), %rax
je 0x669b
movl (%rbx), %ebp
movq 0x4(%rbx), %rax
movq %rax, 0x8(%rsp)
movl 0xc(%rbx), %eax
movl %eax, 0x10(%rsp)
movups 0x30(%rsp), %xmm0
movups %xmm0, (%rbx)
addq $0x18, %r14
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x6450
testl %ebp, %ebp
je 0x66af
movl %ebp, (%rbx)
movq 0x8(%rsp), %rcx
movq %rcx, 0x4(%rbx)
movl 0x10(%rsp), %ecx
movl %ecx, 0xc(%rbx)
jmp 0x66af
addq $0x18, %r14
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x6450
testl %eax, %eax
movl $0x1, %ebx
cmovsl %eax, %ebx
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x37c6
callq 0x37a1
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/cblock.c
// Function: eval_return
static int eval_return(struct cy_token *t, struct cy_file *f)
{
	struct cy_token rt;

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

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x42c4
testl %eax, %eax
js 0x672b
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
je 0x6720
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x6712
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *%rax
testl %eax, %eax
jle 0x6720
movups 0x20(%rsp), %xmm0
movups %xmm0, 0x18(%rbx)
movl $0x2, %ebp
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x37eb
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/cblock.c
// Function: eval_value_return
static int eval_value_return(struct cy_token *t, struct cy_file *f)
{
	struct cy_token rt;

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

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

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x42c4
testl %eax, %eax
js 0x679c
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
je 0x6791
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x6772
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *%rax
testl %eax, %eax
jle 0x6791
cmpl $0x0, 0x20(%rsp)
je 0x678c
leaq 0x20(%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, 0x18(%rbx)
movl $0x2, %ebp
jmp 0x6791
movl $0x1, %ebp
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x3810
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x42c4
testl %eax, %eax
js 0x67fe
je 0x67e3
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x67ea
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq *%rax
xorl %ecx, %ecx
cmpl $0x1, 0x18(%r14)
adcl $0x1, %ecx
testl %eax, %eax
jg 0x67f4
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jmp 0x67f4
xorl %ecx, %ecx
cmpl $0x1, 0x18(%rsp)
adcl $0x1, %ecx
movl %ecx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
callq 0x3835
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x684a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x1, %ecx
jne 0x685b
movl 0x8(%rdi), %eax
subl 0x8(%rsi), %eax
jmp 0x6857
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_O3/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, %r15
movq %rdi, %r14
leaq 0x30(%rsp), %rsi
movq %r15, %rdi
callq 0x42c4
testl %eax, %eax
js 0x69e6
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
je 0x69d9
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x68b9
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq *%rax
testl %eax, %eax
jle 0x69d9
movl 0x48(%rsp), %ebp
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x42c4
testl %eax, %eax
js 0x69eb
je 0x69d9
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x68f0
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq *%rcx
cmpl $0x1, %eax
jne 0x692f
cmpl %ebp, 0x20(%rsp)
je 0x6935
movl %ebp, %edi
callq 0x3bbc
movq %rax, %r14
leaq 0x8(%rsp), %r15
movl 0x18(%r15), %edi
callq 0x3bbc
leaq 0x1835(%rip), %rsi      # 0x814f
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
jmp 0x69d9
jl 0x69d9
movl $0x6, 0x18(%r14)
movl 0x48(%rsp), %edi
cmpl $0x2, %edi
je 0x6955
cmpl $0x1, %edi
jne 0x6993
movl 0x50(%rsp), %eax
subl 0x28(%rsp), %eax
jmp 0x6964
movq 0x50(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x3110
movq 0x8(%r14), %rcx
movq 0x10(%rcx), %rcx
movl $0x1, %ebx
decq %rcx
cmpq $0x5, %rcx
ja 0x69d9
leaq 0x1c4f(%rip), %rdx      # 0x85d0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
testl %eax, %eax
sete 0x20(%r14)
jmp 0x69d9
callq 0x3bbc
leaq 0x1c9c(%rip), %rsi      # 0x863b
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3240
jmp 0x69d9
testl %eax, %eax
setle 0x20(%r14)
jmp 0x69d9
testl %eax, %eax
setns 0x20(%r14)
jmp 0x69d9
testl %eax, %eax
setg 0x20(%r14)
jmp 0x69d9
testl %eax, %eax
setne 0x20(%r14)
jmp 0x69d9
shrl $0x1f, %eax
movb %al, 0x20(%r14)
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x387f
callq 0x385a
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x42c4
testl %eax, %eax
js 0x6a52
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
je 0x6a47
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x6a32
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *%rax
testl %eax, %eax
jle 0x6a47
movl $0x6, 0x18(%rbx)
cmpl $0x0, 0x20(%rsp)
sete 0x20(%rbx)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x38a4
// File: /workspace/github_c_makefile_star2_O3/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 0x42c4
testl %eax, %eax
js 0x703c
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
je 0x7035
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x6ffd
movq %rbx, %rdi
movq %r14, %rsi
callq *%rax
testl %eax, %eax
jle 0x7035
movl $0x1, %ebp
cmpl $0x5, 0x18(%rbx)
je 0x7035
movq %rbx, %rdi
callq 0x652e
testb %al, %al
jne 0x7035
movl 0x18(%rbx), %edi
callq 0x3bbc
leaq 0x1652(%rip), %rsi      # 0x8675
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 0x3938
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x714d
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 0x7172
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_O3/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 0x7589
cmpl $0x2d, %edx
je 0x756b
cmpl $0x2b, %edx
jne 0x756a
cmpb $0x0, 0x2(%rcx)
je 0x759c
retq
cmpb $0x0, 0x2(%rcx)
jne 0x756a
leaq 0x5758(%rip), %rax      # 0xccd0
movq %rax, 0x8(%rdi)
movl $0x6, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
jmp 0x75b2
cmpb $0x0, 0x2(%rcx)
jne 0x756a
leaq 0x5752(%rip), %rax      # 0xcce8
movq %rax, 0x8(%rdi)
jmp 0x75b2
leaq 0x572d(%rip), %rax      # 0xccd0
movq %rax, 0x8(%rdi)
movl $0x6, 0x18(%rdi)
movb $0x1, 0x20(%rdi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x42c4
testl %eax, %eax
js 0x76b5
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
je 0x76a9
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x7636
movq %rsp, %rdi
movq %r15, %rsi
callq *%rax
testl %eax, %eax
jle 0x76a9
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x42c4
testl %eax, %eax
js 0x76ba
je 0x76a9
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x7665
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq *%rax
testl %eax, %eax
jle 0x76a9
movl $0x6, 0x18(%r14)
movl 0x18(%rsp), %edi
cmpl $0x3, %edi
jne 0x7690
movq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x54c7
movb %al, 0x20(%r14)
movl $0x1, %ebx
jmp 0x76a9
callq 0x3bbc
leaq 0x1072(%rip), %rsi      # 0x870e
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3240
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x3982
callq 0x395d
// File: /workspace/github_c_makefile_star2_O3/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 0x42c4
testl %eax, %eax
js 0x77bc
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
je 0x77b1
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x770d
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *%rax
testl %eax, %eax
jle 0x77b1
movl $0x1, 0x18(%rbx)
movl 0x20(%rsp), %edi
cmpl $0x4, %edi
je 0x776e
cmpl $0x3, %edi
je 0x773c
cmpl $0x2, %edi
jne 0x7798
movq 0x28(%rsp), %rdi
callq 0x3090
movq %rax, 0x20(%rbx)
movl $0x1, %ebp
jmp 0x77b1
movq $0x0, 0x20(%rbx)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rcx
movl $0x1, %ebp
cmpq %rax, %rcx
je 0x77b1
movl $0x1, %edx
movq %rdx, 0x20(%rbx)
movq 0x8(%rcx), %rcx
incq %rdx
cmpq %rax, %rcx
jne 0x775c
jmp 0x77b1
movq $0x0, 0x20(%rbx)
movq 0x28(%rsp), %rdi
callq 0x7453
movl $0x1, %ebp
testq %rax, %rax
je 0x77b1
incq 0x20(%rbx)
movq %rax, %rdi
callq 0x7483
jmp 0x7785
callq 0x3bbc
leaq 0xf8a(%rip), %rsi       # 0x872e
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 0x39a7
// File: /workspace/github_c_makefile_star2_O3/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 0x42c4
testl %eax, %eax
js 0x7856
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
je 0x784b
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x7803
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq *%rax
testl %eax, %eax
jle 0x784b
movq %rsp, %rsi
movq %r14, %rdi
callq 0x42c4
testl %eax, %eax
js 0x785b
je 0x784b
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x782e
movq %rsp, %rdi
movq %r14, %rsi
callq *%rax
testl %eax, %eax
jle 0x784b
leaq 0x40(%rsp), %rax
cmpl $0x0, (%rax)
leaq 0x18(%rsp), %rcx
cmovneq %rax, %rcx
movups (%rcx), %xmm0
movups %xmm0, 0x18(%rbx)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x39f1
callq 0x39cc
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x42c4
testl %eax, %eax
js 0x7916
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
je 0x78e7
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x78a7
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq *%rax
testl %eax, %eax
jle 0x78e7
movl 0x20(%rsp), %eax
movl $0x1, %ebx
cmpq $0x6, %rax
ja 0x78da
leaq 0xdeb(%rip), %rcx       # 0x86a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq $0x0, 0x28(%rsp)
jne 0x78da
jmp 0x78e7
movq 0x28(%rsp), %rax
cmpb $0x0, (%rax)
je 0x78e7
leaq 0x20(%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, 0x18(%r14)
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
cmpb $0x1, 0x28(%rsp)
je 0x78da
jmp 0x78e7
movq 0x28(%rsp), %rax
cmpq %rax, 0x8(%rax)
jne 0x78da
jmp 0x78e7
movq 0x28(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x78da
jmp 0x78e7
callq 0x3a16
// File: /workspace/github_c_makefile_star2_O3/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 0x42c4
testl %eax, %eax
js 0x79fa
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
je 0x79ee
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x7962
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq *%rcx
cmpl $0x1, %eax
jne 0x79a2
cmpl $0x2, 0x20(%rsp)
je 0x79a4
movl $0x2, %edi
callq 0x3bbc
movq %rax, %r14
leaq 0x8(%rsp), %r15
movl 0x18(%r15), %edi
callq 0x3bbc
leaq 0x7bf(%rip), %rsi       # 0x814f
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
jmp 0x79ee
jl 0x79ee
leaq 0x8(%rsp), %rdi
movq 0x20(%rdi), %rax
movq %rax, (%rdi)
movl $0x0, 0x18(%rdi)
callq 0x3d84
testl %eax, %eax
js 0x79ee
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x79dc
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq *%rax
testl %eax, %eax
jle 0x79ee
leaq 0x20(%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, 0x18(%r14)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x3a3b
nop
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rcx
movzbl 0x1(%rcx), %edx
xorl %eax, %eax
cmpl $0x3e, %edx
je 0x7a29
cmpl $0x3c, %edx
jne 0x7a7c
cmpb $0x0, 0x2(%rcx)
jne 0x7a7c
movq 0x45b1(%rip), %rcx      # 0xbfd8
jmp 0x7a4c
movzbl 0x2(%rcx), %edx
testl %edx, %edx
je 0x7a45
cmpl $0x21, %edx
jne 0x7a7c
cmpb $0x0, 0x3(%rcx)
jne 0x7a7c
movq 0x45b5(%rip), %rcx      # 0xbff8
jmp 0x7a4c
movq 0x4584(%rip), %rcx      # 0xbfd0
movq (%rcx), %r14
testq %r14, %r14
je 0x7a7c
leaq 0x53c5(%rip), %rax      # 0xce20
movq %rax, 0x8(%rbx)
movl $0x7, 0x18(%rbx)
movl $0x8, %edi
callq 0x3180
movq %rax, 0x20(%rbx)
movq %r14, (%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x42c4
testl %eax, %eax
js 0x7b67
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
je 0x7b5b
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x7ad7
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq *%rcx
cmpl $0x1, %eax
jne 0x7b17
cmpl $0x2, 0x20(%rsp)
je 0x7b19
movl $0x2, %edi
callq 0x3bbc
movq %rax, %r14
leaq 0x8(%rsp), %r15
movl 0x18(%r15), %edi
callq 0x3bbc
leaq 0x64a(%rip), %rsi       # 0x814f
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
jmp 0x7b5b
jl 0x7b5b
movq 0x28(%rsp), %rdi
movq 0x8(%r14), %rax
movq 0x10(%rax), %rsi
callq 0x31b0
testq %rax, %rax
je 0x7b4e
movq %rax, %rbx
movl $0x7, 0x18(%r14)
movl $0x8, %edi
callq 0x3180
movq %rax, 0x20(%r14)
movq %rbx, (%rax)
jmp 0x7b56
movl $0x0, 0x18(%r14)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x3a60
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x42c4
testl %eax, %eax
js 0x7cd8
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
je 0x7cb2
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x7bb4
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
cmpl $0x1, %eax
jne 0x7bd4
cmpl $0x7, 0x20(%rsp)
je 0x7bda
movl $0x7, %edi
callq 0x3bbc
movq %rax, %rbx
leaq 0x8(%rsp), %r14
jmp 0x7c2b
jl 0x7cb2
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x42c4
testl %eax, %eax
js 0x7cdd
je 0x7cb2
movq 0x38(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x7c0d
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
cmpl $0x1, %eax
jne 0x7c52
cmpl $0x2, 0x48(%rsp)
je 0x7c54
movl $0x2, %edi
callq 0x3bbc
movq %rax, %rbx
leaq 0x30(%rsp), %r14
movl 0x18(%r14), %edi
callq 0x3bbc
leaq 0x514(%rip), %rsi       # 0x814f
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x7cb2
jl 0x7cb2
movq 0x28(%rsp), %rax
movq (%rax), %rdi
callq 0x3130
movl $0x1, %ebp
testl %eax, %eax
jne 0x7cb2
movq 0x50(%rsp), %r14
leaq 0xb37(%rip), %rdi       # 0x87ad
movq %r14, %rsi
callq 0x3110
leaq 0x40fb(%rip), %r15      # 0xbd80
testl %eax, %eax
je 0x7ca0
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x7cbf
movq %r14, %rsi
callq 0x3110
addq $0x10, %r15
jmp 0x7c85
movq 0x28(%rsp), %rdi
addq $0x18, %rbx
movq %rbx, %rsi
callq *0x8(%r15)
movl %eax, %ebp
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xad0(%rip), %rsi       # 0x8796
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3240
jmp 0x7c4b
callq 0x3aaa
callq 0x3a85
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
movq %rsp, %rdi
movq %rbx, (%rdi)
leaq 0x8(%rsp), %rsi
movq %rbx, (%rsi)
movq (%r15), %rdx
callq 0x31e0
testq %rax, %rax
jle 0x7d3f
movl $0x2, (%r14)
movq (%rsp), %rcx
movq %rcx, 0x8(%r14)
movb $0x0, -0x1(%rcx,%rax)
movl $0x1, %ebx
jmp 0x7d4f
movq (%r15), %rdi
callq 0x3130
cmpl $0x1, %eax
sbbl %ebx, %ebx
orl $0x1, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x622c
movq %r14, %rdi
callq 0x7569
movq 0x10(%rbx), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x72ef
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x623a
callq 0x5110
movq 0x50(%rbx), %rsi
cmpq $-0x1, %rsi
je 0x6250
movq 0x7a25(%rip), %rax      # 0xdc70
movq %r14, %rdi
callq *(%rax)
movq 0x20(%rbx), %rdi
callq 0x5050
movq (%rbx), %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0x6281
addq $0x8, %r14
movq 0x79a9(%rip), %r15      # 0xdc18
callq *(%r15)
movq (%r14), %rdi
addq $0x8, %r14
testq %rdi, %rdi
jne 0x626f
movq (%rbx), %r14
movq 0x7990(%rip), %r15      # 0xdc18
movq %r14, %rdi
callq *(%r15)
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_O3/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 0x75c0(%rip), %rax      # 0xdfd8
movq (%rsi), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq *(%rax)
movq %rax, %r15
movq 0x7343(%rip), %rax      # 0xdd70
movq (%r14), %rdi
incq %rdi
callq *(%rax)
movq %rax, %r12
movq (%r14), %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x5210
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_O3/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 0x7398(%rip), %rax      # 0xde00
callq *(%rax)
movq 0x74a7(%rip), %rcx      # 0xdf18
movq (%rcx), %rsi
cmpq %rsi, %rax
je 0x6a8b
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
movq %rbx, %rdi
callq 0x6b51
jmp 0x6a97
movq 0x740e(%rip), %rax      # 0xdea0
movq %rbx, %rdi
callq *(%rax)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x715a(%rip), %rax      # 0xdc08
xorl %esi, %esi
xorl %edx, %edx
callq *(%rax)
movq %rax, %r14
movq 0x732a(%rip), %rax      # 0xdde8
movq %rbx, %rdi
callq *(%rax)
movq %rax, %r15
movq 0x10(%r14), %rax
movq 0xa0(%rax), %rdi
movq %rsp, %rcx
leaq 0x8(%rsp), %r8
movl $0x8, %edx
movq %r15, %rsi
callq 0x51c0
testl %eax, %eax
jne 0x6b1b
movq 0x10(%r14), %rax
movq 0xa0(%rax), %rdi
movl $0x8, %edx
movq %r15, %rsi
callq 0x53f0
movq 0x10(%r14), %rax
movq 0x98(%rax), %rdi
movq (%rsp), %rsi
movl $0x8, %edx
callq 0x53f0
movq 0x737e(%rip), %rax      # 0xdea0
movq 0x727f(%rip), %rcx      # 0xdda8
movq (%rcx), %rsi
movq %rbx, %rdi
callq *(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6c09
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3490(%rip), %rcx      # 0xa000
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x7140(%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 0x70f4(%rip), %rax      # 0xdc90
jmp 0x6bf8
movq 0x70c3(%rip), %rax      # 0xdc68
jmp 0x6bf8
movq 0x743a(%rip), %rax      # 0xdfe8
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *(%rax)
movq 0x73b1(%rip), %rax      # 0xdf70
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq *(%rax)
cmpq $0x0, 0x18(%r14)
je 0x6beb
xorl %r15d, %r15d
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x6b51
incq %r15
cmpq 0x18(%r14), %r15
jb 0x6bd2
popq %rbx
popq %r14
popq %r15
retq
movq 0x72a8(%rip), %rax      # 0xdea0
movq (%rax), %rax
movq 0x10(%r14), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
leaq 0x4272(%rip), %rdi      # 0xae82
leaq 0x426d(%rip), %rsi      # 0xae84
leaq 0x426c(%rip), %rcx      # 0xae8a
movl $0xfc, %edx
callq 0x50f0
// File: /workspace/github_c_makefile_star2_O3/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), %r12
movq 0x8(%rdx), %r14
xorl %ebp, %ebp
testq %r14, %r14
je 0x6c7c
movslq 0xc(%r14), %r13
movslq 0x8(%r14), %rax
subq %rax, %r13
leaq (%r14,%rax), %rsi
addq $0x20, %rsi
movl %ebx, %edi
movq %r13, %rdx
callq 0x5080
cmpl %eax, %r13d
jg 0x6c74
incl %ebp
movq (%r14), %r14
jmp 0x6c46
testl %eax, %eax
jle 0x6c7c
addl %eax, 0x8(%r14)
movl %ebp, %esi
movq %r12, %rdi
callq 0x50d0
subl %ebp, 0x20(%r15)
cmpq $0x0, 0x8(%r15)
je 0x6ca0
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, (%r12)
movq %rax, 0x18(%r15)
movl $0x0, 0x20(%r15)
movq 0x6f51(%rip), %rax      # 0xdc10
movq (%rax), %rax
movq (%rsp), %rdi
movl %ebx, %esi
movl $0x2, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/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 0x6d16
movl $0x1, %ebp
movl $0x1, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x5220
testl %eax, %eax
jns 0x6d27
jmp 0x6d7b
movq %rcx, %rdi
callq 0x5140
movl $0x1, %ebp
testl %eax, %eax
jne 0x6d7b
movq 0x7082(%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)
movl $0x0, 0x20(%rbx)
movq %r12, (%rbx)
testq %r14, %r14
je 0x6d79
movq 0x6e4d(%rip), %rax      # 0xdba8
movq (%rax), %rax
movl 0x24(%rbx), %esi
movq %r15, %rdi
movl $0x1, %edx
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
// File: /workspace/github_c_makefile_star2_O3/redis-force[P]rpm/module/rpm.c
// Function: rpm_worker_suicide
static void rpm_worker_suicide(RedisModuleCtx *ctx, worker_process *worker) {
  int32_t idx;
  for (idx = 0; idx < worker->num_upstreams; ++idx) {
    rpm_worker_close_pipe(ctx, worker->upstreams + idx);
  }
  for (idx = 0; idx < worker->num_downstreams; ++idx) {
    if (worker->downstreams[idx] != 0) {
      close(worker->downstreams[idx]);
      worker->downstreams[idx] = 0;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x0, 0x88(%rsi)
jle 0x75ab
movq %rdi, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x90(%rbx), %rsi
addq %r15, %rsi
movq %r14, %rdi
callq 0x75f2
incq %r12
movslq 0x88(%rbx), %rax
addq $0x38, %r15
cmpq %rax, %r12
jl 0x7586
movl 0x78(%rbx), %eax
testl %eax, %eax
jle 0x75e6
movq 0x80(%rbx), %rcx
xorl %r14d, %r14d
movl (%rcx,%r14,4), %edi
testl %edi, %edi
je 0x75db
callq 0x5130
movq 0x80(%rbx), %rcx
movl $0x0, (%rcx,%r14,4)
movl 0x78(%rbx), %eax
incq %r14
movslq %eax, %rdx
cmpq %rdx, %r14
jl 0x75bc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/redis-force[P]rpm/module/rpm.c
// Function: rpm_worker_close_pipe
static void rpm_worker_close_pipe(RedisModuleCtx *ctx, worker_pipe *pipe)
{
  if (pipe->pipe[0]) {
    RedisModule_DeleteFileEvent(ctx, pipe->pipe[0], REDISMODULE_READ | (pipe->write_buffer != NULL ? REDISMODULE_WRITE : 0));
    if (pipe->read_buffer != NULL) {
      chained_buffer_destroy(&pipe->read_buffer, pipe->num_buffers);
    }
    if (pipe->pipe[0] != 0) {
      close(pipe->pipe[0]);
      pipe->pipe[0] = 0;
    }
    if (pipe->pipe[1] != 0) {
      close(pipe->pipe[1]);
      pipe->pipe[1] = 0;
    }
  }
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movl 0x24(%rsi), %esi
testl %esi, %esi
je 0x7651
movq 0x660c(%rip), %rax      # 0xdc10
xorl %ecx, %ecx
cmpq $0x0, 0x10(%rbx)
setne %cl
leal 0x1(,%rcx,2), %edx
callq *(%rax)
cmpq $0x0, 0x8(%rbx)
je 0x762b
leaq 0x8(%rbx), %rdi
movslq 0x20(%rbx), %rsi
callq 0x50d0
movl 0x24(%rbx), %edi
testl %edi, %edi
je 0x763e
callq 0x5130
movl $0x0, 0x24(%rbx)
movl 0x28(%rbx), %edi
testl %edi, %edi
je 0x7651
callq 0x5130
movl $0x0, 0x28(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/redis-force[P]rpm/module/rpm_allocator.c
// Function: chained_buffer_allocator_create
allocator *chained_buffer_allocator_create(int32_t chunk_size) {
  chained_buffer_allocator *allocator;
  chained_buffer *head = NULL;
  if (chunk_size < MIN_CHUNK_SIZE) {
    chunk_size = MIN_CHUNK_SIZE;
  }
  head = chained_buffer_create(libc_allocator, chunk_size + sizeof(chained_buffer_allocator));
  allocator = chained_buffer_allocate(head, sizeof(chained_buffer_allocator));
  allocator->head = head;
  allocator->current = head;
  allocator->next = &head->next;
  allocator->buffer_num = 1;
  allocator->chunk_size = chunk_size;
  return allocator_create(chained_buffer_allocator_malloc, chained_buffer_allocator_calloc,
    chained_buffer_allocator_realloc, chained_buffer_allocator_free, chained_buffer_allocator_destroy, allocator);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x401, %edi            # imm = 0x401
movl $0x400, %r15d           # imm = 0x400
cmovgel %edi, %r15d
movq 0x648c(%rip), %rax      # 0xded8
movq (%rax), %rdi
leal 0x20(%r15), %esi
callq 0x5370
movq %rax, %rbx
movl $0x20, %esi
movq %rax, %rdi
callq 0x53b0
movq %rax, %r14
movq %rbx, (%rax)
movq %rbx, 0x8(%rax)
movq %rbx, 0x10(%rax)
movl $0x1, 0x18(%rax)
movl %r15d, 0x1c(%rax)
movl $0x1, %edi
movl $0x30, %esi
callq 0x51a0
movq 0x6429(%rip), %rcx      # 0xdec0
movq %rcx, (%rax)
movq 0x636f(%rip), %rcx      # 0xde10
movq %rcx, 0x10(%rax)
movq 0x635c(%rip), %rcx      # 0xde08
movq %rcx, 0x8(%rax)
movq 0x6491(%rip), %rcx      # 0xdf48
movq %rcx, 0x18(%rax)
movq 0x64ee(%rip), %rcx      # 0xdfb0
movq %rcx, 0x20(%rax)
movq %r14, 0x28(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/redis-force[P]rpm/module/rpm_chained_buffer.c
// Function: chained_buffer_destroy
void chained_buffer_destroy(chained_buffer **buffer_address, size_t limit) {
  chained_buffer *next;
  chained_buffer *buffer = *buffer_address;
  while (buffer && limit > 0) {
    next = buffer->next;
    allocator_free(buffer->allocator, buffer);
    buffer = next;
    --limit;
  }
  *buffer_address = buffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r15
testq %r15, %r15
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x7b4a
movq %rsi, %r14
decq %r14
movq %r15, %rsi
movq (%r15), %r15
movq 0x18(%rsi), %rdi
callq 0x5040
addq $-0x1, %r14
setb %al
testq %r15, %r15
je 0x7b4a
testb %al, %al
jne 0x7b2b
movq %r15, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/redis-force[P]rpm/module/rpm_chained_buffer.c
// Function: chained_buffer_create
chained_buffer *chained_buffer_create(allocator *allocator, int32_t size)
{
  int32_t allocation_size = CHAINED_BUFFER_SIZE(size);
  int32_t capacity = allocation_size - OFFSET_OF(chained_buffer, buffer);
  chained_buffer *new_buffer = allocator_malloc(allocator, allocation_size);
  memset(new_buffer, 0, OFFSET_OF(chained_buffer, buffer));
  new_buffer->capacity = capacity;
  new_buffer->offset = 0;
  new_buffer->allocator = allocator != NULL ? allocator : libc_allocator;
  return new_buffer;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addl $0x27, %esi
andl $-0x8, %esi
movslq %esi, %rsi
leal -0x20(%rsi), %ebp
callq 0x52c0
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movl %ebp, 0x10(%rax)
testq %rbx, %rbx
jne 0x7b86
movq 0x6355(%rip), %rcx      # 0xded8
movq (%rcx), %rbx
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/redis-force[P]rpm/module/rpm_chained_buffer.c
// Function: chained_buffer_chain
void chained_buffer_chain(chained_buffer **head, chained_buffer **current,
    chained_buffer ***next_address, int32_t *num_buffers, chained_buffer *next) {
  *current = next;
  if (!*head) {
    *head = *current;
  }
  (*num_buffers)++;
  **next_address = next;
  *next_address = &next->next;
}

// Assembly:
movq %r8, (%rsi)
cmpq $0x0, (%rdi)
jne 0x7b9d
movq %r8, (%rdi)
incl (%rcx)
movq (%rdx), %rax
movq %r8, (%rax)
movq %r8, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O3/redis-force[P]rpm/module/rpm_chained_buffer.c
// Function: chained_buffer_check
chained_buffer *chained_buffer_check(chained_buffer **head, chained_buffer **current,
    chained_buffer ***next_address, int32_t *num_buffers, size_t required, int32_t chunk_size) {
  chained_buffer *current_buffer = *current;
  allocator *allocator = libc_allocator;
  if (!current_buffer || chained_buffer_available(current_buffer) < (int32_t)(required)) {
    if ((int32_t) required < chunk_size) {
      required = chunk_size;
    }
    if (current_buffer != NULL) {
      allocator = current_buffer->allocator;
    }
    chained_buffer_chain(head, current, next_address, num_buffers, current_buffer = chained_buffer_create(allocator, required));
  }
  return current_buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movq (%rsi), %rax
testq %rax, %rax
je 0x7be6
movl 0x10(%rax), %ecx
subl 0xc(%rax), %ecx
cmpl %r8d, %ecx
jge 0x7c47
cmpl %r9d, %r8d
movl %r9d, %ecx
cmovlq %rcx, %r8
addq $0x18, %rax
movq %r8, %rcx
jmp 0x7bf7
cmpl %r9d, %r8d
movl %r9d, %ecx
cmovgeq %r8, %rcx
movq 0x62e1(%rip), %rax      # 0xded8
movq (%rax), %r13
addl $0x27, %ecx
andl $-0x8, %ecx
movslq %ecx, %rsi
leal -0x20(%rsi), %ebp
movq %r13, %rdi
callq 0x52c0
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movl %ebp, 0x10(%rax)
testq %r13, %r13
jne 0x7c2a
movq 0x62b1(%rip), %rcx      # 0xded8
movq (%rcx), %r13
movq %r13, 0x18(%rax)
movq %rax, (%r12)
cmpq $0x0, (%r15)
jne 0x7c3b
movq %rax, (%r15)
incl (%r14)
movq (%rbx), %rcx
movq %rax, (%rcx)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop