LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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)
movl $0xd9, %esi
callq 0x14b6
testb %al, %al
je 0x1933
leaq -0x9(%rbp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x1935
movb $0xf, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x18fe
testb %al, %al
je 0x1978
movb $0x1, %r14b
testb %r12b, %r12b
je 0x197b
movzbl %r12b, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq *0x20(%rbx)
testq %rax, %rax
jne 0x197b
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_O2/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
movl $0xda, %esi
callq 0x14b6
testb %al, %al
je 0x19c9
rolw $0x8, %r14w
leaq -0x12(%rbp), %rsi
movw %r14w, (%rsi)
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x19cb
movb $0xf, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1987
testb %al, %al
je 0x1a11
movb $0x1, %r14b
testw %r12w, %r12w
je 0x1a14
movzwl %r12w, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq *0x20(%rbx)
testq %rax, %rax
jne 0x1a14
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_O2/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
movl $0xdb, %esi
callq 0x14b6
testb %al, %al
je 0x1a5f
bswapl %r14d
leaq -0x14(%rbp), %rsi
movl %r14d, (%rsi)
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x1a61
movb $0xf, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1a20
testb %al, %al
je 0x1aa6
movb $0x1, %bl
testl %r12d, %r12d
je 0x1aa8
movl %r12d, %edx
movq %r14, %rdi
movq %r15, %rsi
callq *0x20(%r14)
testq %rax, %rax
jne 0x1aa8
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_O2/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
cmpl $0x1f, %esi
ja 0x1ac6
movzbl %sil, %esi
popq %rbp
jmp 0x1894
cmpl $0xff, %esi
ja 0x1ad8
movzbl %sil, %esi
popq %rbp
jmp 0x18fe
cmpl $0xffff, %esi           # imm = 0xFFFF
ja 0x1ae9
movzwl %si, %esi
popq %rbp
jmp 0x1987
popq %rbp
jmp 0x1a20
// File: /workspace/github_c_makefile_star2_O2/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
cmpl $0x1f, %esi
ja 0x1b02
movzbl %sil, %esi
popq %rbp
jmp 0x1894
cmpl $0xffff, %esi           # imm = 0xFFFF
ja 0x1b13
movzwl %si, %esi
popq %rbp
jmp 0x1987
popq %rbp
jmp 0x1a20
// File: /workspace/github_c_makefile_star2_O2/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 0x1b2b
movzbl %dl, %edx
popq %rbp
jmp 0x18b3
cmpl $0xff, %edx
ja 0x1b3c
movzbl %dl, %edx
popq %rbp
jmp 0x193c
cmpl $0xffff, %edx           # imm = 0xFFFF
ja 0x1b4d
movzwl %dx, %edx
popq %rbp
jmp 0x19d4
popq %rbp
jmp 0x1a6a
// File: /workspace/github_c_makefile_star2_O2/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 0x1b65
movzbl %dl, %edx
popq %rbp
jmp 0x18b3
cmpl $0xffff, %edx           # imm = 0xFFFF
ja 0x1b76
movzwl %dx, %edx
popq %rbp
jmp 0x19d4
popq %rbp
jmp 0x1a6a
// File: /workspace/github_c_makefile_star2_O2/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_bin8_marker
bool cmp_write_bin8_marker(cmp_ctx_t *ctx, uint8_t size) {
  if (!write_type_marker(ctx, BIN8_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)
movl $0xc4, %esi
callq 0x14b6
testb %al, %al
je 0x1bb1
leaq -0x9(%rbp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x1bb3
movb $0xf, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1b7c
testb %al, %al
je 0x1bf6
movb $0x1, %r14b
testb %r12b, %r12b
je 0x1bf9
movzbl %r12b, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq *0x20(%rbx)
testq %rax, %rax
jne 0x1bf9
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_O2/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
movl $0xc5, %esi
callq 0x14b6
testb %al, %al
je 0x1c47
rolw $0x8, %r14w
leaq -0x12(%rbp), %rsi
movw %r14w, (%rsi)
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x1c49
movb $0xf, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1c05
testb %al, %al
je 0x1c8f
movb $0x1, %r14b
testw %r12w, %r12w
je 0x1c92
movzwl %r12w, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq *0x20(%rbx)
testq %rax, %rax
jne 0x1c92
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_O2/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
movl $0xc6, %esi
callq 0x14b6
testb %al, %al
je 0x1cdd
bswapl %r14d
leaq -0x14(%rbp), %rsi
movl %r14d, (%rsi)
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x1cdf
movb $0xf, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1c9e
testb %al, %al
je 0x1d24
movb $0x1, %bl
testl %r12d, %r12d
je 0x1d26
movl %r12d, %edx
movq %r14, %rdi
movq %r15, %rsi
callq *0x20(%r14)
testq %rax, %rax
jne 0x1d26
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_O2/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 0x1d47
movzbl %sil, %esi
popq %rbp
jmp 0x1b7c
cmpl $0xffff, %esi           # imm = 0xFFFF
ja 0x1d58
movzwl %si, %esi
popq %rbp
jmp 0x1c05
popq %rbp
jmp 0x1c9e
// File: /workspace/github_c_makefile_star2_O2/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 0x1d73
movzbl %dl, %edx
popq %rbp
jmp 0x1bba
cmpl $0xffff, %edx           # imm = 0xFFFF
ja 0x1d84
movzwl %dx, %edx
popq %rbp
jmp 0x1c52
popq %rbp
jmp 0x1ce8
// File: /workspace/github_c_makefile_star2_O2/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
cmpb $0xf, %sil
ja 0x1da2
orb $-0x70, %sil
movzbl %sil, %esi
popq %rbp
jmp 0x140b
movb $0x5, (%rdi)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl $0xdc, %esi
callq 0x14b6
testb %al, %al
je 0x1deb
rolw $0x8, %r14w
leaq -0x12(%rbp), %rsi
movw %r14w, (%rsi)
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x1ded
movb $0xf, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl $0xdd, %esi
callq 0x14b6
testb %al, %al
je 0x1e35
bswapl %r14d
leaq -0x14(%rbp), %rsi
movl %r14d, (%rsi)
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x1e37
movb $0xf, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpl $0xf, %esi
ja 0x1e53
movzbl %sil, %esi
popq %rbp
jmp 0x1d8a
cmpl $0xffff, %esi           # imm = 0xFFFF
ja 0x1e64
movzwl %si, %esi
popq %rbp
jmp 0x1da9
popq %rbp
jmp 0x1df6
// File: /workspace/github_c_makefile_star2_O2/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
cmpb $0xf, %sil
ja 0x1e82
orb $-0x80, %sil
movzbl %sil, %esi
popq %rbp
jmp 0x140b
movb $0x5, (%rdi)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl $0xde, %esi
callq 0x14b6
testb %al, %al
je 0x1ecb
rolw $0x8, %r14w
leaq -0x12(%rbp), %rsi
movw %r14w, (%rsi)
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x1ecd
movb $0xf, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl $0xdf, %esi
callq 0x14b6
testb %al, %al
je 0x1f15
bswapl %r14d
leaq -0x14(%rbp), %rsi
movl %r14d, (%rsi)
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x1f17
movb $0xf, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpl $0xf, %esi
ja 0x1f33
movzbl %sil, %esi
popq %rbp
jmp 0x1e6a
cmpl $0xffff, %esi           # imm = 0xFFFF
ja 0x1f44
movzwl %si, %esi
popq %rbp
jmp 0x1e89
popq %rbp
jmp 0x1ed6
// File: /workspace/github_c_makefile_star2_O2/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)
movl $0xd4, %esi
callq 0x14b6
testb %al, %al
je 0x1f7f
leaq -0x9(%rbp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x1f81
movb $0xc, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1f4a
testb %al, %al
je 0x1fb7
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x1fb9
movb $0xa, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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)
movl $0xd5, %esi
callq 0x14b6
testb %al, %al
je 0x1ff3
leaq -0x9(%rbp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x1ff5
movb $0xc, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1fbe
testb %al, %al
je 0x202b
pushq $0x2
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x202d
movb $0xa, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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)
movl $0xd6, %esi
callq 0x14b6
testb %al, %al
je 0x2067
leaq -0x9(%rbp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2069
movb $0xc, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2032
testb %al, %al
je 0x209f
pushq $0x4
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x20a1
movb $0xa, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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)
movl $0xd7, %esi
callq 0x14b6
testb %al, %al
je 0x20db
leaq -0x9(%rbp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x20dd
movb $0xc, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x20a6
testb %al, %al
je 0x2113
pushq $0x8
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2115
movb $0xa, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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)
movl $0xd8, %esi
callq 0x14b6
testb %al, %al
je 0x214f
leaq -0x9(%rbp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2151
movb $0xc, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x211a
testb %al, %al
je 0x2187
pushq $0x10
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2189
movb $0xa, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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)
movl $0xc7, %esi
callq 0x14b6
testb %al, %al
je 0x21dd
leaq -0x9(%rbp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
je 0x21d9
leaq -0xa(%rbp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x21df
movb $0xc, %al
jmp 0x21db
movb $0xf, %al
movb %al, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x218e
testb %al, %al
je 0x221c
movzbl %r15b, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x221e
movb $0xa, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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)
movl $0xc8, %esi
callq 0x14b6
testb %al, %al
je 0x2286
rolw $0x8, %r14w
leaq -0x14(%rbp), %rsi
movw %r14w, (%rsi)
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
je 0x2282
leaq -0x11(%rbp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2288
movb $0xc, %al
jmp 0x2284
movb $0xf, %al
movb %al, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2229
testb %al, %al
je 0x22c7
movzwl %r15w, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x22c9
movb $0xa, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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)
movl $0xc9, %esi
callq 0x14b6
testb %al, %al
je 0x232e
bswapl %r14d
leaq -0x18(%rbp), %rsi
movl %r14d, (%rsi)
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
je 0x232a
leaq -0x11(%rbp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2330
movb $0xc, %al
jmp 0x232c
movb $0xf, %al
movb %al, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x22d4
testb %al, %al
je 0x236e
movl %r15d, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2370
movb $0xa, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x23a1
leaq 0x2cb6(%rip), %rcx      # 0x5044
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsbl %sil, %esi
popq %rbp
jmp 0x1f4a
cmpl $0x10, %edx
jne 0x23b0
movsbl %sil, %esi
popq %rbp
jmp 0x211a
movsbl %sil, %esi
cmpl $0xff, %edx
ja 0x23e3
movzbl %dl, %edx
popq %rbp
jmp 0x218e
movsbl %sil, %esi
popq %rbp
jmp 0x2032
movsbl %sil, %esi
popq %rbp
jmp 0x20a6
movsbl %sil, %esi
popq %rbp
jmp 0x1fbe
cmpl $0xffff, %edx           # imm = 0xFFFF
ja 0x23f4
movzwl %dx, %edx
popq %rbp
jmp 0x2229
popq %rbp
jmp 0x22d4
// File: /workspace/github_c_makefile_star2_O2/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
leal -0x1(%rdx), %eax
cmpl $0x7, %eax
ja 0x2423
leaq 0x2c57(%rip), %r8       # 0x5064
movslq (%r8,%rax,4), %rax
addq %r8, %rax
jmpq *%rax
movsbl %sil, %esi
movq %rcx, %rdx
popq %rbp
jmp 0x1f88
cmpl $0x10, %edx
jne 0x2435
movsbl %sil, %esi
movq %rcx, %rdx
popq %rbp
jmp 0x2158
movsbl %sil, %esi
cmpl $0xff, %edx
ja 0x2471
movzbl %dl, %edx
popq %rbp
jmp 0x21e6
movsbl %sil, %esi
movq %rcx, %rdx
popq %rbp
jmp 0x2070
movsbl %sil, %esi
movq %rcx, %rdx
popq %rbp
jmp 0x20e4
movsbl %sil, %esi
movq %rcx, %rdx
popq %rbp
jmp 0x1ffc
cmpl $0xffff, %edx           # imm = 0xFFFF
ja 0x2482
movzwl %dx, %edx
popq %rbp
jmp 0x2291
popq %rbp
jmp 0x2339
// File: /workspace/github_c_makefile_star2_O2/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_read_pfix
bool cmp_read_pfix(cmp_ctx_t *ctx, uint8_t *c) {
  cmp_object_t obj;

  if (!cmp_read_object(ctx, &obj))
    return false;

  if (obj.type != CMP_TYPE_POSITIVE_FIXNUM) {
    ctx->error = INVALID_TYPE_ERROR;
    return false;
  }

  *c = obj.as.u8;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %rsi
callq 0x27d3
testb %al, %al
je 0x27bf
cmpb $0x0, -0x20(%rbp)
je 0x27ca
movb $0xd, (%r14)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movb -0x18(%rbp), %al
movb %al, (%rbx)
movb $0x1, %al
jmp 0x27c1
// File: /workspace/github_c_makefile_star2_O2/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_read_object
bool cmp_read_object(cmp_ctx_t *ctx, cmp_object_t *obj) {
  uint8_t type_marker = 0;

  if (!read_type_marker(ctx, &type_marker))
    return false;

  if (!type_marker_to_cmp_type(type_marker, &obj->type)) {
    ctx->error = INVALID_TYPE_ERROR;
    return false;
  }

  return read_obj_data(ctx, type_marker, obj);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x19(%rbp), %rsi
movb $0x0, (%rsi)
pushq $0x1
popq %rdx
callq *0x10(%rdi)
testb %al, %al
je 0x2818
movzbl -0x19(%rbp), %r15d
movl %r15d, %edi
movq %rbx, %rsi
callq 0x361f
testb %al, %al
je 0x281e
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x367a
jmp 0x2824
movb $0x7, (%r14)
jmp 0x2822
movb $0xd, (%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_read_nfix
bool cmp_read_nfix(cmp_ctx_t *ctx, int8_t *c) {
  cmp_object_t obj;

  if (!cmp_read_object(ctx, &obj))
    return false;

  if (obj.type != CMP_TYPE_NEGATIVE_FIXNUM) {
    ctx->error = INVALID_TYPE_ERROR;
    return false;
  }

  *c = obj.as.s8;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %rsi
callq 0x27d3
testb %al, %al
je 0x2860
cmpb $0x22, -0x20(%rbp)
jne 0x285c
movb -0x18(%rbp), %al
movb %al, (%rbx)
movb $0x1, %al
jmp 0x2862
movb $0xd, (%r14)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_read_sfix
bool cmp_read_sfix(cmp_ctx_t *ctx, int8_t *c) {
  cmp_object_t obj;

  if (!cmp_read_object(ctx, &obj))
    return false;

  switch (obj.type) {
    case CMP_TYPE_POSITIVE_FIXNUM:
    case CMP_TYPE_NEGATIVE_FIXNUM:
      *c = obj.as.s8;
      return true;
    default:
      ctx->error = INVALID_TYPE_ERROR;
      return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %rsi
callq 0x27d3
testb %al, %al
je 0x28a3
movzbl -0x20(%rbp), %eax
cmpl $0x22, %eax
je 0x2896
testl %eax, %eax
jne 0x289f
movb -0x18(%rbp), %al
movb %al, (%rbx)
movb $0x1, %al
jmp 0x28a5
movb $0xd, (%r14)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_read_s8
bool cmp_read_s8(cmp_ctx_t *ctx, int8_t *c) {
  cmp_object_t obj;

  if (!cmp_read_object(ctx, &obj))
    return false;

  if (obj.type != CMP_TYPE_SINT8) {
    ctx->error = INVALID_TYPE_ERROR;
    return false;
  }

  *c = obj.as.s8;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %rsi
callq 0x27d3
testb %al, %al
je 0x28df
cmpb $0x12, -0x20(%rbp)
jne 0x28db
movb -0x18(%rbp), %al
movb %al, (%rbx)
movb $0x1, %al
jmp 0x28e1
movb $0xd, (%r14)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_read_s16
bool cmp_read_s16(cmp_ctx_t *ctx, int16_t *s) {
  cmp_object_t obj;

  if (!cmp_read_object(ctx, &obj))
    return false;

  if (obj.type != CMP_TYPE_SINT16) {
    ctx->error = INVALID_TYPE_ERROR;
    return false;
  }

  *s = obj.as.s16;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %rsi
callq 0x27d3
testb %al, %al
je 0x291d
cmpb $0x13, -0x20(%rbp)
jne 0x2919
movzwl -0x18(%rbp), %eax
movw %ax, (%rbx)
movb $0x1, %al
jmp 0x291f
movb $0xd, (%r14)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_read_s32
bool cmp_read_s32(cmp_ctx_t *ctx, int32_t *i) {
  cmp_object_t obj;

  if (!cmp_read_object(ctx, &obj))
    return false;

  if (obj.type != CMP_TYPE_SINT32) {
    ctx->error = INVALID_TYPE_ERROR;
    return false;
  }

  *i = obj.as.s32;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %rsi
callq 0x27d3
testb %al, %al
je 0x2959
cmpb $0x14, -0x20(%rbp)
jne 0x2955
movl -0x18(%rbp), %eax
movl %eax, (%rbx)
movb $0x1, %al
jmp 0x295b
movb $0xd, (%r14)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_read_s64
bool cmp_read_s64(cmp_ctx_t *ctx, int64_t *l) {
  cmp_object_t obj;

  if (!cmp_read_object(ctx, &obj))
    return false;

  if (obj.type != CMP_TYPE_SINT64) {
    ctx->error = INVALID_TYPE_ERROR;
    return false;
  }

  *l = obj.as.s64;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %rsi
callq 0x27d3
testb %al, %al
je 0x2997
cmpb $0x15, -0x20(%rbp)
jne 0x2993
movq -0x18(%rbp), %rax
movq %rax, (%rbx)
movb $0x1, %al
jmp 0x2999
movb $0xd, (%r14)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_read_char
bool cmp_read_char(cmp_ctx_t *ctx, int8_t *c) {
  cmp_object_t obj;

  if (!cmp_read_object(ctx, &obj))
    return false;

  switch (obj.type) {
    case CMP_TYPE_POSITIVE_FIXNUM:
    case CMP_TYPE_NEGATIVE_FIXNUM:
    case CMP_TYPE_SINT8:
      *c = obj.as.s8;
      return true;
    case CMP_TYPE_UINT8:
      if (obj.as.u8 <= 127) {
        *c = obj.as.u8;
        return true;
      }
      break;
    default:
      break;
  }

  ctx->error = INVALID_TYPE_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %rsi
callq 0x27d3
testb %al, %al
je 0x29eb
movzbl -0x20(%rbp), %eax
testl %eax, %eax
je 0x29d7
cmpl $0xe, %eax
je 0x29e0
cmpl $0x22, %eax
je 0x29d7
cmpl $0x12, %eax
jne 0x29e7
movb -0x18(%rbp), %al
movb %al, (%rbx)
movb $0x1, %al
jmp 0x29ed
movb -0x18(%rbp), %al
testb %al, %al
jns 0x29da
movb $0xd, (%r14)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_read_short
bool cmp_read_short(cmp_ctx_t *ctx, int16_t *s) {
  cmp_object_t obj;

  if (!cmp_read_object(ctx, &obj))
    return false;

  switch (obj.type) {
    case CMP_TYPE_POSITIVE_FIXNUM:
    case CMP_TYPE_NEGATIVE_FIXNUM:
    case CMP_TYPE_SINT8:
      *s = obj.as.s8;
      return true;
    case CMP_TYPE_UINT8:
      *s = obj.as.u8;
      return true;
    case CMP_TYPE_SINT16:
      *s = obj.as.s16;
      return true;
    case CMP_TYPE_UINT16:
      if (obj.as.u16 <= 32767) {
        *s = obj.as.u16;
        return true;
      }
      break;
    default:
      break;
  }

  ctx->error = INVALID_TYPE_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %rsi
callq 0x27d3
testb %al, %al
je 0x2a62
movzbl -0x20(%rbp), %eax
leal -0xe(%rax), %ecx
cmpl $0x5, %ecx
ja 0x2a36
leaq 0x2775(%rip), %rax      # 0x519c
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movzbl -0x18(%rbp), %eax
jmp 0x2a43
cmpl $0x22, %eax
je 0x2a3f
testl %eax, %eax
jne 0x2a5e
movsbl -0x18(%rbp), %eax
movw %ax, (%rbx)
jmp 0x2a5a
movzwl -0x18(%rbp), %eax
jmp 0x2a57
movzwl -0x18(%rbp), %eax
testw %ax, %ax
js 0x2a5e
movw %ax, (%rbx)
movb $0x1, %al
jmp 0x2a64
movb $0xd, (%r14)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_read_int
bool cmp_read_int(cmp_ctx_t *ctx, int32_t *i) {
  cmp_object_t obj;

  if (!cmp_read_object(ctx, &obj))
    return false;

  switch (obj.type) {
    case CMP_TYPE_POSITIVE_FIXNUM:
    case CMP_TYPE_NEGATIVE_FIXNUM:
    case CMP_TYPE_SINT8:
      *i = obj.as.s8;
      return true;
    case CMP_TYPE_UINT8:
      *i = obj.as.u8;
      return true;
    case CMP_TYPE_SINT16:
      *i = obj.as.s16;
      return true;
    case CMP_TYPE_UINT16:
      *i = obj.as.u16;
      return true;
    case CMP_TYPE_SINT32:
      *i = obj.as.s32;
      return true;
    case CMP_TYPE_UINT32:
      if (obj.as.u32 <= 2147483647) {
        *i = obj.as.u32;
        return true;
      }
      break;
    default:
      break;
  }

  ctx->error = INVALID_TYPE_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %rsi
callq 0x27d3
testb %al, %al
je 0x2ac7
movzbl -0x20(%rbp), %eax
leal -0xe(%rax), %ecx
cmpl $0x6, %ecx
ja 0x2aad
leaq 0x2716(%rip), %rax      # 0x51b4
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movzbl -0x18(%rbp), %eax
jmp 0x2ada
cmpl $0x22, %eax
je 0x2ab6
testl %eax, %eax
jne 0x2ac3
movsbl -0x18(%rbp), %eax
jmp 0x2ada
movl -0x18(%rbp), %eax
testl %eax, %eax
jns 0x2ada
movb $0xd, (%r14)
xorl %eax, %eax
jmp 0x2ade
movswl -0x18(%rbp), %eax
jmp 0x2ada
movzwl -0x18(%rbp), %eax
jmp 0x2ada
movl -0x18(%rbp), %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_read_long
bool cmp_read_long(cmp_ctx_t *ctx, int64_t *d) {
  cmp_object_t obj;

  if (!cmp_read_object(ctx, &obj))
    return false;

  switch (obj.type) {
    case CMP_TYPE_POSITIVE_FIXNUM:
    case CMP_TYPE_NEGATIVE_FIXNUM:
    case CMP_TYPE_SINT8:
      *d = obj.as.s8;
      return true;
    case CMP_TYPE_UINT8:
      *d = obj.as.u8;
      return true;
    case CMP_TYPE_SINT16:
      *d = obj.as.s16;
      return true;
    case CMP_TYPE_UINT16:
      *d = obj.as.u16;
      return true;
    case CMP_TYPE_SINT32:
      *d = obj.as.s32;
      return true;
    case CMP_TYPE_UINT32:
      *d = obj.as.u32;
      return true;
    case CMP_TYPE_SINT64:
      *d = obj.as.s64;
      return true;
    case CMP_TYPE_UINT64:
      if (obj.as.u64 <= 9223372036854775807) {
        *d = obj.as.u64;
        return true;
      }
      break;
    default:
      break;
  }

  ctx->error = INVALID_TYPE_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %rsi
callq 0x27d3
testb %al, %al
je 0x2b3f
movzbl -0x20(%rbp), %ecx
leal -0xe(%rcx), %eax
cmpl $0x14, %eax
ja 0x2b27
leaq 0x26b8(%rip), %rcx      # 0x51d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzbl -0x18(%rbp), %eax
jmp 0x2b5f
testl %ecx, %ecx
jne 0x2b3b
movsbq -0x18(%rbp), %rax
jmp 0x2b5f
movq -0x18(%rbp), %rax
testq %rax, %rax
jns 0x2b5f
movb $0xd, (%r14)
xorl %eax, %eax
jmp 0x2b64
movq -0x18(%rbp), %rax
jmp 0x2b5f
movzwl -0x18(%rbp), %eax
jmp 0x2b5f
movswq -0x18(%rbp), %rax
jmp 0x2b5f
movl -0x18(%rbp), %eax
jmp 0x2b5f
movslq -0x18(%rbp), %rax
movq %rax, (%rbx)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_read_u8
bool cmp_read_u8(cmp_ctx_t *ctx, uint8_t *c) {
  cmp_object_t obj;

  if (!cmp_read_object(ctx, &obj))
    return false;

  if (obj.type != CMP_TYPE_UINT8) {
    ctx->error = INVALID_TYPE_ERROR;
    return false;
  }

  *c = obj.as.u8;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %rsi
callq 0x27d3
testb %al, %al
je 0x2bb2
cmpb $0xe, -0x20(%rbp)
jne 0x2bae
movb -0x18(%rbp), %al
movb %al, (%rbx)
movb $0x1, %al
jmp 0x2bb4
movb $0xd, (%r14)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_read_u16
bool cmp_read_u16(cmp_ctx_t *ctx, uint16_t *s) {
  cmp_object_t obj;

  if (!cmp_read_object(ctx, &obj))
    return false;

  if (obj.type != CMP_TYPE_UINT16) {
    ctx->error = INVALID_TYPE_ERROR;
    return false;
  }

  *s = obj.as.u16;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %rsi
callq 0x27d3
testb %al, %al
je 0x2bf0
cmpb $0xf, -0x20(%rbp)
jne 0x2bec
movzwl -0x18(%rbp), %eax
movw %ax, (%rbx)
movb $0x1, %al
jmp 0x2bf2
movb $0xd, (%r14)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_read_u32
bool cmp_read_u32(cmp_ctx_t *ctx, uint32_t *i) {
  cmp_object_t obj;

  if (!cmp_read_object(ctx, &obj))
    return false;

  if (obj.type != CMP_TYPE_UINT32) {
    ctx->error = INVALID_TYPE_ERROR;
    return false;
  }

  *i = obj.as.u32;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %rsi
callq 0x27d3
testb %al, %al
je 0x2c2c
cmpb $0x10, -0x20(%rbp)
jne 0x2c28
movl -0x18(%rbp), %eax
movl %eax, (%rbx)
movb $0x1, %al
jmp 0x2c2e
movb $0xd, (%r14)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq