LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x4b6b
testl %ecx, %ecx
je 0x4b75
cmpl $0xe, %ecx
jne 0x4b7c
movb 0x8(%rdi), %al
testb %al, %al
jns 0x4b78
xorl %eax, %eax
jmp 0x4b7c
cmpl $0x22, %ecx
je 0x4b75
cmpl $0x12, %ecx
jne 0x4b7c
movb 0x8(%rdi), %al
movb %al, (%rsi)
movb $0x1, %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4ba5
leaq 0x182e(%rip), %rcx      # 0x63c4
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movzbl 0x8(%rdi), %eax
jmp 0x4bc3
cmpl $0x22, %ecx
je 0x4bae
testl %ecx, %ecx
jne 0x4bc8
movsbl 0x8(%rdi), %eax
jmp 0x4bc3
movzwl 0x8(%rdi), %eax
jmp 0x4bc3
movzwl 0x8(%rdi), %eax
testw %ax, %ax
js 0x4bca
movw %ax, (%rsi)
movb $0x1, %al
popq %rbp
retq
xorl %eax, %eax
jmp 0x4bc8
// File: /workspace/github_c_makefile_star2_O3/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 0x4bf5
leaq 0x17f6(%rip), %rcx      # 0x63dc
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movzbl 0x8(%rdi), %eax
jmp 0x4c1e
cmpl $0x22, %ecx
je 0x4bfe
testl %ecx, %ecx
jne 0x4c22
movsbl 0x8(%rdi), %eax
jmp 0x4c1e
movl 0x8(%rdi), %eax
testl %eax, %eax
jns 0x4c1e
xorl %eax, %eax
jmp 0x4c22
movswl 0x8(%rdi), %eax
jmp 0x4c1e
movzwl 0x8(%rdi), %eax
jmp 0x4c1e
movl 0x8(%rdi), %eax
movl %eax, (%rsi)
movb $0x1, %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4cc2
cmpl $0xf, %eax
je 0x4cc8
cmpl $0xe, %eax
jne 0x4cd3
movzbl 0x8(%rdi), %eax
jmp 0x4ccc
movzwl 0x8(%rdi), %eax
movw %ax, (%rsi)
movb $0x1, %al
jmp 0x4cd5
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4cf4
testl %ecx, %ecx
je 0x4cee
cmpl $0xe, %ecx
jne 0x4d0b
movzbl 0x8(%rdi), %eax
jmp 0x4d07
cmpl $0xf, %ecx
je 0x4d03
cmpl $0x10, %ecx
jne 0x4d0b
movl 0x8(%rdi), %eax
jmp 0x4d07
movzwl 0x8(%rdi), %eax
movl %eax, (%rsi)
movb $0x1, %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4d32
leaq 0x1729(%rip), %rcx      # 0x644c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzwl 0x8(%rdi), %eax
jmp 0x4d49
testl %ecx, %ecx
jne 0x4d3c
movzbl 0x8(%rdi), %eax
jmp 0x4d49
xorl %eax, %eax
jmp 0x4d4e
movl 0x8(%rdi), %eax
jmp 0x4d49
movq 0x8(%rdi), %rax
movq %rax, (%rsi)
movb $0x1, %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4d6d
movss 0x8(%rdi), %xmm0
movss %xmm0, (%rsi)
cmpb $0xc, %al
sete %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4d87
movsd 0x8(%rdi), %xmm0
movsd %xmm0, (%rsi)
cmpb $0xd, %al
sete %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4d9d
movb 0x8(%rdi), %cl
movb %cl, (%rsi)
cmpb $0x5, %al
sete %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4dd6
movl 0x8(%rdi), %ecx
movl %ecx, (%rsi)
cmpb $0x3, %al
setb %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4e4c
movl $0x7c00e00, %r8d        # imm = 0x7C00E00
btl %ecx, %r8d
jae 0x4e4c
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_O3/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 0x4ea4
movq %rdi, %r14
movl $0x38000008, %edi       # imm = 0x38000008
btl %edx, %edi
jae 0x4ea4
movl 0x8(%rsi), %r15d
leal 0x1(%r15), %eax
cmpl %ecx, %eax
jbe 0x4e84
movb $0x1, (%r14)
jmp 0x4ea2
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq *0x10(%r14)
testb %al, %al
je 0x4e9e
movb $0x0, (%rbx,%r15)
movb $0x1, %al
jmp 0x4ea4
movb $0x9, (%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_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 0x4eed
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rsi), %eax
movb $0x2, %sil
cmpl %ecx, %eax
ja 0x4ee1
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 0x4ee6
movb %sil, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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        # 0x4ff8
leaq 0x74(%rip), %rcx        # 0x5009
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
xorl %r8d, %r8d
callq 0x1460
movq 0x10(%r14), %rax
cmpq (%r14), %rax
je 0x4fe2
leaq -0x60(%rbp), %r14
leaq -0x70(%rbp), %r15
movzbl %bl, %ebx
leaq -0x38(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x3047
testb %al, %al
je 0x4fef
movq %r12, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x501a
movq -0x28(%rbp), %rax
cmpq -0x38(%rbp), %rax
jne 0x4fbc
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_O3/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 0x4f18
testl %r15d, %r15d
je 0x52bb
movq 0x5d56(%rip), %r15      # 0xafd8
movq (%r15), %rcx
leaq 0x17c4(%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_O3/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 0x2c21(%rip), %rdi      # 0x4532
leaq 0x26f2(%rip), %rsi      # 0x400a
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10f0
leaq 0x68c8(%rip), %r15      # 0x81f0
leaq 0x2834(%rip), %r14      # 0x4163
cmpl $0x0, (%r15)
jne 0x1960
leaq 0x68b8(%rip), %r12      # 0x81f4
cmpl $0x0, (%r12)
je 0x194c
leaq 0x2802(%rip), %r14      # 0x414c
jmp 0x1960
callq 0x216c
movl %eax, (%r15)
movl $0x1, (%r12)
testl %eax, %eax
je 0x1943
movq %r14, %rdi
callq 0x10b0
leaq 0x26ad(%rip), %rdi      # 0x401c
movl $0x20000000, %esi       # imm = 0x20000000
xorl %eax, %eax
callq 0x10f0
movq 0x5656(%rip), %rax      # 0x6fd8
movq (%rax), %rdi
callq 0x1190
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsp)
leaq 0x2e6(%rip), %rax       # 0x1c7f
movq %rax, (%rsp)
leaq 0x27ec(%rip), %rsi      # 0x4190
leaq 0x2c5(%rip), %r9        # 0x1c70
movl $0x20000000, %edi       # imm = 0x20000000
movl $0xb, %edx
movl $0x7d00000, %ecx        # imm = 0x7D00000
movl $0x1, %r8d
callq 0x282c
testl %eax, %eax
je 0x19e7
leaq 0x2660(%rip), %rdi      # 0x4030
xorl %eax, %eax
callq 0x2dc7
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_O3/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 0x1cd7
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 0x1cdc
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1f8c
movq %r13, %rdi
movq %r12, %rsi
callq 0x2074
decq %rbx
jne 0x1ca4
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x290b(%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 0x29e3(%rip), %r15      # 0x40f0
cmpl $0x0, 0x10(%r14,%r15)
jne 0x171e
leaq (%r15,%r14), %rdi
callq 0x1a85
addq $0x14, %r14
cmpq $0x190, %r14            # imm = 0x190
jne 0x170d
xorl %r14d, %r14d
leaq 0x2b6b(%rip), %r15      # 0x42a0
leaq (%r15,%r14), %rdi
callq 0x1a85
addq $0x14, %r14
cmpq $0xc8, %r14
jne 0x1735
xorl %r14d, %r14d
leaq 0x2c1b(%rip), %r15      # 0x4370
leaq (%r15,%r14), %rdi
callq 0x1a85
addq $0x14, %r14
cmpq $0x64, %r14
jne 0x1755
leaq 0x2961(%rip), %rdi      # 0x40d0
callq 0x1a85
leaq 0x2b09(%rip), %rdi      # 0x4284
callq 0x1a85
movq (%rbx), %rdi
movl 0x2947(%rip), %esi      # 0x40d0
movl 0x2945(%rip), %edx      # 0x40d4
callq 0x1130
movq (%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O3/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 0x25fe(%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 0x19ee
movq (%r13), %rcx
testq %rcx, %rcx
je 0x1a63
movswl (%rcx), %eax
movswl 0x2(%rcx), %ecx
jmp 0x1a6d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %eax, (%r14)
movq (%rsp), %rax
movl %ecx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1aad
callq 0x1030
testb %al, %al
je 0x1aad
movq 0x2536(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
movl 0xc(%rbx), %esi
callq 0x1040
movq 0x2524(%rip), %r14      # 0x3fd8
movq (%r14), %rdi
movl (%rbx), %esi
movl 0x4(%rbx), %edx
callq 0x1130
cmpl $-0x1, %eax
je 0x1ad2
movq (%r14), %rdi
movsbl 0x8(%rbx), %esi
callq 0x1140
cmpl $0x0, 0xc(%rbx)
je 0x1af2
callq 0x1030
testb %al, %al
je 0x1af2
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_O3/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 0x1598
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 0x15a7
je 0x1598
movzwl -0x3a(%rbp), %eax
testb $0x10, %al
je 0x152d
leaq 0x2bbe(%rip), %rdi      # 0x40e0
xorl %esi, %esi
callq 0x10a0
movzwl -0x3a(%rbp), %eax
testb $0x1, %al
je 0x1559
movl $0x1, %edx
movl %r14d, %edi
leaq -0x29(%rbp), %rsi
callq 0x10c0
testl %eax, %eax
jle 0x1598
movzbl -0x29(%rbp), %edi
andl $0x3f, %edi
movb %dil, -0x29(%rbp)
movl %r15d, %esi
callq 0x134f
testb $0x1, -0x32(%rbp)
je 0x158e
movl $0x1, %edx
movl %r12d, %edi
leaq -0x29(%rbp), %rsi
callq 0x10c0
testl %eax, %eax
jle 0x1598
movzbl -0x29(%rbp), %edi
andl $0x7f, %edi
movb %dil, -0x29(%rbp)
cmpl $0x1d, %edi
je 0x1598
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 0xe91(%rip), %rdi       # 0x243f
callq 0x1140
jmp 0x1598
// File: /workspace/github_c_makefile_star2_O3/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 0x15cb
movq 0x8(%rsi), %rbx
jmp 0x15cd
xorl %ebx, %ebx
movl $0x2, %r15d
movl $0x2, %edi
callq 0x1170
testl %eax, %eax
js 0x16c0
movl %eax, %r14d
movl %eax, %edi
callq 0x1150
testl %eax, %eax
js 0x16d6
movl %r14d, %edi
callq 0x10d0
testl %eax, %eax
js 0x16c8
testq %rbx, %rbx
je 0x162f
movq %rbx, %rdi
callq 0x1050
movl %r14d, %edi
callq 0x1030
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1090
testl %eax, %eax
js 0x16e2
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 0x16d0
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 0xd99(%rip), %rdi       # 0x2430
xorl %eax, %eax
callq 0x1080
leaq 0x2a4f(%rip), %rdx      # 0x40f4
xorl %edi, %edi
movl $0x2, %esi
callq 0x1120
testq %rbx, %rbx
je 0x16d6
movq %rbx, %rdi
callq 0x1050
jmp 0x16d6
movl $0x1, %r15d
jmp 0x16d6
movl $0x3, %r15d
jmp 0x16d6
movl $0x4, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1190
jmp 0x162f
// File: /workspace/github_c_makefile_star2_O3/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 0x45c5
testl %eax, %eax
jne 0x28bd
leaq 0xcd77(%rip), %rdi      # 0xf554
callq 0x2cd9
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 0x45c5
testl %eax, %eax
jne 0x28bd
leaq 0xcd30(%rip), %rdi      # 0xf554
callq 0x2cd9
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 0x484a
testl %eax, %eax
jne 0x28c6
leaq 0xcce2(%rip), %rdi      # 0xf554
callq 0x2cd9
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 0x4b20
testl %eax, %eax
jne 0x28cf
leaq 0xcca8(%rip), %rdi      # 0xf554
callq 0x2cd9
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 0x425f
callq 0x2090
movl $0x0, (%rax)
movl $0x1, %edi
callq 0x22b0
// File: /workspace/github_c_makefile_star2_O3/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 0x45aa
cmpq $0x4, %rdx
jne 0x4576
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 0x459f
leaq 0x5f90(%rip), %rdi      # 0xa4f6
leaq 0x5fa6(%rip), %rsi      # 0xa513
leaq 0x5fb0(%rip), %rdx      # 0xa524
jmp 0x458b
leaq 0x5f79(%rip), %rdi      # 0xa4f6
leaq 0x5f8f(%rip), %rsi      # 0xa513
leaq 0x5f8c(%rip), %rdx      # 0xa517
xorl %eax, %eax
callq 0x425f
callq 0x2090
movl $0x0, (%rax)
jmp 0x45aa
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_O3/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 0x4822
cmpq $0x7, %rdx
ja 0x4799
leaq 0x5d6d(%rip), %rdi      # 0xa4f6
leaq 0x5da8(%rip), %rsi      # 0xa538
leaq 0x5d80(%rip), %rdx      # 0xa517
jmp 0x47cc
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 0x47e3
leaq 0x5d38(%rip), %rdi      # 0xa4f6
leaq 0x5d73(%rip), %rsi      # 0xa538
leaq 0x5d58(%rip), %rdx      # 0xa524
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x425f
callq 0x2090
movl $0x0, (%rax)
jmp 0x4825
movl 0x4(%rsi), %ecx
bswapl %ecx
cmpl $-0x1, %ecx
je 0x480d
leal 0x8(%rcx), %edi
cmpq %rdx, %rdi
jne 0x4782
xorl %r15d, %r15d
cmpl $0xc8, %eax
jne 0x4825
movl %ecx, %r14d
addq $0x8, %rsi
movq %rsi, %r15
xorl %ebp, %ebp
jmp 0x4825
cmpq $0x8, %rdx
jne 0x4782
xorl %ebp, %ebp
cmpl $0xc8, %eax
setne %bpl
xorl %r15d, %r15d
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
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]kivaloo/liball/../lib/proto_s3/proto_s3_client.c
// Function: callback_range
static int
callback_range(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("RANGE", "bogus length");

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

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

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

		/* Warn about HTTP 200 responses. */
		if (status == 200)
			BAD("RANGE", "HTTP 200 response");

		/* Did the operation succeed? */
		if (status == 206)
			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 0x4a48
cmpq $0x7, %rdx
ja 0x4a4d
leaq 0x5abe(%rip), %rdi      # 0xa4f6
leaq 0x5afd(%rip), %rsi      # 0xa53c
leaq 0x5ad1(%rip), %rdx      # 0xa517
jmp 0x4a80
xorl %r15d, %r15d
jmp 0x4a95
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 0x4aba
leaq 0x5a84(%rip), %rdi      # 0xa4f6
leaq 0x5ac3(%rip), %rsi      # 0xa53c
leaq 0x5aa4(%rip), %rdx      # 0xa524
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x425f
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 0x4ad2
leal 0x8(%rcx), %edi
cmpq %rdx, %rdi
jne 0x4a31
jmp 0x4adc
cmpq $0x8, %rdx
jne 0x4a31
cmpl $0xc8, %eax
jne 0x4afa
leaq 0x5a0c(%rip), %rdi      # 0xa4f6
leaq 0x5a4b(%rip), %rsi      # 0xa53c
leaq 0x5a4a(%rip), %rdx      # 0xa542
jmp 0x4a80
xorl %r15d, %r15d
xorl %ebp, %ebp
cmpl $0xce, %eax
setne %bpl
jne 0x4a95
cmpl $-0x1, %ecx
je 0x4a95
movl %ecx, %r14d
addq $0x8, %rsi
xorl %ebp, %ebp
movq %rsi, %r15
jmp 0x4a95
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]kivaloo/liball/../lib/proto_s3/proto_s3_client.c
// Function: proto_s3_request_head
int
proto_s3_request_head(struct wire_requestqueue * Q, const char * bucket,
    const char * object,
    int (* callback)(void *, int, size_t), void * cookie)
{
	struct head_cookie * C;
	uint8_t *rbuf, *p;
	size_t rlen;

	/* Validate bucket and object name lengths. */
	if ((strlen(bucket) > 255) || (strlen(object) > 255)) {
		warn0("Bucket or object name is too long");
		goto err0;
	}

	/* Bake a cookie. */
	if ((C = malloc(sizeof(struct head_cookie))) == NULL)
		goto err0;
	C->callback = callback;
	C->cookie = cookie;

	/* Compute request packet size. */
	rlen = 6 + strlen(bucket) + strlen(object);

	/* Start writing a request. */
	if ((p = rbuf =
	    wire_requestqueue_add_getbuf(Q, rlen, callback_head, C)) == NULL)
		goto err1;

	/* Construct request. */
	be32enc(p, PROTO_S3_HEAD);
	p += 4;
	*p++ = (uint8_t)strlen(bucket);
	memcpy(p, bucket, strlen(bucket));
	p += strlen(bucket);
	*p++ = (uint8_t)strlen(object);
	memcpy(p, object, strlen(object));

	/* Finish writing request. */
	if (wire_requestqueue_add_done(Q, rbuf, rlen))
		goto err1;

	/* Success! */
	return (0);

err1:
	free(C);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2110
cmpq $0xff, %rax
ja 0x4b62
movq %rax, %r14
movq %rbp, %rdi
callq 0x2110
cmpq $0x100, %rax            # imm = 0x100
jb 0x4b91
leaq 0x591c(%rip), %rdi      # 0xa485
xorl %eax, %eax
callq 0x425f
callq 0x2090
movl $0x0, (%rax)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %rbp, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movl $0x10, %edi
callq 0x2200
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x4b80
movq %r12, (%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq %r15, %r14
addq $0x6, %r14
leaq 0xb9(%rip), %rdx        # 0x4c85
movq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rax, 0x8(%rsp)
movq %rax, %rcx
callq 0x52ca
testq %rax, %rax
je 0x4c6f
movq %rax, %rbp
movl $0x20000100, (%rax)     # imm = 0x20000100
movq %r13, %rdi
callq 0x2110
movq %r14, 0x10(%rsp)
leaq 0x5(%rbp), %r14
movb %al, 0x4(%rbp)
movq %r13, %rdi
callq 0x2110
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x21e0
movq %r13, %rdi
callq 0x2110
movq %rax, %r14
movq 0x18(%rsp), %r13
movq %r13, %rdi
callq 0x2110
leaq (%r14,%rbp), %r15
addq $0x6, %r15
movb %al, 0x5(%rbp,%r14)
movq %r13, %rdi
callq 0x2110
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x21e0
movq %r12, %rdi
movq %rbp, %rsi
movq 0x10(%rsp), %rdx
callq 0x55c5
testl %eax, %eax
je 0x4c7e
movq 0x8(%rsp), %rdi
callq 0x2040
jmp 0x4b80
xorl %ebx, %ebx
jmp 0x4b80
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]kivaloo/liball/../lib/proto_s3/proto_s3_client.c
// Function: callback_head
static int
callback_head(void * cookie, uint8_t * buf, size_t buflen)
{
	struct head_cookie * C = cookie;
	uint32_t status = 0;
	uint32_t len;
	size_t lens = (size_t)(-1);
	int rc;

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

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

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

		/* If status == 200 and len != -1, we have a length. */
		if ((status == 200) && (len != (uint32_t)(-1)))
			lens = len;
	}

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

	/* 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
movq $-0x1, %r14
testq %rsi, %rsi
je 0x4cd8
cmpq $0x8, %rdx
jne 0x4cdd
movl (%rsi), %r15d
bswapl %r15d
testl %r15d, %r15d
sete %al
leal -0x258(%r15), %ecx
cmpl $0xfffffe0c, %ecx       # imm = 0xFFFFFE0C
setae %cl
orb %al, %cl
jne 0x4d09
leaq 0x582e(%rip), %rdi      # 0xa4f6
leaq 0x5885(%rip), %rsi      # 0xa554
leaq 0x584e(%rip), %rdx      # 0xa524
jmp 0x4cf5
xorl %r15d, %r15d
jmp 0x4d2b
leaq 0x5812(%rip), %rdi      # 0xa4f6
leaq 0x5869(%rip), %rsi      # 0xa554
leaq 0x5825(%rip), %rdx      # 0xa517
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x425f
callq 0x2090
movl $0x0, (%rax)
jmp 0x4d2b
movl 0x4(%rsi), %eax
bswapl %eax
movl $0xc8, %ecx
cmpl %ecx, %r15d
sete %dl
cmpl $-0x1, %eax
setne %sil
testb %sil, %dl
cmovneq %rax, %r14
cmovnel %ecx, %r15d
movq 0x8(%rbx), %rdi
movl %r15d, %esi
movq %r14, %rdx
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
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]kivaloo/liball/../lib/proto_s3/proto_s3_client.c
// Function: proto_s3_request_delete
int
proto_s3_request_delete(struct wire_requestqueue * Q, const char * bucket,
    const char * object, int (* callback)(void *, int), void * cookie)
{
	struct delete_cookie * C;
	uint8_t *rbuf, *p;
	size_t rlen;

	/* Validate bucket and object name lengths. */
	if ((strlen(bucket) > 255) || (strlen(object) > 255)) {
		warn0("Bucket or object name is too long");
		goto err0;
	}

	/* Bake a cookie. */
	if ((C = malloc(sizeof(struct delete_cookie))) == NULL)
		goto err0;
	C->callback = callback;
	C->cookie = cookie;

	/* Compute request packet size. */
	rlen = 6 + strlen(bucket) + strlen(object);

	/* Start writing a request. */
	if ((p = rbuf =
	    wire_requestqueue_add_getbuf(Q, rlen, callback_delete, C)) == NULL)
		goto err1;

	/* Construct request. */
	be32enc(p, PROTO_S3_DELETE);
	p += 4;
	*p++ = (uint8_t)strlen(bucket);
	memcpy(p, bucket, strlen(bucket));
	p += strlen(bucket);
	*p++ = (uint8_t)strlen(object);
	memcpy(p, object, strlen(object));

	/* Finish writing request. */
	if (wire_requestqueue_add_done(Q, rbuf, rlen))
		goto err1;

	/* Success! */
	return (0);

err1:
	free(C);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2110
cmpq $0xff, %rax
ja 0x4d90
movq %rax, %r14
movq %rbp, %rdi
callq 0x2110
cmpq $0x100, %rax            # imm = 0x100
jb 0x4dbf
leaq 0x56ee(%rip), %rdi      # 0xa485
xorl %eax, %eax
callq 0x425f
callq 0x2090
movl $0x0, (%rax)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %rbp, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movl $0x10, %edi
callq 0x2200
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x4dae
movq %r12, (%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq %r15, %r14
addq $0x6, %r14
leaq 0xb9(%rip), %rdx        # 0x4eb3
movq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rax, 0x8(%rsp)
movq %rax, %rcx
callq 0x52ca
testq %rax, %rax
je 0x4e9d
movq %rax, %rbp
movl $0x30000100, (%rax)     # imm = 0x30000100
movq %r13, %rdi
callq 0x2110
movq %r14, 0x10(%rsp)
leaq 0x5(%rbp), %r14
movb %al, 0x4(%rbp)
movq %r13, %rdi
callq 0x2110
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x21e0
movq %r13, %rdi
callq 0x2110
movq %rax, %r14
movq 0x18(%rsp), %r13
movq %r13, %rdi
callq 0x2110
leaq (%r14,%rbp), %r15
addq $0x6, %r15
movb %al, 0x5(%rbp,%r14)
movq %r13, %rdi
callq 0x2110
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x21e0
movq %r12, %rdi
movq %rbp, %rsi
movq 0x10(%rsp), %rdx
callq 0x55c5
testl %eax, %eax
je 0x4eac
movq 0x8(%rsp), %rdi
callq 0x2040
jmp 0x4dae
xorl %ebx, %ebx
jmp 0x4dae
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]kivaloo/liball/../lib/proto_s3/proto_s3_client.c
// Function: callback_delete
static int
callback_delete(void * cookie, uint8_t * buf, size_t buflen)
{
	struct delete_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("DELETE", "bogus length");

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

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

		/* Did the operation succeed? */
		if (status == 204)
			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 0x4f30
cmpq $0x4, %rdx
jne 0x4efc
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 0x4f25
leaq 0x560a(%rip), %rdi      # 0xa4f6
leaq 0x5666(%rip), %rsi      # 0xa559
leaq 0x562a(%rip), %rdx      # 0xa524
jmp 0x4f11
leaq 0x55f3(%rip), %rdi      # 0xa4f6
leaq 0x564f(%rip), %rsi      # 0xa559
leaq 0x5606(%rip), %rdx      # 0xa517
xorl %eax, %eax
callq 0x425f
callq 0x2090
movl $0x0, (%rax)
jmp 0x4f30
xorl %ebp, %ebp
cmpl $0xcc, %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
nop
// File: /workspace/github_c_makefile_star2_O3/pipde[P]deos-songlib/utils/dcshift/dcshift.c
// Function: writeCommentOut
void writeCommentOut(FILE *in, FILE *out)
    {
    int ch;

    while((ch = fgetc(in)) && (ch != EOF) && ch != '\n')
        {
        fprintf(out,"%c",ch);

        continue;
        }
    fprintf(out,"\n");      
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x803, %r15d           # imm = 0x803
movq %r14, %rdi
callq 0x10e0
leal 0x1(%rax), %ecx
cmpl $0xb, %ecx
ja 0x1698
btl %ecx, %r15d
jb 0x16a4
movl %eax, %edi
movq %rbx, %rsi
callq 0x1100
jmp 0x1682
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1100
// File: /workspace/github_c_makefile_star2_O3/CSerxzm[P]WindowstoLinuxInterface/src/MD.c
// Function: main
int main(int argc, char* argv[]){
    char lines[argc+1][255];
    predealLine(argc, argv, lines);
    if(strcmp(lines[0],"MD")==0||strcmp(lines[0],"md")==0){
        for(int i=1;i<argc;i++){
            if(access(lines[i],R_OK)){
                char cm[255]="./";
                strcat(cm, lines[i]);
                mkdir(lines[i],S_IRWXU|S_IRGRP|S_IROTH);
            }
            else{
                printf("%s", lines[0]);
                printf("不能创建文件夹: %s :\n", lines[i]);
                printf("文件已经存在或权限不允许!\n");
            }
        }
    }
    else{
        printf("%s: ", lines[0]);
        printf("error\n");
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %r14d
leal 0x1(%r14), %eax
movq %rax, %rcx
shlq $0x8, %rcx
subq %rax, %rcx
addq $0xf, %rcx
movabsq $0x1fffffffff0, %r15    # imm = 0x1FFFFFFFFF0
andq %rcx, %r15
movq %rsp, %r12
movq %r12, %rbx
subq %r15, %rbx
negq %r15
movq %rbx, %rsp
movq %rbx, %rdx
callq 0x119c
movzbl (%r12,%r15), %eax
cmpl $0x6d, %eax
je 0x12fb
cmpl $0x4d, %eax
jne 0x1307
cmpb $0x44, 0x1(%rbx)
je 0x1301
jmp 0x1307
cmpb $0x64, 0x1(%rbx)
jne 0x1307
cmpb $0x0, 0x2(%rbx)
je 0x1335
leaq 0xd16(%rip), %rdi       # 0x2024
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1060
leaq 0xd0a(%rip), %rdi       # 0x2029
callq 0x1040
xorl %eax, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %r14d
jl 0x1324
movl %r14d, %eax
movq %rax, %r14
shlq $0x8, %r14
subq %rax, %r14
movl $0xff, %r15d
leaq 0xcda(%rip), %r12       # 0x202f
leaq (%rbx,%r15), %r13
movq %r13, %rdi
movl $0x4, %esi
callq 0x1070
testl %eax, %eax
je 0x1379
movq %r13, %rdi
movl $0x1e4, %esi            # imm = 0x1E4
callq 0x1030
jmp 0x13a3
leaq 0xc84(%rip), %rdi       # 0x2004
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1060
leaq 0xc76(%rip), %rdi       # 0x2007
movq %r13, %rsi
xorl %eax, %eax
callq 0x1060
movq %r12, %rdi
callq 0x1040
addq $0xff, %r15
cmpq %r15, %r14
jne 0x1355
jmp 0x1324
// File: /workspace/github_c_makefile_star2_O3/zecoxao[P]ps3_decrypt_tools/lib/aes.c
// Function: aes_crypt_cbc
int aes_crypt_cbc(aes_context *ctx,
        int mode,
        size_t length,
        unsigned char iv[16],
        const unsigned char *input,
        unsigned char *output) {
    int i;
    unsigned char temp[16];

    if (length % 16)
        return ( POLARSSL_ERR_AES_INVALID_INPUT_LENGTH);

    if (mode == AES_DECRYPT) {
        while (length > 0) {
            memcpy(temp, input, 16);
            aes_crypt_ecb(ctx, mode, input, output);

            for (i = 0; i < 16; i++)
                output[i] = (unsigned char) (output[i] ^ iv[i]);

            memcpy(iv, temp, 16);

            input += 16;
            output += 16;
            length -= 16;
        }
    } else {
        while (length > 0) {
            for (i = 0; i < 16; i++)
                output[i] = (unsigned char) (input[i] ^ iv[i]);

            aes_crypt_ecb(ctx, mode, output, output);
            memcpy(iv, output, 16);

            input += 16;
            output += 16;
            length -= 16;
        }
    }

    return ( 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movl $0xffffffde, %eax       # imm = 0xFFFFFFDE
testb $0xf, %r12b
jne 0x1f6a
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movl %esi, %ebp
movq %rdi, %r13
testl %esi, %esi
je 0x1f23
testq %r12, %r12
je 0x1f68
xorl %eax, %eax
movb (%r15,%rax), %cl
xorb (%r14,%rax), %cl
movb %cl, (%rbx,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x1ee8
movq %r13, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movq %rbx, %rcx
callq 0x16d4
movups (%rbx), %xmm0
movups %xmm0, (%r15)
addq $0x10, %r14
addq $0x10, %rbx
addq $-0x10, %r12
jne 0x1ee6
jmp 0x1f68
testq %r12, %r12
je 0x1f68
movups (%r14), %xmm0
movaps %xmm0, (%rsp)
movq %r13, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x16d4
xorl %eax, %eax
movb (%r15,%rax), %cl
xorb %cl, (%rbx,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x1f42
movaps (%rsp), %xmm0
movups %xmm0, (%r15)
addq $0x10, %r14
addq $0x10, %rbx
addq $-0x10, %r12
jne 0x1f28
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq