LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/tests/crypto_aesctr/main.c
// Function: print_hardware
static void
print_hardware(const char * str)
{

	/* Inform the user of the general topic... */
	printf("%s", str);

	/* ... and whether we're using hardware acceleration or not. */
#if defined(CPUSUPPORT_CONFIG_FILE)
#ifdef CPUSUPPORT_X86_AESNI
	if (cpusupport_x86_aesni())
		printf(" using hardware AESNI.\n");
	else
#endif
#ifdef CPUSUPPORT_ARM_AES
	if (cpusupport_arm_aes())
		printf(" using hardware ARM-AES.\n");
	else
#endif
		printf(" using software AES.\n");
#else
	printf(" with unknown hardware acceleration status.\n");
#endif /* CPUSUPPORT_CONFIG_FILE */
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rsi
leaq 0x40ef(%rip), %rdi      # 0x6c3f
xorl %eax, %eax
callq 0x2030
leaq 0x76ee(%rip), %r14      # 0xa24c
leaq 0x3b11(%rip), %rbx      # 0x6676
cmpl $0x0, (%r14)
jne 0x2b94
leaq 0x76de(%rip), %r15      # 0xa250
cmpl $0x0, (%r15)
je 0x2b81
leaq 0x3ae2(%rip), %rbx      # 0x6661
jmp 0x2b94
callq 0x333c
movl %eax, (%r14)
movl $0x1, (%r15)
testl %eax, %eax
je 0x2b78
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2080
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/tests/crypto_aesctr/main.c
// Function: perftest_func
static int
perftest_func(void * cookie, uint8_t * buf, size_t buflen, size_t nreps)
{
	struct crypto_aesctr * aesctr = cookie;
	size_t i;

	/* Do the encryption. */
	for (i = 0; i < nreps; i++)
		crypto_aesctr_stream(aesctr, buf, buf, buflen);

	/* Success! */
	return (0);
}

// Assembly:
testq %rcx, %rcx
je 0x2bf9
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3cdb
decq %rbx
jne 0x2bd8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/tests/crypto_aesctr/main.c
// Function: selftest_cases
static size_t
selftest_cases(const struct testcase * tests, size_t num_tests, uint64_t nonce)
{
	struct crypto_aes_key * key_exp;
	uint8_t plaintext_arr[MAX_PLAINTEXT_LENGTH];
	uint8_t ciphertext_arr[MAX_PLAINTEXT_LENGTH];
	uint8_t cbuf[MAX_PLAINTEXT_LENGTH];
	size_t keylen;
	size_t i;
	size_t len;
	size_t failures = 0;

	/* Inform user about the hardware optimization status. */
	print_hardware("Checking test vectors of AES");

	/* Run regular test cases. */
	for (i = 0; i < num_tests; i++) {
		/* Prepare for the test case. */
		if (parse_testcase(tests[i], &key_exp, &keylen,
		    plaintext_arr, ciphertext_arr)) {
			warn0("parse_testcase");
			goto err0;
		}
		printf("Computing %zu-bit AES-CTR of \"%s\"...",
		    keylen * 8, tests[i].plaintext_str);

		/* Plaintext length. */
		len = strlen(tests[i].plaintext_str);

		/* Encrypt with AES-CTR. */
		crypto_aesctr_buf(key_exp, nonce, plaintext_arr,
		    cbuf, len);

		/* Check result. */
		if (memcmp(cbuf, ciphertext_arr, len)) {
			printf(" FAILED!\n");
			print_arr("Computed AES:\t", cbuf, len);
			print_arr("Correct AES:\t", ciphertext_arr, len);
			failures++;
		} else {
			printf(" PASSED!\n");
		}

		/* Clean up. */
		crypto_aes_key_free(key_exp);
	}

	return (failures);

err0:
	/* Failure! */
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, 0x28(%rsp)
movq %rdi, %r14
leaq 0x341b(%rip), %rdi      # 0x6037
callq 0x2b41
leaq 0x80(%rsp), %rbx
leaq 0x60(%rsp), %r15
leaq 0x40(%rsp), %r12
xorl %ebp, %ebp
movq $0x0, 0x20(%rsp)
movq 0x10(%r14,%rbp), %rax
movq %rax, 0x10(%rsp)
movups (%r14,%rbp), %xmm0
movups %xmm0, (%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x316d
testl %eax, %eax
jne 0x2d34
movq 0x30(%rsp), %rsi
shlq $0x3, %rsi
movq 0x8(%r14,%rbp), %rdx
leaq 0x33e0(%rip), %rdi      # 0x6063
xorl %eax, %eax
callq 0x2030
movq 0x8(%r14,%rbp), %rdi
callq 0x2140
movq %rax, %r13
movq %rbx, %rdx
movq 0x38(%rsp), %rbx
movq %rbx, %rdi
movq 0x28(%rsp), %rsi
movq %r12, %rcx
movq %rax, %r8
callq 0x3f5e
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2170
testl %eax, %eax
je 0x2cfb
leaq 0x39cb(%rip), %rdi      # 0x6696
callq 0x2080
leaq 0x33b1(%rip), %rdi      # 0x6088
movq %r12, %rsi
movq %r13, %rdx
callq 0x32e0
leaq 0x33ae(%rip), %rdi      # 0x6097
movq %r15, %rsi
movq %r13, %rdx
callq 0x32e0
incq 0x20(%rsp)
jmp 0x2d07
leaq 0x398b(%rip), %rdi      # 0x668d
callq 0x2080
movq %rbx, %rdi
callq 0x34cf
addq $0x18, %rbp
cmpq $0xd8, %rbp
leaq 0x80(%rsp), %rbx
leaq 0x60(%rsp), %r15
leaq 0x40(%rsp), %r12
jne 0x2c3e
jmp 0x2d57
leaq 0x3319(%rip), %rdi      # 0x6054
xorl %eax, %eax
callq 0x4e37
callq 0x21c0
movl $0x0, (%rax)
movl $0x1, %eax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/tests/crypto_aesctr/main.c
// Function: parse_testcase
static int
parse_testcase(const struct testcase testcase,
    struct crypto_aes_key ** key_exp_p, size_t * keylen_p,
    uint8_t plaintext_arr[static MAX_PLAINTEXT_LENGTH],
    uint8_t ciphertext_arr[static MAX_PLAINTEXT_LENGTH])
{
	uint8_t key_unexpanded[32]; /* We will use 16 or 32 of these bytes. */
	const size_t len = strlen(testcase.plaintext_str);

	/* Determine key length. */
	*keylen_p = strlen(testcase.keytext_hex) / 2;

	/* Sanity check. */
	assert((*keylen_p == 16) || (*keylen_p == 32));
	assert(len <= MAX_PLAINTEXT_LENGTH);

	/* Prepare the key. */
	if (unhexify(testcase.keytext_hex, key_unexpanded, *keylen_p)) {
		warn0("unhexify(%s)", testcase.keytext_hex);
		goto err0;
	}
	if ((*key_exp_p = crypto_aes_key_expand(key_unexpanded, *keylen_p))
	    == NULL) {
		warn0("crypto_aes_key_expand");
		goto err0;
	}

	/* Prepare the arrays. */
	memcpy(plaintext_arr, testcase.plaintext_str, len);
	if (unhexify(testcase.ciphertext_hex, ciphertext_arr, len)) {
		warn0("unhexify(%s)", testcase.ciphertext_hex);
		goto err1;
	}

	/* Clean up.  Irrelevant for a test, but it's a good habit. */
	insecure_memzero(key_unexpanded, 32);

	/* Success! */
	return (0);

err1:
	crypto_aes_key_free(*key_exp_p);
err0:
	/* Failure! */
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %rbx
movq 0x78(%rsp), %r13
movq %r13, %rdi
callq 0x2140
movq %rax, %r15
movq 0x70(%rsp), %r14
movq %r14, %rdi
callq 0x2140
shrq %rax
movq %rax, (%rbp)
cmpq $0x10, %rax
je 0x31bd
cmpq $0x20, %rax
jne 0x32c1
cmpq $0x21, %r15
jae 0x32a2
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x47e7
testl %eax, %eax
je 0x320b
leaq 0x2f71(%rip), %rdi      # 0x6153
movq %r14, %rsi
xorl %eax, %eax
callq 0x4e37
callq 0x21c0
movl $0x0, (%rax)
movl $0x1, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x342f
movq %rax, (%rbx)
testq %rax, %rax
je 0x3272
leaq 0x70(%rsp), %r14
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x2240
movq 0x10(%r14), %r14
movq %r14, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x47e7
testl %eax, %eax
je 0x3285
leaq 0x2f00(%rip), %rdi      # 0x6153
movq %r14, %rsi
xorl %eax, %eax
callq 0x4e37
callq 0x21c0
movl $0x0, (%rax)
movq (%rbx), %rdi
callq 0x34cf
jmp 0x31f7
leaq 0x2ee7(%rip), %rdi      # 0x6160
xorl %eax, %eax
callq 0x4e37
jmp 0x31ec
leaq 0x6fac(%rip), %rax      # 0xa238
movq (%rax), %rax
leaq 0x10(%rsp), %rdi
movl $0x20, %esi
callq *%rax
xorl %eax, %eax
jmp 0x31fc
leaq 0x2e8e(%rip), %rdi      # 0x6137
leaq 0x2e1c(%rip), %rsi      # 0x60cc
leaq 0x2e1c(%rip), %rcx      # 0x60d3
movl $0xd8, %edx
callq 0x20a0
leaq 0x2ddd(%rip), %rdi      # 0x60a5
leaq 0x2dfd(%rip), %rsi      # 0x60cc
leaq 0x2dfd(%rip), %rcx      # 0x60d3
movl $0xd7, %edx
callq 0x20a0
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/tests/crypto_aesctr/main.c
// Function: print_arr
static void
print_arr(const char * name, const uint8_t * arr, size_t len)
{
	size_t i;

	printf("%s", name);
	for (i = 0; i < len; i++)
		printf("%02x", arr[i]);
	printf("\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x3947(%rip), %rdi      # 0x6c3f
xorl %eax, %eax
callq 0x2030
testq %rbx, %rbx
je 0x3325
leaq 0x2e6b(%rip), %r15      # 0x6176
xorl %r12d, %r12d
movzbl (%r14,%r12), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2030
incq %r12
cmpq %r12, %rbx
jne 0x330e
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20b0
nop
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/liball/../crypto/crypto_aes.c
// Function: hwaccel_init
static void
hwaccel_init(void)
{

	/* If we've already set hwaccel, we're finished. */
	if (hwaccel != HW_UNSET)
		return;

	/* Default to software. */
	hwaccel = HW_SOFTWARE;

#if defined(CPUSUPPORT_X86_AESNI)
	CPUSUPPORT_VALIDATE(hwaccel, HW_X86_AESNI, cpusupport_x86_aesni(),
	    functest(x86_aesni_oneshot));
#endif
#if defined(CPUSUPPORT_ARM_AES)
	CPUSUPPORT_VALIDATE(hwaccel, HW_ARM_AES, cpusupport_arm_aes(),
	    functest(arm_aes_oneshot));
#endif

	/*
	 * If we're here, we're not using any intrinsics.  Test OpenSSL; if
	 * there's an error, print a warning and abort.
	 */
	if (functest(openssl_oneshot)) {
		warn0("OpenSSL gives incorrect AES values.");
		abort();
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, 0x6dcd(%rip)      # 0xa150
jne 0x340f
movl $0x0, 0x6dbd(%rip)      # 0xa150
leaq 0x6eb2(%rip), %rbx      # 0xa24c
cmpl $0x0, (%rbx)
je 0x33ca
leaq 0x1f9(%rip), %rdi       # 0x359f
callq 0x3509
testl %eax, %eax
je 0x3405
leaq 0x33ba(%rip), %rdi      # 0x6770
xorl %eax, %eax
callq 0x4e37
callq 0x21c0
movl $0x0, (%rax)
jmp 0x33d7
leaq 0x6e7f(%rip), %r14      # 0xa250
cmpl $0x0, (%r14)
je 0x3417
leaq 0x1fe(%rip), %rdi       # 0x35dc
callq 0x3509
testl %eax, %eax
je 0x340f
leaq 0x33b1(%rip), %rdi      # 0x679f
xorl %eax, %eax
callq 0x4e37
callq 0x21c0
movl $0x0, (%rax)
callq 0x2060
movl $0x1, 0x6d41(%rip)      # 0xa150
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x333c
movl %eax, (%rbx)
movl $0x1, (%r14)
testl %eax, %eax
jne 0x339f
jmp 0x33d7
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/liball/../crypto/crypto_aes.c
// Function: crypto_aes_key_expand
struct crypto_aes_key *
crypto_aes_key_expand(const uint8_t * key_unexpanded, size_t len)
{
	AES_KEY * kexp;

	/* Sanity-check. */
	assert((len == 16) || (len == 32));

#ifdef HWACCEL
	/* Ensure that we've chosen the type of hardware acceleration. */
	hwaccel_init();

#ifdef CPUSUPPORT_X86_AESNI
	if (hwaccel == HW_X86_AESNI)
		return (crypto_aes_key_expand_aesni(key_unexpanded, len));
#endif
#ifdef CPUSUPPORT_ARM_AES
	if (hwaccel == HW_ARM_AES)
		return (crypto_aes_key_expand_arm(key_unexpanded, len));
#endif
#endif /* HWACCEL */

	/* Allocate structure. */
	if ((kexp = malloc(sizeof(AES_KEY))) == NULL)
		goto err0;

	/* Expand the key. */
	if (AES_set_encrypt_key(key_unexpanded, (int)(len * 8), kexp) != 0)
		goto err1;

	/* Success! */
	return ((void *)kexp);

err1:
	free(kexp);
err0:
	/* Failure! */
	return (NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
cmpq $0x10, %rsi
je 0x3446
cmpq $0x20, %rbx
jne 0x349e
callq 0x3378
cmpl $0x1, 0x6cfe(%rip)      # 0xa150
jne 0x3464
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x363c
movl $0xf4, %edi
callq 0x20d0
testq %rax, %rax
je 0x3492
movq %rax, %r14
shll $0x3, %ebx
movq %r15, %rdi
movl %ebx, %esi
movq %rax, %rdx
callq 0x2260
testl %eax, %eax
je 0x3495
movq %r14, %rdi
callq 0x2130
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3253(%rip), %rdi      # 0x66f8
leaq 0x3267(%rip), %rsi      # 0x6713
leaq 0x3277(%rip), %rcx      # 0x672a
movl $0xf1, %edx
callq 0x20a0
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/liball/../crypto/crypto_aes.c
// Function: functest
static int
functest(int (* func)(const uint8_t *, size_t, const uint8_t[16], uint8_t[16]))
{
	struct aes_test * knowngood;
	uint8_t ctext[16];
	size_t i;

	for (i = 0; i < sizeof(testcases) / sizeof(testcases[0]); i++) {
		knowngood = &testcases[i];

		/* Sanity-check. */
		assert((knowngood->len == 16) || (knowngood->len == 32));

		/* Expand the key and encrypt with the provided function. */
		if (func(knowngood->key, knowngood->len, knowngood->ptext,
		    ctext))
			goto err0;

		/* Does the output match the known good value? */
		if (memcmp(knowngood->ctext, ctext, 16))
			goto err0;
	}

	/* Success! */
	return (0);

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x1, %r15d
leaq 0x6c74(%rip), %r12      # 0xa198
movq %rsp, %r14
movq -0x18(%r12), %rsi
cmpq $0x10, %rsi
je 0x3538
cmpq $0x20, %rsi
jne 0x3580
leaq -0x38(%r12), %rdi
leaq -0x10(%r12), %rdx
movq %r14, %rcx
callq *%rbx
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x3574
movdqu (%r12), %xmm0
pcmpeqb (%rsp), %xmm0
pmovmskb %xmm0, %ecx
cmpl $0xffff, %ecx           # imm = 0xFFFF
jne 0x3574
addq $0x48, %r12
decq %r15
je 0x3527
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x323c(%rip), %rdi      # 0x67c3
leaq 0x3185(%rip), %rsi      # 0x6713
leaq 0x325f(%rip), %rcx      # 0x67f4
movl $0x54, %edx
callq 0x20a0
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/liball/../crypto/crypto_aes.c
// Function: x86_aesni_oneshot
static int
x86_aesni_oneshot(const uint8_t * key_unexpanded, size_t len,
    const uint8_t ptext[16], uint8_t ctext[16])
{
	void * kexp_hw;

	/* Expand the key and encrypt with hardware intrinsics. */
	if ((kexp_hw = crypto_aes_key_expand_aesni(key_unexpanded, len))
	    == NULL)
		goto err0;
	crypto_aes_encrypt_block_aesni(ptext, ctext, kexp_hw);
	crypto_aes_key_free_aesni(kexp_hw);

	/* Success! */
	return (0);

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
callq 0x363c
testq %rax, %rax
je 0x35d1
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3bac
movq %r15, %rdi
callq 0x3bc0
xorl %eax, %eax
jmp 0x35d6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/liball/../crypto/crypto_aes.c
// Function: openssl_oneshot
static int
openssl_oneshot(const uint8_t * key_unexpanded, size_t len,
    const uint8_t ptext[16], uint8_t * ctext)
{
	AES_KEY kexp_actual;
	AES_KEY * kexp = &kexp_actual;

	/* Expand the key, encrypt, and clean up. */
	if (AES_set_encrypt_key(key_unexpanded, (int)(len * 8), kexp) != 0)
		goto err0;
	AES_encrypt(ptext, ctext, kexp);
	insecure_memzero(kexp, sizeof(AES_KEY));

	/* Success! */
	return (0);

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rcx, %rbx
movq %rdx, %r14
shll $0x3, %esi
leaq 0xc(%rsp), %rdx
callq 0x2260
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x362f
leaq 0xc(%rsp), %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2160
leaq 0x6c18(%rip), %rax      # 0xa238
movq (%rax), %rax
movl $0xf4, %esi
movq %r15, %rdi
callq *%rax
xorl %eax, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/liball/../crypto/crypto_aesctr.c
// Function: crypto_aesctr_init2
void
crypto_aesctr_init2(struct crypto_aesctr * stream,
    const struct crypto_aes_key * key, uint64_t nonce)
{

	/* If the key is NULL, retain the previous AES key. */
	if (key != NULL)
		stream->key = key;

	/* Set nonce as provided and reset bytectr. */
	be64enc(stream->pblk, nonce);
	stream->bytectr = 0;

	/*
	 * Set the counter such that the least significant byte will wrap once
	 * incremented.
	 */
	stream->pblk[15] = 0xff;

#ifdef HWACCEL
	hwaccel_init();
#endif

	/* Sanity check. */
	assert(stream->key != NULL);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x3bfa
movq %rsi, (%rbx)
bswapq %rdx
movq %rdx, 0x20(%rbx)
movq $0x0, 0x8(%rbx)
movb $-0x1, 0x2f(%rbx)
cmpl $0x2, 0x65dc(%rip)      # 0xa1f0
jne 0x3c38
movl $0x0, 0x65d0(%rip)      # 0xa1f0
callq 0x3364
testl %eax, %eax
je 0x3c38
cmpl $0x1, %eax
jne 0x3c5f
movl $0x1, 0x65b8(%rip)      # 0xa1f0
cmpq $0x0, (%rbx)
je 0x3c40
popq %rbx
retq
leaq 0x2c1e(%rip), %rdi      # 0x6865
leaq 0x2c2b(%rip), %rsi      # 0x6879
leaq 0x2c3e(%rip), %rcx      # 0x6893
movl $0x80, %edx
callq 0x20a0
leaq 0x2d6d(%rip), %rdi      # 0x69d3
leaq 0x2c0c(%rip), %rsi      # 0x6879
leaq 0x2d2f(%rip), %rcx      # 0x69a3
movl $0x48, %edx
callq 0x20a0
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/liball/../crypto/crypto_aesctr.c
// Function: crypto_aesctr_init
struct crypto_aesctr *
crypto_aesctr_init(const struct crypto_aes_key * key, uint64_t nonce)
{
	struct crypto_aesctr * stream;

	/* Sanity check. */
	assert(key != NULL);

	/* Allocate memory. */
	if ((stream = crypto_aesctr_alloc()) == NULL)
		goto err0;

	/* Initialize values. */
	crypto_aesctr_init2(stream, key, nonce);

	/* Success! */
	return (stream);

err0:
	/* Failure! */
	return (NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3cbc
movq %rsi, %rbx
movq %rdi, %r15
movl $0x30, %edi
callq 0x20d0
testq %rax, %rax
je 0x3cb0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3bee
jmp 0x3cb3
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2baa(%rip), %rdi      # 0x686d
leaq 0x2baf(%rip), %rsi      # 0x6879
leaq 0x2c1c(%rip), %rcx      # 0x68ed
movl $0x90, %edx
callq 0x20a0
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/liball/../crypto/crypto_aesctr.c
// Function: crypto_aesctr_buf
void
crypto_aesctr_buf(const struct crypto_aes_key * key, uint64_t nonce,
    const uint8_t * inbuf, uint8_t * outbuf, size_t buflen)
{
	struct crypto_aesctr stream_rec;
	struct crypto_aesctr * stream = &stream_rec;

	/* Sanity check. */
	assert(key != NULL);

	/* Initialize values. */
	crypto_aesctr_init2(stream, key, nonce);

	/* Perform the encryption. */
	crypto_aesctr_stream(stream, inbuf, outbuf, buflen);

	/* Zero potentially sensitive information. */
	insecure_memzero(stream, sizeof(struct crypto_aesctr));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
testq %rdi, %rdi
je 0x3fbb
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x3bee
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3cdb
leaq 0x6296(%rip), %rax      # 0xa238
movq (%rax), %rax
movl $0x30, %esi
movq %r12, %rdi
callq *%rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x28ab(%rip), %rdi      # 0x686d
leaq 0x28b0(%rip), %rsi      # 0x6879
leaq 0x296f(%rip), %rcx      # 0x693f
movl $0xed, %edx
callq 0x20a0
nop
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/liball/../crypto/crypto_aesctr_aesni.c
// Function: crypto_aesctr_aesni_stream
void
crypto_aesctr_aesni_stream(struct crypto_aesctr * stream, const uint8_t * inbuf,
    uint8_t * outbuf, size_t buflen)
{

	/* Process any bytes before we can process a whole block. */
	if (crypto_aesctr_stream_pre_wholeblock(stream, &inbuf, &outbuf,
	    &buflen))
		return;

	/* Process whole blocks of 16 bytes. */
	if (buflen >= 16)
		crypto_aesctr_aesni_stream_wholeblocks(stream, &inbuf,
		    &outbuf, &buflen);

	/* Process any final bytes after finishing all whole blocks. */
	crypto_aesctr_stream_post_wholeblock(stream, &inbuf, &outbuf, &buflen);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
movb $0x1, %al
andq $0xf, %rdx
je 0x4070
leaq (%rdx,%rbp), %rcx
cmpq $0x10, %rcx
ja 0x403e
testq %rbp, %rbp
je 0x402e
leaq (%rdx,%rbx), %rax
addq $0x10, %rax
xorl %ecx, %ecx
movb (%rax,%rcx), %dl
xorb (%r12,%rcx), %dl
movb %dl, (%r14,%rcx)
incq %rcx
cmpq %rcx, %rbp
jne 0x401b
addq %rbp, 0x8(%rbx)
addq %rbp, %r12
addq %rbp, %r14
xorl %ebp, %ebp
xorl %eax, %eax
jmp 0x4070
movl $0x10, %ecx
subq %rdx, %rcx
addq %rbx, %rdx
addq $0x10, %rdx
xorl %esi, %esi
movb (%rdx,%rsi), %dil
xorb (%r12,%rsi), %dil
movb %dil, (%r14,%rsi)
incq %rsi
cmpq %rsi, %rcx
jne 0x404f
addq %rcx, 0x8(%rbx)
addq %rcx, %r12
addq %rcx, %r14
subq %rcx, %rbp
testb %al, %al
je 0x417c
cmpq $0x10, %rbp
jb 0x40ed
movq 0x20(%rbx), %xmm0
movdqa %xmm0, 0x10(%rsp)
movq 0x8(%rbx), %r15
shrq $0x4, %r15
movq %rbp, 0x8(%rsp)
shrq $0x4, %rbp
movq %r15, %r13
bswapq %r13
movq %r13, %xmm1
movdqa 0x10(%rsp), %xmm0
punpcklqdq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0]
movq (%rbx), %rdi
callq 0x3b29
movdqu (%r12), %xmm1
pxor %xmm0, %xmm1
movdqu %xmm1, (%r14)
incq %r15
addq $0x10, %r12
addq $0x10, %r14
decq %rbp
jne 0x409a
movq 0x8(%rsp), %rbp
movq %rbp, %rax
andq $-0x10, %rax
andl $0xf, %ebp
movq %r13, 0x28(%rbx)
addq %rax, 0x8(%rbx)
testq %rbp, %rbp
je 0x417c
movq 0x8(%rbx), %rax
testb $0xf, %al
jne 0x418b
incb 0x2f(%rbx)
jne 0x414e
movl %eax, %ecx
shrl $0x4, %ecx
movb %cl, 0x2f(%rbx)
movl %eax, %ecx
shrl $0xc, %ecx
movb %cl, 0x2e(%rbx)
movl %eax, %ecx
shrl $0x14, %ecx
movb %cl, 0x2d(%rbx)
movq %rax, %rcx
shrq $0x1c, %rcx
movb %cl, 0x2c(%rbx)
movq %rax, %rcx
shrq $0x24, %rcx
movb %cl, 0x2b(%rbx)
movq %rax, %rcx
shrq $0x2c, %rcx
movb %cl, 0x2a(%rbx)
movq %rax, %rcx
shrq $0x34, %rcx
movb %cl, 0x29(%rbx)
shrq $0x3c, %rax
movb %al, 0x28(%rbx)
leaq 0x20(%rbx), %rdi
leaq 0x10(%rbx), %r13
movq (%rbx), %rdx
movq %r13, %rsi
callq 0x34bd
xorl %eax, %eax
movb (%r13,%rax), %cl
xorb (%r12,%rax), %cl
movb %cl, (%r14,%rax)
incq %rax
cmpq %rax, %rbp
jne 0x4163
addq %rbp, 0x8(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2829(%rip), %rdi      # 0x69bb
leaq 0x283c(%rip), %rsi      # 0x69d5
leaq 0x2856(%rip), %rcx      # 0x69f6
movl $0x15, %edx
callq 0x20a0
nop
// File: /workspace/github_c_makefile_star2_O1/vrancurel[P]ec/gf.c
// Function: setup_tables
int setup_tables()
{
  u_int b, log, x_to_w, prim_poly;

  switch(W) {
  case 4:  prim_poly = prim_poly_4;  break;
  case 8:  prim_poly = prim_poly_8;  break;
  case 16: prim_poly = prim_poly_16; break;
  default: return -1;
  }
  x_to_w = 1 << W;
  gflog  = (unsigned short *) xmalloc (sizeof(unsigned short) * x_to_w);
  gfilog = (unsigned short *) xmalloc (sizeof(unsigned short) * x_to_w);
  b = 1;
  for (log = 0; log < x_to_w-1; log++) {
    gflog[b] = (unsigned short) log;
    gfilog[log] = (unsigned short) b;
    b = b << 1;
    if (b & x_to_w) b = b ^ prim_poly;
  }
  return 0; 
}

// Assembly:
pushq %rbx
movl 0x3cf7(%rip), %ebx      # 0x50d0
movl $0x20, %edi
callq 0x2cfe
movq %rax, 0x3cfe(%rip)      # 0x50e8
movl $0x20, %edi
callq 0x2cfe
movq %rax, 0x3cf5(%rip)      # 0x50f0
movl $0x1, %ecx
xorl %edx, %edx
movq 0x3cdf(%rip), %rsi      # 0x50e8
movl %ecx, %edi
movw %dx, (%rsi,%rdi,2)
movw %cx, (%rax,%rdx,2)
leal (%rcx,%rcx), %edi
shll $0x1c, %ecx
sarl $0x1f, %ecx
andl %ebx, %ecx
xorl %edi, %ecx
incq %rdx
cmpq $0xf, %rdx
jne 0x1409
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/vrancurel[P]ec/gf.c
// Function: dump_tables
void dump_tables()
{
  u_int log, x_to_w;

  x_to_w = 1 << W;
  for (log = 0; log < x_to_w-1; log++) {
    printf("%d ", gflog[log]);
  }
  printf("\n");
  for (log = 0; log < x_to_w-1; log++) {
    printf("%d ", gfilog[log]);
  }
  printf("\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x1bcc(%rip), %rbx      # 0x3004
xorl %r14d, %r14d
movq 0x3ca6(%rip), %rax      # 0x50e8
movzwl (%rax,%r14,2), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1070
incq %r14
cmpq $0xf, %r14
jne 0x143b
movl $0xa, %edi
callq 0x1040
leaq 0x1b99(%rip), %rbx      # 0x3004
xorl %r14d, %r14d
movq 0x3c7b(%rip), %rax      # 0x50f0
movzwl (%rax,%r14,2), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1070
incq %r14
cmpq $0xf, %r14
jne 0x146e
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/vrancurel[P]ec/gf.c
// Function: gmul
int gmul(int a, int b)
{
  int sum_log;
  if (a == 0 || b == 0) return 0;
  sum_log = gflog[a] + gflog[b];
  if (sum_log >= NW-1) sum_log -= NW-1;
  return gfilog[sum_log];
}

// Assembly:
testl %edi, %edi
sete %cl
testl %esi, %esi
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x14db
movq 0x3c33(%rip), %rax      # 0x50e8
movslq %edi, %rcx
movzwl (%rax,%rcx,2), %ecx
movslq %esi, %rdx
movzwl (%rax,%rdx,2), %eax
leal (%rax,%rcx), %edx
cmpl $0xf, %edx
leal -0xf(%rax,%rcx), %eax
cmovbl %edx, %eax
movq 0x3c19(%rip), %rcx      # 0x50f0
movzwl (%rcx,%rax,2), %eax
retq
// File: /workspace/github_c_makefile_star2_O1/vrancurel[P]ec/gf.c
// Function: gdiv
int gdiv(int a, int b)
{
  int diff_log;
  if (a == 0) return 0;
  if (b == 0) return -1;
  diff_log = gflog[a] - gflog[b];
  if (diff_log < 0) diff_log += NW-1;
  return gfilog[diff_log];
}

// Assembly:
testl %edi, %edi
je 0x1511
testl %esi, %esi
je 0x1514
movq 0x3bfd(%rip), %rax      # 0x50e8
movslq %edi, %rcx
movzwl (%rax,%rcx,2), %ecx
movslq %esi, %rdx
movzwl (%rax,%rdx,2), %eax
subl %eax, %ecx
leal 0xf(%rcx), %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
movq 0x3be6(%rip), %rcx      # 0x50f0
cltq
movzwl (%rcx,%rax,2), %eax
retq
xorl %eax, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/vrancurel[P]ec/gf.c
// Function: gpow
int gpow(int a, int b)
{
  int r, i;

  if (0 == b)
    return 1;

  if (1 == b)
    return a;

  r = a;
  for (i = 1; i < b;i++) {
    r = gmul(r, a);
  }

  return r;
}

// Assembly:
testl %esi, %esi
je 0x1573
cmpl $0x1, %esi
je 0x1570
jle 0x1570
movq 0x3bbc(%rip), %rcx      # 0x50e8
movslq %edi, %rdx
movq 0x3bba(%rip), %r8       # 0x50f0
decl %esi
movl %edi, %r9d
xorl %eax, %eax
testl %edi, %edi
je 0x1568
testl %r9d, %r9d
je 0x1568
movslq %r9d, %rax
movzwl (%rcx,%rax,2), %eax
movzwl (%rcx,%rdx,2), %r9d
leal (%r9,%rax), %r10d
cmpl $0xf, %r10d
leal -0xf(%r9,%rax), %eax
cmovbl %r10d, %eax
movzwl (%r8,%rax,2), %eax
movl %eax, %r9d
decl %esi
jne 0x153b
retq
movl %edi, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/vrancurel[P]ec/mat.c
// Function: mat_xcalloc
t_mat *mat_xcalloc(u_int n_rows, u_int n_cols)
{
  t_mat *mat;

  mat = xmalloc(sizeof (*mat));
  mat->n_rows = n_rows;
  mat->n_cols = n_cols;
  mat->mem = xmalloc(sizeof (int) * n_rows * n_cols);
  mat_zero(mat);
  return mat;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movl %edi, %r14d
movl $0x10, %edi
callq 0x2cfe
movq %rax, %rbx
movl %r14d, (%rax)
movl %ebp, 0x4(%rax)
movl %r14d, %eax
movl %ebp, %edi
imulq %rax, %rdi
shlq $0x2, %rdi
callq 0x2cfe
movq %rax, 0x8(%rbx)
movl (%rbx), %ecx
movl 0x4(%rbx), %edx
imulq %rcx, %rdx
shlq $0x2, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x10a0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vrancurel[P]ec/mat.c
// Function: mat_dump
void mat_dump(t_mat *mat)
{
  int i, j;
  
  for (i = 0;i < mat->n_rows;i++) {
    for (j = 0;j < mat->n_cols;j++) {
      printf("%d ", MAT_ITEM(mat, i, j));
    }
    printf("\n");
  }
}

// Assembly:
cmpl $0x0, (%rdi)
je 0x24c2
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb8a(%rip), %r14       # 0x3004
xorl %ebp, %ebp
movl 0x4(%rbx), %eax
testl %eax, %eax
je 0x24a8
xorl %r15d, %r15d
movq 0x8(%rbx), %rcx
imull %ebp, %eax
addl %r15d, %eax
movl (%rcx,%rax,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1070
incl %r15d
movl 0x4(%rbx), %eax
cmpl %eax, %r15d
jb 0x2486
movl $0xa, %edi
callq 0x1040
incl %ebp
cmpl (%rbx), %ebp
jb 0x247c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vrancurel[P]ec/mat.c
// Function: mat_vandermonde
t_mat *mat_vandermonde(u_int n_rows, u_int n_cols)
{
  t_mat *mat;
  int i, j;
  
  mat = mat_xcalloc(n_rows, n_cols);
  for (i = 0;i < n_rows;i++) {
    for (j = 0;j < n_cols;j++) {
      MAT_ITEM(mat, i, j) = gpow(j + 1, i); 
    }
  }
  return mat;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
callq 0x23f7
movq %rax, %r14
testl %ebp, %ebp
je 0x2519
xorl %r15d, %r15d
testl %ebx, %ebx
je 0x2511
xorl %r13d, %r13d
leal 0x1(%r13), %r12d
movl %r12d, %edi
movl %r15d, %esi
callq 0x151a
movq 0x8(%r14), %rcx
movl 0x4(%r14), %edx
imull %r15d, %edx
addl %r13d, %edx
movl %eax, (%rcx,%rdx,4)
movl %r12d, %r13d
cmpl %r12d, %ebx
jne 0x24e8
incl %r15d
cmpl %ebp, %r15d
jne 0x24e1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vrancurel[P]ec/mat.c
// Function: mat_cauchy
t_mat *mat_cauchy(u_int n_rows, u_int n_cols)
{
  t_mat *mat;
  int i, j;

  mat = mat_xcalloc(n_rows, n_cols);
  for (i = 0;i < n_rows;i++) {
    for (j = 0;j < n_cols;j++) {
      MAT_ITEM(mat, i, j) = gdiv(1, (i ^ (j + n_rows)));
    }
  }

  /* do optimise */
  // convert 1st row to all 1s
  for (j = 0;j < n_cols;j++) {
    for (i = 0;i < n_rows;i++) {
      MAT_ITEM(mat, i, j) = gdiv(MAT_ITEM(mat, i, j), MAT_ITEM(mat, 0, j));
    }
  }
  // convert 1st element of each row to 1
  for (i = 1;i < n_rows;i++) {
    for (j = 0;j < n_cols;j++) {
      MAT_ITEM(mat, i, j) = gdiv(MAT_ITEM(mat, i, j), MAT_ITEM(mat, i, 0));
    }
  }

  return mat;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %r14d
callq 0x23f7
movq %rax, %r15
testl %r14d, %r14d
je 0x2581
xorl %ebp, %ebp
testl %ebx, %ebx
je 0x257a
xorl %r12d, %r12d
leal (%r14,%r12), %esi
xorl %ebp, %esi
movl $0x1, %edi
callq 0x14dc
movq 0x8(%r15), %rcx
movl 0x4(%r15), %edx
imull %ebp, %edx
addl %r12d, %edx
movl %eax, (%rcx,%rdx,4)
incl %r12d
cmpl %r12d, %ebx
jne 0x2551
incl %ebp
cmpl %r14d, %ebp
jne 0x254a
testl %ebx, %ebx
je 0x25cc
movl %ebx, %r12d
xorl %r13d, %r13d
testl %r14d, %r14d
je 0x25c4
xorl %ebp, %ebp
movq 0x8(%r15), %rax
movl 0x4(%r15), %ecx
imull %ebp, %ecx
addl %r13d, %ecx
movl (%rax,%rcx,4), %edi
movl (%rax,%r13,4), %esi
callq 0x14dc
movq 0x8(%r15), %rcx
movl 0x4(%r15), %edx
imull %ebp, %edx
addl %r13d, %edx
movl %eax, (%rcx,%rdx,4)
incl %ebp
cmpl %ebp, %r14d
jne 0x2592
incq %r13
cmpq %r12, %r13
jne 0x258b
cmpl $0x2, %r14d
jb 0x2618
movl $0x1, %ebp
testl %ebx, %ebx
je 0x2611
xorl %r12d, %r12d
movq 0x8(%r15), %rax
movl 0x4(%r15), %ecx
imull %ebp, %ecx
leal (%r12,%rcx), %edx
movl (%rax,%rdx,4), %edi
movl (%rax,%rcx,4), %esi
callq 0x14dc
movq 0x8(%r15), %rcx
movl 0x4(%r15), %edx
imull %ebp, %edx
addl %r12d, %edx
movl %eax, (%rcx,%rdx,4)
incl %r12d
cmpl %r12d, %ebx
jne 0x25de
incl %ebp
cmpl %r14d, %ebp
jne 0x25d7
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vrancurel[P]ec/mat.c
// Function: mat_check_row_is_identity
int mat_check_row_is_identity(t_mat *mat, int row)
{
  int j;

  for (j = 0;j < mat->n_cols;j++) {
    if (MAT_ITEM(mat, row, j) != ((j == row) ? 1 : 0))
      return 0;
  }
  return 1;
}

// Assembly:
movl 0x4(%rdi), %ecx
movl $0x1, %eax
testq %rcx, %rcx
je 0x2661
movq 0x8(%rdi), %rdx
movl %ecx, %edi
imull %esi, %edi
movl %esi, %esi
xorl %r8d, %r8d
leal (%rdi,%r8), %r9d
xorl %r10d, %r10d
cmpq %r8, %rsi
sete %r10b
cmpl %r10d, (%rdx,%r9,4)
jne 0x2662
incq %r8
cmpq %r8, %rcx
jne 0x2645
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/vrancurel[P]ec/mat.c
// Function: mat_swap_cols
void mat_swap_cols(t_mat *mat, int c1, int c2)
{
  int i;

  assert(c1 < mat->n_cols && c2 < mat->n_cols);
  for (i = 0;i < mat->n_rows;i++) {
    int val = MAT_ITEM(mat, i, c1);
    MAT_ITEM(mat, i, c1) = MAT_ITEM(mat, i, c2);
    MAT_ITEM(mat, i, c2) = val;
  }
}

// Assembly:
pushq %rax
movl 0x4(%rdi), %eax
cmpl %esi, %eax
jbe 0x26ae
cmpl %edx, %eax
jbe 0x26ae
cmpl $0x0, (%rdi)
je 0x26ac
movq 0x8(%rdi), %rax
xorl %ecx, %ecx
movl 0x4(%rdi), %r8d
imull %ecx, %r8d
leal (%r8,%rsi), %r9d
movl (%rax,%r9,4), %r10d
addl %edx, %r8d
movl (%rax,%r8,4), %r8d
movl %r8d, (%rax,%r9,4)
movl 0x4(%rdi), %r8d
imull %ecx, %r8d
addl %edx, %r8d
movl %r10d, (%rax,%r8,4)
incl %ecx
cmpl (%rdi), %ecx
jb 0x267c
popq %rax
retq
leaq 0xc56(%rip), %rdi       # 0x330b
leaq 0xc74(%rip), %rsi       # 0x3330
leaq 0xc73(%rip), %rcx       # 0x3336
movl $0x63, %edx
callq 0x1090
// File: /workspace/github_c_makefile_star2_O1/vrancurel[P]ec/mat.c
// Function: mat_transform1
void mat_transform1(t_mat *tmp, int i)
{
  int k;
  int f_minus_1 = gdiv(1, MAT_ITEM(tmp, i, i));

  for (k = 0;k < tmp->n_rows;k++) {
    MAT_ITEM(tmp, k, i) = gmul(f_minus_1, MAT_ITEM(tmp, k, i));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movl 0x4(%rdi), %ecx
incl %ecx
imull %esi, %ecx
movl (%rax,%rcx,4), %esi
movl $0x1, %edi
callq 0x14dc
cmpl $0x0, (%r14)
je 0x272e
movl %eax, %ebp
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movl 0x4(%r14), %ecx
imull %r15d, %ecx
addl %ebx, %ecx
movl (%rax,%rcx,4), %esi
movl %ebp, %edi
callq 0x149e
movq 0x8(%r14), %rcx
movl 0x4(%r14), %edx
imull %r15d, %edx
addl %ebx, %edx
movl %eax, (%rcx,%rdx,4)
incl %r15d
cmpl (%r14), %r15d
jb 0x26fd
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vrancurel[P]ec/mat.c
// Function: mat_mult
void mat_mult(t_vec *output, t_mat *a, t_vec *b)
{
  int i, j;

  assert(output->n == b->n);
  assert(output->n == a->n_cols);
  for (i = 0;i < a->n_rows;i++) {
    for (j = 0;j < a->n_cols;j++) {
      int x = gmul(MAT_ITEM(a, i, j), VEC_ITEM(b, j));
      if (0 == j)
        VEC_ITEM(output, i) = x;
      else
        VEC_ITEM(output, i) ^= x;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl (%rdi), %eax
cmpl (%rdx), %eax
jne 0x2c41
movq %rsi, %r14
cmpl 0x4(%rsi), %eax
jne 0x2c60
cmpl $0x0, (%r14)
je 0x2c37
movq %rdx, %rbx
movq %rdi, %r15
xorl %r12d, %r12d
movl 0x4(%r14), %eax
testl %eax, %eax
je 0x2c2c
xorl %r13d, %r13d
movq 0x8(%r14), %rcx
imull %r12d, %eax
addl %r13d, %eax
movl (%rcx,%rax,4), %edi
movq 0x8(%rbx), %rax
movl (%rax,%r13,4), %esi
callq 0x149e
testq %r13, %r13
je 0x2c18
movq 0x8(%r15), %rcx
xorl %eax, (%rcx,%r12,4)
jmp 0x2c20
movq 0x8(%r15), %rcx
movl %eax, (%rcx,%r12,4)
incq %r13
movl 0x4(%r14), %eax
cmpq %rax, %r13
jb 0x2bee
incq %r12
movl (%r14), %eax
cmpq %rax, %r12
jb 0x2be3
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x745(%rip), %rdi       # 0x338d
leaq 0x6e1(%rip), %rsi       # 0x3330
leaq 0x749(%rip), %rcx       # 0x339f
movl $0x10b, %edx            # imm = 0x10B
callq 0x1090
leaq 0x761(%rip), %rdi       # 0x33c8
leaq 0x6c2(%rip), %rsi       # 0x3330
leaq 0x72a(%rip), %rcx       # 0x339f
movl $0x10c, %edx            # imm = 0x10C
callq 0x1090
nop
// File: /workspace/github_c_makefile_star2_O1/vrancurel[P]ec/vec.c
// Function: vec_xcalloc
t_vec *vec_xcalloc(u_int n)
{
  t_vec *vec;

  vec = xmalloc(sizeof (*vec));
  vec->n = n;
  vec->mem = xmalloc(sizeof (int) * n);
  vec_zero(vec);
  return vec;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x10, %edi
callq 0x2cfe
movq %rax, %r14
movl %ebx, (%rax)
movl %ebx, %edi
shlq $0x2, %rdi
callq 0x2cfe
movq %rax, 0x8(%r14)
movl (%r14), %edx
shlq $0x2, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x10a0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/igaw[P]jitterdebugger/jd_utils.c
// Function: ringbuffer_create
struct ringbuffer *ringbuffer_create(unsigned int size)
{
	struct ringbuffer *rb;

	/* Size needs to be of power of 2 */
	if ((size & (size - 1)) != 0)
		return NULL;

	rb = calloc(1, sizeof(*rb));
	if (!rb)
		return NULL;

	rb->size = size;
	rb->data = calloc(rb->size, sizeof(struct ringbuffer_sample));

	return rb;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %r14d
leal -0x1(%r14), %eax
testl %eax, %edi
jne 0x2558
movl $0x1, %edi
movl $0x18, %esi
callq 0x2140
testq %rax, %rax
je 0x2558
movq %rax, %rbx
movl %r14d, (%rax)
movl %r14d, %edi
movl $0x18, %esi
callq 0x2140
movq %rax, 0x10(%rbx)
jmp 0x255a
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/igaw[P]jitterdebugger/jd_utils.c
// Function: ringbuffer_write
int ringbuffer_write(struct ringbuffer *rb, struct timespec ts, uint64_t val)
{
	uint32_t read, idx;

	read = READ_ONCE(rb->read);
	if (ringbuffer_full(rb->size, read, rb->write)) {
		rb->overflow++;
		return 1;
	}

	idx = ringbuffer_mask(rb->size, rb->write + 1);
	rb->data[idx].ts = ts;
	rb->data[idx].val = val;

	WRITE_ONCE(rb->write, rb->write + 1);
	return 0;
}

// Assembly:
movl (%rdi), %r8d
movl 0xc(%rdi), %eax
movl %eax, %r9d
subl 0x8(%rdi), %r9d
cmpl %r8d, %r9d
jne 0x2596
incl 0x4(%rdi)
movl $0x1, %eax
retq
incl %eax
decl %r8d
andl %eax, %r8d
movq 0x10(%rdi), %r9
leaq (%r8,%r8,2), %r8
movq %rsi, (%r9,%r8,8)
movq %rdx, 0x8(%r9,%r8,8)
movq %rcx, 0x10(%r9,%r8,8)
movl %eax, 0xc(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/igaw[P]jitterdebugger/jd_utils.c
// Function: ringbuffer_read
int ringbuffer_read(struct ringbuffer *rb, struct timespec *ts, uint64_t *val)
{
	uint32_t write, idx;

	write = READ_ONCE(rb->write);
	if (ringbuffer_empty(rb->read, write))
		return 1;

	idx = ringbuffer_mask(rb->size, rb->read + 1);
	*ts = rb->data[idx].ts;
	*val = rb->data[idx].val;

	WRITE_ONCE(rb->read, rb->read + 1);
	return 0;
}

// Assembly:
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %r8d
movl $0x1, %eax
cmpl %ecx, %r8d
je 0x25f7
movl (%rdi), %eax
incl %ecx
decl %eax
andl %ecx, %eax
movq 0x10(%rdi), %rcx
shlq $0x3, %rax
leaq (%rax,%rax,2), %rax
movups (%rcx,%rax), %xmm0
movups %xmm0, (%rsi)
movq 0x10(%rdi), %rcx
movq 0x10(%rcx,%rax), %rax
movq %rax, (%rdx)
incl 0x8(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/igaw[P]jitterdebugger/jd_utils.c
// Function: err_handler
void _err_handler(int error, char *fmt, ...)
{
	va_list ap;
	char *msg;

	va_start(ap, fmt);
	vasprintf(&msg, fmt, ap);
	va_end(ap);

	fprintf(stderr, "%s: %s\n", msg, strerror(error));

	free(msg);
	exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %edi, %ebx
leaq 0x30(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x265b
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %rdi, 0x10(%rdx)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x20b0
movq 0x3967(%rip), %rax      # 0x5ff8
movq (%rax), %r15
movq (%r14), %r12
movl %ebx, %edi
callq 0x2260
leaq 0x195f(%rip), %rsi      # 0x4004
movq %r15, %rdi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2160
movq (%r14), %rdi
callq 0x2030
movl $0x1, %edi
callq 0x2220
// File: /workspace/github_c_makefile_star2_O1/igaw[P]jitterdebugger/jd_utils.c
// Function: parse_num
long int parse_num(const char *str, int base, size_t *len)
{
	long int ret;
	char *endptr;

	errno = 0;
	ret = strtol(str, &endptr, base);
	if (errno)
		return -errno;
	if (ret < 0)
		return -ERANGE;

	if (len)
		*len = endptr - str;

	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x2050
movq %rax, %r15
movl $0x0, (%rax)
movq %rsp, %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x2180
movslq (%r15), %rcx
testq %rcx, %rcx
je 0x27a2
negq %rcx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testq %rax, %rax
js 0x27b8
testq %rbx, %rbx
je 0x2797
movq (%rsp), %rcx
subq %r14, %rcx
movq %rcx, (%rbx)
jmp 0x2797
movq $-0x22, %rax
jmp 0x2797
// File: /workspace/github_c_makefile_star2_O1/igaw[P]jitterdebugger/jd_utils.c
// Function: parse_time
long int parse_time(const char *str)
{
	long int t;
	char *end;

	t = strtol(str, &end, 10);

	if (!(strlen(end) == 0 || strlen(end) == 1))
		return -EINVAL;

	if (end) {
		switch (*end) {
		case 's':
		case 'S':
			break;
		case 'm':
		case 'M':
			t *= 60;
			break;

		case 'h':
		case 'H':
			t *= 60 * 60;
			break;

		case 'd':
		case 'D':
			t *= 24 * 60 * 60;
			break;
		default:
			return -EINVAL;
		}
	}

	return t;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsp, %r14
movq %r14, %rsi
movl $0xa, %edx
callq 0x2180
movq %rax, %rbx
movq (%r14), %r14
movq %r14, %rdi
callq 0x20e0
movq %rax, %rcx
movq $-0x16, %rax
cmpq $0x1, %rcx
ja 0x2852
testq %r14, %r14
je 0x2846
movzbl (%r14), %ecx
cmpl $0x63, %ecx
jg 0x2812
cmpl $0x4c, %ecx
jg 0x282a
cmpl $0x44, %ecx
je 0x284b
cmpl $0x48, %ecx
je 0x2821
jmp 0x2852
cmpl $0x6c, %ecx
jg 0x2836
cmpl $0x64, %ecx
je 0x284b
cmpl $0x68, %ecx
jne 0x2852
imulq $0xe10, %rbx, %rax      # imm = 0xE10
jmp 0x2852
cmpl $0x4d, %ecx
je 0x2840
cmpl $0x53, %ecx
je 0x2846
jmp 0x2852
cmpl $0x73, %ecx
je 0x2846
cmpl $0x6d, %ecx
jne 0x2852
imulq $0x3c, %rbx, %rax
jmp 0x2852
movq %rbx, %rax
jmp 0x2852
imulq $0x15180, %rbx, %rax    # imm = 0x15180
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/igaw[P]jitterdebugger/jd_utils.c
// Function: cpuset_fprint
void cpuset_fprint(FILE *f, cpu_set_t *set)
{
	unsigned long bit = 0, range = 0;
	unsigned long i, t, comma = 0;

	for (i = 0, t = 0; t < (unsigned) CPU_COUNT(set); t += bit, i++) {
		bit = CPU_ISSET(i, set);
		if (!range && bit) {
			if (comma)
				fputc(',', f);

			comma = 1;
			fprintf(f, "%lu", i);
		} else if (!bit) {
			_cpuset_fprint_end(f, i, range);
			range = 0;
		}
		range += bit;
	}

	_cpuset_fprint_end(f, i, range);
	fprintf(f, " = %u [0x%lX]", CPU_COUNT(set), cpuset_to_bits(set));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, (%rsp)
movl $0x80, %edi
callq 0x20d0
movq $-0x1, %r15
xorl %ebx, %ebx
testl %eax, %eax
je 0x2945
xorl %r13d, %r13d
xorl %ebp, %ebp
movq %r15, %rcx
incq %r15
cmpq $0x3ff, %r15            # imm = 0x3FF
ja 0x28b3
movq %r15, %rax
shrq $0x6, %rax
movq (%r14,%rax,8), %rax
xorl %r12d, %r12d
btq %r15, %rax
setb %r12b
jmp 0x28b6
xorl %r12d, %r12d
testq %rbx, %rbx
sete %al
testq %r12, %r12
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x28fd
testq %r13, %r13
movq (%rsp), %rbx
je 0x28df
movl $0x2c, %edi
movq %rbx, %rsi
callq 0x2120
movq %rbx, %rdi
leaq 0x1818(%rip), %rsi      # 0x4101
movq %r15, %rdx
xorl %eax, %eax
callq 0x2160
movl $0x1, %r13d
xorl %ebx, %ebx
jmp 0x2902
testq %r12, %r12
je 0x2922
addq %r12, %rbx
addq %r12, %rbp
movl $0x80, %edi
movq %r14, %rsi
callq 0x20d0
movl %eax, %eax
cmpq %rax, %rbp
jb 0x288c
jmp 0x2945
cmpq $0x2, %rbx
jb 0x28f9
sete %al
movzbl %al, %edx
xorl $0x2d, %edx
movq (%rsp), %rdi
leaq 0x17c3(%rip), %rsi      # 0x40ff
xorl %eax, %eax
callq 0x2160
jmp 0x28f9
cmpq $0x2, %rbx
movq (%rsp), %r13
jb 0x296c
sete %al
movzbl %al, %edx
xorl $0x2d, %edx
leaq 0x17a0(%rip), %rsi      # 0x40ff
movq %r13, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x2160
movl $0x80, %edi
movq %r14, %rsi
callq 0x20d0
movl %eax, %ebp
movl $0x80, %edi
movq %r14, %rsi
callq 0x20d0
xorl %r12d, %r12d
xorl %r15d, %r15d
testl %eax, %eax
je 0x29d0
xorl %ebx, %ebx
xorl %eax, %eax
cmpl $0x3ff, %r12d           # imm = 0x3FF
ja 0x29b2
movl %r12d, %eax
shrl $0x6, %eax
movq (%r14,%rax,8), %rcx
xorl %eax, %eax
btq %r12, %rcx
setb %al
addl %eax, %ebx
movl %r12d, %ecx
shll %cl, %eax
orq %rax, %r15
incl %r12d
movl $0x80, %edi
movq %r14, %rsi
callq 0x20d0
cmpl %eax, %ebx
jb 0x2994
leaq 0x1635(%rip), %rsi      # 0x400c
movq %r13, %rdi
movl %ebp, %edx
movq %r15, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2160
// File: /workspace/github_c_makefile_star2_O1/igaw[P]jitterdebugger/jd_utils.c
// Function: cpuset_parse
ssize_t cpuset_parse(cpu_set_t *set, const char *str)
{
	unsigned int i, first, last;
	ssize_t len_next;
	long int num = 0;
	size_t len = 0;

	if (!strncmp(str, "0x", 2)) {
		num = _cpuset_parse_num(str, 16, &len);
		cpuset_from_bits(set, (unsigned long) num);
		return len;
	}

	num = _cpuset_parse_num(str, 10, &len);

	str += len;
	first = num;

	if (str[0] == '-') {
		num = _cpuset_parse_num(str + 1, 10, &len);
		str += 1 + len;
		last = len ? num + 1 : CPU_SETSIZE; /* "x-" means x-CPU_SIZE */
	} else
		last = first + 1;

	if (CPU_SETSIZE < last) {
		warn_handler("cpu num %d bigger than CPU_SETSIZE(%u), reducing",
			     last, CPU_SETSIZE);
		last = CPU_SETSIZE;
	}

	for (i = first; i < last; i++)
		CPU_SET(i, set);

	if (str[0] == ',') {
		len_next = cpuset_parse(set, str + 1);
		if (len_next < 0)
			return len_next;

		len += len_next;
	}

	return len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
movq $0x0, (%rsp)
leaq 0x1609(%rip), %rsi      # 0x401a
movl $0x2, %edx
movq %r12, %rdi
callq 0x2060
testl %eax, %eax
je 0x2a73
movq %rsp, %r14
movq %r12, %rdi
movl $0xa, %esi
movq %r14, %rdx
callq 0x2b28
movq %rax, %r15
movq (%r14), %rax
leaq (%r12,%rax), %r14
cmpb $0x2d, (%r12,%rax)
jne 0x2aa1
leaq 0x1(%r14), %rdi
movq %rsp, %r12
movl $0xa, %esi
movq %r12, %rdx
callq 0x2b28
movq (%r12), %rcx
addq %rcx, %r14
incq %r14
incl %eax
testq %rcx, %rcx
movl $0x400, %ecx            # imm = 0x400
cmovnel %eax, %ecx
jmp 0x2aa5
movq %rsp, %rdx
movq %r12, %rdi
movl $0x10, %esi
callq 0x2b28
xorl %ecx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
btq %rcx, %rax
jae 0x2a96
orq %rdx, (%rbx)
incq %rcx
cmpq $0x40, %rcx
jne 0x2a85
jmp 0x2b18
leal 0x1(%r15), %ecx
cmpl $0x401, %ecx            # imm = 0x401
jb 0x2ad4
leaq 0x1569(%rip), %rdi      # 0x401d
leaq 0x159d(%rip), %rsi      # 0x4058
leaq 0x15a1(%rip), %rdx      # 0x4063
movl $0x400, %r8d            # imm = 0x400
xorl %eax, %eax
callq 0x26c7
movl $0x400, %ecx            # imm = 0x400
cmpl %r15d, %ecx
jbe 0x2afb
movl %r15d, %eax
movl %ecx, %edx
movl $0x1, %esi
movl %eax, %ecx
shlq %cl, %rsi
movq %rax, %rcx
shrq $0x6, %rcx
orq %rsi, (%rbx,%rcx,8)
incq %rax
cmpq %rax, %rdx
jne 0x2ade
cmpb $0x2c, (%r14)
jne 0x2b18
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29f4
testq %rax, %rax
js 0x2b1c
addq %rax, (%rsp)
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/igaw[P]jitterdebugger/jd_utils.c
// Function: cpuset_parse_num
static long int _cpuset_parse_num(const char *str, int base, size_t *len)
{
	long int ret;

	ret = parse_num(str, base, len);
	if (ret < 0)
		err_abort("cpuset: unable to parse string %s", str);

	return ret;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x275f
testq %rax, %rax
js 0x2b38
popq %rbx
retq
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_c_makefile_star2_O1/igaw[P]jitterdebugger/jd_utils.c
// Function: sysfs_load_str
int sysfs_load_str(const char *path, char **buf)
{
	int fd, ret;
	size_t len;

	fd = TEMP_FAILURE_RETRY(open(path, O_RDONLY));
	if (fd < 0)
		return -errno;

	len = sysconf(_SC_PAGESIZE);

	*buf = malloc(len);
	if (!*buf) {
		ret = -ENOMEM;
		goto out_fd;
	}

	ret = read(fd, *buf, len - 1);
	if (ret < 0) {
		ret = -errno;
		goto out_buf;
	}

	(*buf)[ret] = 0;
out_buf:
	if (ret < 0)
		free(*buf);
out_fd:
	close(fd);
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x21d0
movl %eax, %ebx
cmpl $-0x1, %eax
jne 0x2b68
callq 0x2050
cmpl $0x4, (%rax)
je 0x2b4b
testl %ebx, %ebx
js 0x2bb3
movl $0x1e, %edi
callq 0x2200
movq %rax, %r15
movq %rax, %rdi
callq 0x2190
movq %rax, (%r14)
testq %rax, %rax
je 0x2bc0
decq %r15
movl %ebx, %edi
movq %rax, %rsi
movq %r15, %rdx
callq 0x2130
movq %rax, %r15
testl %r15d, %r15d
js 0x2bc8
movq (%r14), %rax
movl %r15d, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movb $0x0, (%rax,%rcx)
jmp 0x2bd3
callq 0x2050
xorl %r15d, %r15d
subl (%rax), %r15d
jmp 0x2be7
movl $0xfffffff4, %r15d      # imm = 0xFFFFFFF4
jmp 0x2be0
callq 0x2050
xorl %r15d, %r15d
subl (%rax), %r15d
testl %r15d, %r15d
jns 0x2be0
movq (%r14), %rdi
callq 0x2030
movl %ebx, %edi
callq 0x2110
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq