LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_hashmap.c
// Function: hash_table_clear
int32_t hash_table_clear(hash_map *map, hash_table *table)
{
  size_t idx;
  hash_map_entry *entry = NULL;
  hash_map_entry *next = NULL;

  for (idx = 0; idx < table->size && table->used > 0; ++idx) {
    if ((entry = table->buckets[idx]) == NULL) {
      continue;
    }
    while (entry) {
      next = entry->next;
      HASH_MAP_ENTRY_FREE_KEY(map, entry)
      HASH_MAP_ENTRY_FREE_VALUE(map, entry)
      HASH_MAP_FREE(map, entry);
      --(table->used);
      entry = next;
    }
  }
  HASH_MAP_FREE(map, table->buckets);
  hash_table_reset(table);

  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, 0xf(%rsp)
jae 0xa300
movq 0x28(%rsp), %rax
cmpq $0x0, 0x18(%rax)
seta %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xa30d
jmp 0xa3ed
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
jne 0xa32e
jmp 0xa3da
jmp 0xa330
cmpq $0x0, 0x18(%rsp)
je 0xa3d8
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0xa377
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq (%rcx), %rsi
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rdx
callq *%rax
movq 0x30(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0xa3a5
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rsi
movq 0x18(%rsp), %rcx
movq 0x18(%rcx), %rdx
callq *%rax
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x5040
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0xa330
jmp 0xa3da
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0xa2d9
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x28(%rsp), %rax
movq (%rax), %rsi
callq 0x5040
movq 0x28(%rsp), %rdi
callq 0x95d0
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_hashmap.c
// Function: hash_map_iterator_create
hash_map_iterator *hash_map_iterator_create(hash_map *map)
{
  hash_map_iterator *iterator;
  iterator = HASH_MAP_CALLOC(map, sizeof(hash_map_iterator));
  iterator->map = map;
  iterator->index = -1;
  return iterator;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
movl $0x30, %esi
callq 0x52a0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq $-0x1, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_hashmap.c
// Function: hash_map_iterator_get
void hash_map_iterator_get(hash_map_iterator *iterator, const void **key, size_t *ksiz, const void **val, size_t *vsiz)
{
  hash_map_entry *entry = iterator->current;
  if (entry) {
    *key = entry->key;
    *ksiz = entry->ksize;
    *val = entry->value;
    *vsiz = entry->vsize;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rsp)
cmpq $0x0, -0x30(%rsp)
je 0xa532
movq -0x30(%rsp), %rax
movq (%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movq -0x30(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movq -0x30(%rsp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
movq -0x30(%rsp), %rax
movq 0x18(%rax), %rcx
movq -0x28(%rsp), %rax
movq %rcx, (%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_hashmap.c
// Function: hash_map_iterator_next
uint8_t hash_map_iterator_next(hash_map_iterator *iterator)
{
  hash_table *table;
  hash_map *map = iterator->map;
  while (1) {
    if (iterator->current == NULL) {
      table = &map->tables[iterator->table];
      if (iterator->safe && iterator->index == -1 && iterator->table == 0) {
        iterator->map->iterators++;
      }
      iterator->index++;
      if (iterator->index >= (int64_t)(table->size)) {
        if (HASH_MAP_IS_REHASHING(map) && iterator->table == 0) {
          iterator->table++;
          iterator->index = 0;
          table = &map->tables[1];
        } else {
          break;
        }
      }
      iterator->current = table->buckets[iterator->index];
    } else {
      iterator->current = iterator->next;
    }
    if (iterator->current) {
      /* save next entry */
      iterator->next = iterator->current->next;
      return 1;
    }
  }
  return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xa656
movq -0x20(%rsp), %rax
addq $0x48, %rax
movq -0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
movzbl 0x28(%rax), %eax
cmpl $0x0, %eax
je 0xa5c0
movq -0x10(%rsp), %rax
cmpq $-0x1, 0x10(%rax)
jne 0xa5c0
movq -0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xa5c0
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq 0x90(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x90(%rax)
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jl 0xa636
movq -0x20(%rsp), %rax
cmpq $-0x1, 0x88(%rax)
je 0xa632
movq -0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xa632
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rsp), %rax
addq $0x48, %rax
addq $0x20, %rax
movq %rax, -0x18(%rsp)
jmp 0xa634
jmp 0xa696
jmp 0xa636
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq -0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
jmp 0xa668
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0xa691
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movb $0x1, -0x1(%rsp)
jmp 0xa69b
jmp 0xa552
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_hashmap.c
// Function: hash_map_bitwise_compare_data
int32_t hash_map_bitwise_compare_data(hash_map *map, const void *data1, size_t size1, const void *data2, size_t size2)
{
  (void) map;
  if (size1 != size2) {
    if (size1 > size2) {
      return 1;
    } else {
      return -1;
    }
  }
  return memcmp(data1, data2, size1);
}

// 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 0x18(%rsp), %rax
cmpq 0x8(%rsp), %rax
je 0xa7c9
movq 0x18(%rsp), %rax
cmpq 0x8(%rsp), %rax
jbe 0xa7bf
movl $0x1, 0x34(%rsp)
jmp 0xa7e1
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0xa7e1
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x5190
movl %eax, 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_hashmap.c
// Function: hash_map_check_and_expand
static int32_t
hash_map_check_and_expand(hash_map *map)
{
  hash_table *table;
  if (HASH_MAP_IS_REHASHING(map)) {
    return 0;
  }

  table = &map->tables[0];
  if (table->size == 0) {
    return hash_map_expand(map, map->initial_size);
  }
  if (table->used >= table->size) {
    return hash_map_expand(map, table->size > table->used ? table->size : table->used * 2);
  }
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq $-0x1, 0x88(%rax)
je 0xa815
movl $0x0, 0x24(%rsp)
jmp 0xa8b5
movq 0x18(%rsp), %rax
addq $0x48, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xa848
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rsi
callq 0xa8c0
movl %eax, 0x24(%rsp)
jmp 0xa8b5
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jb 0xa8ad
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jbe 0xa889
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
jmp 0xa899
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
shlq %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0xa8c0
movl %eax, 0x24(%rsp)
jmp 0xa8b5
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_hashmap.c
// Function: hash_map_expand
static int32_t
hash_map_expand(hash_map *map, size_t size)
{
  size_t realsize = hash_map_expand_get_aligned_size(map, size);
  size_t memsize = realsize * sizeof(hash_map_entry);
  hash_table new_table;
  if (HASH_MAP_IS_REHASHING(map) || map->tables[0].used > size) {
    return -1;
  }

  new_table.size = realsize;
  new_table.size_mask = realsize - 1;
  new_table.buckets = HASH_MAP_CALLOC(map, memsize);
  new_table.used = 0;

  if (map->tables[0].buckets == NULL) {
    /* this is the first call after initialization */
    map->tables[0] = new_table;
    return 0;
  }

  map->tables[1] = new_table;
  map->rehash_index = 0;
  return 0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xa9e0
movq %rax, 0x28(%rsp)
imulq $0x28, 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
cmpq $-0x1, 0x88(%rax)
jne 0xa90c
movq 0x38(%rsp), %rax
movq 0x60(%rax), %rax
cmpq 0x30(%rsp), %rax
jbe 0xa919
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0xa9d2
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x52a0
movq %rax, (%rsp)
movq $0x0, 0x18(%rsp)
movq 0x38(%rsp), %rax
cmpq $0x0, 0x48(%rax)
jne 0xa98f
movq 0x38(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x48(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x50(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x58(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x60(%rax)
movl $0x0, 0x44(%rsp)
jmp 0xa9d2
movq 0x38(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x68(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x70(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x78(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x80(%rax)
movq 0x38(%rsp), %rax
movq $0x0, 0x88(%rax)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_hashmap.c
// Function: hash_map_expand_get_aligned_size
static size_t hash_map_expand_get_aligned_size(hash_map *map, size_t size)
{
  size_t result = map->initial_size;

  if (size >= ULONG_MAX) {
    return ULONG_MAX;
  }
  while (1) {
    if (result >= size) {
      return result;
    }
    result <<= 1;
  }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rsp)
cmpq $-0x1, -0x18(%rsp)
jb 0xaa0b
movq $-0x1, -0x8(%rsp)
jmp 0xaa34
jmp 0xaa0d
movq -0x20(%rsp), %rax
cmpq -0x18(%rsp), %rax
jb 0xaa25
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0xaa34
movq -0x20(%rsp), %rax
shlq %rax
movq %rax, -0x20(%rsp)
jmp 0xaa0d
movq -0x8(%rsp), %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_redis.c
// Function: redis_format_command
chained_buffer *redis_format_command(allocator *allocator, uint32_t argc, const char **argv, const size_t *argvlen) {
  uint32_t wr, total, idx, len;
  char *realbuffer;
  chained_buffer *buffer;

  total = 1 + redis_integer_digits(argc) + 2;
  for (idx = 0; idx < argc; idx++) {
    total += redis_bulk_length(argvlen[idx]);
  }

  if ((buffer = chained_buffer_create(allocator, total + 1)) == NULL) {
    return NULL;
  }
  realbuffer = (char *) buffer->buffer;

  wr = sprintf(realbuffer, "*%d\r\n", argc);
  for (idx = 0; idx < argc; idx++) {
    len = argvlen[idx];
    wr += sprintf(realbuffer + wr, "$%u\r\n", len);
    memcpy(realbuffer + wr, argv[idx], len);
    wr += len;
    realbuffer[wr++] = '\r';
    realbuffer[wr++] = '\n';
  }
  realbuffer[wr] = '\0';
  buffer->size = wr;

  return buffer;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movl 0x34(%rsp), %eax
movl %eax, %edi
callq 0xabe0
addl $0x1, %eax
addl $0x2, %eax
movl %eax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x34(%rsp), %eax
jae 0xaaa7
movq 0x20(%rsp), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, %edi
callq 0xac70
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xaa74
movq 0x38(%rsp), %rdi
movl 0x18(%rsp), %esi
addl $0x1, %esi
callq 0x5380
movq %rax, (%rsp)
cmpq $0x0, %rax
jne 0xaad0
movq $0x0, 0x40(%rsp)
jmp 0xabd6
movq (%rsp), %rax
addq $0x20, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl 0x34(%rsp), %edx
leaq 0x3827(%rip), %rsi      # 0xe314
movb $0x0, %al
callq 0x5390
movl %eax, 0x1c(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x34(%rsp), %eax
jae 0xabb5
movq 0x20(%rsp), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
addq %rax, %rdi
movl 0x10(%rsp), %edx
leaq 0x37e4(%rip), %rsi      # 0xe31a
movb $0x0, %al
callq 0x5390
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
addq %rax, %rdi
movq 0x28(%rsp), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
movl 0x10(%rsp), %eax
movl %eax, %edx
callq 0x5220
movl 0x10(%rsp), %eax
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x8(%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x1c(%rsp)
movl %ecx, %ecx
movb $0xd, (%rax,%rcx)
movq 0x8(%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x1c(%rsp)
movl %ecx, %ecx
movb $0xa, (%rax,%rcx)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xab00
movq 0x8(%rsp), %rax
movl 0x1c(%rsp), %ecx
movb $0x0, (%rax,%rcx)
movl 0x1c(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0xc(%rax)
movq (%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_redis.c
// Function: redis_integer_digits
static inline uint32_t redis_integer_digits(uint64_t integer) {
  uint32_t len = 1;
  while (1) {
    if (integer < 10) return len;
    if (integer < 100) return len + 1;
    if (integer < 1000) return len + 2;
    if (integer < 10000) return len + 3;
    integer /= 10000U;
    len += 4;
  }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl $0x1, -0x14(%rsp)
cmpq $0xa, -0x10(%rsp)
jae 0xabff
movl -0x14(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0xac65
cmpq $0x64, -0x10(%rsp)
jae 0xac14
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0xac65
cmpq $0x3e8, -0x10(%rsp)     # imm = 0x3E8
jae 0xac2c
movl -0x14(%rsp), %eax
addl $0x2, %eax
movl %eax, -0x4(%rsp)
jmp 0xac65
cmpq $0x2710, -0x10(%rsp)    # imm = 0x2710
jae 0xac44
movl -0x14(%rsp), %eax
addl $0x3, %eax
movl %eax, -0x4(%rsp)
jmp 0xac65
movq -0x10(%rsp), %rax
movl $0x2710, %ecx           # imm = 0x2710
xorl %edx, %edx
divq %rcx
movq %rax, -0x10(%rsp)
movl -0x14(%rsp), %eax
addl $0x4, %eax
movl %eax, -0x14(%rsp)
jmp 0xabed
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_redis.c
// Function: redis_response_reader_free_response
void redis_response_reader_free_response(redis_response *resp) {
  size_t idx;
  if (resp == NULL) {
    return;
  }

  switch(resp->type) {
  case REDIS_RESPONSE_INTEGER:
    break;
  case REDIS_RESPONSE_ARRAY:
    if (resp->payload.array.array != NULL) {
      for (idx = 0; idx < resp->payload.array.length; idx++) {
        if (resp->payload.array.array[idx] != NULL) {
          redis_response_reader_free_response(resp->payload.array.array[idx]);
        }
      }
      allocator_free(resp->allocator, resp->payload.array.array);
    }
    break;
  case REDIS_RESPONSE_ERROR:
  case REDIS_RESPONSE_STATUS:
  case REDIS_RESPONSE_STRING:
    if (resp->payload.string.str != NULL) {
      allocator_free(resp->allocator, resp->payload.string.str);
    }
    break;
  default:
    break;
  }
  allocator_free(resp->allocator, resp);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xaca6
jmp 0xad8d
movq 0x10(%rsp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x5, %eax
ja 0xad78
movq (%rsp), %rax
leaq 0x35bf(%rip), %rcx      # 0xe288
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xad7a
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0xad51
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jae 0xad3a
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xad28
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5260
jmp 0xad2a
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0xacec
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x5040
jmp 0xad7a
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0xad76
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x5040
jmp 0xad7a
jmp 0xad7a
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x5040
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_redis.c
// Function: redis_response_reader_create
redis_response_reader *redis_response_reader_create(allocator *allocator, int32_t max_buf) {
  redis_response_reader *reader;

  if ((reader = allocator_calloc(allocator, sizeof(redis_response_reader))) == NULL) {
    return NULL;
  }

  reader->allocator = allocator;
  reader->err = 0;
  reader->errstr[0] = '\0';
  reader->buf = NULL;
  reader->capacity = 0;
  reader->max_buf = max_buf < SIZE_16KB ? SIZE_16KB : max_buf;
  reader->task_idx = -1;
  reader->max_task_idx = (sizeof(reader->tasks) / sizeof(reader->tasks[0])) - 1;
  if (reader->max_task_idx >= 15) {
    reader->max_task_idx = 15;
  }
  return reader;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1e8, %esi            # imm = 0x1E8
callq 0x52a0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0xade5
movq $0x0, 0x20(%rsp)
jmp 0xae9f
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x88(%rax)
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x4(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x90(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x98(%rax)
cmpl $0x4000, 0x14(%rsp)     # imm = 0x4000
jge 0xae3f
movl $0x4000, %eax           # imm = 0x4000
movl %eax, 0x4(%rsp)
jmp 0xae47
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movslq %eax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0xb0(%rax)
movq 0x8(%rsp), %rax
movl $0xffffffff, 0x1d8(%rax) # imm = 0xFFFFFFFF
movq 0x8(%rsp), %rax
movl $0x8, 0x1dc(%rax)
movq 0x8(%rsp), %rax
cmpl $0xf, 0x1dc(%rax)
jl 0xae95
movq 0x8(%rsp), %rax
movl $0xf, 0x1dc(%rax)
movq 0x8(%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_redis.c
// Function: redis_response_reader_feed
redis_response_status redis_response_reader_feed(redis_response_reader *reader, const char *buf, int32_t size) {
  REDIS_RESPONSE_READER_CHECK_ERROR(reader);

  if (buf != NULL && size >= 1) {
    if (reader->len == 0 && reader->capacity > reader->max_buf) {
      reader->capacity = SIZE_4KB < size ? size * 2 : SIZE_4KB;
      reader->pos = 0;
      if ((reader->buf = allocator_realloc(reader->allocator, reader->buf, reader->capacity)) == NULL) {
        redis_response_reader_set_error_oom(reader);
        return reader->err;
      }
    }

    if (reader->capacity - reader->len < (uint32_t) size) {
      reader->capacity = 2 * (reader->capacity + size);
      if ((reader->buf = allocator_realloc(reader->allocator, reader->buf, reader->capacity)) == NULL) {
        redis_response_reader_set_error_oom(reader);
        return reader->err;
      }
    }
    memcpy(reader->buf + reader->len, buf, size);
    reader->len += size;
  }

  return REDIS_RESPONSE_OK;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
je 0xaee1
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0xb0a6
jmp 0xaee3
cmpq $0x0, 0x10(%rsp)
je 0xb09e
cmpl $0x1, 0xc(%rsp)
jl 0xb09e
movq 0x18(%rsp), %rax
cmpq $0x0, 0xa8(%rax)
jne 0xafc7
movq 0x18(%rsp), %rax
movq 0x98(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0xb0(%rcx), %rax
jbe 0xafc7
movl $0x1000, %eax           # imm = 0x1000
cmpl 0xc(%rsp), %eax
jge 0xaf42
movl 0xc(%rsp), %eax
shll %eax
movl %eax, 0x4(%rsp)
jmp 0xaf4d
movl $0x1000, %eax           # imm = 0x1000
movl %eax, 0x4(%rsp)
jmp 0xaf4d
movl 0x4(%rsp), %eax
movslq %eax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x98(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0xa0(%rax)
movq 0x18(%rsp), %rax
movq 0x88(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x90(%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x98(%rax), %rdx
callq 0x52f0
movq 0x18(%rsp), %rcx
movq %rax, 0x90(%rcx)
cmpq $0x0, %rax
jne 0xafc5
movq 0x18(%rsp), %rdi
callq 0xb0b0
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0xb0a6
jmp 0xafc7
movq 0x18(%rsp), %rax
movq 0x98(%rax), %rax
movq 0x18(%rsp), %rcx
subq 0xa8(%rcx), %rax
movl 0xc(%rsp), %ecx
cmpq %rcx, %rax
jae 0xb05f
movq 0x18(%rsp), %rax
movq 0x98(%rax), %rcx
movslq 0xc(%rsp), %rax
addq %rax, %rcx
shlq %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x98(%rax)
movq 0x18(%rsp), %rax
movq 0x88(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x90(%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x98(%rax), %rdx
callq 0x52f0
movq 0x18(%rsp), %rcx
movq %rax, 0x90(%rcx)
cmpq $0x0, %rax
jne 0xb05d
movq 0x18(%rsp), %rdi
callq 0xb0b0
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0xb0a6
jmp 0xb05f
movq 0x18(%rsp), %rax
movq 0x90(%rax), %rdi
movq 0x18(%rsp), %rax
addq 0xa8(%rax), %rdi
movq 0x10(%rsp), %rsi
movslq 0xc(%rsp), %rdx
callq 0x5220
movslq 0xc(%rsp), %rcx
movq 0x18(%rsp), %rax
addq 0xa8(%rax), %rcx
movq %rcx, 0xa8(%rax)
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_redis.c
// Function: redis_response_reader_next
redis_response_status redis_response_reader_next(redis_response_reader *reader, redis_response **response) {
  *response = NULL;
  REDIS_RESPONSE_READER_CHECK_ERROR(reader);
  if (reader->len == 0) {
    return REDIS_RESPONSE_OK;
  }

  if (reader->task_idx == -1) {
    redis_response_reader_task_init(NULL, reader->tasks, -1);
    reader->task_idx = 0;
  }

  while (reader->task_idx >= 0) {
    if (redis_response_process_item(reader) != REDIS_RESPONSE_OK) {
      break;
    }
  }

  REDIS_RESPONSE_READER_CHECK_ERROR(reader);

  if (reader->pos >= 1024) {
    memmove(reader->buf, reader->buf + reader->pos, reader->len - reader->pos);
    reader->len -= reader->pos;
    reader->pos = 0;
  }

  if (reader->task_idx == -1) {
    *response = reader->response;
    reader->response = NULL;
  }
  return REDIS_RESPONSE_OK;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0xb109
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0xb263
jmp 0xb10b
movq 0x18(%rsp), %rax
cmpq $0x0, 0xa8(%rax)
jne 0xb127
movl $0x0, 0x24(%rsp)
jmp 0xb263
movq 0x18(%rsp), %rax
cmpl $-0x1, 0x1d8(%rax)
jne 0xb15e
movq 0x18(%rsp), %rsi
addq $0xb8, %rsi
xorl %eax, %eax
movl %eax, %edi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xb270
movq 0x18(%rsp), %rax
movl $0x0, 0x1d8(%rax)
jmp 0xb160
movq 0x18(%rsp), %rax
cmpl $0x0, 0x1d8(%rax)
jl 0xb181
movq 0x18(%rsp), %rdi
callq 0xb2c0
cmpl $0x0, %eax
je 0xb17f
jmp 0xb181
jmp 0xb160
jmp 0xb183
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
je 0xb1a2
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0xb263
jmp 0xb1a4
movq 0x18(%rsp), %rax
cmpq $0x400, 0xa0(%rax) # imm = 0x400
jb 0xb229
movq 0x18(%rsp), %rax
movq 0x90(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x90(%rax), %rsi
movq 0x18(%rsp), %rax
addq 0xa0(%rax), %rsi
movq 0x18(%rsp), %rax
movq 0xa8(%rax), %rdx
movq 0x18(%rsp), %rax
subq 0xa0(%rax), %rdx
callq 0x52e0
movq 0x18(%rsp), %rax
movq 0xa0(%rax), %rdx
movq 0x18(%rsp), %rax
movq 0xa8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0xa8(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0xa0(%rax)
movq 0x18(%rsp), %rax
cmpl $-0x1, 0x1d8(%rax)
jne 0xb25b
movq 0x18(%rsp), %rax
movq 0x1e0(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x1e0(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_redis.c
// Function: redis_response_reader_task_init
static inline void redis_response_reader_task_init(redis_response_reader_task *parent, redis_response_reader_task *task, int32_t idx) {
  task->type = -1;
  task->elements = -1;
  task->idx = idx;
  task->obj = NULL;
  task->parent = parent;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq -0x10(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x10(%rsp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movl -0x14(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_redis.c
// Function: redis_response_reader_free
void redis_response_reader_free(redis_response_reader *reader) {
  if (reader->response != NULL) {
    redis_response_reader_free_response(reader->response);
  }
  if (reader->buf != NULL) {
    allocator_free(reader->allocator, reader->buf);
  }
  allocator_free(reader->allocator, reader);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x1e0(%rax)
je 0xb463
movq (%rsp), %rax
movq 0x1e0(%rax), %rdi
callq 0x5260
movq (%rsp), %rax
cmpq $0x0, 0x90(%rax)
je 0xb48c
movq (%rsp), %rax
movq 0x88(%rax), %rdi
movq (%rsp), %rax
movq 0x90(%rax), %rsi
callq 0x5040
movq (%rsp), %rax
movq 0x88(%rax), %rdi
movq (%rsp), %rsi
callq 0x5040
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_redis.c
// Function: redis_response_reader_set_error
static void redis_response_reader_set_error(redis_response_reader *reader, int32_t type, const char *str) {
  size_t len;

  if (reader->response != NULL) {
    redis_response_reader_free_response(reader->response);
    reader->response = NULL;
  }

  if (reader->buf != NULL) {
    allocator_free(reader->allocator, reader->buf);
    reader->buf = NULL;
    reader->capacity = 0;
    reader->pos = reader->len = 0;
  }

  reader->task_idx = -1;

  reader->err = type;
  len = strlen(str);
  len = len < (sizeof(reader->errstr) - 1) ? len : (sizeof(reader->errstr) - 1);
  memcpy(reader->errstr, str, len);
  reader->errstr[len] = '\0';
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x1e0(%rax)
je 0xb4f2
movq 0x20(%rsp), %rax
movq 0x1e0(%rax), %rdi
callq 0x5260
movq 0x20(%rsp), %rax
movq $0x0, 0x1e0(%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x90(%rax)
je 0xb55e
movq 0x20(%rsp), %rax
movq 0x88(%rax), %rdi
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rsi
callq 0x5040
movq 0x20(%rsp), %rax
movq $0x0, 0x90(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x98(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0xa8(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0xa0(%rax)
movq 0x20(%rsp), %rax
movl $0xffffffff, 0x1d8(%rax) # imm = 0xFFFFFFFF
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rdi
callq 0x50c0
movq %rax, 0x8(%rsp)
cmpq $0x7f, 0x8(%rsp)
jae 0xb59a
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
jmp 0xb5a5
movl $0x7f, %eax
movq %rax, (%rsp)
jmp 0xb5a5
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
addq $0x4, %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x5220
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, 0x4(%rax,%rcx)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_redis.c
// Function: redis_response_reader_read_bytes
static char *redis_response_reader_read_bytes(redis_response_reader *reader, uint32_t bytes) {
  char *p;
  if (reader->len - reader->pos >= bytes) {
    p = reader->buf + reader->pos;
    reader->pos += bytes;
    return p;
  }
  return NULL;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq 0xa8(%rax), %rax
movq -0x10(%rsp), %rcx
subq 0xa0(%rcx), %rax
movl -0x14(%rsp), %ecx
cmpq %rcx, %rax
jb 0xb64c
movq -0x10(%rsp), %rax
movq 0x90(%rax), %rax
movq -0x10(%rsp), %rcx
addq 0xa0(%rcx), %rax
movq %rax, -0x20(%rsp)
movl -0x14(%rsp), %eax
movl %eax, %ecx
movq -0x10(%rsp), %rax
addq 0xa0(%rax), %rcx
movq %rcx, 0xa0(%rax)
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0xb655
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_redis.c
// Function: redis_response_reader_set_error_protocol_byte
static inline void redis_response_reader_set_error_protocol_byte(redis_response_reader *reader, char byte) {
  char cbuf[8], sbuf[128];

  redis_response_reader_set_error_protocol_str(cbuf, sizeof(cbuf), byte);
  snprintf(sbuf, sizeof(sbuf), "Protocol error, got %s as response type byte", cbuf);
  redis_response_reader_set_error(reader, REDIS_RESPONSE_ERROR_PROTOCOL, sbuf);
}

// Assembly:
subq $0x98, %rsp
movb %sil, %al
movq %rdi, 0x90(%rsp)
movb %al, 0x8f(%rsp)
leaq 0x87(%rsp), %rdi
movl $0x8, %esi
movsbl 0x8f(%rsp), %edx
callq 0xbbd0
movq %rsp, %rdi
leaq 0x87(%rsp), %rcx
movl $0x80, %esi
leaq 0x2ccd(%rip), %rdx      # 0xe377
movb $0x0, %al
callq 0x50f0
movq 0x90(%rsp), %rdi
movq %rsp, %rdx
movl $0x2, %esi
callq 0xb4b0
addq $0x98, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_redis.c
// Function: redis_response_reader_read_line_item
static int32_t redis_response_reader_read_line_item(redis_response_reader *reader) {
  redis_response_reader_task *cur = reader->tasks + reader->task_idx;
  void *obj;
  char *p;
  int32_t len;

  if ((p = redis_response_reader_read_line(reader, &len)) != NULL) {
    if (cur->type == REDIS_RESPONSE_INTEGER) {
      obj = redis_response_reader_create_integer(reader, cur, redis_response_reader_read_integer(p));
    } else {
      obj = redis_response_reader_create_string(reader, cur, p, len);
    }
    if (obj == NULL) {
      redis_response_reader_set_error_oom(reader);
      return reader->err;
    }
    if (reader->task_idx == 0) {
      reader->response = obj;
    }
    redis_response_reader_next_task(reader);
    return REDIS_RESPONSE_OK;
  }

  return REDIS_RESPONSE_ERROR_WOULDBLOCK;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq $0xb8, %rax
movq 0x38(%rsp), %rcx
movslq 0x1d8(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0xbda0
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0xb7cb
movq 0x30(%rsp), %rax
cmpl $0x3, (%rax)
jne 0xb75b
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0xbf30
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0xbe70
movq %rax, 0x28(%rsp)
jmp 0xb779
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdx
movslq 0x1c(%rsp), %rcx
callq 0xc000
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0xb798
movq 0x38(%rsp), %rdi
callq 0xb0b0
movq 0x38(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x44(%rsp)
jmp 0xb7d3
movq 0x38(%rsp), %rax
cmpl $0x0, 0x1d8(%rax)
jne 0xb7b7
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x1e0(%rax)
movq 0x38(%rsp), %rdi
callq 0xc180
movl $0x0, 0x44(%rsp)
jmp 0xb7d3
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_redis.c
// Function: redis_response_reader_set_error_protocol_str
static size_t redis_response_reader_set_error_protocol_str(char *buf, size_t size, char byte) {
  size_t len = 0;

  switch(byte) {
  case '\\':
  case '"':
    len = snprintf(buf, size, "\"\\%c\"", byte);
    break;
  case '\n': len = snprintf(buf, size, "\"\\n\""); break;
  case '\r': len = snprintf(buf, size, "\"\\r\""); break;
  case '\t': len = snprintf(buf, size, "\"\\t\""); break;
  case '\a': len = snprintf(buf, size, "\"\\a\""); break;
  case '\b': len = snprintf(buf, size, "\"\\b\""); break;
  default:
    if (isprint(byte)) {
      len = snprintf(buf, size,"\"%c\"", byte);
    } else {
      len = snprintf(buf, size, "\"\\x%02x\"", (unsigned char) byte);
    }
    break;
  }

  return len;
}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq $0x0, 0x8(%rsp)
movsbl 0x17(%rsp), %eax
movl %eax, 0x4(%rsp)
subl $0x7, %eax
je 0xbce4
jmp 0xbc01
movl 0x4(%rsp), %eax
subl $0x8, %eax
je 0xbd08
jmp 0xbc10
movl 0x4(%rsp), %eax
subl $0x9, %eax
je 0xbcc0
jmp 0xbc1f
movl 0x4(%rsp), %eax
subl $0xa, %eax
je 0xbc78
jmp 0xbc2a
movl 0x4(%rsp), %eax
subl $0xd, %eax
je 0xbc9c
jmp 0xbc35
movl 0x4(%rsp), %eax
subl $0x22, %eax
je 0xbc4f
jmp 0xbc40
movl 0x4(%rsp), %eax
subl $0x5c, %eax
jne 0xbd29
jmp 0xbc4f
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movsbl 0x17(%rsp), %ecx
leaq 0x273f(%rip), %rdx      # 0xe3a4
movb $0x0, %al
callq 0x50f0
cltq
movq %rax, 0x8(%rsp)
jmp 0xbd93
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x2721(%rip), %rdx      # 0xe3aa
movb $0x0, %al
callq 0x50f0
cltq
movq %rax, 0x8(%rsp)
jmp 0xbd93
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x2702(%rip), %rdx      # 0xe3af
movb $0x0, %al
callq 0x50f0
cltq
movq %rax, 0x8(%rsp)
jmp 0xbd93
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x26e3(%rip), %rdx      # 0xe3b4
movb $0x0, %al
callq 0x50f0
cltq
movq %rax, 0x8(%rsp)
jmp 0xbd93
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x26c4(%rip), %rdx      # 0xe3b9
movb $0x0, %al
callq 0x50f0
cltq
movq %rax, 0x8(%rsp)
jmp 0xbd93
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x26a5(%rip), %rdx      # 0xe3be
movb $0x0, %al
callq 0x50f0
cltq
movq %rax, 0x8(%rsp)
jmp 0xbd93
callq 0x5420
movq (%rax), %rax
movsbl 0x17(%rsp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0xbd6d
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movsbl 0x17(%rsp), %ecx
leaq 0x2666(%rip), %rdx      # 0xe3c3
movb $0x0, %al
callq 0x50f0
cltq
movq %rax, 0x8(%rsp)
jmp 0xbd91
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movzbl 0x17(%rsp), %ecx
leaq 0x2645(%rip), %rdx      # 0xe3c8
movb $0x0, %al
callq 0x50f0
cltq
movq %rax, 0x8(%rsp)
jmp 0xbd93
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_redis.c
// Function: redis_response_reader_read_line
static char *redis_response_reader_read_line(redis_response_reader *reader, int32_t *len) {
  char *p, *s;
  int32_t real_len;

  p = reader->buf + reader->pos;
  s = redis_response_reader_seek_crlf(p, (reader->len - reader->pos));
  if (s != NULL) {
    real_len = s - (reader->buf + reader->pos);
    reader->pos += real_len + 2;
    if (len) {
      *len = real_len;
    }
    return p;
  }
  return NULL;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x28(%rsp), %rcx
addq 0xa0(%rcx), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0xa8(%rax), %rsi
movq 0x28(%rsp), %rax
subq 0xa0(%rax), %rsi
callq 0xc2b0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xbe5a
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x90(%rcx), %rcx
movq 0x28(%rsp), %rdx
addq 0xa0(%rdx), %rcx
subq %rcx, %rax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addl $0x2, %eax
movslq %eax, %rcx
movq 0x28(%rsp), %rax
addq 0xa0(%rax), %rcx
movq %rcx, 0xa0(%rax)
cmpq $0x0, 0x20(%rsp)
je 0xbe4e
movl 0xc(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xbe63
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_redis.c
// Function: redis_response_reader_create_integer
static void *redis_response_reader_create_integer(const redis_response_reader *reader, const redis_response_reader_task *task, long long value) {
  redis_response *resp, *parent;
  if ((resp = redis_response_reader_create_response(reader, REDIS_RESPONSE_INTEGER)) == NULL) {
    return NULL;
  }

  resp->payload.integer = value;
  if (task->parent) {
    parent = task->parent->obj;
    assert(parent->type == REDIS_RESPONSE_ARRAY);
    parent->payload.array.array[task->idx] = resp;
  }
  return resp;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0x3, %esi
callq 0xc380
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0xbea8
movq $0x0, 0x30(%rsp)
jmp 0xbf24
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0xbf1a
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x2, (%rax)
jne 0xbee0
jmp 0xbeff
leaq 0x24ea(%rip), %rdi      # 0xe3d1
leaq 0x2440(%rip), %rsi      # 0xe32e
movl $0xcb, %edx
leaq 0x24fc(%rip), %rcx      # 0xe3f6
callq 0x5100
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_redis.c
// Function: redis_response_reader_read_integer
static int64_t redis_response_reader_read_integer(char *buffer) {
  int64_t val = 0;
  int32_t digit, sign = 1;
  char ch;

  switch (*buffer) {
    case '-':
      sign = -1;
      /* FALL THROUGH */
    case '+':
      buffer++;
      /* FALL THROUGH */
    default:
      break;
  }

  while ((ch = *(buffer++)) != '\r') {
    digit = ch - '0';
    if (digit >= 0 && digit < 10) {
      val *= 10;
      val += digit;
    } else {
      return -1;
    }
  }

  return sign * val;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
movl $0x1, -0x20(%rsp)
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
movl %eax, -0x28(%rsp)
subl $0x2b, %eax
je 0xbf6c
jmp 0xbf59
movl -0x28(%rsp), %eax
subl $0x2d, %eax
jne 0xbf7a
jmp 0xbf64
movl $0xffffffff, -0x20(%rsp) # imm = 0xFFFFFFFF
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0xbf7c
jmp 0xbf7e
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movb (%rax), %al
movb %al, -0x21(%rsp)
movsbl %al, %eax
cmpl $0xd, %eax
je 0xbfe0
movsbl -0x21(%rsp), %eax
subl $0x30, %eax
movl %eax, -0x1c(%rsp)
cmpl $0x0, -0x1c(%rsp)
jl 0xbfd3
cmpl $0xa, -0x1c(%rsp)
jge 0xbfd3
imulq $0xa, -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movslq -0x1c(%rsp), %rax
addq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
jmp 0xbfde
movq $-0x1, -0x8(%rsp)
jmp 0xbff0
jmp 0xbf7e
movslq -0x20(%rsp), %rax
imulq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_redis.c
// Function: redis_response_reader_create_string
static void *redis_response_reader_create_string(const redis_response_reader *reader, const redis_response_reader_task *task, char *str, size_t len) {
  redis_response *resp, *parent;
  char *buf;
  if ((resp = redis_response_reader_create_response(reader, task->type)) == NULL) {
    return NULL;
  }
  if ((buf = allocator_malloc(reader->allocator, len + 1)) == NULL) {
    redis_response_reader_free_response(resp);
    return NULL;
  }

  assert(task->type == REDIS_RESPONSE_ERROR  ||
         task->type == REDIS_RESPONSE_STATUS ||
         task->type == REDIS_RESPONSE_STRING);

  memcpy(buf, str, len);
  buf[len] = '\0';
  resp->payload.string.str = buf;
  resp->payload.string.length = len;

  if (task->parent) {
    parent = task->parent->obj;
    assert(parent->type == REDIS_RESPONSE_ARRAY);
    parent->payload.array.array[task->idx] = resp;
  }
  return resp;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rax
movl (%rax), %esi
callq 0xc380
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
jne 0xc042
movq $0x0, 0x40(%rsp)
jmp 0xc16a
movq 0x38(%rsp), %rax
movq 0x88(%rax), %rdi
movq 0x20(%rsp), %rsi
addq $0x1, %rsi
callq 0x52d0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0xc07f
movq 0x18(%rsp), %rdi
callq 0x5260
movq $0x0, 0x40(%rsp)
jmp 0xc16a
movq 0x30(%rsp), %rax
cmpl $0x6, (%rax)
je 0xc09d
movq 0x30(%rsp), %rax
cmpl $0x5, (%rax)
je 0xc09d
movq 0x30(%rsp), %rax
cmpl $0x1, (%rax)
jne 0xc09f
jmp 0xc0be
leaq 0x23c9(%rip), %rdi      # 0xe46f
leaq 0x2281(%rip), %rsi      # 0xe32e
movl $0x9c, %edx
leaq 0x2427(%rip), %rcx      # 0xe4e0
callq 0x5100
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x5220
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x30(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0xc160
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x2, (%rax)
jne 0xc126
jmp 0xc145
leaq 0x22a4(%rip), %rdi      # 0xe3d1
leaq 0x21fa(%rip), %rsi      # 0xe32e
movl $0xa5, %edx
leaq 0x23a0(%rip), %rcx      # 0xe4e0
callq 0x5100
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x30(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
movq %rax, 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_redis.c
// Function: redis_response_reader_next_task
static void redis_response_reader_next_task(redis_response_reader *reader) {
  redis_response_reader_task *cur, *prv;
  while (reader->task_idx >= 0) {
    if (reader->task_idx == 0) {
      reader->task_idx--;
      return;
    }

    cur = reader->tasks + reader->task_idx;
    prv = cur - 1;
    assert(prv->type == REDIS_RESPONSE_ARRAY);
    if (cur->idx == prv->elements - 1) {
      reader->task_idx--;
    } else {
      assert(cur->idx < prv->elements);
      cur->type = -1;
      cur->elements = -1;
      cur->idx++;
      return;
    }
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x1d8(%rax)
jl 0xc2a6
movq 0x10(%rsp), %rax
cmpl $0x0, 0x1d8(%rax)
jne 0xc1c2
movq 0x10(%rsp), %rax
movl 0x1d8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x1d8(%rax)
jmp 0xc2a6
movq 0x10(%rsp), %rax
addq $0xb8, %rax
movq 0x10(%rsp), %rcx
movslq 0x1d8(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $-0x20, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x2, (%rax)
jne 0xc1fd
jmp 0xc21c
leaq 0x2359(%rip), %rdi      # 0xe55d
leaq 0x2123(%rip), %rsi      # 0xe32e
movl $0x1a6, %edx            # imm = 0x1A6
leaq 0x2368(%rip), %rcx      # 0xe57f
callq 0x5100
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
movq (%rsp), %rcx
movl 0x4(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0xc248
movq 0x10(%rsp), %rax
movl 0x1d8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x1d8(%rax)
jmp 0xc2a1
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
movq (%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0xc25b
jmp 0xc27a
leaq 0x235b(%rip), %rdi      # 0xe5bd
leaq 0x20c5(%rip), %rsi      # 0xe32e
movl $0x1aa, %edx            # imm = 0x1AA
leaq 0x230a(%rip), %rcx      # 0xe57f
callq 0x5100
movq 0x8(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq 0x8(%rsp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0xc2a6
jmp 0xc189
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_redis.c
// Function: redis_response_reader_seek_crlf
static char *redis_response_reader_seek_crlf(char *buffer, size_t len) {
  int32_t rd = 0;
  int32_t scanlen = len - 1;

  while (rd < scanlen) {
    while (rd < scanlen && buffer[rd] != '\r') rd++;
    if (rd == scanlen) {
      return NULL;
    } else {
      if (buffer[rd + 1] == '\n') {
        return buffer + rd;
      } else {
        rd++;
      }
    }
  }
  return NULL;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movq -0x18(%rsp), %rax
subq $0x1, %rax
movl %eax, -0x20(%rsp)
movl -0x1c(%rsp), %eax
cmpl -0x20(%rsp), %eax
jge 0xc371
jmp 0xc2df
movl -0x1c(%rsp), %ecx
xorl %eax, %eax
cmpl -0x20(%rsp), %ecx
movb %al, -0x21(%rsp)
jge 0xc307
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
setne %al
movb %al, -0x21(%rsp)
movb -0x21(%rsp), %al
testb $0x1, %al
jne 0xc311
jmp 0xc31e
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0xc2df
movl -0x1c(%rsp), %eax
cmpl -0x20(%rsp), %eax
jne 0xc333
movq $0x0, -0x8(%rsp)
jmp 0xc37a
movq -0x10(%rsp), %rax
movl -0x1c(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0xc35f
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
jmp 0xc37a
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0xc36c
jmp 0xc2cf
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
// File: /workspace/github_c_makefile_star2_O0/redis-force[P]rpm/module/rpm_redis.c
// Function: redis_response_reader_create_response
static redis_response *redis_response_reader_create_response(const redis_response_reader *reader, int type) {
  redis_response *resp;
  if ((resp = allocator_calloc(reader->allocator, sizeof(*resp))) == NULL) {
    return NULL;
  }

  resp->type = type;
  resp->allocator = reader->allocator;
  return resp;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq 0x88(%rax), %rdi
movl $0x20, %esi
callq 0x52a0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0xc3b9
movq $0x0, 0x20(%rsp)
jmp 0xc3e3
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movq 0x88(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%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_redis.c
// Function: redis_response_reader_create_nil
static void *redis_response_reader_create_nil(const redis_response_reader *reader, const redis_response_reader_task *task) {
  redis_response *resp, *parent;

  if ((resp = redis_response_reader_create_response(reader, REDIS_RESPONSE_NIL)) == NULL) {
    return NULL;
  }

  if (task->parent) {
    parent = task->parent->obj;
    assert(parent->type == REDIS_RESPONSE_ARRAY);
    parent->payload.array.array[task->idx] = resp;
  }
  return resp;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x4, %esi
callq 0xc380
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0xc423
movq $0x0, 0x20(%rsp)
jmp 0xc48e
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0xc484
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x2, (%rax)
jne 0xc44b
jmp 0xc46a
leaq 0x1f7f(%rip), %rdi      # 0xe3d1
leaq 0x1ed5(%rip), %rsi      # 0xe32e
movl $0xda, %edx
leaq 0x2171(%rip), %rcx      # 0xe5d6
callq 0x5100
movq 0x8(%rsp), %rdx
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)