LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/videolan[P]bitstream/examples/dvb_gen_si.c
// Function: build_desc46
static void build_desc46(uint8_t *desc) {
    uint8_t k = 0;
    uint8_t *lang_n;

    desc46_init(desc);
    desc_set_length(desc, 255);

    lang_n = desc46_get_language(desc, k++);
    desc46n_set_code(lang_n, (uint8_t *)"eng");
    desc46n_set_teletexttype(lang_n, 1);
    desc46n_set_teletextmagazine(lang_n, 3);
    desc46n_set_teletextpage(lang_n, 255);

    lang_n = desc46_get_language(desc, k++);
    desc46n_set_code(lang_n, (uint8_t *)"bul");
    desc46n_set_teletexttype(lang_n, 2);
    desc46n_set_teletextmagazine(lang_n, 2);
    desc46n_set_teletextpage(lang_n, 127);

    lang_n = desc46_get_language(desc, k++);
    desc46n_set_code(lang_n, (uint8_t *)"fre");
    desc46n_set_teletexttype(lang_n, 3);
    desc46n_set_teletextmagazine(lang_n, 1);
    desc46n_set_teletextpage(lang_n, 64);

    lang_n = desc46_get_language(desc, k);
    desc_set_length(desc, lang_n - desc - DESC_HEADER_SIZE);
}

// Assembly:
movabsq $0x62ff0b676e65ff46, %rax # imm = 0x62FF0B676E65FF46
movq %rax, (%rdi)
movb 0x1(%rdi), %cl
leaq 0x7(%rdi), %rsi
leaq 0xc(%rdi), %rax
cmpb $0xa, %cl
cmovaeq %rax, %rsi
xorl %edx, %edx
cmpb $0xf, %cl
cmovbq %rdx, %rsi
cmpb $0xa, %cl
cmovbq %rdx, %rsi
movl $0x7f126c75, 0x8(%rdi)  # imm = 0x7F126C75
movl $0x19657266, (%rsi)     # imm = 0x19657266
movb $0x40, 0x4(%rsi)
movzbl 0x1(%rdi), %ecx
cmpq $0x5, %rcx
jb 0x8506
leaq 0x2(%rdi), %rsi
addq %rsi, %rcx
xorl %edx, %edx
movq %rax, %r8
leaq -0x5(%rdx), %r9
cmpq %rcx, %rax
ja 0x84fa
leaq 0x5(%r8), %rax
cmpb $-0xa, %dl
movq %r9, %rdx
jne 0x84e2
subq %r9, %rsi
xorl %edx, %edx
cmpq %rcx, %r8
cmovbeq %rsi, %rdx
subl %edi, %edx
addb $-0x2, %dl
movb %dl, 0x1(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/keiranrowan[P]tiny-core/./src/cat.c
// Function: main
int main(int argc, char **argv) {
	if ((strcmp(argv[1], "-h") == 0) || (strcmp(argv[1], "--help") == 0)) {
		printf("cat [FILE]...\n- to read stdin\n");
	} else if (strcmp(argv[1],"-") == 0) {
		char ch;
		while ((ch = getc(stdin)) != EOF) {
			putc(ch, stdout);
		}
	} else {
		int i;
		for (i = 1; i < argc; i++) {
			FILE *fp;
			char ch;
			fp = fopen(argv[i], "r");
			if (fp) {
				while ((ch = getc(fp)) != EOF) {
					putc(ch, stdout);
				}
				fclose(fp);
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movq 0x8(%rsi), %r14
cmpb $0x2d, (%r14)
jne 0x121e
cmpb $0x68, 0x1(%r14)
jne 0x11b8
cmpb $0x0, 0x2(%r14)
je 0x1295
leaq 0xe45(%rip), %rsi       # 0x2004
movq %r14, %rdi
callq 0x1050
testl %eax, %eax
je 0x1295
cmpb $0x0, 0x1(%r14)
jne 0x1231
movq 0x2e03(%rip), %rbx      # 0x3fe0
movq (%rbx), %rdi
callq 0x1080
shll $0x18, %eax
cmpl $0xff000000, %eax       # imm = 0xFF000000
je 0x12a1
movq 0x2dde(%rip), %r14      # 0x3fd8
sarl $0x18, %eax
movq (%r14), %rsi
movl %eax, %edi
callq 0x1060
movq (%rbx), %rdi
callq 0x1080
shll $0x18, %eax
cmpl $0xff000000, %eax       # imm = 0xFF000000
jne 0x11fa
jmp 0x12a1
leaq 0xddf(%rip), %rsi       # 0x2004
movq %r14, %rdi
callq 0x1050
testl %eax, %eax
je 0x1295
cmpl $0x2, %ebp
jl 0x12a1
movl %ebp, %r12d
movl $0x1, %r13d
leaq 0xdc5(%rip), %r14       # 0x200b
movq 0x2d8b(%rip), %rbp      # 0x3fd8
movq (%rbx,%r13,8), %rdi
movq %r14, %rsi
callq 0x1070
testq %rax, %rax
je 0x128b
movq %rax, %r15
movq %r15, %rdi
callq 0x1080
shll $0x18, %eax
cmpl $0xff000000, %eax       # imm = 0xFF000000
je 0x1283
sarl $0x18, %eax
movq (%rbp), %rsi
movl %eax, %edi
callq 0x1060
jmp 0x1261
movq %r15, %rdi
callq 0x1040
incq %r13
cmpq %r12, %r13
jne 0x124d
jmp 0x12a1
leaq 0xd71(%rip), %rdi       # 0x200d
callq 0x1030
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/tylerneylon[P]APIsWithLua/ch1/loadmodule.c
// Function: main
int main() {
  lua_State *L = luaL_newstate();
  luaL_openlibs(L);
  luaL_dofile(L, "mymodule.lua");
  lua_setglobal(L, "mymodule");
  lua_settop(L, 0);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x14a89
movq %rax, %rbx
movq %rax, %rdi
callq 0x14c8c
leaq 0x1c85b(%rip), %rsi     # 0x21004
movq %rbx, %rdi
xorl %edx, %edx
callq 0x141e2
testl %eax, %eax
jne 0x47ce
movq %rbx, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5ba7
leaq 0x1c83c(%rip), %rsi     # 0x21011
movq %rbx, %rdi
callq 0x56c4
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4925
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pipde[P]deos-songlib/utils/waveinfo/waveinfo.c
// Function: main
int
main(int argc,char **argv)
    {
    int argIndex = 1;

    char *in;
    WAVE *w;

    argIndex = processOptions(argc,argv);

    if (argc-argIndex == 1)
        {
        in = argv[argIndex];
        }
    else
        {
        printf("usage: waveheader <wave file>\n");
        exit(-1);
        }

    w = readWave(in);

    displayWave(w);

    return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
movl $0x1, %r12d
cmpl $0x2, %edi
jl 0x19cf
movl %r14d, %r13d
movl $0x1, %r12d
leaq 0x1678(%rip), %r15      # 0x3023
movq (%rbx,%r12,8), %rsi
cmpb $0x2d, (%rsi)
jne 0x19cf
cmpb $0x76, 0x1(%rsi)
je 0x19fd
movq %r15, %rdi
xorl %eax, %eax
callq 0x1a38
incq %r12
cmpq %r12, %r13
jne 0x19ab
movl %r13d, %r12d
subl %r12d, %r14d
cmpl $0x1, %r14d
jne 0x1a20
movslq %r12d, %rax
movq (%rbx,%rax,8), %rdi
callq 0x1254
movq %rax, %rdi
callq 0x1e1e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x36c4(%rip), %rsi      # 0x50c8
movq 0x36c5(%rip), %rdx      # 0x50d0
leaq 0x1602(%rip), %rdi      # 0x3014
xorl %eax, %eax
callq 0x10a0
xorl %edi, %edi
callq 0x1150
leaq 0x1616(%rip), %rdi      # 0x303d
callq 0x1060
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1150
nop
// File: /workspace/github_c_makefile_star2_O3/aokad[P]sequeeze/seqtk.c
// Function: stk_reg_destroy
void stk_reg_destroy(reghash_t *h)
{
	khint_t k;
	if (h == 0) return;
	for (k = 0; k < kh_end(h); ++k) {
		if (kh_exist(h, k)) {
			free(kh_val(h, k).a);
			free((char*)kh_key(h, k));
		}
	}
	kh_destroy(reg, h);
}

// Assembly:
testq %rdi, %rdi
je 0x3843
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
testl %eax, %eax
je 0x381b
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x10(%rbx), %rcx
movq %r15, %rdx
shrq $0x4, %rdx
movl (%rcx,%rdx,4), %edx
movl %r14d, %ecx
andb $0x1e, %cl
shrl %cl, %edx
testb $0x3, %dl
jne 0x380d
movq 0x20(%rbx), %rax
movq 0x8(%rax,%r14,8), %rdi
callq 0x2050
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x2050
movl (%rbx), %eax
incq %r15
movl %eax, %ecx
addq $0x2, %r14
cmpq %rcx, %r15
jb 0x37d5
movq 0x18(%rbx), %rdi
callq 0x2050
movq 0x10(%rbx), %rdi
callq 0x2050
movq 0x20(%rbx), %rdi
callq 0x2050
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2050
retq
// File: /workspace/github_c_makefile_star2_O3/aokad[P]sequeeze/seqtk.c
// Function: kr_rand
krint64_t kr_rand(krand_t *kr)
{
	krint64_t x;
	static const krint64_t mag01[2] = { 0, 0xB5026F5AA96619E9ULL };
    if (kr->mti >= KR_NN) {
		int i;
		if (kr->mti == KR_NN + 1) kr_srand0(5489ULL, kr);
        for (i = 0; i < KR_NN - KR_MM; ++i) {
            x = (kr->mt[i] & KR_UM) | (kr->mt[i+1] & KR_LM);
            kr->mt[i] = kr->mt[i + KR_MM] ^ (x>>1) ^ mag01[(int)(x&1)];
        }
        for (; i < KR_NN - 1; ++i) {
            x = (kr->mt[i] & KR_UM) | (kr->mt[i+1] & KR_LM);
            kr->mt[i] = kr->mt[i + (KR_MM - KR_NN)] ^ (x>>1) ^ mag01[(int)(x&1)];
        }
        x = (kr->mt[KR_NN - 1] & KR_UM) | (kr->mt[0] & KR_LM);
        kr->mt[KR_NN - 1] = kr->mt[KR_MM - 1] ^ (x>>1) ^ mag01[(int)(x&1)];
        kr->mti = 0;
    }
    x = kr->mt[kr->mti++];
    x ^= (x >> 29) & 0x5555555555555555ULL;
    x ^= (x << 17) & 0x71D67FFFEDA60000ULL;
    x ^= (x << 37) & 0xFFF7EEE000000000ULL;
    x ^= (x >> 43);
    return x;
}

// Assembly:
movslq (%rdi), %rax
cmpq $0x137, %rax            # imm = 0x137
jle 0x3909
cmpl $0x139, %eax            # imm = 0x139
jne 0x3915
movq $0x1571, 0x8(%rdi)      # imm = 0x1571
movl $0x1, %eax
movl $0x1571, %ecx           # imm = 0x1571
movl $0x2, %edx
movabsq $0x5851f42d4c957f2d, %rsi # imm = 0x5851F42D4C957F2D
movl $0x1571, %r9d           # imm = 0x1571
movq %r9, %r8
shrq $0x3e, %r8
xorq %r9, %r8
imulq %rsi, %r8
leaq (%rdx,%r8), %r9
decq %r9
addq %rax, %r8
movq %r9, (%rdi,%rdx,8)
incq %rax
incq %rdx
movq %r8, %r9
cmpq $0x139, %rdx            # imm = 0x139
jne 0x38dc
jmp 0x3919
movq 0x8(%rdi,%rax,8), %rcx
incl %eax
jmp 0x39f5
movq 0x8(%rdi), %rcx
movq $-0x9c, %rdx
leaq 0x7729(%rip), %rax      # 0xb050
andq $-0x80000000, %rcx      # imm = 0x80000000
movq 0x4f0(%rdi,%rdx,8), %rsi
movl %esi, %r8d
andl $0x7ffffffe, %r8d       # imm = 0x7FFFFFFE
orq %rcx, %r8
movq %rsi, %rcx
andl $0x1, %esi
movq (%rax,%rsi,8), %rsi
xorq 0x9c8(%rdi,%rdx,8), %rsi
shrq %r8
xorq %r8, %rsi
movq %rsi, 0x4e8(%rdi,%rdx,8)
incq %rdx
jne 0x3927
movq 0x4e8(%rdi), %rdx
xorl %ecx, %ecx
andq $-0x80000000, %rdx      # imm = 0x80000000
movq 0x4f0(%rdi,%rcx,8), %rsi
movl %esi, %r8d
andl $0x7ffffffe, %r8d       # imm = 0x7FFFFFFE
orq %rdx, %r8
shrq %r8
movq %rsi, %rdx
andl $0x1, %esi
movq (%rax,%rsi,8), %rsi
xorq 0x8(%rdi,%rcx,8), %rsi
xorq %r8, %rsi
movq %rsi, 0x4e8(%rdi,%rcx,8)
incq %rcx
cmpq $0x9b, %rcx
jne 0x3971
movq $-0x80000000, %rdx      # imm = 0x80000000
andq 0x9c0(%rdi), %rdx
movq 0x8(%rdi), %rcx
movl %ecx, %esi
andl $0x7ffffffe, %esi       # imm = 0x7FFFFFFE
orq %rdx, %rsi
movl %ecx, %edx
andl $0x1, %edx
movq (%rax,%rdx,8), %rax
xorq 0x4e0(%rdi), %rax
shrq %rsi
xorq %rsi, %rax
movq %rax, 0x9c0(%rdi)
movl $0x1, %eax
movl %eax, (%rdi)
movq %rcx, %rax
shrq $0x1d, %rax
movabsq $0x555555555, %rdx      # imm = 0x555555555
andq %rax, %rdx
xorq %rcx, %rdx
movq %rdx, %rax
shlq $0x11, %rax
movabsq $0x71d67fffeda60000, %rcx # imm = 0x71D67FFFEDA60000
andq %rax, %rcx
xorq %rdx, %rcx
movl %ecx, %edx
andl $0x7ffbf77, %edx        # imm = 0x7FFBF77
shlq $0x25, %rdx
xorq %rcx, %rdx
movq %rdx, %rax
shrq $0x2b, %rax
xorq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/aokad[P]sequeeze/seqtk.c
// Function: stk_randbase
int stk_randbase(int argc, char *argv[])
{
	gzFile fp;
	kseq_t *seq;
	int l;
	if (argc == 1) {
		fprintf(stderr, "Usage: seqtk randbase <in.fa>\n");
		return 1;
	}
	fp = (strcmp(argv[1], "-") == 0)? gzdopen(fileno(stdin), "r") : gzopen(argv[1], "r");
	if (fp == 0) {
		fprintf(stderr, "[E::%s] failed to open the input file/stream.\n", __func__);
		return 1;
	}
	seq = kseq_init(fp);
	while ((l = kseq_read(seq)) >= 0) {
		int i;
		printf(">%s", seq->name.s);
		for (i = 0; i < l; ++i) {
			int c, b, a, j, k, m;
			b = seq->seq.s[i];
			c = seq_nt16_table[b];
			a = bitcnt_table[c];
			if (a == 2) {
				m = (drand48() < 0.5);
				for (j = k = 0; j < 4; ++j) {
					if ((1<<j & c) == 0) continue;
					if (k == m) break;
					++k;
				}
				seq->seq.s[i] = islower(b)? "acgt"[j] : "ACGT"[j];
			}
			if (i%60 == 0) putchar('\n');
			putchar(seq->seq.s[i]);
		}
		putchar('\n');
	}
	kseq_destroy(seq);
	gzclose(fp);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x1, %edi
je 0x49be
movq 0x8(%rsi), %rdi
cmpb $0x2d, (%rdi)
jne 0x482f
cmpb $0x0, 0x1(%rdi)
je 0x499c
leaq 0x6972(%rip), %rsi      # 0xb1a8
callq 0x2220
testq %rax, %rax
je 0x49c5
movq %rax, 0x8(%rsp)
movq %rax, %rdi
callq 0x3edd
movq %rax, %rbx
movq %rax, %rdi
callq 0x3f27
testl %eax, %eax
js 0x4979
movl %eax, %ebp
leaq 0xb903(%rip), %r13      # 0x10170
movq %rbx, (%rsp)
movq 0x10(%rbx), %rsi
leaq 0x6c28(%rip), %rdi      # 0xb4a4
xorl %eax, %eax
callq 0x20f0
testl %ebp, %ebp
je 0x4959
movl %ebp, %ebp
movq (%rsp), %rax
movq 0x40(%rax), %r14
xorl %r15d, %r15d
movq %rbp, 0x10(%rsp)
movb (%r14,%r15), %al
movsbq %al, %rbx
movzbl (%rbx,%r13), %r12d
leaq 0xbaef(%rip), %rcx      # 0x103a0
cmpl $0x2, (%rcx,%r12,4)
jne 0x4925
movq %r13, %rbp
callq 0x22a0
xorl %eax, %eax
movsd 0x67a6(%rip), %xmm1     # 0xb070
ucomisd %xmm0, %xmm1
seta %al
xorl %ecx, %ecx
xorl %r13d, %r13d
btl %r13d, %r12d
jae 0x48e2
cmpl %eax, %ecx
je 0x48f1
incl %ecx
incl %r13d
cmpl $0x4, %r13d
jne 0x48d6
movl $0x4, %r13d
callq 0x2290
movq (%rax), %rax
movzwl (%rax,%rbx,2), %eax
btl $0x9, %eax
movl %r13d, %eax
leaq 0x6b9d(%rip), %rcx      # 0xb4a8
leaq 0x6b9b(%rip), %rdx      # 0xb4ad
cmovaeq %rdx, %rcx
movb (%rcx,%rax), %al
movb %al, (%r14,%r15)
movq %rbp, %r13
movq 0x10(%rsp), %rbp
imull $0xeeeeeeef, %r15d, %ecx # imm = 0xEEEEEEEF
rorl $0x2, %ecx
cmpl $0x4444444, %ecx        # imm = 0x4444444
ja 0x4945
movl $0xa, %edi
callq 0x2060
movb (%r14,%r15), %al
movsbl %al, %edi
callq 0x2060
incq %r15
cmpq %rbp, %r15
jne 0x489d
movl $0xa, %edi
callq 0x2060
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x3f27
movl %eax, %ebp
testl %eax, %eax
jns 0x4871
movq %rbx, %rdi
callq 0x428d
movq 0x8(%rsp), %rdi
callq 0x2040
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xb625(%rip), %rax      # 0xffc8
movq (%rax), %rdi
callq 0x21b0
leaq 0x67f6(%rip), %rsi      # 0xb1a8
movl %eax, %edi
callq 0x20b0
jmp 0x483b
callq 0x2428
jmp 0x49ca
callq 0x2409
movl $0x1, %eax
jmp 0x498d
// File: /workspace/github_c_makefile_star2_O3/aokad[P]sequeeze/seqtk.c
// Function: stk_listhet
int stk_listhet(int argc, char *argv[])
{
	gzFile fp;
	kseq_t *seq;
	int i, l;
	if (argc == 1) {
		fprintf(stderr, "Usage: seqtk listhet <in.fa>\n");
		return 1;
	}
	fp = (strcmp(argv[1], "-") == 0)? gzdopen(fileno(stdin), "r") : gzopen(argv[1], "r");
	if (fp == 0) {
		fprintf(stderr, "[E::%s] failed to open the input file/stream.\n", __func__);
		return 1;
	}
	seq = kseq_init(fp);
	while ((l = kseq_read(seq)) >= 0) {
		for (i = 0; i < l; ++i) {
			int b = seq->seq.s[i];
			if (bitcnt_table[seq_nt16_table[b]] == 2)
				printf("%s\t%d\t%c\n", seq->name.s, i+1, b);
		}
	}
	kseq_destroy(seq);
	gzclose(fp);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x1, %edi
je 0x61e1
movq 0x8(%rsi), %rdi
cmpb $0x2d, (%rdi)
jne 0x6113
cmpb $0x0, 0x1(%rdi)
je 0x61bf
leaq 0x508e(%rip), %rsi      # 0xb1a8
callq 0x2220
testq %rax, %rax
je 0x61e8
movq %rax, (%rsp)
movq %rax, %rdi
callq 0x3edd
movq %rax, %r14
movq %rax, %rdi
callq 0x3f27
testl %eax, %eax
js 0x619d
leaq 0xa026(%rip), %r13      # 0x10170
leaq 0xa24f(%rip), %rbp      # 0x103a0
testl %eax, %eax
je 0x6191
movl %eax, %ebx
movq 0x40(%r14), %r15
xorl %r12d, %r12d
movsbq (%r15,%r12), %rcx
movzbl (%rcx,%r13), %eax
cmpl $0x2, (%rbp,%rax,4)
jne 0x6189
movq 0x10(%r14), %rsi
incq %r12
leaq 0x588b(%rip), %rdi      # 0xba08
movl %r12d, %edx
xorl %eax, %eax
callq 0x20f0
jmp 0x618c
incq %r12
cmpq %rbx, %r12
jne 0x615e
movq %r14, %rdi
callq 0x3f27
testl %eax, %eax
jns 0x6151
movq %r14, %rdi
callq 0x428d
movq (%rsp), %rdi
callq 0x2040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x9e02(%rip), %rax      # 0xffc8
movq (%rax), %rdi
callq 0x21b0
leaq 0x4fd3(%rip), %rsi      # 0xb1a8
movl %eax, %edi
callq 0x20b0
jmp 0x611f
callq 0x276a
jmp 0x61ed
callq 0x274b
movl $0x1, %eax
jmp 0x61b0
// File: /workspace/github_c_makefile_star2_O3/aokad[P]sequeeze/seqtk.c
// Function: print_seq
static void print_seq(FILE *fpout, const kseq_t *ks, int begin, int end)
{
	int i;
	if (begin >= end) return; // FIXME: why may this happen? Understand it!
	fprintf(fpout, "%c%s:%d-%d", ks->qual.l? '@' : '>', ks->name.s, begin+1, end);
	for (i = begin; i < end && i < ks->seq.l; ++i) {
		if ((i - begin)%60 == 0) fputc('\n', fpout);
		fputc(ks->seq.s[i], fpout);
	}
	fputc('\n', fpout);
	if (ks->qual.l == 0) return;
	fputs("+\n", fpout);
	for (i = begin; i < end && i < ks->qual.l; ++i) {
		if ((i - begin)%60 == 0) fputc('\n', fpout);
		fputc(ks->qual.s[i], fpout);
	}
	fputc('\n', fpout);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
subl %edx, %ebp
jle 0x65e2
movl %ecx, %r9d
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
cmpq $0x0, 0x48(%rsi)
setne %al
leal 0x3e(,%rax,2), %edx
movq 0x10(%rsi), %rcx
leal 0x1(%r15), %r8d
leaq 0x6069(%rip), %rsi      # 0xc570
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x2190
movslq %r15d, %r15
movq %r15, %r13
cmpq %r13, 0x30(%r14)
jbe 0x655c
imull $0xeeeeeeef, %r12d, %eax # imm = 0xEEEEEEEF
addl $0x8888888, %eax        # imm = 0x8888888
rorl $0x2, %eax
cmpl $0x4444444, %eax        # imm = 0x4444444
ja 0x6540
movl $0xa, %edi
movq %rbx, %rsi
callq 0x2140
movq 0x40(%r14), %rax
movsbl (%rax,%r13), %edi
movq %rbx, %rsi
callq 0x2140
incq %r13
incl %r12d
cmpl %r12d, %ebp
jne 0x6517
movl $0xa, %edi
movq %rbx, %rsi
callq 0x2140
cmpq $0x0, 0x48(%r14)
je 0x65e2
leaq 0x6004(%rip), %rdi      # 0xc57b
movq %rbx, %rsi
callq 0x2110
xorl %r12d, %r12d
cmpq %r15, 0x48(%r14)
jbe 0x65c7
imull $0xeeeeeeef, %r12d, %eax # imm = 0xEEEEEEEF
addl $0x8888888, %eax        # imm = 0x8888888
rorl $0x2, %eax
cmpl $0x4444444, %eax        # imm = 0x4444444
ja 0x65ab
movl $0xa, %edi
movq %rbx, %rsi
callq 0x2140
movq 0x58(%r14), %rax
movsbl (%rax,%r15), %edi
movq %rbx, %rsi
callq 0x2140
incq %r15
incl %r12d
cmpl %r12d, %ebp
jne 0x6582
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2140
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x18, %rsp
movq 0x99ca(%rip), %rax      # 0xffd0
movslq (%rax), %rbx
cmpl %edi, %ebx
je 0x6771
movq %rsi, %r14
leal 0x2(%rbx), %eax
movl $0x7, 0x4(%rsp)
cmpl %edi, %eax
jne 0x6631
movq 0x8(%r14,%rbx,8), %rdi
callq 0x2250
movl %eax, 0x4(%rsp)
movq (%r14,%rbx,8), %rdi
cmpb $0x2d, (%rdi)
jne 0x6644
cmpb $0x0, 0x1(%rdi)
je 0x674f
leaq 0x4b5d(%rip), %rsi      # 0xb1a8
callq 0x2220
testq %rax, %rax
je 0x6778
movq %rax, 0x10(%rsp)
movq %rax, %rdi
callq 0x3edd
movq %rax, %rbx
movq %rax, %rdi
callq 0x3f27
testl %eax, %eax
js 0x66ff
movq %rbx, 0x8(%rsp)
movq 0x30(%rbx), %r13
movq 0x40(%rbx), %rbx
movsbl (%rbx), %ebp
movl $0x1, %r12d
xorl %r14d, %r14d
cmpq $0x2, %r13
jb 0x66ec
movl $0x1, %r15d
movsbl (%rbx,%r15), %eax
cmpl %eax, %ebp
jne 0x66ac
incl %r12d
jmp 0x66e4
cmpl 0x4(%rsp), %r12d
jl 0x66d6
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
addl %r14d, %r12d
leaq 0x5449(%rip), %rdi      # 0xbb0f
movl %r14d, %edx
movl %r12d, %ecx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x20f0
movsbl (%rbx,%r15), %ebp
movl $0x1, %r12d
movl %r15d, %r14d
incq %r15
cmpq %r15, %r13
ja 0x669e
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x3f27
testl %eax, %eax
jns 0x667e
jmp 0x6707
xorl %r12d, %r12d
xorl %ebp, %ebp
xorl %r14d, %r14d
cmpl 0x4(%rsp), %r12d
jl 0x672c
movq 0x10(%rbx), %rsi
addl %r14d, %r12d
leaq 0x53f3(%rip), %rdi      # 0xbb0f
movl %r14d, %edx
movl %r12d, %ecx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x20f0
movq %rbx, %rdi
callq 0x428d
movq 0x10(%rsp), %rdi
callq 0x2040
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x9872(%rip), %rax      # 0xffc8
movq (%rax), %rdi
callq 0x21b0
leaq 0x4a43(%rip), %rsi      # 0xb1a8
movl %eax, %edi
callq 0x20b0
jmp 0x6650
callq 0x283c
jmp 0x677d
callq 0x281d
movl $0x1, %eax
jmp 0x6740
// File: /workspace/github_c_makefile_star2_O3/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 0xa428
leaq 0x30(%r14), %rdi
leaq 0x30(%rbx), %rsi
callq 0xa428
leaq 0x48(%r14), %rdi
leaq 0x48(%rbx), %rsi
callq 0xa428
addq $0x18, %r14
addq $0x18, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa428
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jle 0x82e5
movq %rsi, %r14
movq 0x8(%rsi), %rdi
cmpb $0x2d, (%rdi)
jne 0x8118
cmpb $0x0, 0x1(%rdi)
je 0x82a1
leaq 0x3089(%rip), %rsi      # 0xb1a8
callq 0x2220
movq %rax, %rbx
movq 0x10(%r14), %rdi
cmpb $0x2d, (%rdi)
jne 0x813a
cmpb $0x0, 0x1(%rdi)
je 0x82c3
leaq 0x3067(%rip), %rsi      # 0xb1a8
callq 0x2220
movq %rax, %r14
testq %rbx, %rbx
je 0x82ec
testq %r14, %r14
je 0x82ec
movq %rbx, %rdi
callq 0x3edd
movq %rax, %r12
movq %r14, %rdi
callq 0x3edd
movq %rax, %r15
movq %r12, %rdi
callq 0x3f27
testl %eax, %eax
js 0x8260
movq 0x7e38(%rip), %r13      # 0xffc0
movq %r15, %rdi
callq 0x3f27
testl %eax, %eax
js 0x8302
movq 0x48(%r12), %rbp
xorl %eax, %eax
testq %rbp, %rbp
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
testq %rbp, %rbp
je 0x81f6
movl $0x2b, %edi
callq 0x2060
movl $0xa, %edi
callq 0x2060
movq 0x58(%r12), %rdi
callq 0x2080
movq 0x48(%r15), %rbp
xorl %eax, %eax
testq %rbp, %rbp
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
testq %rbp, %rbp
je 0x8250
movl $0x2b, %edi
callq 0x2060
movl $0xa, %edi
callq 0x2060
movq 0x58(%r15), %rdi
callq 0x2080
movq %r12, %rdi
callq 0x3f27
testl %eax, %eax
jns 0x8188
movq %r15, %rdi
callq 0x3f27
testl %eax, %eax
jns 0x82f8
movq %r12, %rdi
callq 0x428d
movq %rbx, %rdi
callq 0x2040
movq %r15, %rdi
callq 0x428d
movq %r14, %rdi
callq 0x2040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x7d20(%rip), %rax      # 0xffc8
movq (%rax), %rdi
callq 0x21b0
leaq 0x2ef1(%rip), %rsi      # 0xb1a8
movl %eax, %edi
callq 0x20b0
jmp 0x8124
movq 0x7cfe(%rip), %rax      # 0xffc8
movq (%rax), %rdi
callq 0x21b0
leaq 0x2ecf(%rip), %rsi      # 0xb1a8
movl %eax, %edi
callq 0x20b0
jmp 0x8146
callq 0x2c91
jmp 0x82f1
callq 0x2c72
movl $0x1, %eax
jmp 0x8292
callq 0x2c53
jmp 0x8270
callq 0x2c34
jmp 0x8260
// File: /workspace/github_c_makefile_star2_O3/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 0x2a12(%rip), %rdx      # 0xc4ae
callq 0x2240
xorl %r12d, %r12d
testl %eax, %eax
js 0x9ae8
movq 0x6529(%rip), %r13      # 0xffd8
leaq 0x29f8(%rip), %r15      # 0xc4ae
xorl %ebx, %ebx
cmpl $0x70, %eax
je 0x9aca
cmpl $0x6b, %eax
jne 0x9ace
movl $0x1, %r12d
jmp 0x9ace
movq (%r13), %rbx
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2240
testl %eax, %eax
jns 0x9ab8
testl %r12d, %r12d
sete %r15b
jmp 0x9aed
movb $0x1, %r15b
xorl %ebx, %ebx
movq 0x64dc(%rip), %r12      # 0xffd0
movl (%r12), %eax
cmpl %ebp, %eax
je 0x9b97
cmpl $0x1, %ebp
jne 0x9b27
movq 0x64bc(%rip), %rax      # 0xffc8
movq (%rax), %rdi
callq 0x21b0
movl %eax, %edi
callq 0x2090
testl %eax, %eax
jne 0x9ba5
movl (%r12), %eax
cltq
movq (%r14,%rax,8), %rdi
cmpb $0x2d, (%rdi)
jne 0x9b38
cmpb $0x0, 0x1(%rdi)
je 0x9b78
leaq 0x1669(%rip), %rsi      # 0xb1a8
callq 0x2220
testq %rax, %rax
je 0x9b9e
leaq 0x2e50(%rip), %rsi      # 0xc9a0
movq %rax, %rdi
testb %r15b, %r15b
je 0x9b62
movq %rbx, %rdx
callq 0x9273
jmp 0x9b67
callq 0x9701
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x6449(%rip), %rax      # 0xffc8
movq (%rax), %rdi
callq 0x21b0
leaq 0x161a(%rip), %rsi      # 0xb1a8
movl %eax, %edi
callq 0x20b0
jmp 0x9b44
callq 0x2de9
jmp 0x9baa
callq 0x2dca
jmp 0x9baa
callq 0x2dae
movl $0x1, %eax
jmp 0x9b69
// File: /workspace/github_c_makefile_star2_O3/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 0xa491
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rax), %rcx
cmpq 0x8(%rdi), %rcx
jbe 0xa492
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, %rdi
movq %rax, 0x10(%r14)
movq (%rbx), %rax
jmp 0xa496
retq
movq 0x10(%r14), %rdi
movq %rax, (%r14)
movq (%rbx), %rdx
movq 0x10(%rbx), %rsi
incq %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a0
// File: /workspace/github_c_makefile_star2_O3/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 0xa52c
movq (%rbx), %r12
testq %r12, %r12
je 0xa514
movl %r14d, %r13d
xorl %r15d, %r15d
movl %r14d, %ebp
movl $0xa, %edi
callq 0x2060
addq 0x10(%rbx), %r15
movslq %r12d, %rdx
subl %r14d, %r12d
cmovaq %r13, %rdx
movq 0x5ac7(%rip), %rax      # 0xffc0
movq (%rax), %rcx
movl $0x1, %esi
movq %r15, %rdi
callq 0x2260
movslq %ebp, %r15
addl %r14d, %ebp
cmpq %r15, (%rbx)
ja 0xa4da
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_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %r14
movq 0x108(%rdi), %rbp
movq 0x110(%rdi), %r13
leaq (%rdx,%rbp), %rbx
cmpq %r13, %rbx
ja 0x36af
movq 0x118(%r14), %r12
addq %r12, %rbp
movq %rbp, %rdi
movq %r15, %rdx
callq 0x10a0
movq 0xc8(%r14), %rcx
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 %r12, %rsi
movq %rbx, %rdx
callq 0x16d2
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 %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, (%rsp)
leaq (%r15,%r13), %rsi
movq %rsi, 0x110(%r14)
movq 0x118(%r14), %rdi
callq 0x10c0
testq %rax, %rax
je 0x36e2
movq %rax, %r12
movq %rax, 0x118(%r14)
movq (%rsp), %rsi
jmp 0x3648
movq %r13, 0x110(%r14)
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x369d
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x108(%rdi), %rdi
movq 0x110(%r14), %r13
leaq (%rdi,%rdx), %rax
cmpq %r13, %rax
ja 0x378e
movq 0x118(%r14), %r12
addq %r12, %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 0x16d2
movq 0x108(%r14), %rdx
movq 0x118(%r14), %rdi
addq %rdi, %rbx
movq %rbx, %rsi
callq 0x10d0
movl %r15d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq (%rbx,%r13), %rdi
movq %rdi, 0x110(%r14)
callq 0x10b0
testq %rax, %rax
je 0x37cd
movq %rax, %r12
movq %r14, %rdi
callq 0x5874
movq 0x118(%r14), %rdi
callq 0x1030
movq %r12, 0x118(%r14)
movq 0x108(%r14), %rdi
jmp 0x3721
movq %r13, 0x110(%r14)
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x3781
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r12
movq %r12, 0xc8(%rdi)
movq 0x8(%rsi), %rdi
movups 0x8(%rsi), %xmm0
movups %xmm0, 0xd0(%rbx)
leaq (%rdi,%r12), %r14
movq %r14, 0xe0(%rbx)
movabsq $-0x5c28f5c28f5c28f5, %rcx # imm = 0xA3D70A3D70A3D70B
movq %r14, %rax
imulq %rcx
leaq (%rdx,%r14), %rcx
movq %rcx, %rax
shrq $0x3f, %rax
sarq $0x4, %rcx
addq %rax, %rcx
movl %ecx, %eax
andl $0xf0, %eax
movq %rcx, %rdx
sarq $0x4, %rdx
xorl %esi, %esi
testq %rax, %rax
setne %sil
cmoveq %rcx, %rdx
shll $0x2, %esi
movl %edx, %r8d
andl $0xc, %r8d
leaq 0x2(%rsi), %r9
movl %edx, %r10d
shrl $0x2, %r10d
testq %r8, %r8
cmoveq %rsi, %r9
cmoveq %rdx, %r10
orq %r8, %rax
andl $0x2, %r10d
movl %r10d, %edx
shrl %edx
orq %r9, %rdx
xorl %r15d, %r15d
orq %r10, %rax
movl $0x0, %eax
cmovneq %rdx, %rax
movq %rcx, 0xe8(%rbx)
movq %rax, 0xf8(%rbx)
leaq 0xc(%rdx,%rdx), %rax
movq %rax, 0x100(%rbx)
leaq -0x640(%rdi,%r12), %rax
movq $-0x1, %rdx
movq $-0x1, %rsi
shlq %cl, %rsi
cmpq $0x19, %rax
notq %rsi
cmovbq %rdx, %rsi
movq %rsi, 0xf0(%rbx)
movl $0xc8, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1070
movq $0x0, 0x108(%rbx)
imulq %r12, %r14
shrq $0x2, %r14
movq %r14, 0x110(%rbx)
movq %r14, %rdi
callq 0x10b0
movq %rax, 0x118(%rbx)
cmpq $0x1, %rax
sbbl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x5897
xorl %ecx, %ecx
movb $0x0, (%rax,%rcx)
incq %rcx
cmpq 0x108(%rdi), %rcx
jb 0x5887
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x58d3
leaq 0xa1a(%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 0x58a8
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0x1c(%rdi), %eax
testq %rax, %rax
je 0x31a3
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x70(%rdi), %rcx
movq %rax, %rdx
shlq $0x7, %rdx
leaq -0x1(%rax), %rsi
movq %rsi, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
addq $0x180, %rdx            # imm = 0x180
andq $-0x200, %rdx           # imm = 0xFE00
movdqa 0x1fe6(%rip), %xmm1     # 0x5040
movdqa 0x1fee(%rip), %xmm2     # 0x5050
xorl %esi, %esi
movdqa 0x1ff4(%rip), %xmm3     # 0x5060
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movdqa 0x1ff4(%rip), %xmm5     # 0x5070
movdqa %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %edi
notl %edi
testb $0x1, %dil
je 0x30b9
movl $0x1, 0x64(%rcx,%rsi)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0x30d3
movl $0x1, 0xe4(%rcx,%rsi)
movdqa %xmm1, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
pxor %xmm4, %xmm6
pextrw $0x0, %xmm6, %edi
testb $0x1, %dil
je 0x3116
movl $0x1, 0x164(%rcx,%rsi)
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0x312c
movl $0x1, 0x1e4(%rcx,%rsi)
paddq %xmm5, %xmm2
paddq %xmm5, %xmm1
addq $0x200, %rsi            # imm = 0x200
cmpq %rsi, %rdx
jne 0x307c
testq %rax, %rax
je 0x319e
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 0x3152
testl %eax, %eax
je 0x319e
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 0x3180
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5b2e(%rip), %edi      # 0x92f8
movl $0x1, %esi
movl $0x6, %edx
callq 0x2380
testl %eax, %eax
js 0x387f
movl %eax, %ebp
leaq 0x59f6(%rip), %r14      # 0x91e0
cmpb $0x1, 0x44(%r14)
jne 0x381b
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 0x38b5
movl 0x38(%r14), %eax
testl %eax, %eax
je 0x3845
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 0x3891
movl 0x3c(%r14), %eax
testl %eax, %eax
je 0x386f
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 0x38a3
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 0x1a21(%rip), %rdi      # 0x52b0
jmp 0x38c5
callq 0x2070
xorl %ebx, %ebx
subl (%rax), %ebx
leaq 0x1a2e(%rip), %rdi      # 0x52cf
jmp 0x38c5
callq 0x2070
xorl %ebx, %ebx
subl (%rax), %ebx
leaq 0x1a32(%rip), %rdi      # 0x52e5
jmp 0x38c5
callq 0x2070
xorl %ebx, %ebx
subl (%rax), %ebx
leaq 0x19f2(%rip), %rdi      # 0x52b7
callq 0x2280
jmp 0x3874
// File: /workspace/github_c_makefile_star2_O3/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 0x5a1f(%rip), %eax      # 0x92f8
cmpw $0xa, %ax
movl $0x1c, %ecx
movl $0xffffffea, %ebp       # imm = 0xFFFFFFEA
cmovel %ecx, %ebp
cmpw $0x2, %ax
movl $0x10, %edx
cmovnel %ebp, %edx
testl %edx, %edx
js 0x3966
movq %rdi, %rbx
movl 0x4(%rdi), %edi
leaq 0x59f1(%rip), %rsi      # 0x92f8
callq 0x22e0
testl %eax, %eax
js 0x394a
leaq 0x8(%rsp), %rdx
movl $0x1c, (%rdx)
movl 0x4(%rbx), %edi
leaq 0xc(%rsp), %rsi
callq 0x22a0
testl %eax, %eax
js 0x394e
movzwl 0xc(%rsp), %eax
orl $0x8, %eax
cmpl $0xa, %eax
jne 0x3959
movzwl 0xe(%rsp), %eax
rolw $0x8, %ax
movw %ax, 0x8(%rbx)
xorl %ebp, %ebp
jmp 0x3966
movl %eax, %ebp
jmp 0x3966
callq 0x2070
xorl %ebp, %ebp
subl (%rax), %ebp
jmp 0x395e
movl $0xffffffea, %ebp       # imm = 0xFFFFFFEA
movl 0x4(%rbx), %edi
callq 0x2180
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movb 0x18(%rdi), %bpl
movl $0x0, 0x60(%rdi)
cmpl $0x0, 0x64(%rdi)
je 0x3994
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %rbx
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x39f4
movq 0x10(%rbx), %r15
cmpl $0x0, 0x64(%rbx)
jne 0x3987
movl 0x4(%rbx), %edi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x2110
testq %rax, %rax
jns 0x39cd
callq 0x2070
movl (%rax), %ecx
cmpl $0x4, %ecx
je 0x39a4
jmp 0x39fa
addq %rax, %r15
movdqu 0x50(%rbx), %xmm0
movq %rax, %xmm1
movdqa 0x18be(%rip), %xmm2     # 0x52a0
punpcklqdq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0]
paddq %xmm0, %xmm2
movdqu %xmm2, 0x50(%rbx)
subq %rax, %r14
jne 0x39a4
incq 0x48(%rbx)
jmp 0x3a11
cmpl $0x20, %ecx
jne 0x3a03
xorl %ecx, %ecx
jmp 0x3a05
negl %ecx
movl %ecx, 0x60(%rbx)
cmpl $0x0, (%rax)
jg 0x3aa3
cmpl $0x0, 0x64(%rbx)
jne 0x3987
testb %bpl, %bpl
je 0x3a94
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x3a83
movq 0x10(%rbx), %r15
cmpl $0x0, 0x64(%rbx)
jne 0x3a94
movl 0x4(%rbx), %edi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x2040
testq %rax, %rax
jns 0x3a56
callq 0x2070
movl (%rax), %eax
cmpl $0x4, %eax
je 0x3a2d
jmp 0x3a89
je 0x3987
addq %rax, %r15
movdqu 0x38(%rbx), %xmm0
movq %rax, %xmm1
movdqa 0x182f(%rip), %xmm2     # 0x52a0
punpcklqdq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0]
paddq %xmm0, %xmm2
movdqu %xmm2, 0x38(%rbx)
subq %rax, %r14
jne 0x3a2d
incq 0x30(%rbx)
jmp 0x3a94
movl %eax, %ecx
negl %ecx
movl %ecx, 0x60(%rbx)
testl %eax, %eax
jg 0x3aa3
cmpl $0x0, 0x64(%rbx)
je 0x3997
jmp 0x3987
movl $0xffffffff, 0x60(%rbx) # imm = 0xFFFFFFFF
jmp 0x3987
// File: /workspace/github_c_makefile_star2_O3/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 0x37b8
movq %rsp, %rdi
xorl %esi, %esi
callq 0x2340
testl %eax, %eax
jne 0x3be1
movq %rsp, %rdi
callq 0x2300
leaq 0x57b0(%rip), %r14      # 0x9298
movq %r14, %rdi
callq 0x2360
incl 0x57fa(%rip)            # 0x92f0
leaq 0x57c3(%rip), %rdi      # 0x92c0
callq 0x2080
movq %r14, %rdi
callq 0x2200
movq %r14, %rdi
callq 0x2360
cmpl $0x1, 0x57db(%rip)      # 0x92f4
je 0x3b3d
leaq 0x579e(%rip), %r14      # 0x92c0
leaq 0x576f(%rip), %r15      # 0x9298
movq %r14, %rdi
movq %r15, %rsi
callq 0x20d0
cmpl $0x1, 0x57b9(%rip)      # 0x92f4
jne 0x3b29
leaq 0x5754(%rip), %rdi      # 0x9298
callq 0x2200
movq %rbx, %rdi
callq 0x38cc
testl %eax, %eax
js 0x3bc5
leaq 0x573c(%rip), %r14      # 0x9298
movq %r14, %rdi
callq 0x2360
incl 0x5786(%rip)            # 0x92f0
leaq 0x574f(%rip), %rdi      # 0x92c0
callq 0x2080
movq %r14, %rdi
callq 0x2200
movq %r14, %rdi
callq 0x2360
cmpl $0x2, 0x5767(%rip)      # 0x92f4
je 0x3bb1
leaq 0x572a(%rip), %r14      # 0x92c0
leaq 0x56fb(%rip), %r15      # 0x9298
movq %r14, %rdi
movq %r15, %rsi
callq 0x20d0
cmpl $0x2, 0x5745(%rip)      # 0x92f4
jne 0x3b9d
leaq 0x56e0(%rip), %rdi      # 0x9298
callq 0x2200
movq %rbx, %rdi
callq 0x396f
movq %rsp, %rdi
callq 0x2130
movl 0x4(%rbx), %edi
callq 0x2180
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl 0x4(%rbx), %edi
callq 0x3bf1
movq %rsp, %rdi
callq 0x2220
// File: /workspace/github_c_makefile_star2_O3/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 0x3c22
leaq 0x8(%rsp), %rdi
movl $0x4000, %esi           # imm = 0x4000
callq 0x2390
testl %eax, %eax
je 0x3c31
movl %eax, %ebp
negl %ebp
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28(%rbx), %rdi
leaq -0x18d(%rip), %rdx      # 0x3aaf
leaq 0x8(%rsp), %r14
movq %r14, %rsi
movq %rbx, %rcx
callq 0x2250
movl %eax, %ebp
movq %r14, %rdi
callq 0x22c0
jmp 0x3c24