LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_s16
bool cmp_write_s16(cmp_ctx_t *ctx, int16_t s) {
  if (!write_type_marker(ctx, S16_MARKER))
    return false;

  s = be16(s);

  return ctx->write(ctx, &s, sizeof(int16_t));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x11(%rbp), %rsi
movb $-0x2f, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
cmpq $0x1, %rax
jne 0x1605
rolw $0x8, %r14w
leaq -0x14(%rbp), %rsi
movw %r14w, (%rsi)
movl $0x2, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
setne %al
jmp 0x160a
movb $0x8, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_s32
bool cmp_write_s32(cmp_ctx_t *ctx, int32_t i) {
  if (!write_type_marker(ctx, S32_MARKER))
    return false;

  i = be32(i);

  return ctx->write(ctx, &i, sizeof(int32_t));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x11(%rbp), %rsi
movb $-0x2e, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
cmpq $0x1, %rax
jne 0x1656
bswapl %r14d
leaq -0x18(%rbp), %rsi
movl %r14d, (%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
setne %al
jmp 0x165b
movb $0x8, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_s64
bool cmp_write_s64(cmp_ctx_t *ctx, int64_t l) {
  if (!write_type_marker(ctx, S64_MARKER))
    return false;

  l = be64(l);

  return ctx->write(ctx, &l, sizeof(int64_t));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x11(%rbp), %rsi
movb $-0x2d, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
cmpq $0x1, %rax
jne 0x16a7
bswapq %r14
leaq -0x20(%rbp), %rsi
movq %r14, (%rsi)
movl $0x8, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
setne %al
jmp 0x16ac
movb $0x8, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_integer
bool cmp_write_integer(cmp_ctx_t *ctx, int64_t d) {
  if (d >= 0)
    return cmp_write_uinteger(ctx, d);
  if (d >= -32)
    return cmp_write_nfix(ctx, (int8_t)d);
  if (d >= -128)
    return cmp_write_s8(ctx, (int8_t)d);
  if (d >= -32768)
    return cmp_write_s16(ctx, (int16_t)d);
  if (d >= (-2147483647 - 1))
    return cmp_write_s32(ctx, (int32_t)d);

  return cmp_write_s64(ctx, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
js 0x16d1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1757
cmpq $-0x20, %rsi
jb 0x1703
leaq -0x9(%rbp), %rax
movb %sil, (%rax)
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
cmpq $0x1, %rcx
je 0x16fc
movb $0x6, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpq $-0x80, %rsi
jb 0x171b
movsbl %sil, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x157a
cmpq $-0x8000, %rsi          # imm = 0x8000
jb 0x1735
movswl %si, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x15bf
movq %rbx, %rdi
cmpq $-0x80000000, %rsi      # imm = 0x80000000
jb 0x174c
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1613
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1664
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_uinteger
bool cmp_write_uinteger(cmp_ctx_t *ctx, uint64_t u) {
  if (u <= 0x7F)
    return cmp_write_pfix(ctx, (uint8_t)u);
  if (u <= 0xFF)
    return cmp_write_u8(ctx, (uint8_t)u);
  if (u <= 0xFFFF)
    return cmp_write_u16(ctx, (uint16_t)u);
  if (u <= 0xFFFFFFFF)
    return cmp_write_u32(ctx, (uint32_t)u);

  return cmp_write_u64(ctx, u);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x7f, %rsi
ja 0x1792
leaq -0x9(%rbp), %rax
movb %sil, (%rax)
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
cmpq $0x1, %rcx
je 0x178b
movb $0x6, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpq $0xff, %rsi
ja 0x17ad
movzbl %sil, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1828
cmpq $0xffff, %rsi           # imm = 0xFFFF
ja 0x17c7
movzwl %si, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x186d
movq %rsi, %rax
movq %rbx, %rdi
shrq $0x20, %rax
jne 0x17de
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x18c1
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1912
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_u16
bool cmp_write_u16(cmp_ctx_t *ctx, uint16_t s) {
  if (!write_type_marker(ctx, U16_MARKER))
    return false;

  s = be16(s);

  return ctx->write(ctx, &s, sizeof(uint16_t));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x11(%rbp), %rsi
movb $-0x33, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
cmpq $0x1, %rax
jne 0x18b3
rolw $0x8, %r14w
leaq -0x14(%rbp), %rsi
movw %r14w, (%rsi)
movl $0x2, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
setne %al
jmp 0x18b8
movb $0x8, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_u32
bool cmp_write_u32(cmp_ctx_t *ctx, uint32_t i) {
  if (!write_type_marker(ctx, U32_MARKER))
    return false;

  i = be32(i);

  return ctx->write(ctx, &i, sizeof(uint32_t));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x11(%rbp), %rsi
movb $-0x32, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
cmpq $0x1, %rax
jne 0x1904
bswapl %r14d
leaq -0x18(%rbp), %rsi
movl %r14d, (%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
setne %al
jmp 0x1909
movb $0x8, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_u64
bool cmp_write_u64(cmp_ctx_t *ctx, uint64_t l) {
  if (!write_type_marker(ctx, U64_MARKER))
    return false;

  l = be64(l);

  return ctx->write(ctx, &l, sizeof(uint64_t));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x11(%rbp), %rsi
movb $-0x31, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
cmpq $0x1, %rax
jne 0x1955
bswapq %r14
leaq -0x20(%rbp), %rsi
movq %r14, (%rsi)
movl $0x8, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
setne %al
jmp 0x195a
movb $0x8, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_float
bool cmp_write_float(cmp_ctx_t *ctx, float f) {
  if (!write_type_marker(ctx, FLOAT_MARKER))
    return false;

  /*
   * We may need to swap the float's bytes, but we can't just swap them inside
   * the float because the swapped bytes may not constitute a valid float.
   * Therefore, we have to create a buffer and swap the bytes there.
   */
  if (!is_bigendian()) {
    char swapped[sizeof(float)];
    char *fbuf = (char *)&f;
    size_t i;

    for (i = 0; i < sizeof(float); i++)
      swapped[i] = fbuf[sizeof(float) - i - 1];

    return ctx->write(ctx, swapped, sizeof(float));
  }

  return ctx->write(ctx, &f, sizeof(float));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movss %xmm0, -0x10(%rbp)
leaq -0x9(%rbp), %rsi
movb $-0x36, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
cmpq $0x1, %rax
jne 0x19b8
leaq -0xd(%rbp), %rax
xorl %ecx, %ecx
movb (%rax), %dl
movb %dl, -0x14(%rbp,%rcx)
incq %rcx
decq %rax
cmpq $0x4, %rcx
jne 0x198f
leaq -0x14(%rbp), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
setne %al
jmp 0x19bd
movb $0x8, (%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_double
bool cmp_write_double(cmp_ctx_t *ctx, double d) {
  if (!write_type_marker(ctx, DOUBLE_MARKER))
    return false;

  /* Same deal for doubles */
  if (!is_bigendian()) {
    char swapped[sizeof(double)];
    char *dbuf = (char *)&d;
    size_t i;

    for (i = 0; i < sizeof(double); i++)
      swapped[i] = dbuf[sizeof(double) - i - 1];

    return ctx->write(ctx, swapped, sizeof(double));
  }

  return ctx->write(ctx, &d, sizeof(double));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movsd %xmm0, -0x18(%rbp)
leaq -0x10(%rbp), %rsi
movb $-0x35, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
cmpq $0x1, %rax
jne 0x1a19
leaq -0x11(%rbp), %rax
xorl %ecx, %ecx
movb (%rax), %dl
movb %dl, -0x10(%rbp,%rcx)
incq %rcx
decq %rax
cmpq $0x8, %rcx
jne 0x19f0
leaq -0x10(%rbp), %rsi
movl $0x8, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
setne %al
jmp 0x1a1e
movb $0x8, (%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_decimal
bool cmp_write_decimal(cmp_ctx_t *ctx, double d) {
  float f = (float)d;
  double df = (double)f;

  if (df == d)
    return cmp_write_float(ctx, f);
  else
    return cmp_write_double(ctx, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cvtsd2ss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
jne 0x1a42
jp 0x1a42
movaps %xmm1, %xmm0
popq %rbp
jmp 0x1963
popq %rbp
jmp 0x19c4
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixstr_marker
bool cmp_write_fixstr_marker(cmp_ctx_t *ctx, uint8_t size) {
  if (size <= FIXSTR_SIZE)
    return write_fixed_value(ctx, FIXSTR_MARKER | size);

  ctx->error = INPUT_VALUE_TOO_LARGE_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x5, %dl
cmpb $0x1f, %sil
ja 0x1b8a
orb $-0x60, %sil
leaq -0x9(%rbp), %rax
movb %sil, (%rax)
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x6, %dl
movb $0x1, %al
cmpq $0x1, %rcx
je 0x1b8e
movb %dl, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixstr
bool cmp_write_fixstr(cmp_ctx_t *ctx, const char *data, uint8_t size) {
  if (!cmp_write_fixstr_marker(ctx, size))
    return false;

  if (size == 0)
    return true;

  if (ctx->write(ctx, data, size))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r15d
movq %rdi, %rbx
movb $0x5, %cl
cmpb $0x1f, %r15b
ja 0x1bef
movq %rsi, %r14
movl %r15d, %eax
orb $-0x60, %al
leaq -0x21(%rbp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movb $0x6, %cl
cmpq $0x1, %rax
jne 0x1bef
movb $0x1, %r12b
testb %r15b, %r15b
je 0x1bf4
movzbl %r15b, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rbx)
testq %rax, %rax
jne 0x1bf4
movb $0xa, %cl
movb %cl, (%rbx)
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_str8_marker
bool cmp_write_str8_marker(cmp_ctx_t *ctx, uint8_t size) {
  if (!write_type_marker(ctx, STR8_MARKER))
    return false;

  if (ctx->write(ctx, &size, sizeof(uint8_t)))
    return true;

  ctx->error = LENGTH_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb %sil, -0x9(%rbp)
leaq -0xa(%rbp), %rsi
movb $-0x27, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x1c43
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x1c47
movb $0xf, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_str8
bool cmp_write_str8(cmp_ctx_t *ctx, const char *data, uint8_t size) {
  if (!cmp_write_str8_marker(ctx, size))
    return false;

  if (size == 0)
    return true;

  if (ctx->write(ctx, data, size))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
movl %edx, %esi
callq 0x1c04
testb %al, %al
je 0x1c8a
movb $0x1, %r14b
testb %r12b, %r12b
je 0x1c8d
movzbl %r12b, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq *0x20(%rbx)
testq %rax, %rax
jne 0x1c8d
movb $0xa, (%rbx)
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_str16_marker
bool cmp_write_str16_marker(cmp_ctx_t *ctx, uint16_t size) {
  if (!write_type_marker(ctx, STR16_MARKER))
    return false;

  size = be16(size);

  if (ctx->write(ctx, &size, sizeof(uint16_t)))
    return true;

  ctx->error = LENGTH_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x11(%rbp), %rsi
movb $-0x26, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x1ce5
rolw $0x8, %r14w
leaq -0x14(%rbp), %rsi
movw %r14w, (%rsi)
movl $0x2, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x1ce9
movb $0xf, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_str16
bool cmp_write_str16(cmp_ctx_t *ctx, const char *data, uint16_t size) {
  if (!cmp_write_str16_marker(ctx, size))
    return false;

  if (size == 0)
    return true;

  if (ctx->write(ctx, data, size))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
movl %edx, %esi
callq 0x1c99
testb %al, %al
je 0x1d2f
movb $0x1, %r14b
testw %r12w, %r12w
je 0x1d32
movzwl %r12w, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq *0x20(%rbx)
testq %rax, %rax
jne 0x1d32
movb $0xa, (%rbx)
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_str32_marker
bool cmp_write_str32_marker(cmp_ctx_t *ctx, uint32_t size) {
  if (!write_type_marker(ctx, STR32_MARKER))
    return false;

  size = be32(size);

  if (ctx->write(ctx, &size, sizeof(uint32_t)))
    return true;

  ctx->error = LENGTH_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x11(%rbp), %rsi
movb $-0x25, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x1d87
bswapl %r14d
leaq -0x18(%rbp), %rsi
movl %r14d, (%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x1d8b
movb $0xf, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_str32
bool cmp_write_str32(cmp_ctx_t *ctx, const char *data, uint32_t size) {
  if (!cmp_write_str32_marker(ctx, size))
    return false;

  if (size == 0)
    return true;

  if (ctx->write(ctx, data, size))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %r14
movl %edx, %esi
callq 0x1d3e
testb %al, %al
je 0x1dd0
movb $0x1, %bl
testl %r12d, %r12d
je 0x1dd2
movl %r12d, %edx
movq %r14, %rdi
movq %r15, %rsi
callq *0x20(%r14)
testq %rax, %rax
jne 0x1dd2
movb $0xa, (%r14)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_str_marker
bool cmp_write_str_marker(cmp_ctx_t *ctx, uint32_t size) {
  if (size <= FIXSTR_SIZE)
    return cmp_write_fixstr_marker(ctx, (uint8_t)size);
  if (size <= 0xFF)
    return cmp_write_str8_marker(ctx, (uint8_t)size);
  if (size <= 0xFFFF)
    return cmp_write_str16_marker(ctx, (uint16_t)size);

  return cmp_write_str32_marker(ctx, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1f, %esi
ja 0x1e1b
orb $-0x60, %sil
leaq -0x9(%rbp), %rax
movb %sil, (%rax)
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
cmpq $0x1, %rcx
je 0x1e14
movb $0x6, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpl $0xff, %esi
ja 0x1e35
movzbl %sil, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1c04
cmpl $0xffff, %esi           # imm = 0xFFFF
ja 0x1e4e
movzwl %si, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1c99
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1d3e
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_str_marker_v4
bool cmp_write_str_marker_v4(cmp_ctx_t *ctx, uint32_t size) {
  if (size <= FIXSTR_SIZE)
    return cmp_write_fixstr_marker(ctx, (uint8_t)size);
  if (size <= 0xFFFF)
    return cmp_write_str16_marker(ctx, (uint16_t)size);

  return cmp_write_str32_marker(ctx, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1f, %esi
ja 0x1e9a
orb $-0x60, %sil
leaq -0x9(%rbp), %rax
movb %sil, (%rax)
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
cmpq $0x1, %rcx
je 0x1e93
movb $0x6, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpl $0xffff, %esi           # imm = 0xFFFF
ja 0x1eb3
movzwl %si, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1c99
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1d3e
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_str
bool cmp_write_str(cmp_ctx_t *ctx, const char *data, uint32_t size) {
  if (size <= FIXSTR_SIZE)
    return cmp_write_fixstr(ctx, data, (uint8_t)size);
  if (size <= 0xFF)
    return cmp_write_str8(ctx, data, (uint8_t)size);
  if (size <= 0xFFFF)
    return cmp_write_str16(ctx, data, (uint16_t)size);

  return cmp_write_str32(ctx, data, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x1f, %edx
ja 0x1ed3
movzbl %dl, %edx
popq %rbp
jmp 0x1b95
cmpl $0xff, %edx
ja 0x1ee4
movzbl %dl, %edx
popq %rbp
jmp 0x1c4e
cmpl $0xffff, %edx           # imm = 0xFFFF
ja 0x1ef5
movzwl %dx, %edx
popq %rbp
jmp 0x1cf2
popq %rbp
jmp 0x1d94
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_str_v4
bool cmp_write_str_v4(cmp_ctx_t *ctx, const char *data, uint32_t size) {
  if (size <= FIXSTR_SIZE)
    return cmp_write_fixstr(ctx, data, (uint8_t)size);
  if (size <= 0xFFFF)
    return cmp_write_str16(ctx, data, (uint16_t)size);

  return cmp_write_str32(ctx, data, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x1f, %edx
ja 0x1f0d
movzbl %dl, %edx
popq %rbp
jmp 0x1b95
cmpl $0xffff, %edx           # imm = 0xFFFF
ja 0x1f1e
movzwl %dx, %edx
popq %rbp
jmp 0x1cf2
popq %rbp
jmp 0x1d94
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_bin8
bool cmp_write_bin8(cmp_ctx_t *ctx, const void *data, uint8_t size) {
  if (!cmp_write_bin8_marker(ctx, size))
    return false;

  if (size == 0)
    return true;

  if (ctx->write(ctx, data, size))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
movl %edx, %esi
callq 0x1f24
testb %al, %al
je 0x1faa
movb $0x1, %r14b
testb %r12b, %r12b
je 0x1fad
movzbl %r12b, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq *0x20(%rbx)
testq %rax, %rax
jne 0x1fad
movb $0xa, (%rbx)
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_bin16_marker
bool cmp_write_bin16_marker(cmp_ctx_t *ctx, uint16_t size) {
  if (!write_type_marker(ctx, BIN16_MARKER))
    return false;

  size = be16(size);

  if (ctx->write(ctx, &size, sizeof(uint16_t)))
    return true;

  ctx->error = LENGTH_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x11(%rbp), %rsi
movb $-0x3b, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x2005
rolw $0x8, %r14w
leaq -0x14(%rbp), %rsi
movw %r14w, (%rsi)
movl $0x2, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2009
movb $0xf, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_bin16
bool cmp_write_bin16(cmp_ctx_t *ctx, const void *data, uint16_t size) {
  if (!cmp_write_bin16_marker(ctx, size))
    return false;

  if (size == 0)
    return true;

  if (ctx->write(ctx, data, size))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
movl %edx, %esi
callq 0x1fb9
testb %al, %al
je 0x204f
movb $0x1, %r14b
testw %r12w, %r12w
je 0x2052
movzwl %r12w, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq *0x20(%rbx)
testq %rax, %rax
jne 0x2052
movb $0xa, (%rbx)
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_bin32_marker
bool cmp_write_bin32_marker(cmp_ctx_t *ctx, uint32_t size) {
  if (!write_type_marker(ctx, BIN32_MARKER))
    return false;

  size = be32(size);

  if (ctx->write(ctx, &size, sizeof(uint32_t)))
    return true;

  ctx->error = LENGTH_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x11(%rbp), %rsi
movb $-0x3a, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x20a7
bswapl %r14d
leaq -0x18(%rbp), %rsi
movl %r14d, (%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x20ab
movb $0xf, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_bin32
bool cmp_write_bin32(cmp_ctx_t *ctx, const void *data, uint32_t size) {
  if (!cmp_write_bin32_marker(ctx, size))
    return false;

  if (size == 0)
    return true;

  if (ctx->write(ctx, data, size))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %r14
movl %edx, %esi
callq 0x205e
testb %al, %al
je 0x20f0
movb $0x1, %bl
testl %r12d, %r12d
je 0x20f2
movl %r12d, %edx
movq %r14, %rdi
movq %r15, %rsi
callq *0x20(%r14)
testq %rax, %rax
jne 0x20f2
movb $0xa, (%r14)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_bin_marker
bool cmp_write_bin_marker(cmp_ctx_t *ctx, uint32_t size) {
  if (size <= 0xFF)
    return cmp_write_bin8_marker(ctx, (uint8_t)size);
  if (size <= 0xFFFF)
    return cmp_write_bin16_marker(ctx, (uint16_t)size);

  return cmp_write_bin32_marker(ctx, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0xff, %esi
ja 0x2113
movzbl %sil, %esi
popq %rbp
jmp 0x1f24
cmpl $0xffff, %esi           # imm = 0xFFFF
ja 0x2124
movzwl %si, %esi
popq %rbp
jmp 0x1fb9
popq %rbp
jmp 0x205e
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_bin
bool cmp_write_bin(cmp_ctx_t *ctx, const void *data, uint32_t size) {
  if (size <= 0xFF)
    return cmp_write_bin8(ctx, data, (uint8_t)size);
  if (size <= 0xFFFF)
    return cmp_write_bin16(ctx, data, (uint16_t)size);

  return cmp_write_bin32(ctx, data, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0xff, %edx
ja 0x213f
movzbl %dl, %edx
popq %rbp
jmp 0x1f6e
cmpl $0xffff, %edx           # imm = 0xFFFF
ja 0x2150
movzwl %dx, %edx
popq %rbp
jmp 0x2012
popq %rbp
jmp 0x20b4
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixarray
bool cmp_write_fixarray(cmp_ctx_t *ctx, uint8_t size) {
  if (size <= FIXARRAY_SIZE)
    return write_fixed_value(ctx, FIXARRAY_MARKER | size);

  ctx->error = INPUT_VALUE_TOO_LARGE_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x5, %dl
cmpb $0xf, %sil
ja 0x218d
orb $-0x70, %sil
leaq -0x9(%rbp), %rax
movb %sil, (%rax)
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x6, %dl
movb $0x1, %al
cmpq $0x1, %rcx
je 0x2191
movb %dl, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_array16
bool cmp_write_array16(cmp_ctx_t *ctx, uint16_t size) {
  if (!write_type_marker(ctx, ARRAY16_MARKER))
    return false;

  size = be16(size);

  if (ctx->write(ctx, &size, sizeof(uint16_t)))
    return true;

  ctx->error = LENGTH_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x11(%rbp), %rsi
movb $-0x24, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x21e4
rolw $0x8, %r14w
leaq -0x14(%rbp), %rsi
movw %r14w, (%rsi)
movl $0x2, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x21e8
movb $0xf, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_array32
bool cmp_write_array32(cmp_ctx_t *ctx, uint32_t size) {
  if (!write_type_marker(ctx, ARRAY32_MARKER))
    return false;

  size = be32(size);

  if (ctx->write(ctx, &size, sizeof(uint32_t)))
    return true;

  ctx->error = LENGTH_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x11(%rbp), %rsi
movb $-0x23, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x223a
bswapl %r14d
leaq -0x18(%rbp), %rsi
movl %r14d, (%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x223e
movb $0xf, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_array
bool cmp_write_array(cmp_ctx_t *ctx, uint32_t size) {
  if (size <= FIXARRAY_SIZE)
    return cmp_write_fixarray(ctx, (uint8_t)size);
  if (size <= 0xFFFF)
    return cmp_write_array16(ctx, (uint16_t)size);

  return cmp_write_array32(ctx, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0xf, %esi
ja 0x2285
orb $-0x70, %sil
leaq -0x9(%rbp), %rax
movb %sil, (%rax)
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
cmpq $0x1, %rcx
je 0x227e
movb $0x6, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpl $0xffff, %esi           # imm = 0xFFFF
ja 0x229e
movzwl %si, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2198
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21f1
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixmap
bool cmp_write_fixmap(cmp_ctx_t *ctx, uint8_t size) {
  if (size <= FIXMAP_SIZE)
    return write_fixed_value(ctx, FIXMAP_MARKER | size);

  ctx->error = INPUT_VALUE_TOO_LARGE_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x5, %dl
cmpb $0xf, %sil
ja 0x22e3
orb $-0x80, %sil
leaq -0x9(%rbp), %rax
movb %sil, (%rax)
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x6, %dl
movb $0x1, %al
cmpq $0x1, %rcx
je 0x22e7
movb %dl, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_map16
bool cmp_write_map16(cmp_ctx_t *ctx, uint16_t size) {
  if (!write_type_marker(ctx, MAP16_MARKER))
    return false;

  size = be16(size);

  if (ctx->write(ctx, &size, sizeof(uint16_t)))
    return true;

  ctx->error = LENGTH_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x11(%rbp), %rsi
movb $-0x22, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x233a
rolw $0x8, %r14w
leaq -0x14(%rbp), %rsi
movw %r14w, (%rsi)
movl $0x2, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x233e
movb $0xf, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_map32
bool cmp_write_map32(cmp_ctx_t *ctx, uint32_t size) {
  if (!write_type_marker(ctx, MAP32_MARKER))
    return false;

  size = be32(size);

  if (ctx->write(ctx, &size, sizeof(uint32_t)))
    return true;

  ctx->error = LENGTH_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x11(%rbp), %rsi
movb $-0x21, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x2390
bswapl %r14d
leaq -0x18(%rbp), %rsi
movl %r14d, (%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2394
movb $0xf, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_map
bool cmp_write_map(cmp_ctx_t *ctx, uint32_t size) {
  if (size <= FIXMAP_SIZE)
    return cmp_write_fixmap(ctx, (uint8_t)size);
  if (size <= 0xFFFF)
    return cmp_write_map16(ctx, (uint16_t)size);

  return cmp_write_map32(ctx, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0xf, %esi
ja 0x23db
orb $-0x80, %sil
leaq -0x9(%rbp), %rax
movb %sil, (%rax)
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
cmpq $0x1, %rcx
je 0x23d4
movb $0x6, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpl $0xffff, %esi           # imm = 0xFFFF
ja 0x23f4
movzwl %si, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x22ee
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2347
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixext1_marker
bool cmp_write_fixext1_marker(cmp_ctx_t *ctx, int8_t type) {
  if (!write_type_marker(ctx, FIXEXT1_MARKER))
    return false;

  if (ctx->write(ctx, &type, sizeof(int8_t)))
    return true;

  ctx->error = EXT_TYPE_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb %sil, -0x9(%rbp)
leaq -0xa(%rbp), %rsi
movb $-0x2c, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x2441
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2445
movb $0xc, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixext1
bool cmp_write_fixext1(cmp_ctx_t *ctx, int8_t type, const void *data) {
  if (!cmp_write_fixext1_marker(ctx, type))
    return false;

  if (ctx->write(ctx, data, 1))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x2402
testb %al, %al
je 0x247d
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x247f
movb $0xa, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixext2_marker
bool cmp_write_fixext2_marker(cmp_ctx_t *ctx, int8_t type) {
  if (!write_type_marker(ctx, FIXEXT2_MARKER))
    return false;

  if (ctx->write(ctx, &type, sizeof(int8_t)))
    return true;

  ctx->error = EXT_TYPE_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb %sil, -0x9(%rbp)
leaq -0xa(%rbp), %rsi
movb $-0x2b, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x24c3
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x24c7
movb $0xc, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixext2
bool cmp_write_fixext2(cmp_ctx_t *ctx, int8_t type, const void *data) {
  if (!cmp_write_fixext2_marker(ctx, type))
    return false;

  if (ctx->write(ctx, data, 2))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x2484
testb %al, %al
je 0x24ff
movl $0x2, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2501
movb $0xa, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixext4_marker
bool cmp_write_fixext4_marker(cmp_ctx_t *ctx, int8_t type) {
  if (!write_type_marker(ctx, FIXEXT4_MARKER))
    return false;

  if (ctx->write(ctx, &type, sizeof(int8_t)))
    return true;

  ctx->error = EXT_TYPE_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb %sil, -0x9(%rbp)
leaq -0xa(%rbp), %rsi
movb $-0x2a, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x2545
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2549
movb $0xc, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixext4
bool cmp_write_fixext4(cmp_ctx_t *ctx, int8_t type, const void *data) {
  if (!cmp_write_fixext4_marker(ctx, type))
    return false;

  if (ctx->write(ctx, data, 4))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x2506
testb %al, %al
je 0x2581
movl $0x4, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2583
movb $0xa, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixext8_marker
bool cmp_write_fixext8_marker(cmp_ctx_t *ctx, int8_t type) {
  if (!write_type_marker(ctx, FIXEXT8_MARKER))
    return false;

  if (ctx->write(ctx, &type, sizeof(int8_t)))
    return true;

  ctx->error = EXT_TYPE_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb %sil, -0x9(%rbp)
leaq -0xa(%rbp), %rsi
movb $-0x29, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x25c7
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x25cb
movb $0xc, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixext8
bool cmp_write_fixext8(cmp_ctx_t *ctx, int8_t type, const void *data) {
  if (!cmp_write_fixext8_marker(ctx, type))
    return false;

  if (ctx->write(ctx, data, 8))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x2588
testb %al, %al
je 0x2603
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2605
movb $0xa, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixext16_marker
bool cmp_write_fixext16_marker(cmp_ctx_t *ctx, int8_t type) {
  if (!write_type_marker(ctx, FIXEXT16_MARKER))
    return false;

  if (ctx->write(ctx, &type, sizeof(int8_t)))
    return true;

  ctx->error = EXT_TYPE_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb %sil, -0x9(%rbp)
leaq -0xa(%rbp), %rsi
movb $-0x28, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x2649
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x264d
movb $0xc, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixext16
bool cmp_write_fixext16(cmp_ctx_t *ctx, int8_t type, const void *data) {
  if (!cmp_write_fixext16_marker(ctx, type))
    return false;

  if (ctx->write(ctx, data, 16))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x260a
testb %al, %al
je 0x2685
movl $0x10, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2687
movb $0xa, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_ext8_marker
bool cmp_write_ext8_marker(cmp_ctx_t *ctx, int8_t type, uint8_t size) {
  if (!write_type_marker(ctx, EXT8_MARKER))
    return false;

  if (!ctx->write(ctx, &size, sizeof(uint8_t))) {
    ctx->error = LENGTH_WRITING_ERROR;
    return false;
  }

  if (ctx->write(ctx, &type, sizeof(int8_t)))
    return true;

  ctx->error = EXT_TYPE_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb %sil, -0xa(%rbp)
movb %dl, -0x9(%rbp)
leaq -0xb(%rbp), %rsi
movb $-0x39, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x26e6
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
je 0x26e4
leaq -0xa(%rbp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x26ea
movb $0xc, %cl
jmp 0x26e6
movb $0xf, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_ext8
bool cmp_write_ext8(cmp_ctx_t *ctx, int8_t tp, uint8_t sz, const void *data) {
  if (!cmp_write_ext8_marker(ctx, tp, sz))
    return false;

  if (ctx->write(ctx, data, sz))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %r15d
movq %rdi, %rbx
callq 0x268c
testb %al, %al
je 0x2727
movzbl %r15b, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2729
movb $0xa, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_ext16_marker
bool cmp_write_ext16_marker(cmp_ctx_t *ctx, int8_t type, uint16_t size) {
  if (!write_type_marker(ctx, EXT16_MARKER))
    return false;

  size = be16(size);

  if (!ctx->write(ctx, &size, sizeof(uint16_t))) {
    ctx->error = LENGTH_WRITING_ERROR;
    return false;
  }

  if (ctx->write(ctx, &type, sizeof(int8_t)))
    return true;

  ctx->error = EXT_TYPE_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movq %rdi, %rbx
movb %sil, -0x11(%rbp)
leaq -0x12(%rbp), %rsi
movb $-0x38, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x279c
rolw $0x8, %r14w
leaq -0x14(%rbp), %rsi
movw %r14w, (%rsi)
movl $0x2, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
je 0x279a
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x27a0
movb $0xc, %cl
jmp 0x279c
movb $0xf, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_ext16
bool cmp_write_ext16(cmp_ctx_t *ctx, int8_t tp, uint16_t sz, const void *data) {
  if (!cmp_write_ext16_marker(ctx, tp, sz))
    return false;

  if (ctx->write(ctx, data, sz))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %r15d
movq %rdi, %rbx
callq 0x2734
testb %al, %al
je 0x27df
movzwl %r15w, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x27e1
movb $0xa, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_ext32_marker
bool cmp_write_ext32_marker(cmp_ctx_t *ctx, int8_t type, uint32_t size) {
  if (!write_type_marker(ctx, EXT32_MARKER))
    return false;

  size = be32(size);

  if (!ctx->write(ctx, &size, sizeof(uint32_t))) {
    ctx->error = LENGTH_WRITING_ERROR;
    return false;
  }

  if (ctx->write(ctx, &type, sizeof(int8_t)))
    return true;

  ctx->error = EXT_TYPE_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movq %rdi, %rbx
movb %sil, -0x11(%rbp)
leaq -0x12(%rbp), %rsi
movb $-0x37, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x2851
bswapl %r14d
leaq -0x18(%rbp), %rsi
movl %r14d, (%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
je 0x284f
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2855
movb $0xc, %cl
jmp 0x2851
movb $0xf, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_ext32
bool cmp_write_ext32(cmp_ctx_t *ctx, int8_t tp, uint32_t sz, const void *data) {
  if (!cmp_write_ext32_marker(ctx, tp, sz))
    return false;

  if (ctx->write(ctx, data, sz))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %r15d
movq %rdi, %rbx
callq 0x27ec
testb %al, %al
je 0x2893
movl %r15d, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2895
movb $0xa, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_ext_marker
bool cmp_write_ext_marker(cmp_ctx_t *ctx, int8_t tp, uint32_t sz) {
  if (sz == 1)
    return cmp_write_fixext1_marker(ctx, tp);
  if (sz == 2)
    return cmp_write_fixext2_marker(ctx, tp);
  if (sz == 4)
    return cmp_write_fixext4_marker(ctx, tp);
  if (sz == 8)
    return cmp_write_fixext8_marker(ctx, tp);
  if (sz == 16)
    return cmp_write_fixext16_marker(ctx, tp);
  if (sz <= 0xFF)
    return cmp_write_ext8_marker(ctx, tp, (uint8_t)sz);
  if (sz <= 0xFFFF)
    return cmp_write_ext16_marker(ctx, tp, (uint16_t)sz);

  return cmp_write_ext32_marker(ctx, tp, sz);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal -0x1(%rdx), %eax
cmpl $0x7, %eax
ja 0x28c6
leaq 0x3791(%rip), %rcx      # 0x6044
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsbl %sil, %esi
popq %rbp
jmp 0x2402
cmpl $0x10, %edx
jne 0x28d5
movsbl %sil, %esi
popq %rbp
jmp 0x260a
movsbl %sil, %esi
cmpl $0xff, %edx
ja 0x2908
movzbl %dl, %edx
popq %rbp
jmp 0x268c
movsbl %sil, %esi
popq %rbp
jmp 0x2506
movsbl %sil, %esi
popq %rbp
jmp 0x2588
movsbl %sil, %esi
popq %rbp
jmp 0x2484
cmpl $0xffff, %edx           # imm = 0xFFFF
ja 0x2919
movzwl %dx, %edx
popq %rbp
jmp 0x2734
popq %rbp
jmp 0x27ec
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_ext
bool cmp_write_ext(cmp_ctx_t *ctx, int8_t tp, uint32_t sz, const void *data) {
  if (sz == 1)
    return cmp_write_fixext1(ctx, tp, data);
  if (sz == 2)
    return cmp_write_fixext2(ctx, tp, data);
  if (sz == 4)
    return cmp_write_fixext4(ctx, tp, data);
  if (sz == 8)
    return cmp_write_fixext8(ctx, tp, data);
  if (sz == 16)
    return cmp_write_fixext16(ctx, tp, data);
  if (sz <= 0xFF)
    return cmp_write_ext8(ctx, tp, (uint8_t)sz, data);
  if (sz <= 0xFFFF)
    return cmp_write_ext16(ctx, tp, (uint16_t)sz, data);

  return cmp_write_ext32(ctx, tp, sz, data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %r15d
movq %rdi, %rbx
leal -0x1(%r15), %eax
cmpl $0x7, %eax
ja 0x2969
leaq 0x3722(%rip), %rcx      # 0x6064
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsbl %sil, %esi
movq %rbx, %rdi
callq 0x2402
testb %al, %al
je 0x2a2c
movl $0x1, %edx
jmp 0x2a16
cmpl $0x10, %r15d
jne 0x298d
movsbl %sil, %esi
movq %rbx, %rdi
callq 0x260a
testb %al, %al
je 0x2a2c
movl $0x10, %edx
jmp 0x2a16
movsbl %sil, %esi
cmpl $0xff, %r15d
ja 0x29ed
movzbl %r15b, %edx
movq %rbx, %rdi
callq 0x268c
jmp 0x2a0f
movsbl %sil, %esi
movq %rbx, %rdi
callq 0x2506
testb %al, %al
je 0x2a2c
movl $0x4, %edx
jmp 0x2a16
movsbl %sil, %esi
movq %rbx, %rdi
callq 0x2588
testb %al, %al
je 0x2a2c
movl $0x8, %edx
jmp 0x2a16
movsbl %sil, %esi
movq %rbx, %rdi
callq 0x2484
testb %al, %al
je 0x2a2c
movl $0x2, %edx
jmp 0x2a16
cmpl $0xffff, %r15d          # imm = 0xFFFF
ja 0x2a04
movzwl %r15w, %edx
movq %rbx, %rdi
callq 0x2734
jmp 0x2a0f
movq %rbx, %rdi
movl %r15d, %edx
callq 0x27ec
testb %al, %al
je 0x2a2c
movl %r15d, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2a2e
movb $0xa, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq