LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv_sse2.c
// Function: VP8YuvToRgb56532_SSE2
void VP8YuvToRgb56532_SSE2(const uint8_t* y, const uint8_t* u, const uint8_t* v,
                           uint8_t* dst) {
  int n;
  for (n = 0; n < 32; n += 8, dst += 16) {
    __m128i R, G, B;
    YUV444ToRGB_SSE2(y + n, u + n, v + n, &R, &G, &B);
    PackAndStore565_SSE2(&R, &G, &B, dst);
  }
}

// Assembly:
movq $-0x8, %rax
movdqa 0x40c0f(%rip), %xmm1    # 0x12e4b0
movdqa 0x40c17(%rip), %xmm2    # 0x12e4c0
movdqa 0x40c1f(%rip), %xmm3    # 0x12e4d0
movdqa 0x40c27(%rip), %xmm4    # 0x12e4e0
movdqa 0x40c2f(%rip), %xmm5    # 0x12e4f0
movdqa 0x40c37(%rip), %xmm6    # 0x12e500
movdqa 0x40c3f(%rip), %xmm7    # 0x12e510
movdqa 0x40406(%rip), %xmm8    # 0x12dce0
movdqa 0x40c3d(%rip), %xmm9    # 0x12e520
movdqa 0x40404(%rip), %xmm10   # 0x12dcf0
movdqa 0x4040b(%rip), %xmm11   # 0x12dd00
movq 0x8(%rdi,%rax), %xmm12
pxor %xmm14, %xmm14
punpcklbw %xmm12, %xmm14  # xmm14 = xmm14[0],xmm12[0],xmm14[1],xmm12[1],xmm14[2],xmm12[2],xmm14[3],xmm12[3],xmm14[4],xmm12[4],xmm14[5],xmm12[5],xmm14[6],xmm12[6],xmm14[7],xmm12[7]
movq 0x8(%rsi,%rax), %xmm13
pxor %xmm12, %xmm12
punpcklbw %xmm13, %xmm12  # xmm12 = xmm12[0],xmm13[0],xmm12[1],xmm13[1],xmm12[2],xmm13[2],xmm12[3],xmm13[3],xmm12[4],xmm13[4],xmm12[5],xmm13[5],xmm12[6],xmm13[6],xmm12[7],xmm13[7]
movq 0x8(%rdx,%rax), %xmm13
pxor %xmm15, %xmm15
punpcklbw %xmm13, %xmm15  # xmm15 = xmm15[0],xmm13[0],xmm15[1],xmm13[1],xmm15[2],xmm13[2],xmm15[3],xmm13[3],xmm15[4],xmm13[4],xmm15[5],xmm13[5],xmm15[6],xmm13[6],xmm15[7],xmm13[7]
movdqa %xmm15, %xmm13
movdqa %xmm12, %xmm0
pmulhuw %xmm3, %xmm0
pmulhuw %xmm4, %xmm15
paddw %xmm0, %xmm15
pmulhuw 0x40b57(%rip), %xmm14   # 0x12e4a0
pmulhuw %xmm1, %xmm13
paddw %xmm14, %xmm13
paddw %xmm2, %xmm13
pmulhuw %xmm6, %xmm12
paddusw %xmm14, %xmm12
psubw %xmm15, %xmm14
paddw %xmm5, %xmm14
psraw $0x6, %xmm13
packuswb %xmm13, %xmm13
pand %xmm8, %xmm13
psraw $0x6, %xmm14
packuswb %xmm14, %xmm14
movdqa %xmm14, %xmm0
psrlw $0x5, %xmm0
pand %xmm10, %xmm0
por %xmm13, %xmm0
psubusw %xmm7, %xmm12
psrlw $0x6, %xmm12
packuswb %xmm12, %xmm12
psrlw $0x3, %xmm12
pand %xmm9, %xmm12
psllw $0x3, %xmm14
pand %xmm11, %xmm14
por %xmm12, %xmm14
punpcklbw %xmm14, %xmm0   # xmm0 = xmm0[0],xmm14[0],xmm0[1],xmm14[1],xmm0[2],xmm14[2],xmm0[3],xmm14[3],xmm0[4],xmm14[4],xmm0[5],xmm14[5],xmm0[6],xmm14[6],xmm0[7],xmm14[7]
movdqu %xmm0, 0x10(%rcx,%rax,2)
addq $0x8, %rax
cmpq $0x18, %rax
jb 0xed8f5
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv_sse2.c
// Function: WebPInitSamplersSSE2
WEBP_TSAN_IGNORE_FUNCTION void WebPInitSamplersSSE2(void) {
  WebPSamplers[MODE_RGB]  = YuvToRgbRow_SSE2;
  WebPSamplers[MODE_RGBA] = YuvToRgbaRow_SSE2;
  WebPSamplers[MODE_BGR]  = YuvToBgrRow_SSE2;
  WebPSamplers[MODE_BGRA] = YuvToBgraRow_SSE2;
  WebPSamplers[MODE_ARGB] = YuvToArgbRow_SSE2;
}

// Assembly:
leaq 0x37(%rip), %rax        # 0xee3ac
leaq 0x8e364(%rip), %rcx     # 0x17c6e0
movq %rax, (%rcx)
leaq 0x7a1(%rip), %rax       # 0xeeb27
movq %rax, 0x8(%rcx)
leaq 0xa5e(%rip), %rax       # 0xeedef
movq %rax, 0x10(%rcx)
leaq 0x11ce(%rip), %rax      # 0xef56a
movq %rax, 0x18(%rcx)
leaq 0x148b(%rip), %rax      # 0xef832
movq %rax, 0x20(%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv_sse2.c
// Function: WebPInitConvertARGBToYUVSSE2
WEBP_TSAN_IGNORE_FUNCTION void WebPInitConvertARGBToYUVSSE2(void) {
  WebPConvertARGBToY = ConvertARGBToY_SSE2;
  WebPConvertARGBToUV = ConvertARGBToUV_SSE2;

  WebPConvertRGB24ToY = ConvertRGB24ToY_SSE2;
  WebPConvertBGR24ToY = ConvertBGR24ToY_SSE2;

  WebPConvertRGBA32ToUV = ConvertRGBA32ToUV_SSE2;
}

// Assembly:
leaq 0x4f(%rip), %rax        # 0xefb55
leaq 0x8cc53(%rip), %rcx     # 0x17c760
movq %rax, (%rcx)
leaq 0x20e(%rip), %rax       # 0xefd25
leaq 0x8cc4a(%rip), %rcx     # 0x17c768
movq %rax, (%rcx)
leaq 0x56d(%rip), %rax       # 0xf0095
leaq 0x8cc19(%rip), %rcx     # 0x17c748
movq %rax, (%rcx)
leaq 0x80a(%rip), %rax       # 0xf0343
leaq 0x8cc10(%rip), %rcx     # 0x17c750
movq %rax, (%rcx)
leaq 0xaab(%rip), %rax       # 0xf05f5
leaq 0x8cc07(%rip), %rcx     # 0x17c758
movq %rax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/utils/bit_reader_utils.c
// Function: VP8BitReaderSetBuffer
void VP8BitReaderSetBuffer(VP8BitReader* const br,
                           const uint8_t* const start,
                           size_t size) {
  br->buf_     = start;
  br->buf_end_ = start + size;
  br->buf_max_ =
      (size >= sizeof(lbit_t)) ? start + size - sizeof(lbit_t) + 1
                               : start;
}

// Assembly:
movq %rsi, 0x10(%rdi)
leaq (%rsi,%rdx), %rax
movq %rax, 0x18(%rdi)
cmpq $0x8, %rdx
leaq -0x7(%rsi,%rdx), %rax
cmovbq %rsi, %rax
movq %rax, 0x20(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/utils/bit_reader_utils.c
// Function: VP8InitBitReader
void VP8InitBitReader(VP8BitReader* const br,
                      const uint8_t* const start, size_t size) {
  assert(br != NULL);
  assert(start != NULL);
  assert(size < (1u << 31));   // limit ensured by format and upstream checks
  br->range_   = 255 - 1;
  br->value_   = 0;
  br->bits_    = -8;   // to load the very first 8bits
  br->eof_     = 0;
  VP8BitReaderSetBuffer(br, start, size);
  VP8LoadNewBytes(br);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xf08f8
testq %rsi, %rsi
je 0xf0917
movq %rdx, %rax
shrq $0x1f, %rax
jne 0xf0936
movabsq $-0x7ffffff02, %rax     # imm = 0xFFFFFFF8000000FE
movq %rax, 0x8(%rdi)
movq $0x0, (%rdi)
movl $0x0, 0x28(%rdi)
movq %rsi, 0x10(%rdi)
leaq (%rsi,%rdx), %rax
movq %rax, 0x18(%rdi)
cmpq $0x8, %rdx
leaq -0x7(%rsi,%rdx), %rax
cmovbq %rsi, %rax
movq %rax, 0x20(%rdi)
cmpq %rsi, %rax
jbe 0xf08f2
movq (%rsi), %rax
addq $0x7, %rsi
bswapq %rax
movq %rsi, 0x10(%rdi)
shrq $0x8, %rax
movq %rax, (%rdi)
movl $0x30, 0xc(%rdi)
popq %rax
retq
popq %rax
jmp 0xf096e
leaq 0x3dcc1(%rip), %rdi     # 0x12e5c0
leaq 0x3dcc5(%rip), %rsi     # 0x12e5cb
leaq 0x3dcdb(%rip), %rcx     # 0x12e5e8
movl $0x25, %edx
callq 0x55710
leaq 0x39ebf(%rip), %rdi     # 0x12a7dd
leaq 0x3dca6(%rip), %rsi     # 0x12e5cb
leaq 0x3dcbc(%rip), %rcx     # 0x12e5e8
movl $0x26, %edx
callq 0x55710
leaq 0x3dcf4(%rip), %rdi     # 0x12e631
leaq 0x3dc87(%rip), %rsi     # 0x12e5cb
leaq 0x3dc9d(%rip), %rcx     # 0x12e5e8
movl $0x27, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/utils/bit_reader_utils.c
// Function: VP8RemapBitReader
void VP8RemapBitReader(VP8BitReader* const br, ptrdiff_t offset) {
  if (br->buf_ != NULL) {
    br->buf_ += offset;
    br->buf_end_ += offset;
    br->buf_max_ += offset;
  }
}

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xf096d
addq %rsi, %rax
movq %rax, 0x10(%rdi)
addq %rsi, 0x18(%rdi)
addq %rsi, 0x20(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/utils/bit_reader_utils.c
// Function: VP8LoadFinalBytes
void VP8LoadFinalBytes(VP8BitReader* const br) {
  assert(br != NULL && br->buf_ != NULL);
  // Only read 8bits at a time
  if (br->buf_ < br->buf_end_) {
    br->bits_ += 8;
    br->value_ = (bit_t)(*br->buf_++) | (br->value_ << 8);
  } else if (!br->eof_) {
    br->value_ <<= 8;
    br->bits_ += 8;
    br->eof_ = 1;
  } else {
    br->bits_ = 0;  // This is to avoid undefined behaviour with shifts.
  }
}

// Assembly:
testq %rdi, %rdi
je 0xf09bd
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xf09bd
cmpq 0x18(%rdi), %rax
jae 0xf099f
addl $0x8, 0xc(%rdi)
leaq 0x1(%rax), %rcx
movq %rcx, 0x10(%rdi)
movzbl (%rax), %eax
movq (%rdi), %rcx
shlq $0x8, %rcx
orq %rax, %rcx
movq %rcx, (%rdi)
retq
cmpl $0x0, 0x28(%rdi)
je 0xf09ad
movl $0x0, 0xc(%rdi)
retq
shlq $0x8, (%rdi)
addl $0x8, 0xc(%rdi)
movl $0x1, 0x28(%rdi)
retq
pushq %rax
leaq 0x39adb(%rip), %rdi     # 0x12a4a0
leaq 0x3dbff(%rip), %rsi     # 0x12e5cb
leaq 0x3dc70(%rip), %rcx     # 0x12e643
movl $0x59, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/utils/bit_reader_utils.c
// Function: VP8GetValue
uint32_t VP8GetValue(VP8BitReader* const br, int bits, const char label[]) {
  uint32_t v = 0;
  while (bits-- > 0) {
    v |= VP8GetBit(br, 0x80, label) << bits;
  }
  return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0xf0aac
movl %esi, %ebx
movq %rdi, %r14
incl %ebx
xorl %ebp, %ebp
movl 0x8(%r14), %r15d
movl 0xc(%r14), %eax
testl %eax, %eax
jns 0xf0a41
testq %r14, %r14
je 0xf0abb
movq 0x10(%r14), %rcx
testq %rcx, %rcx
je 0xf0abb
cmpq 0x20(%r14), %rcx
jae 0xf0a39
movq (%rcx), %rdx
addq $0x7, %rcx
movq %rcx, 0x10(%r14)
bswapq %rdx
shldq $0x38, %rdx, (%r14)
addl $0x38, %eax
movl %eax, 0xc(%r14)
jmp 0xf0a41
movq %r14, %rdi
callq 0xf096e
movl 0xc(%r14), %eax
movl %r15d, %edx
shrl %edx
andl $0xffffff, %edx         # imm = 0xFFFFFF
movq (%r14), %rdi
movq %rdi, %rsi
movl %eax, %ecx
shrq %cl, %rsi
cmpl %esi, %edx
jae 0xf0a73
leaq 0x1(%rdx), %r8
movl %eax, %ecx
shlq %cl, %r8
subl %edx, %r15d
subq %r8, %rdi
movq %rdi, (%r14)
jmp 0xf0a77
leal 0x1(%rdx), %r15d
xorl %edi, %edi
cmpl %esi, %edx
setb %dil
bsrl %r15d, %ecx
xorl $0x7, %ecx
shll %cl, %r15d
leal -0x2(%rbx), %edx
subl %ecx, %eax
movl %eax, 0xc(%r14)
decl %r15d
movl %edx, %ecx
shll %cl, %edi
movl %r15d, 0x8(%r14)
orl %edi, %ebp
decl %ebx
cmpl $0x1, %ebx
jg 0xf09f5
jmp 0xf0aae
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x399de(%rip), %rdi     # 0x12a4a0
leaq 0x399f6(%rip), %rsi     # 0x12a4bf
leaq 0x39a5a(%rip), %rcx     # 0x12a52a
movl $0x3b, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/utils/bit_reader_utils.c
// Function: VP8LInitBitReader
void VP8LInitBitReader(VP8LBitReader* const br, const uint8_t* const start,
                       size_t length) {
  size_t i;
  vp8l_val_t value = 0;
  assert(br != NULL);
  assert(start != NULL);
  assert(length < 0xfffffff8u);   // can't happen with a RIFF chunk.

  br->len_ = length;
  br->val_ = 0;
  br->bit_pos_ = 0;
  br->eos_ = 0;

  if (length > sizeof(br->val_)) {
    length = sizeof(br->val_);
  }
  for (i = 0; i < length; ++i) {
    value |= (vp8l_val_t)start[i] << (8 * i);
  }
  br->val_ = value;
  br->pos_ = length;
  br->buf_ = start;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xf0b7b
testq %rsi, %rsi
je 0xf0b9a
movq %rdx, %rax
shrq $0x3, %rax
cmpq $0x1fffffff, %rax       # imm = 0x1FFFFFFF
jae 0xf0bb9
movq %rdx, 0x10(%rdi)
xorl %r8d, %r8d
movq %r8, (%rdi)
movq %r8, 0x20(%rdi)
cmpq $0x8, %rdx
movl $0x8, %eax
cmovbq %rdx, %rax
testq %rdx, %rdx
je 0xf0b6e
leaq (,%rax,8), %rdx
xorl %ecx, %ecx
movq %rsi, %r9
xorl %r8d, %r8d
movzbl (%r9), %r10d
shlq %cl, %r10
orq %r10, %r8
addq $0x8, %rcx
incq %r9
cmpq %rcx, %rdx
jne 0xf0b58
movq %r8, (%rdi)
movq %rax, 0x18(%rdi)
movq %rsi, 0x8(%rdi)
popq %rax
retq
leaq 0x3da3e(%rip), %rdi     # 0x12e5c0
leaq 0x3da42(%rip), %rsi     # 0x12e5cb
leaq 0x3dadf(%rip), %rcx     # 0x12e66f
movl $0x91, %edx
callq 0x55710
leaq 0x39c3c(%rip), %rdi     # 0x12a7dd
leaq 0x3da23(%rip), %rsi     # 0x12e5cb
leaq 0x3dac0(%rip), %rcx     # 0x12e66f
movl $0x92, %edx
callq 0x55710
leaq 0x3dafa(%rip), %rdi     # 0x12e6ba
leaq 0x3da04(%rip), %rsi     # 0x12e5cb
leaq 0x3daa1(%rip), %rcx     # 0x12e66f
movl $0x93, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/utils/bit_reader_utils.c
// Function: VP8LBitReaderSetBuffer
void VP8LBitReaderSetBuffer(VP8LBitReader* const br,
                            const uint8_t* const buf, size_t len) {
  assert(br != NULL);
  assert(buf != NULL);
  assert(len < 0xfffffff8u);   // can't happen with a RIFF chunk.
  br->buf_ = buf;
  br->len_ = len;
  // pos_ > len_ should be considered a param error.
  br->eos_ = (br->pos_ > br->len_) || VP8LIsEndOfStream(br);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xf0c23
testq %rsi, %rsi
je 0xf0c42
movq %rdx, %rax
shrq $0x3, %rax
cmpq $0x1fffffff, %rax       # imm = 0x1FFFFFFF
jae 0xf0c61
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq 0x18(%rdi), %rcx
movl $0x1, %eax
cmpq %rdx, %rcx
ja 0xf0c1e
cmpl $0x0, 0x24(%rdi)
jne 0xf0c1e
xorl %eax, %eax
cmpq %rdx, %rcx
jne 0xf0c1e
xorl %eax, %eax
cmpl $0x41, 0x20(%rdi)
setge %al
movl %eax, 0x24(%rdi)
popq %rax
retq
leaq 0x3d996(%rip), %rdi     # 0x12e5c0
leaq 0x3d99a(%rip), %rsi     # 0x12e5cb
leaq 0x3da97(%rip), %rcx     # 0x12e6cf
movl $0xa7, %edx
callq 0x55710
leaq 0x38949(%rip), %rdi     # 0x129592
leaq 0x3d97b(%rip), %rsi     # 0x12e5cb
leaq 0x3da78(%rip), %rcx     # 0x12e6cf
movl $0xa8, %edx
callq 0x55710
leaq 0x3dab7(%rip), %rdi     # 0x12e71f
leaq 0x3d95c(%rip), %rsi     # 0x12e5cb
leaq 0x3da59(%rip), %rcx     # 0x12e6cf
movl $0xa9, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/utils/bit_reader_utils.c
// Function: VP8LDoFillBitWindow
void VP8LDoFillBitWindow(VP8LBitReader* const br) {
  assert(br->bit_pos_ >= VP8L_WBITS);
#if defined(VP8L_USE_FAST_LOAD)
  if (br->pos_ + sizeof(br->val_) < br->len_) {
    br->val_ >>= VP8L_WBITS;
    br->bit_pos_ -= VP8L_WBITS;
    br->val_ |= (vp8l_val_t)HToLE32(WebPMemToUint32(br->buf_ + br->pos_)) <<
                (VP8L_LBITS - VP8L_WBITS);
    br->pos_ += VP8L_LOG8_WBITS;
    return;
  }
#endif
  ShiftBytes(br);       // Slow path.
}

// Assembly:
movl 0x20(%rdi), %ecx
cmpl $0x1f, %ecx
jle 0xf0cc3
movq 0x18(%rdi), %rax
leaq 0x8(%rax), %rdx
cmpq 0x10(%rdi), %rdx
jae 0xf0cc1
movq (%rdi), %rdx
movq 0x8(%rdi), %rsi
movq %rdx, %r8
shrq $0x20, %r8
movq %r8, (%rdi)
addl $-0x20, %ecx
movl %ecx, 0x20(%rdi)
movl (%rsi,%rax), %ecx
shldq $0x20, %rdx, %rcx
movq %rcx, (%rdi)
addq $0x4, %rax
movq %rax, 0x18(%rdi)
retq
jmp 0xf0ce3
pushq %rax
leaq 0x3da66(%rip), %rdi     # 0x12e731
leaq 0x3d8f9(%rip), %rsi     # 0x12e5cb
leaq 0x3da73(%rip), %rcx     # 0x12e74c
movl $0xc3, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/utils/bit_reader_utils.c
// Function: ShiftBytes
static void ShiftBytes(VP8LBitReader* const br) {
  while (br->bit_pos_ >= 8 && br->pos_ < br->len_) {
    br->val_ >>= 8;
    br->val_ |= ((vp8l_val_t)br->buf_[br->pos_]) << (VP8L_LBITS - 8);
    ++br->pos_;
    br->bit_pos_ -= 8;
  }
  if (VP8LIsEndOfStream(br)) {
    VP8LSetEndOfStream(br);
  }
}

// Assembly:
pushq %rax
movl 0x20(%rdi), %eax
movb $0x1, %cl
cmpl $0x8, %eax
jl 0xf0d37
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
cmpq %rcx, %rdx
jae 0xf0d2f
movq (%rdi), %rsi
movq 0x8(%rdi), %r8
movq %rsi, %r9
shrq $0x8, %r9
movq %r9, (%rdi)
movzbl (%r8,%rdx), %r8d
shldq $0x38, %rsi, %r8
movq %r8, (%rdi)
incq %rdx
movq %rdx, 0x18(%rdi)
leal -0x8(%rax), %esi
movl %esi, 0x20(%rdi)
cmpl $0xf, %eax
movl %esi, %eax
jg 0xf0cf6
jmp 0xf0d31
movl %eax, %esi
cmpl $0x41, %esi
setl %cl
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
ja 0xf0d60
setne %al
cmpl $0x0, 0x24(%rdi)
jne 0xf0d50
orb %cl, %al
testb $0x1, %al
jne 0xf0d5e
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x20(%rdi)
popq %rax
retq
leaq 0x39fa2(%rip), %rdi     # 0x12ad09
leaq 0x39fb0(%rip), %rsi     # 0x12ad1e
leaq 0x3a010(%rip), %rcx     # 0x12ad85
movl $0xac, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
testl %esi, %esi
js 0xf0dc4
cmpl $0x18, %esi
jg 0xf0db0
cmpl $0x0, 0x24(%rdi)
jne 0xf0db0
movq (%rdi), %rbx
movl 0x20(%rdi), %ecx
shrq %cl, %rbx
movl %esi, %eax
leaq 0x3db1f(%rip), %rdx     # 0x12e8c0
andl (%rdx,%rax,4), %ebx
addl %esi, %ecx
movl %ecx, 0x20(%rdi)
callq 0xf0ce3
jmp 0xf0dc0
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x20(%rdi)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
leaq 0x3d9b0(%rip), %rdi     # 0x12e77b
leaq 0x3d7f9(%rip), %rsi     # 0x12e5cb
leaq 0x3d9ae(%rip), %rcx     # 0x12e787
movl $0xd2, %edx
callq 0x55710
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl $0x1, %eax
movl %ebx, %ecx
shll %cl, %eax
testq %rdi, %rdi
je 0xf0e34
testl %ebx, %ebx
jle 0xf0e53
movq %rdi, %r14
movslq %eax, %rdi
movl $0x4, %esi
callq 0x56580
movq %rax, (%r14)
testq %rax, %rax
je 0xf0e2a
movl $0x20, %eax
subl %ebx, %eax
movl %eax, 0x8(%r14)
movl %ebx, 0xc(%r14)
movl $0x1, %eax
jmp 0xf0e2c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3a012(%rip), %rdi     # 0x12ae4d
leaq 0x3dae2(%rip), %rsi     # 0x12e924
leaq 0x3daf9(%rip), %rcx     # 0x12e942
movl $0x19, %edx
callq 0x55710
leaq 0x3db1b(%rip), %rdi     # 0x12e975
leaq 0x3dac3(%rip), %rsi     # 0x12e924
leaq 0x3dada(%rip), %rcx     # 0x12e942
movl $0x1a, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O1/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 %rax
testq %rdi, %rdi
je 0xf0eb6
testq %rsi, %rsi
je 0xf0ed5
movl 0xc(%rsi), %ecx
cmpl %ecx, 0xc(%rdi)
jne 0xf0ef4
movq (%rsi), %rax
movl $0x4, %edx
shlq %cl, %rdx
movq (%rdi), %rsi
movq %rax, %rdi
popq %rax
jmp 0x552d0
leaq 0x3dac6(%rip), %rdi     # 0x12e983
leaq 0x3da60(%rip), %rsi     # 0x12e924
leaq 0x3dac4(%rip), %rcx     # 0x12e98f
movl $0x2c, %edx
callq 0x55710
leaq 0x38c76(%rip), %rdi     # 0x129b52
leaq 0x3da41(%rip), %rsi     # 0x12e924
leaq 0x3daa5(%rip), %rcx     # 0x12e98f
movl $0x2d, %edx
callq 0x55710
leaq 0x3dae0(%rip), %rdi     # 0x12e9db
leaq 0x3da22(%rip), %rsi     # 0x12e924
leaq 0x3da86(%rip), %rcx     # 0x12e98f
movl $0x2e, %edx
callq 0x55710
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl %edi, %ebx
movslq %edi, %rdi
movl $0x238, %esi            # imm = 0x238
callq 0x56b20
testq %rax, %rax
je 0xf0f50
cmpl $0x10001, %ebx          # imm = 0x10001
jl 0xf0f52
leaq 0x3dac6(%rip), %rdi     # 0x12e9fe
leaq 0x3dae4(%rip), %rsi     # 0x12ea23
leaq 0x3daf7(%rip), %rcx     # 0x12ea3d
movl $0x1f, %edx
callq 0x55710
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movq %rsi, 0x20(%rsi)
movq $0x0, 0x10(%rsi)
movslq %edi, %rdi
movl $0x4, %esi
callq 0x56b20
movq %rax, (%rbx)
testq %rax, %rax
je 0xf163e
movq %rax, 0x8(%rbx)
movl %ebp, 0x18(%rbx)
movl $0x1, %eax
jmp 0xf1640
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0xf1690
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x10(%r14), %rbx
callq 0x57290
xorl %eax, %eax
movq %rax, (%r14)
movq %rax, 0x10(%r14)
testq %rbx, %rbx
je 0xf1689
movq (%rbx), %rdi
movq 0x10(%rbx), %r14
callq 0x57290
movq %rbx, %rdi
callq 0x57290
movq %r14, %rbx
testq %r14, %r14
jne 0xf166d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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:
xorl %eax, %eax
cmpl %esi, (%rdi)
je 0xf16c2
xorl %ecx, %ecx
leal (%rdx,%rcx), %r8d
sarl %r8d
movslq %r8d, %r8
movl %ecx, %r9d
cmpl %esi, (%rdi,%r8,4)
cmovbl %r8d, %r9d
cmovel %ecx, %r9d
cmoval %r8d, %edx
cmovel %r8d, %eax
movl %r9d, %ecx
jne 0xf169c
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl %esi, %r12d
leaq (,%r12,4), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x552d0
leaq 0x64(%rip), %rcx        # 0xf1757
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x57590
testl %ebp, %ebp
je 0xf174e
xorl %eax, %eax
movl (%r15,%rax,4), %ecx
cmpl %ecx, (%r14)
jne 0xf1716
xorl %ecx, %ecx
jmp 0xf1743
xorl %edi, %edi
movl %ebp, %esi
leal (%rsi,%rdi), %r8d
sarl %r8d
movslq %r8d, %r8
movl %edi, %r9d
cmpl %ecx, (%r14,%r8,4)
cmovbl %r8d, %r9d
cmovel %edi, %r9d
cmoval %r8d, %esi
cmovel %r8d, %edx
movl %r9d, %edi
jne 0xf171a
movslq %edx, %rcx
movl %eax, (%rbx,%rcx,4)
incq %rax
cmpq %r12, %rax
jne 0xf1709
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movss %xmm0, 0xc(%rsp)
movq %rdi, %rbx
addq $0x8, %rdi
leaq 0x3cdd7(%rip), %rsi     # 0x12ee10
movl $0xdc, %edx
callq 0x552d0
movabsq $0x1f00000000, %rax     # imm = 0x1F00000000
movq %rax, (%rbx)
movss 0xc(%rsp), %xmm1
ucomiss 0x37c13(%rip), %xmm1    # 0x129c70
movss 0x3cda3(%rip), %xmm0    # 0x12ee08
mulss %xmm1, %xmm0
cvttss2si %xmm0, %rax
movl $0x100, %ecx            # imm = 0x100
cmovbel %eax, %ecx
xorl %eax, %eax
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
cmovbel %ecx, %eax
movl %eax, 0xe4(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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:
xorl %eax, %eax
testq %rdi, %rdi
je 0xf20e5
cmpq $0x0, (%rdi)
je 0xf20e5
cmpq $0x0, 0x8(%rdi)
je 0xf20e5
cmpq $0x0, 0x10(%rdi)
je 0xf20e5
cmpq $0x0, 0x18(%rdi)
je 0xf20e5
cmpq $0x0, 0x20(%rdi)
je 0xf20e5
cmpq $0x0, 0x28(%rdi)
je 0xf20e5
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movups 0x20(%rdi), %xmm2
movups %xmm2, 0x7d30e(%rip)    # 0x16f3e0
movups %xmm1, 0x7d2f7(%rip)    # 0x16f3d0
movups %xmm0, 0x7d2e0(%rip)    # 0x16f3c0
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
testq %rdi, %rdi
je 0xf2248
movq %rdi, %rbx
movq 0xbb0(%rdi), %rdi
callq 0x57290
xorps %xmm0, %xmm0
movups %xmm0, 0xbb0(%rbx)
movq 0xb90(%rbx), %rdi
callq 0xf2267
movq $0x0, 0xb90(%rbx)
popq %rbx
retq
leaq 0x3845e(%rip), %rdi     # 0x12a6ad
leaq 0x3cd4f(%rip), %rsi     # 0x12efa5
leaq 0x3cd5c(%rip), %rcx     # 0x12efb9
movl $0xa4, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0xf228a
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xd4f48
movq $0x0, 0x18(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x57290
retq
// File: /workspace/github_c_makefile_star2_O1/generot[P]VM-0/src/lang/util.cc
// Function: lexer::expect(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
bool lexer::expect(string tok, bool kill_prog) {
    if(tokens[ix] != tok) {
        if(kill_prog)
            ISSUE_ERROR("Expected \"%s\", got \"%s\" instead.", tok.c_str(), tokens[ix].c_str());

        return false;
    }

    return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq 0x20(%rdi), %rax
movq 0x40(%rdi), %rcx
shlq $0x5, %rcx
leaq (%rax,%rcx), %r14
movq 0x8(%rax,%rcx), %rdx
cmpq 0x8(%rsi), %rdx
jne 0x4aef
testq %rdx, %rdx
je 0x4af3
movq (%rbx), %rsi
movq (%r14), %rdi
callq 0x42f0
testl %eax, %eax
sete %al
jmp 0x4af5
xorl %eax, %eax
jmp 0x4af5
movb $0x1, %al
xorb $0x1, %bpl
orb %al, %bpl
je 0x4b03
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4582
// File: /workspace/github_c_makefile_star2_O1/generot[P]VM-0/src/lang/util.cc
// Function: lexer::file_path[abi:cxx11]()
string lexer::file_path(void) { 
    int i;

    for(i = (int)filepath.length() - 1; i > 0 && 
        (filepath[i] != '/' && filepath[i] != '\\'); i--);

    return string(filepath.substr(0, i)) + (i != 0 ? "/" : "");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl 0x8(%rsi), %eax
testl %eax, %eax
movl $0x1, %ecx
cmovlel %eax, %ecx
decl %ecx
leal -0x1(%rax), %edx
addq (%rsi), %rdx
cmpl $0x2, %eax
jl 0x4b72
movzbl (%rdx), %edi
decl %eax
cmpl $0x5c, %edi
je 0x4b74
decq %rdx
cmpl $0x2f, %edi
jne 0x4b59
jmp 0x4b74
movl %ecx, %eax
movslq %eax, %r14
movq %rsp, %r15
movq %r15, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x4300
testl %r14d, %r14d
leaq 0x1266c(%rip), %rax     # 0x171fd
leaq 0x12586(%rip), %rsi     # 0x1711e
cmoveq %rax, %rsi
movq %r15, %rdi
callq 0x4540
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x4bc6
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x4bcc
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4bfe
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4c29
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x44e0
nop
// File: /workspace/github_c_makefile_star2_O1/generot[P]VM-0/src/lang/util.cc
// Function: match_comp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
opcode match_comp(string strrep) {
    string comps[] = { ">", "<", ">=", "<=", "==", "!=" };

    for(int i = 0; i < 6; i++) {
        if(strrep == comps[i])
            return opcode(OPC_GT + i);
    }

    return OPC_INVALID;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %r15
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x122fa(%rip), %rsi     # 0x17125
leaq 0x122f4(%rip), %rdx     # 0x17126
movq %rsp, %r14
movq %r14, %rdi
callq 0x59ce
leaq 0x20(%rsp), %rbx
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x122d5(%rip), %rsi     # 0x17127
leaq 0x122cf(%rip), %rdx     # 0x17128
movq %rbx, %rdi
callq 0x59ce
leaq 0x40(%rsp), %rbx
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x122b3(%rip), %rsi     # 0x17129
leaq 0x122ae(%rip), %rdx     # 0x1712b
movq %rbx, %rdi
callq 0x59ce
leaq 0x60(%rsp), %rbx
leaq 0x70(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x12292(%rip), %rsi     # 0x1712c
leaq 0x1228d(%rip), %rdx     # 0x1712e
movq %rbx, %rdi
callq 0x59ce
leaq 0x80(%rsp), %rbx
leaq 0x90(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x1226b(%rip), %rsi     # 0x1712f
leaq 0x12266(%rip), %rdx     # 0x17131
movq %rbx, %rdi
callq 0x59ce
leaq 0xa0(%rsp), %rbx
leaq 0xb0(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x12243(%rip), %rsi     # 0x17132
leaq 0x1223e(%rip), %rdx     # 0x17134
movq %rbx, %rdi
callq 0x59ce
movq 0x8(%r15), %r14
movl $0x1a, %ebx
movl $0x8, %r13d
cmpq (%rsp,%r13), %r14
jne 0x4f2c
testq %r14, %r14
je 0x4f40
movq -0x8(%rsp,%r13), %rsi
movq (%r15), %rdi
movq %r14, %rdx
callq 0x42f0
testl %eax, %eax
je 0x4f40
incl %ebx
addq $0x20, %r13
cmpq $0xc8, %r13
jne 0x4f0d
movl $0x26, %ebx
movq $-0xc0, %r14
movq -0x10(%r12), %rdi
cmpq %rdi, %r12
je 0x4f5d
movq (%r12), %rsi
incq %rsi
callq 0x42d0
addq $-0x20, %r12
addq $0x20, %r14
jne 0x4f47
movl %ebx, %eax
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4f82
jmp 0x4f82
jmp 0x4f82
jmp 0x4f82
movq %rax, %r15
cmpq %rbx, %r14
je 0x4fb5
addq $-0x10, %rbx
movq %rsp, %r14
movq -0x10(%rbx), %rdi
cmpq %rdi, %rbx
je 0x4fa5
movq (%rbx), %rsi
incq %rsi
callq 0x42d0
leaq -0x20(%rbx), %rax
addq $-0x10, %rbx
cmpq %r14, %rbx
movq %rax, %rbx
jne 0x4f91
movq %r15, %rdi
callq 0x44e0
movq %rax, %r15
movq %r14, %rbx
jmp 0x4f85
// File: /workspace/github_c_makefile_star2_O1/generot[P]VM-0/src/lang/util.cc
// Function: is_numeric(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool is_numeric(string str) {
    for(auto i = str.begin(); i < str.end(); i++) {
        if(!isdigit(*i) && *i != '.')
            return false;
    }

    return true;
}

// Assembly:
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
setle %al
jle 0x501a
movq (%rdi), %rdx
movsbl (%rdx), %esi
cmpl $0x2e, %esi
setne %dil
addl $-0x30, %esi
cmpl $0xa, %esi
setae %sil
testb %sil, %dil
jne 0x501a
addq %rdx, %rcx
incq %rdx
cmpq %rcx, %rdx
setae %al
jae 0x501a
movsbl (%rdx), %esi
cmpl $0x2e, %esi
sete %dil
addl $-0x30, %esi
cmpl $0xa, %esi
setb %sil
orb %dil, %sil
incq %rdx
testb %sil, %sil
jne 0x4ff3
retq
// File: /workspace/github_c_makefile_star2_O1/generot[P]VM-0/src/lang/util.cc
// Function: dump_program(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<_Instruction, std::allocator<_Instruction>>, long long)
void dump_program(string filename, vector<instr> prog, size_s entry_addr) {
    ofstream outf = ofstream(filename.c_str(), ios::out | ios::binary);

    bcode_header header;

    header.program_size = prog.size();
    header.stack_size_spec = bcode_header::STACK_SIZE_DEFAULT;
    header.entry_point_addr = (size_t)entry_addr;

    header.code_seg_sz = header.data_seg_sz = 0;

    outf.write((const char*)&header, sizeof(bcode_header));
    outf.write((const char*)prog.data(), prog.size() * sizeof(instr));

    outf.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rdx, %r14
movq %rsi, %rbx
movq (%rdi), %rsi
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl $0x14, %edx
callq 0x4320
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movl $0x1, 0x10(%rsi)
movq %r14, 0x8(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsi)
movl $0x28, %edx
movq %r15, %rdi
callq 0x43f0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
subq %rsi, %rdx
leaq 0x30(%rsp), %rdi
callq 0x43f0
leaq 0x30(%rsp), %rdi
callq 0x4430
movq 0x1bef1(%rip), %rax     # 0x20f98
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x38(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x30(%rsp,%rcx)
callq 0x4270
leaq 0x128(%rsp), %rdi
callq 0x40d0
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4470
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O1/generot[P]VM-0/src/lang/vc.cc
// Function: program(lexer&)
void program(lexer& lx) {
    while(!lx.eof()) {
        if(!(EXPECT("var") || EXPECT("proc") || EXPECT("include")))
            ISSUE_ERROR("Expected top-level declaration, got \"%s\" instead.",
                lx.accept().c_str());

        decl(lx);
        include(lx);
        procedure(lx);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
callq 0x4b0e
testb %al, %al
jne 0x139cc
leaq 0x50(%rsp), %r14
leaq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x20(%rsp), %r13
movq %rsp, %r12
movq %r14, 0x40(%rsp)
leaq 0x40(%rsp), %r14
movq %r14, %rdi
leaq 0x470c(%rip), %rsi      # 0x17fc1
leaq 0x4708(%rip), %rdx      # 0x17fc4
callq 0x59ce
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x4ab4
movl %eax, %r14d
movb $0x1, %bpl
testb %al, %al
jne 0x1390c
leaq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %r13, %r15
movq %r13, %rdi
leaq 0x46d6(%rip), %rsi      # 0x17fc5
leaq 0x46d3(%rip), %rdx      # 0x17fc9
callq 0x59ce
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x4ab4
testb %al, %al
je 0x13910
xorl %eax, %eax
jmp 0x13943
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %r12, %r15
movq %r12, %rdi
leaq 0x46a4(%rip), %rsi      # 0x17fca
leaq 0x46a4(%rip), %rdx      # 0x17fd1
callq 0x59ce
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x4ab4
movl %eax, %ebp
movb $0x1, %al
testb %al, %al
je 0x13962
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x13962
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
testb %r14b, %r14b
jne 0x13983
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x13983
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42d0
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %r14
cmpq %r14, %rdi
je 0x1399f
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x42d0
testb %bpl, %bpl
je 0x139db
movq %rbx, %rdi
callq 0x13a4c
movq %rbx, %rdi
callq 0x13d62
movq %rbx, %rdi
callq 0x13ff7
movq %rbx, %rdi
callq 0x4b0e
testb %al, %al
je 0x138a1
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x470b
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x13a08
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x13a08
jmp 0x13a05
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq 0x60(%rsp), %rdi
je 0x13a28
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x13a28
jmp 0x13a25
movq %rax, %rbx
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x13a44
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O1/generot[P]VM-0/src/lang/vc.cc
// Function: procedure(lexer&)
void procedure(lexer& lx) {
    string ident = lx.accept();
    
    if(ident != "proc") {
        lx.unaccept();
        return;
    }

    size_s starting_addr = bytecode.size();

    ident = lx.accept();

    if(symbol_table[ident].stype == SYM_FUNCTION)
        ISSUE_ERROR("Error: Redefinition of function \"%s\".", ident.c_str());

    symbol_table[ident] = { SYM_FUNCTION, ident, starting_addr };

    block(lx);

    if(ident != ENTRY_POINT) 
        bytecode.push_back({ INST_NOARGS, OPC_RET });
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c32
leaq 0x3fa9(%rip), %rsi      # 0x17fc5
movq %r14, %rdi
callq 0x40a0
testl %eax, %eax
je 0x14057
movq %rbx, %rdi
callq 0x4b32
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1404b
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x42d0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xd702(%rip), %r15      # 0x21760
subq 0xd6f3(%rip), %r15      # 0x21758
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x4c32
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x43a0
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1409e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0xd683(%rip), %rdi      # 0x21728
leaq 0x38(%rsp), %rsi
callq 0x160b6
cmpl $0x1, (%rax)
je 0x141ca
leaq 0x10(%rsp), %r14
movl $0x1, -0x8(%r14)
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x585e
sarq $0x3, %r15
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %r15, %rax
movq %rax, 0x30(%rsp)
leaq 0xd626(%rip), %rdi      # 0x21728
leaq 0x38(%rsp), %rsi
callq 0x160b6
movq %rax, %r15
movl 0x8(%rsp), %eax
movl %eax, (%r15)
movq %r15, %rdi
addq $0x8, %rdi
movq %r14, %rsi
callq 0x43a0
movq 0x30(%rsp), %rax
movq %rax, 0x28(%r15)
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x14145
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x1421e
leaq 0x3f17(%rip), %rsi      # 0x1806b
leaq 0x38(%rsp), %rdi
callq 0x40a0
testl %eax, %eax
je 0x14030
movabsq $0x2400000002, %rax     # imm = 0x2400000002
movq %rax, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0xd5d3(%rip), %rsi      # 0x21760
cmpq 0xd5d4(%rip), %rsi      # 0x21768
je 0x141b4
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x18, 0xd5b1(%rip)     # 0x21760
jmp 0x14030
leaq 0xd59d(%rip), %rdi      # 0x21758
leaq 0x8(%rsp), %rdx
callq 0x16660
jmp 0x14030
leaq 0x38(%rsp), %rdi
callq 0x477b
jmp 0x141f8
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x141fb
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x141fb
jmp 0x141f8
jmp 0x141f8
jmp 0x141f8
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14216
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O1/generot[P]VM-0/src/lang/vc.cc
// Function: block(lexer&)
void block(lexer& lx) {
    lx.expect("{");
    lx.accept();

    while(!EXPECT("}")) {
        statement(lx);

        if(lx.eof())
            ISSUE_ERROR("Expected '}', got 'eof' instead");
    }

    lx.accept();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x3e2e(%rip), %rsi      # 0x18070
leaq 0x3e28(%rip), %rdx      # 0x18071
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x59ce
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x4ab4
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1427d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0x68(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c32
movq (%r14), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x142a7
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0x18(%rsp), %r13
leaq 0x3dbf(%rip), %r14      # 0x18072
leaq 0x3db9(%rip), %r15      # 0x18073
leaq 0x8(%rsp), %r12
movq %r13, 0x8(%rsp)
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x59ce
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4ab4
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x142f8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42d0
testb %bpl, %bpl
jne 0x14316
movq %rbx, %rdi
callq 0x1437d
movq %rbx, %rdi
callq 0x4b0e
testb %al, %al
je 0x142bf
callq 0x47a2
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c32
movq (%r14), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x14340
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x42d0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
jmp 0x14364
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x14375
movq (%r13), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O1/generot[P]VM-0/src/lang/vc.cc
// Function: statement(lexer&)
void statement(lexer& lx) {
    assign(lx);
    cond_if(lx);
    cond_while(lx);
    call(lx);
    inpout(lx);

    lx.expect(";");
    lx.accept();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
callq 0x1444b
movq %rbx, %rdi
callq 0x14656
movq %rbx, %rdi
callq 0x147ab
movq %rbx, %rdi
callq 0x148e6
movq %rbx, %rdi
callq 0x14acf
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3c47(%rip), %rsi      # 0x18005
leaq 0x3c41(%rip), %rdx      # 0x18006
movq %rsp, %r14
movq %r14, %rdi
callq 0x59ce
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x4ab4
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x143f6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c32
movq (%r14), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x14420
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42d0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x14443
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O1/generot[P]VM-0/src/lang/vc.cc
// Function: assign(lexer&)
void assign(lexer& lx) {
    string ident = lx.accept();

    if(!EXPECT(":=")) {
        lx.unaccept();
        return;
    }

    symbol sym = symbol_table[ident];

    if(!sym.addr || sym.stype != SYM_VARIABLE)
        ISSUE_ERROR("Symbol \"%s\" is unreachable or unassignable.", ident.c_str());

    lx.accept();
    expr(lx);

    bytecode.push_back({ INST_ADDR, OPC_STORE, SC_INVALID, sym.addr });
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
callq 0x4c32
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3c1d(%rip), %rsi      # 0x18095
leaq 0x3c18(%rip), %rdx      # 0x18097
leaq 0x18(%rsp), %rdi
callq 0x59ce
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4ab4
movl %eax, %ebp
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x144b1
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x42d0
testb %bpl, %bpl
je 0x14597
leaq 0xd267(%rip), %rdi      # 0x21728
leaq 0x38(%rsp), %rsi
callq 0x160b6
movq %rax, %r14
movl (%rax), %eax
leaq 0x60(%rsp), %rdi
movl %eax, -0x8(%rdi)
leaq 0x70(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
callq 0x585e
movq 0x28(%r14), %rax
movq %rax, 0x80(%rsp)
testq %rax, %rax
je 0x145f0
cmpl $0x0, 0x58(%rsp)
jne 0x145f0
leaq 0x88(%rsp), %rdi
movq %rbx, %rsi
callq 0x4c32
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14542
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x14ecf
movabsq $0x1300000001, %rax     # imm = 0x1300000001
movq %rax, (%rsp)
movl $0x3, 0x8(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xd1ec(%rip), %rsi      # 0x21760
cmpq 0xd1ed(%rip), %rsi      # 0x21768
je 0x145a1
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rsi)
movups (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x18, 0xd1cb(%rip)     # 0x21760
jmp 0x145b0
movq %rbx, %rdi
callq 0x4b32
jmp 0x145c7
leaq 0xd1b0(%rip), %rdi      # 0x21758
movq %rsp, %rdx
callq 0x16660
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x145c7
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x42d0
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x145e2
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x42d0
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x38(%rsp), %rdi
callq 0x47c7
jmp 0x145fe
jmp 0x14630
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x14633
movq 0x70(%rsp), %rsi
jmp 0x14626
jmp 0x14630
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x14633
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x14633
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1464e
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O1/generot[P]VM-0/src/lang/vc.cc
// Function: cond_if(lexer&)
void cond_if(lexer& lx) {
    if(!(EXPECT("if")))
        return;

    lx.accept();
    expr(lx);

    bytecode.push_back({ INST_ADDR, OPC_JEZ, SC_INVALID, 0x0 });
    size_t curr_sz = bytecode.size() - 1;

    block(lx);
    bytecode[curr_sz].addr = (size_s)bytecode.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3a52(%rip), %rsi      # 0x180c5
leaq 0x3a4d(%rip), %rdx      # 0x180c7
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x59ce
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x4ab4
movl %eax, %ebp
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x146ad
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x42d0
testb %bpl, %bpl
je 0x1477e
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c32
movq (%r14), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x146e0
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x14ecf
movabsq $0x2200000001, %rax     # imm = 0x2200000001
movq %rax, (%rsp)
movl $0x3, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq 0xd052(%rip), %rsi      # 0x21760
cmpq 0xd053(%rip), %rsi      # 0x21768
je 0x14731
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rsi)
movups (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x18, 0xd031(%rip)     # 0x21760
jmp 0x14740
leaq 0xd020(%rip), %rdi      # 0x21758
movq %rsp, %rdx
callq 0x16660
movq 0xd019(%rip), %r14      # 0x21760
subq 0xd00a(%rip), %r14      # 0x21758
movq %rbx, %rdi
callq 0x1421e
movq 0xd003(%rip), %rax      # 0x21760
movq 0xcff4(%rip), %rcx      # 0x21758
subq %rcx, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
movq %rdx, -0x8(%rcx,%r14)
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x147a3
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x44e0