LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_18/dcl.c
// Function: dir_dcl
void dir_dcl(void)
{
  if (next_token == PAREN_OPEN)
  {
    dcl();

    if (next_token != PAREN_CLOSE)
    {
      puts("Syntax Error: missing ')'.");
    }
  }
  else if (next_token == NAME)
  {
    strcpy(name, token);
  }
  else
  {
    puts("Syntax Error: expected name or (dcl).");
  }

  while ((next_token = get_next_token()) == PARENS || next_token == BRACKETS)
  {
    if (next_token == PARENS)
    {
      strcat(out, " function returning");
    }
    else if (next_token == BRACKETS)
    {
      strcat(out, " array[");
      strcat(out, token);
      strcat(out, "] of");
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0x2b80(%rip), %eax      # 0x4080
testl %eax, %eax
je 0x1520
cmpl $0x28, %eax
jne 0x1535
callq 0x1369
cmpl $0x29, 0x2b6b(%rip)     # 0x4080
je 0x1541
leaq 0xb3f(%rip), %rdi       # 0x205d
jmp 0x153c
leaq 0x3039(%rip), %rdi      # 0x4560
leaq 0x2bd2(%rip), %rsi      # 0x4100
callq 0x1030
jmp 0x1541
leaq 0xb3c(%rip), %rdi       # 0x2078
callq 0x1040
callq 0x1280
movl %eax, %r15d
movl %eax, 0x2b31(%rip)      # 0x4080
leal -0x1(%r15), %eax
cmpl $0x1, %eax
ja 0x15cb
leaq 0x2c11(%rip), %rbx      # 0x4170
movabsq $0x5b796172726120, %r12 # imm = 0x5B796172726120
leaq 0x2b90(%rip), %r14      # 0x4100
movq %rbx, %rdi
callq 0x1050
addq %rbx, %rax
cmpl $0x1, %r15d
jne 0x1594
movups 0xb16(%rip), %xmm0      # 0x209e
movups %xmm0, (%rax)
movl $0x676e69, 0x10(%rax)   # imm = 0x676E69
jmp 0x15b6
movq %r12, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1080
movq %rbx, %rdi
callq 0x1050
movl $0x666f205d, (%rax,%rbx) # imm = 0x666F205D
movb $0x0, 0x4(%rax,%rbx)
callq 0x1280
movl %eax, %r15d
movl %eax, 0x2abc(%rip)      # 0x4080
decl %eax
cmpl $0x2, %eax
jb 0x1570
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/cyb70289[P]tt/tests/decimal.c
// Function: factorial
struct tt_dec *factorial(int i, int j)
{
	struct tt_dec *dec;

	if (i == j) {
		dec = tt_dec_alloc(0);
		tt_dec_from_uint(dec, i);
		return dec;
	}

	int m = (i + j) / 2;
	struct tt_dec *dec1 = factorial(i, m);
	struct tt_dec *dec2 = factorial(m+1, j);

	dec = tt_dec_alloc(dec1->_prec + dec2->_prec);
	tt_dec_mul(dec, dec1, dec2);

	tt_dec_free(dec1);
	tt_dec_free(dec2);

	return dec;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %r14d
cmpl %esi, %edi
jne 0x2c51
xorl %edi, %edi
callq 0x43a0
movq %rax, %rbx
movslq %r14d, %rsi
movq %rax, %rdi
callq 0x4740
jmp 0x2ca8
movl %esi, %ebx
leal (%rbx,%r14), %eax
movl %eax, %ebp
shrl $0x1f, %ebp
addl %eax, %ebp
sarl %ebp
movl %r14d, %edi
movl %ebp, %esi
callq 0x2c2c
movq %rax, %r14
incl %ebp
movl %ebp, %edi
movl %ebx, %esi
callq 0x2c2c
movq %rax, %r15
movl 0x8(%rax), %edi
addl 0x8(%r14), %edi
callq 0x43a0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5688
movq %r14, %rdi
callq 0x447e
movq %r15, %rdi
callq 0x447e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/cyb70289[P]tt/tests/decimal.c
// Function: get_num
static long double get_num(char *s, int lmin, int lmax)
{
	long double ld = 0;

	s[0] = ((rand() & 1)) ? '-' : '+';

	/* len: lmin+1 ~ lmax+1 */
	int len = lmin + rand() % (lmax - lmin + 1) + 1;
	for (int i = 1; i < len; i++) {
		s[i] = rand() % 10;
		ld *= 10;
		ld += s[i];
		s[i] += '0';
	}
	s[len] = '\0';

	if (s[0] == '-')
		ld = -ld;

	return ld;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x21e0
andb $0x1, %al
addb %al, %al
addb $0x2b, %al
movb %al, (%rbx)
callq 0x21e0
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
subl %ecx, %eax
cltq
leaq 0x2(%rax), %r14
fldz
testl %eax, %eax
js 0x423e
fstp %st(0)
movl %r14d, %r15d
fldz
movl $0x1, %r12d
fstpt 0xc(%rsp)
callq 0x21e0
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
addl %edx, %ecx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
fldt 0xc(%rsp)
fmuls 0x8e42(%rip)            # 0xd068
subl %ecx, %eax
movl %eax, 0x8(%rsp)
fiaddl 0x8(%rsp)
addb $0x30, %al
movb %al, (%rbx,%r12)
incq %r12
cmpq %r12, %r15
jne 0x41f8
movb $0x0, (%rbx,%r14)
cmpb $0x2d, (%rbx)
fld %st(0)
fchs
fxch %st(1)
fcmove %st(1), %st
fstp %st(1)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/cyb70289[P]tt/tests/decimal.c
// Function: deq
static bool deq(double d1, double d2, double prec)
{
	if (isnan(d1))
		return isnan(d2);
	if (isinf(d1))
		return isinf(d2) && signbit(d1) == signbit(d2);
	if (d1 == 0)
		return d2 == 0;
	long double dd = (long double)d1 - (long double)d2;
	dd /= d1;
	return dd < prec;
}

// Assembly:
ucomisd %xmm0, %xmm0
jp 0x42de
movq %xmm0, %rax
movq %rax, %rdx
btrq $0x3f, %rdx
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rdx
jne 0x429a
movq %xmm1, %rdx
movq %rdx, %rsi
btrq $0x3f, %rsi
cmpq %rcx, %rsi
sete %cl
xorq %rdx, %rax
setns %al
andb %cl, %al
retq
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm0
jne 0x42b4
jp 0x42b4
cmpeqsd %xmm3, %xmm1
movq %xmm1, %rax
andl $0x1, %eax
retq
movsd %xmm0, -0x8(%rsp)
fldl -0x8(%rsp)
movsd %xmm1, -0x10(%rsp)
fld %st(0)
fsubl -0x10(%rsp)
fdivp %st, %st(1)
movsd %xmm2, -0x18(%rsp)
fldl -0x18(%rsp)
fucompi %st(1), %st
fstp %st(0)
seta %al
retq
ucomisd %xmm1, %xmm1
setp %al
retq
// File: /workspace/github_c_makefile_star2_O3/cyb70289[P]tt/tests/decimal.c
// Function: gen_float
static double gen_float(int mexp)
{
	union {
		uint64_t i;
		double d;
	} v = {
		.i = 0,
	};

	/* Sign: 0,1 */
	if (rand() & 1)
		v.i |= 1ULL << 63;

	/* Exponent: -mexp ~ +mexp */
	double _exp = (double)(rand() % (mexp + 1));	/* 0 ~ mexp */
	if (rand() & 1)
		_exp = -_exp;
	int e = 1023;
	if (_exp > 0)
		e = (int)(_exp / log10(2) + 1023);
	else if (_exp < 0)
		e = (int)(_exp / log10(2) + 1024);
	v.i |= ((int64_t)e) << 52;

	/* Mantissa */
	int64_t i64 = rand();
	i64 *= rand();
	v.i |= (i64 & ((1ULL << 52) - 1));

	return v.d;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebp
callq 0x21e0
movl %eax, %ebx
callq 0x21e0
incl %ebp
cltd
idivl %ebp
cvtsi2sd %edx, %xmm0
movapd %xmm0, (%rsp)
callq 0x21e0
testb $0x1, %al
je 0x4322
movapd (%rsp), %xmm1
xorpd 0x8d10(%rip), %xmm1     # 0xd030
jmp 0x4327
movapd (%rsp), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jbe 0x4343
divsd 0x8d17(%rip), %xmm1     # 0xd050
addsd 0x8d1f(%rip), %xmm1     # 0xd060
jmp 0x435f
movl $0x3ff, %r14d           # imm = 0x3FF
ucomisd %xmm1, %xmm0
jbe 0x4364
divsd 0x8cf9(%rip), %xmm1     # 0xd050
addsd 0x8cf9(%rip), %xmm1     # 0xd058
cvttsd2si %xmm1, %r14d
shlq $0x3f, %rbx
shlq $0x34, %r14
orq %rbx, %r14
callq 0x21e0
movslq %eax, %rbx
callq 0x21e0
cltq
imulq %rbx, %rax
movabsq $0xfffffffffffff, %rcx  # imm = 0xFFFFFFFFFFFFF
andq %rax, %rcx
orq %r14, %rcx
movq %rcx, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/cirocosta[P]stress/src/write.c
// Function: main
int
main(int argc, char** argv)
{
	stress_args_t args = { 0 };
	pthread_t threads[2];

	stress_parse_args(argc, argv, &args);
	_STRESS_MUST(strlen(args.d), "a base directory must be specified");

	thread_arg_t thread1arg = { .count = args.n,
		                    .base_dir = args.d,
		                    .thread_num = 0 };
	thread_arg_t thread2arg = { .count = args.n,
		                    .base_dir = args.d,
		                    .thread_num = 1 };

	srand(time(NULL));

	_STRESS_MUST(
	  (!pthread_create(&threads[0], NULL, &thread_handler, &thread1arg)),
	  "Unexpected error creating stdout thread");
	_STRESS_MUST(
	  (!pthread_create(&threads[1], NULL, &thread_handler, &thread2arg)),
	  "Unexpected error creating stderr thread");

	_STRESS_MUST((!pthread_join(threads[0], NULL)),
	             "Unexpected error waiting for stdout thread");

	_STRESS_MUST((!pthread_join(threads[1], NULL)),
	             "Unexpected error waiting for stderr thread");

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x2040, %rsp           # imm = 0x2040
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x38(%rsp), %r14
movl $0x2008, %edx           # imm = 0x2008
movq %r14, %rdi
xorl %esi, %esi
callq 0x10b0
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x18f9
cmpb $0x0, 0x1005(%r14)
je 0x200f
leaq 0x103d(%rsp), %rax
leaq 0x28(%rsp), %rbx
movq %rax, (%rbx)
movl $0x0, 0x8(%rbx)
movl -0x1005(%rax), %ecx
movl %ecx, 0xc(%rbx)
movq %rax, 0x18(%rsp)
movl $0x1, 0x20(%rsp)
movl %ecx, 0x24(%rsp)
xorl %edi, %edi
callq 0x1100
movl %eax, %edi
callq 0x10e0
leaq -0x487(%rip), %rdx      # 0x1b2e
movq %rsp, %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x1130
testl %eax, %eax
jne 0x2014
leaq 0x8(%rsp), %rdi
leaq -0x4a4(%rip), %rdx      # 0x1b2e
leaq 0x18(%rsp), %rcx
xorl %esi, %esi
callq 0x1130
testl %eax, %eax
jne 0x2019
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x11a0
testl %eax, %eax
jne 0x201e
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x11a0
testl %eax, %eax
jne 0x2023
xorl %eax, %eax
addq $0x2040, %rsp           # imm = 0x2040
popq %rbx
popq %r14
popq %rbp
retq
callq 0x16f4
callq 0x141c
callq 0x14d2
callq 0x1588
callq 0x163e
// File: /workspace/github_c_makefile_star2_O3/maandree[P]libkeccak/test.c
// Function: test_digest_case
static int
test_digest_case(const struct libkeccak_spec *restrict spec, const char *restrict suffix,
                 const char *restrict msg, size_t bytes, size_t bits, const char *restrict expected_answer)
{
	struct libkeccak_state state;
	int ret;
	if (libkeccak_state_initialise(&state, spec)) {
		perror("libkeccak_state_initialise");
		return -1;
	}
	ret = test_digest_case_inited(&state, spec, suffix, msg, bytes, bits, expected_answer);
	libkeccak_state_fast_destroy(&state);
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %r9, %r13
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbp
leaq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x8fb8
testl %eax, %eax
jne 0x4455
movq %r13, (%rsp)
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0x4468
movl %eax, %ebx
movq 0x118(%r13), %rdi
callq 0x1030
movl %ebx, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5d20(%rip), %rdi      # 0xa17c
callq 0x1120
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x4441
// File: /workspace/github_c_makefile_star2_O3/maandree[P]libkeccak/test.c
// Function: test_digest_case_inited
static int
test_digest_case_inited(struct libkeccak_state *restrict state, const struct libkeccak_spec *restrict spec,
                        const char *restrict suffix, const char *restrict msg, size_t bytes, size_t bits,
                        const char *restrict expected_answer)
{
	unsigned char *restrict hashsum;
	char *restrict hexsum;
	int ok;

	hashsum = malloc((size_t)((spec->output + 7) / 8));
	if (!hashsum) {
		perror("malloc");
		return -1;
	}
	hexsum = malloc((size_t)((spec->output + 7) / 8 * 2 + 1));
	if (!hexsum) {
		perror("malloc");
		return -1;
	}

	if (libkeccak_digest(state, msg, bytes, bits, suffix, hashsum)) {
		perror("libkeccak_digest");
		return -1;
	}

	libkeccak_behex_lower(hexsum, hashsum, (size_t)((spec->output + 7) / 8));
	ok = !strcmp(hexsum, expected_answer);
	printf("%s%s\n", ok ? "OK" : "Fail: ", ok ? "" : hexsum);
	if (!ok)
		printf("  r, c, n = %li, %li, %li\n", spec->bitrate, spec->capacity, spec->output);

	free(hashsum);
	free(hexsum);

	return ok - 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x20(%rsp)
movq %r8, 0x10(%rsp)
movq %rcx, %r14
movq %rdx, 0x18(%rsp)
movq %rsi, %r12
movq %rdi, %rbp
movq 0x10(%rsi), %rbx
leaq 0x7(%rbx), %rax
leaq 0xe(%rbx), %r13
testq %rax, %rax
cmovnsq %rax, %r13
sarq $0x3, %r13
movq %r13, %rdi
callq 0x10e0
testq %rax, %rax
je 0x4594
movq %rax, %r15
movq %r12, 0x8(%rsp)
leaq 0x1(,%r13,2), %rdi
callq 0x10e0
testq %rax, %rax
je 0x4594
movq %rax, %r12
movq %rbp, %rdi
movq %r14, %rsi
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movq %r15, %r9
callq 0x85c5
testl %eax, %eax
jne 0x459d
movq 0x60(%rsp), %r14
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x95c8
movq %r12, %rdi
movq %r14, %rsi
callq 0x10c0
movl %eax, %r13d
testl %eax, %eax
leaq 0x71c1(%rip), %rax      # 0xb6e7
leaq 0xc9d1(%rip), %rsi      # 0x10efe
cmovneq %rax, %rsi
leaq 0x65d4(%rip), %rdx      # 0xab0c
cmovneq %r12, %rdx
leaq 0x719e(%rip), %rdi      # 0xb6e1
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x1080
testl %r13d, %r13d
je 0x456e
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
leaq 0x718a(%rip), %rdi      # 0xb6ee
movq %rbx, %rcx
xorl %eax, %eax
callq 0x1080
movq %r15, %rdi
callq 0x1030
movq %r12, %rdi
callq 0x1030
negl %r13d
sbbl %ebp, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5c16(%rip), %rdi      # 0xa1b1
jmp 0x45a4
leaq 0x712c(%rip), %rdi      # 0xb6d0
callq 0x1120
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x4583
// File: /workspace/github_c_makefile_star2_O3/maandree[P]libkeccak/test.c
// Function: test_digest_case_cshake
static int
test_digest_case_cshake(const struct libkeccak_spec *restrict spec, const char *restrict suffix,
                        const void *n_text, size_t n_len, size_t n_bits, const char *n_suffix,
                        const void *s_text, size_t s_len, size_t s_bits, const char *s_suffix,
                        const char *restrict msg, size_t bytes, size_t bits, const char *restrict expected_answer)
{
	struct libkeccak_state state;
	int ret;
	if (libkeccak_state_initialise(&state, spec)) {
		perror("libkeccak_state_initialise");
		return -1;
	}
	libkeccak_cshake_initialise(&state, n_text, n_len, n_bits, n_suffix, s_text, s_len, s_bits, s_suffix);
	ret = test_digest_case_inited(&state, spec, suffix, msg, bytes, bits, expected_answer);
	libkeccak_state_fast_destroy(&state);
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
leaq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0x8fb8
testl %eax, %eax
jne 0x4658
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsp)
movq %rbp, (%rsp)
leaq 0x6515(%rip), %rsi      # 0xab0c
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r13, %r9
callq 0x89e0
movq 0x178(%rsp), %rax
movq %rax, (%rsp)
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
movq 0x170(%rsp), %r9
callq 0x4468
movl %eax, %ebx
movq 0x118(%rbp), %rdi
callq 0x1030
movl %ebx, %eax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5b1d(%rip), %rdi      # 0xa17c
callq 0x1120
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x4644
// File: /workspace/github_c_makefile_star2_O3/maandree[P]libkeccak/test.c
// Function: test_squeeze_case
static int
test_squeeze_case(struct libkeccak_state *restrict state, const struct libkeccak_spec *restrict spec,
                  long int fast_squeezes, long int squeezes, int fast_digest, void *restrict hashsum,
                  char *restrict hexsum, const char *restrict expected_answer)
{
#define message "withdrew hypothesis snakebird qmc2"
	long int i;
	int ok;

	libkeccak_state_reset(state);
	if (libkeccak_digest(state, message, strlen(message), 0, LIBKECCAK_SHA3_SUFFIX, fast_digest ? NULL : hashsum)) {
		perror("libkeccak_digest");
		return -1;
	}

	libkeccak_fast_squeeze(state, fast_squeezes);
	for (i = fast_squeezes; i < squeezes; i++)
		libkeccak_squeeze(state, hashsum);

	libkeccak_behex_lower(hexsum, hashsum, (size_t)((spec->output + 7) / 8));
	ok = !strcmp(hexsum, expected_answer);
	printf("%s%s\n", ok ? "OK" : "Fail: ", ok ? "" : hexsum);
	if (!ok)
		printf("  r, c, n = %li, %li, %li\n", spec->bitrate, spec->capacity, spec->output);

	return ok - 1;
#undef message
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r15
movl %r8d, %ebx
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, 0x10(%rsp)
movq %rdi, %rbp
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
xorl %r14d, %r14d
movq %r14, 0x108(%rdi)
movl $0xc8, %edx
xorl %esi, %esi
callq 0x1090
testl %ebx, %ebx
cmoveq %r15, %r14
leaq 0x5d56(%rip), %rsi      # 0xa5bb
leaq 0xbedb(%rip), %r8       # 0x10747
movl $0x22, %edx
movq %rbp, %rdi
xorl %ecx, %ecx
movq %r14, %r9
callq 0x85c5
testl %eax, %eax
jne 0x4960
movq 0xd8(%rbp), %rax
decq %rax
cqto
idivq 0xc8(%rbp)
leaq 0x1(%rax), %rsi
imulq %r12, %rsi
movq %rbp, %rdi
callq 0x8936
subq %r12, %r13
jle 0x48be
movq %rbp, %rdi
movq %r15, %rsi
callq 0x8998
decq %r13
jne 0x48ae
movq 0x10(%rsp), %r14
movq 0x10(%r14), %r12
leaq 0x7(%r12), %rax
leaq 0xe(%r12), %rdx
testq %rax, %rax
cmovnsq %rax, %rdx
sarq $0x3, %rdx
movq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x95c8
movq %r13, %rdi
movq (%rsp), %rsi
callq 0x10c0
movl %eax, %ebx
testl %eax, %eax
leaq 0xc5fb(%rip), %rax      # 0x10efe
leaq 0x6ddd(%rip), %rsi      # 0xb6e7
cmoveq %rax, %rsi
leaq 0x61f7(%rip), %rdx      # 0xab0c
cmovneq %r13, %rdx
leaq 0x6dc1(%rip), %rdi      # 0xb6e1
xorl %eax, %eax
callq 0x1080
testl %ebx, %ebx
je 0x4951
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x6db5(%rip), %rdi      # 0xb6ee
movq %r12, %rcx
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1080
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6d69(%rip), %rdi      # 0xb6d0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1120
nop
// File: /workspace/github_c_makefile_star2_O3/maandree[P]libkeccak/libkeccak_cshake_initialise.c
// Function: encode_left
static size_t
encode_left(struct libkeccak_state *restrict state, uint8_t *restrict buf, size_t byterate, size_t value, size_t off)
{
	size_t x, n, j, i = off;

	for (x = value, n = 0; x; x >>= 8)
		n += 1;
	if (!n)
		n = 1;
	buf[i++] = (uint8_t)n;
	if (i == byterate) {
		libkeccak_zerocopy_update(state, buf, byterate);
		i = 0;
	}

	for (j = 0; j < n;) {
		buf[i++] = (uint8_t)(value >> ((n - ++j) << 3));
		if (i == byterate) {
			libkeccak_zerocopy_update(state, buf, byterate);
			i = 0;
		}
	}

	return i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
testq %rcx, %rcx
je 0x8e07
movq %rbx, %rdx
movq %rbx, %rcx
incq %r13
shrq $0x8, %rcx
cmpq $0xff, %rdx
movq %rcx, %rdx
ja 0x8df4
cmpq $0x1, %r13
adcq $0x0, %r13
movb %r13b, (%r15,%rax)
incq %rax
cmpq %r14, %rax
jne 0x8e2b
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x497c
xorl %eax, %eax
leaq -0x8(,%r13,8), %r13
movq %rbx, %rdx
movl %r13d, %ecx
shrq %cl, %rdx
movb %dl, (%r15,%rax)
incq %rax
cmpq %r14, %rax
jne 0x8e58
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x497c
xorl %eax, %eax
addq $-0x8, %r13
cmpq $-0x8, %r13
jne 0x8e33
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/maandree[P]libkeccak/libkeccak_cshake_initialise.c
// Function: feed_text
static size_t
feed_text(struct libkeccak_state *restrict state, uint8_t *restrict buf, const uint8_t *restrict text, size_t bytes,
          size_t bits, const char *restrict suffix, size_t off, size_t byterate, size_t *restrict bitoffp)
{
	size_t n, bitoff;

	if (off) {
		n = bytes < byterate - off ? bytes : byterate - off;
		memcpy(&buf[off], text, n);
		off += n;
		if (off == byterate) {
			libkeccak_zerocopy_update(state, buf, byterate);
			off = 0;
		}
		text = &text[n];
		bytes -= n;
	}
	if (bytes) {
		n = bytes;
		n -= bytes %= byterate;
		libkeccak_zerocopy_update(state, text, n);
		text = &text[n];
	}
	memcpy(&buf[off], text, bytes + !!bits);
	off += bytes;
	bitoff = bits;
	if (!bitoff)
		buf[off] = 0;
	for (; *suffix; suffix++) {
		if (*suffix == '1')
			buf[off] |= (uint8_t)(1 << bitoff);
		if (++bitoff == 8) {
			if (++off == byterate) {
				libkeccak_zerocopy_update(state, buf, byterate);
				off = 0;
			}
			bitoff = 0;
			buf[off] = 0;
		}
	}

	*bitoffp = bitoff;
	return off;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, %r13
movq %rdx, %r8
movq %rsi, %r14
movq %rdi, %r15
movq 0x58(%rsp), %r12
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x8eeb
movq %r12, %rbp
subq %rax, %rbp
cmpq %rcx, %rbp
movq %rcx, (%rsp)
cmovaeq %rcx, %rbp
leaq (%r14,%rax), %rdi
movq %r8, 0x8(%rsp)
movq %r8, %rsi
movq %rbp, %rdx
callq 0x10d0
movq 0x50(%rsp), %rax
addq %rbp, %rax
cmpq %r12, %rax
jne 0x8eda
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x497c
xorl %eax, %eax
movq 0x8(%rsp), %r8
addq %rbp, %r8
movq (%rsp), %rcx
subq %rbp, %rcx
jmp 0x8eed
xorl %eax, %eax
testq %rcx, %rcx
movq %rax, 0x10(%rsp)
je 0x8f2c
movq %rcx, %rax
xorl %edx, %edx
divq %r12
movq %rdx, %rbp
subq %rdx, %rcx
movq %rcx, (%rsp)
movq %r15, %rdi
movq %r8, %rsi
movq %rcx, %rdx
movq %r8, 0x8(%rsp)
callq 0x497c
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %r8
addq (%rsp), %r8
jmp 0x8f2e
xorl %ebp, %ebp
leaq (%r14,%rax), %rdi
xorl %edx, %edx
testq %r13, %r13
setne %dl
addq %rbp, %rdx
movq %r8, %rsi
callq 0x10d0
addq 0x10(%rsp), %rbp
testq %r13, %r13
jne 0x8f90
movb $0x0, (%r14,%rbp)
jmp 0x8f90
movl $0x1, %eax
movl %r13d, %ecx
shll %cl, %eax
orb %al, (%r14,%rbp)
incq %r13
cmpq $0x8, %r13
jne 0x8f8d
incq %rbp
cmpq %r12, %rbp
jne 0x8f85
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x497c
xorl %ebp, %ebp
movb $0x0, (%r14,%rbp)
xorl %r13d, %r13d
incq %rbx
movzbl (%rbx), %eax
cmpl $0x31, %eax
je 0x8f56
testl %eax, %eax
jne 0x8f64
movq 0x60(%rsp), %rax
movq %r13, (%rax)
movq %rbp, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/maandree[P]libkeccak/extra/libkeccak_state_duplicate.c
// Function: libkeccak_state_duplicate
struct libkeccak_state *
libkeccak_state_duplicate(const struct libkeccak_state *src)
{
	struct libkeccak_state *dest = malloc(sizeof(struct libkeccak_state));
	if (!dest || libkeccak_state_copy(dest, src)) {
		libkeccak_state_free(dest);
		return NULL;
	}
	return dest;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x120, %edi            # imm = 0x120
callq 0x10e0
testq %rax, %rax
je 0x9187
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x9890
testl %eax, %eax
je 0x9189
movq %rbx, %rdi
callq 0x9304
movq 0x118(%rbx), %rdi
callq 0x1030
movq $0x0, 0x118(%rbx)
movq %rbx, %rdi
callq 0x1030
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/maandree[P]libkeccak/extra/libkeccak_state_marshal.c
// Function: libkeccak_state_marshal
size_t
libkeccak_state_marshal(const struct libkeccak_state *restrict state, void *restrict data_)
{
#define set(VAR)\
	do {\
		__builtin_memcpy(data, &state->VAR, sizeof(state->VAR));\
		data += sizeof(state->VAR);\
	} while (0)

	unsigned char *restrict start = data_;
	unsigned char *restrict data = start;

	if (!data) {
		return 7 * sizeof(long int) +
		       1 * sizeof(uint64_t) +
		       sizeof(state->S) +
		       2 * sizeof(size_t) +
		       state->mptr;
	}

	set(r);
	set(c);
	set(n);
	set(b);
	set(w);
	set(wmod);
	set(l);
	set(nr);
	__builtin_memcpy(data, &state->S, sizeof(state->S));
	data += sizeof(state->S);
	set(mptr);
	set(mlen);
	memcpy(data, state->M, state->mptr * sizeof(char));
	data += state->mptr;

	return (size_t)(data - start);

#undef set
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x9219
movq %rsi, %r14
movups 0xc8(%rbx), %xmm0
movups %xmm0, (%rsi)
movups 0xd8(%rbx), %xmm0
movups %xmm0, 0x10(%rsi)
movups 0xe8(%rbx), %xmm0
movups %xmm0, 0x20(%rsi)
movups 0xf8(%rbx), %xmm0
movups %xmm0, 0x30(%rsi)
leaq 0x40(%rsi), %rdi
movl $0xc8, %edx
movq %rbx, %rsi
callq 0x10d0
movq 0x108(%rbx), %r15
movups 0x108(%rbx), %xmm0
movups %xmm0, 0x108(%r14)
movl $0x118, %r12d           # imm = 0x118
addq %r12, %r14
movq 0x118(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x10d0
addq %r12, %r15
jmp 0x9226
movl $0x118, %r15d           # imm = 0x118
addq 0x108(%rbx), %r15
movq %r15, %rax
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_unmarshal.c
// Function: libkeccak_state_unmarshal
size_t
libkeccak_state_unmarshal(struct libkeccak_state *restrict state, const void *restrict data_)
{
#define get(VAR) \
	do {\
		__builtin_memcpy(&state->VAR, data, sizeof(state->VAR));\
		data += sizeof(state->VAR);\
	} while (0)

	const unsigned char *restrict start = data_;
	const unsigned char *restrict data = start;
	size_t mptr;

	if (!state) {
		data += 7U * sizeof(long int);
		data += 1U * sizeof(uint64_t);
		data += sizeof(state->S);
		mptr = *(const size_t *)data;
		data += 2U * sizeof(size_t);
		data += mptr;
		return (size_t)(data - start);
	}

	get(r);
	get(c);
	get(n);
	get(b);
	get(w);
	get(wmod);
	get(l);
	get(nr);
	memcpy(&state->S, data, sizeof(state->S));
	data += sizeof(state->S);
	get(mptr);
	get(mlen);
	if (state->mptr) {
		state->M = malloc(state->mptr * sizeof(char));
		if (!state->M)
			return 0;
		memcpy(state->M, data, state->mptr * sizeof(char));
		data += state->mptr;
	} else {
		state->M = NULL;
	}

	return (size_t)(data - start);

#undef get
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x92d1
movq %rdi, %r15
movups (%rbx), %xmm0
movups %xmm0, 0xc8(%rdi)
movups 0x10(%rbx), %xmm0
movups %xmm0, 0xd8(%rdi)
movups 0x20(%rbx), %xmm0
movups %xmm0, 0xe8(%rdi)
movups 0x30(%rbx), %xmm0
movups %xmm0, 0xf8(%rdi)
leaq 0x40(%rbx), %rsi
movl $0xc8, %edx
callq 0x10d0
movq 0x108(%rbx), %r12
movups 0x108(%rbx), %xmm0
movups %xmm0, 0x108(%r15)
leaq 0x118(%rbx), %r14
testq %r12, %r12
je 0x92e0
movq %r12, %rdi
callq 0x10e0
movq %rax, 0x118(%r15)
testq %rax, %rax
je 0x92f0
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x10d0
addq %r12, %r14
jmp 0x92eb
movl $0x118, %r14d           # imm = 0x118
addq 0x108(%rbx), %r14
jmp 0x92f3
movq $0x0, 0x118(%r15)
subq %rbx, %r14
jmp 0x92f3
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/maandree[P]libkeccak/util/libkeccak_behex_upper.c
// Function: libkeccak_behex_upper
void
libkeccak_behex_upper(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 0x963f
leaq 0x7e9f(%rip), %rax      # 0x114b3
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 0x9614
retq
// File: /workspace/github_c_makefile_star2_O3/maandree[P]libkeccak/util/libkeccak_unhex.c
// Function: libkeccak_unhex
void
libkeccak_unhex(void *restrict output_, const char *restrict hashsum)
{
	unsigned char *restrict output = output_;
	size_t n = strlen(hashsum) / 2;
	unsigned char a, b;

	while (n--) {
		a = (unsigned char)hashsum[2 * n + 0];
		b = (unsigned char)hashsum[2 * n + 1];

		a = (unsigned char)((a & 15) + (a > '9' ? 9 : 0));
		b = (unsigned char)((b & 15) + (b > '9' ? 9 : 0));

		a = (unsigned char)(a << 4);
		a |= b;
		output[n] = a;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1070
cmpq $0x2, %rax
jb 0x9887
shrq %rax
movl $0x39, %ecx
movb -0x2(%rbx,%rax,2), %dl
movb -0x1(%rbx,%rax,2), %sil
cmpb $0x3a, %dl
movl $0x0, %edi
cmovael %ecx, %edi
addb %dl, %dil
movl %esi, %edx
andb $0xf, %dl
xorl %r8d, %r8d
cmpb $0x3a, %sil
setae %r8b
leal (%r8,%r8,8), %esi
addb %dl, %sil
shlb $0x4, %dil
orb %sil, %dil
movb %dil, -0x1(%r14,%rax)
decq %rax
jne 0x9848
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/maandree[P]libkeccak/extra/libkeccak_state_copy.c
// Function: libkeccak_state_copy
int
libkeccak_state_copy(struct libkeccak_state *restrict dest, const struct libkeccak_state *restrict src)
{
	*dest = *src;
	if (src->mlen) {
		dest->M = malloc(src->mlen * sizeof(char));
		if (!dest->M)
			return -1;
		memcpy(dest->M, src->M, src->mptr * sizeof(char));
	} else {
		dest->M = NULL;
	}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x120, %edx            # imm = 0x120
callq 0x10d0
movq 0x110(%rbx), %rdi
testq %rdi, %rdi
je 0x98d9
callq 0x10e0
movq %rax, 0x118(%r14)
testq %rax, %rax
je 0x98e8
movq 0x108(%rbx), %rdx
movq 0x118(%rbx), %rsi
movq %rax, %rdi
callq 0x10d0
jmp 0x98e4
movq $0x0, 0x118(%r14)
xorl %eax, %eax
jmp 0x98ed
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/motet-a[P]libforks/tests/pid_ptr.c
// Function: main
int main() {
  libforks_ServerConn conn;

  check(pipe(pipe_fds) == 0);

  check(libforks_start(&conn) == libforks_OK);

  pid_t child_pid;

  check(libforks_fork(
    conn,
    &child_pid, // pid_ptr
    NULL, // socket_fd_ptr
    NULL, // exit_fd_ptr
    child_main
  ) == libforks_OK);

  pid_t received_child_pid;
  check(
    read(
      pipe_fds[0],
      &received_child_pid, sizeof received_child_pid
    ) == sizeof received_child_pid
  ); // blocks until the child writes
  check(child_pid == received_child_pid);

  check(libforks_stop(conn) == libforks_OK);

  check(child_pid == received_child_pid);

  return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x4df4(%rip), %rdi      # 0x610c
callq 0x10e0
testl %eax, %eax
jne 0x138a
leaq 0x8(%rsp), %rdi
callq 0x180b
testl %eax, %eax
jne 0x139b
movq 0x8(%rsp), %rdi
leaq 0xf1(%rip), %r8         # 0x142c
movq %rsp, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2198
testl %eax, %eax
jne 0x13ac
movl 0x4dbb(%rip), %edi      # 0x610c
leaq 0x4(%rsp), %rsi
movl $0x4, %edx
callq 0x10f0
cmpq $0x4, %rax
jne 0x13bd
movl (%rsp), %ebx
cmpl 0x4(%rsp), %ebx
jne 0x13ce
movq 0x8(%rsp), %rdi
callq 0x2353
testl %eax, %eax
jne 0x13df
cmpl %ebx, (%rsp)
jne 0x13f0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x1c73(%rip), %rdi      # 0x3004
movl $0x11, %esi
callq 0x1401
leaq 0x1c86(%rip), %rdi      # 0x3028
movl $0x13, %esi
callq 0x1401
leaq 0x1c9a(%rip), %rdi      # 0x304d
movl $0x1d, %esi
callq 0x1401
leaq 0x1cd2(%rip), %rdi      # 0x3096
movl $0x25, %esi
callq 0x1401
leaq 0x1d22(%rip), %rdi      # 0x30f7
movl $0x26, %esi
callq 0x1401
leaq 0x1d31(%rip), %rdi      # 0x3117
movl $0x28, %esi
callq 0x1401
leaq 0x1d00(%rip), %rdi      # 0x30f7
movl $0x2a, %esi
callq 0x1401
// File: /workspace/github_c_makefile_star2_O3/antonblanchard[P]will-it-scale/tests/read4.c
// Function: testcase_prepare
void testcase_prepare(unsigned long nr_tasks)
{
	int fd = mkstemp(tmpfile);
	char buf[FILESIZE];

	memset(buf, 0, sizeof(buf));
	assert(fd >= 0);
	assert(write(fd, buf, sizeof(buf)) == sizeof(buf));
	close(fd);
}

// Assembly:
pushq %rbx
subq $0x100000, %rsp         # imm = 0x100000
leaq 0x24dd(%rip), %rdi      # 0x51a0
callq 0x21f0
movl %eax, %ebx
movq %rsp, %rdi
movl $0x100000, %edx         # imm = 0x100000
xorl %esi, %esi
callq 0x2140
testl %ebx, %ebx
js 0x2d03
movq %rsp, %rsi
movl $0x100000, %edx         # imm = 0x100000
movl %ebx, %edi
callq 0x20d0
cmpq $0x100000, %rax         # imm = 0x100000
jne 0x2d22
movl %ebx, %edi
addq $0x100000, %rsp         # imm = 0x100000
popq %rbx
jmp 0x2150
leaq 0x5b6(%rip), %rdi       # 0x32c0
leaq 0x5b7(%rip), %rsi       # 0x32c8
leaq 0x5be(%rip), %rcx       # 0x32d6
movl $0x15, %edx
callq 0x2130
leaq 0x5d2(%rip), %rdi       # 0x32fb
leaq 0x598(%rip), %rsi       # 0x32c8
leaq 0x59f(%rip), %rcx       # 0x32d6
movl $0x16, %edx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O3/antonblanchard[P]will-it-scale/tests/read4.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	int fd = open(tmpfile, O_DIRECT|O_RDONLY);
	char *p;

	p = aligned_alloc(getpagesize(), BUFLEN);

	while (1) {
		int ret = read(fd, p, BUFLEN);
		assert(ret >= 0);
		if (ret == 0)
			lseek(fd, 0, SEEK_SET);

		(*iterations)++;
	}
	free(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x244e(%rip), %rdi      # 0x51a0
movl $0x4000, %esi           # imm = 0x4000
xorl %eax, %eax
callq 0x2230
movl %eax, %ebp
callq 0x22a0
movslq %eax, %r14
movq %r14, %rdi
movq %r14, %rsi
callq 0x22c0
movq %rax, %r15
movl %ebp, %edi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2170
testl %eax, %eax
js 0x2da0
testl %eax, %eax
jne 0x2d96
movl %ebp, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2120
incq (%rbx)
movl %ebp, %edi
movq %r15, %rsi
jmp 0x2d7b
leaq 0x57f(%rip), %rdi       # 0x3326
leaq 0x51a(%rip), %rsi       # 0x32c8
leaq 0x57a(%rip), %rcx       # 0x332f
movl $0x23, %edx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/ch5/lua_error.c
// Function: main
int main() {

  lua_State *L = luaL_newstate();
  luaL_openlibs(L);
  lua_register(L, "fn", fn);
  
  // Call fn().
  lua_getglobal(L, "fn");
  lua_call(L, 0, 0);

  printf("Done!\n");

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
callq 0x14ac9
movq %rax, %rbx
movq %rax, %rdi
callq 0x14ccc
leaq -0x47(%rip), %rsi       # 0x479c
movq %rbx, %rdi
xorl %edx, %edx
callq 0x52c0
leaq 0x1c822(%rip), %r14     # 0x21016
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5704
movq %rbx, %rdi
movq %r14, %rsi
callq 0x538f
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5b7f
leaq 0x1c7f7(%rip), %rdi     # 0x21019
callq 0x40c0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/ch1/runmodule.c
// Function: main
int main() {

  // Create a Lua state and load the module.
  lua_State *L = luaL_newstate();
  luaL_openlibs(L);
  luaL_dofile(L, "eatyguy0.lua");
  lua_setglobal(L, "eatyguy");
  lua_settop(L, 0);

  // Run the init() function.
  lua_getglobal(L, "eatyguy");
  lua_getfield(L, -1, "init");  // -1 means stack top.
  lua_call(L, 0, 0);            // 0, 0 = #args, #retvals

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
callq 0x14abd
movq %rax, %rbx
movq %rax, %rdi
callq 0x14cc0
leaq 0x1c85a(%rip), %rsi     # 0x21004
movq %rbx, %rdi
xorl %edx, %edx
callq 0x14216
testl %eax, %eax
jne 0x47cf
movq %rbx, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5bdb
leaq 0x1c83b(%rip), %r14     # 0x21011
movq %rbx, %rdi
movq %r14, %rsi
callq 0x56f8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4959
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5383
leaq 0x1c81c(%rip), %rdx     # 0x21019
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x54a1
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5b73
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/dropletzhu[P]msuite/msender.c
// Function: udp_csum
unsigned short
udp_csum(unsigned short *pseudo_header, unsigned short *buf, int nwords)
{
    unsigned long sum = 0;
	int  i = 0;

	for ( ; i < sizeof(pseudo_header_t)>>1; i++ )
		sum += *pseudo_header++;

    for ( ;nwords > 0; nwords--)
        sum += *buf++;

    sum = (sum >> 16) + (sum & 0xffff);
    sum += (sum >> 16);

    return (unsigned short)~sum;
}

// Assembly:
pxor %xmm0, %xmm0
xorl %eax, %eax
pxor %xmm1, %xmm1
movd (%rdi,%rax,2), %xmm2
punpcklwd %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1],xmm2[2],xmm0[2],xmm2[3],xmm0[3]
punpckldq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
paddq %xmm2, %xmm1
addq $0x2, %rax
cmpq $0x6, %rax
jne 0x1249
pshufd $0xee, %xmm1, %xmm0     # xmm0 = xmm1[2,3,2,3]
paddq %xmm1, %xmm0
movq %xmm0, %rax
testl %edx, %edx
jle 0x1289
incl %edx
movzwl (%rsi), %ecx
addq $0x2, %rsi
addq %rcx, %rax
decl %edx
cmpl $0x1, %edx
ja 0x1278
movq %rax, %rcx
shrq $0x10, %rcx
movzwl %ax, %eax
addl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
addl %ecx, %eax
notl %eax
retq
// File: /workspace/github_c_makefile_star2_O3/dropletzhu[P]msuite/msender.c
// Function: usage
void usage()
{
    printf("Usage: ./msender -s source -g group -p port -t ttl -l length -c count\n");
	printf(" -s source	the source ip\n");
	printf(" -g group	the group ip\n");
	printf(" -p port	the port\n");
	printf(" -t ttl		the ttl, default ttl is 1\n");
	printf(" -l length	the packet length, default length is 256 bytes\n");
	printf(" -c count	the packet count, default count is unlimited\n");
    printf(" Version	%s\n",version);
}

// Assembly:
pushq %rax
leaq 0xdf2(%rip), %rdi       # 0x2099
callq 0x1040
leaq 0xe2c(%rip), %rdi       # 0x20df
callq 0x1040
leaq 0xe39(%rip), %rdi       # 0x20f8
callq 0x1040
leaq 0xe44(%rip), %rdi       # 0x210f
callq 0x1040
leaq 0xe4a(%rip), %rdi       # 0x2121
callq 0x1040
leaq 0xe61(%rip), %rdi       # 0x2144
callq 0x1040
leaq 0xe8f(%rip), %rdi       # 0x217e
callq 0x1040
leaq 0xd49(%rip), %rdi       # 0x2044
leaq 0xd4f(%rip), %rsi       # 0x2051
xorl %eax, %eax
popq %rcx
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]yasuna/src/libpolyaness/src/polyaness.c
// Function: get_polyaness
char* get_polyaness(const char* key, int record, polyaness_t** polyaness)
{
    if (polyaness == NULL   ||
            key == NULL     ||
            (*polyaness)->recs < record)
        return NULL;

    int     i       = 0,
            j       = 0;
    
    char*   match   = NULL,
        **  keys    = (*polyaness)->record[record]->key;

    j = (*polyaness)->record[record]->keys - 1;
    while (i < (*polyaness)->record[record]->keys && i <= j) {
        if (strcmp_lite(*(keys + i), key) == 0)
            return match = (*polyaness)->record[record]->value[i];
        if (strcmp_lite(*(keys + j), key) == 0)
            return match = (*polyaness)->record[record]->value[j];
        i++;
        j--;
    }

    return match;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0xa2af
movq (%rdx), %rax
cmpl %esi, (%rax)
jl 0xa2af
movq 0x8(%rax), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %rax
movslq (%rax), %r12
testq %r12, %r12
jle 0xa2af
movq %rdi, %rbx
movq %rax, (%rsp)
movq 0x8(%rax), %rbp
leaq -0x1(%r12), %r15
xorl %r14d, %r14d
xorl %r13d, %r13d
movq (%rbp,%r13,8), %rdi
movq %rbx, %rsi
callq 0xa2d5
testl %eax, %eax
je 0xa2c7
movq (%rbp,%r15,8), %rdi
movq %rbx, %rsi
callq 0xa2d5
testl %eax, %eax
je 0xa2c4
incq %r13
cmpq %r12, %r13
jae 0xa2b2
leaq -0x1(%r15), %rax
cmpq %r15, %r13
movq %rax, %r15
jl 0xa277
jmp 0xa2b2
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %r13
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax,%r13,8), %r14
jmp 0xa2b2
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]yasuna/src/libpolyaness/src/polyaness.c
// Function: release_polyaness
void release_polyaness(polyaness_t* polyaness)
{
    if (polyaness == NULL)
        return;

    int     i   = 0,
            j   = 0;

    if (polyaness->record != NULL) {
        i = 0;
        j = polyaness->recs - 1;
        while (i <= j) {
            if (polyaness->record[i] != NULL)
                release_polyaness_cell(&polyaness->record[i]);
            if (polyaness->record[j] != NULL)
                release_polyaness_cell(&polyaness->record[j]);
            i++;
            j--;
        }
        free(polyaness->record);
    }

    free(polyaness);
    polyaness = NULL;

    return;
}

// Assembly:
testq %rdi, %rdi
je 0xa3d8
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xa3c7
movslq (%rbx), %r14
testq %r14, %r14
jle 0xa3c2
leaq -0x8(,%r14,8), %r15
decq %r14
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%rbx), %rdi
cmpq $0x0, (%rdi,%r12)
je 0xa398
addq %r12, %rdi
callq 0xa3d9
movq 0x8(%rbx), %rdi
cmpq $0x0, (%rdi,%r15)
je 0xa3a7
addq %r15, %rdi
callq 0xa3d9
incq %r13
addq $0x8, %r12
addq $-0x8, %r15
leaq -0x1(%r14), %rax
cmpq %r14, %r13
movq %rax, %r14
jl 0xa381
movq 0x8(%rbx), %rdi
callq 0x2190
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2190
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]yasuna/src/libpolyaness/src/polyaness.c
// Function: release_polyaness_cell
void release_polyaness_cell(polyaness_cell** record)
{
    int i   = 0,
        j   = 0;
    
    j = (*record)->keys - 1;
    while (j >= i) {
        if ((*record)->key[i] != NULL) {
            free((*record)->key[i]);
            (*record)->key[i] = NULL;
        }
        if ((*record)->value[i] != NULL) {
            free((*record)->value[i]);
            (*record)->value[i] = NULL;
        }
        if ((*record)->key[j] != NULL) {
            free((*record)->key[j]);
            (*record)->key[j] = NULL;
        }
        if ((*record)->value[j] != NULL) {
            free((*record)->value[j]);
            (*record)->value[j] = NULL;
        }
        i++;
        j--;
    }
    if ((*record)->key != NULL) {
        free((*record)->key);
        (*record)->key = NULL;
    }
    if ((*record)->value != NULL) {
        free((*record)->value);
        (*record)->value = NULL;
    }
    if (*record != NULL) {
        free(*record);
        *record = NULL;
    }

    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movslq (%rdi), %r14
testq %r14, %r14
jle 0xa49c
decq %r14
xorl %r15d, %r15d
movq (%rbx), %rax
movq 0x8(%rax), %rcx
movq (%rcx,%r15,8), %rdi
testq %rdi, %rdi
je 0xa41d
callq 0x2190
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq $0x0, (%rax,%r15,8)
movq (%rbx), %rax
movq 0x10(%rax), %rcx
movq (%rcx,%r15,8), %rdi
testq %rdi, %rdi
je 0xa441
callq 0x2190
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq $0x0, (%rax,%r15,8)
movq (%rbx), %rax
movq 0x8(%rax), %rcx
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0xa465
callq 0x2190
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq $0x0, (%rax,%r14,8)
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0xa486
callq 0x2190
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq $0x0, (%rax,%r14,8)
incq %r15
leaq -0x1(%r14), %rax
cmpq %r15, %r14
movq %rax, %r14
jg 0xa3f6
movq (%rbx), %rdi
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0xa4bb
movq %rax, %rdi
callq 0x2190
movq (%rbx), %rax
movq $0x0, 0x8(%rax)
movq (%rbx), %rdi
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xa4df
movq %rax, %rdi
callq 0x2190
movq (%rbx), %rax
movq $0x0, 0x10(%rax)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xa4eb
callq 0x2190
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]yasuna/src/subset.c
// Function: open_dict_file
int open_dict_file(FILE** fp, yasuna_t* yasuna)
{
    int     status  = 0;

    STRING* path    = new_string(NULL);

    struct  stat st;

    if (concat_file_path(path, yasuna) < 0) {
        status = -1; goto ERR;
    }

    if (stat(path->c_str(path), &st) != 0) {
        status = -2; goto ERR;
    }

    if ((st.st_mode & S_IFMT) == S_IFDIR) {
        status = -3; goto ERR;
    }
    if ((*fp = fopen(path->c_str(path), "r")) == NULL) {
        status = -4; goto ERR;
    }
    path->release(path);

    return 0;

ERR:
    switch (status) {
        case    -1:
            break;
        case    -2:
            fprintf(stderr, "%s: %s: %s\n",
                    PROGNAME, path->c_str(path), strerror(ENOENT));
            break;
        case    -3:
            fprintf(stderr, "%s: %s: %s\n",
                    PROGNAME, path->c_str(path), strerror(EISDIR));
            break;
        case    -4:
            fprintf(stderr, "%s: %s: %s\n",
                    PROGNAME, path->c_str(path), strerror(errno));
            break;
    }
    path->release(path);

    return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r12
movq %rdi, %r15
xorl %edi, %edi
callq 0x62b0
movq %rax, %r14
movq %rax, %rbx
movq %rax, (%rsp)
testb $0x2, (%r12)
movq 0x58(%rax), %rax
jne 0xa5ef
leaq 0x207e(%rip), %rsi      # 0xc64e
movq %rsp, %rdi
callq *%rax
testl %eax, %eax
js 0xa660
movq %rsp, %rdi
movq (%rdi), %rax
leaq 0x207d(%rip), %rsi      # 0xc667
callq *0x68(%rax)
jmp 0xa5f9
movq 0x10(%r12), %rsi
movq %rsp, %rdi
callq *%rax
testl %eax, %eax
js 0xa660
addq $0xc8, %r14
movq %rbx, %rdi
callq *0xc8(%rbx)
movq %rsp, %rsi
movq %rax, %rdi
callq 0x2410
testl %eax, %eax
jne 0xa680
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsp), %eax
cmpl $0x4000, %eax           # imm = 0x4000
je 0xa692
movq %rbx, %rdi
callq *0xc8(%rbx)
leaq 0x20d6(%rip), %rsi      # 0xc712
movq %rax, %rdi
callq 0x20f0
movq %rax, (%r15)
xorl %ebp, %ebp
testq %rax, %rax
jne 0xa665
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2683
movl $0xfffffffc, %ebp       # imm = 0xFFFFFFFC
jmp 0xa665
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq *0x268(%rbx)
movl %ebp, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x263c
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
jmp 0xa665
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26ce
movl $0xfffffffd, %ebp       # imm = 0xFFFFFFFD
jmp 0xa665
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]yasuna/src/subset.c
// Function: print_all_quotes
void print_all_quotes(polyaness_t* pt, yasuna_t* yasuna)
{
    int     i   = 0;

    if (yasuna->flag & YASUNA_SPEAKER)
        fprintf(stdout, "*** speaker = %s, %d quotes ***\n",
                yasuna->sarg, pt->recs);

    while (i < pt->recs) {
        fprintf(stdout, "%4d %s\n",
                i, get_polyaness("quote", i, &pt));
        i++;
    }

    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, (%rsp)
testb $0x4, (%rsi)
je 0xaca1
movq 0x636e(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
movq 0x8(%rsi), %rdx
movl (%rbx), %ecx
leaq 0x1985(%rip), %rsi      # 0xc61f
xorl %eax, %eax
callq 0x2400
cmpl $0x0, (%rbx)
jle 0xaced
movq 0x634b(%rip), %r13      # 0x10ff8
leaq 0x1994(%rip), %rbx      # 0xc648
movq %rsp, %r14
leaq 0x1982(%rip), %r15      # 0xc640
xorl %ebp, %ebp
movq (%r13), %r12
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0xa22c
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2400
incl %ebp
movq (%rsp), %rax
cmpl (%rax), %ebp
jl 0xacc0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sasairc[P]yasuna/src/yasuna.c
// Function: release
static
void release(FILE* fp, polyaness_t* pt)
{
    if (fp != NULL) {
        fclose(fp);
        fp = NULL;
    }
    if (pt != NULL)
        release_polyaness(pt);

    return;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0xafec
callq 0x2390
testq %rbx, %rbx
je 0xaffa
movq %rbx, %rdi
popq %rbx
jmp 0xa34a
popq %rbx
retq