LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x42fd
testl %eax, %eax
js 0x7b37
je 0x7ad5
movq 0x30(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x7ad7
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x7ad7
xorl %eax, %eax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x7b2c
movq %rsp, %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x7b3c
je 0x7b09
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x7b0b
movq %rsp, %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x7b0b
xorl %eax, %eax
testl %eax, %eax
jle 0x7b2c
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 0x3a24
callq 0x39ff
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x7bf1
je 0x7b7b
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x7b7d
movq %rsp, %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x7b7d
xorl %eax, %eax
testl %eax, %eax
jle 0x7ba8
movl 0x18(%rsp), %ecx
movl $0x1, %eax
cmpq $0x6, %rcx
ja 0x7bdd
leaq 0x1b21(%rip), %rdx      # 0x96b8
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
cmpq $0x0, 0x20(%rsp)
jmp 0x7bd6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x7be9
movq 0x20(%rsp), %rcx
cmpb $0x0, (%rcx)
jmp 0x7bd6
movb 0x20(%rsp), %cl
xorb $0x1, %cl
jmp 0x7bd9
movq 0x20(%rsp), %rcx
cmpq %rcx, 0x8(%rcx)
jmp 0x7bd6
movq 0x20(%rsp), %rcx
cmpq $0x0, (%rcx)
sete %cl
testb %cl, %cl
jne 0x7be9
leaq 0x18(%rsp), %rcx
movups (%rcx), %xmm0
movups %xmm0, 0x18(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
callq 0x3a49
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x7ce5
je 0x7c39
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x7c3b
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x7c3b
xorl %eax, %eax
cmpl $0x1, %eax
jne 0x7c84
movl $0x1, %eax
cmpl $0x2, 0x20(%rsp)
je 0x7c84
movl $0x2, %edi
callq 0x3bfc
movq %rax, %r15
leaq 0x8(%rsp), %r12
movl 0x18(%r12), %edi
callq 0x3bfc
leaq 0x14e9(%rip), %rsi      # 0x9158
movq %r12, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x7cd6
leaq 0x8(%rsp), %rdi
movq 0x20(%rdi), %rax
movq %rax, (%rdi)
movl $0x0, 0x18(%rdi)
callq 0x3dcc
testl %eax, %eax
js 0x7cd6
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x7cc5
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *%rax
testl %eax, %eax
jle 0x7cd6
leaq 0x20(%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, 0x18(%rbx)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x3a6e
nop
// File: /workspace/github_c_makefile_star2_O1/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), %rax
movzbl 0x1(%rax), %ecx
cmpl $0x3e, %ecx
je 0x7d0f
cmpl $0x3c, %ecx
jne 0x7d34
cmpb $0x0, 0x2(%rax)
je 0x7d39
cmpb $0x3e, %cl
jne 0x7d34
movzbl 0x2(%rax), %ecx
cmpl $0x21, %ecx
je 0x7d25
testl %ecx, %ecx
jne 0x7d34
movq 0x52ad(%rip), %rax      # 0xcfd0
jmp 0x7d40
cmpb $0x0, 0x3(%rax)
jne 0x7d34
movq 0x52c6(%rip), %rax      # 0xcff8
jmp 0x7d40
xorl %r14d, %r14d
jmp 0x7d43
movq 0x5298(%rip), %rax      # 0xcfd8
movq (%rax), %r14
testq %r14, %r14
je 0x7d72
leaq 0x60d1(%rip), %rax      # 0xde20
movq %rax, 0x8(%rbx)
movl $0x7, 0x18(%rbx)
movl $0x8, %edi
callq 0x3180
movq %rax, 0x20(%rbx)
movq %r14, (%rax)
movl $0x1, %eax
jmp 0x7d74
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x7e67
je 0x7dc8
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x7dca
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x7dca
xorl %eax, %eax
cmpl $0x1, %eax
jne 0x7e12
movl $0x1, %eax
cmpl $0x2, 0x20(%rsp)
je 0x7e12
movl $0x2, %edi
callq 0x3bfc
movq %rax, %r14
leaq 0x8(%rsp), %r15
movl 0x18(%r15), %edi
callq 0x3bfc
leaq 0x135b(%rip), %rsi      # 0x9158
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x7e4a
movq 0x28(%rsp), %rdi
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rsi
callq 0x31b0
testq %rax, %rax
je 0x7e51
movq %rax, %r14
movl $0x7, 0x18(%rbx)
movl $0x8, %edi
callq 0x3180
movq %rax, 0x20(%rbx)
movq %r14, (%rax)
jmp 0x7e58
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x7e5d
movl $0x0, 0x18(%rbx)
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x3a93
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x8014
je 0x7eab
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x7ead
movq %rsp, %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x7ead
xorl %eax, %eax
cmpl $0x1, %eax
jne 0x7ef4
movl $0x1, %eax
cmpl $0x7, 0x18(%rsp)
je 0x7ef4
movl $0x7, %edi
callq 0x3bfc
movq %rax, %r15
movq %rsp, %r12
movl 0x18(%r12), %edi
callq 0x3bfc
leaq 0x1279(%rip), %rsi      # 0x9158
movq %r12, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x8005
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x42fd
testl %eax, %eax
js 0x8019
je 0x7f32
movq 0x30(%rsp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x7f34
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq *%rcx
jmp 0x7f34
xorl %eax, %eax
cmpl $0x1, %eax
jne 0x7f7c
movl $0x1, %eax
cmpl $0x2, 0x40(%rsp)
je 0x7f7c
movl $0x2, %edi
callq 0x3bfc
movq %rax, %r14
leaq 0x28(%rsp), %r15
movl 0x18(%r15), %edi
callq 0x3bfc
leaq 0x11f1(%rip), %rsi      # 0x9158
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x8005
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x3130
movl $0x1, %ebp
testl %eax, %eax
jne 0x8005
movq 0x48(%rsp), %r14
leaq 0x1817(%rip), %rdi      # 0x97bd
movq %r14, %rsi
callq 0x3110
leaq 0x4dcb(%rip), %r15      # 0xcd80
testl %eax, %eax
je 0x7fd3
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x7fd0
movq %r14, %rsi
callq 0x3110
addq $0x10, %r15
jmp 0x7fb5
xorl %r15d, %r15d
testq %r15, %r15
je 0x7fec
movq 0x20(%rsp), %rdi
addq $0x18, %rbx
movq %rbx, %rsi
callq *0x8(%r15)
movl %eax, %ebp
jmp 0x8005
leaq 0x17b3(%rip), %rsi      # 0x97a6
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x3add
callq 0x3ab8
// File: /workspace/github_c_makefile_star2_O1/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 0x807b
movl $0x2, (%r14)
movq (%rsp), %rcx
movq %rcx, 0x8(%r14)
movb $0x0, -0x1(%rcx,%rax)
movl $0x1, %ebx
jmp 0x808b
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_O1/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 0x61f8
movq %r14, %rdi
callq 0x7505
movq 0x10(%rbx), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7295
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x6206
callq 0x5110
movq 0x50(%rbx), %rsi
cmpq $-0x1, %rsi
je 0x621c
movq 0x7a59(%rip), %rax      # 0xdc70
movq %r14, %rdi
callq *(%rax)
movq 0x20(%rbx), %rdi
callq 0x5050
movq (%rbx), %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0x624a
addq $0x8, %r14
movq 0x79dd(%rip), %r15      # 0xdc18
callq *(%r15)
movq (%r14), %rdi
addq $0x8, %r14
testq %rdi, %rdi
jne 0x623b
movq 0x79c7(%rip), %r14      # 0xdc18
movq (%rbx), %rdi
callq *(%r14)
movq 0x48(%rbx), %rdi
callq *(%r14)
movq %rbx, %rdi
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
jmpq *(%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x75f6(%rip), %rax      # 0xdfd8
movq (%rsi), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq *(%rax)
movq %rax, %r15
movq 0x7379(%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_O1/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 0x73ce(%rip), %rax      # 0xde00
callq *(%rax)
movq 0x74dd(%rip), %rcx      # 0xdf18
movq (%rcx), %rsi
cmpq %rsi, %rax
je 0x6a55
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
movq %rbx, %rdi
callq 0x6b1b
jmp 0x6a61
movq 0x7444(%rip), %rax      # 0xdea0
movq %rbx, %rdi
callq *(%rax)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7190(%rip), %rax      # 0xdc08
xorl %esi, %esi
xorl %edx, %edx
callq *(%rax)
movq %rax, %r14
movq 0x7360(%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 0x6ae5
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 0x73b4(%rip), %rax      # 0xdea0
movq 0x72b5(%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_O1/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 0x6bd3
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x34c6(%rip), %rcx      # 0xa000
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x7176(%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 0x712a(%rip), %rax      # 0xdc90
jmp 0x6bc2
movq 0x70f9(%rip), %rax      # 0xdc68
jmp 0x6bc2
movq 0x7470(%rip), %rax      # 0xdfe8
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *(%rax)
movq 0x73e7(%rip), %rax      # 0xdf70
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq *(%rax)
cmpq $0x0, 0x18(%r14)
je 0x6bb5
xorl %r15d, %r15d
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x6b1b
incq %r15
cmpq 0x18(%r14), %r15
jb 0x6b9c
popq %rbx
popq %r14
popq %r15
retq
movq 0x72de(%rip), %rax      # 0xdea0
movq (%rax), %rax
movq 0x10(%r14), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
leaq 0x42a8(%rip), %rdi      # 0xae82
leaq 0x42a3(%rip), %rsi      # 0xae84
leaq 0x42a2(%rip), %rcx      # 0xae8a
movl $0xfc, %edx
callq 0x50f0
// File: /workspace/github_c_makefile_star2_O1/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 0x6c46
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 0x6c3e
incl %ebp
movq (%r14), %r14
jmp 0x6c10
testl %eax, %eax
jle 0x6c46
addl %eax, 0x8(%r14)
movl %ebp, %esi
movq %r12, %rdi
callq 0x50d0
subl %ebp, 0x20(%r15)
cmpq $0x0, 0x8(%r15)
je 0x6c6a
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 0x6f87(%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_O1/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 0x6ce0
movl $0x1, %ebp
movl $0x1, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x5220
testl %eax, %eax
jns 0x6cf1
jmp 0x6d45
movq %rcx, %rdi
callq 0x5140
movl $0x1, %ebp
testl %eax, %eax
jne 0x6d45
movq 0x70b8(%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 0x6d43
movq 0x6e83(%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_O1/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 0x7547
movq %rdi, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x90(%rbx), %rsi
addq %r15, %rsi
movq %r14, %rdi
callq 0x758b
incq %r12
movslq 0x88(%rbx), %rax
addq $0x38, %r15
cmpq %rax, %r12
jl 0x7522
cmpl $0x0, 0x78(%rbx)
jle 0x757f
xorl %r14d, %r14d
movq 0x80(%rbx), %rax
movl (%rax,%r14,4), %edi
testl %edi, %edi
je 0x7573
callq 0x5130
movq 0x80(%rbx), %rax
movl $0x0, (%rax,%r14,4)
incq %r14
movslq 0x78(%rbx), %rax
cmpq %rax, %r14
jl 0x7550
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x75ea
movq 0x6673(%rip), %rax      # 0xdc10
xorl %ecx, %ecx
cmpq $0x0, 0x10(%rbx)
setne %cl
leal 0x1(,%rcx,2), %edx
callq *(%rax)
cmpq $0x0, 0x8(%rbx)
je 0x75c4
leaq 0x8(%rbx), %rdi
movslq 0x20(%rbx), %rsi
callq 0x50d0
movl 0x24(%rbx), %edi
testl %edi, %edi
je 0x75d7
callq 0x5130
movl $0x0, 0x24(%rbx)
movl 0x28(%rbx), %edi
testl %edi, %edi
je 0x75ea
callq 0x5130
movl $0x0, 0x28(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/redis-force[P]rpm/module/rpm_allocator.c
// Function: chained_buffer_allocator_calloc
void *chained_buffer_allocator_calloc(void *impl, size_t size) {
  chained_buffer_allocator *allocator = impl;
  void *result = chained_buffer_allocate(chained_buffer_check(&allocator->head, &allocator->current,
      &allocator->next, &allocator->buffer_num, size, allocator->chunk_size), size);
  memset(result, 0, size);
  return result;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
leaq 0x8(%rdi), %rsi
leaq 0x10(%rdi), %rdx
leaq 0x18(%rdi), %rcx
movl 0x1c(%rdi), %r9d
movq %rbx, %r8
callq 0x5360
movq %rax, %rdi
movq %rbx, %rsi
callq 0x53b0
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
popq %rbx
jmp 0x5100
// File: /workspace/github_c_makefile_star2_O1/redis-force[P]rpm/module/rpm_allocator.c
// Function: chained_buffer_allocator_realloc
void *chained_buffer_allocator_realloc(void *impl, void *ptr, size_t size) {
  chained_buffer_allocator *allocator = impl;
  void *result = chained_buffer_allocate(chained_buffer_check(&allocator->head, &allocator->current,
      &allocator->next, &allocator->buffer_num, size, allocator->chunk_size), size);
  memcpy(result, ptr, size);
  return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x8(%rdi), %rsi
leaq 0x10(%rdi), %rdx
leaq 0x18(%rdi), %rcx
movl 0x1c(%rdi), %r9d
movq %rbx, %r8
callq 0x5360
movq %rax, %rdi
movq %rbx, %rsi
callq 0x53b0
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5210
// File: /workspace/github_c_makefile_star2_O1/redis-force[P]rpm/module/rpm_allocator.c
// Function: allocator_create
allocator *allocator_create(void *(*amalloc)(void *, size_t), void *(*acalloc)(void *, size_t), 
    void *(*arealloc)(void *, void *, size_t), void (*afree)(void *, void *), 
    void (*adestroy)(void *), void *privdata) {
  allocator *allocator = calloc(1, sizeof(struct allocator));
  allocator->malloc = amalloc;
  allocator->calloc = acalloc;
  allocator->realloc = arealloc;
  allocator->free = afree;
  allocator->destroy = adestroy;
  allocator->impl = privdata;
  return allocator;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movl $0x1, %edi
movl $0x30, %esi
callq 0x51a0
movq %rbp, (%rax)
movq %r13, 0x10(%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x64dc(%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 0x6479(%rip), %rcx      # 0xdec0
movq %rcx, (%rax)
movq 0x63bf(%rip), %rcx      # 0xde10
movq %rcx, 0x10(%rax)
movq 0x63ac(%rip), %rcx      # 0xde08
movq %rcx, 0x8(%rax)
movq 0x64e1(%rip), %rcx      # 0xdf48
movq %rcx, 0x18(%rax)
movq 0x653e(%rip), %rcx      # 0xdfb0
movq %rcx, 0x20(%rax)
movq %r14, 0x28(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7afa
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 0x7afa
testb %al, %al
jne 0x7adb
movq %r15, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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)
movl $0x0, 0x8(%rax)
testq %rbx, %rbx
jne 0x7b3d
movq 0x639e(%rip), %rcx      # 0xded8
movq (%rcx), %rbx
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7b54
movq %r8, (%rdi)
incl (%rcx)
movq (%rdx), %rax
movq %r8, (%rax)
movq %r8, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq 0x6357(%rip), %rcx      # 0xded8
movq (%rcx), %r13
testq %rax, %rax
je 0x7b94
movl 0x10(%rax), %ecx
subl 0xc(%rax), %ecx
cmpl %r8d, %ecx
jge 0x7bfb
cmpl %r9d, %r8d
movl %r9d, %ecx
cmovgeq %r8, %rcx
testq %rax, %rax
je 0x7ba7
movq 0x18(%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)
movl $0x0, 0x8(%rax)
testq %r13, %r13
jne 0x7bde
movq 0x62fd(%rip), %rcx      # 0xded8
movq (%rcx), %r13
movq %r13, 0x18(%rax)
movq %rax, (%r12)
cmpq $0x0, (%r15)
jne 0x7bef
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
// File: /workspace/github_c_makefile_star2_O1/redis-force[P]rpm/module/rpm_hashmap.c
// Function: rs_hash
uint32_t rs_hash(hash_map *mp, const void *in, size_t len)
{
  (void) mp;
  uint32_t b = 378551;
  uint32_t a = 63689;
  uint32_t hash = 0;
  uint32_t i = 0;
  uint8_t *input = (uint8_t *)in;

  for (i = 0; i < len; input++, i++) {
    hash = hash * a + (*input);
    a = a * b;
  }

  return hash;
}

// Assembly:
testq %rdx, %rdx
je 0x7c37
movl $0xf8c9, %ecx           # imm = 0xF8C9
xorl %edi, %edi
xorl %eax, %eax
imull %ecx, %eax
movzbl (%rsi,%rdi), %r8d
addl %r8d, %eax
imull $0x5c6b7, %ecx, %ecx    # imm = 0x5C6B7
incq %rdi
movl %edi, %r8d
cmpq %rdx, %r8
jb 0x7c1a
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/redis-force[P]rpm/module/rpm_hashmap.c
// Function: hash_map_create
hash_map *hash_map_create(const hash_map_type *type, size_t initial_size)
{
  hash_map *hm;
  allocator *allocator = NULL;

  if (type == NULL) {
    type = &hash_map_type_default;
  }
  allocator = type->allocator ? type->allocator : libc_allocator;

  hm = allocator_calloc(allocator, sizeof(hash_map));

  if (initial_size <= DEFAULT_HASH_MAP_INITIAL_SIZE) {
    initial_size = DEFAULT_HASH_MAP_INITIAL_SIZE;
  }

  hash_table_reset(&hm->tables[0]);
  hash_table_reset(&hm->tables[1]);

  memcpy(&hm->type, type, sizeof(hash_map_type));
  hm->type.allocator = allocator;
  if (type->algorithm == NULL) {
    hm->type.algorithm = rs_hash;
  }
  hm->initial_size = initial_size;
  hm->rehash_index = -1;
  hm->iterators = 0;

  return hm;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
leaq 0x5d94(%rip), %r15      # 0xd9e0
cmovneq %rdi, %r15
movq 0x30(%r15), %r14
testq %r14, %r14
jne 0x7c63
movq 0x6278(%rip), %rax      # 0xded8
movq (%rax), %r14
movl $0x98, %esi
movq %r14, %rdi
callq 0x5290
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rax)
movups %xmm0, 0x58(%rax)
movups %xmm0, 0x68(%rax)
movups %xmm0, 0x78(%rax)
movq 0x30(%r15), %rcx
movq %rcx, 0x30(%rax)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movups %xmm2, 0x20(%rax)
movq %r14, 0x30(%rax)
cmpq $0x0, (%r15)
jne 0x7cb8
movq 0x61e3(%rip), %rcx      # 0xde98
movq %rcx, (%rax)
cmpq $0x10, %rbx
movl $0xf, %ecx
cmovaeq %rbx, %rcx
movq %rcx, 0x40(%rax)
movq $-0x1, 0x88(%rax)
movq $0x0, 0x90(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/redis-force[P]rpm/module/rpm_hashmap.c
// Function: hash_map_clear
int32_t hash_map_clear(hash_map *map)
{
  hash_table_clear(map, &map->tables[0]);
  hash_table_clear(map, &map->tables[1]);
  map->rehash_index = -1;
  map->iterators = 0;
  return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x48(%rdi), %rsi
callq 0x834f
leaq 0x68(%rbx), %rsi
movq %rbx, %rdi
callq 0x834f
movq $-0x1, 0x88(%rbx)
movq $0x0, 0x90(%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/redis-force[P]rpm/module/rpm_hashmap.c
// Function: hash_map_set_if_absent
uint8_t hash_map_set_if_absent(hash_map *map, const void *key, size_t ksiz, const void *val, size_t vsiz)
{
  size_t index;
  uint8_t found;
  hash_map_entry *entry;
  hash_table *table;

  if (HASH_MAP_IS_REHASHING(map)) {
    hash_map_rehash_step(map, 1);
  }

  index = hash_map_key_index(map, key, ksiz, &found);
  if (found == 1) {
    return 0;
  }

  table = HASH_MAP_IS_REHASHING(map) ? &map->tables[1] : &map->tables[0];

  entry = HASH_MAP_MALLOC(map, sizeof(hash_map_entry));
  entry->next = table->buckets[index];
  table->buckets[index] = entry;
  ++(table->used);

  HASH_MAP_ENTRY_SET_KEY(map, entry, key, ksiz);
  HASH_MAP_ENTRY_SET_VALUE(map, entry, val, vsiz);

  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, 0x8(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
cmpq $-0x1, 0x88(%rdi)
je 0x7d85
movq %r15, %rdi
callq 0x7ef8
xorl %eax, %eax
cmpq $-0x1, 0x88(%r15)
jne 0x7db4
movq 0x50(%r15), %rcx
testq %rcx, %rcx
je 0x7da8
movq 0x60(%r15), %rsi
cmpq %rcx, %rsi
jb 0x7db4
addq %rsi, %rsi
jmp 0x7dac
movq 0x40(%r15), %rsi
movq %r15, %rdi
callq 0x8571
movq %rbx, 0x10(%rsp)
testl %eax, %eax
je 0x7dc7
movslq %eax, %rbx
xorl %eax, %eax
jmp 0x7e59
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq *(%r15)
movl %eax, %eax
movq %rax, 0x20(%rsp)
leaq 0x48(%r15), %rax
movq %rax, 0x18(%rsp)
movq $0x0, (%rsp)
xorl %ebp, %ebp
movq %rbp, %rax
shlq $0x5, %rax
movq 0x18(%rsp), %rcx
movl 0x10(%rcx,%rax), %ebx
andl 0x20(%rsp), %ebx
movq (%rcx,%rax), %rax
movq (%rax,%rbx,8), %r14
testq %r14, %r14
je 0x7e40
movq 0x18(%r15), %rax
movq (%r14), %rcx
testq %rax, %rax
je 0x7e2f
movq 0x8(%r14), %r8
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq *%rax
testl %eax, %eax
jne 0x7e34
jmp 0x7e3a
cmpq %r13, %rcx
je 0x7e3a
movq 0x20(%r14), %r14
jmp 0x7e09
movb $0x1, %al
movq %rax, (%rsp)
testq %rbp, %rbp
jne 0x7e52
incq %rbp
cmpq $-0x1, 0x88(%r15)
jne 0x7ded
cmpb $0x1, (%rsp)
sete %al
testb %al, %al
je 0x7e64
xorl %eax, %eax
jmp 0x7ee9
movq 0x30(%r15), %rdi
xorl %r14d, %r14d
cmpq $-0x1, 0x88(%r15)
setne %r14b
shll $0x5, %r14d
movl $0x28, %esi
callq 0x52c0
movq %rax, %rbp
movq 0x48(%r15,%r14), %rax
movq (%rax,%rbx,8), %rcx
movq %rcx, 0x20(%rbp)
movq %rbp, (%rax,%rbx,8)
incq 0x60(%r15,%r14)
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x7eb5
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq *%rax
movq %rax, %r13
movq 0x10(%rsp), %rbx
movq %r13, (%rbp)
movq %r12, 0x8(%rbp)
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x7eda
movq %r15, %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq *%rax
jmp 0x7edf
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rbp)
movq %rbx, 0x18(%rbp)
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/redis-force[P]rpm/module/rpm_hashmap.c
// Function: hash_map_rehash_step
static void hash_map_rehash_step(hash_map *map, size_t steps)
{
  hash_map_entry *entry, *next_entry;
  hash_table *curr, *next;
  int64_t rehash_index;
  size_t size_mask, hash, curr_used, next_used;

  /* we can't rehash at this time as there is an open iterator */
  if (map->iterators != 0) {
    return;
  }
  if (!HASH_MAP_IS_REHASHING(map)) {
    return;
  }

  curr = &map->tables[0];
  next = &map->tables[1];
  rehash_index = map->rehash_index;
  size_mask = next->size_mask;
  curr_used = curr->used;
  next_used = next->used;

  while (steps--) {
    if (curr_used == 0) {
      /* we are done */
      HASH_MAP_FREE(map, curr->buckets);
      curr->used = curr_used;
      next->used = next_used;
      *curr = *next;
      hash_table_reset(next);
      map->rehash_index = -1;
      return;
    }

    /* rehash index can't overflow */
    while (curr->buckets[rehash_index] == NULL) {
      ++rehash_index;
    }

    entry = curr->buckets[rehash_index];
    while (entry) {
      next_entry = entry->next;
      hash = HASH_MAP_HASH_CODE(map, entry->key, entry->ksize);
      hash = hash & size_mask;
      entry->next = next->buckets[hash];
      next->buckets[hash] = entry;
      curr_used--;
      next_used++;
      entry = next_entry;
    }
    curr->buckets[rehash_index] = NULL;
    rehash_index++;
  }
  curr->used = curr_used;
  next->used = next_used;
  map->rehash_index = rehash_index;
}

// Assembly:
cmpq $0x0, 0x90(%rdi)
je 0x7f03
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x88(%rdi), %r14
cmpq $-0x1, %r14
je 0x7ff6
leaq 0x48(%rdi), %rbp
movq 0x60(%rdi), %r12
movq 0x80(%rdi), %r15
testq %r12, %r12
movq %rdi, (%rsp)
je 0x7f9f
movq 0x78(%rdi), %rbx
movq (%rbp), %rax
movq (%rax,%r14,8), %rbp
incq %r14
testq %rbp, %rbp
je 0x7f3f
movq 0x20(%rbp), %r13
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
movq (%rsp), %rdi
movq (%rsp), %rax
callq *(%rax)
movq (%rsp), %rdi
andl %ebx, %eax
movq 0x68(%rdi), %rcx
movq (%rcx,%rax,8), %rdx
movq %rdx, 0x20(%rbp)
movq %rbp, (%rcx,%rax,8)
decq %r12
incq %r15
movq %r13, %rbp
testq %r13, %r13
jne 0x7f4b
movq 0x48(%rdi), %rax
movq $0x0, -0x8(%rax,%r14,8)
movq %r12, 0x60(%rdi)
movq %r15, 0x80(%rdi)
jmp 0x7fef
leaq 0x68(%rdi), %r14
movq (%rsp), %rax
movq 0x30(%rax), %rdi
movq (%rsp), %rax
movq 0x48(%rax), %rsi
callq 0x5040
movq (%rsp), %rdi
movq $0x0, 0x60(%rdi)
movq %r15, 0x80(%rdi)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rbp)
movups %xmm0, (%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movups %xmm0, 0x10(%r14)
movq $-0x1, %r14
movq %r14, 0x88(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/redis-force[P]rpm/module/rpm_hashmap.c
// Function: hash_map_set
int32_t hash_map_set(hash_map *map, const void *key, size_t ksiz, const void *val, size_t vsiz)
{
  hash_map_entry *entry, saved_entry;
  if (hash_map_set_if_absent(map, key, ksiz, val, vsiz) == 0) {
    return 0;
  }

  entry = hash_map_find_entry(map, key, ksiz);
  saved_entry = *entry;
  HASH_MAP_ENTRY_SET_VALUE(map, entry, val, vsiz);
  HASH_MAP_ENTRY_FREE_VALUE(map, &saved_entry);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
callq 0x5260
testb %al, %al
je 0x8074
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x8085
movq %rax, %rbp
movq 0x10(%rax), %r12
movq 0x18(%rax), %r13
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x8058
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *%rax
movq %rax, %r15
movq %r15, 0x10(%rbp)
movq %r14, 0x18(%rbp)
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x8074
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq *%rax
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/redis-force[P]rpm/module/rpm_hashmap.c
// Function: hash_map_find_entry
static hash_map_entry *hash_map_find_entry(hash_map *map, const void *key, size_t ksiz)
{
  hash_map_entry *entry;
  size_t hash, idx, table;
  hash_table *hash_table;
  if (map->tables[0].size == 0) {
    /* don't have any data at all */
    return NULL;
  }
  hash = HASH_MAP_HASH_CODE(map, key, ksiz);
  if (HASH_MAP_IS_REHASHING(map)) {
    hash_map_rehash_step(map, 1);
  }

  for (table = 0; table <= 1; ++table) {
    hash_table = &map->tables[table];
    idx = hash & hash_table->size_mask;
    /* Search if this slot does not already contain the given key */
    entry = hash_table->buckets[idx];
    while (entry) {
      if (HASH_MAP_COMPARE_KEYS(map, key, ksiz, entry->key, entry->ksize)) {
        return entry;
      }
      entry = entry->next;
    }
    if (!HASH_MAP_IS_REHASHING(map)) {
      return NULL;
    }
  }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpq $0x0, 0x50(%rdi)
je 0x813d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq *(%rdi)
movl %eax, %eax
movq %rax, 0x10(%rsp)
cmpq $-0x1, 0x88(%r15)
je 0x80c2
movq %r15, %rdi
callq 0x7ef8
leaq 0x48(%r15), %rbp
movq $0x0, 0x8(%rsp)
xorl %r13d, %r13d
movq %r13, %rax
shlq $0x5, %rax
movl 0x10(%rbp,%rax), %ecx
andl 0x10(%rsp), %ecx
movq (%rbp,%rax), %rax
movq (%rax,%rcx,8), %r12
testq %r12, %r12
je 0x811e
movq 0x18(%r15), %rax
movq (%r12), %rcx
testq %rax, %rax
je 0x8112
movq 0x8(%r12), %r8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *%rax
testl %eax, %eax
jne 0x8117
jmp 0x8136
cmpq %r14, %rcx
je 0x8136
movq 0x20(%r12), %r12
jmp 0x80ea
cmpq $-0x1, 0x88(%r15)
je 0x8146
leaq 0x1(%r13), %rax
testq %r13, %r13
movq %rax, %r13
je 0x80d2
jmp 0x8146
movq %r12, 0x8(%rsp)
jmp 0x8146
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/redis-force[P]rpm/module/rpm_hashmap.c
// Function: hash_map_remove_internal
static int32_t
hash_map_remove_internal(hash_map *map, const void *key, size_t ksiz, uint8_t call_free)
{
  size_t hash, index, table;
  hash_map_entry *entry, *prev;
  hash_table *hash_table;

  if (map->tables[0].size == 0) {
    return -1;
  }
  if (HASH_MAP_IS_REHASHING(map)) {
    hash_map_rehash_step(map, 1);
  }

  hash = HASH_MAP_HASH_CODE(map, key, ksiz);
  for (table = 0; table <= 1; ++table) {
    hash_table = &map->tables[table];
    index = hash & hash_table->size_mask;
    entry = hash_table->buckets[index];
    prev = NULL;
    while (entry) {
      if (HASH_MAP_COMPARE_KEYS(map, entry->key, entry->ksize, key, ksiz)) {
        if (prev) {
          prev->next = entry->next;
        } else {
          hash_table->buckets[index] = entry->next;
        }

        if (call_free) {
          HASH_MAP_ENTRY_FREE_KEY(map, entry);
          HASH_MAP_ENTRY_FREE_VALUE(map, entry);
        }
        HASH_MAP_FREE(map, entry);
        hash_table->used--;
        return 0;
      }
      prev = entry;
      entry = entry->next;
    }
    if (!HASH_MAP_IS_REHASHING(map)) {
      break;
    }
  }

  return -1;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x0, 0x50(%rdi)
je 0x82c1
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl %ecx, 0xc(%rsp)
cmpq $-0x1, 0x88(%rdi)
je 0x819e
movq %rbx, %rdi
callq 0x7ef8
leaq 0x48(%rbx), %rax
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *(%rbx)
movl %eax, %eax
movq %rax, 0x18(%rsp)
xorl %eax, %eax
movq %rax, 0x20(%rsp)
shlq $0x5, %rax
movq 0x10(%rsp), %rcx
movl 0x10(%rcx,%rax), %r14d
andl 0x18(%rsp), %r14d
movq %rax, (%rsp)
movq (%rcx,%rax), %rax
movq (%rax,%r14,8), %rax
testq %rax, %rax
je 0x8226
movq 0x10(%rsp), %rcx
addq %rcx, (%rsp)
xorl %r13d, %r13d
movq %rax, %rbp
movq 0x18(%rbx), %rax
movq (%rbp), %rsi
testq %rax, %rax
je 0x8215
movq 0x8(%rbp), %rdx
movq %rbx, %rdi
movq %r12, %rcx
movq %r15, %r8
callq *%rax
testl %eax, %eax
jne 0x821a
jmp 0x8249
cmpq %r12, %rsi
je 0x8249
movq 0x20(%rbp), %rax
movq %rbp, %r13
testq %rax, %rax
jne 0x81f0
cmpq $-0x1, 0x88(%rbx)
je 0x8242
movq 0x20(%rsp), %rcx
leaq 0x1(%rcx), %rax
testq %rcx, %rcx
je 0x81bb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x82b3
movq 0x20(%rbp), %rax
testq %r13, %r13
je 0x825c
addq $0x20, %r13
movq (%rsp), %r15
jmp 0x826a
shlq $0x3, %r14
movq (%rsp), %r15
addq (%r15), %r14
movq %r14, %r13
movq %rax, (%r13)
cmpb $0x0, 0xc(%rsp)
je 0x82a1
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x828b
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
movq %rbx, %rdi
callq *%rax
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x82a1
movq 0x10(%rbp), %rsi
movq 0x18(%rbp), %rdx
movq %rbx, %rdi
callq *%rax
movq 0x30(%rbx), %rdi
movq %rbp, %rsi
callq 0x5040
decq 0x18(%r15)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/redis-force[P]rpm/module/rpm_hashmap.c
// Function: hash_map_find
int32_t hash_map_find(hash_map *map, const void *key, size_t ksiz, const void **val, size_t *vsiz)
{
  hash_map_entry *entry;

  entry = hash_map_find_entry(map, key, ksiz);
  if (entry) {
    *val = entry->value;
    *vsiz = entry->vsize;
    return 0;
  } else {
    return -1;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
callq 0x8085
testq %rax, %rax
je 0x82ef
movq 0x10(%rax), %rcx
movq %rcx, (%r14)
movq 0x18(%rax), %rax
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x82f4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/redis-force[P]rpm/module/rpm_hashmap.c
// Function: hash_map_get
int32_t hash_map_get(hash_map *map, const void *key, size_t ksiz, void *buff, size_t *bufsiz)
{
  const void *val = NULL;
  size_t vsiz = 0;
  int32_t st = 0;

  st = hash_map_find(map, key, ksiz, &val, &vsiz);
  if (st != 0) {
    return st;
  }
  if (*bufsiz < vsiz) {
    return -1;
  }
  memcpy(buff, val, vsiz);
  *bufsiz = vsiz;
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
callq 0x8085
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x8320
movq 0x10(%rcx), %rsi
movq 0x18(%rcx), %r15
jmp 0x832a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %esi, %esi
xorl %r15d, %r15d
testq %rcx, %rcx
je 0x8349
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %r15, (%rbx)
jb 0x8349
movq %r14, %rdi
movq %r15, %rdx
callq 0x5210
movq %r15, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq