LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/bit_reader_utils.c
// Function: VP8LReadBits
uint32_t VP8LReadBits(VP8LBitReader* const br, int n_bits) {
  assert(n_bits >= 0);
  // Flag an error if end_of_stream or n_bits is more than allowed limit.
  if (!br->eos_ && n_bits <= VP8L_MAX_NUM_BIT_READ) {
    const uint32_t val = VP8LPrefetchBits(br) & kBitMask[n_bits];
    const int new_bits = br->bit_pos_ + n_bits;
    br->bit_pos_ = new_bits;
    ShiftBytes(br);
    return val;
  } else {
    VP8LSetEndOfStream(br);
    return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x1824c7
jmp 0x1824e6
leaq 0x3ee78(%rip), %rdi     # 0x1c1346
leaq 0x3ecc1(%rip), %rsi     # 0x1c1196
movl $0xd2, %edx
leaq 0x3ee71(%rip), %rcx     # 0x1c1352
callq 0x598a0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x24(%rax)
jne 0x182538
cmpl $0x18, -0x14(%rbp)
jg 0x182538
movq -0x10(%rbp), %rdi
callq 0x182560
movslq -0x14(%rbp), %rdx
leaq 0x3ef86(%rip), %rcx     # 0x1c1490
andl (%rcx,%rdx,4), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x182400
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x182548
movq -0x10(%rbp), %rdi
callq 0x182580
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/color_cache_utils.c
// Function: VP8LColorCacheInit
int VP8LColorCacheInit(VP8LColorCache* const color_cache, int hash_bits) {
  const int hash_size = 1 << hash_bits;
  assert(color_cache != NULL);
  assert(hash_bits > 0);
  color_cache->colors_ = (uint32_t*)WebPSafeCalloc(
      (uint64_t)hash_size, sizeof(*color_cache->colors_));
  if (color_cache->colors_ == NULL) return 0;
  color_cache->hash_shift_ = 32 - hash_bits;
  color_cache->hash_bits_ = hash_bits;
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x182605
jmp 0x182624
leaq 0x3b68c(%rip), %rdi     # 0x1bdc98
leaq 0x3eee1(%rip), %rsi     # 0x1c14f4
movl $0x19, %edx
leaq 0x3eef3(%rip), %rcx     # 0x1c1512
callq 0x598a0
cmpl $0x0, -0x14(%rbp)
jle 0x18262c
jmp 0x18264b
leaq 0x3ef12(%rip), %rdi     # 0x1c1545
leaq 0x3eeba(%rip), %rsi     # 0x1c14f4
movl $0x1a, %edx
leaq 0x3eecc(%rip), %rcx     # 0x1c1512
callq 0x598a0
movslq -0x18(%rbp), %rdi
movl $0x4, %esi
callq 0x5a9f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x182676
movl $0x0, -0x4(%rbp)
jmp 0x182696
movl $0x20, %ecx
subl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/color_cache_utils.c
// Function: VP8LColorCacheCopy
void VP8LColorCacheCopy(const VP8LColorCache* const src,
                        VP8LColorCache* const dst) {
  assert(src != NULL);
  assert(dst != NULL);
  assert(src->hash_bits_ == dst->hash_bits_);
  memcpy(dst->colors_, src->colors_,
         ((size_t)1u << dst->hash_bits_) * sizeof(*dst->colors_));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1826e9
jmp 0x182708
leaq 0x3ee63(%rip), %rdi     # 0x1c1553
leaq 0x3edfd(%rip), %rsi     # 0x1c14f4
movl $0x2c, %edx
leaq 0x3ee5c(%rip), %rcx     # 0x1c155f
callq 0x598a0
cmpq $0x0, -0x10(%rbp)
je 0x182711
jmp 0x182730
leaq 0x3a101(%rip), %rdi     # 0x1bc819
leaq 0x3edd5(%rip), %rsi     # 0x1c14f4
movl $0x2d, %edx
leaq 0x3ee34(%rip), %rcx     # 0x1c155f
callq 0x598a0
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x182742
jmp 0x182761
leaq 0x3ee62(%rip), %rdi     # 0x1c15ab
leaq 0x3eda4(%rip), %rsi     # 0x1c14f4
movl $0x2e, %edx
leaq 0x3ee03(%rip), %rcx     # 0x1c155f
callq 0x598a0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %ecx
movl $0x1, %edx
shlq %cl, %rdx
shlq $0x2, %rdx
callq 0x593a0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/huffman_utils.c
// Function: VP8LHtreeGroupsNew
HTreeGroup* VP8LHtreeGroupsNew(int num_htree_groups) {
  HTreeGroup* const htree_groups =
      (HTreeGroup*)WebPSafeMalloc(num_htree_groups, sizeof(*htree_groups));
  if (htree_groups == NULL) {
    return NULL;
  }
  assert(num_htree_groups <= MAX_HTREE_GROUPS);
  return htree_groups;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
movl $0x238, %esi            # imm = 0x238
callq 0x5b060
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1827be
movq $0x0, -0x8(%rbp)
jmp 0x1827f0
cmpl $0x10000, -0xc(%rbp)    # imm = 0x10000
jg 0x1827c9
jmp 0x1827e8
leaq 0x3edfe(%rip), %rdi     # 0x1c15ce
leaq 0x3ee1c(%rip), %rsi     # 0x1c15f3
movl $0x1f, %edx
leaq 0x3ee2a(%rip), %rcx     # 0x1c160d
callq 0x598a0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/huffman_utils.c
// Function: VP8LHuffmanTablesAllocate
int VP8LHuffmanTablesAllocate(int size, HuffmanTables* huffman_tables) {
  // Have 'segment' point to the first segment for now, 'root'.
  HuffmanTablesSegment* const root = &huffman_tables->root;
  huffman_tables->curr_segment = root;
  root->next = NULL;
  // Allocate root.
  root->start = (HuffmanCode*)WebPSafeMalloc(size, sizeof(*root->start));
  if (root->start == NULL) return 0;
  root->curr_table = root->start;
  root->size = size;
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movslq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x5b060
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x18311a
movl $0x0, -0x4(%rbp)
jmp 0x18313a
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/huffman_utils.c
// Function: VP8LHuffmanTablesDeallocate
void VP8LHuffmanTablesDeallocate(HuffmanTables* const huffman_tables) {
  HuffmanTablesSegment *current, *next;
  if (huffman_tables == NULL) return;
  // Free the root node.
  current = &huffman_tables->root;
  next = current->next;
  WebPSafeFree(current->start);
  current->start = NULL;
  current->next = NULL;
  current = next;
  // Free the following nodes.
  while (current != NULL) {
    next = current->next;
    WebPSafeFree(current->start);
    WebPSafeFree(current);
    current = next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x183165
jmp 0x1831d6
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5b920
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1831d6
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5b920
movq -0x10(%rbp), %rdi
callq 0x5b920
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x1831a4
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/huffman_utils.c
// Function: ReplicateValue
static WEBP_INLINE void ReplicateValue(HuffmanCode* table,
                                       int step, int end,
                                       HuffmanCode code) {
  assert(end % step == 0);
  do {
    end -= step;
    table[end] = code;
  } while (end > 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %ecx, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x18(%rbp), %eax
cltd
idivl -0x14(%rbp)
cmpl $0x0, %edx
jne 0x183203
jmp 0x183222
leaq 0x3e571(%rip), %rdi     # 0x1c177b
leaq 0x3e3e2(%rip), %rsi     # 0x1c15f3
movl $0x38, %edx
leaq 0x3e56e(%rip), %rcx     # 0x1c178b
callq 0x598a0
jmp 0x183224
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl -0x4(%rbp), %edx
movl %edx, (%rax,%rcx,4)
cmpl $0x0, -0x18(%rbp)
jg 0x183224
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/huffman_utils.c
// Function: GetNextKey
static WEBP_INLINE uint32_t GetNextKey(uint32_t key, int len) {
  uint32_t step = 1 << (len - 1);
  while (key & step) {
    step >>= 1;
  }
  return step ? (key & (step - 1)) + step : key;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
andl -0xc(%rbp), %eax
cmpl $0x0, %eax
je 0x18327f
movl -0xc(%rbp), %eax
shrl %eax
movl %eax, -0xc(%rbp)
jmp 0x18326a
cmpl $0x0, -0xc(%rbp)
je 0x183298
movl -0x4(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
addl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x18329e
movl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/huffman_utils.c
// Function: NextTableBitSize
static WEBP_INLINE int NextTableBitSize(const int* const count,
                                        int len, int root_bits) {
  int left = 1 << (len - root_bits);
  while (len < MAX_ALLOWED_CODE_LENGTH) {
    left -= count[len];
    if (left <= 0) break;
    ++len;
    left <<= 1;
  }
  return len - root_bits;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %ecx
subl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x14(%rbp)
cmpl $0xf, -0xc(%rbp)
jge 0x183302
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x1832ef
jmp 0x183302
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x14(%rbp), %eax
shll %eax
movl %eax, -0x14(%rbp)
jmp 0x1832ce
movl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/palette.c
// Function: SearchColorNoIdx
int SearchColorNoIdx(const uint32_t sorted[], uint32_t color, int num_colors) {
  int low = 0, hi = num_colors;
  if (sorted[low] == color) return low;  // loop invariant: sorted[low] != color
  while (1) {
    const int mid = (low + hi) >> 1;
    if (sorted[mid] == color) {
      return mid;
    } else if (sorted[mid] < color) {
      low = mid;
    } else {
      hi = mid;
    }
  }
  assert(0);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jne 0x183343
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x18338a
jmp 0x183345
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
sarl %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jne 0x183368
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x18338a
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jae 0x183380
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x183386
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x183388
jmp 0x183345
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/palette.c
// Function: PrepareMapToPalette
void PrepareMapToPalette(const uint32_t palette[], uint32_t num_colors,
                         uint32_t sorted[], uint32_t idx_map[]) {
  uint32_t i;
  memcpy(sorted, palette, num_colors * sizeof(*sorted));
  qsort(sorted, num_colors, sizeof(*sorted), PaletteCompareColorsForQsort);
  for (i = 0; i < num_colors; ++i) {
    idx_map[SearchColorNoIdx(sorted, palette[i], num_colors)] = i;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %eax
movl %eax, %edx
shlq $0x2, %rdx
callq 0x593a0
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
movl $0x4, %edx
leaq 0x5e(%rip), %rcx        # 0x183430
callq 0x5bcb0
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x183424
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movl (%rax,%rcx,4), %esi
movl -0xc(%rbp), %edx
callq 0x183310
movl -0x34(%rbp), %edx
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1833de
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/palette.c
// Function: PaletteCompareColorsForQsort
static int PaletteCompareColorsForQsort(const void* p1, const void* p2) {
  const uint32_t a = WebPMemToUint32((uint8_t*)p1);
  const uint32_t b = WebPMemToUint32((uint8_t*)p2);
  assert(a != b);
  return (a < b) ? -1 : 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x183d90
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x183d90
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
je 0x183462
jmp 0x183481
leaq 0x3e453(%rip), %rdi     # 0x1c18bc
leaq 0x3e378(%rip), %rsi     # 0x1c17e8
movl $0x20, %edx
leaq 0x3e447(%rip), %rcx     # 0x1c18c3
callq 0x598a0
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %esi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl %esi, %edx
cmovbl %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/palette.c
// Function: PaletteSort
int PaletteSort(PaletteSorting method, const struct WebPPicture* const pic,
                const uint32_t* const palette_sorted, uint32_t num_colors,
                uint32_t* const palette) {
  switch (method) {
    case kSortedDefault:
      // Nothing to do, we have already sorted the palette.
      memcpy(palette, palette_sorted, num_colors * sizeof(*palette));
      return 1;
    case kMinimizeDelta:
      PaletteSortMinimizeDeltas(palette_sorted, num_colors, palette);
      return 1;
    case kModifiedZeng:
      return PaletteSortModifiedZeng(pic, palette_sorted, num_colors, palette);
    case kUnusedPalette:
    case kPaletteSortingNum:
      break;
  }

  assert(0);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x4, %rax
ja 0x1837ee
movq -0x30(%rbp), %rax
leaq 0x3e036(%rip), %rcx     # 0x1c17c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
shlq $0x2, %rdx
callq 0x593a0
movl $0x1, -0x4(%rbp)
jmp 0x18380d
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x183820
movl $0x1, -0x4(%rbp)
jmp 0x18380d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0x183910
movl %eax, -0x4(%rbp)
jmp 0x18380d
jmp 0x1837ee
leaq 0x3c7cb(%rip), %rdi     # 0x1bffc0
leaq 0x3dfec(%rip), %rsi     # 0x1c17e8
movl $0x190, %edx            # imm = 0x190
leaq 0x3e041(%rip), %rcx     # 0x1c1849
callq 0x598a0
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/palette.c
// Function: PaletteSortMinimizeDeltas
static void PaletteSortMinimizeDeltas(const uint32_t* const palette_sorted,
                                      int num_colors, uint32_t* const palette) {
  uint32_t predict = 0x00000000;
  int i, k;
  memcpy(palette, palette_sorted, num_colors * sizeof(*palette));
  if (!PaletteHasNonMonotonousDeltas(palette_sorted, num_colors)) return;
  // Find greedily always the closest color of the predicted color to minimize
  // deltas in the palette. This reduces storage needs since the
  // palette is stored with delta encoding.
  for (i = 0; i < num_colors; ++i) {
    int best_ix = i;
    uint32_t best_score = ~0U;
    for (k = i; k < num_colors; ++k) {
      const uint32_t cur_score = PaletteColorDistance(palette[k], predict);
      if (best_score > cur_score) {
        best_score = cur_score;
        best_ix = k;
      }
    }
    SwapColor(&palette[best_ix], &palette[i]);
    predict = palette[i];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rdx
shlq $0x2, %rdx
callq 0x593a0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x183db0
cmpl $0x0, %eax
jne 0x183865
jmp 0x183909
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x183909
movl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1838ca
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movl -0x1c(%rbp), %esi
callq 0x183ee0
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jbe 0x1838bd
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x1838bf
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x18388b
movq -0x18(%rbp), %rdi
movslq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movslq -0x20(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x183f70
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x18386c
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/palette.c
// Function: PaletteHasNonMonotonousDeltas
static int PaletteHasNonMonotonousDeltas(const uint32_t* const palette,
                                         int num_colors) {
  uint32_t predict = 0x000000;
  int i;
  uint8_t sign_found = 0x00;
  for (i = 0; i < num_colors; ++i) {
    const uint32_t diff = VP8LSubPixels(palette[i], predict);
    const uint8_t rd = (diff >> 16) & 0xff;
    const uint8_t gd = (diff >> 8) & 0xff;
    const uint8_t bd = (diff >> 0) & 0xff;
    if (rd != 0x00) {
      sign_found |= (rd < 0x80) ? 1 : 2;
    }
    if (gd != 0x00) {
      sign_found |= (gd < 0x80) ? 8 : 16;
    }
    if (bd != 0x00) {
      sign_found |= (bd < 0x80) ? 64 : 128;
    }
    predict = palette[i];
  }
  return (sign_found & (sign_found << 1)) != 0;  // two consequent signs.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movb $0x0, -0x15(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x183eb4
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movl -0x10(%rbp), %esi
callq 0x183fa0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, -0x1d(%rbp)
movl -0x1c(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, -0x1e(%rbp)
movl -0x1c(%rbp), %eax
shrl $0x0, %eax
andl $0xff, %eax
movb %al, -0x1f(%rbp)
movzbl -0x1d(%rbp), %eax
cmpl $0x0, %eax
je 0x183e46
movzbl -0x1d(%rbp), %edx
movl $0x2, %ecx
movl $0x1, %eax
cmpl $0x80, %edx
cmovll %eax, %ecx
movzbl -0x15(%rbp), %eax
orl %ecx, %eax
movb %al, -0x15(%rbp)
movzbl -0x1e(%rbp), %eax
cmpl $0x0, %eax
je 0x183e6f
movzbl -0x1e(%rbp), %edx
movl $0x10, %ecx
movl $0x8, %eax
cmpl $0x80, %edx
cmovll %eax, %ecx
movzbl -0x15(%rbp), %eax
orl %ecx, %eax
movb %al, -0x15(%rbp)
movzbl -0x1f(%rbp), %eax
cmpl $0x0, %eax
je 0x183e98
movzbl -0x1f(%rbp), %edx
movl $0x80, %ecx
movl $0x40, %eax
cmpl $0x80, %edx
cmovll %eax, %ecx
movzbl -0x15(%rbp), %eax
orl %ecx, %eax
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x183dd1
movzbl -0x15(%rbp), %eax
movzbl -0x15(%rbp), %ecx
shll %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/palette.c
// Function: PaletteColorDistance
static WEBP_INLINE uint32_t PaletteColorDistance(uint32_t col1, uint32_t col2) {
  const uint32_t diff = VP8LSubPixels(col1, col2);
  const int kMoreWeightForRGBThanForAlpha = 9;
  uint32_t score;
  score = PaletteComponentDistance((diff >> 0) & 0xff);
  score += PaletteComponentDistance((diff >> 8) & 0xff);
  score += PaletteComponentDistance((diff >> 16) & 0xff);
  score *= kMoreWeightForRGBThanForAlpha;
  score += PaletteComponentDistance((diff >> 24) & 0xff);
  return score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x183fa0
movl %eax, -0xc(%rbp)
movl $0x9, -0x10(%rbp)
movl -0xc(%rbp), %edi
shrl $0x0, %edi
andl $0xff, %edi
callq 0x184000
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %edi
shrl $0x8, %edi
andl $0xff, %edi
callq 0x184000
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %edi
shrl $0x10, %edi
andl $0xff, %edi
callq 0x184000
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
imull $0x9, -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %edi
shrl $0x18, %edi
andl $0xff, %edi
callq 0x184000
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless_common.h
// Function: VP8LSubPixels
static WEBP_UBSAN_IGNORE_UNSIGNED_OVERFLOW WEBP_INLINE
uint32_t VP8LSubPixels(uint32_t a, uint32_t b) {
  const uint32_t alpha_and_green =
      0x00ff00ffu + (a & 0xff00ff00u) - (b & 0xff00ff00u);
  const uint32_t red_and_blue =
      0xff00ff00u + (a & 0x00ff00ffu) - (b & 0x00ff00ffu);
  return (alpha_and_green & 0xff00ff00u) | (red_and_blue & 0x00ff00ffu);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0xff00ff00, %eax       # imm = 0xFF00FF00
addl $0xff00ff, %eax         # imm = 0xFF00FF
movl -0x8(%rbp), %ecx
andl $0xff00ff00, %ecx       # imm = 0xFF00FF00
subl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
andl $0xff00ff, %eax         # imm = 0xFF00FF
addl $0xff00ff00, %eax       # imm = 0xFF00FF00
movl -0x8(%rbp), %ecx
andl $0xff00ff, %ecx         # imm = 0xFF00FF
subl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
andl $0xff00ff00, %eax       # imm = 0xFF00FF00
movl -0x10(%rbp), %ecx
andl $0xff00ff, %ecx         # imm = 0xFF00FF
orl %ecx, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/palette.c
// Function: CoOccurrenceFindMax
static void CoOccurrenceFindMax(const uint32_t* const cooccurrence,
                                uint32_t num_colors, uint8_t* const c1,
                                uint8_t* const c2) {
  // Find the index that is most frequently located adjacent to other
  // (different) indexes.
  uint32_t best_sum = 0u;
  uint32_t i, j, best_cooccurrence;
  *c1 = 0u;
  for (i = 0; i < num_colors; ++i) {
    uint32_t sum = 0;
    for (j = 0; j < num_colors; ++j) sum += cooccurrence[i * num_colors + j];
    if (sum > best_sum) {
      best_sum = sum;
      *c1 = i;
    }
  }
  // Find the index that is most frequently found adjacent to *c1.
  *c2 = 0u;
  best_cooccurrence = 0u;
  for (i = 0; i < num_colors; ++i) {
    if (cooccurrence[*c1 * num_colors + i] > best_cooccurrence) {
      best_cooccurrence = cooccurrence[*c1 * num_colors + i];
      *c2 = i;
    }
  }
  assert(*c1 != *c2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x184334
movl $0x0, -0x34(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x18430e
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
imull -0xc(%rbp), %ecx
addl -0x2c(%rbp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1842e2
movl -0x34(%rbp), %eax
cmpl -0x24(%rbp), %eax
jbe 0x184327
movl -0x34(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
jmp 0x184329
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1842cc
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x18439f
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
imull -0xc(%rbp), %ecx
addl -0x28(%rbp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
cmpl -0x30(%rbp), %eax
jbe 0x184392
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
imull -0xc(%rbp), %ecx
addl -0x28(%rbp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x30(%rbp)
movl -0x28(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
jmp 0x184394
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x184349
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movq -0x20(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x1843b3
jmp 0x1843d2
leaq 0x3d5cf(%rip), %rdi     # 0x1c1989
leaq 0x3d427(%rip), %rsi     # 0x1c17e8
movl $0xf0, %edx
leaq 0x3d5c7(%rip), %rcx     # 0x1c1994
callq 0x598a0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/random_utils.c
// Function: VP8InitRandom
void VP8InitRandom(VP8Random* const rg, float dithering) {
  memcpy(rg->tab_, kRandomTable, sizeof(rg->tab_));
  rg->index1_ = 0;
  rg->index2_ = 31;
  rg->amp_ = (dithering < 0.0) ? 0
           : (dithering > 1.0) ? (1 << VP8_RANDOM_DITHER_FIX)
           : (uint32_t)((1 << VP8_RANDOM_DITHER_FIX) * dithering);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
leaq 0x3d600(%rip), %rsi     # 0x1c1a00
movl $0xdc, %edx
callq 0x593a0
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x1f, 0x4(%rax)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x184438
xorl %eax, %eax
movl %eax, -0x10(%rbp)
jmp 0x184478
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x2f1f(%rip), %xmm1     # 0x187368
ucomisd %xmm1, %xmm0
jbe 0x184459
movl $0x100, %eax            # imm = 0x100
movl %eax, -0x14(%rbp)
jmp 0x184472
movss -0xc(%rbp), %xmm0
movss 0x3d58a(%rip), %xmm1    # 0x1c19f0
mulss %xmm1, %xmm0
cvttss2si %xmm0, %rax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xe4(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/thread_utils.c
// Function: WebPSetWorkerInterface
int WebPSetWorkerInterface(const WebPWorkerInterface* const winterface) {
  if (winterface == NULL ||
      winterface->Init == NULL || winterface->Reset == NULL ||
      winterface->Sync == NULL || winterface->Launch == NULL ||
      winterface->Execute == NULL || winterface->End == NULL) {
    return 0;
  }
  g_worker_interface = *winterface;
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1844e4
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1844e4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1844e4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1844e4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1844e4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1844e4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x1844ed
movl $0x0, -0x4(%rbp)
jmp 0x184509
movq -0x10(%rbp), %rsi
leaq 0x87848(%rip), %rdi     # 0x20bd40
movl $0x30, %edx
callq 0x593a0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/thread_utils.c
// Function: End
static void End(WebPWorker* const worker) {
#ifdef WEBP_USE_THREAD
  if (worker->impl_ != NULL) {
    WebPWorkerImpl* const impl = (WebPWorkerImpl*)worker->impl_;
    ChangeState(worker, NOT_OK);
    pthread_join(impl->thread_, NULL);
    pthread_mutex_destroy(&impl->mutex_);
    pthread_cond_destroy(&impl->condition_);
    WebPSafeFree(impl);
    worker->impl_ = NULL;
  }
#else
  worker->status_ = NOT_OK;
  assert(worker->impl_ == NULL);
#endif
  assert(worker->status_ == NOT_OK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1846d3
jmp 0x1846f2
leaq 0x3d489(%rip), %rdi     # 0x1c1b63
leaq 0x3d41a(%rip), %rsi     # 0x1c1afb
movl $0x157, %edx            # imm = 0x157
leaq 0x3d48c(%rip), %rcx     # 0x1c1b79
callq 0x598a0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x1846fe
jmp 0x18471d
leaq 0x3d490(%rip), %rdi     # 0x1c1b95
leaq 0x3d3ef(%rip), %rsi     # 0x1c1afb
movl $0x159, %edx            # imm = 0x159
leaq 0x3d461(%rip), %rcx     # 0x1c1b79
callq 0x598a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/alpha_dec.c
// Function: WebPDeallocateAlphaMemory
void WebPDeallocateAlphaMemory(VP8Decoder* const dec) {
  assert(dec != NULL);
  WebPSafeFree(dec->alpha_plane_mem_);
  dec->alpha_plane_mem_ = NULL;
  dec->alpha_plane_ = NULL;
  ALPHDelete(dec->alph_dec_);
  dec->alph_dec_ = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x184745
jmp 0x184764
leaq 0x38d91(%rip), %rdi     # 0x1bd4dd
leaq 0x3d45c(%rip), %rsi     # 0x1c1baf
movl $0xa4, %edx
leaq 0x3d464(%rip), %rcx     # 0x1c1bc3
callq 0x598a0
movq -0x8(%rbp), %rax
movq 0xbb0(%rax), %rdi
callq 0x5b920
movq -0x8(%rbp), %rax
movq $0x0, 0xbb0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xbb8(%rax)
movq -0x8(%rbp), %rax
movq 0xb90(%rax), %rdi
callq 0x1847c0
movq -0x8(%rbp), %rax
movq $0x0, 0xb90(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/alpha_dec.c
// Function: ALPHDelete
static void ALPHDelete(ALPHDecoder* const dec) {
  if (dec != NULL) {
    VP8LDelete(dec->vp8l_dec_);
    dec->vp8l_dec_ = NULL;
    WebPSafeFree(dec);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1847f5
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x145130
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0x5b920
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/alpha_dec.c
// Function: AllocateAlphaPlane
WEBP_NODISCARD static int AllocateAlphaPlane(VP8Decoder* const dec,
                                             const VP8Io* const io) {
  const int stride = io->width;
  const int height = io->crop_bottom;
  const uint64_t alpha_size = (uint64_t)stride * height;
  assert(dec->alpha_plane_mem_ == NULL);
  dec->alpha_plane_mem_ =
      (uint8_t*)WebPSafeMalloc(alpha_size, sizeof(*dec->alpha_plane_));
  if (dec->alpha_plane_mem_ == NULL) {
    return VP8SetError(dec, VP8_STATUS_OUT_OF_MEMORY,
                       "Alpha decoder initialization failed.");
  }
  dec->alpha_plane_ = dec->alpha_plane_mem_;
  dec->alpha_prev_line_ = NULL;
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x84(%rax), %eax
movl %eax, -0x20(%rbp)
movslq -0x1c(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xbb0(%rax)
jne 0x184b86
jmp 0x184ba5
leaq 0x3d115(%rip), %rdi     # 0x1c1ca2
leaq 0x3d01b(%rip), %rsi     # 0x1c1baf
movl $0x97, %edx
leaq 0x3d120(%rip), %rcx     # 0x1c1cc0
callq 0x598a0
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x5b060
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xbb0(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xbb0(%rax)
jne 0x184be9
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x3d087(%rip), %rdx     # 0x1c1c66
callq 0x142580
movl %eax, -0x4(%rbp)
jmp 0x184c15
movq -0x10(%rbp), %rax
movq 0xbb0(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xbb8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xbc0(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/tree_dec.c
// Function: VP8ParseIntraModeRow
int VP8ParseIntraModeRow(VP8BitReader* const br, VP8Decoder* const dec) {
  int mb_x;
  for (mb_x = 0; mb_x < dec->mb_w_; ++mb_x) {
    ParseIntraMode(br, dec, mb_x);
  }
  return !dec->br_.eof_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x198(%rcx), %eax
jge 0x1854a1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x1854c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x185477
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/quant_levels_dec_utils.c
// Function: WebPDequantizeLevels
int WebPDequantizeLevels(uint8_t* const data, int width, int height, int stride,
                         int strength) {
  int radius = 4 * strength / 100;

  if (strength < 0 || strength > 100) return 0;
  if (data == NULL || width <= 0 || height <= 0) return 0;  // bad params

  // limit the filter size to not exceed the image dimensions
  if (2 * radius + 1 > width) radius = (width - 1) >> 1;
  if (2 * radius + 1 > height) radius = (height - 1) >> 1;

  if (radius > 0) {
    SmoothParams p;
    memset(&p, 0, sizeof(p));
    if (!InitParams(data, width, height, stride, radius, &p)) return 0;
    if (p.num_levels_ > 2) {
      for (; p.row_ < p.height_; ++p.row_) {
        VFilter(&p);  // accumulate average of input
        // Need to wait few rows in order to prime the filter,
        // before emitting some output.
        if (p.row_ >= p.radius_) {
          HFilter(&p);
          ApplyFilter(&p);
        }
      }
    }
    CleanupParams(&p);
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl -0x20(%rbp), %eax
shll $0x2, %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x185c69
cmpl $0x64, -0x20(%rbp)
jle 0x185c75
movl $0x0, -0x4(%rbp)
jmp 0x185d79
cmpq $0x0, -0x10(%rbp)
je 0x185c88
cmpl $0x0, -0x14(%rbp)
jle 0x185c88
cmpl $0x0, -0x18(%rbp)
jg 0x185c94
movl $0x0, -0x4(%rbp)
jmp 0x185d79
movl -0x24(%rbp), %eax
shll %eax
addl $0x1, %eax
cmpl -0x14(%rbp), %eax
jle 0x185cac
movl -0x14(%rbp), %eax
subl $0x1, %eax
sarl %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
shll %eax
addl $0x1, %eax
cmpl -0x18(%rbp), %eax
jle 0x185cc4
movl -0x18(%rbp), %eax
subl $0x1, %eax
sarl %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x185d72
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
movl $0x70, %edx
callq 0x5a200
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x24(%rbp), %r8d
leaq -0x98(%rbp), %r9
callq 0x185d90
cmpl $0x0, %eax
jne 0x185d0c
movl $0x0, -0x4(%rbp)
jmp 0x185d79
cmpl $0x2, -0x40(%rbp)
jle 0x185d66
jmp 0x185d14
movl -0x8c(%rbp), %eax
cmpl -0x94(%rbp), %eax
jge 0x185d64
leaq -0x98(%rbp), %rdi
callq 0x185f60
movl -0x8c(%rbp), %eax
cmpl -0x78(%rbp), %eax
jl 0x185d51
leaq -0x98(%rbp), %rdi
callq 0x1860b0
leaq -0x98(%rbp), %rdi
callq 0x186230
jmp 0x185d53
movl -0x8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
jmp 0x185d14
jmp 0x185d66
leaq -0x98(%rbp), %rdi
callq 0x186310
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/quant_levels_dec_utils.c
// Function: VFilter
static void VFilter(SmoothParams* const p) {
  const uint8_t* src = p->src_;
  const int w = p->width_;
  uint16_t* const cur = p->cur_;
  const uint16_t* const top = p->top_;
  uint16_t* const out = p->end_;
  uint16_t sum = 0;               // all arithmetic is modulo 16bit
  int x;

  for (x = 0; x < w; ++x) {
    uint16_t new_value;
    sum += src[x];
    new_value = top[x] + sum;
    out[x] = new_value - cur[x];  // vertical sum of 'r' pixels.
    cur[x] = new_value;
  }
  // move input pointers one row down
  p->top_ = p->cur_;
  p->cur_ += w;
  if (p->cur_ == p->end_) p->cur_ = p->start_;  // roll-over
  // We replicate edges, as it's somewhat easier as a boundary condition.
  // That's why we don't update the 'src' pointer on top/bottom area:
  if (p->row_ >= 0 && p->row_ < p->height_ - 1) {
    p->src_ += p->stride_;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x30(%rbp)
movw $0x0, -0x32(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x18601e
movq -0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movzwl -0x32(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x32(%rbp)
movq -0x28(%rbp), %rax
movslq -0x38(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movzwl -0x32(%rbp), %ecx
addl %ecx, %eax
movw %ax, -0x3a(%rbp)
movzwl -0x3a(%rbp), %eax
movq -0x20(%rbp), %rcx
movslq -0x38(%rbp), %rdx
movzwl (%rcx,%rdx,2), %ecx
subl %ecx, %eax
movw %ax, %dx
movq -0x30(%rbp), %rax
movslq -0x38(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movw -0x3a(%rbp), %dx
movq -0x20(%rbp), %rax
movslq -0x38(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x185fae
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movslq %edx, %rdx
shlq %rdx
addq %rdx, %rcx
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jne 0x186068
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jl 0x1860a0
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1860a0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/quant_levels_dec_utils.c
// Function: ApplyFilter
static void ApplyFilter(SmoothParams* const p) {
  const uint16_t* const average = p->average_;
  const int w = p->width_;
  const int16_t* const correction = p->correction_;
#if defined(USE_DITHERING)
  const uint8_t* const dither = kOrderedDither[p->row_ % DSIZE];
#endif
  uint8_t* const dst = p->dst_;
  int x;
  for (x = 0; x < w; ++x) {
    const int v = dst[x];
    if (v < p->max_ && v > p->min_) {
      const int c = (v << DFIX) + correction[average[x] - (v << LFIX)];
#if defined(USE_DITHERING)
      dst[x] = clip_8b(c + dither[x % DSIZE]);
#else
      dst[x] = clip_8b(c);
#endif
    }
  }
  p->dst_ += p->stride_;  // advance output pointer
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1862eb
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x60(%rcx), %eax
jge 0x1862de
movl -0x30(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x5c(%rcx), %eax
jle 0x1862de
movl -0x30(%rbp), %eax
shll $0x0, %eax
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdx
movslq -0x2c(%rbp), %rsi
movzwl (%rdx,%rsi,2), %edx
movl -0x30(%rbp), %esi
shll $0x2, %esi
subl %esi, %edx
movslq %edx, %rdx
movswl (%rcx,%rdx,2), %ecx
addl %ecx, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %edi
callq 0x1865b0
movb %al, %dl
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x1862e0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x186270
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/quant_levels_dec_utils.c
// Function: CountLevels
static void CountLevels(SmoothParams* const p) {
  int i, j, last_level;
  uint8_t used_levels[256] = { 0 };
  const uint8_t* data = p->src_;
  p->min_ = 255;
  p->max_ = 0;
  for (j = 0; j < p->height_; ++j) {
    for (i = 0; i < p->width_; ++i) {
      const int v = data[i];
      if (v < p->min_) p->min_ = v;
      if (v > p->max_) p->max_ = v;
      used_levels[v] = 1;
    }
    data += p->stride_;
  }
  // Compute the mininum distance between two non-zero levels.
  p->min_level_dist_ = p->max_ - p->min_;
  last_level = -1;
  for (i = 0; i < 256; ++i) {
    if (used_levels[i]) {
      ++p->num_levels_;
      if (last_level >= 0) {
        const int level_dist = i - last_level;
        if (level_dist < p->min_level_dist_) {
          p->min_level_dist_ = level_dist;
        }
      }
      last_level = i;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x5a200
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x128(%rbp)
movq -0x8(%rbp), %rax
movl $0xff, 0x5c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x60(%rax)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x186430
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x186407
movq -0x128(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x12c(%rbp)
movl -0x12c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x5c(%rcx), %eax
jge 0x1863d1
movl -0x12c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x5c(%rax)
movl -0x12c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x60(%rcx), %eax
jle 0x1863ed
movl -0x12c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x60(%rax)
movslq -0x12c(%rbp), %rax
movb $0x1, -0x120(%rbp,%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x186395
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x128(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x128(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x18637e
movq -0x8(%rbp), %rax
movl 0x60(%rax), %ecx
movq -0x8(%rbp), %rax
subl 0x5c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x64(%rax)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jge 0x1864ba
movslq -0xc(%rbp), %rax
cmpb $0x0, -0x120(%rbp,%rax)
je 0x1864ad
movq -0x8(%rbp), %rax
movl 0x58(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x58(%rax)
cmpl $0x0, -0x14(%rbp)
jl 0x1864a7
movl -0xc(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x130(%rbp)
movl -0x130(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x64(%rcx), %eax
jge 0x1864a5
movl -0x130(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x64(%rax)
jmp 0x1864a7
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x1864af
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x186453
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/quant_levels_dec_utils.c
// Function: InitCorrectionLUT
static void InitCorrectionLUT(int16_t* const lut, int min_dist) {
  // The correction curve is:
  //   f(x) = x for x <= threshold2
  //   f(x) = 0 for x >= threshold1
  // and a linear interpolation for range x=[threshold2, threshold1]
  // (along with f(-x) = -f(x) symmetry).
  // Note that: threshold2 = 3/4 * threshold1
  const int threshold1 = min_dist << LFIX;
  const int threshold2 = (3 * threshold1) >> 2;
  const int max_threshold = threshold2 << DFIX;
  const int delta = threshold1 - threshold2;
  int i;
  for (i = 1; i <= LUT_SIZE; ++i) {
    int c = (i <= threshold2) ? (i << DFIX)
          : (i < threshold1) ? max_threshold * (threshold1 - i) / delta
          : 0;
    c >>= LFIX;
    lut[+i] = +c;
    lut[-i] = -c;
  }
  lut[0] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x10(%rbp)
imull $0x3, -0x10(%rbp), %eax
sarl $0x2, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shll $0x0, %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
cmpl $0x3ff, -0x20(%rbp)     # imm = 0x3FF
jg 0x186598
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x186527
movl -0x20(%rbp), %eax
shll $0x0, %eax
movl %eax, -0x28(%rbp)
jmp 0x186551
movl -0x20(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x186544
movl -0x18(%rbp), %eax
movl -0x10(%rbp), %ecx
subl -0x20(%rbp), %ecx
imull %ecx, %eax
cltd
idivl -0x1c(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x18654b
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x18654b
movl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
sarl $0x2, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
xorl %eax, %eax
subl -0x24(%rbp), %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
subl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movw %dx, (%rax,%rcx,2)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x186507
movq -0x8(%rbp), %rax
movw $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)