LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x5, %eax
ja 0x767f
movq 0x8(%rsp), %rax
leaq 0x5a7d(%rip), %rcx      # 0xd000
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x9735(%rip), %rax      # 0x10cc8
movq (%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rsi
movq 0x18(%rsp), %rcx
movq 0x18(%rcx), %rdx
callq *%rax
jmp 0x769e
movq 0x99bd(%rip), %rax      # 0x10f78
movq (%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq 0x18(%rcx), %rsi
callq *%rax
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x7613
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x7550
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x75d7
jmp 0x769e
movq 0x9651(%rip), %rax      # 0x10c70
movq (%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
jmp 0x769e
movq 0x99b5(%rip), %rax      # 0x10ff0
movq (%rax), %rax
movq 0x20(%rsp), %rdi
callq *%rax
jmp 0x769e
movq 0x964a(%rip), %rax      # 0x10c98
movq (%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
jmp 0x769e
movq 0x983e(%rip), %rax      # 0x10ea8
movq (%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
jmp 0x769e
leaq 0x67ec(%rip), %rdi      # 0xde72
leaq 0x67e7(%rip), %rsi      # 0xde74
movl $0xfc, %edx
leaq 0x67e1(%rip), %rcx      # 0xde7a
callq 0x5100
xorl %eax, %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_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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x77c9
movq 0x18(%rsp), %rax
movl 0xc(%rax), %eax
movq 0x18(%rsp), %rcx
subl 0x8(%rcx), %eax
movl %eax, 0xc(%rsp)
movl 0x3c(%rsp), %edi
movq 0x18(%rsp), %rsi
addq $0x20, %rsi
movq 0x18(%rsp), %rax
movslq 0x8(%rax), %rax
addq %rax, %rsi
movslq 0xc(%rsp), %rdx
callq 0x5090
movl %eax, 0x14(%rsp)
cmpl 0xc(%rsp), %eax
jge 0x77af
cmpl $0x0, 0x14(%rsp)
jle 0x77ad
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
jmp 0x77c9
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x774e
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
movslq 0x10(%rsp), %rsi
callq 0x50e0
movl 0x10(%rsp), %edx
movq 0x20(%rsp), %rax
movl 0x20(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x20(%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x781d
movq 0x20(%rsp), %rdi
callq 0x7880
movq 0x940e(%rip), %rax      # 0x10c18
movq (%rax), %rax
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl $0x2, %edx
callq *%rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x790f
movq 0x18(%rsp), %rcx
addq $0x24, %rcx
movl $0x1, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x5230
cmpl $0x0, %eax
jge 0x790d
movl $0x1, 0x34(%rsp)
jmp 0x799c
jmp 0x792e
movq 0x18(%rsp), %rdi
addq $0x24, %rdi
callq 0x5150
cmpl $0x0, %eax
je 0x792c
movl $0x1, 0x34(%rsp)
jmp 0x799c
jmp 0x792e
movq 0x9483(%rip), %rax      # 0x10db8
movq (%rax), %rax
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rcx
movl 0x24(%rcx), %esi
callq *%rax
movq 0x18(%rsp), %rdi
callq 0x7880
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, 0x10(%rsp)
je 0x7994
movq 0x9243(%rip), %rax      # 0x10bb0
movq (%rax), %rax
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rcx
movl 0x24(%rcx), %esi
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %r8
movl $0x1, %edx
callq *%rax
movl %eax, 0x34(%rsp)
jmp 0x799c
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
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_on_reply
static int rpm_worker_upstream_on_reply(RedisModuleCtx *ctx, redis_response *reply) {
  redis_response *client_id, *request_id;
  rpm_context *rpm = rpm_context_get(ctx);
  if (reply->type != REDIS_RESPONSE_ARRAY || reply->payload.array.length != 3 || 
      reply->payload.array.array[0]->type != REDIS_RESPONSE_INTEGER ||
      reply->payload.array.array[1]->type != REDIS_RESPONSE_INTEGER) {
    return REDIS_RESPONSE_ERROR_PROTOCOL;
  }
  client_id = reply->payload.array.array[0];
  request_id = reply->payload.array.array[1];
  if ((reply = rpm_worker_process_reply(rpm, client_id->payload.integer, request_id->payload.integer, reply)) != NULL) {
    redis_response_reader_free_response(reply);
  }
  return REDIS_RESPONSE_OK;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x7240
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x2, (%rax)
jne 0x83f6
movq 0x20(%rsp), %rax
cmpq $0x3, 0x18(%rax)
jne 0x83f6
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
cmpl $0x3, (%rax)
jne 0x83f6
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x3, (%rax)
je 0x8400
movl $0x2, 0x34(%rsp)
jmp 0x8461
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdx
movq 0x20(%rsp), %rcx
callq 0x8540
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x8459
movq 0x20(%rsp), %rdi
callq 0x5260
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x88(%rcx), %eax
jge 0x84c6
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x90(%rax), %rsi
movslq 0x4(%rsp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rsi
callq 0x8610
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x8486
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x78(%rcx), %eax
jge 0x8533
movq 0x8(%rsp), %rax
movq 0x80(%rax), %rax
movslq 0x4(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x8524
movq 0x8(%rsp), %rax
movq 0x80(%rax), %rax
movslq 0x4(%rsp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x5140
movq 0x8(%rsp), %rax
movq 0x80(%rax), %rax
movslq 0x4(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0x8526
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x84ce
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm.c
// Function: rpm_worker_process_reply
static void *rpm_worker_process_reply(rpm_context *rpm, int64_t client_id, int64_t request_id, void *reply) {
  RedisModuleBlockedClient *bc = NULL;
  worker_process *worker = rpm->worker;
  size_t ignored;
  if (hash_map_find(worker->request_id_to_client, hash_map_int_ptr(request_id), sizeof(request_id), (const void **) &bc, &ignored) != 0) {
    return reply;
  } else {
    hash_map_remove(worker->client_id_to_request_id, hash_map_int_ptr(client_id), sizeof(client_id));
    hash_map_remove(worker->request_id_to_client, hash_map_int_ptr(request_id), sizeof(request_id));
    RedisModule_UnblockClient(bc, reply);
    return NULL;
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x98(%rax), %rdi
movq 0x28(%rsp), %rsi
movl $0x8, %edx
leaq 0x18(%rsp), %rcx
leaq 0x8(%rsp), %r8
callq 0x51d0
cmpl $0x0, %eax
je 0x85a5
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x85fa
movq 0x10(%rsp), %rax
movq 0xa0(%rax), %rdi
movq 0x30(%rsp), %rsi
movl $0x8, %edx
callq 0x5400
movq 0x10(%rsp), %rax
movq 0x98(%rax), %rdi
movq 0x28(%rsp), %rsi
movl $0x8, %edx
callq 0x5400
movq 0x8896(%rip), %rax      # 0x10e78
movq (%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq *%rax
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x24(%rax)
je 0x86cd
movq 0x85e4(%rip), %rax      # 0x10c18
movq (%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rcx
movl 0x24(%rcx), %esi
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %r8
xorl %edx, %edx
movl $0x2, %ecx
cmpq $0x0, %r8
cmovnel %ecx, %edx
orl $0x1, %edx
callq *%rax
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x8683
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movq 0x8(%rsp), %rax
movslq 0x20(%rax), %rsi
callq 0x50e0
movq 0x8(%rsp), %rax
cmpl $0x0, 0x24(%rax)
je 0x86a7
movq 0x8(%rsp), %rax
movl 0x24(%rax), %edi
callq 0x5140
movq 0x8(%rsp), %rax
movl $0x0, 0x24(%rax)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x28(%rax)
je 0x86cb
movq 0x8(%rsp), %rax
movl 0x28(%rax), %edi
callq 0x5140
movq 0x8(%rsp), %rax
movl $0x0, 0x28(%rax)
jmp 0x86cd
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm.c
// Function: rpm_worker_log_read
static void rpm_worker_log_read(RedisModuleCtx *ctx, int fd, void *client_data, int mask, const char *level) {
  int rd;
  worker_pipe *pipe = client_data;
  worker_process *worker = pipe->worker;
  char *buf = worker->buf, *start, *end, *linefeed = NULL;
  REDISMODULE_NOT_USED(mask);
  while ((rd = read(fd, buf, sizeof(worker->buf))) > 0) {
    linefeed = start = buf;
    end = buf + rd;
scan_for_lf:
    if (start < end && (linefeed = memchr(start, '\n', end - start)) != NULL) {
      rpm_worker_log_flush(ctx, pipe, start, linefeed - start, level);
      start = linefeed + 1;
      goto scan_for_lf;
    }
    /* check if there are more data without linefeed left in read buffer */
    if (linefeed == NULL && start < end) {
      rpm_worker_pipe_buffer_data(pipe, start, end - start);
    }
  }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movq %r8, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
addq $0xa8, %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x8(%rsp)
movl 0x5c(%rsp), %edi
movq 0x20(%rsp), %rsi
movl $0x100000, %edx         # imm = 0x100000
callq 0x5180
movl %eax, 0x3c(%rsp)
cmpl $0x0, %eax
jle 0x880c
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movslq 0x3c(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x87d5
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rax
subq %rax, %rdx
movl $0xa, %esi
callq 0x5170
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x87d5
movq 0x60(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
subq %rax, %rcx
movq 0x40(%rsp), %r8
callq 0x8820
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x876c
cmpq $0x0, 0x8(%rsp)
jne 0x8807
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x8807
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rcx, %rax
movl %eax, %edx
callq 0x8920
jmp 0x872b
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm.c
// Function: rpm_worker_log_flush
static void rpm_worker_log_flush(RedisModuleCtx *ctx, worker_pipe *pipe, const char *log, size_t length, const char *level)
{
  char log_buffer[MAX_REAL_LOG_LEN];
  int32_t offset = 0;
  if (pipe->num_buffers > 0) {
    offset = rpm_worker_log_buffer_flush(pipe, log_buffer, offset);
  }
  offset = rpm_worker_log_buffer_append(log_buffer, offset, log, length);
  if (offset == MAX_LOG_LEN) {
    memset(log_buffer + offset, '.', 6);
    offset += 6;
  }
  log_buffer[offset] = '\0';
  RedisModule_Log(ctx, level, "%s", log_buffer);
}

// Assembly:
subq $0x438, %rsp            # imm = 0x438
movq %rdi, 0x430(%rsp)
movq %rsi, 0x428(%rsp)
movq %rdx, 0x420(%rsp)
movq %rcx, 0x418(%rsp)
movq %r8, 0x410(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x428(%rsp), %rax
cmpl $0x0, 0x20(%rax)
jle 0x8880
movq 0x428(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movslq 0xc(%rsp), %rdx
callq 0x89b0
movl %eax, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rsi
movq 0x420(%rsp), %rdx
movq 0x418(%rsp), %rcx
callq 0x8a40
movl %eax, 0xc(%rsp)
cmpl $0x3e8, 0xc(%rsp)       # imm = 0x3E8
jne 0x88d4
leaq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rax
addq %rax, %rdi
movl $0x2e, %esi
movl $0x6, %edx
callq 0x5110
movl 0xc(%rsp), %eax
addl $0x6, %eax
movl %eax, 0xc(%rsp)
movslq 0xc(%rsp), %rax
movb $0x0, 0x10(%rsp,%rax)
movq 0x858b(%rip), %rax      # 0x10e70
movq (%rax), %r8
movq 0x430(%rsp), %rdi
movq 0x410(%rsp), %rsi
leaq 0x10(%rsp), %rcx
leaq 0x57d6(%rip), %rdx      # 0xe0da
movb $0x0, %al
callq *%r8
addq $0x438, %rsp            # imm = 0x438
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm.c
// Function: rpm_worker_log_buffer_flush
static size_t rpm_worker_log_buffer_flush(worker_pipe *pipe, char *log_buffer, size_t offset)
{
  chained_buffer *buffer = pipe->read_buffer;
  while (buffer != NULL) {
    offset = rpm_worker_log_buffer_append(log_buffer, offset, buffer->buffer, buffer->size);
    buffer = buffer->next;
  }
  chained_buffer_destroy(&pipe->read_buffer, pipe->num_buffers);
  rpm_worker_pipe_buffer_reset(pipe);
  return offset;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x8a0e
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
addq $0x20, %rdx
movq 0x8(%rsp), %rax
movslq 0xc(%rax), %rcx
callq 0x8a40
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x89d1
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
movq 0x20(%rsp), %rax
movslq 0x20(%rax), %rsi
callq 0x50e0
movq 0x20(%rsp), %rdi
callq 0x7880
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm.c
// Function: rpm_worker_log_buffer_append
static size_t rpm_worker_log_buffer_append(char *buffer, size_t offset, const void *log, size_t length) {
  if (offset + length >= MAX_LOG_LEN) {
    length = MAX_LOG_LEN - offset;
  }
  if (length > 0) {
    memcpy(buffer + offset, log, length);
    return offset + length;
  } else {
    return offset;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
movq 0x10(%rsp), %rax
addq (%rsp), %rax
cmpq $0x3e8, %rax            # imm = 0x3E8
jb 0x8a76
movl $0x3e8, %eax            # imm = 0x3E8
subq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jbe 0x8aa5
movq 0x18(%rsp), %rdi
addq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x5220
movq 0x10(%rsp), %rax
addq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x8aaf
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm.c
// Function: rpm_worker_redirect_fd
static inline void rpm_worker_redirect_fd(int from, int to) {
  if (from == to) {
    return;
  }
  dup2(from, to);
  close(from);
}

// Assembly:
pushq %rax
movl %edi, 0x4(%rsp)
movl %esi, (%rsp)
movl 0x4(%rsp), %eax
cmpl (%rsp), %eax
jne 0x8ad3
jmp 0x8ae8
movl 0x4(%rsp), %edi
movl (%rsp), %esi
callq 0x50d0
movl 0x4(%rsp), %edi
callq 0x5140
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm.c
// Function: rpm_worker_process_daemonize
static void rpm_worker_process_daemonize() {
  pid_t pid;

  umask(027);
  setsid();
  signal(SIGCHLD, SIG_IGN);
  signal(SIGHUP, SIG_IGN);
  if ((pid = fork()) != 0) {
    if (pid < 0) {
      exit(1);
    } else {
      exit(0);
    }
  }
}

// Assembly:
pushq %rax
movl $0x17, %edi
callq 0x5200
callq 0x5160
movl $0x11, %edi
movl $0x1, %esi
callq 0x51e0
movl $0x1, %edi
movl $0x1, %esi
callq 0x51e0
callq 0x53e0
movl %eax, 0x4(%rsp)
cmpl $0x0, %eax
je 0x8b44
cmpl $0x0, 0x4(%rsp)
jge 0x8b3d
movl $0x1, %edi
callq 0x53a0
xorl %edi, %edi
callq 0x53a0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm.c
// Function: rpm_worker_create_later
static int rpm_worker_create_later(RedisModuleCtx *ctx, long long id, void *user_data) {
  rpm_context *rpm = user_data;
  REDISMODULE_NOT_USED(id);
  if ((rpm->worker = rpm_worker_create(ctx, rpm)) != NULL) {
    rpm->restart_timer = -1;
    return REDISMODULE_TIME_NOMORE;
  } else {
    return 0;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
callq 0x6b60
movq (%rsp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
je 0x8b9e
movq (%rsp), %rax
movq $-0x1, 0x50(%rax)
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x8ba6
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm.c
// Function: rpm_context_shutdown_redis
static void rpm_context_shutdown_redis(RedisModuleCtx *ctx, rpm_context *rpm) {
  const char *shutdown = rpm->shutdown_command ? rpm->shutdown_command : "shutdown";
  RedisModuleCallReply *reply = RedisModule_Call(ctx, shutdown, "");
  if (reply != NULL) {
    RedisModule_FreeCallReply(reply);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x8bd9
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, (%rsp)
jmp 0x8be6
leaq 0x569f(%rip), %rax      # 0xe27f
movq %rax, (%rsp)
jmp 0x8be6
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8402(%rip), %rax      # 0x10ff8
movq (%rax), %rcx
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x570f(%rip), %rdx      # 0xe319
movb $0x0, %al
callq *%rcx
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x8c2c
movq 0x8326(%rip), %rax      # 0x10f48
movq (%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x8, %rsi
movq 0x10(%rsp), %rdx
addq $0x10, %rdx
movq 0x10(%rsp), %rcx
addq $0x18, %rcx
movq 0x18(%rsp), %r8
movq 0x10(%rsp), %rax
movl 0x1c(%rax), %r9d
callq 0x5370
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x53c0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rdx
xorl %esi, %esi
callq 0x5110
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
movq 0x8(%rsp), %rdx
addq $0x10, %rdx
movq 0x8(%rsp), %rcx
addq $0x18, %rcx
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %rax
movl 0x1c(%rax), %r9d
callq 0x5370
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x53c0
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x5220
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x51b0
movq %rax, (%rsp)
movq 0x30(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq (%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq $0x0, (%rsp)
cmpl $0x400, 0x14(%rsp)      # imm = 0x400
jge 0x8fb2
movl $0x400, 0x14(%rsp)      # imm = 0x400
movq 0x7f27(%rip), %rax      # 0x10ee0
movq (%rax), %rdi
movslq 0x14(%rsp), %rax
addq $0x20, %rax
movl %eax, %esi
callq 0x5380
movq %rax, (%rsp)
movq (%rsp), %rdi
movl $0x20, %esi
callq 0x53c0
movq %rax, 0x8(%rsp)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movl $0x1, 0x18(%rax)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x1c(%rax)
movq 0x8(%rsp), %r9
movq 0x7e9b(%rip), %rdi      # 0x10ec8
movq 0x7de4(%rip), %rsi      # 0x10e18
movq 0x7dd5(%rip), %rdx      # 0x10e10
movq 0x7f0e(%rip), %rcx      # 0x10f50
movq 0x7f6f(%rip), %r8       # 0x10fb8
callq 0x51c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x8(%rsp)
movb %al, 0x7(%rsp)
je 0x9186
cmpq $0x0, 0x18(%rsp)
seta %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x9190
jmp 0x91ca
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x5040
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x916b
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
movl $0x28, %ecx
addq $0x20, %rcx
subq $0x28, %rcx
addq %rcx, %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
movl %eax, 0x18(%rsp)
movslq 0x18(%rsp), %rax
movl $0x28, %ecx
addq $0x20, %rcx
subq $0x28, %rcx
subq %rcx, %rax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x18(%rsp), %rsi
callq 0x52d0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
addq $0x20, %rdx
subq $0x28, %rdx
callq 0x5110
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x8(%rax)
cmpq $0x0, 0x20(%rsp)
je 0x9283
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
jmp 0x9291
movq 0x7c56(%rip), %rax      # 0x10ee0
movq (%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq -0x28(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x92f1
movq -0x10(%rsp), %rax
movq (%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movq -0x20(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x28(%rsp), %rcx
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x28(%rsp), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movl %r9d, 0x3c(%rsp)
movq 0x58(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x7b8a(%rip), %rax      # 0x10ee0
movq (%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x9383
movq 0x30(%rsp), %rax
movl 0x10(%rax), %eax
movq 0x30(%rsp), %rcx
subl 0xc(%rcx), %eax
movq 0x40(%rsp), %rcx
cmpl %ecx, %eax
jge 0x9408
movq 0x40(%rsp), %rax
cmpl 0x3c(%rsp), %eax
jge 0x9398
movslq 0x3c(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x93ae
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x40(%rsp), %rax
movl %eax, %esi
callq 0x5380
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq %rax, %r8
movq %r8, 0x30(%rsp)
callq 0x50b0
movq 0x30(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl $0x5c6b7, -0x1c(%rsp)   # imm = 0x5C6B7
movl $0xf8c9, -0x20(%rsp)    # imm = 0xF8C9
movl $0x0, -0x24(%rsp)
movl $0x0, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x30(%rsp)
movl $0x0, -0x28(%rsp)
movl -0x28(%rsp), %eax
cmpq -0x18(%rsp), %rax
jae 0x94ab
movl -0x24(%rsp), %eax
imull -0x20(%rsp), %eax
movq -0x30(%rsp), %rcx
movzbl (%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x24(%rsp)
movl -0x20(%rsp), %eax
imull -0x1c(%rsp), %eax
movl %eax, -0x20(%rsp)
movq -0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rsp)
movl -0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rsp)
jmp 0x9461
movl -0x24(%rsp), %eax
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x94db
leaq 0x7e0a(%rip), %rax      # 0x112e0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x94f6
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, (%rsp)
jmp 0x9504
movq 0x79e3(%rip), %rax      # 0x10ee0
movq (%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x98, %esi
callq 0x52a0
movq %rax, 0x10(%rsp)
cmpq $0xf, 0x18(%rsp)
ja 0x9532
movq $0xf, 0x18(%rsp)
movq 0x10(%rsp), %rdi
addq $0x48, %rdi
callq 0x95d0
movq 0x10(%rsp), %rdi
addq $0x48, %rdi
addq $0x20, %rdi
callq 0x95d0
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x38, %edx
callq 0x5220
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x958e
movq 0x10(%rsp), %rax
movq 0x7915(%rip), %rcx      # 0x10ea0
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x10(%rsp), %rax
movq $-0x1, 0x88(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x90(%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_hashmap.c
// Function: hash_table_reset
static void
hash_table_reset(hash_table *table)
{
  table->buckets = NULL;
  table->size = 0;
  table->size_mask = 0;
  table->used = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movq (%rsp), %rsi
addq $0x48, %rsi
callq 0xa2b0
movq (%rsp), %rdi
movq (%rsp), %rsi
addq $0x48, %rsi
addq $0x20, %rsi
callq 0xa2b0
movq (%rsp), %rax
movq $-0x1, 0x88(%rax)
movq (%rsp), %rax
movq $0x0, 0x90(%rax)
xorl %eax, %eax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq 0x58(%rsp), %rax
cmpq $-0x1, 0x88(%rax)
je 0x96cb
movq 0x58(%rsp), %rdi
movl $0x1, %esi
callq 0x9850
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0x2f(%rsp), %rcx
callq 0x9ac0
movq %rax, 0x30(%rsp)
movzbl 0x2f(%rsp), %eax
cmpl $0x1, %eax
jne 0x96fd
movb $0x0, 0x67(%rsp)
jmp 0x983f
movq 0x58(%rsp), %rax
cmpq $-0x1, 0x88(%rax)
je 0x971f
movq 0x58(%rsp), %rax
addq $0x48, %rax
addq $0x20, %rax
movq %rax, (%rsp)
jmp 0x972c
movq 0x58(%rsp), %rax
addq $0x48, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rax
movq 0x30(%rax), %rdi
movl $0x28, %esi
callq 0x52d0
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x97c7
movq 0x10(%rsp), %rax
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq *%rax
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
jmp 0x97d4
movq 0x50(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x48(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x97e4
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x981e
movq 0x8(%rsp), %rax
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq *%rax
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x982c
movq 0x40(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x38(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movb $0x1, 0x67(%rsp)
movb 0x67(%rsp), %al
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_hashmap.c
// Function: hash_map_key_index
static size_t hash_map_key_index(hash_map *map, const void *key, size_t ksiz, uint8_t *found)
{
  int32_t st = 0;
  size_t hash, idx, table;
  hash_map_entry *entry;
  hash_table *hash_table;
  *found = 0;

  if ((st = hash_map_check_and_expand(map)) != 0) {
    return st;
  }

  hash = HASH_MAP_HASH_CODE(map, key, ksiz);
  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)) {
        *found = 1;
        break;
      }
      entry = entry->next;
    }
    if (!HASH_MAP_IS_REHASHING(map)) {
      break;
    }
  }
  return idx;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movb $0x0, (%rax)
movq 0x48(%rsp), %rdi
callq 0xa7f0
movl %eax, 0x2c(%rsp)
cmpl $0x0, %eax
je 0x9b0a
movslq 0x2c(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x9c1e
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq *%rax
movl %eax, %eax
movq %rax, 0x20(%rsp)
movq $0x0, 0x10(%rsp)
cmpq $0x1, 0x10(%rsp)
ja 0x9c14
movq 0x48(%rsp), %rax
addq $0x48, %rax
movq 0x10(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq (%rsp), %rcx
andq 0x10(%rcx), %rax
movq %rax, 0x18(%rsp)
movq (%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x9bee
movq 0x48(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x9bc5
movq 0x48(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq 0x8(%rsp), %r8
movq 0x8(%r8), %r8
callq *%rax
cmpl $0x0, %eax
je 0x9bd4
jmp 0x9bde
movq 0x40(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq (%rcx), %rax
jne 0x9bde
movq 0x30(%rsp), %rax
movb $0x1, (%rax)
jmp 0x9bee
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x9b7f
movq 0x48(%rsp), %rax
cmpq $-0x1, 0x88(%rax)
jne 0x9bff
jmp 0x9c14
jmp 0x9c01
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x9b33
movq 0x18(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x38(%rsp), %r8
callq 0x5270
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x9c80
movl $0x0, 0x64(%rsp)
jmp 0x9d2e
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x9d40
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
movl $0x28, %edx
callq 0x5220
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x9ce4
movq (%rsp), %rax
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq *%rax
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x9cf2
movq 0x40(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x58(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x9d26
movq 0x58(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x58(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq *%rax
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x9d6d
movq $0x0, 0x40(%rsp)
jmp 0x9ea9
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq *%rax
movl %eax, %eax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
cmpq $-0x1, 0x88(%rax)
je 0x9dab
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x9850
movq $0x0, 0x8(%rsp)
cmpq $0x1, 0x8(%rsp)
ja 0x9ea0
movq 0x38(%rsp), %rax
addq $0x48, %rax
movq 0x8(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
andq 0x10(%rcx), %rax
movq %rax, 0x10(%rsp)
movq (%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x9e71
movq 0x38(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x9e46
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq 0x20(%rsp), %r8
movq 0x8(%r8), %r8
callq *%rax
cmpl $0x0, %eax
je 0x9e55
jmp 0x9e61
movq 0x30(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq (%rcx), %rax
jne 0x9e61
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x9ea9
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x9e00
movq 0x38(%rsp), %rax
cmpq $-0x1, 0x88(%rax)
jne 0x9e8b
movq $0x0, 0x40(%rsp)
jmp 0x9ea9
jmp 0x9e8d
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x9db4
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x9d40
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0xa1d6
movq (%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x34(%rsp)
jmp 0xa1de
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x10(%rsp), %rcx
leaq 0x8(%rsp), %r8
callq 0x51d0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0xa25a
movl 0x4(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0xa29c
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpq 0x8(%rsp), %rax
jae 0xa273
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0xa29c
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x5220
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)