LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/stv0g[P]c11-queues/spsc_ub_queue.c
// Function: spsc_ub_queue_destroy
int spsc_ub_queue_destroy(struct spsc_ub_queue* q)
{
	struct node* n = q->_first;

	do {
		struct node* next = n->_next;
		memory_free(q->mem, (void *) n, sizeof(struct node));
		n = next;
	} while (n);
	
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xd8(%rdi), %rsi
movq (%rsi), %r14
movq (%rbx), %rdi
movl $0x10, %edx
callq 0x1715
movq %r14, %rsi
testq %r14, %r14
jne 0x16a8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/antonblanchard[P]will-it-scale/tests/brk2.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	unsigned long page_size = getpagesize();
	void *addr = sbrk(page_size) + page_size;

	while (1) {
		addr += page_size;
		assert(brk(addr) == 0);

		addr -= page_size;
		assert(brk(addr) == 0);

		(*iterations) += 2;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1270
movslq %eax, %r14
movq %r14, %rdi
callq 0x1180
movq %rax, %r15
addq %r14, %r15
addq %r15, %r14
movq %r14, %rdi
callq 0x1170
testl %eax, %eax
jne 0x1caf
movq %r15, %rdi
callq 0x1170
testl %eax, %eax
jne 0x1cce
addq $0x2, (%rbx)
jmp 0x1c91
leaq 0x5cd(%rip), %rdi       # 0x2283
leaq 0x5d5(%rip), %rsi       # 0x2292
leaq 0x5db(%rip), %rcx       # 0x229f
movl $0xe, %edx
callq 0x1130
leaq 0x5ae(%rip), %rdi       # 0x2283
leaq 0x5b6(%rip), %rsi       # 0x2292
leaq 0x5bc(%rip), %rcx       # 0x229f
movl $0x11, %edx
callq 0x1130
// File: /workspace/github_c_makefile_star2_O1/randyrossi[P]fisher-modem/mkfilter/src/gencode.C
// Function: pr_ypart(char const*)
static void pr_ypart(const char* vs) { /* output contribution from Y vec */
  for (int i = 0; i < npoles; i++) {
    if (i % 2 == 0)
      prnl();
    printf(" + (%14.10f * %s[%d])", ycoeffs[i], vs, i);
  }
}

// Assembly:
cmpl $0x0, 0x4778(%rip)      # 0x6208
jle 0x1aed
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x476c(%rip), %r12      # 0x6210
xorl %r14d, %r14d
leaq 0x16a8(%rip), %r15      # 0x3156
testb $0x1, %r14b
jne 0x1ab9
callq 0x1cc4
movsd (%r12), %xmm0
movq %r15, %rdi
movq %rbx, %rsi
movl %r14d, %edx
movb $0x1, %al
callq 0x1030
incq %r14
movslq 0x472f(%rip), %rax      # 0x6208
addq $0x8, %r12
cmpq %rax, %r14
jl 0x1aae
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/randyrossi[P]fisher-modem/mkfilter/src/gencode.C
// Function: prxfac(double)
static void prxfac(double x) {
  if (nxfacs > 0 && nxfacs % 3 == 0)
    prnl();
  if (x > 0.0)
    printf((nxfacs > 0) ? " + " : "   ");
  if (x < 0.0) {
    printf(" - ");
    x = -x;
  }
  unless(x == 1.0) {
    double f = fmod(x, 1.0);
    const char* fmt = (f < EPS || f > 1.0 - EPS) ? "%g" : "%14.10f";
    printf(fmt, x);
    printf(" * ");
  }
  nxfacs++;
}

// Assembly:
subq $0x18, %rsp
movl 0x5522(%rip), %eax      # 0x721c
testl %eax, %eax
movapd %xmm0, (%rsp)
jle 0x1d24
movl $0xaaaaaaab, %ecx       # imm = 0xAAAAAAAB
movq %rax, %rdx
imulq %rcx, %rdx
shrq $0x21, %rdx
leal (%rdx,%rdx,2), %ecx
subl %ecx, %eax
jne 0x1d24
callq 0x1cc4
movapd (%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1d57
cmpl $0x0, 0x54e7(%rip)      # 0x721c
leaq 0x145b(%rip), %rax      # 0x3197
leaq 0x14d5(%rip), %rdi      # 0x3218
cmovgq %rax, %rdi
xorl %eax, %eax
callq 0x1030
xorpd %xmm1, %xmm1
movapd (%rsp), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x1d78
leaq 0x1437(%rip), %rdi      # 0x319b
xorl %eax, %eax
callq 0x1030
movapd (%rsp), %xmm0
xorpd 0x12a8(%rip), %xmm0     # 0x3020
ucomisd 0x1288(%rip), %xmm0     # 0x3008
jne 0x1d84
jnp 0x1dda
movsd 0x127c(%rip), %xmm1     # 0x3008
movapd %xmm0, (%rsp)
callq 0x10b0
ucomisd 0x1272(%rip), %xmm0     # 0x3010
leaq 0x13fa(%rip), %rax      # 0x319f
leaq 0x13f6(%rip), %rdi      # 0x31a2
cmovaq %rax, %rdi
movsd 0x1260(%rip), %xmm1     # 0x3018
ucomisd %xmm0, %xmm1
cmovaq %rax, %rdi
movapd (%rsp), %xmm0
movb $0x1, %al
callq 0x1030
leaq 0x13d7(%rip), %rdi      # 0x31aa
xorl %eax, %eax
callq 0x1030
incl 0x543c(%rip)            # 0x721c
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/randyrossi[P]fisher-modem/mkfilter/src/readdata.C
// Function: rdline(char*)
static void rdline(char vec[]) {
  int n = 0;
  int ch = getchar();
  until(n >= MAXSTRING || ch == '\n' || ch < 0) {
    vec[n++] = ch;
    ch = getchar();
  }
  if (n == 0 && ch < 0)
    formaterror(6);
  vec[n] = '\0';
  until(ch == '\n' || ch < 0) ch = getchar();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x10c0
cmpl $0xa, %eax
sete %cl
testl %eax, %eax
sets %dl
xorl %r14d, %r14d
orb %cl, %dl
jne 0x2187
xorl %r15d, %r15d
leaq 0x1(%r15), %r14
movb %al, (%rbx,%r15)
callq 0x10c0
testl %eax, %eax
js 0x2187
cmpq $0xfe, %r15
ja 0x2187
movq %r14, %r15
cmpl $0xa, %eax
jne 0x2165
testl %r14d, %r14d
setne %cl
testl %eax, %eax
setns %dl
orb %cl, %dl
je 0x21c0
movl %r14d, %ecx
movb $0x0, (%rbx,%rcx)
cmpl $0xa, %eax
sete %cl
testl %eax, %eax
sets %al
orb %cl, %al
jne 0x21ba
callq 0x10c0
cmpl $0xa, %eax
je 0x21ba
testl %eax, %eax
jns 0x21ac
popq %rbx
popq %r14
popq %r15
retq
callq 0x11fa
// File: /workspace/github_c_makefile_star2_O1/randyrossi[P]fisher-modem/mkfilter/src/readdata.C
// Function: rdcoeffs(char, int&, double*)
static void rdcoeffs(char c, int& n, double* coeffs) {
  char fmt[6];
  strcpy(fmt, "N? = ");
  fmt[1] = c;
  n = rdint(fmt);
  unless(n >= 0 && n <= MAXPZ) formaterror(3);
  for (int i = 0; i <= n; i++)
    coeffs[i] = rddouble("");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x8(%rsp), %rcx
movl $0x3d203f4e, (%rcx)     # imm = 0x3D203F4E
movw $0x20, 0x4(%rcx)
movb %dil, 0x1(%rcx)
leaq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %r15
movq %r15, %rsi
movl $0x4, %edx
callq 0x228d
movslq (%r15), %rax
leaq (%rsp,%rax), %rdi
addq $0x10, %rdi
callq 0x1110
movl %eax, (%r14)
cmpl $0x200, %eax            # imm = 0x200
ja 0x2288
cmpl $0x0, (%r14)
js 0x2276
movq $-0x1, %rbp
leaq 0xf98(%rip), %r15       # 0x31ce
leaq 0x10(%rsp), %r12
leaq 0x4(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
movl $0x5, %edx
movq %r15, %rcx
callq 0x228d
movslq 0x4(%rsp), %rax
leaq (%rsp,%rax), %rdi
addq $0x10, %rdi
callq 0x10a0
movsd %xmm0, 0x8(%rbx,%rbp,8)
movslq (%r14), %rax
incq %rbp
cmpq %rax, %rbp
jl 0x2240
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1228
// File: /workspace/github_c_makefile_star2_O1/randyrossi[P]fisher-modem/mkfilter/src/readdata.C
// Function: getline(char*, int&, int, char const*)
static void getline(char* vec, int& p, int e, const char* exp) {
  rdline(vec);
  p = strlen(exp);
  unless(memcmp(vec, exp, p) == 0) formaterror(e);
  while (vec[p] == ' ' || vec[p] == '\t')
    p++;
  unless((vec[p] >= '0' && vec[p] <= '9') || (vec[p] == '+') ||
         (vec[p] == '-') || (vec[p] == '.')) formaterror(e);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x2143
movq %r12, %rdi
callq 0x1060
movl %eax, (%r14)
movslq %eax, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x1080
testl %eax, %eax
jne 0x2304
movslq (%r14), %rax
addq %rax, %r15
leal 0x1(%rax), %ecx
movzbl (%r15), %eax
cmpl $0x20, %eax
je 0x22d9
cmpl $0x9, %eax
jne 0x22e3
movl %ecx, (%r14)
incq %r15
incl %ecx
jmp 0x22cb
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0x22f8
leal -0x2d(%rax), %ecx
cmpl $0x2, %ecx
jb 0x22f8
cmpl $0x2b, %eax
jne 0x230b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl %ebx, %edi
callq 0x1256
movl %ebx, %edi
callq 0x1283
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/matrix_lookup.c
// Function: parasail_matrix_lookup
const parasail_matrix_t* parasail_matrix_lookup(const char *matrixname)
{
    const parasail_matrix_t *matrix = NULL;

    if (matrixname) {
        int index = 0;
        const parasail_matrix_t *current = parasail_matrices[index++];
        while (current) {
            if (0 == strcmp(matrixname, current->name)) {
                matrix = current;
                break;
            }
            current = parasail_matrices[index++];
        }
    }

    return matrix;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x189594
movq %rdi, %r14
leaq 0x4d952d(%rip), %rbx    # 0x662a98
movl $0x1, %r15d
leaq 0x4d92f8(%rip), %r12    # 0x662870
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x1291a0
testl %eax, %eax
je 0x189596
movq (%r12,%r15,8), %rbx
incq %r15
cmpq $0x45, %r15
jne 0x189578
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/parser.c
// Function: strdup_rpl
static char* strdup_rpl(const char *str)
{
    size_t l = strlen(str);
    char *s = (char*)calloc(l + 1, sizeof(char));
    if(!s) {
        return NULL;
    }
    (void)memcpy(s, str, l);
    return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1290a0
movq %rax, %r14
leaq 0x1(%rax), %rdi
movl $0x1, %esi
callq 0x1290e0
testq %rax, %rax
je 0x18b7a6
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x129100
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/parser.c
// Function: parasail_sequences_free
void parasail_sequences_free(parasail_sequences_t *sequences)
{
    size_t i;
    for (i=0; i<sequences->l; ++i) {
        if (sequences->seqs[i].name.s)    free(sequences->seqs[i].name.s);
        if (sequences->seqs[i].comment.s) free(sequences->seqs[i].comment.s);
        if (sequences->seqs[i].seq.s)     free(sequences->seqs[i].seq.s);
        if (sequences->seqs[i].qual.s)    free(sequences->seqs[i].qual.s);
    }
    free(sequences->seqs);
    free(sequences);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x18b81a
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rax
movq 0x8(%rax,%r14), %rdi
testq %rdi, %rdi
je 0x18b7d7
callq 0x129170
movq (%rbx), %rax
movq 0x18(%rax,%r14), %rdi
testq %rdi, %rdi
je 0x18b7e9
callq 0x129170
movq (%rbx), %rax
movq 0x28(%rax,%r14), %rdi
testq %rdi, %rdi
je 0x18b7fb
callq 0x129170
movq (%rbx), %rax
movq 0x38(%rax,%r14), %rdi
testq %rdi, %rdi
je 0x18b80d
callq 0x129170
incq %r15
addq $0x40, %r14
cmpq 0x8(%rbx), %r15
jb 0x18b7c5
movq (%rbx), %rdi
callq 0x129170
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x129170
// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/parser.c
// Function: parasail_sequences_pack
char* parasail_sequences_pack(const parasail_sequences_t *sequences, size_t *size)
{
    size_t i = 0;
    size_t offset = 0;
    char *packed = NULL;

    packed = (char*)malloc(sizeof(char) * (sequences->characters+sequences->l+1));
    if (NULL == packed) {
        perror("malloc");
        fprintf(stderr, "parasail_sequences_pack: failed\n");
        return NULL;
    }

    for (i=0; i<sequences->l; ++i) {
        memcpy(&packed[offset], sequences->seqs[i].seq.s, sequences->seqs[i].seq.l);
        offset += sequences->seqs[i].seq.l;
        packed[offset++] = '$';
    }
    packed[offset] = '\0';

    *size = offset;

    return packed;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %r12
movq 0x10(%rdi), %rax
leaq (%rax,%r12), %rdi
incq %rdi
callq 0x129190
testq %rax, %rax
je 0x18b8b6
movq %rax, %r14
testq %r12, %r12
je 0x18b899
movq (%r15), %rbp
addq $0x28, %rbp
xorl %r13d, %r13d
leaq (%r14,%r13), %rdi
movq -0x8(%rbp), %r15
movq (%rbp), %rsi
movq %r15, %rdx
callq 0x129100
leaq (%r15,%r13), %rax
addq %r15, %r13
incq %r13
movb $0x24, (%r14,%rax)
addq $0x40, %rbp
decq %r12
jne 0x18b86b
jmp 0x18b89c
xorl %r13d, %r13d
movb $0x0, (%r14,%r13)
movq %r13, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x12a332
xorl %r14d, %r14d
jmp 0x18b8a4
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/benes.c
// Function: layer_ex
static void layer_ex(uint64_t * data, uint64_t * bits, int lgs)
{
	int i, j, s;

	uint64_t d;

	s = 1 << lgs;

	for (i = 0; i < 128; i += s*2)
	for (j = i; j < i+s; j++)
	{

		d = (data[j+0] ^ data[j+s]);
		d &= (*bits++);
		data[j+0] ^= d;
		data[j+s] ^= d;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ecx
movl $0x1, %edx
shll %cl, %edx
movl $0x2, %eax
shll %cl, %eax
cltq
movslq %edx, %rdx
leaq (%rdi,%rdx,8), %r8
xorl %r9d, %r9d
cmpl $0x1f, %ecx
je 0x1810
leaq (%r9,%rdx), %r10
movq %r9, %r11
movq (%rdi,%r11,8), %rbx
movq (%r8,%r11,8), %r14
movq %r14, %r15
xorq %rbx, %r15
andq (%rsi), %r15
addq $0x8, %rsi
xorq %r15, %rbx
movq %rbx, (%rdi,%r11,8)
xorq %r14, %r15
movq %r15, (%r8,%r11,8)
incq %r11
cmpq %r10, %r11
jl 0x17e5
addq %rax, %r9
cmpq $0x80, %r9
jl 0x17d9
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/benes.c
// Function: layer_in
static void layer_in(uint64_t data[2][64], uint64_t * bits, int lgs)
{
	int i, j, s;

	uint64_t d;

	s = 1 << lgs;

	for (i = 0; i < 64; i += s*2)
	for (j = i; j < i+s; j++)
	{

		d = (data[0][j+0] ^ data[0][j+s]);
		d &= (*bits++);
		data[0][j+0] ^= d;
		data[0][j+s] ^= d;

		d = (data[1][j+0] ^ data[1][j+s]);
		d &= (*bits++);
		data[1][j+0] ^= d;
		data[1][j+s] ^= d;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ecx
movl $0x1, %edx
shll %cl, %edx
movl $0x2, %eax
shll %cl, %eax
cltq
movslq %edx, %rdx
leaq (%rdi,%rdx,8), %r8
addq $0x200, %r8             # imm = 0x200
xorl %r9d, %r9d
cmpl $0x1f, %ecx
je 0x18b1
leaq (%r9,%rdx), %r10
movq %r9, %r11
movq (%rdi,%r11,8), %rbx
movq -0x200(%r8,%r11,8), %r14
movq %r14, %r15
xorq %rbx, %r15
andq (%rsi), %r15
xorq %r15, %rbx
movq %rbx, (%rdi,%r11,8)
xorq %r14, %r15
movq %r15, -0x200(%r8,%r11,8)
movq 0x200(%rdi,%r11,8), %rbx
movq (%r8,%r11,8), %r14
movq %r14, %r15
xorq %rbx, %r15
andq 0x8(%rsi), %r15
addq $0x10, %rsi
xorq %r15, %rbx
movq %rbx, 0x200(%rdi,%r11,8)
xorq %r14, %r15
movq %r15, (%r8,%r11,8)
incq %r11
cmpq %r10, %r11
jl 0x1856
addq %rax, %r9
cmpq $0x40, %r9
jl 0x184a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/benes.c
// Function: support_gen
void support_gen(gf * s, const unsigned char *c)
{
	gf a;
	int i, j;
	unsigned char L[ GFBITS ][ (1 << GFBITS)/8 ];

	for (i = 0; i < GFBITS; i++)
		for (j = 0; j < (1 << GFBITS)/8; j++)
			L[i][j] = 0;

	for (i = 0; i < (1 << GFBITS); i++)
	{
		a = bitrev((gf) i);

		for (j = 0; j < GFBITS; j++)
			L[j][ i/8 ] |= ((a >> j) & 1) << (i%8);
	}
			
	for (j = 0; j < GFBITS; j++)
		apply_benes(L[j], c, 0);

	for (i = 0; i < SYS_N; i++)
	{
		a = bitrev((gf) i);
	
		s[i] = 0;
		for (j = GFBITS-1; j >= 0; j--)
		{
			s[i] <<= 1;
			s[i] |= (L[j][i/8] >> (i%8)) & 1;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x3408, %rsp           # imm = 0x3408
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
xorl %r15d, %r15d
movl $0x3400, %edx           # imm = 0x3400
xorl %esi, %esi
callq 0x1070
movq %r15, %rax
shrq $0x3, %rax
leaq (%rsp,%rax), %r12
movzwl %r15w, %edi
callq 0x6b92
movzwl %ax, %eax
movl %r15d, %ecx
andl $0x7, %ecx
xorl %edx, %edx
xorl %esi, %esi
btl %edx, %eax
setb %sil
shll %cl, %esi
orb %sil, (%r12)
incq %rdx
addq $0x400, %r12            # imm = 0x400
cmpq $0xd, %rdx
jne 0x1905
incq %r15
cmpl $0x2000, %r15d          # imm = 0x2000
jne 0x18e6
xorl %r15d, %r15d
leaq (%rsp,%r15), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1504
addq $0x400, %r15            # imm = 0x400
cmpq $0x3400, %r15           # imm = 0x3400
jne 0x1933
xorl %r14d, %r14d
movq %r14, %rax
shrq $0x3, %rax
leaq (%rsp,%rax), %r15
movzwl %r14w, %edi
callq 0x6b92
movw $0x0, (%rbx,%r14,2)
movl %r14d, %eax
andl $0x7, %eax
movl $0x3400, %edx           # imm = 0x3400
xorl %ecx, %ecx
movzbl -0x400(%r15,%rdx), %esi
xorl %edi, %edi
btl %eax, %esi
setb %dil
leal (%rdi,%rcx,2), %ecx
addq $-0x400, %rdx           # imm = 0xFC00
jne 0x197c
movw %cx, (%rbx,%r14,2)
incq %r14
cmpq $0x2000, %r14           # imm = 0x2000
jne 0x1954
addq $0x3408, %rsp           # imm = 0x3408
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/chacha20.c
// Function: chacha20_init
static unsigned long unpack32(const unsigned char *x) {
    return
        (unsigned long) (x[0])                  \
    | (((unsigned long) (x[1])) << 8)           \
    | (((unsigned long) (x[2])) << 16)          \
    | (((unsigned long) (x[3])) << 24);
}

// Assembly:
movl (%rsi), %eax
movq %rax, (%rdi)
movl 0x4(%rsi), %eax
movq %rax, 0x8(%rdi)
movl 0x8(%rsi), %eax
movq %rax, 0x10(%rdi)
movl 0xc(%rsi), %eax
movq %rax, 0x18(%rdi)
movl 0x10(%rsi), %eax
movq %rax, 0x20(%rdi)
movl 0x14(%rsi), %eax
movq %rax, 0x28(%rdi)
movl 0x18(%rsi), %eax
movq %rax, 0x30(%rdi)
movl 0x1c(%rsi), %eax
movq %rax, 0x38(%rdi)
movl (%rdx), %eax
movq %rax, 0x40(%rdi)
movl 0x4(%rdx), %eax
movq %rax, 0x48(%rdi)
movq $0x0, 0x50(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/checkfd.c
// Function: checkfd
int checkfd(int fd, short event) {

    struct pollfd p;
    char ch = 0;
    int r;
    struct stat st;

    if (fstat(fd, &st) != 0) return 0;

    p.fd = fd;
    p.events = event;
    p.revents = 0;
    for (;;) {
        r = poll(&p, 1, 0);
        if (r == -1) {
            if (errno == EAGAIN) continue;
            if (errno == EINTR) continue;
        }
        if (r != 1) return 0;
        if (r == 1) break;
    }
    if (p.revents) return 1;
    /* catch errno */
    if (event == POLLOUT)
        r = write(fd, &ch, 1);
    if (event == POLLIN)
        r = read(fd, &ch, 1);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movl %esi, %ebp
movl %edi, %ebx
movb $0x0, 0xf(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x1120
testl %eax, %eax
jne 0x3b9b
leaq 0x10(%rsp), %r14
movl %ebx, (%r14)
movw %bp, 0x4(%r14)
movw $0x0, 0x6(%r14)
movl $0x1, %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x10d0
movl %eax, %r15d
cmpl $-0x1, %eax
jne 0x3b64
callq 0x1040
movl (%rax), %eax
cmpl $0x4, %eax
je 0x3b3c
cmpl $0xb, %eax
je 0x3b3c
cmpl $0x1, %r15d
jne 0x3b9b
movl $0x1, %r14d
cmpw $0x0, 0x16(%rsp)
jne 0x3b9e
movswl %bp, %eax
xorl %r14d, %r14d
cmpl $0x1, %eax
je 0x3baf
cmpl $0x4, %eax
jne 0x3b9e
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
movl %ebx, %edi
callq 0x1060
jmp 0x3b9e
xorl %r14d, %r14d
movl %r14d, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
movl %ebx, %edi
callq 0x1090
jmp 0x3b9e
nop
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/controlbits.c
// Function: controlbits
void controlbits(unsigned char * out)
{
	int i;
	uint32_t pi[ (1 << GFBITS) ];
	unsigned char c[ (2*GFBITS - 1) * (1 << GFBITS) / 16 ];

	perm_gen(pi);

	for (i = 0; i < sizeof(c); i++)
		c[i] = 0;

	controlbitsfrompermutation(GFBITS, (1 << GFBITS), 1, 0, c, pi);

	for (i = 0; i < sizeof(c); i++)
		out[i] = c[i];
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x18000, %rsp          # imm = 0x18000
movq %rdi, %rbx
movq %rsp, %r14
movl $0x1, %ebp
movl $0x10000, %esi          # imm = 0x10000
movq %r14, %rdi
callq 0x6524
xorl %eax, %eax
movq (%rsp,%rax,8), %rcx
shlq $0xd, %rcx
addq %rax, %rcx
movq %rcx, (%rsp,%rax,8)
incq %rax
cmpq $0x2000, %rax           # imm = 0x2000
jne 0x3be9
xorl %eax, %eax
movl $0x1, %ecx
movq (%rsp,%rcx,8), %rdx
xorl %esi, %esi
movq (%rsp,%rsi,8), %rdi
xorq %rdx, %rdi
cmpq $0x2000, %rdi           # imm = 0x2000
cmovbl %ebp, %eax
incq %rsi
cmpq %rsi, %rcx
jne 0x3c10
incq %rcx
cmpq $0x2000, %rcx           # imm = 0x2000
jne 0x3c0a
testl %eax, %eax
jne 0x3bda
movq %rsp, %rsi
movl $0x2000, %edi           # imm = 0x2000
callq 0x413d
xorl %eax, %eax
movl $0x1fff, %ecx           # imm = 0x1FFF
movl (%rsp,%rax,8), %edx
andl %ecx, %edx
movl %edx, 0x10000(%rsp,%rax,4)
incq %rax
cmpq $0x2000, %rax           # imm = 0x2000
jne 0x3c4d
movq %rsp, %r14
movl $0x3200, %edx           # imm = 0x3200
movq %r14, %rdi
xorl %esi, %esi
callq 0x1070
leaq 0x10000(%rsp), %r9
movl $0xd, %edi
movl $0x2000, %esi           # imm = 0x2000
movl $0x1, %edx
xorl %ecx, %ecx
movq %r14, %r8
callq 0x3cb3
movl $0x3200, %edx           # imm = 0x3200
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10a0
addq $0x18000, %rsp          # imm = 0x18000
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/controlbits.c
// Function: sort_64b
static void sort_64b(int n, uint64_t x[n])
{
  if (n <= 1) return;
  sort_64b(n/2,x);
  sort_64b(n/2,x + n/2);
  merge_64b(n/2,x,1);
}

// Assembly:
cmpl $0x1, %edi
jg 0x4143
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
shrl %r14d
movl %r14d, %edi
callq 0x413d
leaq (%rbx,%r14,8), %rsi
movl %r14d, %edi
callq 0x413d
movl %r14d, %edi
movq %rbx, %rsi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4178
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/controlbits.c
// Function: merge_64b
static void merge_64b(int n,uint64_t x[n],int step)
{
  int i;
  if (n == 1)
    minmax_64b(&x[0],&x[step]);
  else {
    merge_64b(n / 2,x,step * 2);
    merge_64b(n / 2,x + step,step * 2);
    for (i = 1;i < 2*n-1;i += 2)
      minmax_64b(&x[i * step],&x[(i + 1) * step]);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %rbx
cmpl $0x1, %edi
jne 0x41bd
movslq %r15d, %rax
movq (%rbx,%rax,8), %rcx
movq (%rbx), %rdx
movq %rdx, %rsi
shrq %rsi
movq %rdx, %rdi
xorq %rcx, %rdi
shrq %rcx
xorl %r8d, %r8d
cmpq %rsi, %rcx
cmovbq %rdi, %r8
xorq %r8, %rdx
movq %rdx, (%rbx)
xorq %r8, (%rbx,%rax,8)
jmp 0x423e
movl %edi, %r14d
movl %edi, %ebp
shrl $0x1f, %ebp
addl %edi, %ebp
sarl %ebp
leal (%r15,%r15), %r12d
movl %ebp, %edi
movq %rbx, %rsi
movl %r12d, %edx
callq 0x4178
movslq %r15d, %r15
leaq (%rbx,%r15,8), %rsi
movl %ebp, %edi
movl %r12d, %edx
callq 0x4178
cmpl $0x2, %r14d
jl 0x423e
leal -0x1(,%r14,2), %eax
cltq
movq %r15, %rcx
shlq $0x4, %rcx
movl $0x1, %edx
xorl %esi, %esi
movq (%rbx,%rcx), %rdi
movq (%rbx,%r15,8), %r8
movq %r8, %r9
shrq %r9
movq %r8, %r10
xorq %rdi, %r10
shrq %rdi
cmpq %r9, %rdi
cmovaeq %rsi, %r10
xorq %r10, %r8
movq %r8, (%rbx,%r15,8)
xorq %r10, (%rbx,%rcx)
addq %rcx, %rbx
addq $0x2, %rdx
cmpq %rax, %rdx
jl 0x4209
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/controlbits.c
// Function: composeinv
static void composeinv(int n,uint32_t y[n],uint32_t x[n],uint32_t pi[n]) /* // NC */
{
  int i;
  uint32_t t[n];

  for (i = 0;i < n;++i) 
    t[i] = x[i] | (pi[i] << 16);

  sort(n,t);

  for (i = 0;i < n;++i)
    y[i] = t[i] & 0xFFFF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %r15d
movl %edi, %r12d
movq %rsp, %r14
leaq 0xf(,%r12,4), %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
testl %edi, %edi
jle 0x428b
xorl %eax, %eax
movl (%rcx,%rax,4), %esi
shll $0x10, %esi
orl (%rdx,%rax,4), %esi
movl %esi, (%r14,%rax,4)
incq %rax
cmpq %rax, %r12
jne 0x4276
movl %r15d, %edi
movq %r14, %rsi
callq 0x42ba
testl %r15d, %r15d
jle 0x42ad
xorl %eax, %eax
movzwl (%r14,%rax,4), %ecx
movl %ecx, (%rbx,%rax,4)
incq %rax
cmpq %rax, %r12
jne 0x429d
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/controlbits.c
// Function: sort
static void sort(int n, uint32_t x[n])
{
  if (n <= 1) return;
  sort(n/2,x);
  sort(n/2,x + n/2);
  merge(n/2,x,1);
}

// Assembly:
cmpl $0x1, %edi
jg 0x42c0
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
shrl %r14d
movl %r14d, %edi
callq 0x42ba
leaq (%rbx,%r14,4), %rsi
movl %r14d, %edi
callq 0x42ba
movl %r14d, %edi
movq %rbx, %rsi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x42f5
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/controlbits.c
// Function: merge
static void merge(int n,uint32_t x[n],int step)
{
  int i;
  if (n == 1)
    minmax(&x[0],&x[step]);
  else {
    merge(n / 2,x,step * 2);
    merge(n / 2,x + step,step * 2);
    for (i = 1;i < 2*n-1;i += 2)
      minmax(&x[i * step],&x[(i + 1) * step]);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %rbx
cmpl $0x1, %edi
jne 0x4324
movslq %r15d, %rax
movl (%rbx,%rax,4), %ecx
movl (%rbx), %edx
movl %edx, %esi
xorl %ecx, %esi
subl %edx, %ecx
sarl $0x1f, %ecx
andl %esi, %ecx
xorl %ecx, %edx
movl %edx, (%rbx)
xorl %ecx, (%rbx,%rax,4)
jmp 0x439b
movl %edi, %r14d
movl %edi, %ebp
shrl $0x1f, %ebp
addl %edi, %ebp
sarl %ebp
leal (%r15,%r15), %r12d
movl %ebp, %edi
movq %rbx, %rsi
movl %r12d, %edx
callq 0x42f5
movslq %r15d, %r15
leaq (%rbx,%r15,4), %rsi
movl %ebp, %edi
movl %r12d, %edx
callq 0x42f5
cmpl $0x2, %r14d
jl 0x439b
leal -0x1(,%r14,2), %eax
cltq
leaq (,%r15,8), %rcx
movl $0x1, %edx
movl (%rbx,%r15,8), %esi
movl (%rbx,%r15,4), %edi
movl %edi, %r8d
xorl %esi, %r8d
subl %edi, %esi
sarl $0x1f, %esi
andl %r8d, %esi
xorl %esi, %edi
movl %edi, (%rbx,%r15,4)
xorl %esi, (%rbx,%r15,8)
addq $0x2, %rdx
addq %rcx, %rbx
cmpq %rax, %rdx
jl 0x436f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/crypto_hash_sha512.c
// Function: crypto_hash_sha512
int crypto_hash_sha512(unsigned char *o,const unsigned char *m, unsigned long long n) {

    long long i;
    unsigned char x[256];
    unsigned long long b = n;
    unsigned long long h[8] = {
        0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL, 0x3c6ef372fe94f82bULL, 0xa54ff53a5f1d36f1ULL,
        0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL, 0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL
    };

    blocks(h, m, n);
    m += n;
    n &= 127;
    m -= n;

    for (i = 0; i < sizeof x; ++i) x[i] = 0;
    for (i = 0; i < n; ++i) x[i] = m[i];
    x[n] = 128;

    n = 256 - 128 * (n < 112);
    x[n - 9] = b >> 61;
    store64_bigendian(x + n - 8, b << 3);
    blocks(h, x, n);

    for (i = 0; i < 8; ++i) store64_bigendian(o + 8 * i, h[i]);
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x140, %rsp            # imm = 0x140
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movaps 0x2d4c(%rip), %xmm0     # 0x7110
movq %rsp, %rdi
movaps %xmm0, 0x30(%rdi)
movaps 0x2d2e(%rip), %xmm0     # 0x7100
movaps %xmm0, 0x20(%rdi)
movaps 0x2d13(%rip), %xmm0     # 0x70f0
movaps %xmm0, 0x10(%rdi)
movaps 0x2cf8(%rip), %xmm0     # 0x70e0
movaps %xmm0, (%rdi)
callq 0x44ad
leaq 0x40(%rsp), %r15
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
xorl %esi, %esi
callq 0x1070
movq %r14, %r13
andq $0x7f, %r13
je 0x4423
addq %r14, %r12
subq %r13, %r12
leaq 0x40(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x10a0
movb $-0x80, 0x40(%rsp,%r13)
xorl %eax, %eax
cmpq $0x70, %r13
setae %al
shll $0x7, %eax
leaq 0x80(%rax), %rdx
movq %r14, %rcx
shrq $0x3d, %rcx
movb %cl, 0x77(%rax,%r15)
addq %rsp, %rax
addq $0xb8, %rax
shlq $0x3, %r14
movl $0x8, %ecx
movb %r14b, -0x1(%rax,%rcx)
shrq $0x8, %r14
decq %rcx
jne 0x445a
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x44ad
xorl %eax, %eax
movq (%rsp,%rax,8), %rcx
movl $0x8, %edx
movb %cl, -0x1(%rbx,%rdx)
shrq $0x8, %rcx
decq %rdx
jne 0x4480
incq %rax
addq $0x8, %rbx
cmpq $0x8, %rax
jne 0x4477
xorl %eax, %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/decrypt.c
// Function: decrypt
int decrypt(unsigned char *e, const unsigned char *sk, const unsigned char *c)
{
	int i, w = 0; 
	uint16_t check;	

	unsigned char r[ SYS_N/8 ];

	gf g[ SYS_T+1 ];
	gf L[ SYS_N ];

	gf s[ SYS_T*2 ];
	gf s_cmp[ SYS_T*2 ];
	gf locator[ SYS_T+1 ];
	gf images[ SYS_N ];

	gf t;

	/* // */

	for (i = 0; i < SYND_BYTES; i++)       r[i] = c[i];
	for (i = SYND_BYTES; i < SYS_N/8; i++) r[i] = 0;

	for (i = 0; i < SYS_T; i++) { g[i] = load2(sk); g[i] &= GFMASK; sk += 2; } g[ SYS_T ] = 1;

	support_gen(L, sk);

	synd(s, g, L, r);

	bm(locator, s);

	root(images, locator, L);

	/* // */
	
	for (i = 0; i < SYS_N/8; i++) 
		e[i] = 0;

	for (i = 0; i < SYS_N; i++)
	{
		t = gf_iszero(images[i]) & 1;

		e[ i/8 ] |= t << (i%8);
		w += t;

	}

	synd(s_cmp, g, L, e);

	/* // */

	check = w;
	check ^= SYS_T;

	for (i = 0; i < SYS_T*2; i++)
		check |= s[i] ^ s_cmp[i]; 

	check -= 1;
	check >>= 15;

	return check ^ 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x8a20, %rsp           # imm = 0x8A20
movq %rdx, %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x620(%rsp), %rdi
movl $0xd0, %edx
movq %rax, %rsi
callq 0x10a0
leaq 0x6f0(%rsp), %rdi
xorl %r12d, %r12d
movl $0x330, %edx            # imm = 0x330
xorl %esi, %esi
callq 0x1070
leaq (%r14,%r12), %rdi
callq 0x6b60
andl $0x1fff, %eax           # imm = 0x1FFF
movw %ax, (%rsp,%r12)
addq $0x2, %r12
cmpq $0x100, %r12            # imm = 0x100
jne 0x46e4
movq %rsp, %r15
movw $0x1, 0x100(%r15)
addq %r12, %r14
leaq 0x4a20(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x18c0
leaq 0x310(%rsp), %r14
leaq 0x620(%rsp), %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x69c4
leaq 0x510(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x19bc
leaq 0xa20(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x66f9
xorl %r14d, %r14d
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1070
xorl %ebp, %ebp
movzwl 0xa20(%rsp,%r14,2), %edi
callq 0x4f58
andl $0x1, %eax
movl %r14d, %ecx
andb $0x7, %cl
addl %eax, %ebp
shll %cl, %eax
movl %r14d, %ecx
shrl $0x3, %ecx
orb %al, (%rbx,%rcx)
incq %r14
cmpq $0x2000, %r14           # imm = 0x2000
jne 0x477f
leaq 0x110(%rsp), %rdi
movq %rsp, %rsi
leaq 0x4a20(%rsp), %rdx
movq %rbx, %rcx
callq 0x69c4
xorl $0x80, %ebp
xorl %eax, %eax
movzwl 0x110(%rsp,%rax,2), %ecx
xorw 0x310(%rsp,%rax,2), %cx
orl %ecx, %ebp
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x47d2
negl %ebp
movzwl %bp, %eax
shrl $0xf, %eax
addq $0x8a20, %rsp           # imm = 0x8A20
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/die.c
// Function: die_usage
void die_usage(const char *name, const char *why, const char *usage) {
    cleanup();
    outs(name);
    outs(": usage: ");
    outs(name);
    outs(" ");
    outs(usage);
    outs("\n");
    outs(name);
    outs(": fatal: ");
    outs(why);
    outs(": ");
    outs(e_str(errno));
    outs("\n");
    flush();
    _exit(111);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x122c
movq %r15, %rdi
callq 0x48ad
leaq 0x2b76(%rip), %rdi      # 0x73a0
callq 0x48ad
movq %r15, %rdi
callq 0x48ad
leaq 0x2b6a(%rip), %rdi      # 0x73a8
callq 0x48ad
movq %r14, %rdi
callq 0x48ad
leaq 0x2b58(%rip), %r14      # 0x73aa
movq %r14, %rdi
callq 0x48ad
movq %r15, %rdi
callq 0x48ad
leaq 0x2b43(%rip), %rdi      # 0x73ac
callq 0x48ad
movq %rbx, %rdi
callq 0x48ad
leaq 0x2b2a(%rip), %rdi      # 0x73a7
callq 0x48ad
callq 0x1040
movl (%rax), %edi
callq 0x49f8
movq %rax, %rdi
callq 0x48ad
movq %r14, %rdi
callq 0x48ad
callq 0x48ff
movl $0x6f, %edi
callq 0x1050
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/die.c
// Function: outs
static void outs(const char *x) {

    long long i;

    for(i = 0; x[i]; ++i) {
        if (buflen >= sizeof buf) flush();
        buf[buflen++] = x[i];
    }
}

// Assembly:
cmpb $0x0, (%rdi)
je 0x48fe
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
incq %rbx
leaq 0x25127d(%rip), %r14    # 0x255b40
cmpq $0x100, 0x251262(%rip) # imm = 0x100
jb 0x48d5
callq 0x48ff
movb -0x1(%rbx), %al
movq 0x251251(%rip), %rcx    # 0x255b30
leaq 0x1(%rcx), %rdx
movq %rdx, 0x251246(%rip)    # 0x255b30
movb %al, (%rcx,%r14)
cmpb $0x0, (%rbx)
leaq 0x1(%rbx), %rbx
jne 0x48c3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/die.c
// Function: die_temp
void die_temp(const char *name, const char *why) {
    cleanup();
    outs(name);
    outs(": fatal: ");
    outs(why);
    if (errno) {
        outs(": ");
        outs(e_str(errno));
    }
    outs("\n");
    flush();
    _exit(111);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x122c
movq %r14, %rdi
callq 0x48ad
leaq 0x2a5a(%rip), %rdi      # 0x73ac
callq 0x48ad
movq %rbx, %rdi
callq 0x48ad
callq 0x1040
cmpl $0x0, (%rax)
je 0x4987
movq %rax, %rbx
leaq 0x2a34(%rip), %rdi      # 0x73a7
callq 0x48ad
movl (%rbx), %edi
callq 0x49f8
movq %rax, %rdi
callq 0x48ad
leaq 0x2a1c(%rip), %rdi      # 0x73aa
callq 0x48ad
callq 0x48ff
movl $0x6f, %edi
callq 0x1050
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/die.c
// Function: die_perm
void die_perm(const char *name, const char *why) {
    cleanup();
    outs(name);
    outs(": fatal: ");
    outs(why);
    outs("\n");
    flush();
    _exit(100);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x122c
movq %r14, %rdi
callq 0x48ad
leaq 0x29ec(%rip), %rdi      # 0x73ac
callq 0x48ad
movq %rbx, %rdi
callq 0x48ad
leaq 0x29d6(%rip), %rdi      # 0x73aa
callq 0x48ad
callq 0x48ff
movl $0x64, %edi
callq 0x1050
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/encrypt.c
// Function: syndrome
void syndrome(unsigned char *s, const unsigned char *pk, unsigned char *e)
{
	unsigned char b, row[SYS_N/8];
	const unsigned char *pk_ptr = pk;

	int i, j;

	for (i = 0; i < SYND_BYTES; i++)
		s[i] = 0;

	for (i = 0; i < PK_NROWS; i++)	
	{
		for (j = 0; j < SYS_N/8; j++) 
			row[j] = 0;

		for (j = 0; j < PK_ROW_BYTES; j++) 
			row[ SYS_N/8 - PK_ROW_BYTES + j ] = pk_ptr[j];

		row[i/8] |= 1 << (i%8);
		
		b = 0;
		for (j = 0; j < SYS_N/8; j++)
			b ^= row[j] & e[j];

		b ^= b >> 4;
		b ^= b >> 2;
		b ^= b >> 1;
		b &= 1;

		s[ i/8 ] |= (b << (i%8));

		pk_ptr += PK_ROW_BYTES;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
movl $0xd0, %edx
xorl %esi, %esi
callq 0x1070
movq %rsp, %r13
xorl %r12d, %r12d
movl $0x400, %edx            # imm = 0x400
movq %r13, %rdi
xorl %esi, %esi
callq 0x1070
movl $0x330, %edx            # imm = 0x330
leaq 0xd0(%rsp), %rdi
movq %r14, %rsi
callq 0x10a0
movl %ebp, %ecx
andl $0x7, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %ebp, %eax
shrl $0x3, %eax
orb %dl, (%rsp,%rax)
xorl %edx, %edx
movb (%rbx,%r12), %sil
andb (%rsp,%r12), %sil
xorb %sil, %dl
incq %r12
cmpq $0x400, %r12            # imm = 0x400
jne 0x4d98
movl %edx, %esi
shrb $0x4, %sil
xorb %dl, %sil
movl %esi, %edx
shrb $0x2, %dl
xorb %sil, %dl
movl %edx, %esi
shrb %sil
xorb %dl, %sil
andb $0x1, %sil
movzbl %sil, %edx
shll %cl, %edx
orb %dl, (%r15,%rax)
addq $0x330, %r14            # imm = 0x330
incl %ebp
cmpl $0x680, %ebp            # imm = 0x680
jne 0x4d5b
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/fsyncfd.c
// Function: fsyncfd
int fsyncfd(int fd) {

    struct stat st;

    if (fstat(fd, &st) == 0 && S_ISREG(st.st_mode)) {
        if (fsync(fd) == -1) return -1;
    }
    return 0;
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
movl %edi, %ebx
movq %rsp, %rsi
callq 0x1120
testl %eax, %eax
jne 0x4f46
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x4f46
movl %ebx, %edi
callq 0x10f0
cmpl $-0x1, %eax
je 0x4f51
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x4f48
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/gf.c
// Function: gf_mul
gf gf_mul(gf in0, gf in1)
{
	int i;

	uint64_t tmp;
	uint64_t t0;
	uint64_t t1;
	uint64_t t;

	t0 = in0;
	t1 = in1;

	tmp = t0 * (t1 & 1);

	for (i = 1; i < GFBITS; i++)
		tmp ^= (t0 * (t1 & (1 << i)));

	/* // */

	t = tmp & 0x1FF0000;
	tmp ^= (t >> 9) ^ (t >> 10) ^ (t >> 12) ^ (t >> 13);

	t = tmp & 0x000E000;
	tmp ^= (t >> 9) ^ (t >> 10) ^ (t >> 12) ^ (t >> 13);

	return tmp & GFMASK;
}

// Assembly:
movl %edi, %eax
xorl %edx, %edx
testb $0x1, %sil
cmovneq %rax, %rdx
movl $0x1, %ecx
movl $0x1, %edi
shll %cl, %edi
andl %esi, %edi
imulq %rax, %rdi
xorq %rdi, %rdx
incl %ecx
cmpl $0xd, %ecx
jne 0x4f75
movl %edx, %eax
andl $0x1ff0000, %eax        # imm = 0x1FF0000
movl %eax, %ecx
shrl $0x9, %ecx
movl %eax, %esi
shrl $0xa, %esi
xorl %ecx, %esi
movl %eax, %ecx
shrl $0xc, %ecx
shrl $0xd, %eax
xorl %ecx, %eax
xorl %esi, %eax
xorl %edx, %eax
movl %eax, %ecx
andl $0xe000, %ecx           # imm = 0xE000
movl %ecx, %edx
shrl $0x9, %edx
movl %ecx, %esi
shrl $0xa, %esi
movl %ecx, %edi
shrl $0xc, %edi
xorl %edx, %edi
shrl $0xd, %ecx
andl $0x1fff, %eax           # imm = 0x1FFF
xorl %esi, %eax
xorl %edi, %eax
xorl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/gf.c
// Function: gf_mul2
uint64_t gf_mul2(gf a, gf b0, gf b1)
{
	int i;

	uint64_t tmp=0;
	uint64_t t0;
	uint64_t t1;
	uint64_t t;
	uint64_t mask = 0x0000000100000001;

	t0 = a;
	t1 = b1;
	t1 = (t1 << 32) | b0;
	
	for (i = 0; i < GFBITS; i++)
	{
		tmp ^= t0 * (t1 & mask);
		mask += mask;
	}

	/* // */

	t = tmp & 0x01FF000001FF0000;
	tmp ^= (t >> 9) ^ (t >> 10) ^ (t >> 12) ^ (t >> 13);

	t = tmp & 0x0000E0000000E000;
	tmp ^= (t >> 9) ^ (t >> 10) ^ (t >> 12) ^ (t >> 13);

	return tmp & 0x00001FFF00001FFF;
}

// Assembly:
movl %edi, %ecx
shlq $0x20, %rdx
movl %esi, %esi
orq %rdx, %rsi
movabsq $0x100000001, %rdx      # imm = 0x100000001
movl $0xd, %edi
xorl %eax, %eax
movq %rdx, %r8
andq %rsi, %r8
imulq %rcx, %r8
xorq %r8, %rax
addq %rdx, %rdx
decl %edi
jne 0x4ff1
movabsq $0x1ff000001ff0000, %rcx # imm = 0x1FF000001FF0000
andq %rax, %rcx
movq %rcx, %rdx
shrq $0x9, %rdx
movq %rcx, %rsi
shrq $0xa, %rsi
xorq %rdx, %rsi
movq %rcx, %rdx
shrq $0xc, %rdx
shrq $0xd, %rcx
xorq %rdx, %rcx
xorq %rsi, %rcx
xorq %rax, %rcx
movabsq $0xe0000000e000, %rdx   # imm = 0xE0000000E000
andq %rcx, %rdx
movq %rdx, %rax
shrq $0x9, %rax
movq %rdx, %rsi
shrq $0xa, %rsi
movq %rdx, %rdi
shrq $0xc, %rdi
xorq %rax, %rdi
shrq $0xd, %rdx
movabsq $0x1fff00001fff, %rax   # imm = 0x1FFF00001FFF
andq %rcx, %rax
xorq %rsi, %rax
xorq %rdi, %rax
xorq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/gf.c
// Function: GF_mul
void GF_mul(gf *out, gf *in0, gf *in1)
{
	int i, j;

	gf prod[255];

	for (i = 0; i < 255; i++)
		prod[i] = 0;

	for (i = 0; i < 128; i++)
		for (j = 0; j < 128; j++)
			prod[i+j] ^= gf_mul(in0[i], in1[j]);

	/* // */
 
	for (i = 254; i >= 128; i--)
	{
		prod[i - 123] ^= gf_mul(prod[i], (gf) 7682);
		prod[i - 125] ^= gf_mul(prod[i], (gf) 2159);
		prod[i - 128] ^= gf_mul(prod[i], (gf) 3597);
	}

	for (i = 0; i < 128; i++)
		out[i] = prod[i];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
leaq 0x10(%rsp), %r12
xorl %r13d, %r13d
movl $0x1fe, %edx            # imm = 0x1FE
movq %r12, %rdi
xorl %esi, %esi
callq 0x1070
movzwl (%r15,%r13,2), %ebp
xorl %ebx, %ebx
movzwl (%r14,%rbx,2), %esi
movl %ebp, %edi
callq 0x4f64
xorw %ax, (%r12,%rbx,2)
incq %rbx
cmpq $0x80, %rbx
jne 0x5727
incq %r13
addq $0x2, %r12
cmpq $0x80, %r13
jne 0x5720
movl $0xff, %r14d
movzwl 0xe(%rsp,%r14,2), %ebp
movl %ebp, %edi
movl $0x1e02, %esi           # imm = 0x1E02
callq 0x4f64
xorw %ax, -0xe8(%rsp,%r14,2)
movl %ebp, %edi
movl $0x86f, %esi            # imm = 0x86F
callq 0x4f64
xorw %ax, -0xec(%rsp,%r14,2)
movl %ebp, %edi
movl $0xe0d, %esi            # imm = 0xE0D
callq 0x4f64
xorw %ax, -0xf2(%rsp,%r14,2)
decq %r14
cmpq $0x80, %r14
ja 0x575a
leaq 0x10(%rsp), %rsi
movl $0x100, %edx            # imm = 0x100
movq 0x8(%rsp), %rdi
callq 0x10a0
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/memreadall.c
// Function: memreadall
unsigned char *memreadall(unsigned long long *len, int fd) {

    unsigned char *buf = 0;
    unsigned char *newbuf;
    unsigned long long bufalloc = 0;
    unsigned long long pos = 0;
    long long r;

    for (;;) {
        if (bufalloc <= pos + CHUNK) {
            while (bufalloc <= pos + CHUNK) {
                bufalloc = bufalloc * 2 + CHUNK;
                if (bufalloc != (unsigned long long)(size_t)bufalloc) goto nomem;
                if (bufalloc >= MAX) goto nomem;
            }
            newbuf = realloc(buf, bufalloc);
            if (!newbuf) goto nomem;
            buf = newbuf;
        }

        r = read(fd, buf + pos, CHUNK);
        if (r == -1) { free(buf); return 0; }
        if (r == 0) { *len = pos; return buf; }
        pos += r;
    }
    

nomem:
    errno = ENOMEM;
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
xorl %ebx, %ebx
xorl %r15d, %r15d
xorl %r12d, %r12d
leaq 0x1000(%r12), %rax
cmpq %rax, %r15
ja 0x5861
cmpq %rax, %r15
ja 0x584e
leaq 0x1000(,%r15,2), %r15
movq %r15, %rcx
shrq $0x3e, %rcx
je 0x5836
jmp 0x5881
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10c0
movq %rax, %rbx
testq %rax, %rax
je 0x5881
leaq (%rbx,%r12), %rsi
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
callq 0x1090
testq %rax, %rax
je 0x589a
cmpq $-0x1, %rax
je 0x589f
addq %rax, %r12
jmp 0x5829
callq 0x1040
movl $0xc, (%rax)
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r12, (%r14)
jmp 0x588e
movq %rbx, %rdi
callq 0x1030
jmp 0x588c
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/operations.c
// Function: crypto_kem_mceliece8192128sha512_enc
int crypto_kem_mceliece8192128sha512_enc(
       unsigned char *c,
       unsigned char *key,
       const unsigned char *pk
)
{
	unsigned char two_e[ 1 + SYS_N/8 ] = {2};
	unsigned char *e = two_e + 1;
	unsigned char one_ec[ 1 + SYS_N/8 + (SYND_BYTES + 32) ] = {1};
	unsigned char conf[64];
    long long i;

	/* // */

	encrypt(c, pk, e);

	crypto_hash_sha512(conf, two_e, sizeof(two_e)); 
    for (i = 0; i < 32; ++i) c[SYND_BYTES + i] = conf[i];

	memcpy(one_ec + 1,e,SYS_N/8);
	memcpy(one_ec + 1 + SYS_N/8,c,SYND_BYTES + 32);

	crypto_hash_sha512(key, one_ec, sizeof one_ec);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x948, %rsp            # imm = 0x948
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x540(%rsp), %r13
movl $0x401, %edx            # imm = 0x401
movq %r13, %rdi
xorl %esi, %esi
callq 0x1070
movb $0x2, (%r13)
leaq 0x541(%rsp), %r12
leaq 0x40(%rsp), %r15
movl $0x4f1, %edx            # imm = 0x4F1
movq %r15, %rdi
xorl %esi, %esi
callq 0x1070
movb $0x1, (%r15)
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x4dfd
movq %rsp, %rbp
movl $0x401, %edx            # imm = 0x401
movq %rbp, %rdi
movq %r13, %rsi
callq 0x43a4
movaps (%rbp), %xmm0
movaps 0x10(%rbp), %xmm1
movups %xmm0, 0xd0(%r14)
movups %xmm1, 0xe0(%r14)
leaq 0x41(%rsp), %rdi
movl $0x400, %edx            # imm = 0x400
movq %r12, %rsi
callq 0x10a0
leaq 0x441(%rsp), %rdi
movl $0xf0, %edx
movq %r14, %rsi
callq 0x10a0
movl $0x4f1, %edx            # imm = 0x4F1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x43a4
xorl %eax, %eax
addq $0x948, %rsp            # imm = 0x948
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/operations.c
// Function: crypto_kem_mceliece8192128sha512_dec
int crypto_kem_mceliece8192128sha512_dec(
       unsigned char *key,
       const unsigned char *c,
       const unsigned char *sk
)
{
	int i;

	unsigned char ret_confirm = 0;
	unsigned char ret_decrypt = 0;

	uint16_t m;

	unsigned char conf[64];
	unsigned char two_e[ 1 + SYS_N/8 ] = {2};
	unsigned char *e = two_e + 1;
	unsigned char preimage[ 1 + SYS_N/8 + (SYND_BYTES + 32) ];

	/* // */

	ret_decrypt = decrypt(e, sk + SYS_N/8, c);

	crypto_hash_sha512(conf, two_e, sizeof(two_e)); 

	for (i = 0; i < 32; i++)
		ret_confirm |= conf[i] ^ c[SYND_BYTES + i];

	m = ret_decrypt | ret_confirm;
	m -= 1;
	m >>= 8;

	{
		unsigned char *x = preimage;
		*x++ = (~m & 0) |  (m & 1);
		for (i = 0; i < SYS_N/8; i++) 
			*x++ = (~m & sk[i]) | (m & e[i]);
		for (i = 0; i < SYND_BYTES + 32; i++) 
			*x++ = c[i];
	}

	crypto_hash_sha512(key, preimage, sizeof(preimage)); 

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x948, %rsp            # imm = 0x948
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x540(%rsp), %r12
xorl %r13d, %r13d
movl $0x401, %edx            # imm = 0x401
movq %r12, %rdi
xorl %esi, %esi
callq 0x1070
movb $0x2, (%r12)
leaq 0x541(%rsp), %rdi
leaq 0x400(%r15), %rsi
movq %r14, %rdx
callq 0x46a0
movl %eax, %ebp
movq %rsp, %rdi
movl $0x401, %edx            # imm = 0x401
movq %r12, %rsi
callq 0x43a4
xorl %eax, %eax
movb 0xd0(%r14,%r13), %cl
xorb (%rsp,%r13), %cl
orb %cl, %al
incq %r13
cmpq $0x20, %r13
jne 0x59ea
movzbl %bpl, %ecx
movzbl %al, %eax
orl %ecx, %eax
addl $0xffff, %eax           # imm = 0xFFFF
shrl $0x8, %eax
movl %eax, %ecx
notl %ecx
movl %eax, %edx
andb $0x1, %dl
movb %dl, 0x40(%rsp)
movl $0x1, %edx
movzbl -0x1(%r15,%rdx), %esi
andl %ecx, %esi
movzbl 0x540(%rsp,%rdx), %edi
andl %eax, %edi
orl %esi, %edi
movb %dil, 0x40(%rsp,%rdx)
incq %rdx
cmpq $0x401, %rdx            # imm = 0x401
jne 0x5a24
leaq (%rsp,%rdx), %rdi
addq $0x40, %rdi
movl $0xf0, %edx
movq %r14, %rsi
callq 0x10a0
leaq 0x40(%rsp), %rsi
movl $0x4f1, %edx            # imm = 0x4F1
movq %rbx, %rdi
callq 0x43a4
xorl %eax, %eax
addq $0x948, %rsp            # imm = 0x948
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/poly1305.c
// Function: poly1305_init
void poly1305_init(poly1305_ctx *ctx, const unsigned char *k) {

    /* r &= 0xffffffc0ffffffc0ffffffc0fffffff */
    ctx->r[0] = (unpack(k +  0)     ) & 0x3ffffff;
    ctx->r[1] = (unpack(k +  3) >> 2) & 0x3ffff03;
    ctx->r[2] = (unpack(k +  6) >> 4) & 0x3ffc0ff;
    ctx->r[3] = (unpack(k +  9) >> 6) & 0x3f03fff;
    ctx->r[4] = (unpack(k + 12) >> 8) & 0x00fffff;

    ctx->s[1] = ctx->r[1] * 5;
    ctx->s[2] = ctx->r[2] * 5;
    ctx->s[3] = ctx->r[3] * 5;
    ctx->s[4] = ctx->r[4] * 5;

    /* h = 0 */
    ctx->h[0] = 0;
    ctx->h[1] = 0;
    ctx->h[2] = 0;
    ctx->h[3] = 0;
    ctx->h[4] = 0;

    ctx->pad[0] = unpack(k + 16);
    ctx->pad[1] = unpack(k + 20);
    ctx->pad[2] = unpack(k + 24);
    ctx->pad[3] = unpack(k + 28);
}

// Assembly:
movzwl (%rsi), %eax
movzbl 0x2(%rsi), %ecx
shll $0x10, %ecx
orq %rax, %rcx
movzbl 0x3(%rsi), %eax
andl $0x3, %eax
shll $0x18, %eax
orq %rcx, %rax
movq %rax, 0x28(%rdi)
movl 0x3(%rsi), %eax
shrl $0x2, %eax
andl $0x3ffff03, %eax        # imm = 0x3FFFF03
movq %rax, 0x30(%rdi)
movl 0x6(%rsi), %ecx
shrl $0x4, %ecx
andl $0x3ffc0ff, %ecx        # imm = 0x3FFC0FF
movq %rcx, 0x38(%rdi)
movl 0x9(%rsi), %edx
shrl $0x6, %edx
andl $0x3f03fff, %edx        # imm = 0x3F03FFF
movq %rdx, 0x40(%rdi)
movzwl 0xd(%rsi), %r8d
movzbl 0xf(%rsi), %r9d
andl $0xf, %r9d
shll $0x10, %r9d
orq %r8, %r9
movq %r9, 0x48(%rdi)
leaq (%rax,%rax,4), %rax
movq %rax, 0x58(%rdi)
leaq (%rcx,%rcx,4), %rax
movq %rax, 0x60(%rdi)
leaq (%rdx,%rdx,4), %rax
movq %rax, 0x68(%rdi)
leaq (%r9,%r9,4), %rax
movq %rax, 0x70(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
movl 0x10(%rsi), %eax
movq %rax, 0x78(%rdi)
movl 0x14(%rsi), %eax
movq %rax, 0x80(%rdi)
movl 0x18(%rsi), %eax
movq %rax, 0x88(%rdi)
movl 0x1c(%rsi), %eax
movq %rax, 0x90(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/janmojzis[P]mcencrypt/poly1305.c
// Function: poly1305
void poly1305(unsigned char *o, const unsigned char *m, unsigned long long n, const unsigned char *k) {

    poly1305_ctx ctx;

    poly1305_init(&ctx, k);
    poly1305_blocks(&ctx, m, n);
    poly1305_final(&ctx, o);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %r12
movq %r12, %rdi
movq %rcx, %rsi
callq 0x5e68
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5f26
movq %r12, %rdi
movq %r15, %rsi
callq 0x6308
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq