#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ pack(unsigned char *, unsigned long);
unsigned long long unpack(unsigned char const *);
int crypto_onetimeauth_poly1305_tinynacl(unsigned char *o,
                                         const unsigned char *m,
                                         unsigned long long n,
                                         const unsigned char *k) {
  unsigned long h0, h1, h2, h3, h4;
  unsigned long r0, r1, r2, r3, r4;
  unsigned long s1, s2, s3, s4;
  unsigned long long d0, d1, d2, d3, d4;
  unsigned long c, mask;
  unsigned long long f;
  long long i;
  r0 = (unpack(k + 0)) & 0x3ffffff;
  r1 = (unpack(k + 3) >> 2) & 0x3ffff03;
  r2 = (unpack(k + 6) >> 4) & 0x3ffc0ff;
  r3 = (unpack(k + 9) >> 6) & 0x3f03fff;
  r4 = (unpack(k + 12) >> 8) & 0x00fffff;
  s1 = r1 * 5;
  s2 = r2 * 5;
  s3 = r3 * 5;
  s4 = r4 * 5;
  h0 = h1 = h2 = h3 = h4 = 0;
  while ((long long)n > 0) {
    if (n >= 16) {
      h0 += (unpack(m)) & 0x3ffffff;
      h1 += (unpack(m + 3) >> 2) & 0x3ffffff;
      h2 += (unpack(m + 6) >> 4) & 0x3ffffff;
      h3 += (unpack(m + 9) >> 6) & 0x3ffffff;
      h4 += (unpack(m + 12) >> 8) | 16777216;
    } else {
      unsigned char mm[16];
      for (i = 0; i < 16; ++i)
        mm[i] = 0;
      for (i = 0; i < n; ++i)
        mm[i] = m[i];
      mm[i] = 1;
      h0 += (unpack(mm)) & 0x3ffffff;
      h1 += (unpack(mm + 3) >> 2) & 0x3ffffff;
      h2 += (unpack(mm + 6) >> 4) & 0x3ffffff;
      h3 += (unpack(mm + 9) >> 6) & 0x3ffffff;
      h4 += (unpack(mm + 12) >> 8);
    }
    d0 = ((unsigned long long)h0 * r0) + ((unsigned long long)h1 * s4) +
         ((unsigned long long)h2 * s3) + ((unsigned long long)h3 * s2) +
         ((unsigned long long)h4 * s1);
    d1 = ((unsigned long long)h0 * r1) + ((unsigned long long)h1 * r0) +
         ((unsigned long long)h2 * s4) + ((unsigned long long)h3 * s3) +
         ((unsigned long long)h4 * s2);
    d2 = ((unsigned long long)h0 * r2) + ((unsigned long long)h1 * r1) +
         ((unsigned long long)h2 * r0) + ((unsigned long long)h3 * s4) +
         ((unsigned long long)h4 * s3);
    d3 = ((unsigned long long)h0 * r3) + ((unsigned long long)h1 * r2) +
         ((unsigned long long)h2 * r1) + ((unsigned long long)h3 * r0) +
         ((unsigned long long)h4 * s4);
    d4 = ((unsigned long long)h0 * r4) + ((unsigned long long)h1 * r3) +
         ((unsigned long long)h2 * r2) + ((unsigned long long)h3 * r1) +
         ((unsigned long long)h4 * r0);
    c = (unsigned long)(d0 >> 26);
    h0 = (unsigned long)d0 & 0x3ffffff;
    d1 += c;
    c = (unsigned long)(d1 >> 26);
    h1 = (unsigned long)d1 & 0x3ffffff;
    d2 += c;
    c = (unsigned long)(d2 >> 26);
    h2 = (unsigned long)d2 & 0x3ffffff;
    d3 += c;
    c = (unsigned long)(d3 >> 26);
    h3 = (unsigned long)d3 & 0x3ffffff;
    d4 += c;
    c = (unsigned long)(d4 >> 26);
    h4 = (unsigned long)d4 & 0x3ffffff;
    h0 += c * 5;
    c = (h0 >> 26);
    h0 = h0 & 0x3ffffff;
    h1 += c;
    m += 16;
    n -= 16;
  }
  c = h1 >> 26;
  h1 = h1 & 0x3ffffff;
  h2 += c;
  c = h2 >> 26;
  h2 = h2 & 0x3ffffff;
  h3 += c;
  c = h3 >> 26;
  h3 = h3 & 0x3ffffff;
  h4 += c;
  c = h4 >> 26;
  h4 = h4 & 0x3ffffff;
  h0 += c * 5;
  c = h0 >> 26;
  h0 = h0 & 0x3ffffff;
  h1 += c;
  r0 = h0 + 5;
  c = r0 >> 26;
  r0 &= 0x3ffffff;
  r1 = h1 + c;
  c = r1 >> 26;
  r1 &= 0x3ffffff;
  r2 = h2 + c;
  c = r2 >> 26;
  r2 &= 0x3ffffff;
  r3 = h3 + c;
  c = r3 >> 26;
  r3 &= 0x3ffffff;
  r4 = h4 + c - (1 << 26);
  mask = (r4 >> ((sizeof(unsigned long) * 8) - 1)) - 1;
  r0 &= mask;
  r1 &= mask;
  r2 &= mask;
  r3 &= mask;
  r4 &= mask;
  mask = ~mask;
  h0 = (h0 & mask) | r0;
  h1 = (h1 & mask) | r1;
  h2 = (h2 & mask) | r2;
  h3 = (h3 & mask) | r3;
  h4 = (h4 & mask) | r4;
  h0 = ((h0) | (h1 << 26)) & 0xffffffff;
  h1 = ((h1 >> 6) | (h2 << 20)) & 0xffffffff;
  h2 = ((h2 >> 12) | (h3 << 14)) & 0xffffffff;
  h3 = ((h3 >> 18) | (h4 << 8)) & 0xffffffff;
  f = (unsigned long long)h0 + unpack(k + 16);
  h0 = (unsigned long)f;
  f = (unsigned long long)h1 + unpack(k + 20) + (f >> 32);
  h1 = (unsigned long)f;
  f = (unsigned long long)h2 + unpack(k + 24) + (f >> 32);
  h2 = (unsigned long)f;
  f = (unsigned long long)h3 + unpack(k + 28) + (f >> 32);
  h3 = (unsigned long)f;
  pack(o + 0, h0);
  pack(o + 4, h1);
  pack(o + 8, h2);
  pack(o + 12, h3);
  return 0;
}


x86 assembly (clang, -O0):
<crypto_onetimeauth_poly1305_tinynacl>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x20(%rbp),%rdi
call   1040 <unpack@plt>
and    $0x3ffffff,%rax
mov    %rax,-0x50(%rbp)
mov    -0x20(%rbp),%rdi
add    $0x3,%rdi
call   1040 <unpack@plt>
shr    $0x2,%rax
and    $0x3ffff03,%rax
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%rdi
add    $0x6,%rdi
call   1040 <unpack@plt>
shr    $0x4,%rax
and    $0x3ffc0ff,%rax
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%rdi
add    $0x9,%rdi
call   1040 <unpack@plt>
shr    $0x6,%rax
and    $0x3f03fff,%rax
mov    %rax,-0x68(%rbp)
mov    -0x20(%rbp),%rdi
add    $0xc,%rdi
call   1040 <unpack@plt>
shr    $0x8,%rax
and    $0xfffff,%rax
mov    %rax,-0x70(%rbp)
imul   $0x5,-0x58(%rbp),%rax
mov    %rax,-0x78(%rbp)
imul   $0x5,-0x60(%rbp),%rax
mov    %rax,-0x80(%rbp)
imul   $0x5,-0x68(%rbp),%rax
mov    %rax,-0x88(%rbp)
imul   $0x5,-0x70(%rbp),%rax
mov    %rax,-0x90(%rbp)
movq   $0x0,-0x48(%rbp)
movq   $0x0,-0x40(%rbp)
movq   $0x0,-0x38(%rbp)
movq   $0x0,-0x30(%rbp)
movq   $0x0,-0x28(%rbp)
cmpq   $0x0,-0x18(%rbp)
jle    16a4 <crypto_onetimeauth_poly1305_tinynacl+0x584>
cmpq   $0x10,-0x18(%rbp)
jb     12ba <crypto_onetimeauth_poly1305_tinynacl+0x19a>
mov    -0x10(%rbp),%rdi
call   1040 <unpack@plt>
and    $0x3ffffff,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rdi
add    $0x3,%rdi
call   1040 <unpack@plt>
shr    $0x2,%rax
and    $0x3ffffff,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rdi
add    $0x6,%rdi
call   1040 <unpack@plt>
shr    $0x4,%rax
and    $0x3ffffff,%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rdi
add    $0x9,%rdi
call   1040 <unpack@plt>
shr    $0x6,%rax
and    $0x3ffffff,%rax
add    -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rdi
add    $0xc,%rdi
call   1040 <unpack@plt>
shr    $0x8,%rax
or     $0x1000000,%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
jmp    13f3 <crypto_onetimeauth_poly1305_tinynacl+0x2d3>
movq   $0x0,-0xd8(%rbp)
cmpq   $0x10,-0xd8(%rbp)
10
jge    12f9 <crypto_onetimeauth_poly1305_tinynacl+0x1d9>
mov    -0xd8(%rbp),%rax
movb   $0x0,-0xf0(%rbp,%rax,1)
mov    -0xd8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xd8(%rbp)
jmp    12c5 <crypto_onetimeauth_poly1305_tinynacl+0x1a5>
movq   $0x0,-0xd8(%rbp)
mov    -0xd8(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1348 <crypto_onetimeauth_poly1305_tinynacl+0x228>
mov    -0x10(%rbp),%rax
mov    -0xd8(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0xd8(%rbp),%rax
mov    %cl,-0xf0(%rbp,%rax,1)
mov    -0xd8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xd8(%rbp)
jmp    1304 <crypto_onetimeauth_poly1305_tinynacl+0x1e4>
mov    -0xd8(%rbp),%rax
movb   $0x1,-0xf0(%rbp,%rax,1)
01
lea    -0xf0(%rbp),%rdi
call   1040 <unpack@plt>
and    $0x3ffffff,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
lea    -0xf0(%rbp),%rdi
add    $0x3,%rdi
call   1040 <unpack@plt>
shr    $0x2,%rax
and    $0x3ffffff,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
lea    -0xf0(%rbp),%rdi
add    $0x6,%rdi
call   1040 <unpack@plt>
shr    $0x4,%rax
and    $0x3ffffff,%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
lea    -0xf0(%rbp),%rdi
add    $0x9,%rdi
call   1040 <unpack@plt>
shr    $0x6,%rax
and    $0x3ffffff,%rax
add    -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
lea    -0xf0(%rbp),%rdi
add    $0xc,%rdi
call   1040 <unpack@plt>
shr    $0x8,%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%rax
imul   -0x50(%rbp),%rax
mov    -0x30(%rbp),%rcx
imul   -0x90(%rbp),%rcx
ff
add    %rcx,%rax
mov    -0x38(%rbp),%rcx
imul   -0x88(%rbp),%rcx
ff
add    %rcx,%rax
mov    -0x40(%rbp),%rcx
imul   -0x80(%rbp),%rcx
add    %rcx,%rax
mov    -0x48(%rbp),%rcx
imul   -0x78(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x28(%rbp),%rax
imul   -0x58(%rbp),%rax
mov    -0x30(%rbp),%rcx
imul   -0x50(%rbp),%rcx
add    %rcx,%rax
mov    -0x38(%rbp),%rcx
imul   -0x90(%rbp),%rcx
ff
add    %rcx,%rax
mov    -0x40(%rbp),%rcx
imul   -0x88(%rbp),%rcx
ff
add    %rcx,%rax
mov    -0x48(%rbp),%rcx
imul   -0x80(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x28(%rbp),%rax
imul   -0x60(%rbp),%rax
mov    -0x30(%rbp),%rcx
imul   -0x58(%rbp),%rcx
add    %rcx,%rax
mov    -0x38(%rbp),%rcx
imul   -0x50(%rbp),%rcx
add    %rcx,%rax
mov    -0x40(%rbp),%rcx
imul   -0x90(%rbp),%rcx
ff
add    %rcx,%rax
mov    -0x48(%rbp),%rcx
imul   -0x88(%rbp),%rcx
ff
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0x28(%rbp),%rax
imul   -0x68(%rbp),%rax
mov    -0x30(%rbp),%rcx
imul   -0x60(%rbp),%rcx
add    %rcx,%rax
mov    -0x38(%rbp),%rcx
imul   -0x58(%rbp),%rcx
add    %rcx,%rax
mov    -0x40(%rbp),%rcx
imul   -0x50(%rbp),%rcx
add    %rcx,%rax
mov    -0x48(%rbp),%rcx
imul   -0x90(%rbp),%rcx
ff
add    %rcx,%rax
mov    %rax,-0xb0(%rbp)
mov    -0x28(%rbp),%rax
imul   -0x70(%rbp),%rax
mov    -0x30(%rbp),%rcx
imul   -0x68(%rbp),%rcx
add    %rcx,%rax
mov    -0x38(%rbp),%rcx
imul   -0x60(%rbp),%rcx
add    %rcx,%rax
mov    -0x40(%rbp),%rcx
imul   -0x58(%rbp),%rcx
add    %rcx,%rax
mov    -0x48(%rbp),%rcx
imul   -0x50(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0xb8(%rbp)
mov    -0x98(%rbp),%rax
shr    $0x1a,%rax
mov    %rax,-0xc0(%rbp)
mov    -0x98(%rbp),%rax
and    $0x3ffffff,%rax
mov    %rax,-0x28(%rbp)
mov    -0xc0(%rbp),%rax
add    -0xa0(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0xa0(%rbp),%rax
shr    $0x1a,%rax
mov    %rax,-0xc0(%rbp)
mov    -0xa0(%rbp),%rax
and    $0x3ffffff,%rax
mov    %rax,-0x30(%rbp)
mov    -0xc0(%rbp),%rax
add    -0xa8(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rax
shr    $0x1a,%rax
mov    %rax,-0xc0(%rbp)
mov    -0xa8(%rbp),%rax
and    $0x3ffffff,%rax
mov    %rax,-0x38(%rbp)
mov    -0xc0(%rbp),%rax
add    -0xb0(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xb0(%rbp),%rax
shr    $0x1a,%rax
mov    %rax,-0xc0(%rbp)
mov    -0xb0(%rbp),%rax
and    $0x3ffffff,%rax
mov    %rax,-0x40(%rbp)
mov    -0xc0(%rbp),%rax
add    -0xb8(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xb8(%rbp),%rax
shr    $0x1a,%rax
mov    %rax,-0xc0(%rbp)
mov    -0xb8(%rbp),%rax
and    $0x3ffffff,%rax
mov    %rax,-0x48(%rbp)
imul   $0x5,-0xc0(%rbp),%rax
05
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
shr    $0x1a,%rax
mov    %rax,-0xc0(%rbp)
mov    -0x28(%rbp),%rax
and    $0x3ffffff,%rax
mov    %rax,-0x28(%rbp)
mov    -0xc0(%rbp),%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
sub    $0x10,%rax
mov    %rax,-0x18(%rbp)
jmp    120c <crypto_onetimeauth_poly1305_tinynacl+0xec>
mov    -0x30(%rbp),%rax
shr    $0x1a,%rax
mov    %rax,-0xc0(%rbp)
mov    -0x30(%rbp),%rax
and    $0x3ffffff,%rax
mov    %rax,-0x30(%rbp)
mov    -0xc0(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
shr    $0x1a,%rax
mov    %rax,-0xc0(%rbp)
mov    -0x38(%rbp),%rax
and    $0x3ffffff,%rax
mov    %rax,-0x38(%rbp)
mov    -0xc0(%rbp),%rax
add    -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
shr    $0x1a,%rax
mov    %rax,-0xc0(%rbp)
mov    -0x40(%rbp),%rax
and    $0x3ffffff,%rax
mov    %rax,-0x40(%rbp)
mov    -0xc0(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
shr    $0x1a,%rax
mov    %rax,-0xc0(%rbp)
mov    -0x48(%rbp),%rax
and    $0x3ffffff,%rax
mov    %rax,-0x48(%rbp)
imul   $0x5,-0xc0(%rbp),%rax
05
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
shr    $0x1a,%rax
mov    %rax,-0xc0(%rbp)
mov    -0x28(%rbp),%rax
and    $0x3ffffff,%rax
mov    %rax,-0x28(%rbp)
mov    -0xc0(%rbp),%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
add    $0x5,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
shr    $0x1a,%rax
mov    %rax,-0xc0(%rbp)
mov    -0x50(%rbp),%rax
and    $0x3ffffff,%rax
mov    %rax,-0x50(%rbp)
mov    -0x30(%rbp),%rax
add    -0xc0(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
shr    $0x1a,%rax
mov    %rax,-0xc0(%rbp)
mov    -0x58(%rbp),%rax
and    $0x3ffffff,%rax
mov    %rax,-0x58(%rbp)
mov    -0x38(%rbp),%rax
add    -0xc0(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
shr    $0x1a,%rax
mov    %rax,-0xc0(%rbp)
mov    -0x60(%rbp),%rax
and    $0x3ffffff,%rax
mov    %rax,-0x60(%rbp)
mov    -0x40(%rbp),%rax
add    -0xc0(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
shr    $0x1a,%rax
mov    %rax,-0xc0(%rbp)
mov    -0x68(%rbp),%rax
and    $0x3ffffff,%rax
mov    %rax,-0x68(%rbp)
mov    -0x48(%rbp),%rax
add    -0xc0(%rbp),%rax
sub    $0x4000000,%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rax
shr    $0x3f,%rax
sub    $0x1,%rax
mov    %rax,-0xc8(%rbp)
mov    -0xc8(%rbp),%rax
and    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0xc8(%rbp),%rax
and    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0xc8(%rbp),%rax
and    -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0xc8(%rbp),%rax
and    -0x68(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0xc8(%rbp),%rax
and    -0x70(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0xc8(%rbp),%rax
xor    $0xffffffffffffffff,%rax
mov    %rax,-0xc8(%rbp)
mov    -0x28(%rbp),%rax
and    -0xc8(%rbp),%rax
or     -0x50(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
and    -0xc8(%rbp),%rax
or     -0x58(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
and    -0xc8(%rbp),%rax
or     -0x60(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
and    -0xc8(%rbp),%rax
or     -0x68(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
and    -0xc8(%rbp),%rax
or     -0x70(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x1a,%rcx
or     %rcx,%rax
movabs $0xffffffff,%rcx
and    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
shr    $0x6,%rax
mov    -0x38(%rbp),%rcx
shl    $0x14,%rcx
or     %rcx,%rax
movabs $0xffffffff,%rcx
and    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
shr    $0xc,%rax
mov    -0x40(%rbp),%rcx
shl    $0xe,%rcx
or     %rcx,%rax
movabs $0xffffffff,%rcx
and    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
shr    $0x12,%rax
mov    -0x48(%rbp),%rcx
shl    $0x8,%rcx
or     %rcx,%rax
movabs $0xffffffff,%rcx
and    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x110(%rbp)
mov    -0x20(%rbp),%rdi
add    $0x10,%rdi
call   1040 <unpack@plt>
mov    %rax,%rcx
mov    -0x110(%rbp),%rax
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd0(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    -0x20(%rbp),%rdi
add    $0x14,%rdi
call   1040 <unpack@plt>
mov    %rax,%rcx
mov    -0x108(%rbp),%rax
add    %rcx,%rax
mov    -0xd0(%rbp),%rcx
shr    $0x20,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd0(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x100(%rbp)
mov    -0x20(%rbp),%rdi
add    $0x18,%rdi
call   1040 <unpack@plt>
mov    %rax,%rcx
mov    -0x100(%rbp),%rax
add    %rcx,%rax
mov    -0xd0(%rbp),%rcx
shr    $0x20,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd0(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0xf8(%rbp)
mov    -0x20(%rbp),%rdi
add    $0x1c,%rdi
call   1040 <unpack@plt>
mov    %rax,%rcx
mov    -0xf8(%rbp),%rax
add    %rcx,%rax
mov    -0xd0(%rbp),%rcx
shr    $0x20,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd0(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   1030 <pack@plt>
mov    -0x8(%rbp),%rdi
add    $0x4,%rdi
mov    -0x30(%rbp),%rsi
call   1030 <pack@plt>
mov    -0x8(%rbp),%rdi
add    $0x8,%rdi
mov    -0x38(%rbp),%rsi
call   1030 <pack@plt>
mov    -0x8(%rbp),%rdi
add    $0xc,%rdi
mov    -0x40(%rbp),%rsi
call   1030 <pack@plt>
xor    %eax,%eax
add    $0x110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<crypto_onetimeauth_poly1305_tinynacl>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %rcx,%rbx
mov    %rdx,%r14
mov    %rsi,0x90(%rsp)
mov    %rdi,0x38(%rsp)
mov    %rcx,%rdi
call   1050 <unpack@plt>
mov    %rax,%r15
lea    0x3(%rbx),%rdi
call   1050 <unpack@plt>
mov    %rax,%r12
lea    0x6(%rbx),%rdi
call   1050 <unpack@plt>
mov    %rax,%r13
lea    0x9(%rbx),%rdi
call   1050 <unpack@plt>
mov    %rax,%rbp
mov    %rbx,0x30(%rsp)
lea    0xc(%rbx),%rdi
call   1050 <unpack@plt>
test   %r14,%r14
jle    1531 <crypto_onetimeauth_poly1305_tinynacl+0x3f1>
mov    %rax,%r8
mov    %r14,%rax
and    $0x3ffffff,%r15d
mov    %r15,0x88(%rsp)
shr    $0x2,%r12
and    $0x3ffff03,%r12d
shr    $0x4,%r13
and    $0x3ffc0ff,%r13d
shr    $0x6,%rbp
and    $0x3f03fff,%ebp
shr    $0x8,%r8d
and    $0xfffff,%r8d
mov    %r12,0x80(%rsp)
lea    (%r12,%r12,4),%rcx
mov    %rcx,0x60(%rsp)
mov    %r13,0x78(%rsp)
lea    0x0(%r13,%r13,4),%rcx
mov    %rcx,0x58(%rsp)
mov    %rbp,0x70(%rsp)
lea    0x0(%rbp,%rbp,4),%rcx
mov    %rcx,0x50(%rsp)
lea    (%r8,%r8,4),%rcx
mov    %rcx,0x48(%rsp)
mov    $0x10,%ecx
sub    %r14,%rcx
mov    %rcx,0x40(%rsp)
xor    %edx,%edx
xor    %r15d,%r15d
xor    %esi,%esi
xor    %r12d,%r12d
xor    %ebp,%ebp
xor    %r13d,%r13d
mov    %r8,0x68(%rsp)
jmp    14a0 <crypto_onetimeauth_poly1305_tinynacl+0x360>
nopl   0x0(%rax,%rax,1)
mov    0x40(%rsp),%rcx
add    %rcx,%rdx
mov    %rdi,(%rsp)
lea    (%rsp,%rax,1),%rdi
add    $0x10,%rdi
xor    %esi,%esi
mov    %rax,%r14
call   1040 <memset@plt>
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
mov    (%rsp),%rsi
mov    %r14,%rdx
call   1060 <memcpy@plt>
movb   $0x1,0x10(%rsp,%r14,1)
mov    %rbx,%rdi
call   1050 <unpack@plt>
mov    %rax,(%rsp)
lea    0x13(%rsp),%rdi
call   1050 <unpack@plt>
mov    %rax,0x28(%rsp)
lea    0x16(%rsp),%rdi
call   1050 <unpack@plt>
mov    %rax,%r14
lea    0x19(%rsp),%rdi
call   1050 <unpack@plt>
mov    %rax,0x20(%rsp)
lea    0x1c(%rsp),%rdi
call   1050 <unpack@plt>
shr    $0x8,%rax
add    %r13,%rax
mov    (%rsp),%r13
and    $0x3ffffff,%r13d
add    %r15,%r13
mov    0x28(%rsp),%rbx
shr    $0x2,%ebx
and    $0x3ffffff,%ebx
add    0x98(%rsp),%rbx
shr    $0x4,%r14d
and    $0x3ffffff,%r14d
add    %r12,%r14
mov    0x20(%rsp),%r12
shr    $0x6,%r12d
add    %rbp,%r12
mov    %r13,%rdx
mov    0x88(%rsp),%r8
imul   %r8,%rdx
mov    %rbx,%rsi
mov    0x48(%rsp),%r15
imul   %r15,%rsi
mov    %r14,%rdi
mov    0x50(%rsp),%r11
imul   %r11,%rdi
mov    %r12,%rbp
mov    0x58(%rsp),%r9
imul   %r9,%rbp
mov    0x60(%rsp),%rcx
imul   %rax,%rcx
add    %rbp,%rcx
add    %rdi,%rcx
add    %rsi,%rcx
add    %rdx,%rcx
mov    %r13,%rsi
mov    0x80(%rsp),%r10
imul   %r10,%rsi
mov    %rbx,%rdi
imul   %r8,%rdi
mov    %r12,%rbp
imul   %r11,%rbp
mov    %rax,%rdx
imul   %r9,%rdx
add    %rbp,%rdx
mov    %r14,%rbp
imul   %r15,%rbp
add    %rbp,%rdx
add    %rdi,%rdx
add    %rsi,%rdx
mov    %r13,%rdi
mov    0x78(%rsp),%r9
imul   %r9,%rdi
mov    %r12,%rbp
imul   %r15,%rbp
mov    %rax,%rsi
imul   %r11,%rsi
add    %rbp,%rsi
mov    %r14,%rbp
imul   %r8,%rbp
add    %rbp,%rsi
mov    %rbx,%rbp
imul   %r10,%rbp
add    %rbp,%rsi
add    %rdi,%rsi
mov    %r12,%rbp
imul   %r8,%rbp
mov    %rax,%rdi
imul   %r15,%rdi
add    %rbp,%rdi
mov    %r14,%rbp
imul   %r10,%rbp
add    %rbp,%rdi
mov    %rbx,%rbp
imul   %r9,%rbp
add    %rbp,%rdi
mov    %r13,%rbp
mov    0x70(%rsp),%r11
imul   %r11,%rbp
add    %rbp,%rdi
imul   %r10,%r12
imul   %r8,%rax
add    %r12,%rax
imul   %r9,%r14
add    %r14,%rax
imul   %r11,%rbx
add    %rbx,%rax
mov    0x68(%rsp),%r8
imul   %r8,%r13
add    %r13,%rax
mov    %rcx,%rbx
shr    $0x1a,%rbx
add    %rdx,%rbx
and    $0x3ffffff,%ecx
mov    %rbx,%r12
shr    $0x1a,%r12
add    %rsi,%r12
and    $0x3ffffff,%ebx
mov    %r12,%rbp
shr    $0x1a,%rbp
add    %rdi,%rbp
mov    %rbp,%r13
shr    $0x1a,%r13
add    %rax,%r13
mov    %r13,%rax
shr    $0x1a,%rax
lea    (%rax,%rax,4),%r15
add    %rcx,%r15
mov    %r15,%rsi
shr    $0x1a,%rsi
add    %rbx,%rsi
and    $0x3ffffff,%r12d
and    $0x3ffffff,%ebp
and    $0x3ffffff,%r13d
and    $0x3ffffff,%r15d
mov    0x8(%rsp),%rdx
add    $0x10,%rdx
mov    0xa0(%rsp),%rax
cmp    $0x10,%rax
lea    -0x10(%rax),%rax
jle    153e <crypto_onetimeauth_poly1305_tinynacl+0x3fe>
mov    %rsi,0x98(%rsp)
mov    0x90(%rsp),%rbx
lea    (%rbx,%rdx,1),%rdi
cmp    $0x10,%rax
mov    %rdx,0x8(%rsp)
mov    %rax,0xa0(%rsp)
jb     1250 <crypto_onetimeauth_poly1305_tinynacl+0x110>
mov    %rdx,%r14
call   1050 <unpack@plt>
mov    %rax,(%rsp)
lea    (%rbx,%r14,1),%rdi
add    $0x3,%rdi
call   1050 <unpack@plt>
mov    %rax,0x28(%rsp)
lea    (%rbx,%r14,1),%rdi
add    $0x6,%rdi
call   1050 <unpack@plt>
mov    %rax,%r14
mov    0x8(%rsp),%rax
lea    (%rbx,%rax,1),%rdi
add    $0x9,%rdi
call   1050 <unpack@plt>
mov    %rax,0x20(%rsp)
mov    0x8(%rsp),%rax
lea    (%rbx,%rax,1),%rdi
add    $0xc,%rdi
call   1050 <unpack@plt>
shr    $0x8,%rax
or     $0x1000000,%rax
jmp    12cd <crypto_onetimeauth_poly1305_tinynacl+0x18d>
xor    %r13d,%r13d
xor    %ebp,%ebp
xor    %r12d,%r12d
xor    %esi,%esi
xor    %r15d,%r15d
mov    %rsi,%rax
shr    $0x1a,%rax
add    %r12,%rax
and    $0x3ffffff,%esi
mov    %rax,%rcx
shr    $0x1a,%rcx
add    %rbp,%rcx
and    $0x3ffffff,%eax
mov    %rcx,%r12
shr    $0x1a,%r12
add    %r13,%r12
and    $0x3ffffff,%ecx
mov    %r12,%rdx
shr    $0x1a,%rdx
lea    (%rdx,%rdx,4),%r8
add    %r15,%r8
mov    %r8,%rbx
shr    $0x1a,%rbx
add    %rsi,%rbx
and    $0x3ffffff,%r8d
lea    0x5(%r8),%r10
mov    %r10,%rsi
shr    $0x1a,%rsi
add    %rbx,%rsi
mov    %rsi,%rbp
shr    $0x1a,%rbp
add    %rax,%rbp
mov    %rbp,%r11
shr    $0x1a,%r11
add    %rcx,%r11
mov    %r11,%rdx
shr    $0x1a,%rdx
mov    %r12,%rdi
or     $0xfffffffffc000000,%rdi
add    %rdx,%rdi
mov    %rdi,%r9
sar    $0x3f,%r9
mov    %rdi,%rdx
shr    $0x3f,%rdx
add    $0xffffffff,%edx
and    %edx,%edi
and    $0x3ffffff,%edx
and    %edx,%r10d
and    %edx,%esi
and    %edx,%ebp
and    %edx,%r11d
and    %r9d,%r8d
or     %r10d,%r8d
and    %r9d,%ebx
or     %esi,%ebx
and    %r9d,%eax
or     %ebp,%eax
and    %r9d,%ecx
or     %r11d,%ecx
and    %r9d,%r12d
or     %edi,%r12d
mov    %ebx,%r14d
shl    $0x1a,%r14d
or     %r8d,%r14d
shr    $0x6,%rbx
mov    %eax,%edx
shl    $0x14,%edx
or     %edx,%ebx
shr    $0xc,%rax
mov    %ecx,%ebp
shl    $0xe,%ebp
or     %rax,%rbp
shr    $0x12,%rcx
shl    $0x8,%r12d
or     %rcx,%r12
mov    0x30(%rsp),%r13
lea    0x10(%r13),%rdi
call   1050 <unpack@plt>
add    %rax,%r14
lea    0x14(%r13),%rdi
call   1050 <unpack@plt>
add    %rax,%rbx
mov    %r14,%r15
shr    $0x20,%r15
add    %rbx,%r15
lea    0x18(%r13),%rdi
call   1050 <unpack@plt>
add    %rax,%rbp
mov    %r15,%rbx
shr    $0x20,%rbx
add    %rbp,%rbx
add    $0x1c,%r13
mov    %r13,%rdi
call   1050 <unpack@plt>
add    %rax,%r12
mov    %rbx,%r13
shr    $0x20,%r13
add    %r12,%r13
mov    0x38(%rsp),%rbp
mov    %rbp,%rdi
mov    %r14,%rsi
call   1030 <pack@plt>
lea    0x4(%rbp),%rdi
mov    %r15,%rsi
call   1030 <pack@plt>
lea    0x8(%rbp),%rdi
mov    %rbx,%rsi
call   1030 <pack@plt>
add    $0xc,%rbp
mov    %rbp,%rdi
mov    %r13,%rsi
call   1030 <pack@plt>
xor    %eax,%eax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @crypto_onetimeauth_poly1305_tinynacl(i8* %0, i8* %1, i64 %2, i8* %3) {
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i64
%8 = alloca i8*
%9 = alloca i64
%10 = alloca i64
%11 = alloca i64
%12 = alloca i64
%13 = alloca i64
%14 = alloca i64
%15 = alloca i64
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
%19 = alloca i64
%20 = alloca i64
%21 = alloca i64
%22 = alloca i64
%23 = alloca i64
%24 = alloca i64
%25 = alloca i64
%26 = alloca i64
%27 = alloca i64
%28 = alloca i64
%29 = alloca i64
%30 = alloca i64
%31 = alloca i64
%32 = alloca [16 x i8]
store i8* %0, i8** %5
store i8* %1, i8** %6
store i64 %2, i64* %7
store i8* %3, i8** %8
%33 = load i8*, i8** %8
%34 = getelementptr inbounds i8, i8* %33, i64 0
%35 = call i64 @unpack(i8* %34)
%36 = and i64 %35, 67108863
store i64 %36, i64* %14
%37 = load i8*, i8** %8
%38 = getelementptr inbounds i8, i8* %37, i64 3
%39 = call i64 @unpack(i8* %38)
%40 = lshr i64 %39, 2
%41 = and i64 %40, 67108611
store i64 %41, i64* %15
%42 = load i8*, i8** %8
%43 = getelementptr inbounds i8, i8* %42, i64 6
%44 = call i64 @unpack(i8* %43)
%45 = lshr i64 %44, 4
%46 = and i64 %45, 67092735
store i64 %46, i64* %16
%47 = load i8*, i8** %8
%48 = getelementptr inbounds i8, i8* %47, i64 9
%49 = call i64 @unpack(i8* %48)
%50 = lshr i64 %49, 6
%51 = and i64 %50, 66076671
store i64 %51, i64* %17
%52 = load i8*, i8** %8
%53 = getelementptr inbounds i8, i8* %52, i64 12
%54 = call i64 @unpack(i8* %53)
%55 = lshr i64 %54, 8
%56 = and i64 %55, 1048575
store i64 %56, i64* %18
%57 = load i64, i64* %15
%58 = mul i64 %57, 5
store i64 %58, i64* %19
%59 = load i64, i64* %16
%60 = mul i64 %59, 5
store i64 %60, i64* %20
%61 = load i64, i64* %17
%62 = mul i64 %61, 5
store i64 %62, i64* %21
%63 = load i64, i64* %18
%64 = mul i64 %63, 5
store i64 %64, i64* %22
store i64 0, i64* %13
store i64 0, i64* %12
store i64 0, i64* %11
store i64 0, i64* %10
store i64 0, i64* %9
br label %65
65: ; preds = %165, %4
%66 = load i64, i64* %7
%67 = icmp sgt i64 %66, 0
br i1 %67, label %68, label %308
68: ; preds = %65
%69 = load i64, i64* %7
%70 = icmp uge i64 %69, 16
br i1 %70, label %71, label %105
71: ; preds = %68
%72 = load i8*, i8** %6
%73 = call i64 @unpack(i8* %72)
%74 = and i64 %73, 67108863
%75 = load i64, i64* %9
%76 = add i64 %75, %74
store i64 %76, i64* %9
%77 = load i8*, i8** %6
%78 = getelementptr inbounds i8, i8* %77, i64 3
%79 = call i64 @unpack(i8* %78)
%80 = lshr i64 %79, 2
%81 = and i64 %80, 67108863
%82 = load i64, i64* %10
%83 = add i64 %82, %81
store i64 %83, i64* %10
%84 = load i8*, i8** %6
%85 = getelementptr inbounds i8, i8* %84, i64 6
%86 = call i64 @unpack(i8* %85)
%87 = lshr i64 %86, 4
%88 = and i64 %87, 67108863
%89 = load i64, i64* %11
%90 = add i64 %89, %88
store i64 %90, i64* %11
%91 = load i8*, i8** %6
%92 = getelementptr inbounds i8, i8* %91, i64 9
%93 = call i64 @unpack(i8* %92)
%94 = lshr i64 %93, 6
%95 = and i64 %94, 67108863
%96 = load i64, i64* %12
%97 = add i64 %96, %95
store i64 %97, i64* %12
%98 = load i8*, i8** %6
%99 = getelementptr inbounds i8, i8* %98, i64 12
%100 = call i64 @unpack(i8* %99)
%101 = lshr i64 %100, 8
%102 = or i64 %101, 16777216
%103 = load i64, i64* %13
%104 = add i64 %103, %102
store i64 %104, i64* %13
br label %165
105: ; preds = %68
store i64 0, i64* %31
br label %106
106: ; preds = %112, %105
%107 = load i64, i64* %31
%108 = icmp slt i64 %107, 16
br i1 %108, label %109, label %115
109: ; preds = %106
%110 = load i64, i64* %31
%111 = getelementptr inbounds [16 x i8], [16 x i8]* %32, i64 0, i64 %110
store i8 0, i8* %111
br label %112
112: ; preds = %109
%113 = load i64, i64* %31
%114 = add nsw i64 %113, 1
store i64 %114, i64* %31
br label %106
115: ; preds = %106
store i64 0, i64* %31
br label %116
116: ; preds = %127, %115
%117 = load i64, i64* %31
%118 = load i64, i64* %7
%119 = icmp ult i64 %117, %118
br i1 %119, label %120, label %130
120: ; preds = %116
%121 = load i8*, i8** %6
%122 = load i64, i64* %31
%123 = getelementptr inbounds i8, i8* %121, i64 %122
%124 = load i8, i8* %123
%125 = load i64, i64* %31
%126 = getelementptr inbounds [16 x i8], [16 x i8]* %32, i64 0, i64 %125
store i8 %124, i8* %126
br label %127
127: ; preds = %120
%128 = load i64, i64* %31
%129 = add nsw i64 %128, 1
store i64 %129, i64* %31
br label %116
130: ; preds = %116
%131 = load i64, i64* %31
%132 = getelementptr inbounds [16 x i8], [16 x i8]* %32, i64 0, i64 %131
store i8 1, i8* %132
%133 = getelementptr inbounds [16 x i8], [16 x i8]* %32, i64 0, i64 0
%134 = call i64 @unpack(i8* %133)
%135 = and i64 %134, 67108863
%136 = load i64, i64* %9
%137 = add i64 %136, %135
store i64 %137, i64* %9
%138 = getelementptr inbounds [16 x i8], [16 x i8]* %32, i64 0, i64 0
%139 = getelementptr inbounds i8, i8* %138, i64 3
%140 = call i64 @unpack(i8* %139)
%141 = lshr i64 %140, 2
%142 = and i64 %141, 67108863
%143 = load i64, i64* %10
%144 = add i64 %143, %142
store i64 %144, i64* %10
%145 = getelementptr inbounds [16 x i8], [16 x i8]* %32, i64 0, i64 0
%146 = getelementptr inbounds i8, i8* %145, i64 6
%147 = call i64 @unpack(i8* %146)
%148 = lshr i64 %147, 4
%149 = and i64 %148, 67108863
%150 = load i64, i64* %11
%151 = add i64 %150, %149
store i64 %151, i64* %11
%152 = getelementptr inbounds [16 x i8], [16 x i8]* %32, i64 0, i64 0
%153 = getelementptr inbounds i8, i8* %152, i64 9
%154 = call i64 @unpack(i8* %153)
%155 = lshr i64 %154, 6
%156 = and i64 %155, 67108863
%157 = load i64, i64* %12
%158 = add i64 %157, %156
store i64 %158, i64* %12
%159 = getelementptr inbounds [16 x i8], [16 x i8]* %32, i64 0, i64 0
%160 = getelementptr inbounds i8, i8* %159, i64 12
%161 = call i64 @unpack(i8* %160)
%162 = lshr i64 %161, 8
%163 = load i64, i64* %13
%164 = add i64 %163, %162
store i64 %164, i64* %13
br label %165
165: ; preds = %130, %71
%166 = load i64, i64* %9
%167 = load i64, i64* %14
%168 = mul i64 %166, %167
%169 = load i64, i64* %10
%170 = load i64, i64* %22
%171 = mul i64 %169, %170
%172 = add i64 %168, %171
%173 = load i64, i64* %11
%174 = load i64, i64* %21
%175 = mul i64 %173, %174
%176 = add i64 %172, %175
%177 = load i64, i64* %12
%178 = load i64, i64* %20
%179 = mul i64 %177, %178
%180 = add i64 %176, %179
%181 = load i64, i64* %13
%182 = load i64, i64* %19
%183 = mul i64 %181, %182
%184 = add i64 %180, %183
store i64 %184, i64* %23
%185 = load i64, i64* %9
%186 = load i64, i64* %15
%187 = mul i64 %185, %186
%188 = load i64, i64* %10
%189 = load i64, i64* %14
%190 = mul i64 %188, %189
%191 = add i64 %187, %190
%192 = load i64, i64* %11
%193 = load i64, i64* %22
%194 = mul i64 %192, %193
%195 = add i64 %191, %194
%196 = load i64, i64* %12
%197 = load i64, i64* %21
%198 = mul i64 %196, %197
%199 = add i64 %195, %198
%200 = load i64, i64* %13
%201 = load i64, i64* %20
%202 = mul i64 %200, %201
%203 = add i64 %199, %202
store i64 %203, i64* %24
%204 = load i64, i64* %9
%205 = load i64, i64* %16
%206 = mul i64 %204, %205
%207 = load i64, i64* %10
%208 = load i64, i64* %15
%209 = mul i64 %207, %208
%210 = add i64 %206, %209
%211 = load i64, i64* %11
%212 = load i64, i64* %14
%213 = mul i64 %211, %212
%214 = add i64 %210, %213
%215 = load i64, i64* %12
%216 = load i64, i64* %22
%217 = mul i64 %215, %216
%218 = add i64 %214, %217
%219 = load i64, i64* %13
%220 = load i64, i64* %21
%221 = mul i64 %219, %220
%222 = add i64 %218, %221
store i64 %222, i64* %25
%223 = load i64, i64* %9
%224 = load i64, i64* %17
%225 = mul i64 %223, %224
%226 = load i64, i64* %10
%227 = load i64, i64* %16
%228 = mul i64 %226, %227
%229 = add i64 %225, %228
%230 = load i64, i64* %11
%231 = load i64, i64* %15
%232 = mul i64 %230, %231
%233 = add i64 %229, %232
%234 = load i64, i64* %12
%235 = load i64, i64* %14
%236 = mul i64 %234, %235
%237 = add i64 %233, %236
%238 = load i64, i64* %13
%239 = load i64, i64* %22
%240 = mul i64 %238, %239
%241 = add i64 %237, %240
store i64 %241, i64* %26
%242 = load i64, i64* %9
%243 = load i64, i64* %18
%244 = mul i64 %242, %243
%245 = load i64, i64* %10
%246 = load i64, i64* %17
%247 = mul i64 %245, %246
%248 = add i64 %244, %247
%249 = load i64, i64* %11
%250 = load i64, i64* %16
%251 = mul i64 %249, %250
%252 = add i64 %248, %251
%253 = load i64, i64* %12
%254 = load i64, i64* %15
%255 = mul i64 %253, %254
%256 = add i64 %252, %255
%257 = load i64, i64* %13
%258 = load i64, i64* %14
%259 = mul i64 %257, %258
%260 = add i64 %256, %259
store i64 %260, i64* %27
%261 = load i64, i64* %23
%262 = lshr i64 %261, 26
store i64 %262, i64* %28
%263 = load i64, i64* %23
%264 = and i64 %263, 67108863
store i64 %264, i64* %9
%265 = load i64, i64* %28
%266 = load i64, i64* %24
%267 = add i64 %266, %265
store i64 %267, i64* %24
%268 = load i64, i64* %24
%269 = lshr i64 %268, 26
store i64 %269, i64* %28
%270 = load i64, i64* %24
%271 = and i64 %270, 67108863
store i64 %271, i64* %10
%272 = load i64, i64* %28
%273 = load i64, i64* %25
%274 = add i64 %273, %272
store i64 %274, i64* %25
%275 = load i64, i64* %25
%276 = lshr i64 %275, 26
store i64 %276, i64* %28
%277 = load i64, i64* %25
%278 = and i64 %277, 67108863
store i64 %278, i64* %11
%279 = load i64, i64* %28
%280 = load i64, i64* %26
%281 = add i64 %280, %279
store i64 %281, i64* %26
%282 = load i64, i64* %26
%283 = lshr i64 %282, 26
store i64 %283, i64* %28
%284 = load i64, i64* %26
%285 = and i64 %284, 67108863
store i64 %285, i64* %12
%286 = load i64, i64* %28
%287 = load i64, i64* %27
%288 = add i64 %287, %286
store i64 %288, i64* %27
%289 = load i64, i64* %27
%290 = lshr i64 %289, 26
store i64 %290, i64* %28
%291 = load i64, i64* %27
%292 = and i64 %291, 67108863
store i64 %292, i64* %13
%293 = load i64, i64* %28
%294 = mul i64 %293, 5
%295 = load i64, i64* %9
%296 = add i64 %295, %294
store i64 %296, i64* %9
%297 = load i64, i64* %9
%298 = lshr i64 %297, 26
store i64 %298, i64* %28
%299 = load i64, i64* %9
%300 = and i64 %299, 67108863
store i64 %300, i64* %9
%301 = load i64, i64* %28
%302 = load i64, i64* %10
%303 = add i64 %302, %301
store i64 %303, i64* %10
%304 = load i8*, i8** %6
%305 = getelementptr inbounds i8, i8* %304, i64 16
store i8* %305, i8** %6
%306 = load i64, i64* %7
%307 = sub i64 %306, 16
store i64 %307, i64* %7
br label %65
308: ; preds = %65
%309 = load i64, i64* %10
%310 = lshr i64 %309, 26
store i64 %310, i64* %28
%311 = load i64, i64* %10
%312 = and i64 %311, 67108863
store i64 %312, i64* %10
%313 = load i64, i64* %28
%314 = load i64, i64* %11
%315 = add i64 %314, %313
store i64 %315, i64* %11
%316 = load i64, i64* %11
%317 = lshr i64 %316, 26
store i64 %317, i64* %28
%318 = load i64, i64* %11
%319 = and i64 %318, 67108863
store i64 %319, i64* %11
%320 = load i64, i64* %28
%321 = load i64, i64* %12
%322 = add i64 %321, %320
store i64 %322, i64* %12
%323 = load i64, i64* %12
%324 = lshr i64 %323, 26
store i64 %324, i64* %28
%325 = load i64, i64* %12
%326 = and i64 %325, 67108863
store i64 %326, i64* %12
%327 = load i64, i64* %28
%328 = load i64, i64* %13
%329 = add i64 %328, %327
store i64 %329, i64* %13
%330 = load i64, i64* %13
%331 = lshr i64 %330, 26
store i64 %331, i64* %28
%332 = load i64, i64* %13
%333 = and i64 %332, 67108863
store i64 %333, i64* %13
%334 = load i64, i64* %28
%335 = mul i64 %334, 5
%336 = load i64, i64* %9
%337 = add i64 %336, %335
store i64 %337, i64* %9
%338 = load i64, i64* %9
%339 = lshr i64 %338, 26
store i64 %339, i64* %28
%340 = load i64, i64* %9
%341 = and i64 %340, 67108863
store i64 %341, i64* %9
%342 = load i64, i64* %28
%343 = load i64, i64* %10
%344 = add i64 %343, %342
store i64 %344, i64* %10
%345 = load i64, i64* %9
%346 = add i64 %345, 5
store i64 %346, i64* %14
%347 = load i64, i64* %14
%348 = lshr i64 %347, 26
store i64 %348, i64* %28
%349 = load i64, i64* %14
%350 = and i64 %349, 67108863
store i64 %350, i64* %14
%351 = load i64, i64* %10
%352 = load i64, i64* %28
%353 = add i64 %351, %352
store i64 %353, i64* %15
%354 = load i64, i64* %15
%355 = lshr i64 %354, 26
store i64 %355, i64* %28
%356 = load i64, i64* %15
%357 = and i64 %356, 67108863
store i64 %357, i64* %15
%358 = load i64, i64* %11
%359 = load i64, i64* %28
%360 = add i64 %358, %359
store i64 %360, i64* %16
%361 = load i64, i64* %16
%362 = lshr i64 %361, 26
store i64 %362, i64* %28
%363 = load i64, i64* %16
%364 = and i64 %363, 67108863
store i64 %364, i64* %16
%365 = load i64, i64* %12
%366 = load i64, i64* %28
%367 = add i64 %365, %366
store i64 %367, i64* %17
%368 = load i64, i64* %17
%369 = lshr i64 %368, 26
store i64 %369, i64* %28
%370 = load i64, i64* %17
%371 = and i64 %370, 67108863
store i64 %371, i64* %17
%372 = load i64, i64* %13
%373 = load i64, i64* %28
%374 = add i64 %372, %373
%375 = sub i64 %374, 67108864
store i64 %375, i64* %18
%376 = load i64, i64* %18
%377 = lshr i64 %376, 63
%378 = sub i64 %377, 1
store i64 %378, i64* %29
%379 = load i64, i64* %29
%380 = load i64, i64* %14
%381 = and i64 %380, %379
store i64 %381, i64* %14
%382 = load i64, i64* %29
%383 = load i64, i64* %15
%384 = and i64 %383, %382
store i64 %384, i64* %15
%385 = load i64, i64* %29
%386 = load i64, i64* %16
%387 = and i64 %386, %385
store i64 %387, i64* %16
%388 = load i64, i64* %29
%389 = load i64, i64* %17
%390 = and i64 %389, %388
store i64 %390, i64* %17
%391 = load i64, i64* %29
%392 = load i64, i64* %18
%393 = and i64 %392, %391
store i64 %393, i64* %18
%394 = load i64, i64* %29
%395 = xor i64 %394, -1
store i64 %395, i64* %29
%396 = load i64, i64* %9
%397 = load i64, i64* %29
%398 = and i64 %396, %397
%399 = load i64, i64* %14
%400 = or i64 %398, %399
store i64 %400, i64* %9
%401 = load i64, i64* %10
%402 = load i64, i64* %29
%403 = and i64 %401, %402
%404 = load i64, i64* %15
%405 = or i64 %403, %404
store i64 %405, i64* %10
%406 = load i64, i64* %11
%407 = load i64, i64* %29
%408 = and i64 %406, %407
%409 = load i64, i64* %16
%410 = or i64 %408, %409
store i64 %410, i64* %11
%411 = load i64, i64* %12
%412 = load i64, i64* %29
%413 = and i64 %411, %412
%414 = load i64, i64* %17
%415 = or i64 %413, %414
store i64 %415, i64* %12
%416 = load i64, i64* %13
%417 = load i64, i64* %29
%418 = and i64 %416, %417
%419 = load i64, i64* %18
%420 = or i64 %418, %419
store i64 %420, i64* %13
%421 = load i64, i64* %9
%422 = load i64, i64* %10
%423 = shl i64 %422, 26
%424 = or i64 %421, %423
%425 = and i64 %424, 4294967295
store i64 %425, i64* %9
%426 = load i64, i64* %10
%427 = lshr i64 %426, 6
%428 = load i64, i64* %11
%429 = shl i64 %428, 20
%430 = or i64 %427, %429
%431 = and i64 %430, 4294967295
store i64 %431, i64* %10
%432 = load i64, i64* %11
%433 = lshr i64 %432, 12
%434 = load i64, i64* %12
%435 = shl i64 %434, 14
%436 = or i64 %433, %435
%437 = and i64 %436, 4294967295
store i64 %437, i64* %11
%438 = load i64, i64* %12
%439 = lshr i64 %438, 18
%440 = load i64, i64* %13
%441 = shl i64 %440, 8
%442 = or i64 %439, %441
%443 = and i64 %442, 4294967295
store i64 %443, i64* %12
%444 = load i64, i64* %9
%445 = load i8*, i8** %8
%446 = getelementptr inbounds i8, i8* %445, i64 16
%447 = call i64 @unpack(i8* %446)
%448 = add i64 %444, %447
store i64 %448, i64* %30
%449 = load i64, i64* %30
store i64 %449, i64* %9
%450 = load i64, i64* %10
%451 = load i8*, i8** %8
%452 = getelementptr inbounds i8, i8* %451, i64 20
%453 = call i64 @unpack(i8* %452)
%454 = add i64 %450, %453
%455 = load i64, i64* %30
%456 = lshr i64 %455, 32
%457 = add i64 %454, %456
store i64 %457, i64* %30
%458 = load i64, i64* %30
store i64 %458, i64* %10
%459 = load i64, i64* %11
%460 = load i8*, i8** %8
%461 = getelementptr inbounds i8, i8* %460, i64 24
%462 = call i64 @unpack(i8* %461)
%463 = add i64 %459, %462
%464 = load i64, i64* %30
%465 = lshr i64 %464, 32
%466 = add i64 %463, %465
store i64 %466, i64* %30
%467 = load i64, i64* %30
store i64 %467, i64* %11
%468 = load i64, i64* %12
%469 = load i8*, i8** %8
%470 = getelementptr inbounds i8, i8* %469, i64 28
%471 = call i64 @unpack(i8* %470)
%472 = add i64 %468, %471
%473 = load i64, i64* %30
%474 = lshr i64 %473, 32
%475 = add i64 %472, %474
store i64 %475, i64* %30
%476 = load i64, i64* %30
store i64 %476, i64* %12
%477 = load i8*, i8** %5
%478 = getelementptr inbounds i8, i8* %477, i64 0
%479 = load i64, i64* %9
%480 = call i32 @pack(i8* %478, i64 %479)
%481 = load i8*, i8** %5
%482 = getelementptr inbounds i8, i8* %481, i64 4
%483 = load i64, i64* %10
%484 = call i32 @pack(i8* %482, i64 %483)
%485 = load i8*, i8** %5
%486 = getelementptr inbounds i8, i8* %485, i64 8
%487 = load i64, i64* %11
%488 = call i32 @pack(i8* %486, i64 %487)
%489 = load i8*, i8** %5
%490 = getelementptr inbounds i8, i8* %489, i64 12
%491 = load i64, i64* %12
%492 = call i32 @pack(i8* %490, i64 %491)
ret i32 0
}

LLVM IR (-O2):
define i32 @crypto_onetimeauth_poly1305_tinynacl(i8* %0, i8* %1, i64 %2, i8* %3) {
%5 = alloca [16 x i8]
%6 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 0
%7 = tail call i64 @unpack(i8* %3)
%8 = and i64 %7, 67108863
%9 = getelementptr inbounds i8, i8* %3, i64 3
%10 = tail call i64 @unpack(i8* %9)
%11 = lshr i64 %10, 2
%12 = and i64 %11, 67108611
%13 = getelementptr inbounds i8, i8* %3, i64 6
%14 = tail call i64 @unpack(i8* %13)
%15 = lshr i64 %14, 4
%16 = and i64 %15, 67092735
%17 = getelementptr inbounds i8, i8* %3, i64 9
%18 = tail call i64 @unpack(i8* %17)
%19 = lshr i64 %18, 6
%20 = and i64 %19, 66076671
%21 = getelementptr inbounds i8, i8* %3, i64 12
%22 = tail call i64 @unpack(i8* %21)
%23 = lshr i64 %22, 8
%24 = and i64 %23, 1048575
%25 = mul nuw nsw i64 %12, 5
%26 = mul nuw nsw i64 %16, 5
%27 = mul nuw nsw i64 %20, 5
%28 = mul nuw nsw i64 %24, 5
%29 = icmp sgt i64 %2, 0
br i1 %29, label %30, label %152
30: ; preds = %4
%31 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 0
%32 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 3
%33 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 6
%34 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 9
%35 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 12
br label %36
36: ; preds = %30, %67
%37 = phi i8* [ %1, %30 ], [ %149, %67 ]
%38 = phi i64 [ %2, %30 ], [ %150, %67 ]
%39 = phi i64 [ 0, %30 ], [ %147, %67 ]
%40 = phi i64 [ 0, %30 ], [ %148, %67 ]
%41 = phi i64 [ 0, %30 ], [ %129, %67 ]
%42 = phi i64 [ 0, %30 ], [ %136, %67 ]
%43 = phi i64 [ 0, %30 ], [ %143, %67 ]
%44 = icmp ugt i64 %38, 15
br i1 %44, label %45, label %57
45: ; preds = %36
%46 = call i64 @unpack(i8* %37)
%47 = getelementptr inbounds i8, i8* %37, i64 3
%48 = call i64 @unpack(i8* %47)
%49 = getelementptr inbounds i8, i8* %37, i64 6
%50 = call i64 @unpack(i8* %49)
%51 = getelementptr inbounds i8, i8* %37, i64 9
%52 = call i64 @unpack(i8* %51)
%53 = getelementptr inbounds i8, i8* %37, i64 12
%54 = call i64 @unpack(i8* %53)
%55 = lshr i64 %54, 8
%56 = or i64 %55, 16777216
br label %67
57: ; preds = %36
%58 = sub i64 16, %38
%59 = getelementptr [16 x i8], [16 x i8]* %5, i64 0, i64 %38
%60 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 %38
store i8 1, i8* %60
%61 = call i64 @unpack(i8* %31)
%62 = call i64 @unpack(i8* %32)
%63 = call i64 @unpack(i8* %33)
%64 = call i64 @unpack(i8* %34)
%65 = call i64 @unpack(i8* %35)
%66 = lshr i64 %65, 8
br label %67
67: ; preds = %57, %45
%68 = phi i64 [ %56, %45 ], [ %66, %57 ]
%69 = phi i64 [ %52, %45 ], [ %64, %57 ]
%70 = phi i64 [ %50, %45 ], [ %63, %57 ]
%71 = phi i64 [ %48, %45 ], [ %62, %57 ]
%72 = phi i64 [ %46, %45 ], [ %61, %57 ]
%73 = and i64 %72, 67108863
%74 = add nuw nsw i64 %73, %39
%75 = lshr i64 %71, 2
%76 = and i64 %75, 67108863
%77 = add nuw nsw i64 %76, %40
%78 = lshr i64 %70, 4
%79 = and i64 %78, 67108863
%80 = add nuw nsw i64 %79, %41
%81 = lshr i64 %69, 6
%82 = and i64 %81, 67108863
%83 = add nuw nsw i64 %82, %42
%84 = add nsw i64 %68, %43
%85 = mul nuw nsw i64 %74, %8
%86 = mul i64 %77, %28
%87 = mul nuw nsw i64 %80, %27
%88 = mul nuw nsw i64 %83, %26
%89 = mul i64 %25, %84
%90 = add i64 %88, %89
%91 = add i64 %90, %87
%92 = add i64 %91, %86
%93 = add i64 %92, %85
%94 = mul nuw nsw i64 %74, %12
%95 = mul i64 %77, %8
%96 = mul nuw nsw i64 %80, %28
%97 = mul nuw nsw i64 %83, %27
%98 = mul i64 %84, %26
%99 = mul nuw nsw i64 %74, %16
%100 = mul i64 %77, %12
%101 = mul nuw nsw i64 %80, %8
%102 = mul nuw nsw i64 %83, %28
%103 = mul i64 %84, %27
%104 = mul nuw nsw i64 %74, %20
%105 = mul i64 %77, %16
%106 = mul nuw nsw i64 %80, %12
%107 = mul nuw nsw i64 %83, %8
%108 = mul i64 %84, %28
%109 = mul nuw nsw i64 %74, %24
%110 = mul i64 %77, %20
%111 = mul nuw nsw i64 %80, %16
%112 = mul nuw nsw i64 %83, %12
%113 = mul i64 %84, %8
%114 = lshr i64 %93, 26
%115 = and i64 %93, 67108863
%116 = add i64 %97, %98
%117 = add i64 %116, %96
%118 = add i64 %117, %95
%119 = add i64 %118, %94
%120 = add i64 %119, %114
%121 = lshr i64 %120, 26
%122 = and i64 %120, 67108863
%123 = add i64 %102, %103
%124 = add i64 %123, %101
%125 = add i64 %124, %100
%126 = add i64 %125, %99
%127 = add i64 %126, %121
%128 = lshr i64 %127, 26
%129 = and i64 %127, 67108863
%130 = add i64 %107, %108
%131 = add i64 %130, %106
%132 = add i64 %131, %105
%133 = add i64 %132, %104
%134 = add i64 %133, %128
%135 = lshr i64 %134, 26
%136 = and i64 %134, 67108863
%137 = add i64 %112, %113
%138 = add i64 %137, %111
%139 = add i64 %138, %110
%140 = add i64 %139, %109
%141 = add i64 %140, %135
%142 = lshr i64 %141, 26
%143 = and i64 %141, 67108863
%144 = mul nuw nsw i64 %142, 5
%145 = add nuw nsw i64 %144, %115
%146 = lshr i64 %145, 26
%147 = and i64 %145, 67108863
%148 = add nuw nsw i64 %146, %122
%149 = getelementptr inbounds i8, i8* %37, i64 16
%150 = add nsw i64 %38, -16
%151 = icmp sgt i64 %38, 16
br i1 %151, label %36, label %152
152: ; preds = %67, %4
%153 = phi i64 [ 0, %4 ], [ %143, %67 ]
%154 = phi i64 [ 0, %4 ], [ %136, %67 ]
%155 = phi i64 [ 0, %4 ], [ %129, %67 ]
%156 = phi i64 [ 0, %4 ], [ %148, %67 ]
%157 = phi i64 [ 0, %4 ], [ %147, %67 ]
%158 = lshr i64 %156, 26
%159 = and i64 %156, 67108863
%160 = add nuw nsw i64 %158, %155
%161 = lshr i64 %160, 26
%162 = and i64 %160, 67108863
%163 = add nuw nsw i64 %161, %154
%164 = lshr i64 %163, 26
%165 = and i64 %163, 67108863
%166 = add nuw nsw i64 %164, %153
%167 = lshr i64 %166, 26
%168 = and i64 %166, 16777215
%169 = mul nuw nsw i64 %167, 5
%170 = add nuw nsw i64 %169, %157
%171 = lshr i64 %170, 26
%172 = and i64 %170, 67108863
%173 = add nuw nsw i64 %171, %159
%174 = add nuw nsw i64 %172, 5
%175 = lshr i64 %174, 26
%176 = add nuw nsw i64 %175, %173
%177 = lshr i64 %176, 26
%178 = add nuw nsw i64 %177, %162
%179 = lshr i64 %178, 26
%180 = add nuw nsw i64 %179, %165
%181 = lshr i64 %180, 26
%182 = or i64 %166, -67108864
%183 = add nsw i64 %182, %181
%184 = ashr i64 %183, 63
%185 = lshr i64 %183, 63
%186 = add nsw i64 %185, -1
%187 = and i64 %186, 67108863
%188 = and i64 %187, %174
%189 = and i64 %187, %176
%190 = and i64 %187, %178
%191 = and i64 %187, %180
%192 = and i64 %186, %183
%193 = and i64 %184, %172
%194 = or i64 %193, %188
%195 = and i64 %184, %173
%196 = or i64 %195, %189
%197 = and i64 %184, %162
%198 = or i64 %197, %190
%199 = and i64 %184, %165
%200 = or i64 %199, %191
%201 = and i64 %184, %168
%202 = or i64 %192, %201
%203 = shl i64 %196, 26
%204 = and i64 %203, 4227858432
%205 = or i64 %194, %204
%206 = lshr i64 %196, 6
%207 = shl nuw nsw i64 %198, 20
%208 = or i64 %206, %207
%209 = and i64 %208, 4294967295
%210 = lshr i64 %198, 12
%211 = shl nuw nsw i64 %200, 14
%212 = and i64 %211, 4294950912
%213 = or i64 %212, %210
%214 = lshr i64 %200, 18
%215 = shl nsw i64 %202, 8
%216 = and i64 %215, 4294967040
%217 = or i64 %216, %214
%218 = getelementptr inbounds i8, i8* %3, i64 16
%219 = call i64 @unpack(i8* %218)
%220 = add i64 %219, %205
%221 = getelementptr inbounds i8, i8* %3, i64 20
%222 = call i64 @unpack(i8* %221)
%223 = add i64 %222, %209
%224 = lshr i64 %220, 32
%225 = add i64 %223, %224
%226 = getelementptr inbounds i8, i8* %3, i64 24
%227 = call i64 @unpack(i8* %226)
%228 = add i64 %213, %227
%229 = lshr i64 %225, 32
%230 = add i64 %228, %229
%231 = getelementptr inbounds i8, i8* %3, i64 28
%232 = call i64 @unpack(i8* %231)
%233 = add i64 %217, %232
%234 = lshr i64 %230, 32
%235 = add i64 %233, %234
%236 = call i32 @pack(i8* %0, i64 %220)
%237 = getelementptr inbounds i8, i8* %0, i64 4
%238 = call i32 @pack(i8* %237, i64 %225)
%239 = getelementptr inbounds i8, i8* %0, i64 8
%240 = call i32 @pack(i8* %239, i64 %230)
%241 = getelementptr inbounds i8, i8* %0, i64 12
%242 = call i32 @pack(i8* %241, i64 %235)
ret i32 0
}