LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_skip_object
bool cmp_skip_object(cmp_ctx_t *ctx, cmp_object_t *obj) {
  uint8_t type_marker = 0;
  uint8_t cmp_type;
  uint32_t size = 0;

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

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

  switch (cmp_type) {
    case CMP_TYPE_FIXARRAY:
    case CMP_TYPE_ARRAY16:
    case CMP_TYPE_ARRAY32:
    case CMP_TYPE_FIXMAP:
    case CMP_TYPE_MAP16:
    case CMP_TYPE_MAP32:
      obj->type = cmp_type;

      if (!read_obj_data(ctx, type_marker, obj)) {
        return false;
      }

      ctx->error = SKIP_DEPTH_LIMIT_EXCEEDED_ERROR;

      return false;
    default:
      if (!read_type_size(ctx, type_marker, cmp_type, &size)) {
        return false;
      }

      if (size) {
        switch (cmp_type) {
          case CMP_TYPE_FIXEXT1:
          case CMP_TYPE_FIXEXT2:
          case CMP_TYPE_FIXEXT4:
          case CMP_TYPE_FIXEXT8:
          case CMP_TYPE_FIXEXT16:
          case CMP_TYPE_EXT8:
          case CMP_TYPE_EXT16:
          case CMP_TYPE_EXT32:
            size++;
          default:
            break;
        }

        skip_bytes(ctx, size);
      }
  }

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x19(%rbp), %rsi
callq 0x57f0
testb $0x1, %al
jne 0x6205
movb $0x0, -0x1(%rbp)
jmp 0x62da
leaq -0x1a(%rbp), %rsi
movzbl -0x19(%rbp), %edi
callq 0x5830
testb $0x1, %al
jne 0x6226
movq -0x10(%rbp), %rax
movb $0xd, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0x62da
movzbl -0x1a(%rbp), %eax
movl %eax, -0x24(%rbp)
decl %eax
subl $0x2, %eax
jb 0x6243
jmp 0x6236
movl -0x24(%rbp), %eax
addl $-0x1e, %eax
subl $0x3, %eax
ja 0x6276
jmp 0x6243
movb -0x1a(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rdi
movb -0x19(%rbp), %al
movq -0x18(%rbp), %rdx
movzbl %al, %esi
callq 0x5ad0
testb $0x1, %al
jne 0x6269
movb $0x0, -0x1(%rbp)
jmp 0x62da
movq -0x10(%rbp), %rax
movb $0x10, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0x62da
movq -0x10(%rbp), %rdi
movb -0x19(%rbp), %al
leaq -0x20(%rbp), %rcx
movzbl %al, %esi
movzbl -0x1a(%rbp), %edx
callq 0x62f0
testb $0x1, %al
jne 0x6297
movb $0x0, -0x1(%rbp)
jmp 0x62da
cmpl $0x0, -0x20(%rbp)
je 0x62d4
movzbl -0x1a(%rbp), %eax
movl %eax, -0x28(%rbp)
addl $-0x9, %eax
subl $0x3, %eax
jb 0x62bb
jmp 0x62ae
movl -0x28(%rbp), %eax
addl $-0x16, %eax
subl $0x4, %eax
ja 0x62c4
jmp 0x62bb
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x62c6
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x6860
jmp 0x62d6
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: skip_bytes
static bool skip_bytes(cmp_ctx_t *ctx, size_t count) {
  if (ctx->skip) {
    return ctx->skip(ctx, count);
  }
  else {
    uint8_t floor;
    size_t i;

    for (i = 0; i < count; i++) {
      if (!ctx->read(ctx, &floor, sizeof(uint8_t))) {
        return false;
      }
    }

    return true;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x6894
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x68db
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x68d7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rdi
leaq -0x19(%rbp), %rsi
movl $0x1, %edx
callq *%rax
testb $0x1, %al
jne 0x68c7
movb $0x0, -0x1(%rbp)
jmp 0x68db
jmp 0x68c9
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x689c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_is_char
bool cmp_object_is_char(cmp_object_t *obj) {
  switch (obj->type) {
    case CMP_TYPE_NEGATIVE_FIXNUM:
    case CMP_TYPE_SINT8:
      return true;
    default:
      return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x12, %eax
je 0x6ea3
jmp 0x6e99
movl -0x14(%rbp), %eax
subl $0x22, %eax
jne 0x6ea9
jmp 0x6ea3
movb $0x1, -0x1(%rbp)
jmp 0x6ead
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_is_short
bool cmp_object_is_short(cmp_object_t *obj) {
  switch (obj->type) {
    case CMP_TYPE_NEGATIVE_FIXNUM:
    case CMP_TYPE_SINT8:
    case CMP_TYPE_SINT16:
      return true;
    default:
      return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
addl $-0x12, %eax
subl $0x2, %eax
jb 0x6ee6
jmp 0x6edc
movl -0x14(%rbp), %eax
subl $0x22, %eax
jne 0x6eec
jmp 0x6ee6
movb $0x1, -0x1(%rbp)
jmp 0x6ef0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_is_int
bool cmp_object_is_int(cmp_object_t *obj) {
  switch (obj->type) {
    case CMP_TYPE_NEGATIVE_FIXNUM:
    case CMP_TYPE_SINT8:
    case CMP_TYPE_SINT16:
    case CMP_TYPE_SINT32:
      return true;
    default:
      return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
addl $-0x12, %eax
subl $0x3, %eax
jb 0x6f26
jmp 0x6f1c
movl -0x14(%rbp), %eax
subl $0x22, %eax
jne 0x6f2c
jmp 0x6f26
movb $0x1, -0x1(%rbp)
jmp 0x6f30
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_is_long
bool cmp_object_is_long(cmp_object_t *obj) {
  switch (obj->type) {
    case CMP_TYPE_NEGATIVE_FIXNUM:
    case CMP_TYPE_SINT8:
    case CMP_TYPE_SINT16:
    case CMP_TYPE_SINT32:
    case CMP_TYPE_SINT64:
      return true;
    default:
      return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
addl $-0x12, %eax
subl $0x4, %eax
jb 0x6f66
jmp 0x6f5c
movl -0x14(%rbp), %eax
subl $0x22, %eax
jne 0x6f6c
jmp 0x6f66
movb $0x1, -0x1(%rbp)
jmp 0x6f70
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_is_uchar
bool cmp_object_is_uchar(cmp_object_t *obj) {
  switch (obj->type) {
    case CMP_TYPE_POSITIVE_FIXNUM:
    case CMP_TYPE_UINT8:
      return true;
    default:
      return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x6fc2
jmp 0x6fb8
movl -0x14(%rbp), %eax
subl $0xe, %eax
jne 0x6fc8
jmp 0x6fc2
movb $0x1, -0x1(%rbp)
jmp 0x6fcc
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_is_ushort
bool cmp_object_is_ushort(cmp_object_t *obj) {
  switch (obj->type) {
    case CMP_TYPE_POSITIVE_FIXNUM:
    case CMP_TYPE_UINT8:
      return true;
    case CMP_TYPE_UINT16:
      return true;
    default:
      return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x700c
jmp 0x6ff8
movl -0x14(%rbp), %eax
subl $0xe, %eax
je 0x700c
jmp 0x7002
movl -0x14(%rbp), %eax
subl $0xf, %eax
je 0x7012
jmp 0x7018
movb $0x1, -0x1(%rbp)
jmp 0x701c
movb $0x1, -0x1(%rbp)
jmp 0x701c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_is_uint
bool cmp_object_is_uint(cmp_object_t *obj) {
  switch (obj->type) {
    case CMP_TYPE_POSITIVE_FIXNUM:
    case CMP_TYPE_UINT8:
    case CMP_TYPE_UINT16:
    case CMP_TYPE_UINT32:
      return true;
    default:
      return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x7055
jmp 0x7048
movl -0x14(%rbp), %eax
addl $-0xe, %eax
subl $0x2, %eax
ja 0x705b
jmp 0x7055
movb $0x1, -0x1(%rbp)
jmp 0x705f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_is_ulong
bool cmp_object_is_ulong(cmp_object_t *obj) {
  switch (obj->type) {
    case CMP_TYPE_POSITIVE_FIXNUM:
    case CMP_TYPE_UINT8:
    case CMP_TYPE_UINT16:
    case CMP_TYPE_UINT32:
    case CMP_TYPE_UINT64:
      return true;
    default:
      return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x7095
jmp 0x7088
movl -0x14(%rbp), %eax
addl $-0xe, %eax
subl $0x3, %eax
ja 0x709b
jmp 0x7095
movb $0x1, -0x1(%rbp)
jmp 0x709f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_is_str
bool cmp_object_is_str(cmp_object_t *obj) {
  switch (obj->type) {
    case CMP_TYPE_FIXSTR:
    case CMP_TYPE_STR8:
    case CMP_TYPE_STR16:
    case CMP_TYPE_STR32:
      return true;
    default:
      return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x3, %eax
je 0x71b6
jmp 0x71a9
movl -0x14(%rbp), %eax
addl $-0x1b, %eax
subl $0x2, %eax
ja 0x71bc
jmp 0x71b6
movb $0x1, -0x1(%rbp)
jmp 0x71c0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_is_bin
bool cmp_object_is_bin(cmp_object_t *obj) {
  switch (obj->type) {
    case CMP_TYPE_BIN8:
    case CMP_TYPE_BIN16:
    case CMP_TYPE_BIN32:
      return true;
    default:
      return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
addl $-0x6, %eax
subl $0x2, %eax
ja 0x71ef
jmp 0x71e9
movb $0x1, -0x1(%rbp)
jmp 0x71f3
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_is_array
bool cmp_object_is_array(cmp_object_t *obj) {
  switch (obj->type) {
    case CMP_TYPE_FIXARRAY:
    case CMP_TYPE_ARRAY16:
    case CMP_TYPE_ARRAY32:
      return true;
    default:
      return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x2, %eax
je 0x7226
jmp 0x7219
movl -0x14(%rbp), %eax
addl $-0x1e, %eax
subl $0x1, %eax
ja 0x722c
jmp 0x7226
movb $0x1, -0x1(%rbp)
jmp 0x7230
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_is_map
bool cmp_object_is_map(cmp_object_t *obj) {
  switch (obj->type) {
    case CMP_TYPE_FIXMAP:
    case CMP_TYPE_MAP16:
    case CMP_TYPE_MAP32:
      return true;
    default:
      return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x1, %eax
je 0x7266
jmp 0x7259
movl -0x14(%rbp), %eax
addl $-0x20, %eax
subl $0x1, %eax
ja 0x726c
jmp 0x7266
movb $0x1, -0x1(%rbp)
jmp 0x7270
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_is_ext
bool cmp_object_is_ext(cmp_object_t *obj) {
  switch (obj->type) {
    case CMP_TYPE_FIXEXT1:
    case CMP_TYPE_FIXEXT2:
    case CMP_TYPE_FIXEXT4:
    case CMP_TYPE_FIXEXT8:
    case CMP_TYPE_FIXEXT16:
    case CMP_TYPE_EXT8:
    case CMP_TYPE_EXT16:
    case CMP_TYPE_EXT32:
      return true;
    default:
      return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
addl $-0x9, %eax
subl $0x3, %eax
jb 0x72a9
jmp 0x729c
movl -0x14(%rbp), %eax
addl $-0x16, %eax
subl $0x4, %eax
ja 0x72af
jmp 0x72a9
movb $0x1, -0x1(%rbp)
jmp 0x72b3
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_as_char
bool cmp_object_as_char(cmp_object_t *obj, int8_t *c) {
  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.s8;
        return true;
      }
      else {
        return false;
      }
    default:
        return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x22, %rax
ja 0x732a
movq -0x20(%rbp), %rax
leaq 0x246c(%rip), %rcx      # 0x9754
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movb 0x8(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x732e
movq -0x10(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x7f, %eax
jg 0x7324
movq -0x10(%rbp), %rax
movb 0x8(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x732e
movb $0x0, -0x1(%rbp)
jmp 0x732e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_as_short
bool cmp_object_as_short(cmp_object_t *obj, int16_t *s) {
  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;
      }
      else {
        return false;
      }
    default:
        return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x22, %rax
ja 0x73e4
movq -0x20(%rbp), %rax
leaq 0x2474(%rip), %rcx      # 0x97e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movsbl 0x8(%rax), %eax
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x73e8
movq -0x10(%rbp), %rax
movzbl 0x8(%rax), %eax
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x73e8
movq -0x10(%rbp), %rax
movw 0x8(%rax), %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x73e8
movq -0x10(%rbp), %rax
movzwl 0x8(%rax), %eax
cmpl $0x7fff, %eax           # imm = 0x7FFF
jg 0x73de
movq -0x10(%rbp), %rax
movw 0x8(%rax), %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x73e8
movb $0x0, -0x1(%rbp)
jmp 0x73e8
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_as_int
bool cmp_object_as_int(cmp_object_t *obj, int32_t *i) {
  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;
      }
      else {
        return false;
      }
    default:
        return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x22, %rax
ja 0x74ae
movq -0x20(%rbp), %rax
leaq 0x2450(%rip), %rcx      # 0x986c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movsbl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x74b2
movq -0x10(%rbp), %rax
movzbl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x74b2
movq -0x10(%rbp), %rax
movswl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x74b2
movq -0x10(%rbp), %rax
movzwl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x74b2
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x74b2
movq -0x10(%rbp), %rax
cmpl $0x7fffffff, 0x8(%rax)  # imm = 0x7FFFFFFF
ja 0x74a8
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x74b2
movb $0x0, -0x1(%rbp)
jmp 0x74b2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_as_long
bool cmp_object_as_long(cmp_object_t *obj, int64_t *d) {
  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;
      }
      else {
        return false;
      }
    default:
        return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x22, %rax
ja 0x75c7
movq -0x20(%rbp), %rax
leaq 0x240c(%rip), %rcx      # 0x98f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movsbq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x75cb
movq -0x10(%rbp), %rax
movzbl 0x8(%rax), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x75cb
movq -0x10(%rbp), %rax
movswq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x75cb
movq -0x10(%rbp), %rax
movzwl 0x8(%rax), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x75cb
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x75cb
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x75cb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x75cb
movq -0x10(%rbp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, 0x8(%rax)
ja 0x75c1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x75cb
movb $0x0, -0x1(%rbp)
jmp 0x75cb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_as_uchar
bool cmp_object_as_uchar(cmp_object_t *obj, uint8_t *c) {
  switch (obj->type) {
    case CMP_TYPE_POSITIVE_FIXNUM:
    case CMP_TYPE_UINT8:
      *c = obj->as.u8;
      return true;
    default:
        return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x7636
jmp 0x762c
movl -0x1c(%rbp), %eax
subl $0xe, %eax
jne 0x7649
jmp 0x7636
movq -0x10(%rbp), %rax
movb 0x8(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x764d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_as_ushort
bool cmp_object_as_ushort(cmp_object_t *obj, uint16_t *s) {
  switch (obj->type) {
    case CMP_TYPE_POSITIVE_FIXNUM:
    case CMP_TYPE_UINT8:
      *s = obj->as.u8;
      return true;
    case CMP_TYPE_UINT16:
      *s = obj->as.u16;
      return true;
    default:
        return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x7690
jmp 0x767c
movl -0x1c(%rbp), %eax
subl $0xe, %eax
je 0x7690
jmp 0x7686
movl -0x1c(%rbp), %eax
subl $0xf, %eax
je 0x76a8
jmp 0x76bd
movq -0x10(%rbp), %rax
movzbl 0x8(%rax), %eax
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x76c1
movq -0x10(%rbp), %rax
movw 0x8(%rax), %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x76c1
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_as_uint
bool cmp_object_as_uint(cmp_object_t *obj, uint32_t *i) {
  switch (obj->type) {
    case CMP_TYPE_POSITIVE_FIXNUM:
    case CMP_TYPE_UINT8:
      *i = obj->as.u8;
      return true;
    case CMP_TYPE_UINT16:
      *i = obj->as.u16;
      return true;
    case CMP_TYPE_UINT32:
      *i = obj->as.u32;
      return true;
    default:
        return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x10, %rax
ja 0x773c
movq -0x20(%rbp), %rax
leaq 0x228c(%rip), %rcx      # 0x9984
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movzbl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x7740
movq -0x10(%rbp), %rax
movzwl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x7740
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x7740
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_as_ulong
bool cmp_object_as_ulong(cmp_object_t *obj, uint64_t *u) {
  switch (obj->type) {
    case CMP_TYPE_POSITIVE_FIXNUM:
    case CMP_TYPE_UINT8:
      *u = obj->as.u8;
      return true;
    case CMP_TYPE_UINT16:
      *u = obj->as.u16;
      return true;
    case CMP_TYPE_UINT32:
      *u = obj->as.u32;
      return true;
    case CMP_TYPE_UINT64:
      *u = obj->as.u64;
      return true;
    default:
        return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x11, %rax
ja 0x77da
movq -0x20(%rbp), %rax
leaq 0x2250(%rip), %rcx      # 0x99c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movzbl 0x8(%rax), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x77de
movq -0x10(%rbp), %rax
movzwl 0x8(%rax), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x77de
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x77de
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x77de
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_as_float
bool cmp_object_as_float(cmp_object_t *obj, float *f) {
  if (obj->type == CMP_TYPE_FLOAT) {
    *f = obj->as.flt;
    return true;
  }

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xc, %eax
jne 0x784f
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x7853
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_as_double
bool cmp_object_as_double(cmp_object_t *obj, double *d) {
  if (obj->type == CMP_TYPE_DOUBLE) {
    *d = obj->as.dbl;
    return true;
  }

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0x788f
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x7893
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_as_bool
bool cmp_object_as_bool(cmp_object_t *obj, bool *b) {
  if (obj->type == CMP_TYPE_BOOLEAN) {
    if (obj->as.boolean)
      *b = true;
    else
      *b = false;

    return true;
  }

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x5, %eax
jne 0x78d8
movq -0x10(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x78cb
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
jmp 0x78d2
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x78dc
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_as_str
bool cmp_object_as_str(cmp_object_t *obj, uint32_t *size) {
  switch (obj->type) {
    case CMP_TYPE_FIXSTR:
    case CMP_TYPE_STR8:
    case CMP_TYPE_STR16:
    case CMP_TYPE_STR32:
      *size = obj->as.str_size;
      return true;
    default:
        return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x3, %eax
je 0x791a
jmp 0x790d
movl -0x1c(%rbp), %eax
addl $-0x1b, %eax
subl $0x2, %eax
ja 0x792d
jmp 0x791a
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x7931
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_as_bin
bool cmp_object_as_bin(cmp_object_t *obj, uint32_t *size) {
  switch (obj->type) {
    case CMP_TYPE_BIN8:
    case CMP_TYPE_BIN16:
    case CMP_TYPE_BIN32:
      *size = obj->as.bin_size;
      return true;
    default:
        return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
addl $-0x6, %eax
subl $0x2, %eax
ja 0x7970
jmp 0x795d
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x7974
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_as_array
bool cmp_object_as_array(cmp_object_t *obj, uint32_t *size) {
  switch (obj->type) {
    case CMP_TYPE_FIXARRAY:
    case CMP_TYPE_ARRAY16:
    case CMP_TYPE_ARRAY32:
      *size = obj->as.array_size;
      return true;
    default:
        return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x2, %eax
je 0x79aa
jmp 0x799d
movl -0x1c(%rbp), %eax
addl $-0x1e, %eax
subl $0x1, %eax
ja 0x79bd
jmp 0x79aa
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x79c1
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_as_map
bool cmp_object_as_map(cmp_object_t *obj, uint32_t *size) {
  switch (obj->type) {
    case CMP_TYPE_FIXMAP:
    case CMP_TYPE_MAP16:
    case CMP_TYPE_MAP32:
      *size = obj->as.map_size;
      return true;
    default:
        return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0x79fa
jmp 0x79ed
movl -0x1c(%rbp), %eax
addl $-0x20, %eax
subl $0x1, %eax
ja 0x7a0d
jmp 0x79fa
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x7a11
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_as_ext
bool cmp_object_as_ext(cmp_object_t *obj, int8_t *type, uint32_t *size) {
  switch (obj->type) {
    case CMP_TYPE_FIXEXT1:
    case CMP_TYPE_FIXEXT2:
    case CMP_TYPE_FIXEXT4:
    case CMP_TYPE_FIXEXT8:
    case CMP_TYPE_FIXEXT16:
    case CMP_TYPE_EXT8:
    case CMP_TYPE_EXT16:
    case CMP_TYPE_EXT32:
      *type = obj->as.ext.type;
      *size = obj->as.ext.size;
      return true;
    default:
        return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x24(%rbp)
addl $-0x9, %eax
subl $0x3, %eax
jb 0x7a51
jmp 0x7a44
movl -0x24(%rbp), %eax
addl $-0x16, %eax
subl $0x4, %eax
ja 0x7a71
jmp 0x7a51
movq -0x10(%rbp), %rax
movb 0x8(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x7a75
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_to_str
bool cmp_object_to_str(cmp_ctx_t *ctx, cmp_object_t *obj, char *data,
                                                          uint32_t buf_size) {
  uint32_t str_size = 0;

  switch (obj->type) {
    case CMP_TYPE_FIXSTR:
    case CMP_TYPE_STR8:
    case CMP_TYPE_STR16:
    case CMP_TYPE_STR32:
      str_size = obj->as.str_size;
      if ((str_size + 1) > buf_size) {
        ctx->error = STR_DATA_LENGTH_TOO_LONG_ERROR;
        return false;
      }

      if (!ctx->read(ctx, data, str_size)) {
        ctx->error = DATA_READING_ERROR;
        return false;
      }

      data[str_size] = 0;
      return true;
    default:
      return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x3, %eax
je 0x7abc
jmp 0x7aaf
movl -0x2c(%rbp), %eax
addl $-0x1b, %eax
subl $0x2, %eax
ja 0x7b17
jmp 0x7abc
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
cmpl -0x24(%rbp), %eax
jbe 0x7ade
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0x7b1b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x28(%rbp), %ecx
movl %ecx, %edx
callq *%rax
testb $0x1, %al
jne 0x7b06
movq -0x10(%rbp), %rax
movb $0x9, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0x7b1b
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movb $0x1, -0x1(%rbp)
jmp 0x7b1b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_object_to_bin
bool cmp_object_to_bin(cmp_ctx_t *ctx, cmp_object_t *obj, void *data,
                                                          uint32_t buf_size) {
  uint32_t bin_size = 0;

  switch (obj->type) {
    case CMP_TYPE_BIN8:
    case CMP_TYPE_BIN16:
    case CMP_TYPE_BIN32:
      bin_size = obj->as.bin_size;
      if (bin_size > buf_size) {
        ctx->error = BIN_DATA_LENGTH_TOO_LONG_ERROR;
        return false;
      }

      if (!ctx->read(ctx, data, bin_size)) {
        ctx->error = DATA_READING_ERROR;
        return false;
      }
      return true;
    default:
      return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
addl $-0x6, %eax
subl $0x2, %eax
ja 0x7bac
jmp 0x7b5f
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jbe 0x7b7e
movq -0x10(%rbp), %rax
movb $0x2, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0x7bb0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x28(%rbp), %ecx
movl %ecx, %edx
callq *%rax
testb $0x1, %al
jne 0x7ba6
movq -0x10(%rbp), %rax
movb $0x9, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0x7bb0
movb $0x1, -0x1(%rbp)
jmp 0x7bb0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: decode_befloat
static float decode_befloat(char *b) {
  float f = 0.;
  char *fb = (char *)&f;

  if (!is_bigendian()) {
    fb[0] = b[3];
    fb[1] = b[2];
    fb[2] = b[1];
    fb[3] = b[0];
  }

  return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
leaq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl 0x1dc1(%rip), %eax      # 0x9a10
cmpl $0x0, %eax
je 0x7c8a
movq -0x8(%rbp), %rax
movb 0x3(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movb 0x2(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rax
movb 0x1(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x8(%rbp), %rax
movb (%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x3(%rax)
movss -0xc(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: decode_bedouble
static double decode_bedouble(char *b) {
  double d = 0.;
  char *db = (char *)&d;

  if (!is_bigendian()) {
    db[0] = b[7];
    db[1] = b[6];
    db[2] = b[5];
    db[3] = b[4];
    db[4] = b[3];
    db[5] = b[2];
    db[6] = b[1];
    db[7] = b[0];
  }

  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl 0x1d51(%rip), %eax      # 0x9a10
cmpl $0x0, %eax
je 0x7d32
movq -0x8(%rbp), %rax
movb 0x7(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movb 0x6(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rax
movb 0x5(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x8(%rbp), %rax
movb 0x4(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x8(%rbp), %rax
movb 0x3(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x8(%rbp), %rax
movb 0x2(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x8(%rbp), %rax
movb 0x1(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x6(%rax)
movq -0x8(%rbp), %rax
movb (%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x7(%rax)
movsd -0x10(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/dump.c
// Function: msgpack_data_read
void msgpack_data_read(msgpack_data *backing_data, void* out_data, size_t length) {
    size_t new_end_position = backing_data->position + length;
    if (new_end_position > backing_data->buffer.length) {
        perror("Msgpack library tried to read more than the message's size. Message is probably malformed.\n");
        exit(4);
    }
    memcpy(out_data, backing_data->buffer.data + backing_data->position, length);
    backing_data->position = new_end_position;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x7dd7
leaq 0x1eec(%rip), %rdi      # 0x9cb4
callq 0x10d0
movl $0x4, %edi
callq 0x10e0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
addq 0x10(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x10a0
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/dump.c
// Function: msgpack_data_skip
void msgpack_data_skip(msgpack_data *backing_data, size_t length) {
    backing_data->position += length;
    if (backing_data->position > backing_data->buffer.length) {
        perror("Msgpack library tried to read more than the message's size. Message is probably malformed.\n");
        exit(4);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x7e57
leaq 0x1e6c(%rip), %rdi      # 0x9cb4
callq 0x10d0
movl $0x4, %edi
callq 0x10e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/dump.c
// Function: dump_msgpack
void dump_msgpack(buffer rawdata, bool print_strings) {
    msgpack_data data = make_msgpack_data(rawdata);
    cmp_ctx_t ctx;

    cmp_init(&ctx, &data, msgpack_reader, msgpack_skipper, NULL);

    cmp_object_t obj;
    while (!msgpack_data_reached_eof(&data)) {
        if (!cmp_read_object(&ctx, &obj)) {
            perror("Messagepack library error\n");
            perror(cmp_strerror(&ctx));
            exit(5);
        }

        dump_msgpack_object(&data, &obj, print_strings);
    }
    //printf("%s", "done");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x7d40
leaq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq 0x79(%rip), %rdx        # 0x7f10
leaq 0xb2(%rip), %rcx        # 0x7f50
xorl %eax, %eax
movl %eax, %r8d
callq 0x1410
leaq -0x30(%rbp), %rdi
callq 0x7d70
xorb $-0x1, %al
testb $0x1, %al
jne 0x7eb9
jmp 0x7f08
leaq -0x58(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3f70
testb $0x1, %al
jne 0x7ef1
leaq 0x1e3f(%rip), %rdi      # 0x9d10
callq 0x10d0
leaq -0x58(%rbp), %rdi
callq 0x1490
movq %rax, %rdi
callq 0x10d0
movl $0x5, %edi
callq 0x10e0
movb -0x11(%rbp), %al
leaq -0x30(%rbp), %rdi
leaq -0x68(%rbp), %rsi
andb $0x1, %al
movzbl %al, %edx
callq 0x7f80
jmp 0x7ea8
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/dump.c
// Function: dump_msgpack_string
void dump_msgpack_string(msgpack_data *raw_data, cmp_object_t* object, uint32_t length, bool print_strings) {
    char *str = malloc(length);
    msgpack_data_read(raw_data, str, length);

    if (print_strings) {
        fprintf(stdout, "\n\"");
        fwrite(str, 1, length, stdout);
        fprintf(stdout, "\"");
    }

    free(str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %edi
callq 0x10b0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x7d90
testb $0x1, -0x15(%rbp)
je 0x841d
movq 0x5c01(%rip), %rax      # 0xdfd8
movq (%rax), %rdi
leaq 0x1c07(%rip), %rsi      # 0x9fe8
movb $0x0, %al
callq 0x1090
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %edx
movq 0x5be0(%rip), %rax      # 0xdfd8
movq (%rax), %rcx
movl $0x1, %esi
callq 0x10f0
movq 0x5bcc(%rip), %rax      # 0xdfd8
movq (%rax), %rdi
leaq 0x1bd3(%rip), %rsi      # 0x9fe9
movb $0x0, %al
callq 0x1090
movq -0x20(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nerves-project[P]nerves_initramfs/tests/fixture/init_fixture.c
// Function: fixture_init
__attribute__((constructor)) void fixture_init()
{
    // WARNING: This is hacky!!!
    starting_pid = getpid();
    if (starting_pid == 1)
        errx(EXIT_FAILURE, "getpid() overridden before it should have been");

    work = getenv("WORK");

    // Don't wrap child processes
    unsetenv("LD_PRELOAD");
    unsetenv("DYLD_INSERT_LIBRARIES");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x10b0
movl %eax, 0x3ea1(%rip)      # 0x5090
cmpl $0x1, 0x3e9a(%rip)      # 0x5090
jne 0x120b
movl $0x1, %edi
leaq 0x1dfc(%rip), %rsi      # 0x3000
movb $0x0, %al
callq 0x1050
leaq 0x1e1d(%rip), %rdi      # 0x302f
callq 0x1030
movq %rax, 0x3e82(%rip)      # 0x50a0
leaq 0x1e0f(%rip), %rdi      # 0x3034
callq 0x10d0
leaq 0x1e0e(%rip), %rdi      # 0x303f
callq 0x10d0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nerves-project[P]nerves_initramfs/tests/fixture/init_fixture.c
// Function: fixup_path
static int fixup_path(const char *input, char *output)
{
    // All paths from init should be absolute
    if (input[0] != '/')
        errx(EXIT_FAILURE, "Non-absolute path detected: \"%s\"", input);

    // Prepend the working directory to the path
    sprintf(output, "%s%s%s", work, remounted_root ? "/mnt" : "", input);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x13e3
movq -0x8(%rbp), %rdx
movl $0x1, %edi
leaq 0x1fb8(%rip), %rsi      # 0x3394
movb $0x0, %al
callq 0x1050
movq -0x10(%rbp), %rdi
movq 0x3cb2(%rip), %rdx      # 0x50a0
movb 0x3cb3(%rip), %sil      # 0x50a8
leaq 0x1e33(%rip), %rcx      # 0x322f
leaq 0x1fb9(%rip), %rax      # 0x33bc
testb $0x1, %sil
cmovneq %rax, %rcx
movq -0x8(%rbp), %r8
leaq 0x1f9f(%rip), %rsi      # 0x33b5
movb $0x0, %al
callq 0x10f0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nerves-project[P]nerves_initramfs/tests/fixture/init_fixture.c
// Function: unfixup_path
static void unfixup_path(char *path)
{
    char prefix[PATH_MAX];
    sprintf(prefix, "%s%s", work, remounted_root ? "/mnt" : "");

    size_t prefix_len = strlen(prefix);
    size_t path_len = strlen(path);

    if (path_len >= prefix_len && memcmp(path, prefix, prefix_len) == 0)
        memmove(path, path + prefix_len, path_len - prefix_len + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, -0x8(%rbp)
leaq -0x1010(%rbp), %rdi
movq 0x2853(%rip), %rdx      # 0x50a0
movb 0x2854(%rip), %sil      # 0x50a8
leaq 0x9d4(%rip), %rcx       # 0x322f
leaq 0xb5a(%rip), %rax       # 0x33bc
testb $0x1, %sil
cmovneq %rax, %rcx
leaq 0xb46(%rip), %rsi       # 0x33b7
movb $0x0, %al
callq 0x10f0
leaq -0x1010(%rbp), %rdi
callq 0x1040
movq %rax, -0x1018(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1040
movq %rax, -0x1020(%rbp)
movq -0x1020(%rbp), %rax
cmpq -0x1018(%rbp), %rax
jb 0x28ed
movq -0x8(%rbp), %rdi
leaq -0x1010(%rbp), %rsi
movq -0x1018(%rbp), %rdx
callq 0x1080
cmpl $0x0, %eax
jne 0x28ed
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq -0x1018(%rbp), %rsi
movq -0x1020(%rbp), %rdx
subq -0x1018(%rbp), %rdx
addq $0x1, %rdx
callq 0x10c0
addq $0x1020, %rsp           # imm = 0x1020
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/crc32/main.c
// Function: perftest
static int
perftest(void)
{

	/* Inform user. */
	print_hardware("CRC32C time trial");
	printf("Hashing %zu bytes.\n", nbytes_perftest);
	fflush(stdout);

	/* Time the function. */
	if (perftest_buffers(nbytes_perftest, perfsizes, num_perf,
	    nbytes_warmup, 1, perftest_init, perftest_func, NULL, NULL)) {
		warn0("perftest_buffers");
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x2b2b(%rip), %rdi      # 0x400a
callq 0x18e0
leaq 0x2b31(%rip), %rdi      # 0x401c
movl $0x20000000, %esi       # imm = 0x20000000
movb $0x0, %al
callq 0x10d0
movq 0x5ada(%rip), %rax      # 0x6fd8
movq (%rax), %rdi
callq 0x1160
movl $0x20000000, %edi       # imm = 0x20000000
leaq 0x2c7e(%rip), %rsi      # 0x4190
movl $0xb, %edx
movl $0x7d00000, %ecx        # imm = 0x7D00000
movl $0x1, %r8d
leaq 0x407(%rip), %r9        # 0x1930
leaq 0x430(%rip), %rax       # 0x1960
xorl %r10d, %r10d
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x3020
cmpl $0x0, %eax
je 0x1570
jmp 0x1555
leaq 0x2ad4(%rip), %rdi      # 0x4030
movb $0x0, %al
callq 0x3880
callq 0x1070
movl $0x0, (%rax)
jmp 0x1579
movl $0x0, -0x4(%rbp)
jmp 0x1580
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/crc32/main.c
// Function: perftest_func
static int
perftest_func(void * cookie, uint8_t * buf, size_t buflen, size_t nreps)
{
	CRC32C_CTX ctx;
	uint8_t cbuf[4];
	size_t i;

	(void)cookie; /* UNUSED */

	/* Do the hashing. */
	for (i = 0; i < nreps; i++) {
		CRC32C_Init(&ctx);
		CRC32C_Update(&ctx, buf, buflen);
		CRC32C_Final(cbuf, &ctx);
	}

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x19bf
leaq -0x24(%rbp), %rdi
callq 0x1a70
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x24(%rbp), %rdi
callq 0x1c10
leaq -0x28(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x1d80
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1980
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)