LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x69b0(%rip), %rdi      # 0x9c4f
movb $0x0, %al
callq 0x2030
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x32e0
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x5eed(%rip), %rdi      # 0x91b8
movb $0x0, %al
callq 0x2030
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x32ae
leaq 0x5dd7(%rip), %rdi      # 0x90be
movb $0x0, %al
callq 0x2030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
cmpl $0x2, 0x9bf5(%rip)      # 0xd120
je 0x3532
jmp 0x35b5
movl $0x0, 0x9be4(%rip)      # 0xd120
callq 0x3750
cmpl $0x0, %eax
je 0x3582
leaq 0x363(%rip), %rdi       # 0x38b0
callq 0x37c0
cmpl $0x0, %eax
jne 0x3563
movl $0x1, 0x9bbf(%rip)      # 0xd120
jmp 0x35b5
jmp 0x3565
leaq 0x6214(%rip), %rdi      # 0x9780
movb $0x0, %al
callq 0x7b30
callq 0x2170
movl $0x0, (%rax)
jmp 0x3580
jmp 0x3582
jmp 0x3584
leaq 0x395(%rip), %rdi       # 0x3920
callq 0x37c0
cmpl $0x0, %eax
je 0x35b5
jmp 0x3597
leaq 0x6211(%rip), %rdi      # 0x97af
movb $0x0, %al
callq 0x7b30
callq 0x2170
movl $0x0, (%rax)
callq 0x2060
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x10, -0x18(%rbp)
je 0x35de
cmpq $0x20, -0x18(%rbp)
jne 0x35e0
jmp 0x35ff
leaq 0x6121(%rip), %rdi      # 0x9708
leaq 0x6135(%rip), %rsi      # 0x9723
movl $0xf1, %edx
leaq 0x6140(%rip), %rcx      # 0x973a
callq 0x2090
callq 0x3520
cmpl $0x1, 0x9b15(%rip)      # 0xd120
jne 0x3620
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x39e0
movq %rax, -0x8(%rbp)
jmp 0x366f
movl $0xf4, %edi
callq 0x20b0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x3636
jmp 0x3667
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
shlq $0x3, %rax
movl %eax, %esi
movq -0x20(%rbp), %rdx
callq 0x2210
cmpl $0x0, %eax
je 0x3654
jmp 0x365e
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x366f
movq -0x20(%rbp), %rdi
callq 0x2100
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x2, -0x38(%rbp)
jae 0x388d
leaq 0x994a(%rip), %rax      # 0xd130
imulq $0x48, -0x38(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x10, 0x20(%rax)
je 0x3808
movq -0x18(%rbp), %rax
cmpq $0x20, 0x20(%rax)
jne 0x380a
jmp 0x3829
leaq 0x5fc2(%rip), %rdi      # 0x97d3
leaq 0x5f0b(%rip), %rsi      # 0x9723
movl $0x54, %edx
leaq 0x5fe0(%rip), %rcx      # 0x9804
callq 0x2090
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq 0x20(%rcx), %rsi
movq -0x18(%rbp), %rdx
addq $0x28, %rdx
leaq -0x30(%rbp), %rcx
callq *%rax
cmpl $0x0, %eax
je 0x384e
jmp 0x3896
movq -0x18(%rbp), %rax
addq $0x38, %rax
leaq -0x30(%rbp), %rcx
movups (%rcx), %xmm1
movups (%rax), %xmm0
pcmpeqb %xmm1, %xmm0
pmovmskb %xmm0, %eax
subl $0xffff, %eax           # imm = 0xFFFF
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x387a
jmp 0x3896
jmp 0x387c
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x37d4
movl $0x0, -0x4(%rbp)
jmp 0x389d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x39e0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x38e1
jmp 0x3904
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x5610
movq -0x30(%rbp), %rdi
callq 0x5680
movl $0x0, -0x4(%rbp)
jmp 0x390b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq -0x11c(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
shlq $0x3, %rax
movl %eax, %esi
movq -0x128(%rbp), %rdx
callq 0x2210
cmpl $0x0, %eax
je 0x396a
jmp 0x3998
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x128(%rbp), %rdx
callq 0x2130
movq -0x128(%rbp), %rdi
movl $0xf4, %esi
callq 0x3720
movl $0x0, -0x4(%rbp)
jmp 0x399f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/liball/../crypto/crypto_aes_aesni.c
// Function: crypto_aes_key_expand_aesni
void *
crypto_aes_key_expand_aesni(const uint8_t * key_unexpanded, size_t len)
{
	struct crypto_aes_key_aesni * kexp;

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

	/* Figure out where to put the round keys. */
	ALIGN_PTR_INIT(kexp->rkeys, sizeof(__m128i));

	/* Compute round keys. */
	if (len == 16) {
		kexp->nr = 10;
		crypto_aes_key_expand_128_aesni(key_unexpanded, kexp->rkeys);
	} else if (len == 32) {
		kexp->nr = 14;
		crypto_aes_key_expand_256_aesni(key_unexpanded, kexp->rkeys);
	} else {
		warn0("Unsupported AES key length: %zu bytes", len);
		goto err1;
	}

	/* Success! */
	return (kexp);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x110, %edi            # imm = 0x110
callq 0x20b0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x3a09
jmp 0x3ab3
movq -0x20(%rbp), %rdi
movl $0x10, %esi
callq 0x3ad0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x100(%rax)
cmpq $0x10, -0x18(%rbp)
jne 0x3a51
movq -0x20(%rbp), %rax
movq $0xa, 0x108(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x100(%rax), %rsi
callq 0x3b10
jmp 0x3aa0
cmpq $0x20, -0x18(%rbp)
jne 0x3a7d
movq -0x20(%rbp), %rax
movq $0xe, 0x108(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x100(%rax), %rsi
callq 0x44e0
jmp 0x3a9e
jmp 0x3a7f
movq -0x18(%rbp), %rsi
leaq 0x5dc5(%rip), %rdi      # 0x984f
movb $0x0, %al
callq 0x7b30
callq 0x2170
movl $0x0, (%rax)
jmp 0x3aaa
jmp 0x3aa0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3abb
movq -0x20(%rbp), %rdi
callq 0x2100
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/liball/../crypto/crypto_aes_aesni.c
// Function: crypto_aes_key_free_aesni
void
crypto_aes_key_free_aesni(void * key)
{

	/* Behave consistently with free(NULL). */
	if (key == NULL)
		return;

	/* Attempt to zero the expanded key. */
	insecure_memzero(key, sizeof(struct crypto_aes_key_aesni));

	/* Free the key. */
	free(key);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5695
jmp 0x56ac
movq -0x8(%rbp), %rdi
movl $0x110, %esi            # imm = 0x110
callq 0x56c0
movq -0x8(%rbp), %rdi
callq 0x2100
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/liball/../crypto/crypto_aesctr.c
// Function: crypto_aesctr_alloc
struct crypto_aesctr *
crypto_aesctr_alloc(void)
{
	struct crypto_aesctr * stream;

	/* Allocate memory. */
	if ((stream = malloc(sizeof(struct crypto_aesctr))) == NULL)
		goto err0;

	/* Success! */
	return (stream);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x30, %edi
callq 0x20b0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x573e
jmp 0x5748
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5750
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5786
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
callq 0x57f0
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movb $-0x1, 0x2f(%rax)
callq 0x58c0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x57bc
jmp 0x57db
leaq 0x40b2(%rip), %rdi      # 0x9875
leaq 0x40bf(%rip), %rsi      # 0x9889
movl $0x80, %edx
leaq 0x40cd(%rip), %rcx      # 0x98a3
callq 0x2090
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/liball/../crypto/crypto_aesctr.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;

	/* Can we use AESNI? */
	switch (crypto_aes_can_use_intrinsics()) {
#ifdef CPUSUPPORT_X86_AESNI
	case 1:
		hwaccel = HW_X86_AESNI;
		break;
#endif
#ifdef CPUSUPPORT_ARM_AES
	case 2:
		hwaccel = HW_ARM_AES;
		break;
#endif
	case 0:
		break;
	default:
		/* Should never happen. */
		assert(0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x2, 0x78f1(%rip)      # 0xd1c0
je 0x58d3
jmp 0x5924
movl $0x0, 0x78e3(%rip)      # 0xd1c0
callq 0x34f0
movl %eax, %ecx
movl %ecx, -0x4(%rbp)
testl %eax, %eax
je 0x5903
jmp 0x58ed
movl -0x4(%rbp), %eax
subl $0x1, %eax
jne 0x5905
jmp 0x58f7
movl $0x1, 0x78bf(%rip)      # 0xd1c0
jmp 0x5924
jmp 0x5924
leaq 0x40d7(%rip), %rdi      # 0x99e3
leaq 0x3f76(%rip), %rsi      # 0x9889
movl $0x48, %edx
leaq 0x4094(%rip), %rcx      # 0x99b3
callq 0x2090
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5949
jmp 0x5968
leaq 0x3f2d(%rip), %rdi      # 0x987d
leaq 0x3f32(%rip), %rsi      # 0x9889
movl $0x90, %edx
leaq 0x3f9a(%rip), %rcx      # 0x98fd
callq 0x2090
callq 0x5720
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x5979
jmp 0x5994
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5760
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x599c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/liball/../crypto/crypto_aesctr.c
// Function: crypto_aesctr_stream
void
crypto_aesctr_stream(struct crypto_aesctr * stream, const uint8_t * inbuf,
    uint8_t * outbuf, size_t buflen)
{

#if defined(HWACCEL)
#if defined(CPUSUPPORT_X86_AESNI)
	if ((buflen >= 16) && (hwaccel == HW_X86_AESNI)) {
		crypto_aesctr_aesni_stream(stream, inbuf, outbuf, buflen);
		return;
	}
#endif
#if defined(CPUSUPPORT_ARM_AES)
	if ((buflen >= 16) && (hwaccel == HW_ARM_AES)) {
		crypto_aesctr_arm_stream(stream, inbuf, outbuf, buflen);
		return;
	}
#endif
#endif /* HWACCEL */

	/* 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. */
	while (buflen >= 16) {
		/* Generate a block of cipherstream. */
		crypto_aesctr_stream_cipherblock_generate(stream);

		/* Encrypt the bytes and update the positions. */
		crypto_aesctr_stream_cipherblock_use(stream, &inbuf, &outbuf,
		    &buflen, 16, 0);
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x10, -0x20(%rbp)
jb 0x59ef
cmpl $0x1, 0x77ea(%rip)      # 0xd1c0
jne 0x59ef
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x5de0
jmp 0x5a54
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x5a60
cmpl $0x0, %eax
je 0x5a0b
jmp 0x5a54
jmp 0x5a0d
cmpq $0x10, -0x20(%rbp)
jb 0x5a3f
movq -0x8(%rbp), %rdi
callq 0x5b00
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
movl $0x10, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x5ba0
jmp 0x5a0d
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x5c50
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/liball/../crypto/crypto_aesctr_shared.c
// Function: crypto_aesctr_stream_pre_wholeblock
static inline int
crypto_aesctr_stream_pre_wholeblock(struct crypto_aesctr * stream,
    const uint8_t ** inbuf, uint8_t ** outbuf, size_t * buflen_p)
{
	size_t bytemod;

	/* Do we have any bytes left in the current cipherblock? */
	bytemod = stream->bytectr % 16;
	if (bytemod != 0) {
		/* Do we have enough to complete the request? */
		if (bytemod + *buflen_p <= 16) {
			/* Process only buflen bytes, then return. */
			crypto_aesctr_stream_cipherblock_use(stream, inbuf,
			    outbuf, buflen_p, *buflen_p, bytemod);
			return (1);
		}

		/* Encrypt the byte(s) and update the positions. */
		crypto_aesctr_stream_cipherblock_use(stream, inbuf, outbuf,
		    buflen_p, 16 - bytemod, bytemod);
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
andq $0xf, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x5aec
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
addq (%rcx), %rax
cmpq $0x10, %rax
ja 0x5ac9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x28(%rbp), %rax
movq (%rax), %r8
movq -0x30(%rbp), %r9
callq 0x5ba0
movl $0x1, -0x4(%rbp)
jmp 0x5af3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x10, %r8d
subq -0x30(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x5ba0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/liball/../crypto/crypto_aesctr_shared.c
// Function: crypto_aesctr_stream_cipherblock_generate
static inline void
crypto_aesctr_stream_cipherblock_generate(struct crypto_aesctr * stream)
{

	/* Sanity check. */
	assert(stream->bytectr % 16 == 0);

	/* Prepare counter. */
	stream->pblk[15]++;
	if (stream->pblk[15] == 0) {
		/*
		 * If incrementing the least significant byte resulted in it
		 * wrapping, re-encode the complete 64-bit value.
		 */
		be64enc(stream->pblk + 8, stream->bytectr / 16);
	}

	/* Encrypt the cipherblock. */
	crypto_aes_encrypt_block(stream->pblk, stream->buf, stream->key);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
andq $0xf, %rax
cmpq $0x0, %rax
jne 0x5b20
jmp 0x5b3f
leaq 0x3ea4(%rip), %rdi      # 0x99cb
leaq 0x3eb7(%rip), %rsi      # 0x99e5
movl $0x15, %edx
leaq 0x3ecc(%rip), %rcx      # 0x9a06
callq 0x2090
movq -0x8(%rbp), %rax
movb 0x2f(%rax), %cl
addb $0x1, %cl
movb %cl, 0x2f(%rax)
movq -0x8(%rbp), %rax
movzbl 0x2f(%rax), %eax
cmpl $0x0, %eax
jne 0x5b76
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
shrq $0x4, %rsi
callq 0x57f0
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
callq 0x3680
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/liball/../crypto/crypto_aesctr_shared.c
// Function: crypto_aesctr_stream_cipherblock_use
static inline void
crypto_aesctr_stream_cipherblock_use(struct crypto_aesctr * stream,
    const uint8_t ** inbuf, uint8_t ** outbuf, size_t * buflen, size_t nbytes,
    size_t bytemod)
{
	size_t i;

	/* Encrypt the byte(s). */
	for (i = 0; i < nbytes; i++)
		(*outbuf)[i] = (*inbuf)[i] ^ stream->buf[bytemod + i];

	/* Move to the next byte(s) of cipherstream. */
	stream->bytectr += nbytes;

	/* Update the positions. */
	*inbuf += nbytes;
	*outbuf += nbytes;
	*buflen -= nbytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x5c0e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movq -0x30(%rbp), %rdx
addq -0x38(%rbp), %rdx
movzbl 0x10(%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x5bc4
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rax
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/liball/../crypto/crypto_aesctr_shared.c
// Function: crypto_aesctr_stream_post_wholeblock
static inline void
crypto_aesctr_stream_post_wholeblock(struct crypto_aesctr * stream,
    const uint8_t ** inbuf, uint8_t ** outbuf, size_t * buflen_p)
{

	/* Process any final bytes; we need a new cipherblock. */
	if (*buflen_p > 0) {
		/* Generate a block of cipherstream. */
		crypto_aesctr_stream_cipherblock_generate(stream);

		/* Encrypt the byte(s) and update the positions. */
		crypto_aesctr_stream_cipherblock_use(stream, inbuf, outbuf,
		    buflen_p, *buflen_p, 0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jbe 0x5c9c
movq -0x8(%rbp), %rdi
callq 0x5b00
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %r8
xorl %eax, %eax
movl %eax, %r9d
callq 0x5ba0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/liball/../crypto/crypto_aesctr.c
// Function: crypto_aesctr_free
void
crypto_aesctr_free(struct crypto_aesctr * stream)
{

	/* Behave consistently with free(NULL). */
	if (stream == NULL)
		return;

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

	/* Free the stream. */
	free(stream);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5cc5
jmp 0x5cdc
movq -0x8(%rbp), %rdi
movl $0x30, %esi
callq 0x5cf0
movq -0x8(%rbp), %rdi
callq 0x2100
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x58(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5d4d
jmp 0x5d6c
leaq 0x3b29(%rip), %rdi      # 0x987d
leaq 0x3b2e(%rip), %rsi      # 0x9889
movl $0xed, %edx
leaq 0x3be8(%rip), %rcx      # 0x994f
callq 0x2090
movq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x5760
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x59b0
movq -0x60(%rbp), %rdi
movl $0x30, %esi
callq 0x5cf0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x5e50
cmpl $0x0, %eax
je 0x5e14
jmp 0x5e45
cmpq $0x10, -0x20(%rbp)
jb 0x5e30
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x5ef0
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x60e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/tests/lbs/main.c
// Function: callback_params
static int
callback_params(void * cookie, int failed, size_t blklen, uint64_t blkno)
{

	(void)cookie; /* UNUSED */

	/* Record returned values. */
	params_failed = failed;
	params_blklen = blklen;
	params_nextblk = blkno;

	/* We're done. */
	params_done = 1;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, 0x1182c(%rip)     # 0x14698
movq -0x18(%rbp), %rax
movq %rax, 0x11829(%rip)     # 0x146a0
movq -0x20(%rbp), %rax
movq %rax, 0x1182e(%rip)     # 0x146b0
movl $0x1, 0x11810(%rip)     # 0x1469c
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/tests/lbs/main.c
// Function: callback_append
static int
callback_append(void * cookie, int failed, int status, uint64_t blkno)
{

	(void)cookie; /* UNUSED */

	/* Record returned values. */
	append_failed = failed;
	if (status)
		append_failed = 1;
	params_nextblk = blkno;

	/* We're done. */
	append_done = 1;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, 0x117fd(%rip)     # 0x146a8
cmpl $0x0, -0x10(%rbp)
je 0x2ebb
movl $0x1, 0x117ed(%rip)     # 0x146a8
movq -0x18(%rbp), %rax
movq %rax, 0x117ea(%rip)     # 0x146b0
movl $0x1, 0x117dc(%rip)     # 0x146ac
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/tests/lbs/main.c
// Function: callback_get
static int
callback_get(void * cookie, int failed, int status, const uint8_t * buf)
{
	uint8_t * dstbuf = cookie;

	/* Record returned values. */
	get_failed = failed;
	if (status)
		get_failed = 1;
	if (failed == 0)
		memcpy(dstbuf, buf, params_blklen);

	/* We're done. */
	get_done = 1;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, 0x11775(%rip)     # 0x146bc
cmpl $0x0, -0x10(%rbp)
je 0x2f57
movl $0x1, 0x11765(%rip)     # 0x146bc
cmpl $0x0, -0xc(%rbp)
jne 0x2f71
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x11734(%rip), %rdx     # 0x146a0
callq 0x21d0
movl $0x1, 0x11745(%rip)     # 0x146c0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/tests/lbs/main.c
// Function: callback_gets
static int
callback_gets(void * cookie, int failed, int status, const uint8_t * buf)
{
	int val = (int)(uintptr_t)cookie;

	/* Did we fail? */
	if (failed)
		gets_failed = 1;
	else if (status)
		gets_failed = 1;
	else if (buf[0] != val)
		gets_failed = 1;

	/* We're done this GET. */
	gets_ndone += 1;
	if (gets_ndone == 256)
		gets_done = 1;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x2fbb
movl $0x1, 0x1170f(%rip)     # 0x146c8
jmp 0x2fe7
cmpl $0x0, -0x10(%rbp)
je 0x2fcd
movl $0x1, 0x116fd(%rip)     # 0x146c8
jmp 0x2fe5
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl -0x1c(%rbp), %eax
je 0x2fe3
movl $0x1, 0x116e5(%rip)     # 0x146c8
jmp 0x2fe5
jmp 0x2fe7
movl 0x116d7(%rip), %eax     # 0x146c4
addl $0x1, %eax
movl %eax, 0x116ce(%rip)     # 0x146c4
cmpl $0x100, 0x116c4(%rip)   # imm = 0x100
jne 0x300c
movl $0x1, 0x116c0(%rip)     # 0x146cc
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x4de2(%rip), %eax      # 0x60c0
movl %eax, -0x10(%rbp)
movl $0x10, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %edi
shlq %rdi
callq 0x38a0
movq %rax, 0x4ddc(%rip)      # 0x60d8
movl -0xc(%rbp), %eax
movl %eax, %edi
shlq %rdi
callq 0x38a0
movq %rax, 0x4dd0(%rip)      # 0x60e0
movl $0x1, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x137c
movl -0x8(%rbp), %eax
movw %ax, %dx
movq 0x4da0(%rip), %rax      # 0x60d8
movl -0x4(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
movl -0x4(%rbp), %eax
movw %ax, %dx
movq 0x4d94(%rip), %rax      # 0x60e0
movl -0x8(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
movl -0x4(%rbp), %eax
shll %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl -0xc(%rbp), %eax
cmpl $0x0, %eax
je 0x136f
movl -0x4(%rbp), %eax
xorl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1371
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x131e
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x10, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x13da
movq 0x4d1e(%rip), %rax      # 0x60d8
movl -0x4(%rbp), %ecx
movzwl (%rax,%rcx,2), %esi
leaq 0x2c3c(%rip), %rdi      # 0x4004
movb $0x0, %al
callq 0x1060
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x13a6
leaq 0x2ede(%rip), %rdi      # 0x42bf
movb $0x0, %al
callq 0x1060
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x1423
movq 0x4cdd(%rip), %rax      # 0x60e0
movl -0x4(%rbp), %ecx
movzwl (%rax,%rcx,2), %esi
leaq 0x2bf3(%rip), %rdi      # 0x4004
movb $0x0, %al
callq 0x1060
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x13ef
leaq 0x2e95(%rip), %rdi      # 0x42bf
movb $0x0, %al
callq 0x1060
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x1456
cmpl $0x0, -0xc(%rbp)
jne 0x145f
movl $0x0, -0x4(%rbp)
jmp 0x14a3
movq 0x4c72(%rip), %rax      # 0x60d8
movslq -0x8(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq 0x4c63(%rip), %rcx      # 0x60d8
movslq -0xc(%rbp), %rdx
movzwl (%rcx,%rdx,2), %ecx
addl %ecx, %eax
movl %eax, -0x10(%rbp)
cmpl $0xf, -0x10(%rbp)
jl 0x1491
movl -0x10(%rbp), %eax
subl $0xf, %eax
movl %eax, -0x10(%rbp)
movq 0x4c48(%rip), %rax      # 0x60e0
movslq -0x10(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x14c9
movl $0x0, -0x4(%rbp)
jmp 0x151c
cmpl $0x0, -0xc(%rbp)
jne 0x14d8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x151c
movq 0x4bf9(%rip), %rax      # 0x60d8
movslq -0x8(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq 0x4bea(%rip), %rcx      # 0x60d8
movslq -0xc(%rbp), %rdx
movzwl (%rcx,%rdx,2), %ecx
subl %ecx, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0x150a
movl -0x10(%rbp), %eax
addl $0xf, %eax
movl %eax, -0x10(%rbp)
movq 0x4bcf(%rip), %rax      # 0x60e0
movslq -0x10(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jne 0x154e
movl $0x1, -0x4(%rbp)
jmp 0x1594
movl $0x1, %eax
cmpl -0xc(%rbp), %eax
jne 0x1560
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1594
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x158e
movl -0x10(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x1440
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x156d
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x10, %edi
callq 0x38a0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x4(%rbp), %eax
movl %eax, %edi
shlq $0x2, %rdi
movl -0x8(%rbp), %eax
imulq %rax, %rdi
callq 0x38a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x29d0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x2b2e
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x2b15
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rdx
imull 0x4(%rdx), %ecx
addl -0x10(%rbp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %esi
leaq 0x1501(%rip), %rdi      # 0x4004
movb $0x0, %al
callq 0x1060
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2ad5
leaq 0x17a3(%rip), %rdi      # 0x42bf
movb $0x0, %al
callq 0x1060
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2ac3
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x2a10
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jae 0x2bbe
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x8(%rbp), %eax
jae 0x2bb1
movl -0x18(%rbp), %edi
addl $0x1, %edi
movl -0x14(%rbp), %esi
callq 0x1530
movl %eax, %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rsi
imull 0x4(%rsi), %ecx
addl -0x18(%rbp), %ecx
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2b73
jmp 0x2bb3
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2b64
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x2df5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rdx
imull 0x4(%rdx), %ecx
addl -0x18(%rbp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edi
xorl %ecx, %ecx
movl $0x1, %edx
cmpl %edi, %esi
cmovel %edx, %ecx
cmpl %ecx, %eax
je 0x2de8
movl $0x0, -0x4(%rbp)
jmp 0x2dfc
jmp 0x2dea
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2da2
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x2e3c
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x2e3c
jmp 0x2e5b
leaq 0x14c8(%rip), %rdi      # 0x430b
leaq 0x14e6(%rip), %rsi      # 0x4330
movl $0x63, %edx
leaq 0x14e0(%rip), %rcx      # 0x4336
callq 0x1080
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x2ef1
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rdx
imull 0x4(%rdx), %ecx
addl -0xc(%rbp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rdx
imull 0x4(%rdx), %ecx
addl -0x10(%rbp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rsi
imull 0x4(%rsi), %ecx
addl -0xc(%rbp), %ecx
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rsi
imull 0x4(%rsi), %ecx
addl -0x10(%rbp), %ecx
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2e62
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rdx
imull 0x4(%rdx), %ecx
addl -0xc(%rbp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %esi
movl $0x1, %edi
callq 0x14b0
movl %eax, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x2f94
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rdx
imull 0x4(%rdx), %ecx
addl -0xc(%rbp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %esi
callq 0x1440
movl %eax, %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rsi
imull 0x4(%rsi), %ecx
addl -0xc(%rbp), %ecx
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2f3e
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vrancurel[P]ec/mat.c
// Function: mat_transform2
void mat_transform2(t_mat *tmp, int i, int j)
{
  int k;
  int f_i_j = MAT_ITEM(tmp, i, j);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rdx
imull 0x4(%rdx), %ecx
addl -0x10(%rbp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x304e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rdx
imull 0x4(%rdx), %ecx
addl -0x10(%rbp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %edi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rdx
imull 0x4(%rdx), %ecx
addl -0xc(%rbp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %esi
callq 0x1440
movl -0x1c(%rbp), %edx
xorl %eax, %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rsi
imull 0x4(%rsi), %ecx
addl -0x10(%rbp), %ecx
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2fd7
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x36c4
jmp 0x36e3
leaq 0xcc2(%rip), %rdi       # 0x438d
leaq 0xc5e(%rip), %rsi       # 0x4330
movl $0x10b, %edx            # imm = 0x10B
leaq 0xcc1(%rip), %rcx       # 0x439f
callq 0x1080
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x36f4
jmp 0x3713
leaq 0xccd(%rip), %rdi       # 0x43c8
leaq 0xc2e(%rip), %rsi       # 0x4330
movl $0x10c, %edx            # imm = 0x10C
leaq 0xc91(%rip), %rcx       # 0x439f
callq 0x1080
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x37bb
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x37ab
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rdx
imull 0x4(%rdx), %ecx
addl -0x20(%rbp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %edi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x1440
movl %eax, -0x24(%rbp)
xorl %eax, %eax
cmpl -0x20(%rbp), %eax
jne 0x3789
movl -0x24(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x379e
movl -0x24(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
jmp 0x37a0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3730
jmp 0x37ad
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x371a
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x10, %edi
callq 0x38a0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x4(%rbp), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x38a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x3920
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop