LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x7ed0
cmpl $0x0, %eax
jg 0x7d0b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7d2e
movq -0x10(%rbp), %rax
movl $0x6, 0x18(%rax)
cmpl $0x0, -0x28(%rbp)
sete %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x7ed0
cmpl $0x0, %eax
jg 0x7d6b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7dbc
cmpl $0x6, -0x28(%rbp)
jne 0x7d87
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rsi
callq 0x7fd0
movl %eax, -0x4(%rbp)
jmp 0x7dbc
cmpl $0x5, -0x28(%rbp)
jne 0x7da3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rsi
callq 0x8080
movl %eax, -0x4(%rbp)
jmp 0x7dbc
movq -0x10(%rbp), %rdi
leaq 0x3874(%rip), %rsi      # 0xb622
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x7ed0
cmpl $0x0, %eax
jg 0x7dfe
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7ec3
cmpl $0x5, -0x28(%rbp)
jne 0x7e1d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rsi
callq 0x8290
movl %eax, -0x4(%rbp)
jmp 0x7ec3
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x80b0
cmpl $0x0, %eax
jg 0x7e3b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7ec3
movl -0x28(%rbp), %eax
movl %eax, -0x6c(%rbp)
subl $0x1, %eax
je 0x7e90
jmp 0x7e48
movl -0x6c(%rbp), %eax
subl $0x3, %eax
je 0x7e5c
jmp 0x7e52
movl -0x6c(%rbp), %eax
subl $0x4, %eax
je 0x7e76
jmp 0x7eaa
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
leaq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x8310
movl %eax, -0x4(%rbp)
jmp 0x7ec3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
leaq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x8410
movl %eax, -0x4(%rbp)
jmp 0x7ec3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
leaq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x8510
movl %eax, -0x4(%rbp)
jmp 0x7ec3
movq -0x10(%rbp), %rdi
leaq 0x37ab(%rip), %rsi      # 0xb660
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/cond.c
// Function: eval_if
static int eval_if(struct cy_token *t, struct cy_token *t_cond, struct cy_file *f)
{
	int ret;
	struct cy_token t_then, t_else;

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

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

	if (t_cond->v.v_bool)
		ret = call_branch(&t_then, f, &t->v);
	else
		ret = call_branch(&t_else, f, &t->v);

	if (ret < 0)
		return ret;

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x80b0
cmpl $0x0, %eax
jg 0x8002
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x806e
movq -0x20(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x80b0
cmpl $0x0, %eax
jg 0x801d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x806e
movq -0x18(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x8041
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x18, %rdx
leaq -0x50(%rbp), %rdi
callq 0x8140
movl %eax, -0x24(%rbp)
jmp 0x8059
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x18, %rdx
leaq -0x78(%rbp), %rdi
callq 0x8140
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x8067
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x806e
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7ed0
cmpl $0x0, %eax
jg 0x80db
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x812b
movq -0x10(%rbp), %rax
cmpl $0x5, 0x18(%rax)
je 0x8124
movq -0x10(%rbp), %rdi
callq 0x7770
testb $0x1, %al
jne 0x8124
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
callq 0x3400
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x3529(%rip), %rsi      # 0xb63d
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x812b
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/cond.c
// Function: cy_call_sblock
static int cy_call_sblock(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 ct = {};
		struct cy_token bt = {};

		ret = cy_eval_next_x(f, &ct, CY_V_BOOL);
		if (ret <= 0)
			break;

		ret = get_branch(&bt, f);
		if (ret <= 0)
			break;

		if (ct.v.v_bool) {
			ret = call_branch(&bt, f, rv);
			break;
		}
	}

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

	if (ret < 0)
		return ret;

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x3da0
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x30b0
leaq -0x88(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x30b0
movq -0x18(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x6, %edx
callq 0x7f50
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jg 0x8210
jmp 0x824c
movq -0x18(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x80b0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jg 0x822b
jmp 0x824c
testb $0x1, -0x40(%rbp)
je 0x824a
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0x8140
movl %eax, -0x24(%rbp)
jmp 0x824c
jmp 0x81d0
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
cmpl $0x0, -0x24(%rbp)
jge 0x8272
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8279
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/cond.c
// Function: eval_cblock_loop
static int eval_cblock_loop(struct cy_token *t, struct cy_token *bt, struct cy_file *f)
{
	int ret;

	while (1) {
		struct cy_value rv = {};

		ret = cy_call_cblock(bt, f, &rv);
		if (ret <= 0)
			return -1;

		if (ret == 2) {
			t->v = rv;
			break;
		}
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30b0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x7620
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jg 0x82d7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x82fc
cmpl $0x2, -0x24(%rbp)
jne 0x82f3
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x82f5
jmp 0x82a4
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/cond.c
// Function: eval_list_loop
static int eval_list_loop(struct cy_token *t, struct cy_token *lt, struct cy_token *bt, struct cy_file *f)
{
	int ret;
	struct cy_list_value *lv;

	list_for_each_entry(lv, &lt->v.v_list->h, l) {
		struct cy_value rv = {};

		set_cursor(&lv->v);
		ret = call_branch(bt, f, &rv);
		if (ret < 0)
			return ret;

		if (ret == 2) {
			t->v = rv;
			break;
		}

		/* XXX if someone removes an element from the list while
		 * we iterate it :(
		 */
		if (list_empty(&lv->l))
			break;
	}
	set_cursor(NULL);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x20(%rcx), %rcx
cmpq %rcx, %rax
je 0x83eb
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30b0
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
callq 0x4aa0
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x8140
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x839c
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x83fb
cmpl $0x2, -0x2c(%rbp)
jne 0x83b8
movq -0x10(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x83eb
movq -0x38(%rbp), %rdi
callq 0x8630
cmpl $0x0, %eax
je 0x83c8
jmp 0x83eb
jmp 0x83ca
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x8348
xorl %eax, %eax
movl %eax, %edi
callq 0x4aa0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/cond.c
// Function: eval_map_loop
static int eval_map_loop(struct cy_token *t, struct cy_token *mt, struct cy_token *bt, struct cy_file *f)
{
	int ret;
	struct rb_node *n;

	for (n = rb_first(&mt->v.v_map->r); n != NULL; n = rb_next(n)) {
		struct cy_map_value *mv;
		struct cy_value rv = {};
		struct cy_value cv = { .t = CY_V_STRING, };

		mv = rb_entry(n, struct cy_map_value, n);
		cv.v_str = mv->key;
		set_cursor(&cv);
		ret = call_branch(bt, f, &rv);
		if (ret < 0)
			return ret;

		if (ret == 2) {
			t->v = rv;
			break;
		}
	}
	set_cursor(NULL);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x8fa0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x84ec
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30b0
movq 0x3215(%rip), %rax      # 0xb670
movq %rax, -0x60(%rbp)
movq 0x3212(%rip), %rax      # 0xb678
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4aa0
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x8140
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x84bc
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x84fc
cmpl $0x2, -0x2c(%rbp)
jne 0x84d8
movq -0x10(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x84ec
jmp 0x84da
movq -0x38(%rbp), %rdi
callq 0x9040
movq %rax, -0x38(%rbp)
jmp 0x8439
xorl %eax, %eax
movl %eax, %edi
callq 0x4aa0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/cond.c
// Function: eval_nuber_loop
static int eval_nuber_loop(struct cy_token *t, struct cy_token *nt, struct cy_token *bt, struct cy_file *f)
{
	int ret, start, stop, inc;
	struct cy_value lc = { .t = CY_V_NUMBER, };
	struct cy_value rv = {};

	if (nt->v.v_i > 0) {
		start = 0;
		stop = nt->v.v_i;
		inc = 1;
	} else if (nt->v.v_i < 0) {
		start = -nt->v.v_i;
		stop = 0;
		inc = -1;
	} else
		return 1;

	for (lc.v_i = start; lc.v_i != stop; lc.v_i += inc) {
		set_cursor(&lc);
		ret = call_branch(bt, f, &rv);
		if (ret < 0)
			return ret;
		if (ret == 2) {
			t->v = rv;
			break;
		}
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq 0x3151(%rip), %rax      # 0xb680
movq %rax, -0x48(%rbp)
movq 0x314e(%rip), %rax      # 0xb688
movq %rax, -0x40(%rbp)
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x30b0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jle 0x8574
movl $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movl %eax, -0x34(%rbp)
movl $0x1, -0x38(%rbp)
jmp 0x85a7
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jge 0x859c
movq -0x18(%rbp), %rcx
xorl %eax, %eax
subq 0x20(%rcx), %rax
movl %eax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0xffffffff, -0x38(%rbp) # imm = 0xFFFFFFFF
jmp 0x85a5
movl $0x1, -0x4(%rbp)
jmp 0x861a
jmp 0x85a7
movslq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movslq -0x34(%rbp), %rcx
cmpq %rcx, %rax
je 0x8613
leaq -0x48(%rbp), %rdi
callq 0x4aa0
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x8140
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x85e7
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x861a
cmpl $0x2, -0x2c(%rbp)
jne 0x8603
movq -0x10(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x8613
jmp 0x8605
movslq -0x38(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x85af
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $-0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x88c7
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x8c00
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8c00
cmpq $0x0, -0x20(%rbp)
je 0x8911
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x8903
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x890f
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x891c
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8c00
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/rbtree.c
// Function: rb_first
struct rb_node *rb_first(const struct rb_root *root)
{
	struct rb_node	*n;

	n = root->rb_node;
	if (!n)
		return NULL;

	while (n->rb_left)
		n = n->rb_left;

	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8fc4
movq $0x0, -0x8(%rbp)
jmp 0x8fe7
jmp 0x8fc6
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x8fdf
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x8fc6
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/rbtree.c
// Function: rb_last
struct rb_node *rb_last(const struct rb_root *root)
{
	struct rb_node	*n;

	n = root->rb_node;
	if (!n)
		return NULL;

	while (n->rb_right)
		n = n->rb_right;

	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9014
movq $0x0, -0x8(%rbp)
jmp 0x9037
jmp 0x9016
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x902f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x9016
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/rbtree.c
// Function: rb_prev
struct rb_node *rb_prev(const struct rb_node *node)
{
	struct rb_node *parent;

	if (rb_parent(node) == node)
		return NULL;

	/*
	 * If we have a left-hand child, go down and
	 * then right as far as we can.
	 */
	if (node->rb_left) {
		node = node->rb_left;
		while (node->rb_right)
			node = node->rb_right;
		return (struct rb_node *)node;
	}

	/*
	 * No left-hand children. Go up till we find
	 * an ancestor which is a right-hand child of its parent.
	 */
	while ((parent = rb_parent(node)) && node == parent->rb_left)
		node = parent;

	return parent;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $-0x4, %rax
cmpq -0x10(%rbp), %rax
jne 0x9116
movq $0x0, -0x8(%rbp)
jmp 0x9199
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x9150
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x9146
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x912d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9199
jmp 0x9152
movq -0x10(%rbp), %rax
movq (%rax), %rcx
andq $-0x4, %rcx
movq %rcx, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x19(%rbp)
je 0x917e
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x9187
jmp 0x9191
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x9152
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2b, %eax
jne 0x92e8
movq -0x18(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x0, %eax
jne 0x92e8
movq -0x10(%rbp), %rax
leaq 0x69f8(%rip), %rcx      # 0xfcc0
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x6, 0x18(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x20(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x9366
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2d, %eax
jne 0x932d
movq -0x18(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x0, %eax
jne 0x932d
movq -0x10(%rbp), %rax
leaq 0x69b3(%rip), %rcx      # 0xfcc0
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x6, 0x18(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x20(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x9366
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3f, %eax
jne 0x935f
movq -0x18(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x0, %eax
jne 0x935f
movq -0x10(%rbp), %rax
leaq 0x6986(%rip), %rcx      # 0xfcd8
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x9366
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/misc.c
// Function: eval_in
static int eval_in(struct cy_token *t, struct cy_file *f)
{
	struct cy_token it, ct;

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

	t->v.t = CY_V_BOOL;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x97a0
cmpl $0x0, %eax
jg 0x940e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9494
movq -0x18(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x97a0
cmpl $0x0, %eax
jg 0x9429
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9494
movq -0x10(%rbp), %rax
movl $0x6, 0x18(%rax)
cmpl $0x3, -0x28(%rbp)
jne 0x9460
movq -0x20(%rbp), %rdi
leaq -0x68(%rbp), %rsi
addq $0x18, %rsi
callq 0x5e20
movb %al, %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x9494
cmpl $0x4, -0x28(%rbp)
jne 0x9468
jmp 0x9468
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movl -0x28(%rbp), %edi
callq 0x3400
movq -0x70(%rbp), %rdi
movq %rax, %rdx
leaq 0x2270(%rip), %rsi      # 0xb6f6
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x97a0
cmpl $0x0, %eax
jg 0x94d1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x95ee
movq -0x10(%rbp), %rax
movl $0x1, 0x18(%rax)
cmpl $0x2, -0x28(%rbp)
jne 0x9502
movq -0x20(%rbp), %rdi
callq 0x3080
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x95ee
cmpl $0x3, -0x28(%rbp)
jne 0x9574
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq %rcx, %rax
je 0x956b
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x9530
movl $0x1, -0x4(%rbp)
jmp 0x95ee
cmpl $0x4, -0x28(%rbp)
jne 0x95c2
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x20(%rbp), %rdi
callq 0x8fa0
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x70(%rbp)
je 0x95b9
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movq -0x70(%rbp), %rdi
callq 0x9040
movq %rax, -0x70(%rbp)
jmp 0x9593
movl $0x1, -0x4(%rbp)
jmp 0x95ee
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x28(%rbp), %edi
callq 0x3400
movq -0x78(%rbp), %rdi
movq %rax, %rdx
leaq 0x2136(%rip), %rsi      # 0xb716
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x97a0
cmpl $0x0, %eax
jg 0x962b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9687
movq -0x18(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x97a0
cmpl $0x0, %eax
jg 0x9646
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9687
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x70(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x966d
movq -0x70(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x9680
movq -0x70(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x97a0
cmpl $0x0, %eax
jg 0x96bb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x96e7
leaq -0x40(%rbp), %rdi
addq $0x18, %rdi
callq 0x9820
testb $0x1, %al
jne 0x96e0
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x2, %edx
callq 0x9900
cmpl $0x0, %eax
jg 0x9720
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x978c
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x28(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3770
cmpl $0x0, %eax
jge 0x9746
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x978c
movq -0x38(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x9771
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
jg 0x9771
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x978c
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/misc.c
// Function: is_empty_value
static bool is_empty_value(struct cy_value *v)
{
	switch (v->t) {
	case CY_V_NOVALUE:
		return true;
	case CY_V_BOOL:
		return !v->v_bool;
	case CY_V_LIST:
		return list_empty(&v->v_list->h);
	case CY_V_MAP:
		return RB_EMPTY_ROOT(&v->v_map->r);
	case CY_V_STRING:
		return v->v_str[0] == '\0';
	case CY_V_NUMBER:
		return v->v_i == 0;
	}

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x6, %rax
ja 0x98c5
movq -0x18(%rbp), %rax
leaq 0x1e45(%rip), %rcx      # 0xb690
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, -0x1(%rbp)
jmp 0x98c9
movq -0x10(%rbp), %rax
movb 0x8(%rax), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x98c9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x98e0
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x98c9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, (%rax)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x98c9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x98c9
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x98c9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3c, %eax
jne 0x99c4
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x2(%rax), %eax
cmpl $0x0, %eax
jne 0x99c4
movq 0x561d(%rip), %rax      # 0xefd8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x9a28
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3e, %eax
jne 0x9a26
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x2(%rax), %eax
cmpl $0x0, %eax
jne 0x99f4
movq 0x55e5(%rip), %rax      # 0xefd0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x9a24
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x2(%rax), %eax
cmpl $0x21, %eax
jne 0x9a22
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x3(%rax), %eax
cmpl $0x0, %eax
jne 0x9a22
movq 0x55dd(%rip), %rax      # 0xeff8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x9a24
jmp 0x9a26
jmp 0x9a28
cmpq $0x0, -0x18(%rbp)
jne 0x9a38
movl $0x0, -0x4(%rbp)
jmp 0x9a5b
movq -0x10(%rbp), %rax
leaq 0x63cd(%rip), %rcx      # 0xfe10
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9a70
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movl $0x2, %edx
callq 0x9c70
cmpl $0x0, %eax
jg 0x9b10
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9b58
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x31a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x9b44
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x9b58
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9a70
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x7, %edx
callq 0x9c70
cmpl $0x0, %eax
jg 0x9ba3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9c29
movq -0x18(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movl $0x2, %edx
callq 0x9c70
cmpl $0x0, %eax
jg 0x9bc3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9c29
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x3120
cmpl $0x0, %eax
je 0x9bdd
movl $0x1, -0x4(%rbp)
jmp 0x9c29
movq -0x48(%rbp), %rdi
callq 0x9d70
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x70(%rbp)
jne 0x9c10
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x1b7e(%rip), %rsi      # 0xb77e
movb $0x0, %al
callq 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9c29
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq *%rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xemul[P]cylang/stream.c
// Function: get_format
static struct stream_format *get_format(const char *fn)
{
	int i;

	for (i = 0; formats[i].f != NULL; i++)
		if (!strcmp(formats[i].f, fn))
			return &formats[i];

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x6252(%rip), %rax      # 0xffe0
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x9de3
movslq -0x14(%rbp), %rcx
leaq 0x623a(%rip), %rax      # 0xffe0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3100
cmpl $0x0, %eax
jne 0x9dd6
movslq -0x14(%rbp), %rcx
leaq 0x6217(%rip), %rax      # 0xffe0
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x9deb
jmp 0x9dd8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9d83
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x31d0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jg 0x9e62
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3120
movl %eax, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x9e8f
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm.c
// Function: RedisModule_OnLoad
int RedisModule_OnLoad(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
  rpm_context *rpm;
  if (RedisModule_Init(ctx, "rpm", 1, REDISMODULE_APIVER_1) == REDISMODULE_ERR) {
    return REDISMODULE_ERR;
  }
  if ((rpm = rpm_context_create(ctx, argc, argv)) == NULL) {
    return REDISMODULE_ERR;
  }
  RedisModule_Attach(ctx, NULL, 0, rpm, (RedisModuleFinalizer) rpm_context_destroy);
  return REDISMODULE_OK;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x7bf6(%rip), %rsi      # 0xd044
movl $0x1, %ecx
movl %ecx, %edx
callq 0x54d0
cmpl $0x1, %eax
jne 0x5469
movl $0x1, 0x24(%rsp)
jmp 0x54b9
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0x6110
movq %rax, (%rsp)
cmpq $0x0, %rax
jne 0x5490
movl $0x1, 0x24(%rsp)
jmp 0x54b9
movq 0xb961(%rip), %rax      # 0x10df8
movq (%rax), %rax
movq 0x18(%rsp), %rdi
movq (%rsp), %rcx
xorl %edx, %edx
leaq 0x11c4(%rip), %r8       # 0x6670
movq %rdx, %rsi
callq *%rax
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x66b5
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x8470
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdx
callq 0x8060
movq 0x8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x66cf
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x5120
movq 0x8(%rsp), %rax
cmpq $-0x1, 0x50(%rax)
je 0x66f5
movq 0xa596(%rip), %rax      # 0x10c78
movq (%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rcx
movq 0x50(%rcx), %rsi
callq *%rax
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x5050
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x673a
movq 0xa500(%rip), %rax      # 0x10c20
movq (%rax), %rax
movq (%rsp), %rcx
movq (%rcx), %rdi
callq *%rax
movq (%rsp), %rax
addq $0x8, %rax
movq %rax, (%rsp)
jmp 0x670f
movq 0xa4df(%rip), %rax      # 0x10c20
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rdi
callq *%rax
movq 0xa4cb(%rip), %rax      # 0x10c20
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x48(%rcx), %rdi
callq *%rax
movq 0xa4b6(%rip), %rax      # 0x10c20
movq (%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x9e0b(%rip), %rax      # 0x10fe0
movq (%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rdi
leaq 0x10(%rsp), %rsi
callq *%rax
movq %rax, (%rsp)
movq 0x9b86(%rip), %rax      # 0x10d78
movq (%rax), %rax
movq 0x10(%rsp), %rdi
addq $0x1, %rdi
callq *%rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x5220
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm.c
// Function: rpm_worker_process_request
static long long rpm_worker_process_request(RedisModuleCtx *ctx, rpm_context *rpm, int64_t timeout, int64_t client_id) {
  int64_t request_id = rpm->current_request_id++;
  worker_process *worker = rpm->worker;
  RedisModuleBlockedClient *bc = RedisModule_BlockClient(ctx, rpm_worker_command_on_reply,
      rpm_worker_command_on_timeout, rpm_worker_command_free_reply, timeout);
  hash_map_set(worker->request_id_to_client, hash_map_int_ptr(request_id), sizeof(request_id), bc, sizeof(bc));
  hash_map_set(rpm->worker->client_id_to_request_id, hash_map_int_ptr(client_id),
      sizeof(client_id), hash_map_int_ptr(request_id), sizeof(request_id));
  return request_id;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x999a(%rip), %rax      # 0x10c40
movq (%rax), %rax
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %r8
leaq 0x126(%rip), %rsi       # 0x73e0
leaq 0x19f(%rip), %rdx       # 0x7460
leaq 0x258(%rip), %rcx       # 0x7520
callq *%rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq 0x98(%rax), %rdi
movq 0x10(%rsp), %rsi
movq (%rsp), %rcx
movl $0x8, %r8d
movq %r8, %rdx
callq 0x53d0
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0xa0(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rcx
movl $0x8, %r8d
movq %r8, %rdx
callq 0x53d0
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm.c
// Function: rpm_worker_upstream_write
static void rpm_worker_upstream_write(RedisModuleCtx *ctx, worker_pipe *pipe, int to, chained_buffer *buf) {
  int32_t wr, available;
  if (pipe->write_buffer == NULL) {
    available = buf->size - buf->offset;
    if ((wr = write(to, buf->buffer + buf->offset, available)) == available) {
      chained_buffer_destroy(&buf, 1);
      return;
    }
    if (wr > 0) {
      buf->offset += wr;
    }
  }
  rpm_worker_upstream_buffer_data(ctx, pipe, to, buf);
  return;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x73ba
movq 0x8(%rsp), %rax
movl 0xc(%rax), %eax
movq 0x8(%rsp), %rcx
subl 0x8(%rcx), %eax
movl %eax, (%rsp)
movl 0x14(%rsp), %edi
movq 0x8(%rsp), %rsi
addq $0x20, %rsi
movq 0x8(%rsp), %rax
movslq 0x8(%rax), %rax
addq %rax, %rsi
movslq (%rsp), %rdx
callq 0x5090
movl %eax, 0x4(%rsp)
cmpl (%rsp), %eax
jne 0x73a2
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x50e0
jmp 0x73d2
cmpl $0x0, 0x4(%rsp)
jle 0x73b8
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
jmp 0x73ba
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
movq 0x8(%rsp), %rcx
callq 0x76b0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x9a0f(%rip), %rax      # 0x10e08
movq (%rax), %rax
movq 0x20(%rsp), %rdi
callq *%rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x9b0c(%rip), %rcx      # 0x10f20
cmpq (%rcx), %rax
jne 0x7436
movq 0x9a88(%rip), %rax      # 0x10ea8
movq (%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x9af1(%rip), %rcx      # 0x10f20
movq (%rcx), %rsi
callq *%rax
jmp 0x7455
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x7550
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rdi
callq 0x7240
movq %rax, 0x10(%rsp)
movq 0x9968(%rip), %rax      # 0x10df0
movq (%rax), %rax
movq 0x30(%rsp), %rdi
callq *%rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0xa0(%rax), %rdi
movq (%rsp), %rsi
movl $0x8, %edx
leaq 0x8(%rsp), %rcx
leaq 0x18(%rsp), %r8
callq 0x51d0
cmpl $0x0, %eax
jne 0x7500
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0xa0(%rax), %rdi
movq (%rsp), %rsi
movl $0x8, %edx
callq 0x5400
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x98(%rax), %rdi
movq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x5400
movq 0x99a1(%rip), %rax      # 0x10ea8
movq (%rax), %rax
movq 0x30(%rsp), %rdi
movq 0x989a(%rip), %rcx      # 0x10db0
movq (%rcx), %rsi
callq *%rax
addq $0x38, %rsp
retq