LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_read_ext8
bool cmp_read_ext8(cmp_ctx_t *ctx, int8_t *type, uint8_t *size, void *data) {
  if (!cmp_read_ext8_marker(ctx, type, size))
    return false;

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

  ctx->error = DATA_READING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq -0x30(%rbp), %rsi
callq 0x2f8d
testb %al, %al
je 0x3d90
cmpb $0x9, -0x30(%rbp)
jne 0x3d8d
movb -0x28(%rbp), %al
movb %al, (%r12)
movl -0x24(%rbp), %eax
movzbl %al, %edx
movb %dl, (%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq *0x10(%rbx)
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x3d92
movb $0x9, (%rbx)
jmp 0x3d90
movb $0xd, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_read_ext16_marker
bool cmp_read_ext16_marker(cmp_ctx_t *ctx, int8_t *type, uint16_t *size) {
  cmp_object_t obj;

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

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

  *type = obj.as.ext.type;
  *size = (uint16_t)obj.as.ext.size;

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x28(%rbp), %rsi
callq 0x2f8d
testb %al, %al
je 0x3ddd
cmpb $0xa, -0x28(%rbp)
jne 0x3dd9
movb -0x20(%rbp), %al
movb %al, (%r14)
movzwl -0x1c(%rbp), %eax
movw %ax, (%rbx)
movb $0x1, %al
jmp 0x3ddf
movb $0xd, (%r15)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_read_ext16
bool cmp_read_ext16(cmp_ctx_t *ctx, int8_t *type, uint16_t *size, void *data) {
  if (!cmp_read_ext16_marker(ctx, type, size))
    return false;

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

  ctx->error = DATA_READING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq -0x30(%rbp), %rsi
callq 0x2f8d
testb %al, %al
je 0x3e42
cmpb $0xa, -0x30(%rbp)
jne 0x3e3f
movb -0x28(%rbp), %al
movb %al, (%r12)
movl -0x24(%rbp), %eax
movzwl %ax, %edx
movw %dx, (%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq *0x10(%rbx)
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x3e44
movb $0x9, (%rbx)
jmp 0x3e42
movb $0xd, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_read_ext32_marker
bool cmp_read_ext32_marker(cmp_ctx_t *ctx, int8_t *type, uint32_t *size) {
  cmp_object_t obj;

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

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

  *type = obj.as.ext.type;
  *size = obj.as.ext.size;

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x28(%rbp), %rsi
callq 0x2f8d
testb %al, %al
je 0x3e8d
cmpb $0xb, -0x28(%rbp)
jne 0x3e89
movb -0x20(%rbp), %al
movb %al, (%r14)
movl -0x1c(%rbp), %eax
movl %eax, (%rbx)
movb $0x1, %al
jmp 0x3e8f
movb $0xd, (%r15)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_read_ext32
bool cmp_read_ext32(cmp_ctx_t *ctx, int8_t *type, uint32_t *size, void *data) {
  if (!cmp_read_ext32_marker(ctx, type, size))
    return false;

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

  ctx->error = DATA_READING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq -0x30(%rbp), %rsi
callq 0x2f8d
testb %al, %al
je 0x3eee
cmpb $0xb, -0x30(%rbp)
jne 0x3eeb
movb -0x28(%rbp), %al
movb %al, (%r12)
movl -0x24(%rbp), %edx
movl %edx, (%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq *0x10(%rbx)
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x3ef0
movb $0x9, (%rbx)
jmp 0x3eee
movb $0xd, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_read_ext_marker
bool cmp_read_ext_marker(cmp_ctx_t *ctx, int8_t *type, uint32_t *size) {
  cmp_object_t obj;

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

  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:
      ctx->error = INVALID_TYPE_ERROR;
      return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x28(%rbp), %rsi
callq 0x2f8d
testb %al, %al
je 0x3f46
movzbl -0x28(%rbp), %eax
cmpl $0x1a, %eax
ja 0x3f42
movl $0x7c00e00, %ecx        # imm = 0x7C00E00
btl %eax, %ecx
jae 0x3f42
movb -0x20(%rbp), %al
movb %al, (%r14)
movl -0x1c(%rbp), %eax
movl %eax, (%rbx)
movb $0x1, %al
jmp 0x3f48
movb $0xd, (%r15)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_read_ext
bool cmp_read_ext(cmp_ctx_t *ctx, int8_t *type, uint32_t *size, void *data) {
  if (!cmp_read_ext_marker(ctx, type, size))
    return false;

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

  ctx->error = DATA_READING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
callq 0x3efd
testb %al, %al
je 0x3f86
movl (%r15), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x10(%rbx)
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x3f88
movb $0x9, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x22(%rbp), %rsi
movb $0x0, (%rsi)
movl $0x0, -0x28(%rbp)
movl $0x1, %edx
callq *0x10(%rdi)
testb %al, %al
je 0x42ad
movzbl -0x22(%rbp), %r15d
leaq -0x21(%rbp), %rsi
movl %r15d, %edi
callq 0x3f93
testb %al, %al
je 0x42b2
movzbl -0x21(%rbp), %r12d
cmpq $0x21, %r12
ja 0x42c8
movabsq $0x3c0000006, %rax      # imm = 0x3C0000006
btq %r12, %rax
jae 0x42c8
movb %r12b, (%r14)
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x3fee
testb %al, %al
je 0x42b5
movb $0x10, (%rbx)
jmp 0x42b5
movb $0x7, (%rbx)
jmp 0x42b5
movb $0xd, (%rbx)
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movzbl %r12b, %edx
leaq -0x28(%rbp), %rcx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x430c
testb %al, %al
je 0x42b5
movl -0x28(%rbp), %eax
movb $0x1, %r14b
testl %eax, %eax
je 0x42b8
cmpl $0x1a, %r12d
ja 0x42ff
movl $0x7c00e00, %ecx        # imm = 0x7C00E00
btl %r12d, %ecx
jae 0x42ff
incl %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %esi
movq %rbx, %rdi
callq 0x4455
jmp 0x42b8
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x4480
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
testq %rbx, %rbx
je 0x44b5
leaq -0x19(%rbp), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq *0x10(%r14)
testb %al, %al
je 0x44b5
leaq -0x19(%rbp), %r15
decq %rbx
je 0x44b5
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq *0x10(%r14)
testb %al, %al
jne 0x449d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movzbl (%rdi), %ecx
xorl %eax, %eax
cmpl $0x11, %ecx
jg 0x4b43
testl %ecx, %ecx
je 0x4b4d
cmpl $0xe, %ecx
jne 0x4b54
movb 0x8(%rdi), %al
testb %al, %al
jns 0x4b50
xorl %eax, %eax
jmp 0x4b54
cmpl $0x22, %ecx
je 0x4b4d
cmpl $0x12, %ecx
jne 0x4b54
movb 0x8(%rdi), %al
movb %al, (%rsi)
movb $0x1, %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movzbl (%rdi), %ecx
xorl %eax, %eax
leal -0xe(%rcx), %edx
cmpl $0x5, %edx
ja 0x4b7d
leaq 0x1856(%rip), %rcx      # 0x63c4
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movzbl 0x8(%rdi), %eax
jmp 0x4b9b
cmpl $0x22, %ecx
je 0x4b86
testl %ecx, %ecx
jne 0x4ba0
movsbl 0x8(%rdi), %eax
jmp 0x4b9b
movzwl 0x8(%rdi), %eax
jmp 0x4b9b
movzwl 0x8(%rdi), %eax
testw %ax, %ax
js 0x4ba2
movw %ax, (%rsi)
movb $0x1, %al
popq %rbp
retq
xorl %eax, %eax
jmp 0x4ba0
// File: /workspace/github_c_makefile_star2_O1/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
movzbl (%rdi), %ecx
xorl %eax, %eax
leal -0xe(%rcx), %edx
cmpl $0x6, %edx
ja 0x4bcd
leaq 0x181e(%rip), %rcx      # 0x63dc
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movzbl 0x8(%rdi), %eax
jmp 0x4bf6
cmpl $0x22, %ecx
je 0x4bd6
testl %ecx, %ecx
jne 0x4bfa
movsbl 0x8(%rdi), %eax
jmp 0x4bf6
movl 0x8(%rdi), %eax
testl %eax, %eax
jns 0x4bf6
xorl %eax, %eax
jmp 0x4bfa
movswl 0x8(%rdi), %eax
jmp 0x4bf6
movzwl 0x8(%rdi), %eax
jmp 0x4bf6
movl 0x8(%rdi), %eax
movl %eax, (%rsi)
movb $0x1, %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movzbl (%rdi), %eax
testl %eax, %eax
je 0x4c9a
cmpl $0xf, %eax
je 0x4ca0
cmpl $0xe, %eax
jne 0x4cab
movzbl 0x8(%rdi), %eax
jmp 0x4ca4
movzwl 0x8(%rdi), %eax
movw %ax, (%rsi)
movb $0x1, %al
jmp 0x4cad
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movzbl (%rdi), %ecx
xorl %eax, %eax
cmpl $0xe, %ecx
jg 0x4ccc
testl %ecx, %ecx
je 0x4cc6
cmpl $0xe, %ecx
jne 0x4ce3
movzbl 0x8(%rdi), %eax
jmp 0x4cdf
cmpl $0xf, %ecx
je 0x4cdb
cmpl $0x10, %ecx
jne 0x4ce3
movl 0x8(%rdi), %eax
jmp 0x4cdf
movzwl 0x8(%rdi), %eax
movl %eax, (%rsi)
movb $0x1, %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movzbl (%rdi), %ecx
leal -0xe(%rcx), %eax
cmpl $0x3, %eax
ja 0x4d0a
leaq 0x1751(%rip), %rcx      # 0x644c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzwl 0x8(%rdi), %eax
jmp 0x4d21
testl %ecx, %ecx
jne 0x4d14
movzbl 0x8(%rdi), %eax
jmp 0x4d21
xorl %eax, %eax
jmp 0x4d26
movl 0x8(%rdi), %eax
jmp 0x4d21
movq 0x8(%rdi), %rax
movq %rax, (%rsi)
movb $0x1, %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movb (%rdi), %al
cmpb $0xc, %al
jne 0x4d45
movss 0x8(%rdi), %xmm0
movss %xmm0, (%rsi)
cmpb $0xc, %al
sete %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movb (%rdi), %al
cmpb $0xd, %al
jne 0x4d5f
movsd 0x8(%rdi), %xmm0
movsd %xmm0, (%rsi)
cmpb $0xd, %al
sete %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movb (%rdi), %al
cmpb $0x5, %al
jne 0x4d75
movb 0x8(%rdi), %cl
movb %cl, (%rsi)
cmpb $0x5, %al
sete %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movb (%rdi), %al
addb $-0x6, %al
cmpb $0x2, %al
ja 0x4dae
movl 0x8(%rdi), %ecx
movl %ecx, (%rsi)
cmpb $0x3, %al
setb %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movzbl (%rdi), %ecx
xorl %eax, %eax
cmpl $0x1a, %ecx
ja 0x4e24
movl $0x7c00e00, %r8d        # imm = 0x7C00E00
btl %ecx, %r8d
jae 0x4e24
movb 0x8(%rdi), %al
movb %al, (%rsi)
movl 0xc(%rdi), %eax
movl %eax, (%rdx)
movb $0x1, %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movzbl (%rsi), %edx
xorl %eax, %eax
cmpl $0x1d, %edx
ja 0x4e7c
movq %rdi, %r14
movl $0x38000008, %edi       # imm = 0x38000008
btl %edx, %edi
jae 0x4e7c
movl 0x8(%rsi), %r15d
leal 0x1(%r15), %eax
cmpl %ecx, %eax
jbe 0x4e5c
movb $0x1, (%r14)
jmp 0x4e7a
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq *0x10(%r14)
testb %al, %al
je 0x4e76
movb $0x0, (%rbx,%r15)
movb $0x1, %al
jmp 0x4e7c
movb $0x9, (%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movb (%rsi), %al
addb $-0x6, %al
cmpb $0x2, %al
ja 0x4ec5
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rsi), %eax
movb $0x2, %sil
cmpl %ecx, %eax
ja 0x4eb9
movq %rbx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq *0x10(%rbx)
movl %eax, %ecx
movb $0x9, %sil
movb $0x1, %al
testb %cl, %cl
jne 0x4ebe
movb %sil, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq 0x10(%rdi), %rax
leaq (%rax,%rdx), %r14
cmpq (%rdi), %r14
ja 0x4f1f
movq %rdi, %rbx
addq 0x8(%rdi), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x10a0
movq %r14, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1140
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %edx, %ebx
leaq -0x38(%rbp), %r14
movq %rdi, (%r14)
movq %rsi, 0x8(%r14)
movq $0x0, 0x10(%r14)
leaq 0x6a(%rip), %rdx        # 0x4fd0
leaq 0x74(%rip), %rcx        # 0x4fe1
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
xorl %r8d, %r8d
callq 0x1460
movq 0x10(%r14), %rax
cmpq (%r14), %rax
je 0x4fba
leaq -0x60(%rbp), %r14
leaq -0x70(%rbp), %r15
movzbl %bl, %ebx
leaq -0x38(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2f8d
testb %al, %al
je 0x4fc7
movq %r12, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x4ff2
movq -0x28(%rbp), %rax
cmpq -0x38(%rbp), %rax
jne 0x4f94
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x60(%rbp), %rdi
callq 0x1170
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r15d
movq %rdi, %r12
movl %edx, %r14d
movq %r14, %rdi
callq 0x10b0
movq %rax, %rbx
movq %r12, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x4ef0
testl %r15d, %r15d
je 0x5293
movq 0x5d7e(%rip), %r15      # 0xafd8
movq (%r15), %rcx
leaq 0x17ec(%rip), %rdi      # 0x6a50
movl $0x2, %esi
movl $0x1, %edx
callq 0x10f0
movq (%r15), %rcx
movl $0x1, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x10f0
movq (%r15), %rsi
movl $0x22, %edi
callq 0x1090
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1030
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rax
xorl %eax, %eax
callq *0x3bf3(%rip)           # 0x60b8
cmpl 0x3bc5(%rip), %eax      # 0x6090
movl $0x1, %ecx
cmovnel %eax, %ecx
movl %ecx, 0x3bb7(%rip)      # 0x6090
cmpl $0x1, %ecx
je 0x250a
leaq 0x1b8e(%rip), %rdi      # 0x4073
callq 0x2030
movq %rax, 0x3baf(%rip)      # 0x60a0
leaq 0x1b80(%rip), %rdi      # 0x4078
callq 0x20c0
leaq 0x1b7f(%rip), %rdi      # 0x4083
popq %rax
jmp 0x20c0
leaq 0x1b33(%rip), %rsi      # 0x4044
movl $0x1, %edi
xorl %eax, %eax
callq 0x2050
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x2c22(%rip), %rdi      # 0x44f3
leaq 0x2732(%rip), %rsi      # 0x400a
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10f0
leaq 0x6908(%rip), %r15      # 0x81f0
leaq 0x2874(%rip), %r14      # 0x4163
cmpl $0x0, (%r15)
jne 0x1920
leaq 0x68f8(%rip), %r12      # 0x81f4
cmpl $0x0, (%r12)
je 0x190c
leaq 0x2842(%rip), %r14      # 0x414c
jmp 0x1920
callq 0x2130
movl %eax, (%r15)
movl $0x1, (%r12)
testl %eax, %eax
je 0x1903
movq %r14, %rdi
callq 0x10b0
leaq 0x26ed(%rip), %rdi      # 0x401c
movl $0x20000000, %esi       # imm = 0x20000000
xorl %eax, %eax
callq 0x10f0
movq 0x5696(%rip), %rax      # 0x6fd8
movq (%rax), %rdi
callq 0x1190
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsp)
leaq 0x2e6(%rip), %rax       # 0x1c3f
movq %rax, (%rsp)
leaq 0x282c(%rip), %rsi      # 0x4190
leaq 0x2c5(%rip), %r9        # 0x1c30
movl $0x20000000, %edi       # imm = 0x20000000
movl $0xb, %edx
movl $0x7d00000, %ecx        # imm = 0x7D00000
movl $0x1, %r8d
callq 0x274c
testl %eax, %eax
je 0x19a7
leaq 0x26a0(%rip), %rdi      # 0x4030
xorl %eax, %eax
callq 0x2cdb
callq 0x1080
movl $0x0, (%rax)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rcx, %rcx
je 0x1c97
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x8(%rsp), %r12
leaq 0xc(%rsp), %r13
movq %r12, %rdi
callq 0x1c9c
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1f4c
movq %r13, %rdi
movq %r12, %rsi
callq 0x2034
decq %rbx
jne 0x1c64
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/kobolt[P]curses-collection/cgame/cgame.c
// Function: draw_screen
static void draw_screen(void)
{
  int i;

  erase();

  box(stdscr, '|', '-');

  for (i = 0; i < AMOUNT_OF_MONEY; i++)
    if (! money[i].taken)
      draw_object(&money[i]);
  for (i = 0; i < AMOUNT_OF_MINES; i++)
    draw_object(&mines[i]);
  for (i = 0; i < AMOUNT_OF_CRATES; i++)
    draw_object(&crates[i]);
  draw_object(&player);
  draw_object(&enemy);

  move(player.y, player.x);

  refresh();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x2904(%rip), %rbx      # 0x3fd8
movq (%rbx), %rdi
callq 0x1050
movq (%rbx), %rdi
subq $0x8, %rsp
xorl %r14d, %r14d
movl $0x7c, %esi
movl $0x7c, %edx
movl $0x2d, %ecx
movl $0x2d, %r8d
xorl %r9d, %r9d
pushq %r14
pushq %r14
pushq %r14
callq 0x1070
addq $0x20, %rsp
leaq 0x29dc(%rip), %r15      # 0x40f0
cmpl $0x0, 0x10(%r14,%r15)
jne 0x1725
leaq (%r15,%r14), %rdi
callq 0x19a5
addq $0x14, %r14
cmpq $0x190, %r14            # imm = 0x190
jne 0x1714
xorl %r14d, %r14d
leaq 0x2b64(%rip), %r15      # 0x42a0
leaq (%r15,%r14), %rdi
callq 0x19a5
addq $0x14, %r14
cmpq $0xc8, %r14
jne 0x173c
xorl %r14d, %r14d
leaq 0x2c14(%rip), %r15      # 0x4370
leaq (%r15,%r14), %rdi
callq 0x19a5
addq $0x14, %r14
cmpq $0x64, %r14
jne 0x175c
leaq 0x295a(%rip), %rdi      # 0x40d0
callq 0x19a5
leaq 0x2b02(%rip), %rdi      # 0x4284
callq 0x19a5
movq (%rbx), %rdi
movl 0x2940(%rip), %esi      # 0x40d0
movl 0x293e(%rip), %edx      # 0x40d4
callq 0x1130
movq (%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O1/kobolt[P]curses-collection/cgame/cgame.c
// Function: find_empty_spot
static void find_empty_spot(int *y, int *x)
{
  do {
    move((random() % (GAME_ROWS - 2)) + 1, (random() % (GAME_COLS - 2)) + 1);
  } while ((inch() & A_CHARTEXT) != ' ');
  getyx(stdscr, *y, *x);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
movq %rdi, %r14
movq 0x26e0(%rip), %r13      # 0x3fd8
movabsq $0x2e8ba2e8ba2e8ba3, %rbp # imm = 0x2E8BA2E8BA2E8BA3
movabsq $0x6906906906906907, %rbx # imm = 0x6906906906906907
movq (%r13), %r15
callq 0x1100
movq %rax, %r12
imulq %rbp
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x2, %rdx
addl %eax, %edx
leal (%rdx,%rdx,4), %eax
leal (%rdx,%rax,4), %eax
addl %edx, %eax
subl %eax, %r12d
incl %r12d
callq 0x1100
movq %rax, %rcx
imulq %rbx
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x5, %rdx
addl %eax, %edx
imull $0x4e, %edx, %eax
subl %eax, %ecx
incl %ecx
movq %r15, %rdi
movl %r12d, %esi
movl %ecx, %edx
callq 0x1130
movq (%r13), %rdi
callq 0x1120
cmpb $0x20, %al
jne 0x190c
movq (%r13), %rax
testq %rax, %rax
je 0x1984
movswl (%rax), %ecx
movl %ecx, (%r14)
movswl 0x2(%rax), %eax
jmp 0x1990
movl $0xffffffff, (%r14)     # imm = 0xFFFFFFFF
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq (%rsp), %rcx
movl %eax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kobolt[P]curses-collection/cgame/cgame.c
// Function: draw_object
static void draw_object(object_t *object)
{
  if (object->attributes != 0 && has_colors())
    wattrset(stdscr, object->attributes);
  mvaddch(object->y, object->x, object->symbol);
  if (object->attributes != 0 && has_colors())
    wattrset(stdscr, A_NORMAL);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xc(%rdi)
je 0x19cd
callq 0x1030
testb %al, %al
je 0x19cd
movq 0x2616(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
movl 0xc(%rbx), %esi
callq 0x1040
movq 0x2604(%rip), %r14      # 0x3fd8
movq (%r14), %rdi
movl (%rbx), %esi
movl 0x4(%rbx), %edx
callq 0x1130
cmpl $-0x1, %eax
je 0x19f2
movq (%r14), %rdi
movsbl 0x8(%rbx), %esi
callq 0x1140
cmpl $0x0, 0xc(%rbx)
je 0x1a12
callq 0x1030
testb %al, %al
je 0x1a12
movq (%r14), %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1040
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/misc/mkptyfl.c
// Function: raw
int
raw(int fd)
{
	struct termios tio;
	if(tcgetattr(fd, &tio) < 0) return -1;
	tiosaved = tio;
	cfmakeraw(&tio);
	if(tcsetattr(fd, TCSAFLUSH, &tio) < 0) return -1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edi, %ebx
leaq -0x4c(%rbp), %rsi
callq 0x1110
testl %eax, %eax
js 0x1325
leaq -0x4c(%rbp), %r14
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x2c(%r14), %xmm3
movups %xmm3, 0x2e2c(%rip)     # 0x4120
movups %xmm2, 0x2e19(%rip)     # 0x4114
movups %xmm1, 0x2e02(%rip)     # 0x4104
movups %xmm0, 0x2deb(%rip)     # 0x40f4
movq %r14, %rdi
callq 0x10f0
movl %ebx, %edi
movl $0x2, %esi
movq %r14, %rdx
callq 0x1120
sarl $0x1f, %eax
jmp 0x132a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/misc/mkptyfl.c
// Function: putfl
void
putfl(int c, int fd)
{
	char s[10];

	c = ucase*0100 + (c&0177);
	c = fl2ascii[c];
	switch(c){
	case -1: return;
	case FlColor:
		color = !color;
		if(color == 0){
			sprintf(s, "\e[39;49m");
			write(fd, s, 8);
		}else{
			sprintf(s, "\e[31m");
			write(fd, s, 5);
		}
		break;
	case FlStop:
		break;
	case FlUCase:
		ucase = 1;
		break;
	case FlLCase:
		ucase = 0;
		break;
	case FlNull:
		break;
	default:
		if(c == '\n'){
			s[0] = '\r';
			s[1] = '\n';
			write(fd, s, 2);
		}else{
			s[0] = c;
			write(fd, s, 1);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movslq 0x2dd2(%rip), %rax      # 0x4130
shlq $0x6, %rax
andl $0x7f, %edi
addq %rax, %rdi
leaq 0xcc1(%rip), %rax       # 0x2030
movl (%rax,%rdi,4), %ecx
leal 0x6(%rcx), %eax
cmpl $0x5, %eax
ja 0x13c6
leaq 0xc8f(%rip), %rcx       # 0x2010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, 0x2d9c(%rip)      # 0x4130
jmp 0x1412
xorl %eax, %eax
cmpl $0x0, 0x2d95(%rip)      # 0x4134
sete %al
movl %eax, 0x2d8c(%rip)      # 0x4134
je 0x13f3
movabsq $0x6d39343b39335b1b, %rcx # imm = 0x6D39343B39335B1B
leaq -0x10(%rbp), %rax
movq %rcx, (%rax)
movb $0x0, 0x8(%rax)
movl $0x8, %edx
jmp 0x1408
andl $-0x41, %edi
leaq -0x10(%rbp), %rax
cmpl $0x29, %edi
jne 0x13ea
movw $0xa0d, (%rax)          # imm = 0xA0D
movl $0x2, %edx
jmp 0x1408
movl $0x1, 0x2d48(%rip)      # 0x4130
jmp 0x1412
movb %cl, (%rax)
movl $0x1, %edx
jmp 0x1408
leaq -0x10(%rbp), %rax
movw $0x6d, 0x4(%rax)
movl $0x31335b1b, (%rax)     # imm = 0x31335B1B
movl $0x5, %edx
movl %esi, %edi
movq %rax, %rsi
callq 0x1070
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/misc/mkptyfl.c
// Function: putascii
void
putascii(int c, int fd, int localfd)
{
	char s[2];
	int n;
	c = ascii2fl[c];
	if(c < 0)
		return;
	n = 0;
	if(c & 0300){
		if(c & 0100 && ucase)
			s[n++] = 075;
		else if(c & 0200 && !ucase)
			s[n++] = 071;
	}
	s[n++] = c & 077;
	write(fd, s, n);

// local echo
int i;
for(i = 0; i < n; i++)
	putfl(s[i], localfd);
}

// Assembly:
movslq %edi, %rax
leaq 0xe0e(%rip), %rcx       # 0x2230
movl (%rcx,%rax,4), %eax
testl %eax, %eax
js 0x14b7
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
xorl %r14d, %r14d
testb $-0x40, %al
je 0x1478
movl %eax, %edx
shrb $0x6, %dl
movl 0x2ce5(%rip), %ecx      # 0x4130
testl %ecx, %ecx
setne %dil
andb %dl, %dil
cmpb $0x1, %dil
jne 0x1460
movb $0x3d, -0x1a(%rbp)
jmp 0x1472
testl %ecx, %ecx
setne %cl
testb %al, %al
setns %dl
orb %cl, %dl
jne 0x1478
movb $0x39, -0x1a(%rbp)
movl $0x1, %r14d
andb $0x3f, %al
movl %r14d, %ecx
incl %r14d
movb %al, -0x1a(%rbp,%rcx)
leaq -0x1a(%rbp), %rax
movl %esi, %edi
movq %rax, %rsi
movq %r14, %rdx
callq 0x1070
xorl %r15d, %r15d
movsbl -0x1a(%rbp,%r15), %edi
movl %ebx, %esi
callq 0x134f
incq %r15
cmpq %r15, %r14
jne 0x1498
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/misc/mkptyfl.c
// Function: readwrite
void
readwrite(int ttyin, int ttyout, int ptyin, int ptyout)
{
	int n;
	struct pollfd pfd[2];
	char c;

	pfd[0].fd = ptyin;
	pfd[0].events = POLLIN;
	pfd[1].fd = ttyin;
	pfd[1].events = POLLIN;
	while(pfd[0].fd != -1){
		n = poll(pfd, 2, -1);
		if(n < 0){
			perror("error poll");
			return;
		}
		if(n == 0)
			return;
		if(pfd[0].revents & POLLHUP)
			nanosleep(&hupslp, NULL);
		/* read from pty, write to tty */
		if(pfd[0].revents & POLLIN){
			if(n = read(ptyin, &c, 1), n <= 0)
				return;
			else{
				c &= 077;
				putfl(c, ttyout);
				SLEEP;
			}
		}
		/* read from tty, write to pty */
		if(pfd[1].revents & POLLIN){
			if(n = read(ttyin, &c, 1), n <= 0)
				return;
			else{
				c &= 0177;	// needed?
				if(c == 035)
					return;
				putascii(c, ptyout, ttyout);
				SLEEP;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, -0x40(%rbp)
movw $0x1, %ax
movw %ax, -0x3c(%rbp)
movl %edi, -0x38(%rbp)
movw %ax, -0x34(%rbp)
cmpl $-0x1, %edx
je 0x1594
movl %ecx, %ebx
movl %edx, %r14d
movl %esi, %r15d
movl %edi, %r12d
leaq -0x40(%rbp), %r13
movl $0x2, %esi
movq %r13, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x1100
testl %eax, %eax
js 0x15a3
je 0x1594
testb $0x10, -0x3a(%rbp)
je 0x1527
leaq 0x2bc0(%rip), %rdi      # 0x40e0
xorl %esi, %esi
callq 0x10a0
testb $0x1, -0x3a(%rbp)
je 0x1555
movl $0x1, %edx
movl %r14d, %edi
leaq -0x29(%rbp), %rsi
callq 0x10c0
testl %eax, %eax
jle 0x1594
movzbl -0x29(%rbp), %edi
andl $0x3f, %edi
movb %dil, -0x29(%rbp)
movl %r15d, %esi
callq 0x134f
testb $0x1, -0x32(%rbp)
je 0x158a
movl $0x1, %edx
movl %r12d, %edi
leaq -0x29(%rbp), %rsi
callq 0x10c0
testl %eax, %eax
jle 0x1594
movzbl -0x29(%rbp), %edi
andl $0x7f, %edi
movb %dil, -0x29(%rbp)
cmpl $0x1d, %edi
je 0x1594
movl %ebx, %esi
movl %r15d, %edx
callq 0x1418
cmpl $-0x1, -0x40(%rbp)
jne 0x14f3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe95(%rip), %rdi       # 0x243f
callq 0x1140
jmp 0x1594
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/misc/mkptyfl.c
// Function: main
int
main(int argc, char *argv[])
{
	int fd;
	int slv;
	const char *ptylink;

	ptylink = NULL;
	if(argc > 1)
		ptylink = argv[1];

	fd = posix_openpt(O_RDWR);
	if(fd < 0)
		return 1;
	if(grantpt(fd) < 0)
		return 2;
	if(unlockpt(fd) < 0)
		return 3;

	if(ptylink){
		unlink(ptylink);
		if(symlink(ptsname(fd), ptylink) < 0)
			fprintf(stderr, "Error: %s\n", strerror(errno));
	}

	printf("%s\n", ptsname(fd));

	slv = open(ptsname(fd), O_RDWR);
	if(slv < 0)
		return 4;
	raw(slv);
	close(slv);

	raw(0);

	readwrite(0, 1, fd, fd);
	close(fd);

	printf("\e[39;49m");
	reset(0);

	if(ptylink)
		unlink(ptylink);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x2, %edi
jl 0x15c7
movq 0x8(%rsi), %rbx
jmp 0x15c9
xorl %ebx, %ebx
movl $0x2, %r15d
movl $0x2, %edi
callq 0x1170
testl %eax, %eax
js 0x16bc
movl %eax, %r14d
movl %eax, %edi
callq 0x1150
testl %eax, %eax
js 0x16d2
movl %r14d, %edi
callq 0x10d0
testl %eax, %eax
js 0x16c4
testq %rbx, %rbx
je 0x162b
movq %rbx, %rdi
callq 0x1050
movl %r14d, %edi
callq 0x1030
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1090
testl %eax, %eax
js 0x16de
movl %r14d, %edi
callq 0x1030
movq %rax, %rdi
callq 0x1060
movl %r14d, %edi
callq 0x1030
xorl %r15d, %r15d
movq %rax, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x1130
testl %eax, %eax
js 0x16cc
movl %eax, %r12d
movl %eax, %edi
callq 0x12bc
movl %r12d, %edi
callq 0x10b0
xorl %edi, %edi
callq 0x12bc
xorl %edi, %edi
movl $0x1, %esi
movl %r14d, %edx
movl %r14d, %ecx
callq 0x14b8
movl %r14d, %edi
callq 0x10b0
leaq 0xd9d(%rip), %rdi       # 0x2430
xorl %eax, %eax
callq 0x1080
leaq 0x2a53(%rip), %rdx      # 0x40f4
xorl %edi, %edi
movl $0x2, %esi
callq 0x1120
testq %rbx, %rbx
je 0x16d2
movq %rbx, %rdi
callq 0x1050
jmp 0x16d2
movl $0x1, %r15d
jmp 0x16d2
movl $0x3, %r15d
jmp 0x16d2
movl $0x4, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1190
jmp 0x162b
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]kivaloo/tests/s3/main.c
// Function: readtests
static void
readtests(struct wire_requestqueue * Q, const char * bucket)
{

	/* GET with a large buffer. */
	opdone = 0;
	if (proto_s3_request_get(Q, bucket, "s3-testfile", 100,
	    callback_get, NULL) ||
	    events_spin(&opdone)) {
		warn0("GET failed");
		exit(1);
	}

	/* GET with a small buffer. */
	opdone = 0;
	if (proto_s3_request_get(Q, bucket, "s3-testfile", 10,
	    callback_get, NULL) ||
	    events_spin(&opdone)) {
		warn0("GET failed");
		exit(1);
	}

	/* RANGE. */
	opdone = 0;
	if (proto_s3_request_range(Q, bucket, "s3-testfile", 6, 5,
	    callback_range, NULL) ||
	    events_spin(&opdone)) {
		warn0("RANGE failed");
		exit(1);
	}

	/* HEAD. */
	opdone = 0;
	if (proto_s3_request_head(Q, bucket, "s3-testfile",
	    callback_head, NULL) ||
	    events_spin(&opdone)) {
		warn0("HEAD failed");
		exit(1);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x0, 0xcda1(%rip)      # 0xf554
leaq 0x789d(%rip), %rdx      # 0xa057
leaq 0x131(%rip), %r8        # 0x28f2
movl $0x64, %ecx
xorl %r9d, %r9d
callq 0x4599
testl %eax, %eax
jne 0x28bd
leaq 0xcd77(%rip), %rdi      # 0xf554
callq 0x2ce9
testl %eax, %eax
jne 0x28bd
movl $0x0, 0xcd60(%rip)      # 0xf554
leaq 0x785c(%rip), %rdx      # 0xa057
leaq 0xf0(%rip), %r8         # 0x28f2
movl $0xa, %ecx
movq %r14, %rdi
movq %rbx, %rsi
xorl %r9d, %r9d
callq 0x4599
testl %eax, %eax
jne 0x28bd
leaq 0xcd30(%rip), %rdi      # 0xf554
callq 0x2ce9
testl %eax, %eax
jne 0x28bd
movl $0x0, 0xcd19(%rip)      # 0xf554
movq $0x0, (%rsp)
leaq 0x780d(%rip), %rdx      # 0xa057
leaq 0x10f(%rip), %r9        # 0x2960
movq %r14, %rdi
movq %rbx, %rsi
movl $0x6, %ecx
movl $0x5, %r8d
callq 0x4820
testl %eax, %eax
jne 0x28c6
leaq 0xcce2(%rip), %rdi      # 0xf554
callq 0x2ce9
testl %eax, %eax
jne 0x28c6
movl $0x0, 0xcccf(%rip)      # 0xf554
leaq 0x77cb(%rip), %rdx      # 0xa057
leaq 0x13b(%rip), %rcx       # 0x29ce
movq %r14, %rdi
movq %rbx, %rsi
xorl %r8d, %r8d
callq 0x4af6
testl %eax, %eax
jne 0x28cf
leaq 0xcca8(%rip), %rdi      # 0xf554
callq 0x2ce9
testl %eax, %eax
jne 0x28cf
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x779f(%rip), %rdi      # 0xa063
jmp 0x28d6
leaq 0x77a1(%rip), %rdi      # 0xa06e
jmp 0x28d6
leaq 0x77a5(%rip), %rdi      # 0xa07b
xorl %eax, %eax
callq 0x4233
callq 0x2090
movl $0x0, (%rax)
movl $0x1, %edi
callq 0x22b0
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]kivaloo/tests/s3/main.c
// Function: callback_get
static int
callback_get(void * cookie, int failed, size_t len, const uint8_t * buf)
{

	(void)cookie; /* UNUSED */

	/* Print status. */
	printf("GET failed = %d len = %zd\n", failed, (ssize_t)len);

	/* Print data. */
	if (buf != NULL) {
		printf("GET data = >>>");
		fwrite(buf, len, 1, stdout);
		printf("<<<\n");
	} else {
		printf("GET data = NULL\n");
	}

	/* We're done. */
	opdone = 1;
	return (0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
leaq 0x7784(%rip), %rdi      # 0xa087
xorl %eax, %eax
callq 0x2140
testq %r14, %r14
je 0x2940
leaq 0x778c(%rip), %rdi      # 0xa0a2
xorl %eax, %eax
callq 0x2140
movq 0xc6ac(%rip), %rax      # 0xefd0
movq (%rax), %rcx
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22d0
leaq 0x782c(%rip), %rdi      # 0xa16a
jmp 0x2947
leaq 0x7801(%rip), %rdi      # 0xa148
callq 0x20b0
movl $0x1, 0xcbfe(%rip)      # 0xf554
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]kivaloo/tests/s3/main.c
// Function: callback_range
static int
callback_range(void * cookie, int failed, size_t buflen, const uint8_t * buf)
{

	(void)cookie; /* UNUSED */

	/* Print status. */
	printf("RANGE failed = %d buflen = %zd\n", failed, (ssize_t)buflen);

	/* Print data. */
	if (buf != NULL) {
		printf("RANGE data = >>>");
		fwrite(buf, buflen, 1, stdout);
		printf("<<<\n");
	} else {
		printf("RANGE data = NULL\n");
	}

	/* We're done. */
	opdone = 1;
	return (0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
leaq 0x7740(%rip), %rdi      # 0xa0b1
xorl %eax, %eax
callq 0x2140
testq %r14, %r14
je 0x29ae
leaq 0x774d(%rip), %rdi      # 0xa0d1
xorl %eax, %eax
callq 0x2140
movq 0xc63e(%rip), %rax      # 0xefd0
movq (%rax), %rcx
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22d0
leaq 0x77be(%rip), %rdi      # 0xa16a
jmp 0x29b5
leaq 0x77a3(%rip), %rdi      # 0xa158
callq 0x20b0
movl $0x1, 0xcb90(%rip)      # 0xf554
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]kivaloo/liball/../lib/proto_s3/proto_s3_client.c
// Function: callback_put
static int
callback_put(void * cookie, uint8_t * buf, size_t buflen)
{
	struct put_cookie * C = cookie;
	int failed = 1;
	uint32_t status;
	int rc;

	/* If we have a packet, parse it. */
	if (buf != NULL) {
		/* Do we have the right packet length? */
		if (buflen != 4)
			BAD("PUT", "bogus length");

		/* Parse the packet. */
		status = be32dec(&buf[0]);

		/* Check status. */
		if ((status != 0) && ((status < 100) || (status > 599)))
			BAD("PUT", "Invalid HTTP status");

		/* Did the operation succeed? */
		if (status == 200)
			failed = 0;
	}

failed:
	/* Invoke the upstream callback. */
	rc = (C->callback)(C->cookie, failed);

	/* Free the cookie. */
	free(C);

	/* Return status from callback. */
	return (rc);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %ebp
testq %rsi, %rsi
je 0x457e
cmpq $0x4, %rdx
jne 0x454a
movl (%rsi), %eax
bswapl %eax
testl %eax, %eax
sete %cl
leal -0x258(%rax), %edx
cmpl $0xfffffe0c, %edx       # imm = 0xFFFFFE0C
setae %dl
orb %cl, %dl
jne 0x4573
leaq 0x5fac(%rip), %rdi      # 0xa4e6
leaq 0x5fc2(%rip), %rsi      # 0xa503
leaq 0x5fcc(%rip), %rdx      # 0xa514
jmp 0x455f
leaq 0x5f95(%rip), %rdi      # 0xa4e6
leaq 0x5fab(%rip), %rsi      # 0xa503
leaq 0x5fa8(%rip), %rdx      # 0xa507
xorl %eax, %eax
callq 0x4233
callq 0x2090
movl $0x0, (%rax)
jmp 0x457e
xorl %ebp, %ebp
cmpl $0xc8, %eax
setne %bpl
movq 0x8(%rbx), %rdi
movl %ebp, %esi
callq *(%rbx)
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2040
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]kivaloo/liball/../lib/proto_s3/proto_s3_client.c
// Function: callback_get
static int
callback_get(void * cookie, uint8_t * buf, size_t buflen)
{
	struct get_cookie * C = cookie;
	int failed = 1;
	uint32_t status;
	uint32_t len;
	size_t lens = (size_t)(-1);
	uint8_t * dbuf = NULL;
	int rc;

	/* If we have a packet, parse it. */
	if (buf != NULL) {
		/* Do we have the right packet length? */
		if (buflen < 8)
			BAD("GET", "bogus length");

		/* Parse the packet. */
		status = be32dec(&buf[0]);
		len = be32dec(&buf[4]);

		/* Check status. */
		if ((status != 0) && ((status < 100) || (status > 599)))
			BAD("GET", "Invalid HTTP status");

		/* Do we have the right packet length? */
		if (len != (uint32_t)(-1)) {
			if (buflen != 8 + len)
				BAD("GET", "bogus length");
		} else {
			if (buflen != 8)
				BAD("GET", "bogus length");
		}

		/* Did the operation succeed? */
		if (status == 200)
			failed = 0;

		/* Do we have data? */
		if ((failed == 0) && (len != (uint32_t)(-1))) {
			lens = len;
			dbuf = &buf[8];
		}
	}

failed:
	/* Invoke the upstream callback. */
	rc = (C->callback)(C->cookie, failed, lens, dbuf);

	/* Free the cookie. */
	free(C);

	/* Return status from callback. */
	return (rc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %ebp
movq $-0x1, %r14
testq %rsi, %rsi
je 0x4769
cmpq $0x7, %rdx
ja 0x476e
leaq 0x5d8d(%rip), %rdi      # 0xa4e6
leaq 0x5dc8(%rip), %rsi      # 0xa528
leaq 0x5da0(%rip), %rdx      # 0xa507
jmp 0x47a1
xorl %r15d, %r15d
jmp 0x47b6
movl (%rsi), %eax
bswapl %eax
testl %eax, %eax
sete %cl
leal -0x258(%rax), %edi
cmpl $0xfffffe0c, %edi       # imm = 0xFFFFFE0C
setae %dil
orb %cl, %dil
jne 0x47db
leaq 0x5d53(%rip), %rdi      # 0xa4e6
leaq 0x5d8e(%rip), %rsi      # 0xa528
leaq 0x5d73(%rip), %rdx      # 0xa514
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x4233
callq 0x2090
movl $0x0, (%rax)
movq 0x8(%rbx), %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %r15, %rcx
callq *(%rbx)
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2040
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x4(%rsi), %ecx
bswapl %ecx
cmpl $-0x1, %ecx
je 0x47f3
leal 0x8(%rcx), %edi
cmpq %rdx, %rdi
jne 0x4752
jmp 0x47fd
cmpq $0x8, %rdx
jne 0x4752
xorl %r15d, %r15d
xorl %ebp, %ebp
cmpl $0xc8, %eax
setne %bpl
jne 0x47b6
cmpl $-0x1, %ecx
je 0x47b6
movl %ecx, %r14d
addq $0x8, %rsi
xorl %ebp, %ebp
movq %rsi, %r15
jmp 0x47b6