LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/challenge.c
// Function: main
int
main(int argc, char** argv)
{
	int c;
	int counter = 1000;

	DBUG_ENTER("main");
	DBUG_PROCESS(argv[0]);
	while ((c = getopt(argc, argv, "n:#:V")) != EOF) {
		switch(c) {
		case 'n':	counter = atoi(optarg);	break;
		case '#':	DBUG_PUSH(optarg);		break;
		case 'V':	banner();				exit(EXIT_SUCCESS);
		case '?':							usage();
		default:							usage();
		}
	}
	banner();

	test_erlang_challenge(counter);	/* this test involves running the dispatch loop */

	report_cons_stats();
	DBUG_RETURN (exit(EXIT_SUCCESS), 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xa42c(%rip), %rax      # 0xd09b
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0xf67c(%rip), %r12      # 0x122f8
movq (%r12), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x9a, 0xc(%rdi)
leaq 0xbfdc(%rip), %rcx      # 0xec74
movq %rcx, 0x10(%rdi)
leaq 0xf47d(%rip), %rcx      # 0x12120
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0xca9a
movq (%r12), %rax
movq 0x18(%rax), %rcx
movq 0xf339(%rip), %rdx      # 0x11ff8
testq %rcx, %rcx
jne 0x2cc7
movq (%rdx), %rcx
movq %rcx, 0x18(%rax)
callq 0x20b0
movq (%r12), %rcx
movl %eax, 0x10(%rcx)
movq (%rbx), %rax
movq %rax, 0x8(%rcx)
movl $0x3e8, %r14d           # imm = 0x3E8
leaq 0xa3b5(%rip), %r15      # 0xd0a0
movq 0xf2e6(%rip), %r13      # 0x11fd8
movl %ebp, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x21b0
cmpl $0x23, %eax
jne 0x2d1e
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x9f, 0xc(%rax)
movq (%r13), %rdi
callq 0xc359
jmp 0x2cf2
cmpl $0x6d, %eax
jle 0x2d36
cmpl $0x6e, %eax
jne 0x2d4c
movq (%r13), %rdi
callq 0x21d0
movl %eax, %r14d
jmp 0x2cf2
cmpl $-0x1, %eax
je 0x2d75
cmpl $0x3f, %eax
je 0x2d4c
cmpl $0x56, %eax
jne 0x2d4c
callq 0x2c32
jmp 0x2d96
movq 0xf2a5(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0xa310(%rip), %rsi      # 0xd06d
leaq 0xf3cc(%rip), %rdx      # 0x12130
xorl %eax, %eax
callq 0x2160
movl $0x1, %edi
callq 0x21f0
callq 0x2c32
movl %r14d, %edi
callq 0x2b01
callq 0x2bf8
movq %rsp, %rdi
movl $0xaa, 0xc(%rdi)
callq 0xcc1f
xorl %edi, %edi
callq 0x21f0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/rotate.c
// Function: print_seq
static void print_seq(char *seq, int len, int rv, int pos, int line_wd, FILE *fo)
{
    char *s;
    if (!rv) {
        // forward
        for (s = seq, seq += len; s < seq; s++) {
            fputc(*s, fo);
            if ((++pos) % line_wd == 0)
                fputc('\n', fo);
        }
    } else {
         // reverse
        for (s = seq + len - 1; s >= seq; s--) {
            fputc(comp_table[(int) (*s)], fo);
            if ((++pos) % line_wd == 0)
                fputc('\n', fo);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdi, %r15
movslq %esi, %r12
addq %rdi, %r12
testl %edx, %edx
je 0x3f12
decq %r12
cmpq %r15, %r12
jb 0x3f47
incl %r14d
leaq 0x2174(%rip), %r13      # 0x6050
movsbq (%r12), %rax
movsbl (%rax,%r13), %edi
movq %rbx, %rsi
callq 0x2190
movl %r14d, %eax
cltd
idivl %ebp
testl %edx, %edx
jne 0x3f05
movl $0xa, %edi
movq %rbx, %rsi
callq 0x2190
decq %r12
incl %r14d
cmpq %r15, %r12
jae 0x3edc
jmp 0x3f47
testl %esi, %esi
jle 0x3f47
incl %r14d
movsbl (%r15), %edi
movq %rbx, %rsi
callq 0x2190
movl %r14d, %eax
cltd
idivl %ebp
testl %edx, %edx
jne 0x3f3c
movl $0xa, %edi
movq %rbx, %rsi
callq 0x2190
incq %r15
incl %r14d
cmpq %r12, %r15
jb 0x3f19
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/antonblanchard[P]will-it-scale/tests/pread1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char buf[BUFLEN];
	char tmpfile[] = "/tmp/willitscale.XXXXXX";
	int fd = mkstemp(tmpfile);

	memset(buf, 0, sizeof(buf));
	assert(fd >= 0);
	assert(write(fd, buf, sizeof(buf)) == sizeof(buf));
	unlink(tmpfile);

	while (1) {
		assert(pread(fd, buf, BUFLEN, 0) == BUFLEN);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, %rbx
movaps 0x6d7(%rip), %xmm0      # 0x3360
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movabsq $0x5858585858582e, %rax # imm = 0x5858585858582E
movq %rax, 0x10(%rdi)
callq 0x21c0
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
movl $0x1000, %edx           # imm = 0x1000
xorl %esi, %esi
callq 0x2130
testl %ebp, %ebp
js 0x2d3d
leaq 0x20(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
callq 0x20d0
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x2d5c
movq %rsp, %rdi
callq 0x2080
leaq 0x20(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
xorl %ecx, %ecx
callq 0x2250
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x2d1e
leaq 0x20(%rsp), %r14
incq (%rbx)
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x2250
cmpq $0x1000, %rax           # imm = 0x1000
je 0x2d02
leaq 0x60c(%rip), %rdi       # 0x3331
leaq 0x598(%rip), %rsi       # 0x32c4
leaq 0x5a0(%rip), %rcx       # 0x32d3
movl $0x17, %edx
callq 0x2120
leaq 0x578(%rip), %rdi       # 0x32bc
leaq 0x579(%rip), %rsi       # 0x32c4
leaq 0x581(%rip), %rcx       # 0x32d3
movl $0x12, %edx
callq 0x2120
leaq 0x5a3(%rip), %rdi       # 0x3306
leaq 0x55a(%rip), %rsi       # 0x32c4
leaq 0x562(%rip), %rcx       # 0x32d3
movl $0x13, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/vcf_sweep.c
// Function: bcf_sweep_init
bcf_sweep_t *bcf_sweep_init(const char *fname)
{
    bcf_sweep_t *sw = (bcf_sweep_t*) calloc(1,sizeof(bcf_sweep_t));
    sw->file = hts_open(fname, "r");
    sw->fp   = hts_get_bgzfp(sw->file);
    if (sw->fp) bgzf_index_build_init(sw->fp);
    sw->hdr  = bcf_hdr_read(sw->file);
    sw->mrec = 1;
    sw->rec  = (bcf1_t*) calloc(sw->mrec,(sizeof(bcf1_t)));
    sw->block_size = 1024*1024*3;
    sw->direction = SW_FWD;
    return sw;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %edi
movl $0x68, %esi
callq 0x4300
movq %rax, %rbx
leaq 0xa7135(%rip), %rsi     # 0xad241
movq %r14, %rdi
callq 0x284b4
movq %rax, %r14
movq %rax, (%rbx)
movq %rax, %rdi
callq 0x29af7
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x6133
movq %rax, %rdi
callq 0x22318
movq %r14, %rdi
callq 0xa22f
movq %rax, 0x8(%rbx)
movl $0x1, 0x2c(%rbx)
movl $0x1, %edi
movl $0xd0, %esi
callq 0x4300
movq %rax, 0x20(%rbx)
movl $0x300000, 0x1c(%rbx)   # imm = 0x300000
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/vcf_sweep.c
// Function: bcf_sweep_destroy
void bcf_sweep_destroy(bcf_sweep_t *sw)
{
    int i;
    for (i=0; i<sw->mrec; i++) bcf_empty1(&sw->rec[i]);
    free(sw->idx);
    free(sw->rec);
    free(sw->lals);
    bcf_hdr_destroy(sw->hdr);
    hts_close(sw->file);
    free(sw);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x2c(%rdi)
jle 0x619e
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x20(%rbx), %rdi
addq %r14, %rdi
callq 0xb3d6
incq %r15
movslq 0x2c(%rbx), %rax
addq $0xd0, %r14
cmpq %rax, %r15
jl 0x617f
movq 0x50(%rbx), %rdi
callq 0x45d0
movq 0x20(%rbx), %rdi
callq 0x45d0
movq 0x48(%rbx), %rdi
callq 0x45d0
movq 0x8(%rbx), %rdi
callq 0xa08c
movq (%rbx), %rdi
callq 0x29716
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x45d0
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/vcf_sweep.c
// Function: bcf_sweep_fwd
bcf1_t *bcf_sweep_fwd(bcf_sweep_t *sw)
{
    if ( sw->direction==SW_BWD ) sw_seek(sw, SW_FWD);

    off_t pos = hts_utell(sw->file);

    bcf1_t *rec = &sw->rec[0];
    int ret = bcf_read1(sw->file, sw->hdr, rec);

    if ( ret!=0 )   // last record, get ready for sweeping backwards
    {
        sw->idx_done = 1;
        if (sw->fp) sw->fp->idx_build_otf = 0;
        sw_seek(sw, SW_BWD);
        return NULL;
    }

    if ( !sw->idx_done )
    {
        if ( !sw->nidx || pos - sw->idx[sw->nidx-1] > sw->block_size )
        {
            sw->nidx++;
            hts_expand(uint64_t, sw->nidx, sw->midx, sw->idx);
            sw->idx[sw->nidx-1] = pos;
        }
    }
    return rec;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x1, 0x18(%rdi)
jne 0x6201
movl $0x0, 0x18(%rbx)
movq (%rbx), %rdi
movq 0x50(%rbx), %rax
movq (%rax), %rsi
xorl %edx, %edx
callq 0x29cca
movq (%rbx), %rdi
callq 0x29ce5
movq %rax, %r15
movq 0x20(%rbx), %r14
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %r14, %rdx
callq 0xb891
testl %eax, %eax
je 0x6253
movl $0x1, 0x64(%rbx)
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x623a
movl $0x0, 0x58(%rax)
movl $0x1, 0x18(%rbx)
movl 0x5c(%rbx), %eax
movl %eax, 0x58(%rbx)
movl $0x0, 0x28(%rbx)
xorl %r14d, %r14d
jmp 0x62c2
cmpl $0x0, 0x64(%rbx)
jne 0x62c2
movslq 0x5c(%rbx), %rax
testq %rax, %rax
je 0x6277
movq 0x50(%rbx), %rcx
movq %r15, %rdx
subq -0x8(%rcx,%rax,8), %rdx
movslq 0x1c(%rbx), %rcx
cmpq %rcx, %rdx
jbe 0x62c2
leal 0x1(%rax), %ecx
movl %ecx, 0x5c(%rbx)
movslq 0x60(%rbx), %rsi
cmpl %esi, %eax
jl 0x62b6
testl %eax, %eax
movl $0x1, %edi
cmovnsl %ecx, %edi
leaq 0x50(%rbx), %r9
leaq 0xa0df0(%rip), %rax     # 0xa708a
movq %rax, (%rsp)
movl $0x4, %edx
movl $0x8, %ecx
xorl %r8d, %r8d
callq 0x30435
movl %eax, 0x60(%rbx)
movl 0x5c(%rbx), %ecx
movq 0x50(%rbx), %rax
movslq %ecx, %rcx
movq %r15, -0x8(%rax,%rcx,8)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/examples/gff3sort.c
// Function: main
int main(int argc, const char *argv[])
{
  GtNodeStream *gff3_in_stream, *sort_stream, *gff3_out_stream;
  GtGenomeNode *gn;
  GtError *err;
  int had_err;

  gt_lib_init();
  err = gt_error_new();

  gff3_in_stream = gt_gff3_in_stream_new_unsorted(argc-1, argv+1);
  sort_stream = gt_sort_stream_new(gff3_in_stream);
  gff3_out_stream = gt_gff3_out_stream_new(sort_stream, NULL);

  while (!(had_err = gt_node_stream_next(gff3_out_stream, &gn, err)) && gn)
    gt_genome_node_delete(gn);

  if (had_err)
    fprintf(stderr, "%s: error: %s\n", argv[0], gt_error_get(err));

  gt_node_stream_delete(gff3_out_stream);
  gt_node_stream_delete(sort_stream);
  gt_node_stream_delete(gff3_in_stream);
  gt_error_delete(err);

  if (had_err)
    return EXIT_FAILURE;
  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movl %edi, %ebp
callq 0x189e8
callq 0x18828
movq %rax, %rbx
decl %ebp
movq %r14, 0x10(%rsp)
leaq 0x8(%r14), %rsi
movl %ebp, %edi
callq 0x2217f
movq %rax, %r15
movq %rax, %rdi
callq 0x298d8
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
callq 0x22b08
movq %rax, %r13
leaq 0x8(%rsp), %rbp
movq %rax, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x28a88
testl %eax, %eax
sete %r14b
movq (%rbp), %rdi
testq %rdi, %rdi
setne %al
andb %r14b, %al
cmpb $0x1, %al
jne 0x187dd
leaq 0x8(%rsp), %rbp
callq 0x21cb4
movq %r13, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x28a88
testl %eax, %eax
sete %r14b
jne 0x187dd
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
jne 0x187b8
testb %r14b, %r14b
je 0x18819
movq %r13, %rdi
callq 0x28a0e
movq %r12, %rdi
callq 0x28a0e
movq %r15, %rdi
callq 0x28a0e
movq %rbx, %rdi
callq 0x189a9
xorb $0x1, %r14b
movzbl %r14b, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x7a20
jmp 0x187e2
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sort_stream.c
// Function: gt_sort_stream_class
const GtNodeStreamClass* gt_sort_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtSortStream),
                                   gt_sort_stream_free,
                                   gt_sort_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0x4459b
cmpq $0x0, 0x8f12e(%rip)     # 0xb8768
jne 0x2965b
leaq 0x26(%rip), %rsi        # 0x29669
leaq 0x81(%rip), %rdx        # 0x296cb
movl $0x30, %edi
callq 0x28954
movq %rax, 0x8f10d(%rip)     # 0xb8768
callq 0x445b1
movq 0x8f101(%rip), %rax     # 0xb8768
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sort_stream.c
// Function: gt_sort_stream_free
static void gt_sort_stream_free(GtNodeStream *ns)
{
  GtUword i;
  GtSortStream *sort_stream = gt_sort_stream_cast(ns);
  for (i = sort_stream->idx; i < gt_array_size(sort_stream->nodes); i++) {
    gt_genome_node_delete(*(GtGenomeNode**)
                          gt_array_get(sort_stream->nodes, i));
  }
  gt_array_delete(sort_stream->nodes);
  gt_node_stream_delete(sort_stream->in_stream);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2962c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x28c17
movq %rax, %rbx
movq 0x18(%rax), %r14
movq 0x20(%rax), %rdi
callq 0x42fe8
cmpq %rax, %r14
jae 0x296b2
movq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x42d0f
movq (%rax), %rdi
callq 0x21cb4
incq %r14
movq 0x20(%rbx), %rdi
jmp 0x2968b
movq 0x20(%rbx), %rdi
callq 0x43440
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x28a0e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sort_stream.c
// Function: gt_sort_stream_new
GtNodeStream* gt_sort_stream_new(GtNodeStream *in_stream)
{
  GtNodeStream *ns = gt_node_stream_create(gt_sort_stream_class(), true);
  GtSortStream *sort_stream = gt_sort_stream_cast(ns);
  gt_assert(in_stream);
  sort_stream->in_stream = gt_node_stream_ref(in_stream);
  sort_stream->sorted = false;
  sort_stream->idx = 0;
  sort_stream->nodes = gt_array_new(sizeof (GtGenomeNode*));
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x2962c
movq %rax, %rdi
movl $0x1, %esi
callq 0x2898c
movq %rax, %rbx
callq 0x2962c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x28c17
testq %r14, %r14
je 0x2993d
movq %rax, %r15
movq %r14, %rdi
callq 0x289f8
movq %rax, 0x10(%r15)
movb $0x0, 0x28(%r15)
movq $0x0, 0x18(%r15)
movl $0x8, %edi
callq 0x42c54
movq %rax, 0x20(%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0xe1ea
nop
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/httpServer.c
// Function: setupServer
int setupServer(ConfigurationRef config) {
    int socketNumber = 0;
    int status = 0;
    struct sockaddr_in configuration = (const struct sockaddr_in){0};

    socketNumber = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (socketNumber < 0) {
        exitWithError("setupServer: unable to obtain socket for server",
            EC_SOCKET_FAILURE);
    }

    memset(&configuration, 0, sizeof(configuration));
    configuration.sin_family = AF_INET;
    configuration.sin_addr.s_addr = htonl(INADDR_ANY);
    configuration.sin_port = htons(configPort(config));

    status = bind(socketNumber, (struct sockaddr*)&configuration, sizeof(configuration));
    if (status < 0) {
        exitWithError("setupServer: socket could not be bound with configuration",
            EC_BIND_FAILURE);
    }

    status = listen(socketNumber, BACKLOG_SIZE);
    if (status < 0) {
        exitWithError("setupServer: unable to configure server listening",
            EC_LISTEN_FAILURE);
    }

    return socketNumber;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movl $0x2, %edi
movl $0x1, %esi
movl $0x6, %edx
callq 0x11f0
testl %eax, %eax
js 0x1501
movl %eax, %ebx
leaq -0x28(%rbp), %r15
movq $0x0, 0x8(%r15)
movw $0x2, (%r15)
movl $0x0, 0x4(%r15)
movq %r14, %rdi
callq 0x1a00
rolw $0x8, %ax
movw %ax, 0x2(%r15)
movl %ebx, %edi
movq %r15, %rsi
movl $0x10, %edx
callq 0x1170
testl %eax, %eax
js 0x1506
movl %ebx, %edi
movl $0x5, %esi
callq 0x1150
testl %eax, %eax
js 0x150b
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1286
callq 0x125b
callq 0x1230
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/httpServer.c
// Function: handleClientRequest
void handleClientRequest(int clientSocket, char* request) {
    printf("received message:\n");

    printWithEscapeCharacters(stdout, request);
    printf("\n");

    printf("\n");

    printf("sent message:\n");

    send(clientSocket, defaultHeader, strlen(defaultHeader), 0);
    printWithEscapeCharacters(stdout, defaultHeader);
    printf("\n");

    send(clientSocket, defaultBody, strlen(defaultBody), 0);
    printWithEscapeCharacters(stdout, defaultBody);
    printf("\n");

    printf("\n");

    CLOSESOCKET(clientSocket);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebx
leaq 0xfc52(%rip), %rdi      # 0x11178
callq 0x1070
movq 0x14a9e(%rip), %r15     # 0x15fd0
movq (%r15), %rdi
movq %r14, %rsi
callq 0x13d6
movl $0xa, %edi
callq 0x1050
movl $0xa, %edi
callq 0x1050
leaq 0xfc32(%rip), %rdi      # 0x1118a
callq 0x1070
movq 0x14bac(%rip), %r14     # 0x16110
movq %r14, %rdi
callq 0x10b0
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x10c0
movq (%r15), %rdi
movq 0x14b8b(%rip), %rsi     # 0x16110
callq 0x13d6
movl $0xa, %edi
callq 0x1050
movq 0x14b7d(%rip), %r14     # 0x16118
movq %r14, %rdi
callq 0x10b0
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x10c0
movq (%r15), %rdi
movq 0x14b5c(%rip), %rsi     # 0x16118
callq 0x13d6
movl $0xa, %edi
callq 0x1050
movl $0xa, %edi
callq 0x1050
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x10f0
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/httpServer.c
// Function: main
int main(int argc, char **argv) {
    int serverSocket = 0;
    int clientSocket = 0;
    int receivedCharacters = 0;
    char messageBuffer[BUFFER_SIZE];
    ConfigurationRef config = configCreate();

    checkArguments(argc, argv, config);

    // conditional calls to winsock methods //
    #ifdef _WINDOWS_DETECTED_
      int status = WSAStartup(MAKEWORD(2, 0), &wsaData);
      if (status != 0) {
          exitWithError("main: could not perform startup on Windows",
              EC_WSASTARTUP_FAILURE);
      }
    #endif

    serverSocket = setupServer(config);

    printf("awaiting client connections...\n\n");

    while (1) {
        clientSocket = accept(serverSocket, NULL, NULL);
        printf("client connected!\n\n");

        receivedCharacters = recv(clientSocket, messageBuffer, BUFFER_SIZE, 0);
        if (receivedCharacters < 1) {
            printf("---ERROR RETRIEVING CLIENT REQUEST---\n");
            if (receivedCharacters == 0) printf(" -client already shutdown\n");
            if (receivedCharacters < 0) printf(" -socket error, check errno\n");
            //CLOSESOCKET(clientSocket);
            continue;
        }

        handleClientRequest(clientSocket, messageBuffer);
    }

    CLOSESOCKET(serverSocket);

    // conditional calls to winsock methods //
    #ifdef _WINDOWS_DETECTED_
      WSACleanup();
    #endif

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rsi, %r14
movl %edi, %r15d
callq 0x16a8
movq %rax, %rbx
cmpl $0x3, %r15d
jl 0x161a
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x1923
movq %rbx, %rdi
callq 0x147c
movl %eax, %ebx
leaq 0xfb6d(%rip), %rdi      # 0x11198
callq 0x1070
leaq 0xfb81(%rip), %r14      # 0x111b8
leaq -0x1030(%rbp), %r15
movl %ebx, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x11a0
movl %eax, %r13d
movq %r14, %rdi
callq 0x1070
movl $0x1000, %edx           # imm = 0x1000
movl %r13d, %edi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x1040
movq %rax, %r12
testl %r12d, %r12d
jle 0x167b
movl %r13d, %edi
movq %r15, %rsi
callq 0x1510
jmp 0x163e
leaq 0xfb49(%rip), %rdi      # 0x111cb
callq 0x1070
testl %r12d, %r12d
je 0x169a
leaq 0xfb78(%rip), %rdi      # 0x1120b
callq 0x1070
jmp 0x163e
leaq 0xfb50(%rip), %rdi      # 0x111f1
callq 0x1070
jmp 0x163e
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/config.c
// Function: configCreate
ConfigurationRef configCreate() {
    ConfigurationRef config = malloc(sizeof(struct Configuration));
    if (config != NULL) {
        config->port = 8080;
    }

    return config;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x2, %edi
callq 0x1140
testq %rax, %rax
je 0x16c0
movw $0x1f90, (%rax)         # imm = 0x1F90
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/config.c
// Function: configLoadDocument
enum ConfigurationStatus _configLoadDocument(ConfigurationRef config, yaml_document_t *document) {
    enum ConfigurationStatus status = CONFIG_SUCCESS;

    yaml_node_t *rootNode =  yaml_document_get_root_node(document);
    if (rootNode->type == YAML_MAPPING_NODE) {

        yaml_node_pair_t *pair = rootNode->data.mapping.pairs.start;
        for (; pair != rootNode->data.mapping.pairs.top; pair++) {
            yaml_node_t *keyNode = yaml_document_get_node(document, pair->key);
            yaml_node_t *valueNode = yaml_document_get_node(document, pair->value);
            
            status = configSetOption(
                config,
                (const char *)keyNode->data.scalar.value,
                (const char *)valueNode->data.scalar.value);

            if (status != CONFIG_SUCCESS) {
                break;
            }
        }
    }
    else {
        status = CONFIG_INVALID_ROOT_ERROR;
    }

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3c19
movq %rax, %r12
movl $0x3, %eax
cmpl $0x3, (%r12)
jne 0x1762
movq 0x10(%r12), %r15
xorl %eax, %eax
cmpq 0x20(%r12), %r15
je 0x1762
movl (%r15), %esi
movq %rbx, %rdi
callq 0x3bcc
movq %rax, %r13
movl 0x4(%r15), %esi
movq %rbx, %rdi
callq 0x3bcc
movq 0x10(%r13), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x1771
testl %eax, %eax
jne 0x1762
addq $0x8, %r15
cmpq 0x20(%r12), %r15
jne 0x1727
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/config.c
// Function: configSetOption
enum ConfigurationStatus configSetOption(ConfigurationRef config, const char *name, const char *value) {
    assert(config != NULL);
    assert(name != NULL);
    assert(value != NULL);

    // ideally should use some sort of mapping
    if (strcmp(name, "port") == 0) {
        
        errno = 0;
        unsigned short portNumber = (unsigned short)strtoul(value, NULL, 10);

        if (errno == EINVAL || errno == ERANGE) {
            return CONFIG_INVALID_VALUE_ERROR;
        }
        config->port = portNumber;

    } 
    else {
        return CONFIG_NO_SUCH_OPTION_ERROR;
    }

    return CONFIG_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x17f9
testq %rsi, %rsi
je 0x1818
movq %rdx, %r14
testq %rdx, %rdx
je 0x1837
movq %rdi, %rbx
leaq 0xfbee(%rip), %rax      # 0x1138d
movq %rsi, %rdi
movq %rax, %rsi
callq 0x1110
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
je 0x17c0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1060
movq %rax, %r15
movl $0x0, (%rax)
movq %r14, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x11b0
movq %rax, %rcx
movl (%r15), %edx
movl $0x2, %eax
cmpl $0x16, %edx
je 0x17b5
cmpl $0x22, %edx
je 0x17b5
movw %cx, (%rbx)
xorl %eax, %eax
jmp 0x17b5
leaq 0xfa27(%rip), %rdi      # 0x11227
leaq 0xfa2f(%rip), %rsi      # 0x11236
leaq 0xfb0d(%rip), %rcx      # 0x1131b
movl $0x73, %edx
callq 0x10d0
leaq 0xfb53(%rip), %rdi      # 0x11372
leaq 0xfa10(%rip), %rsi      # 0x11236
leaq 0xfaee(%rip), %rcx      # 0x1131b
movl $0x74, %edx
callq 0x10d0
leaq 0xfb41(%rip), %rdi      # 0x1137f
leaq 0xf9f1(%rip), %rsi      # 0x11236
leaq 0xfacf(%rip), %rcx      # 0x1131b
movl $0x75, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/config.c
// Function: configLoadString
enum ConfigurationStatus configLoadString(ConfigurationRef config, const char *inputString) {
    assert(config != NULL);
    assert(inputString != NULL);

    enum ConfigurationStatus status = CONFIG_SUCCESS;
    int inputLength = strlen(inputString);
    yaml_parser_t parser;
    yaml_document_t document;

    yaml_parser_initialize(&parser);
    yaml_parser_set_input_string(&parser, (const unsigned char *)inputString, inputLength);
    yaml_parser_load(&parser, &document);

    status = _configLoadDocument(config, &document);

    yaml_parser_delete(&parser);
    yaml_document_delete(&document);

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
testq %rdi, %rdi
je 0x18e5
movq %rsi, %r14
testq %rsi, %rsi
je 0x1904
movq %rdi, %rbx
movq %r14, %rdi
callq 0x10b0
movq %rax, %r15
leaq -0x268(%rbp), %r12
movq %r12, %rdi
callq 0x1c4f
movslq %r15d, %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x21d8
leaq -0x88(%rbp), %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x42d4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16ee
movl %eax, %ebx
movq %r12, %rdi
callq 0x1f9a
movq %r14, %rdi
callq 0x3aa6
movl %ebx, %eax
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf93b(%rip), %rdi      # 0x11227
leaq 0xf943(%rip), %rsi      # 0x11236
leaq 0xf96a(%rip), %rcx      # 0x11264
movl $0x3f, %edx
callq 0x10d0
leaq 0xf9a3(%rip), %rdi      # 0x112ae
leaq 0xf924(%rip), %rsi      # 0x11236
leaq 0xf94b(%rip), %rcx      # 0x11264
movl $0x40, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/config.c
// Function: configLoadFile
enum ConfigurationStatus configLoadFile(ConfigurationRef config, const char *filepath) {
    assert(config != NULL);
    assert(filepath != NULL);

    enum ConfigurationStatus status = CONFIG_SUCCESS;
    yaml_parser_t parser;
    yaml_document_t document;

    FILE *file = fopen(filepath, "r");
    
    yaml_parser_initialize(&parser);
    yaml_parser_set_input_file(&parser, file);
    yaml_parser_load(&parser, &document);

    status = _configLoadDocument(config, &document);

    fclose(file);
    yaml_parser_delete(&parser);
    yaml_document_delete(&document);

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
testq %rdi, %rdi
je 0x19c2
testq %rsi, %rsi
je 0x19e1
movq %rdi, %rbx
leaq 0x113d4(%rip), %rax     # 0x12d25
movq %rsi, %rdi
movq %rax, %rsi
callq 0x1190
movq %rax, %r14
leaq -0x268(%rbp), %r15
movq %r15, %rdi
callq 0x1c4f
movq %r15, %rdi
movq %r14, %rsi
callq 0x22ae
leaq -0x88(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x42d4
movq %rbx, %rdi
movq %r12, %rsi
callq 0x16ee
movl %eax, %ebx
movq %r14, %rdi
callq 0x10a0
movq %r15, %rdi
callq 0x1f9a
movq %r12, %rdi
callq 0x3aa6
movl %ebx, %eax
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf85e(%rip), %rdi      # 0x11227
leaq 0xf866(%rip), %rsi      # 0x11236
leaq 0xf8eb(%rip), %rcx      # 0x112c2
movl $0x54, %edx
callq 0x10d0
leaq 0xf922(%rip), %rdi      # 0x1130a
leaq 0xf847(%rip), %rsi      # 0x11236
leaq 0xf8cc(%rip), %rcx      # 0x112c2
movl $0x55, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/examples/noop.c
// Function: main
int main(GT_UNUSED int argc, GT_UNUSED char *argv[])
{
  gt_lib_init();
  if (gt_version_check(GT_MAJOR_VERSION, GT_MINOR_VERSION, GT_MICRO_VERSION)) {
    fprintf(stderr, "error: %s\n", gt_version_check(GT_MAJOR_VERSION,
                                                    GT_MINOR_VERSION,
                                                    GT_MICRO_VERSION));
    return EXIT_FAILURE;
  }

  if (gt_lib_clean())
    return GT_EXIT_PROGRAMMING_ERROR; /* programmer error */
  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbx
callq 0xb51c
movl $0x1, %ebx
movl $0x1, %edi
movl $0x6, %esi
movl $0x6, %edx
callq 0x134e8
testq %rax, %rax
jne 0xb512
callq 0xb747
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
addl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
callq 0x46b0
jmp 0xb50e
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/version.c
// Function: gt_version_check
const char* gt_version_check(unsigned int required_major,
                             unsigned int required_minor,
                             unsigned int required_micro)
{
  if (required_major > GT_MAJOR_VERSION)
    return "GenomeTools library version too old (major mismatch)";
  if (required_major < GT_MAJOR_VERSION)
    return "GenomeTools library version too new (major mismatch)";
  if (required_minor > GT_MINOR_VERSION)
    return "GenomeTools library version too old (minor mismatch)";
  if (required_micro > GT_MICRO_VERSION)
    return "GenomeTools library version too old (micro mismatch)";
  return NULL;
}

// Assembly:
cmpl $0x1, %edi
jbe 0x134f5
leaq 0x2b787(%rip), %rax     # 0x3ec7b
retq
testl %edi, %edi
je 0x13506
cmpl $0x6, %esi
jbe 0x1350e
leaq 0x2b7e0(%rip), %rax     # 0x3ece5
retq
leaq 0x2b7a3(%rip), %rax     # 0x3ecb0
retq
xorl %eax, %eax
cmpl $0x7, %edx
leaq 0x2b800(%rip), %rcx     # 0x3ed1a
cmovaeq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/sguerrini97[P]ps3linux-ps3vuart-tools/ps3av/dev.c
// Function: dev_read
int
dev_read(void *buf, size_t len)
{
	char tmp[4096];
	struct ps3av_reply *reply;
	int ret;

	if (fd < 0)
		return (-1);

	reply = (struct ps3av_reply *) tmp;

	while (1) {
		ret = read(fd, &reply->hdr, sizeof(reply->hdr));
		if (ret < 0) {
			if (errno != EAGAIN)
				return (-1);
		} else if (ret > 0) {
			break;
		}
	}

	while (1) {
		ret = read(fd, &reply->cmd, reply->hdr.length);
		if (ret < 0) {
			if (errno != EAGAIN)
				return (-1);
		} else if (ret > 0) {
			break;
		}
	}

	if (len > (sizeof(reply->hdr) + reply->hdr.length))
		len = sizeof(reply->hdr) + reply->hdr.length;

	memcpy(buf, tmp, len);

	return (len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rdi, %r14
movl 0x2d6c(%rip), %edi      # 0x4190
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %edi, %edi
js 0x14a3
movq %rsi, %r15
movq %rsp, %r12
movl $0x4, %edx
movq %r12, %rsi
callq 0x1070
testl %eax, %eax
js 0x1448
je 0x1452
jmp 0x145a
callq 0x1030
cmpl $0xb, (%rax)
jne 0x14a3
movl 0x2d38(%rip), %edi      # 0x4190
jmp 0x1433
leaq 0x4(%rsp), %r12
movl 0x2d2b(%rip), %edi      # 0x4190
movzwl 0x2(%rsp), %edx
movq %r12, %rsi
callq 0x1070
testl %eax, %eax
js 0x147a
je 0x145f
jmp 0x1486
callq 0x1030
cmpl $0xb, (%rax)
je 0x145f
jmp 0x14a3
movq %rsp, %rsi
movzwl 0x2(%rsi), %ebx
addq $0x4, %rbx
cmpq %r15, %rbx
cmovaeq %r15, %rbx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x10a0
movl %ebx, %eax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sguerrini97[P]ps3linux-ps3vuart-tools/ps3av/cmd/cmd_av_get_hdcp_ksv.c
// Function: cmd_av_get_hdcp_ksv_exec
int
cmd_av_get_hdcp_ksv_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3av_request req;
	struct ps3av_av_get_hdcp_ksv_reply av_get_hdcp_ksv_reply;
	int ret;

	ps3av_init_request(&req, sizeof(req) - sizeof(struct ps3av_header),
	    PS3AV_CMD_AV_GET_HDCP_KSV);

	ret = dev_write(&req, sizeof(req));
	if (ret != sizeof(req))
		return (CMD_EIO);

	ret = dev_read(&av_get_hdcp_ksv_reply, sizeof(av_get_hdcp_ksv_reply));
	if (ret != sizeof(av_get_hdcp_ksv_reply))
		return (CMD_EIO);

	if (av_get_hdcp_ksv_reply.reply.status != PS3AV_STATUS_SUCCESS)
		return (CMD_EIO);

	fwrite(av_get_hdcp_ksv_reply.ksv, 1, av_get_hdcp_ksv_reply.ksv_length, stdout);

	return (CMD_EOK);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movabsq $0xc00040205, %rax      # imm = 0xC00040205
leaq 0xc(%rsp), %rdi
movq %rax, (%rdi)
movl $0x8, %esi
callq 0x13ec
movl $0x3, %ebx
cmpl $0x8, %eax
jne 0x1518
leaq 0x14(%rsp), %rdi
movl $0x1c, %esi
callq 0x140d
cmpl $0x1c, %eax
jne 0x1518
cmpl $0x0, 0x1c(%rsp)
jne 0x1518
leaq 0x24(%rsp), %rdi
movl -0x4(%rdi), %edx
movq 0x2abf(%rip), %rax      # 0x3fc8
movq (%rax), %rcx
movl $0x1, %esi
callq 0x10f0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/sguerrini97[P]ps3linux-ps3vuart-tools/ps3av/cmd/cmd_av_get_hw_conf.c
// Function: cmd_av_get_hw_conf_exec
int
cmd_av_get_hw_conf_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3av_request req;
	struct ps3av_av_get_hw_conf_reply av_get_hw_conf_reply;
	int ret;

	ps3av_init_request(&req, sizeof(req) - sizeof(struct ps3av_header),
	    PS3AV_CMD_AV_GET_HW_CONF);

	ret = dev_write(&req, sizeof(req));
	if (ret != sizeof(req))
		return (CMD_EIO);

	ret = dev_read(&av_get_hw_conf_reply, sizeof(av_get_hw_conf_reply));
	if (ret != sizeof(av_get_hw_conf_reply))
		return (CMD_EIO);

	if (av_get_hw_conf_reply.reply.status != PS3AV_STATUS_SUCCESS)
		return (CMD_EIO);

	fprintf(stdout, "%d %d %d\n", av_get_hw_conf_reply.nr_hdmi,
	    av_get_hw_conf_reply.nr_avmulti, av_get_hw_conf_reply.nr_spdif);

	return (CMD_EOK);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movabsq $0x300040205, %rax      # imm = 0x300040205
leaq 0x18(%rsp), %rdi
movq %rax, (%rdi)
movl $0x8, %esi
callq 0x13ec
movl $0x3, %ebx
cmpl $0x8, %eax
jne 0x1590
leaq 0x4(%rsp), %rdi
movl $0x14, %esi
callq 0x140d
cmpl $0x14, %eax
jne 0x1590
cmpl $0x0, 0xc(%rsp)
jne 0x1590
movq 0x2a5b(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
movzwl 0x10(%rsp), %edx
movzwl 0x12(%rsp), %ecx
movzwl 0x14(%rsp), %r8d
leaq 0xb9e(%rip), %rsi       # 0x2125
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1090
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/sguerrini97[P]ps3linux-ps3vuart-tools/ps3av/cmd/cmd_av_video_mute.c
// Function: cmd_av_video_mute_exec
int
cmd_av_video_mute_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3av_av_video_mute av_video_mute_req;
	struct ps3av_reply reply;
	char *endptr;
	unsigned int port, mute;
	int ret;

	port = strtoul(argv[0], &endptr, 0);
	if (*endptr != '\0')
		return (CMD_EINVAL);

	mute = strtoul(argv[1], &endptr, 0);
	if (*endptr != '\0')
		return (CMD_EINVAL);

	ps3av_init_request(PS3AV_REQ(&av_video_mute_req),
	    sizeof(av_video_mute_req) - sizeof(struct ps3av_header),
	    PS3AV_CMD_AV_VIDEO_MUTE);

	av_video_mute_req.port = port;
	av_video_mute_req.mute = mute;

	ret = dev_write(&av_video_mute_req, sizeof(av_video_mute_req));
	if (ret != sizeof(av_video_mute_req))
		return (CMD_EIO);

	ret = dev_read(&reply, sizeof(reply));
	if (ret != sizeof(reply))
		return (CMD_EIO);

	if (reply.status != PS3AV_STATUS_SUCCESS)
		return (CMD_EIO);

	return (CMD_EOK);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r15
movq (%rcx), %rdi
movq %rsp, %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x10d0
movq %rax, %r14
movq (%rbx), %rax
movl $0x2, %ebx
cmpb $0x0, (%rax)
jne 0x1779
movq 0x8(%r15), %rdi
movq %rsp, %r15
movq %r15, %rsi
xorl %edx, %edx
callq 0x10d0
movq (%r15), %rcx
cmpb $0x0, (%rcx)
jne 0x1779
movabsq $0x1000200080205, %rcx  # imm = 0x1000200080205
leaq 0x14(%rsp), %rdi
movq %rcx, (%rdi)
movw %r14w, 0x8(%rdi)
movw %ax, 0xa(%rdi)
movl $0xc, %esi
callq 0x13ec
movl $0x3, %ebx
cmpl $0xc, %eax
jne 0x1779
leaq 0x8(%rsp), %rdi
movl $0xc, %esi
callq 0x140d
cmpl $0xc, %eax
jne 0x1779
xorl %eax, %eax
cmpl $0x0, 0x10(%rsp)
setne %al
leal (%rax,%rax,2), %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/sguerrini97[P]ps3linux-ps3vuart-tools/ps3av/cmd/cmd_video_pitch.c
// Function: cmd_video_pitch_exec
int
cmd_video_pitch_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3av_video_pitch video_pitch_req;
	struct ps3av_reply reply;
	char *endptr;
	unsigned int head, pitch;
	int ret;

	head = strtoul(argv[0], &endptr, 0);
	if (*endptr != '\0')
		return (CMD_EINVAL);

	pitch = strtoul(argv[1], &endptr, 0);
	if (*endptr != '\0')
		return (CMD_EINVAL);

	ps3av_init_request(PS3AV_REQ(&video_pitch_req),
	    sizeof(video_pitch_req) - sizeof(struct ps3av_header),
	    PS3AV_CMD_VIDEO_PITCH);

	video_pitch_req.head = head;
	video_pitch_req.pitch = pitch;

	ret = dev_write(&video_pitch_req, sizeof(video_pitch_req));
	if (ret != sizeof(video_pitch_req))
		return (CMD_EIO);

	ret = dev_read(&reply, sizeof(reply));
	if (ret != sizeof(reply))
		return (CMD_EIO);

	if (reply.status != PS3AV_STATUS_SUCCESS)
		return (CMD_EIO);

	return (CMD_EOK);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r15
movq (%rcx), %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x10d0
movq %rax, %r14
movq (%rbx), %rax
movl $0x2, %ebx
cmpb $0x0, (%rax)
jne 0x181f
movq 0x8(%r15), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
xorl %edx, %edx
callq 0x10d0
movq (%r15), %rcx
cmpb $0x0, (%rcx)
jne 0x181f
movabsq $0x1000005000c0205, %rcx # imm = 0x1000005000C0205
leaq 0x20(%rsp), %rdi
movq %rcx, (%rdi)
movl %r14d, 0x8(%rdi)
movl %eax, 0xc(%rdi)
movl $0x10, %esi
callq 0x13ec
movl $0x3, %ebx
cmpl $0x10, %eax
jne 0x181f
leaq 0x14(%rsp), %rdi
movl $0xc, %esi
callq 0x140d
cmpl $0xc, %eax
jne 0x181f
xorl %eax, %eax
cmpl $0x0, 0x1c(%rsp)
setne %al
leal (%rax,%rax,2), %ebx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/snowcrash/snowcrash.c
// Function: main
int main(int argc, char *argv[])
{
  int x, y, maxy, maxx;

  srand(time(NULL));

  initscr();
  atexit((void *)endwin);
  noecho();
  timeout(0);

  while (1) {
    if (getch() != ERR)
      return 0; /* Stop on any key press. */

    getmaxyx(stdscr, maxy, maxx);
    for (y = 0; y < maxy; y++) {
      for (x = 0; x < maxx; x++) {
        mvaddch(y, x, (rand() % 0x5E) + 0x21); /* 0x21 -> 0x7E */
      }
    }
    refresh();
    usleep(40000); /* ~24 frames per second. */
  }

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %edi, %edi
callq 0x1090
movl %eax, %edi
callq 0x1070
callq 0x1050
movq 0x2ddf(%rip), %rdi      # 0x3ff0
callq 0x12f0
callq 0x1040
movq 0x2db6(%rip), %r15      # 0x3fd8
movq (%r15), %rdi
xorl %esi, %esi
callq 0x1080
movq (%r15), %rdi
callq 0x1030
cmpl $-0x1, %eax
jne 0x12d8
movq (%r15), %rdi
testq %rdi, %rdi
je 0x12c2
movswl 0x4(%rdi), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
js 0x12c4
movswl 0x6(%rdi), %r12d
movl %r12d, %r13d
incl %r13d
xorl %ebx, %ebx
testw %r12w, %r12w
js 0x12b2
xorl %ebp, %ebp
movq (%r15), %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x10a0
cmpl $-0x1, %eax
je 0x12ab
movq (%r15), %r14
callq 0x10d0
cltq
imulq $-0x51b3bea3, %rax, %rcx # imm = 0xAE4C415D
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x6, %ecx
addl %edx, %ecx
imull $0x5e, %ecx, %ecx
negl %ecx
leal (%rax,%rcx), %esi
addl $0x21, %esi
movq %r14, %rdi
callq 0x10c0
incl %ebp
cmpl %ebp, %r13d
jne 0x1266
leal 0x1(%rbx), %eax
cmpl 0x4(%rsp), %ebx
movl %eax, %ebx
jne 0x125e
movq (%r15), %rdi
jmp 0x12c4
xorl %edi, %edi
callq 0x1060
movl $0x9c40, %edi           # imm = 0x9C40
callq 0x10e0
jmp 0x122c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/canboat[P]canboat/n2kd/main.c
// Function: closeClientRequest
static void closeClientRequest(int i)
{
  ssize_t r;
  char    buf[4];

  logDebug("closeClientRequest: read i=%d\n", i);
  r = read(stream[i].fd, buf, sizeof(buf));

  logDebug("close-on-eof %s r=%d i=%d fd=%d %s\n", streamTypeName[stream[i].type], (int) r, i, stream[i].fd, strerror(errno));
  closeStream(i);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leaq 0x6bb4(%rip), %rdi      # 0x9c59
movl %ebx, %esi
xorl %eax, %eax
callq 0x7509
movslq %ebx, %rbx
imulq $0x8038, %rbx, %r15     # imm = 0x8038
leaq 0xb461(%rip), %r12      # 0xe520
movl (%r15,%r12), %edi
leaq 0xc(%rsp), %rsi
movl $0x4, %edx
callq 0x21b0
movq %rax, %r14
movl (%r15,%r12), %ebp
movl 0x4(%r15,%r12), %eax
leaq 0xb11b(%rip), %rcx      # 0xe200
movq (%rcx,%rax,8), %r15
callq 0x2050
movl (%rax), %edi
callq 0x2360
leaq 0x6b7c(%rip), %rdi      # 0x9c78
movq %r15, %rsi
movl %r14d, %edx
movl %ebx, %ecx
movl %ebp, %r8d
movq %rax, %r9
xorl %eax, %eax
callq 0x7509
movl %ebx, %edi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3fe5
// File: /workspace/github_c_makefile_star2_O3/canboat[P]canboat/n2kd/main.c
// Function: acceptClient
void acceptClient(SOCKET s, StreamType ct)
{
  SOCKET             r;
  struct sockaddr_in clientAddr;
  socklen_t          clientAddrLen;

  for (;;)
  {
    clientAddrLen = sizeof(clientAddr);
    r             = accept(s, (struct sockaddr *) &clientAddr, &clientAddrLen);
    if (r == INVALID_SOCKET)
    {
      /* No socket ready, just ignore */
      return;
    }

    /* New client found, mark it as such */
    if (setFdUsed(r, ct) < 0)
    {
      /* Too many open clients, ignore */
      return;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movl %edi, %ebp
leaq 0x8(%rsp), %r14
leaq 0x4(%rsp), %r15
movl $0x10, 0x4(%rsp)
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x22d0
cmpl $-0x1, %eax
je 0x3217
movl %eax, %edi
movl %ebx, %esi
callq 0x3222
testl %eax, %eax
jns 0x31f0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/canboat[P]canboat/n2kd/main.c
// Function: parseUDPAddress
bool parseUDPAddress(char *target, char *port)
{
  int              r;
  struct addrinfo  hints;
  struct addrinfo *res, *res0;

  hints.ai_flags    = 0;
  hints.ai_family   = PF_INET;
  hints.ai_socktype = SOCK_DGRAM;
  hints.ai_protocol = IPPROTO_UDP;
  hints.ai_flags    = AI_NUMERICHOST;

  r = getaddrinfo(target, port, &hints, &res0);
  if (r)
  {
    return false;
  }
  for (res = res0; res; res = res->ai_next)
  {
    if (res->ai_addrlen == sizeof udpWildcardAddress)
    {
      memcpy(&udpWildcardAddress, res->ai_addr, sizeof udpWildcardAddress);
      return true;
    }
  }
  return false;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movaps 0x5bcd(%rip), %xmm0     # 0x9010
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
leaq 0x8(%rsp), %rbx
movq %rbx, %rcx
callq 0x2350
testl %eax, %eax
setne %cl
movq (%rbx), %rax
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x3479
cmpl $0x10, 0x10(%rax)
je 0x347d
movq 0x28(%rax), %rax
testq %rax, %rax
jne 0x346a
xorl %eax, %eax
jmp 0x348d
movq 0x18(%rax), %rax
movups (%rax), %xmm0
movups %xmm0, 0xaef1(%rip)     # 0xe37c
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/canboat[P]canboat/n2kd/main.c
// Function: setHaveNMEA0183Client
static void setHaveNMEA0183Client(void)
{
  int i;

  haveNMEA0183Client = udp183;
  if (!haveNMEA0183Client)
  {
    for (i = 0; i <= socketIdxMax; i++)
    {
      if (stream[i].fd != INVALID_SOCKET
          && (stream[i].type == CLIENT_NMEA0183_STREAM || stream[i].type == SERVER_NMEA0183_DATAGRAM
              || stream[i].type == DATA_OUTPUT_NMEA0183_STREAM))
      {
        haveNMEA0183Client = true;
        return;
      }
    }
  }
}

// Assembly:
movb 0xa583(%rip), %al       # 0xe510
movb %al, 0xa3e5(%rip)       # 0xe378
testb %al, %al
jne 0x3fdc
movl 0xa3d3(%rip), %eax      # 0xe370
testl %eax, %eax
js 0x3fdc
imulq $0x8038, %rax, %rax     # imm = 0x8038
addq $0x8038, %rax           # imm = 0x8038
xorl %ecx, %ecx
leaq 0xa569(%rip), %rdx      # 0xe520
movl $0x41020, %esi          # imm = 0x41020
cmpl $-0x1, (%rcx,%rdx)
je 0x3fd0
movl 0x4(%rcx,%rdx), %edi
cmpl $0x12, %edi
ja 0x3fd0
btl %edi, %esi
jb 0x3fdd
addq $0x8038, %rcx           # imm = 0x8038
cmpq %rcx, %rax
jne 0x3fbc
retq
movb $0x1, 0xa394(%rip)      # 0xe378
retq
// File: /workspace/github_c_makefile_star2_O3/canboat[P]canboat/n2kd/main.c
// Function: closeStream
static void closeStream(int i)
{
  int j;

  close(stream[i].fd);
  FD_CLR(stream[i].fd, &activeSet);
  FD_CLR(stream[i].fd, &readSet);
  FD_CLR(stream[i].fd, &writeSet);
  sbClean(&stream[i].writeBuffer);

  stream[i].fd = INVALID_SOCKET; /* Free for re-use */
  if (i == socketIdxMax)
  {
    socketIdxMax = 0;
    socketFdMax  = 0;
    for (j = i - 1; j >= 0; j--)
    {
      if (stream[j].fd != INVALID_SOCKET)
      {
        socketIdxMax = CB_MAX(socketIdxMax, j);
        socketFdMax  = CB_MAX(socketFdMax, stream[j].fd);
      }
    }
  }
  setHaveNMEA0183Client();
  logDebug("closeStream(%d) (%u..%u fdMax=%d)\n", i, socketIdxMin, socketIdxMax, socketFdMax);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movslq %edi, %rax
imulq $0x8038, %rax, %r12     # imm = 0x8038
leaq 0xa520(%rip), %r14      # 0xe520
leaq (%r14,%r12), %r15
movl (%r12,%r14), %edi
callq 0x2190
movl (%r12,%r14), %ecx
movq $-0x2, %rax
rolq %cl, %rax
leal 0x3f(%rcx), %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
sarl $0x6, %edx
movslq %edx, %rcx
leaq 0xa360(%rip), %rdx      # 0xe390
andq %rax, (%rdx,%rcx,8)
leaq 0xa3d5(%rip), %rdx      # 0xe410
andq %rax, (%rdx,%rcx,8)
leaq 0xa44a(%rip), %rdx      # 0xe490
andq %rax, (%rdx,%rcx,8)
movq 0x8018(%r12,%r14), %rdi
testq %rdi, %rdi
je 0x4067
callq 0x2030
movq $0x0, 0x8018(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x8020(%r15)
movl $0xffffffff, (%r15)     # imm = 0xFFFFFFFF
cmpl %ebx, 0xa2f1(%rip)      # 0xe370
jne 0x40df
xorl %eax, %eax
movl %eax, 0xa2e7(%rip)      # 0xe370
movl %eax, 0xa2e5(%rip)      # 0xe374
testl %ebx, %ebx
jle 0x40df
movl %ebx, %ecx
imulq $0x8038, %rcx, %rdx     # imm = 0x8038
addq %r14, %rdx
addq $-0x8038, %rdx          # imm = 0xFFFF7FC8
xorl %esi, %esi
movl (%rdx), %edi
cmpl $-0x1, %edi
je 0x40cb
leal -0x1(%rcx), %r8d
cmpl %r8d, %eax
cmovlel %r8d, %eax
movl %eax, 0xa2b0(%rip)      # 0xe370
cmpl %edi, %esi
cmovlel %edi, %esi
movl %esi, 0xa2a9(%rip)      # 0xe374
decq %rcx
leaq 0x1(%rcx), %rdi
addq $-0x8038, %rdx          # imm = 0xFFFF7FC8
cmpq $0x1, %rdi
ja 0x40a8
callq 0x3f87
movl 0xa282(%rip), %edx      # 0xe36c
movl 0xa280(%rip), %ecx      # 0xe370
movl 0xa27d(%rip), %r8d      # 0xe374
leaq 0x588d(%rip), %rdi      # 0x998b
movl %ebx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7509
// File: /workspace/github_c_makefile_star2_O3/canboat[P]canboat/n2kd/main.c
// Function: tcpServer
static void tcpServer(uint16_t port, StreamType st)
{
  struct sockaddr_in serverAddr;
  int                sockAddrSize = sizeof(serverAddr);
  int                r;
  int                on = 1;
  SOCKET             s;
  bool               udp = (st == SERVER_NMEA0183_DATAGRAM);

  s = socket(PF_INET, udp ? SOCK_DGRAM : SOCK_STREAM, 0);
  if (s == INVALID_SOCKET)
  {
    die("Unable to open server socket");
  }
  memset((char *) &serverAddr, 0, sockAddrSize);
  serverAddr.sin_family      = AF_INET;
  serverAddr.sin_port        = htons(port);
  serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);

  setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *) &on, (socklen_t) sizeof(on));

  r = bind(s, (struct sockaddr *) &serverAddr, sockAddrSize);
  if (r == INVALID_SOCKET)
  {
    die("Unable to bind server socket");
  }

  if (!udp)
  {
    r = listen(s, 10);
    if (r == INVALID_SOCKET)
    {
      die("Unable to listen to server socket");
    }
  }
  else
  {
    setsockopt(s, SOL_SOCKET, SO_BROADCAST, (char *) &on, (socklen_t) sizeof(on));
  }

  setFdUsed(s, st);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movl %edi, %r14d
movl $0x1, 0x4(%rsp)
xorl %esi, %esi
cmpl $0xc, %ebx
sete %sil
incl %esi
movl $0x2, %edi
xorl %edx, %edx
callq 0x23b0
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x4294
leaq 0x5bc9(%rip), %rdi      # 0x9e58
callq 0x76df
leaq 0x8(%rsp), %r15
movq $0x0, 0x8(%r15)
movw $0x2, (%r15)
rolw $0x8, %r14w
movw %r14w, 0x2(%r15)
movl $0x0, 0x4(%r15)
leaq 0x4(%rsp), %rcx
movl %ebp, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x20c0
movl %ebp, %edi
movq %r15, %rsi
movl $0x10, %edx
callq 0x2270
cmpl $-0x1, %eax
jne 0x42f5
leaq 0x5b85(%rip), %rdi      # 0x9e75
callq 0x76df
cmpl $0xc, %ebx
jne 0x4318
leaq 0x4(%rsp), %rcx
movl %ebp, %edi
movl $0x1, %esi
movl $0x6, %edx
movl $0x4, %r8d
callq 0x20c0
jmp 0x4335
movl %ebp, %edi
movl $0xa, %esi
callq 0x2250
cmpl $-0x1, %eax
jne 0x4335
leaq 0x5b62(%rip), %rdi      # 0x9e92
callq 0x76df
movl %ebp, %edi
movl %ebx, %esi
callq 0x3222
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq