LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/aokad[P]sequeeze/seqtk.c
// Function: stk_hrun
int stk_hrun(int argc, char *argv[])
{
	gzFile fp;
	kseq_t *ks;
	int min_len = 7, l = 0, c = 0, beg = 0, i;
	if (argc == optind) {
		fprintf(stderr, "Usage: seqtk hrun <in.fa> [minLen=%d]\n", min_len);
		return 1;
	}
	if (argc == optind + 2) min_len = atoi(argv[optind+1]);
	fp = (strcmp(argv[optind], "-") == 0)? gzdopen(fileno(stdin), "r") : gzopen(argv[optind], "r");
	if (fp == 0) {
		fprintf(stderr, "[E::%s] failed to open the input file/stream.\n", __func__);
		return 1;
	}
	ks = kseq_init(fp);
	while (kseq_read(ks) >= 0) {
		c = ks->seq.s[0]; l = 1; beg = 0;
		for (i = 1; i < ks->seq.l; ++i) {
			if (ks->seq.s[i] != c) {
				if (l >= min_len) printf("%s\t%d\t%d\t%c\n", ks->name.s, beg, beg + l, c);
				c = ks->seq.s[i]; l = 1; beg = i;
			} else ++l;
		}
	}
	if (l >= min_len) printf("%s\t%d\t%d\t%c\n", ks->name.s, beg, beg + l, c);
	kseq_destroy(ks);
	gzclose(fp);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x9aa3(%rip), %rax      # 0xffd0
movslq (%rax), %r15
cmpl %edi, %r15d
je 0x668f
movq %rsi, %r14
leal 0x2(%r15), %eax
movl $0x7, %ebx
cmpl %edi, %eax
jne 0x6555
movq 0x8(%r14,%r15,8), %rdi
callq 0x2250
movl %eax, %ebx
movq (%r14,%r15,8), %r14
leaq 0x5e4e(%rip), %rsi      # 0xc3ae
movq %r14, %rdi
callq 0x2170
testl %eax, %eax
je 0x657d
leaq 0x4c25(%rip), %rsi      # 0xb198
movq %r14, %rdi
callq 0x2220
jmp 0x659a
movq 0x9a44(%rip), %rax      # 0xffc8
movq (%rax), %rdi
callq 0x21b0
leaq 0x4c05(%rip), %rsi      # 0xb198
movl %eax, %edi
callq 0x20b0
testq %rax, %rax
je 0x6696
movq %rax, (%rsp)
movq %rax, %rdi
callq 0x3e57
movq %rax, %r15
movq %rax, %rdi
callq 0x3ea1
testl %eax, %eax
js 0x6642
movq 0x40(%r15), %rax
movsbl (%rax), %ebp
movl $0x1, %r12d
cmpq $0x2, 0x30(%r15)
jb 0x6631
xorl %r14d, %r14d
movl $0x1, %r13d
movq 0x40(%r15), %rax
movsbl (%rax,%r13), %eax
cmpl %eax, %ebp
jne 0x65f1
incl %r12d
jmp 0x6626
cmpl %ebx, %r12d
jl 0x6614
movq 0x10(%r15), %rsi
addl %r14d, %r12d
leaq 0x54fb(%rip), %rdi      # 0xbaff
movl %r14d, %edx
movl %r12d, %ecx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x20f0
movq 0x40(%r15), %rax
movsbl (%rax,%r13), %ebp
movl $0x1, %r12d
movl %r13d, %r14d
incq %r13
cmpq %r13, 0x30(%r15)
ja 0x65df
jmp 0x6634
xorl %r14d, %r14d
movq %r15, %rdi
callq 0x3ea1
testl %eax, %eax
jns 0x65c2
jmp 0x664a
xorl %r12d, %r12d
xorl %ebp, %ebp
xorl %r14d, %r14d
cmpl %ebx, %r12d
jl 0x666d
movq 0x10(%r15), %rsi
addl %r14d, %r12d
leaq 0x54a2(%rip), %rdi      # 0xbaff
movl %r14d, %edx
movl %r12d, %ecx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x20f0
movq %r15, %rdi
callq 0x4229
movq (%rsp), %rdi
callq 0x2040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x283c
jmp 0x669b
callq 0x281d
movl $0x1, %eax
jmp 0x6680
// File: /workspace/github_c_makefile_star2_O1/aokad[P]sequeeze/seqtk.c
// Function: cpy_kseq
static void cpy_kseq(kseq_t *dst, const kseq_t *src)
{
	cpy_kstr(&dst->name, &src->name);
	cpy_kstr(&dst->seq,  &src->seq);
	cpy_kstr(&dst->qual, &src->qual);
	cpy_kstr(&dst->comment, &src->comment);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa1ca
leaq 0x30(%r14), %rdi
leaq 0x30(%rbx), %rsi
callq 0xa1ca
leaq 0x48(%r14), %rdi
leaq 0x48(%rbx), %rsi
callq 0xa1ca
addq $0x18, %r14
addq $0x18, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa1ca
// File: /workspace/github_c_makefile_star2_O1/aokad[P]sequeeze/seqtk.c
// Function: stk_mergepe
int stk_mergepe(int argc, char *argv[])
{
	gzFile fp1, fp2;
	kseq_t *seq[2];

	if (argc < 3) {
		fprintf(stderr, "Usage: seqtk mergepe <in1.fq> <in2.fq>\n");
		return 1;
	}
	fp1 = strcmp(argv[1], "-")? gzopen(argv[1], "r") : gzdopen(fileno(stdin), "r");
	fp2 = strcmp(argv[2], "-")? gzopen(argv[2], "r") : gzdopen(fileno(stdin), "r");
	if (fp1 == 0 || fp2 == 0) {
		fprintf(stderr, "[E::%s] failed to open the input file/stream.\n", __func__);
		return 1;
	}
	seq[0] = kseq_init(fp1);
	seq[1] = kseq_init(fp2);
	while (kseq_read(seq[0]) >= 0) {
		if (kseq_read(seq[1]) < 0) {
			fprintf(stderr, "[W::%s] the 2nd file has fewer records.\n", __func__);
			break;
		}
		stk_printseq(seq[0], 0);
		stk_printseq(seq[1], 0);
	}
	if (kseq_read(seq[1]) >= 0)
		fprintf(stderr, "[W::%s] the 1st file has fewer records.\n", __func__);
	kseq_destroy(seq[0]); gzclose(fp1);
	kseq_destroy(seq[1]); gzclose(fp2);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0x2, %edi
jle 0x804c
movq %rsi, %r14
movq 0x8(%rsi), %rbx
leaq 0x4537(%rip), %rsi      # 0xc3ae
movq %rbx, %rdi
callq 0x2170
testl %eax, %eax
je 0x7e94
leaq 0x330e(%rip), %rsi      # 0xb198
movq %rbx, %rdi
callq 0x2220
jmp 0x7eb1
movq 0x812d(%rip), %rax      # 0xffc8
movq (%rax), %rdi
callq 0x21b0
leaq 0x32ee(%rip), %rsi      # 0xb198
movl %eax, %edi
callq 0x20b0
movq %rax, %rbx
movq 0x10(%r14), %r14
leaq 0x44ef(%rip), %rsi      # 0xc3ae
movq %r14, %rdi
callq 0x2170
testl %eax, %eax
je 0x7edc
leaq 0x32c6(%rip), %rsi      # 0xb198
movq %r14, %rdi
callq 0x2220
jmp 0x7ef9
movq 0x80e5(%rip), %rax      # 0xffc8
movq (%rax), %rdi
callq 0x21b0
leaq 0x32a6(%rip), %rsi      # 0xb198
movl %eax, %edi
callq 0x20b0
movq %rax, %r14
testq %rbx, %rbx
je 0x8053
testq %r14, %r14
je 0x8053
movq %rbx, %rdi
callq 0x3e57
movq %rax, %r12
movq %r14, %rdi
callq 0x3e57
movq %rax, %r15
movq %r12, %rdi
callq 0x3ea1
testl %eax, %eax
js 0x8014
movq 0x8085(%rip), %r13      # 0xffc0
movq %r15, %rdi
callq 0x3ea1
testl %eax, %eax
js 0x8066
xorl %eax, %eax
cmpq $0x0, 0x48(%r12)
setne %al
leal 0x3e(,%rax,2), %edi
callq 0x2060
movq 0x10(%r12), %rdi
movq (%r13), %rsi
callq 0x2110
movl $0xa, %edi
callq 0x2060
movq 0x40(%r12), %rdi
callq 0x2080
cmpq $0x0, 0x48(%r12)
je 0x7faa
movl $0x2b, %edi
callq 0x2060
movl $0xa, %edi
callq 0x2060
movq 0x58(%r12), %rdi
callq 0x2080
xorl %eax, %eax
cmpq $0x0, 0x48(%r15)
setne %al
leal 0x3e(,%rax,2), %edi
callq 0x2060
movq 0x10(%r15), %rdi
movq (%r13), %rsi
callq 0x2110
movl $0xa, %edi
callq 0x2060
movq 0x40(%r15), %rdi
callq 0x2080
cmpq $0x0, 0x48(%r15)
je 0x8004
movl $0x2b, %edi
callq 0x2060
movl $0xa, %edi
callq 0x2060
movq 0x58(%r15), %rdi
callq 0x2080
movq %r12, %rdi
callq 0x3ea1
testl %eax, %eax
jns 0x7f3b
movq %r15, %rdi
callq 0x3ea1
testl %eax, %eax
jns 0x805f
movq %r12, %rdi
callq 0x4229
movq %rbx, %rdi
callq 0x2040
movq %r15, %rdi
callq 0x4229
movq %r14, %rdi
callq 0x2040
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x2c91
jmp 0x8058
callq 0x2c72
movl $0x1, %eax
jmp 0x8042
callq 0x2c53
jmp 0x8020
callq 0x2c34
jmp 0x8014
// File: /workspace/github_c_makefile_star2_O1/aokad[P]sequeeze/seqtk.c
// Function: stk_squeeze
int stk_squeeze(int argc, char *argv[])
{
	gzFile fp;
	//kseq_t *seq, last;
	char *prefix = 0;
	//uint64_t n = 1;

	int c, keep_read_name = 0;
	//char *bin_quality = 0;
	char bin_quality[] = "!!''''''''000000000077777<<<<<BBBBBFFFFFII";
	
	while ((c = getopt(argc, argv, "p:k")) >= 0) {
		switch (c) {
			case 'k': keep_read_name = 1; break;
			case 'p': prefix = optarg; break;
		}
	}

	if (optind == argc) {
		fprintf(stderr, "\n");
		fprintf(stderr, "Usage:   seqtk sequeeze [options] <in.fq>\n");
		fprintf(stderr, "Options: -p CHAR    prefix\n");
		fprintf(stderr, "Options: -k         keep read name\n");
		fprintf(stderr, "\n");
		return 1;
	}

	if (argc == 1 && isatty(fileno(stdin))) {
		fprintf(stderr, "Usage: seqtk rename <in.fq>\n");
		return 1;
	}
	
	fp = (strcmp(argv[optind], "-") == 0)? gzdopen(fileno(stdin), "r") : gzopen(argv[optind], "r");
	if (fp == 0) {
		fprintf(stderr, "[E::%s] failed to open the input file/stream.\n", __func__);
		return 1;
	}
	
	if (keep_read_name == 0) {
		return sequeeze(fp, bin_quality, prefix);
	} else {
		return binning(fp, bin_quality);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebp
leaq 0x2ca6(%rip), %rdx      # 0xc49e
callq 0x2240
xorl %r12d, %r12d
testl %eax, %eax
js 0x9844
movq 0x67cd(%rip), %r13      # 0xffd8
leaq 0x2c8c(%rip), %r15      # 0xc49e
xorl %ebx, %ebx
cmpl $0x70, %eax
je 0x9826
cmpl $0x6b, %eax
jne 0x982a
movl $0x1, %r12d
jmp 0x982a
movq (%r13), %rbx
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2240
testl %eax, %eax
jns 0x9814
testl %r12d, %r12d
sete %r15b
jmp 0x9849
movb $0x1, %r15b
xorl %ebx, %ebx
movq 0x6780(%rip), %r12      # 0xffd0
cmpl %ebp, (%r12)
je 0x98fa
cmpl $0x1, %ebp
jne 0x987d
movq 0x6762(%rip), %rax      # 0xffc8
movq (%rax), %rdi
callq 0x21b0
movl %eax, %edi
callq 0x2090
testl %eax, %eax
jne 0x9908
movslq (%r12), %rax
movq (%r14,%rax,8), %r14
leaq 0x2b22(%rip), %rsi      # 0xc3ae
movq %r14, %rdi
callq 0x2170
testl %eax, %eax
je 0x98a9
leaq 0x18f9(%rip), %rsi      # 0xb198
movq %r14, %rdi
callq 0x2220
jmp 0x98c6
movq 0x6718(%rip), %rax      # 0xffc8
movq (%rax), %rdi
callq 0x21b0
leaq 0x18d9(%rip), %rsi      # 0xb198
movl %eax, %edi
callq 0x20b0
testq %rax, %rax
je 0x9901
leaq 0x30be(%rip), %rsi      # 0xc990
movq %rax, %rdi
testb %r15b, %r15b
je 0x98e4
movq %rbx, %rdx
callq 0x904d
jmp 0x98e9
callq 0x949e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2de9
jmp 0x990d
callq 0x2dca
jmp 0x990d
callq 0x2dae
movl $0x1, %eax
jmp 0x98eb
// File: /workspace/github_c_makefile_star2_O1/aokad[P]sequeeze/seqtk.c
// Function: cpy_kstr
static void cpy_kstr(kstring_t *dst, const kstring_t *src)
{
	if (src->l == 0) return;
	if (src->l + 1 > dst->m) {
		dst->m = src->l + 1;
		kroundup32(dst->m);
		dst->s = realloc(dst->s, dst->m);
	}
	dst->l = src->l;
	memcpy(dst->s, src->s, src->l + 1);
}

// Assembly:
movq (%rsi), %rax
testq %rax, %rax
je 0xa24b
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rax), %rcx
cmpq 0x8(%rdi), %rcx
jbe 0xa22b
movq %rax, %rcx
shrq %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x2, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x8, %rax
orq %rcx, %rax
movq %rax, %rsi
shrq $0x10, %rsi
orq %rax, %rsi
incq %rsi
movq %rsi, 0x8(%r14)
movq 0x10(%r14), %rdi
callq 0x2200
movq %rax, 0x10(%r14)
movq (%rbx), %rax
movq %rax, (%r14)
movq 0x10(%r14), %rdi
movq (%rbx), %rdx
movq 0x10(%rbx), %rsi
incq %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a0
retq
// File: /workspace/github_c_makefile_star2_O1/aokad[P]sequeeze/seqtk.c
// Function: stk_printstr
static void stk_printstr(const kstring_t *s, unsigned line_len)
{
	if (line_len != UINT_MAX && line_len != 0) {
		int i, rest = s->l;
		for (i = 0; i < s->l; i += line_len, rest -= line_len) {
			putchar('\n');
			if (rest > line_len) fwrite(s->s + i, 1, line_len, stdout);
			else fwrite(s->s + i, 1, rest, stdout);
		}
		putchar('\n');
	} else {
		putchar('\n');
		puts(s->s);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
leal -0x1(%r14), %eax
cmpl $-0x3, %eax
ja 0xa4ff
cmpq $0x0, (%rbx)
je 0xa4e7
movl (%rbx), %ebp
movl %r14d, %eax
movq %rax, (%rsp)
xorl %r12d, %r12d
movl %r14d, %r15d
movl %ebp, %r13d
movl $0xa, %edi
callq 0x2060
subl %r14d, %r13d
jbe 0xa4ba
addq 0x10(%rbx), %r12
movq 0x5b17(%rip), %rax      # 0xffc0
movq (%rax), %rcx
movl $0x1, %esi
movq %r12, %rdi
movq (%rsp), %rdx
jmp 0xa4d3
addq 0x10(%rbx), %r12
movslq %ebp, %rdx
movq 0x5af8(%rip), %rax      # 0xffc0
movq (%rax), %rcx
movl $0x1, %esi
movq %r12, %rdi
callq 0x2260
movslq %r15d, %r12
leal (%r12,%r14), %r15d
movl %r13d, %ebp
cmpq %r12, (%rbx)
ja 0xa48f
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2060
movl $0xa, %edi
callq 0x2060
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2080
// File: /workspace/github_c_makefile_star2_O1/eric-lo[P]3150/5-Signal/pause.c
// Function: main
int main(void)
{
	signal(SIGINT, sig_handler);
	pause();
	printf("Ctrl+C received. Bye!\n");
	return 0;
}

// Assembly:
pushq %rax
leaq -0x1a(%rip), %rsi       # 0x115c
movl $0x2, %edi
callq 0x1040
callq 0x1050
leaq 0xe88(%rip), %rdi       # 0x2014
callq 0x1030
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/maandree[P]libkeccak/digest.c
// Function: libkeccak_fast_update
int
libkeccak_fast_update(struct libkeccak_state *restrict state, const void *restrict msg, size_t msglen)
{
	size_t len;
	auto unsigned char *restrict new;

	if (__builtin_expect(state->mptr + msglen > state->mlen, 0)) {
		state->mlen += msglen;
		new = realloc(state->M, state->mlen * sizeof(char));
		if (!new) {
			state->mlen -= msglen;
			return -1;
		}
		state->M = new;
	}

	__builtin_memcpy(state->M + state->mptr, msg, msglen * sizeof(char));
	state->mptr += msglen;
	len = state->mptr;
	len -= state->mptr % (size_t)(state->r >> 3);
	state->mptr -= len;

	libkeccak_absorption_phase(state, state->M, len);
	__builtin_memmove(state->M, state->M + len, state->mptr * sizeof(char));

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x108(%rdi), %rax
addq %rdx, %rax
movq 0x110(%rdi), %rsi
cmpq %rsi, %rax
ja 0x3420
movq 0x118(%r14), %rdi
addq 0x108(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x10a0
addq 0x108(%r14), %rbx
movq 0xc8(%r14), %rcx
movq 0x118(%r14), %rsi
sarq $0x3, %rcx
xorl %r15d, %r15d
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
subq %rdx, %rbx
movq %rdx, 0x108(%r14)
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1976
movq 0x108(%r14), %rdx
movq 0x118(%r14), %rdi
addq %rdi, %rbx
movq %rbx, %rsi
callq 0x10d0
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
addq %rbx, %rsi
movq %rsi, 0x110(%r14)
movq 0x118(%r14), %rdi
callq 0x10c0
testq %rax, %rax
je 0x3447
movq %rax, 0x118(%r14)
jmp 0x33ac
subq %rbx, 0x110(%r14)
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x3417
// File: /workspace/github_c_makefile_star2_O1/maandree[P]libkeccak/digest.c
// Function: libkeccak_update
int
libkeccak_update(struct libkeccak_state *restrict state, const void *restrict msg, size_t msglen)
{
	size_t len;
	auto unsigned char *restrict new;

	if (__builtin_expect(state->mptr + msglen > state->mlen, 0)) {
		state->mlen += msglen;
		new = malloc(state->mlen * sizeof(char));
		if (!new) {
			state->mlen -= msglen;
			return -1;
		}
		libkeccak_state_wipe_message(state);
		free(state->M);
		state->M = new;
	}

	__builtin_memcpy(state->M + state->mptr, msg, msglen * sizeof(char));
	state->mptr += msglen;
	len = state->mptr;
	len -= state->mptr % (size_t)(state->r >> 3);
	state->mptr -= len;

	libkeccak_absorption_phase(state, state->M, len);
	__builtin_memmove(state->M, state->M + len, state->mptr * sizeof(char));

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x108(%rdi), %rax
addq %rdx, %rax
movq 0x110(%rdi), %rdi
cmpq %rdi, %rax
ja 0x34f7
movq 0x118(%r14), %rdi
addq 0x108(%r14), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x10a0
addq 0x108(%r14), %rbx
movq 0xc8(%r14), %rcx
movq 0x118(%r14), %rsi
sarq $0x3, %rcx
xorl %r15d, %r15d
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
subq %rdx, %rbx
movq %rdx, 0x108(%r14)
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1976
movq 0x108(%r14), %rdx
movq 0x118(%r14), %rdi
addq %rdi, %rbx
movq %rbx, %rsi
callq 0x10d0
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x110(%r14), %rdx
movq %rbx, %rsi
movq %r14, %rcx
callq 0x12b9
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testb $0x1, %al
je 0x347d
jmp 0x34e8
// File: /workspace/github_c_makefile_star2_O1/maandree[P]libkeccak/libkeccak_state_initialise.c
// Function: libkeccak_state_initialise
int
libkeccak_state_initialise(struct libkeccak_state *restrict state, const struct libkeccak_spec *restrict spec)
{
	long int x;

	state->r = spec->bitrate;
	state->n = spec->output;
	state->c = spec->capacity;
	state->b = state->r + state->c;
	state->w = x = state->b / 25;
	state->l = 0;

	if (x & 0xF0L) {
		state->l |= 4;
		x >>= 4;
	}
	if (x & 0x0CL) {
		state->l |= 2;
		x >>= 2;
	}
	if (x & 0x02L) {
		state->l |= 1;
	}

	state->nr = 12 + (state->l << 1);
	state->wmod = (state->w == 64) ? ~0ULL : (uint64_t)((1ULL << state->w) - 1);
	for (x = 0; x < 25; x++)
		state->S.w64[x] = 0;
	state->mptr = 0;
	state->mlen = (size_t)(state->r * state->b) >> 2;

	state->M = malloc(state->mlen * sizeof(char));
	return state->M == NULL ? -1 : 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, 0xc8(%rdi)
movq 0x10(%rsi), %rcx
movq %rcx, 0xd8(%rdi)
movq 0x8(%rsi), %rsi
movq %rsi, 0xd0(%rdi)
addq %rax, %rsi
movq %rsi, 0xe0(%rdi)
movabsq $-0x5c28f5c28f5c28f5, %rcx # imm = 0xA3D70A3D70A3D70B
movq %rsi, %rax
imulq %rcx
movq %rdx, %rcx
addq %rsi, %rcx
movq %rcx, %rax
shrq $0x3f, %rax
sarq $0x4, %rcx
addq %rax, %rcx
movq %rcx, 0xe8(%rdi)
movq $0x0, 0xf8(%rdi)
movq %rcx, %rax
testb $-0x10, %cl
je 0x50e8
movq $0x4, 0xf8(%rbx)
movq %rcx, %rax
sarq $0x4, %rax
testb $0xc, %al
je 0x50f7
orb $0x2, 0xf8(%rbx)
sarq $0x2, %rax
testb $0x2, %al
je 0x5102
orb $0x1, 0xf8(%rbx)
movq 0xf8(%rbx), %rax
leaq 0xc(,%rax,2), %rax
movq %rax, 0x100(%rbx)
addq $-0x640, %rsi           # imm = 0xF9C0
movq $-0x1, %rax
movq $-0x1, %rdx
shlq %cl, %rdx
cmpq $0x19, %rsi
notq %rdx
cmovbq %rax, %rdx
movq %rdx, 0xf0(%rbx)
xorl %ebp, %ebp
movl $0xc8, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1070
movq $0x0, 0x108(%rbx)
movq 0xe0(%rbx), %rdi
imulq 0xc8(%rbx), %rdi
shrq $0x2, %rdi
movq %rdi, 0x110(%rbx)
callq 0x10b0
movq %rax, 0x118(%rbx)
cmpq $0x1, %rax
sbbl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/maandree[P]libkeccak/extra/libkeccak_state_wipe_message.c
// Function: libkeccak_state_wipe_message
void
libkeccak_state_wipe_message(volatile struct libkeccak_state *state)
{
	volatile unsigned char *restrict M = state->M;
	size_t i;

	for (i = 0; i < state->mptr; i++)
		M[i] = 0;
}

// Assembly:
movq 0x118(%rdi), %rax
cmpq $0x0, 0x108(%rdi)
je 0x51b7
xorl %ecx, %ecx
movb $0x0, (%rax,%rcx)
incq %rcx
cmpq 0x108(%rdi), %rcx
jb 0x51a7
retq
// File: /workspace/github_c_makefile_star2_O1/maandree[P]libkeccak/util/libkeccak_behex_lower.c
// Function: libkeccak_behex_lower
void
libkeccak_behex_lower(char *restrict output, const void *restrict hashsum_, size_t n)
{
	const unsigned char *restrict hashsum = hashsum_;

	output[2 * n] = '\0';
	while (n--) {
		output[2 * n + 0] = "0123456789abcdef"[(hashsum[n] >> 4) & 15];
		output[2 * n + 1] = "0123456789abcdef"[(hashsum[n] >> 0) & 15];
	}
}

// Assembly:
movb $0x0, (%rdi,%rdx,2)
testq %rdx, %rdx
je 0x51f3
leaq 0x10fa(%rip), %rax      # 0x62c2
movzbl -0x1(%rsi,%rdx), %ecx
movl %ecx, %r8d
shrl $0x4, %r8d
movb (%r8,%rax), %r8b
movb %r8b, -0x2(%rdi,%rdx,2)
andl $0xf, %ecx
movb (%rcx,%rax), %cl
movb %cl, -0x1(%rdi,%rdx,2)
leaq -0x1(%rdx), %rcx
movq %rcx, %rdx
testq %rcx, %rcx
jne 0x51c8
retq
// File: /workspace/github_c_makefile_star2_O1/mkubecek[P]nperf/client/main.c
// Function: kill_workers
static void kill_workers(struct client_config *config)
{
	unsigned int i;

	for (i = 0; i < config->n_threads; i++)
		config->workers_data[i].test_finished = 1;
	for (i = 0; i < config->n_threads; i++)
		pthread_kill(config->workers_data[i].tid, SIGUSR1);
	for (i = 0; i < config->n_threads; i++)
		pthread_join(config->workers_data[i].tid, NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x1c(%rdi), %eax
testq %rax, %rax
je 0x300f
movq 0x70(%rbx), %rcx
shlq $0x7, %rax
xorl %edx, %edx
movl $0x1, 0x64(%rcx,%rdx)
subq $-0x80, %rdx
cmpq %rdx, %rax
jne 0x2ffe
cmpl $0x0, 0x1c(%rbx)
je 0x303f
movl $0x28, %r14d
xorl %r15d, %r15d
movq 0x70(%rbx), %rax
movq (%rax,%r14), %rdi
movl $0xa, %esi
callq 0x21c0
incq %r15
movl 0x1c(%rbx), %eax
subq $-0x80, %r14
cmpq %rax, %r15
jb 0x301e
cmpl $0x0, 0x1c(%rbx)
je 0x306c
movl $0x28, %r14d
xorl %r15d, %r15d
movq 0x70(%rbx), %rax
movq (%rax,%r14), %rdi
xorl %esi, %esi
callq 0x2330
incq %r15
movl 0x1c(%rbx), %eax
subq $-0x80, %r14
cmpq %rax, %r15
jb 0x304e
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/mkubecek[P]nperf/client/worker.c
// Function: worker_setup
int worker_setup(struct client_worker_data *data)
{
	int val;
	int ret;
	int sd;

	sd = socket(test_addr.sa.sa_family, SOCK_STREAM, IPPROTO_TCP);
	if (sd < 0) {
		ret = -errno;
		perror("socket");
		return ret;
	}

	if (client_config.tcp_nodelay) {
		val = 1;
		ret = setsockopt(sd, SOL_TCP, TCP_NODELAY, &val, sizeof(val));
		if (ret < 0) {
			ret = -errno;
			perror("setsockopt(TCP_NODELAY)");
			return ret;
		}
	}
	if (client_config.rcvbuf_size) {
		val = client_config.rcvbuf_size;
		ret = setsockopt(sd, SOL_SOCKET, SO_RCVBUF, &val, sizeof(val));
		if (ret < 0) {
			ret = -errno;
			perror("setsockopt(SO_RCVBUF)");
			return ret;
		}
	}
	if (client_config.sndbuf_size) {
		val = client_config.sndbuf_size;
		ret = setsockopt(sd, SOL_SOCKET, SO_SNDBUF, &val, sizeof(val));
		if (ret < 0) {
			ret = -errno;
			perror("setsockopt(SO_SNDBUF)");
			return ret;
		}
	}

	data->sd = sd;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movzwl 0x5c5e(%rip), %edi      # 0x92f8
movl $0x1, %esi
movl $0x6, %edx
callq 0x2380
testl %eax, %eax
js 0x374f
movl %eax, %ebp
leaq 0x5b26(%rip), %r14      # 0x91e0
cmpb $0x1, 0x44(%r14)
jne 0x36eb
leaq 0xc(%rsp), %rcx
movl $0x1, (%rcx)
movl %ebp, %edi
movl $0x6, %esi
movl $0x1, %edx
movl $0x4, %r8d
callq 0x20b0
testl %eax, %eax
js 0x3785
movl 0x38(%r14), %eax
testl %eax, %eax
je 0x3715
leaq 0xc(%rsp), %rcx
movl %eax, (%rcx)
movl %ebp, %edi
movl $0x1, %esi
movl $0x8, %edx
movl $0x4, %r8d
callq 0x20b0
testl %eax, %eax
js 0x3761
movl 0x3c(%r14), %eax
testl %eax, %eax
je 0x373f
leaq 0xc(%rsp), %rcx
movl %eax, (%rcx)
movl %ebp, %edi
movl $0x1, %esi
movl $0x7, %edx
movl $0x4, %r8d
callq 0x20b0
testl %eax, %eax
js 0x3773
movl %ebp, 0x4(%rbx)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2070
xorl %ebx, %ebx
subl (%rax), %ebx
leaq 0x1aec(%rip), %rdi      # 0x524b
jmp 0x3795
callq 0x2070
xorl %ebx, %ebx
subl (%rax), %ebx
leaq 0x1af9(%rip), %rdi      # 0x526a
jmp 0x3795
callq 0x2070
xorl %ebx, %ebx
subl (%rax), %ebx
leaq 0x1afd(%rip), %rdi      # 0x5280
jmp 0x3795
callq 0x2070
xorl %ebx, %ebx
subl (%rax), %ebx
leaq 0x1abd(%rip), %rdi      # 0x5252
callq 0x2280
jmp 0x3744
// File: /workspace/github_c_makefile_star2_O1/mkubecek[P]nperf/client/worker.c
// Function: worker_connect
int worker_connect(struct client_worker_data *data)
{
	union sockaddr_any local_addr;
	socklen_t addr_len;
	int ret;

	ret = sockaddr_length(&test_addr);
	if (ret < 0)
		return ret;
	addr_len = ret;
	ret = connect(data->sd, &test_addr.sa, addr_len);
	if (ret < 0)
		return ret;

	addr_len = sizeof(local_addr);
	ret = getsockname(data->sd, &local_addr.sa, &addr_len);
	if (ret < 0) {
		ret = -errno;
		goto err_close;
	}
	ret = sockaddr_get_port(&local_addr);
	if (ret < 0)
		goto err_close;
	data->client_port = ret;

	return 0;
err_close:
	close(data->sd);
	return ret;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movzwl 0x5b4f(%rip), %eax      # 0x92f8
cmpw $0xa, %ax
movl $0x1c, %ecx
movl $0xffffffea, %edx       # imm = 0xFFFFFFEA
cmovel %ecx, %edx
cmpw $0x2, %ax
movl $0x10, %ebp
cmovnel %edx, %ebp
testl %ebp, %ebp
js 0x3843
movq %rdi, %rbx
movl %ebp, 0x8(%rsp)
movl 0x4(%rdi), %edi
leaq 0x5b1d(%rip), %rsi      # 0x92f8
movl %ebp, %edx
callq 0x22e0
testl %eax, %eax
js 0x382e
leaq 0x8(%rsp), %rdx
movl $0x1c, (%rdx)
movl 0x4(%rbx), %edi
leaq 0xc(%rsp), %rsi
callq 0x22a0
testl %eax, %eax
js 0x3832
movzwl 0xc(%rsp), %eax
cmpl $0xa, %eax
je 0x3816
movl $0xffffffea, %ebp       # imm = 0xFFFFFFEA
cmpl $0x2, %eax
jne 0x3822
movzwl 0xe(%rsp), %eax
rolw $0x8, %ax
movzwl %ax, %ebp
testl %ebp, %ebp
js 0x383b
movw %bp, 0x8(%rbx)
xorl %ebp, %ebp
jmp 0x3843
movl %eax, %ebp
jmp 0x3843
callq 0x2070
xorl %ebp, %ebp
subl (%rax), %ebp
movl 0x4(%rbx), %edi
callq 0x2180
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mkubecek[P]nperf/client/worker.c
// Function: worker_run_test
int worker_run_test(struct client_worker_data *data)
{
	bool get_reply = data->reply;
	bool eof = false;
	int ret;

	data->status = 0;
	while (!eof && !data->test_finished) {
		ret = send_msg(data);
		if (ret < 0) {
			data->status = -1;
			break;
		}
		if (data->test_finished)
			break;
		if (get_reply) {
			ret = recv_msg(data, &eof);
			if (ret < 0) {
				data->status = -1;
				break;
			}
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movb 0x18(%rdi), %bpl
movl $0x0, 0x60(%rdi)
xorl %r12d, %r12d
cmpl $0x0, 0x64(%rbx)
jne 0x395f
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x38b5
movq 0x10(%rbx), %r15
cmpl $0x0, 0x64(%rbx)
jne 0x38d2
movl 0x4(%rbx), %edi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x2110
testq %rax, %rax
jns 0x38a5
callq 0x2070
movl (%rax), %ecx
cmpl $0x4, %ecx
je 0x387c
jmp 0x38bb
addq %rax, %r15
incq 0x50(%rbx)
addq %rax, 0x58(%rbx)
subq %rax, %r14
jne 0x387c
incq 0x48(%rbx)
jmp 0x38d2
cmpl $0x20, %ecx
jne 0x38c4
xorl %ecx, %ecx
jmp 0x38c6
negl %ecx
movl %ecx, 0x60(%rbx)
cmpl $0x0, (%rax)
jg 0x3958
cmpl $0x0, 0x64(%rbx)
jne 0x395f
testb %bpl, %bpl
je 0x3947
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x3929
movq 0x10(%rbx), %r15
cmpl $0x0, 0x64(%rbx)
jne 0x392d
movl 0x4(%rbx), %edi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x2040
testq %rax, %rax
jns 0x3917
callq 0x2070
movl (%rax), %eax
cmpl $0x4, %eax
je 0x38ee
jmp 0x3934
je 0x3953
addq %rax, %r15
incq 0x38(%rbx)
addq %rax, 0x40(%rbx)
subq %rax, %r14
jne 0x38ee
incq 0x30(%rbx)
xorl %r12d, %r12d
xorl %eax, %eax
jmp 0x3943
movl %eax, %ecx
negl %ecx
movl %ecx, 0x60(%rbx)
testl %eax, %eax
setg %al
xorl %r12d, %r12d
testb %al, %al
jne 0x3958
testb $0x1, %r12b
je 0x3865
jmp 0x395f
movb $0x1, %r12b
jmp 0x3930
movl $0xffffffff, 0x60(%rbx) # imm = 0xFFFFFFFF
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mkubecek[P]nperf/client/worker.c
// Function: worker_main
void *worker_main(void * _data)
{
	struct client_worker_data *data = _data;
	int ret;

	data->status = -1;
	worker_setup(data);
	pthread_cleanup_push(cleanup_close, data);
	wsync_inc_counter(&client_worker_sync);

	wsync_wait_for_state(&client_worker_sync, WS_CONNECT);
	ret = worker_connect(data);
	if (ret < 0)
		goto out;
	wsync_inc_counter(&client_worker_sync);

	wsync_wait_for_state(&client_worker_sync, WS_RUN);
	ret = worker_run_test(data);
	if (ret < 0 || data->test_finished)
		goto out;

out:
	pthread_cleanup_pop(1);
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movl $0xffffffff, 0x60(%rdi) # imm = 0xFFFFFFFF
callq 0x3688
movq %rsp, %rdi
xorl %esi, %esi
callq 0x2340
testl %eax, %eax
jne 0x3a9c
movq %rsp, %rdi
callq 0x2300
leaq 0x58f5(%rip), %r14      # 0x9298
movq %r14, %rdi
callq 0x2360
incl 0x593f(%rip)            # 0x92f0
leaq 0x5908(%rip), %rdi      # 0x92c0
callq 0x2080
movq %r14, %rdi
callq 0x2200
movq %r14, %rdi
callq 0x2360
cmpl $0x1, 0x5920(%rip)      # 0x92f4
je 0x39f8
leaq 0x58e3(%rip), %r14      # 0x92c0
leaq 0x58b4(%rip), %r15      # 0x9298
movq %r14, %rdi
movq %r15, %rsi
callq 0x20d0
cmpl $0x1, 0x58fe(%rip)      # 0x92f4
jne 0x39e4
leaq 0x5899(%rip), %rdi      # 0x9298
callq 0x2200
movq %rbx, %rdi
callq 0x379c
testl %eax, %eax
js 0x3a80
leaq 0x5881(%rip), %r14      # 0x9298
movq %r14, %rdi
callq 0x2360
incl 0x58cb(%rip)            # 0x92f0
leaq 0x5894(%rip), %rdi      # 0x92c0
callq 0x2080
movq %r14, %rdi
callq 0x2200
movq %r14, %rdi
callq 0x2360
cmpl $0x2, 0x58ac(%rip)      # 0x92f4
je 0x3a6c
leaq 0x586f(%rip), %r14      # 0x92c0
leaq 0x5840(%rip), %r15      # 0x9298
movq %r14, %rdi
movq %r15, %rsi
callq 0x20d0
cmpl $0x2, 0x588a(%rip)      # 0x92f4
jne 0x3a58
leaq 0x5825(%rip), %rdi      # 0x9298
callq 0x2200
movq %rbx, %rdi
callq 0x384c
movq %rsp, %rdi
callq 0x2130
movl 0x4(%rbx), %edi
callq 0x2180
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x3aac
movq %rsp, %rdi
callq 0x2220
// File: /workspace/github_c_makefile_star2_O1/mkubecek[P]nperf/client/worker.c
// Function: start_client_worker
int start_client_worker(struct client_worker_data *data)
{
	pthread_attr_t attr;
	int ret;

	ret = pthread_attr_init(&attr);
	if (ret)
		return -ret;
	ret = pthread_attr_setstacksize(&attr, WORKER_STACK_SIZE);
	if (ret)
		return -ret;
	ret = pthread_create(&data->tid, &attr, worker_main, data);

	pthread_attr_destroy(&attr);
	return -ret;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2190
testl %eax, %eax
jne 0x3ae0
leaq 0x8(%rsp), %rdi
movl $0x4000, %esi           # imm = 0x4000
callq 0x2390
testl %eax, %eax
je 0x3aef
movl %eax, %ebp
negl %ebp
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28(%rbx), %rdi
leaq -0x190(%rip), %rdx      # 0x396a
leaq 0x8(%rsp), %r14
movq %r14, %rsi
movq %rbx, %rcx
callq 0x2250
movl %eax, %ebp
movq %r14, %rdi
callq 0x22c0
jmp 0x3ae2
nop
// File: /workspace/github_c_makefile_star2_O1/mkubecek[P]nperf/stats.c
// Function: print_count
void print_count(uint64_t val, const struct print_options *opts)
{
	unsigned int base = opts->binary_prefix ? 1024 : 1000;
	const char *unit_str = unit_names[opts->unit];
	const char prefixes[] = " KMGT";
	const char *prefix = &prefixes[0];
	double dval;

	if (opts->exact) {
		printf("%*" PRIu64 " %s", opts->width, val, unit_str);
		return;
	}
	if (val < 20 * base) {
		printf("%5" PRIu64 "    %s", val, unit_str);
		return;
	}

	dval = val / base;
	prefix++;
	while ((dval >= 20 * base) && *prefix) {
		dval /= base;
		prefix++;
	}
	printf("%7.1lf %c%s", dval, *prefix, unit_str);

}

// Assembly:
movq %rdi, %rdx
cmpb $0x0, 0x9(%rsi)
movl $0x400, %eax            # imm = 0x400
movl $0x3e8, %edi            # imm = 0x3E8
cmovnel %eax, %edi
movl (%rsi), %eax
leaq 0x4c91(%rip), %rcx      # 0x8db0
movq (%rcx,%rax,8), %rcx
cmpb $0x1, 0x8(%rsi)
jne 0x413a
movl 0x4(%rsi), %esi
leaq 0x1f1d(%rip), %rdi      # 0x6050
xorl %eax, %eax
jmp 0x2120
leal (,%rdi,4), %eax
leal (%rax,%rax,4), %esi
cmpq %rdx, %rsi
jbe 0x415d
leaq 0x1f08(%rip), %rdi      # 0x6058
movq %rdx, %rsi
movq %rcx, %rdx
xorl %eax, %eax
jmp 0x2120
movl %edi, %r8d
movq %rdx, %rax
xorl %edx, %edx
divq %r8
cvtsi2sd %rax, %xmm0
cvtsi2sd %esi, %xmm1
ucomisd %xmm1, %xmm0
jae 0x4180
leaq 0x1ef2(%rip), %rax      # 0x6070
jmp 0x41ad
cvtsi2sd %edi, %xmm2
xorl %edx, %edx
leaq 0x1ee7(%rip), %rax      # 0x6074
cmpq $0x4, %rdx
je 0x41ad
divsd %xmm2, %xmm0
incq %rdx
ucomisd %xmm1, %xmm0
jae 0x418d
leaq 0x1ec8(%rip), %rax      # 0x606f
addq %rdx, %rax
incq %rax
movsbl (%rax), %esi
leaq 0x1eac(%rip), %rdi      # 0x6063
movq %rcx, %rdx
movb $0x1, %al
jmp 0x2120
// File: /workspace/github_c_makefile_star2_O1/mkubecek[P]nperf/stats.c
// Function: print_rate
void print_rate(double val, const struct print_options *opts)
{
	unsigned int base = opts->binary_prefix ? 1024 : 1000;
	const char *unit_str = unit_names[opts->unit];
	const char prefixes[] = " KMGT";
	const char *prefix = &prefixes[0];

	if (opts->exact) {
		printf("%*.1lf %s/s", opts->width, val, unit_str);
		return;
	}

	while (val >= 20000 && *prefix) {
		val /= base;
		prefix++;
	}
	printf("%7.1lf %c%s/s", val, *prefix, unit_str);

}

// Assembly:
movl (%rdi), %eax
leaq 0x4be6(%rip), %rcx      # 0x8db0
movq (%rcx,%rax,8), %rdx
cmpb $0x0, 0x8(%rdi)
je 0x41e5
movl 0x4(%rdi), %esi
leaq 0x1e97(%rip), %rdi      # 0x6075
movb $0x1, %al
jmp 0x2120
ucomisd 0x1e23(%rip), %xmm0     # 0x6010
jae 0x41f8
leaq 0x1e79(%rip), %rax      # 0x606f
jmp 0x423e
cmpb $0x0, 0x9(%rdi)
jne 0x4208
movsd 0x1e1a(%rip), %xmm1     # 0x6020
jmp 0x4210
movsd 0x1e08(%rip), %xmm1     # 0x6018
xorl %ecx, %ecx
leaq 0x1e5b(%rip), %rax      # 0x6074
movsd 0x1def(%rip), %xmm2     # 0x6010
cmpq $-0x5, %rcx
je 0x423e
divsd %xmm1, %xmm0
decq %rcx
ucomisd %xmm2, %xmm0
jae 0x4221
leaq 0x1e34(%rip), %rax      # 0x606f
subq %rcx, %rax
movsbl (%rax), %esi
leaq 0x1e39(%rip), %rdi      # 0x6081
movb $0x1, %al
jmp 0x2120
// File: /workspace/github_c_makefile_star2_O1/mkubecek[P]nperf/stats.c
// Function: xfer_stats_print_raw
void xfer_stats_print_raw(const struct xfer_stats *stats, unsigned int id)
{
	if (id == XFER_STATS_TOTAL)
		fputs("total    ", stdout);
	else
		printf("%-8u ", id);

	xfer_stats_1_print(&stats->rx);
	fputs("    ", stdout);
	xfer_stats_1_print(&stats->tx);
	putchar('\n');
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $-0x1, %esi
je 0x42de
leaq 0x1dfb(%rip), %rdi      # 0x60d0
xorl %eax, %eax
callq 0x2120
jmp 0x42f4
movq 0x4ceb(%rip), %rax      # 0x8fd0
movq (%rax), %rsi
leaq 0x1dd7(%rip), %rdi      # 0x60c6
callq 0x2150
movq (%rbx), %rdx
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rcx
leaq 0x1e5d(%rip), %r14      # 0x6163
movq %r14, %rdi
xorl %eax, %eax
callq 0x2120
movq 0x4cb9(%rip), %rax      # 0x8fd0
movq (%rax), %rsi
leaq 0x1ddf(%rip), %rdi      # 0x6100
callq 0x2150
movq 0x18(%rbx), %rdx
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rcx
movq %r14, %rdi
xorl %eax, %eax
callq 0x2120
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O1/mkubecek[P]nperf/stats.c
// Function: xfer_stats_thread_footer
void xfer_stats_thread_footer(double sum, double sum_sqr, unsigned int n,
			      const struct print_options *opts)
{
	double avg, mdev;

	avg = sum / n;
	mdev = mdev_n(sum, sum_sqr, n);
	fputs("thread average ", stdout);
	print_rate(avg, opts);
	fputs(", mdev ", stdout);
	print_rate(mdev, opts);
	printf(" (%.1lf%%)\n", 100 * mdev / avg);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl %edi, %eax
cvtsi2sd %rax, %xmm3
movapd %xmm0, %xmm2
divsd %xmm3, %xmm2
movsd %xmm2, 0x10(%rsp)
mulsd %xmm0, %xmm0
mulsd %xmm3, %xmm1
subsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x438b
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0x43a0
movapd %xmm1, %xmm0
movsd %xmm3, 0x8(%rsp)
callq 0x2310
movsd 0x8(%rsp), %xmm3
divsd %xmm3, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x4c1f(%rip), %r14      # 0x8fd0
movq (%r14), %rsi
leaq 0x1d1b(%rip), %rdi      # 0x60d6
callq 0x2150
movsd 0x10(%rsp), %xmm0
movq %rbx, %rdi
callq 0x41c1
movq (%r14), %rsi
leaq 0x1d0e(%rip), %rdi      # 0x60e6
callq 0x2150
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x41c1
movsd 0x8(%rsp), %xmm0
mulsd 0xc37(%rip), %xmm0      # 0x5030
divsd 0x10(%rsp), %xmm0
leaq 0x1ce8(%rip), %rdi      # 0x60ee
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x2120
// File: /workspace/github_c_makefile_star2_O1/kobolt[P]curses-collection/invaders/loop.c
// Function: loop
void loop(void)
{
  long cycle;
  iface_action_t action;
  
  game_init();
  iface_init();

  iface_redraw_screen();
  for (cycle = 0;; cycle++) {

    action = iface_get_action();

    /* Perform player action. */
    switch (action) {
    case ACTION_EXIT:
      iface_set_end_msg("Player gave up!");
      return;

    case ACTION_RESIZE:
      if (iface_invalid_size()) {
        iface_set_end_msg("Invalid resize of terminal!");
        return;
      }
      break;

    case ACTION_SHOOT:
      game_fire_shot();
      break;

    case ACTION_MOVE_LEFT:
      game_state.player_pos--;
      if (game_state.player_pos < 2)
        game_state.player_pos = 2;
      break;

    case ACTION_MOVE_RIGHT:
      game_state.player_pos++;
      if (game_state.player_pos > (GAME_MAP_WIDTH - 3))
        game_state.player_pos = GAME_MAP_WIDTH - 3;
      break;

    case ACTION_NONE:
      break;
    }

    if (game_handle_invaders(cycle)) {
      iface_flash_screen();
      iface_set_end_msg("Player could not stop the invaders in time!");
      return;
    }

    if (game_handle_shot())
      iface_flash_screen();

    if (game_handle_bombs()) {
      iface_flash_screen();
      iface_set_end_msg("Player died from an invader's bomb!");
      return;
    }

    if (game_invaders_alive() == 0)
      break; /* Won. */

    iface_redraw_screen();

    usleep(50000);
  }

  iface_set_end_msg("Success! Invader attack has been stopped!");
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x1ac0
callq 0x13b8
callq 0x15e8
xorl %r14d, %r14d
leaq 0x1d55(%rip), %rbx      # 0x3018
leaq 0x1d7a(%rip), %r15      # 0x3044
leaq 0x1d33(%rip), %r12      # 0x3004
leaq 0x3e68(%rip), %r13      # 0x5140
callq 0x155c
decl %eax
cmpl $0x4, %eax
ja 0x132f
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
callq 0x1504
testl %eax, %eax
je 0x132f
jmp 0x13a0
movzwl 0xa(%r13), %eax
incl %eax
cmpw $0x4d, %ax
movl $0x4d, %ecx
cmovgel %ecx, %eax
jmp 0x132a
callq 0x1b57
jmp 0x132f
movzwl 0xa(%r13), %eax
decl %eax
cmpw $0x3, %ax
movl $0x2, %ecx
cmovll %ecx, %eax
movw %ax, 0xa(%r13)
movq %r14, %rdi
callq 0x1b7e
testl %eax, %eax
jne 0x1379
callq 0x1d7a
testl %eax, %eax
je 0x1349
callq 0x1ab5
callq 0x1f02
testl %eax, %eax
jne 0x1372
callq 0x1b36
testl %eax, %eax
je 0x1383
callq 0x15e8
movl $0xc350, %edi           # imm = 0xC350
callq 0x1190
incq %r14
jmp 0x12d8
leaq 0x1cf7(%rip), %r15      # 0x3070
callq 0x1ab5
movq %r15, %rbx
jmp 0x138a
leaq 0x1d0a(%rip), %rbx      # 0x3094
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1543
leaq 0x1c81(%rip), %rbx      # 0x3028
jmp 0x138a
// File: /workspace/github_c_makefile_star2_O1/kobolt[P]curses-collection/invaders/iface.c
// Function: iface_init
void iface_init(void)
{
  initscr();
  atexit(iface_exit_handler);
  noecho();
  keypad(stdscr, TRUE);
  timeout(0); /* Non-blocking mode */

  if (iface_invalid_size()) {
    strncpy(iface_end_msg, 
      "Invalid size of terminal. (Must be atleast 80x24.)", IFACE_END_MSG_MAX);
    exit(0);
  }

  strncpy(iface_end_msg, "Abnormal termination.", IFACE_END_MSG_MAX);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
callq 0x1080
leaq 0x83(%rip), %rdi        # 0x144e
callq 0x20f0
callq 0x1060
movq 0x3c04(%rip), %r14      # 0x4fe0
movq (%r14), %rdi
movl $0x1, %esi
callq 0x10a0
movq (%r14), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x10e0
movq (%r14), %rax
testq %rax, %rax
je 0x1405
cmpw $0x17, 0x4(%rax)
setge %bl
testq %rax, %rax
je 0x1414
cmpw $0x4f, 0x6(%rax)
setge %al
jmp 0x1416
xorl %eax, %eax
leaq 0x3cd3(%rip), %rdi      # 0x50f0
testb %al, %bl
je 0x1436
leaq 0x1d53(%rip), %rsi      # 0x317b
movl $0x50, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x10d0
leaq 0x1d8f(%rip), %rsi      # 0x31cc
movl $0x50, %edx
callq 0x10d0
xorl %edi, %edi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O1/kobolt[P]curses-collection/invaders/iface.c
// Function: iface_exit_handler
static void iface_exit_handler(void)
{
  char *rating;

  if (game_state.score >= 3000)
    rating = "Perfect";
  else if (game_state.score > 2500)
    rating = "Very Good";
  else if (game_state.score > 2000)
    rating = "Good";
  else if (game_state.score > 1000)
    rating = "Mediocre";
  else if (game_state.score > 0)
    rating = "Poor";
  else
    rating = "Horrible";

  endwin();
  printf("\n%s\n", iface_end_msg);
  printf("%d invaders survived, and %d shots were wasted.\n",
    game_invaders_alive(), game_state.wasted_shots);
  printf("Score: %ld (%s)\n", game_state.score, rating);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x3ce4(%rip), %r14      # 0x5140
movq (%r14), %rax
cmpq $0xbb7, %rax            # imm = 0xBB7
jle 0x1470
leaq 0x1c9d(%rip), %rbx      # 0x310b
jmp 0x14b8
cmpq $0x9c4, %rax            # imm = 0x9C4
jle 0x1481
leaq 0x1c94(%rip), %rbx      # 0x3113
jmp 0x14b8
cmpq $0x7d0, %rax            # imm = 0x7D0
jle 0x1492
leaq 0x1c88(%rip), %rbx      # 0x3118
jmp 0x14b8
cmpq $0x3e8, %rax            # imm = 0x3E8
jle 0x14a3
leaq 0x1c7c(%rip), %rbx      # 0x311d
jmp 0x14b8
testq %rax, %rax
leaq 0x1c79(%rip), %rax      # 0x3126
leaq 0x1c77(%rip), %rbx      # 0x312b
cmovgq %rax, %rbx
callq 0x1150
leaq 0x1c70(%rip), %rdi      # 0x3134
leaq 0x3c25(%rip), %rsi      # 0x50f0
xorl %eax, %eax
callq 0x1070
callq 0x1b36
movswl 0x8(%r14), %edx
leaq 0x1c56(%rip), %rdi      # 0x3139
movl %eax, %esi
xorl %eax, %eax
callq 0x1070
movq (%r14), %rsi
leaq 0x1c74(%rip), %rdi      # 0x316a
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/kobolt[P]curses-collection/invaders/iface.c
// Function: iface_invalid_size
int iface_invalid_size(void)
{
  int maxy, maxx;

  getmaxyx(stdscr, maxy, maxx);

  if (maxy < GAME_MAP_HEIGHT)
    return 1;
  else if (maxx < GAME_MAP_WIDTH)
    return 1;
  else
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x3ad1(%rip), %rax      # 0x4fe0
movq (%rax), %rdx
testq %rdx, %rdx
je 0x1521
cmpw $0x17, 0x4(%rdx)
setl %cl
jmp 0x1523
movb $0x1, %cl
movl $0x1, %esi
movl $0x1, %eax
testq %rdx, %rdx
je 0x153c
xorl %eax, %eax
cmpw $0x4f, 0x6(%rdx)
setl %al
testb %cl, %cl
cmovnel %esi, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kobolt[P]curses-collection/invaders/iface.c
// Function: iface_get_action
iface_action_t iface_get_action(void)
{
  int c;
  iface_action_t action;

  action = ACTION_NONE; /* Default. */

  /* Read character buffer until empty. */
  while ((c = getch()) != ERR) {
    switch (c) {
    case KEY_RESIZE:
      return ACTION_RESIZE;
    case ' ':
    case KEY_UP:
      action = ACTION_SHOOT;
      break;
    case KEY_LEFT:
      action = ACTION_MOVE_LEFT;
      break;
    case KEY_RIGHT:
      action = ACTION_MOVE_RIGHT;
      break;
    case 'q':
    case 'Q':
    case '\e':
      return ACTION_EXIT;
    default:
      break;
    }
  }

  return action;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
xorl %ebx, %ebx
movq 0x3a74(%rip), %r14      # 0x4fe0
movq (%r14), %rdi
callq 0x1050
cmpl $0x70, %eax
jle 0x159c
cmpl $0x103, %eax            # imm = 0x103
jle 0x15ad
cmpl $0x19a, %eax            # imm = 0x19A
je 0x15dc
cmpl $0x105, %eax            # imm = 0x105
je 0x15ce
cmpl $0x104, %eax            # imm = 0x104
jne 0x156c
movl $0x3, %ebx
jmp 0x156c
cmpl $0x1f, %eax
jg 0x15bb
cmpl $-0x1, %eax
je 0x15e1
cmpl $0x1b, %eax
jne 0x156c
jmp 0x15d5
cmpl $0x71, %eax
je 0x15d5
cmpl $0x103, %eax            # imm = 0x103
jne 0x156c
jmp 0x15c7
cmpl $0x20, %eax
je 0x15c7
cmpl $0x51, %eax
jne 0x156c
jmp 0x15d5
movl $0x5, %ebx
jmp 0x156c
movl $0x4, %ebx
jmp 0x156c
movl $0x1, %ebx
jmp 0x15e1
movl $0x2, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Keith-S-Thompson[P]kst-time-utils/usleep-until.c
// Function: main
int main(int argc, char **argv) {
    if (argc < 2) {
        usage_error(argv[0]);
    }
    const int seconds = atoi(argv[1]);
    if (seconds <= 0) {
        usage_error(argv[0]);
    }

    struct timeval tv;
    gettimeofday(&tv, NULL);

    time_t sleep_seconds = seconds - tv.tv_sec % seconds - 1;
    suseconds_t sleep_useconds = ONE_MILLION - tv.tv_usec;
    if (sleep_useconds == ONE_MILLION) {
        sleep_useconds = 0;
        sleep_seconds ++;
    }

    usleep(ONE_MILLION * (useconds_t)sleep_seconds + sleep_useconds);

    if (argc > 2) {
        execvp(argv[2], argv+2);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
cmpl $0x1, %edi
jle 0x126c
movl %edi, %ebp
movq 0x8(%rbx), %rdi
callq 0x1060
testl %eax, %eax
jle 0x1274
movl %eax, %r14d
xorl %r12d, %r12d
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x1030
movl %r14d, %ecx
movq (%r15), %rax
movq 0x8(%r15), %rsi
cqto
idivq %rcx
subl %edx, %r14d
movl $0xf4240, %eax          # imm = 0xF4240
subl %esi, %eax
xorl %ecx, %ecx
testq %rsi, %rsi
cmovel %r12d, %eax
setne %cl
subl %ecx, %r14d
imull $0xf4240, %r14d, %edi   # imm = 0xF4240
addl %eax, %edi
callq 0x1080
cmpl $0x2, %ebp
je 0x125d
movq 0x10(%rbx), %rdi
addq $0x10, %rbx
movq %rbx, %rsi
callq 0x1050
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x10c4
movq %rbx, %rdi
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O1/garbeam[P]st/st.c
// Function: ttyread
size_t
ttyread(void)
{
	static char buf[BUFSIZ];
	static int buflen = 0;
	int written;
	int ret;

	/* append read bytes to unprocessed bytes */
	if ((ret = read(cmdfd, buf+buflen, LEN(buf)-buflen)) < 0)
		die("couldn't read from shell: %s\n", strerror(errno));
	buflen += ret;

	written = twrite(buf, buflen, 0);
	buflen -= written;
	/* keep any uncomplete utf8 char for the next call */
	if (buflen > 0)
		memmove(buf, buf + written, buflen);

	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0xedb9(%rip), %edi      # 0x15778
movslq 0x10dba(%rip), %rax     # 0x17780
leaq 0xedb3(%rip), %rsi      # 0x15780
addq %rax, %rsi
movl $0x2000, %edx           # imm = 0x2000
subq %rax, %rdx
callq 0x51c0
movq %rax, %rbx
testl %ebx, %ebx
js 0x6a34
movl 0x10d96(%rip), %esi     # 0x17780
addl %ebx, %esi
movl %esi, 0x10d8e(%rip)     # 0x17780
leaq 0xed87(%rip), %r14      # 0x15780
movq %r14, %rdi
xorl %edx, %edx
callq 0x6a51
movl 0x10d77(%rip), %ecx     # 0x17780
subl %eax, %ecx
movl %ecx, 0x10d6f(%rip)     # 0x17780
jle 0x6a23
movslq %eax, %rsi
addq %r14, %rsi
movl %ecx, %edx
movq %r14, %rdi
callq 0x54d0
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x5560
movl (%rax), %edi
callq 0x5420
leaq 0x7bc0(%rip), %rdi      # 0xe607
movq %rax, %rsi
xorl %eax, %eax
callq 0x5e16
// File: /workspace/github_c_makefile_star2_O1/garbeam[P]st/st.c
// Function: draw
void
draw(void)
{
	int cx = term.c.x;

	if (!xstartdraw())
		return;

	/* adjust cursor position */
	LIMIT(term.ocx, 0, term.col-1);
	LIMIT(term.ocy, 0, term.row-1);
	if (term.line[term.ocy][term.ocx].mode & ATTR_WDUMMY)
		term.ocx--;
	if (term.line[term.c.y][cx].mode & ATTR_WDUMMY)
		cx--;

	drawregion(0, 0, term.col, term.row);
	xdrawcursor(cx, term.c.y, term.line[term.c.y][cx],
			term.ocx, term.ocy, term.line[term.ocy][term.ocx]);
	term.ocx = cx, term.ocy = term.c.y;
	xfinishdraw();
	xximspot(term.ocx, term.ocy);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movslq 0xdfa0(%rip), %rbx      # 0x15740
callq 0xa27b
testl %eax, %eax
je 0x7907
movl 0xdf99(%rip), %edx      # 0x1574c
xorl %ecx, %ecx
movl $0x0, %eax
testl %edx, %edx
js 0x77cb
movl 0xdf50(%rip), %eax      # 0x15714
decl %eax
cmpl %eax, %edx
cmovll %edx, %eax
movl %eax, 0xdf7b(%rip)      # 0x1574c
movl 0xdf79(%rip), %edx      # 0x15750
testl %edx, %edx
js 0x77e8
movl 0xdf2f(%rip), %ecx      # 0x15710
decl %ecx
cmpl %ecx, %edx
cmovll %edx, %ecx
movl %ecx, 0xdf62(%rip)      # 0x15750
movq 0xdf23(%rip), %rdx      # 0x15718
movslq %ecx, %rcx
movq (%rdx,%rcx,8), %rcx
movslq %eax, %rsi
shlq $0x4, %rsi
testb $0x4, 0x5(%rcx,%rsi)
je 0x7812
decl %eax
movl %eax, 0xdf3a(%rip)      # 0x1574c
movslq 0xdf2b(%rip), %rax      # 0x15744
movq (%rdx,%rax,8), %rax
movq %rbx, %rcx
shlq $0x4, %rcx
movl 0x4(%rax,%rcx), %eax
shll $0x5, %eax
movswl %ax, %ebp
sarl $0xf, %ebp
addl %ebx, %ebp
movslq 0xded6(%rip), %r15      # 0x15710
testq %r15, %r15
jle 0x787d
movl 0xdecf(%rip), %ebx      # 0x15714
xorl %r14d, %r14d
movq 0xded9(%rip), %rax      # 0x15728
cmpl $0x0, (%rax,%r14,4)
je 0x7875
movl $0x0, (%rax,%r14,4)
movq 0xdeb3(%rip), %rax      # 0x15718
movq (%rax,%r14,8), %rdi
xorl %esi, %esi
movl %r14d, %edx
movl %ebx, %ecx
callq 0xa285
incq %r14
cmpq %r14, %r15
jne 0x7848
movslq 0xdec0(%rip), %rsi      # 0x15744
movq 0xde8d(%rip), %rax      # 0x15718
movq (%rax,%rsi,8), %rcx
movslq %ebp, %rbx
movq %rbx, %rdi
shlq $0x4, %rdi
movslq 0xdeac(%rip), %r8       # 0x1574c
movslq 0xdea9(%rip), %r9       # 0x15750
movq (%rax,%r9,8), %rax
movq %r8, %r10
shlq $0x4, %r10
movq (%rcx,%rdi), %rdx
movq 0x8(%rcx,%rdi), %rcx
movups (%rax,%r10), %xmm0
movaps %xmm0, 0x10(%rsp)
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%rsp)
movl %ebx, %edi
callq 0x9efd
movl %ebx, 0xde71(%rip)      # 0x1574c
movl 0xde63(%rip), %eax      # 0x15744
movl %eax, 0xde69(%rip)      # 0x15750
callq 0xae5f
movl 0xde5a(%rip), %edi      # 0x1574c
movl 0xde58(%rip), %esi      # 0x15750
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xaee0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq