#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*/ curve25519_squeeze(unsigned int *);
void curve25519_mult(unsigned int out[32], const unsigned int a[32],
                     const unsigned int b[32]) {
  unsigned int i;
  unsigned int j;
  unsigned int u;
  for (i = 0; i < 32; ++i) {
    u = 0;
    for (j = 0; j <= i; ++j)
      u += a[j] * b[i - j];
    for (j = i + 1; j < 32; ++j)
      u += 38 * a[j] * b[i + 32 - j];
    out[i] = u;
  }
  curve25519_squeeze(out);
}


x86 assembly (clang, -O0):
<curve25519_mult>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x20,-0x1c(%rbp)
jae    11dd <curve25519_mult+0xcd>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
ja     117d <curve25519_mult+0x6d>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
mov    -0x1c(%rbp),%edx
sub    -0x20(%rbp),%edx
mov    %edx,%edx
imul   (%rcx,%rdx,4),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1143 <curve25519_mult+0x33>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x20,-0x20(%rbp)
jae    11c2 <curve25519_mult+0xb2>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   $0x26,(%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
mov    -0x1c(%rbp),%edx
add    $0x20,%edx
sub    -0x20(%rbp),%edx
mov    %edx,%edx
imul   (%rcx,%rdx,4),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1186 <curve25519_mult+0x76>
mov    -0x24(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    112b <curve25519_mult+0x1b>
mov    -0x8(%rbp),%rdi
call   1030 <curve25519_squeeze@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<curve25519_mult>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
movabs $0x7ffffffffffffffc,%r11
ff ff 7f
lea    0x14(%rsi),%r10
lea    0x70(%rdx),%rax
mov    %rax,-0x8(%rsp)
mov    $0x1,%r15d
mov    $0xfffffffffffffffc,%r13
mov    $0x1f,%eax
mov    %rax,-0x10(%rsp)
xor    %r12d,%r12d
movdqa 0xead(%rip),%xmm0
mov    %rdx,%r9
jmp    1184 <curve25519_mult+0x74>
nopl   0x0(%rax,%rax,1)
mov    %ebp,(%rdi,%r14,4)
add    $0x1,%r15
add    $0x1,%r13
addq   $0xffffffffffffffff,-0x10(%rsp)
add    $0x4,%r10
add    $0x4,%r9
cmp    $0x20,%r12
je     14a0 <curve25519_mult+0x390>
mov    %r12,%r14
cmp    $0x4,%r15
jb     12e0 <curve25519_mult+0x1d0>
mov    %r14,%rax
shr    $0x20,%rax
mov    $0x0,%r8d
mov    $0x0,%ebx
jne    12c8 <curve25519_mult+0x1b8>
mov    %r15,%r8
and    %r11,%r8
lea    -0x4(%r8),%rax
mov    %rax,%r12
shr    $0x2,%r12
add    $0x1,%r12
test   %rax,%rax
je     148b <curve25519_mult+0x37b>
mov    %r15,%rax
and    $0xfffffffffffffffc,%rax
add    $0xfffffffffffffffc,%rax
shr    $0x2,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
pxor   %xmm1,%xmm1
mov    %r13,%rbx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
lea    0x4(%rbx),%ecx
movdqu -0xc(%rdx,%rcx,4),%xmm2
pshufd $0x1b,%xmm2,%xmm3
movdqu (%rsi,%rbp,4),%xmm4
movdqu 0x10(%rsi,%rbp,4),%xmm5
pshufd $0xf5,%xmm4,%xmm6
pshufd $0x4e,%xmm2,%xmm2
pmuludq %xmm6,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pmuludq %xmm4,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm2,%xmm3
paddd  %xmm1,%xmm3
mov    %ebx,%ecx
movdqu -0xc(%rdx,%rcx,4),%xmm1
pshufd $0x1b,%xmm1,%xmm2
pshufd $0xf5,%xmm5,%xmm4
pshufd $0x4e,%xmm1,%xmm1
pmuludq %xmm4,%xmm1
pshufd $0xe8,%xmm1,%xmm4
pmuludq %xmm5,%xmm2
pshufd $0xe8,%xmm2,%xmm1
punpckldq %xmm4,%xmm1
paddd  %xmm3,%xmm1
add    $0x8,%rbp
add    $0xfffffffffffffff8,%rbx
add    $0xfffffffffffffffe,%rax
jne    11f0 <curve25519_mult+0xe0>
test   $0x1,%r12b
je     12ab <curve25519_mult+0x19b>
movdqu (%rsi,%rbp,4),%xmm2
mov    %r14d,%eax
sub    %ebp,%eax
movdqu -0xc(%rdx,%rax,4),%xmm3
pshufd $0x1b,%xmm3,%xmm4
pshufd $0xf5,%xmm2,%xmm5
pshufd $0x4e,%xmm3,%xmm3
pmuludq %xmm5,%xmm3
pshufd $0xe8,%xmm3,%xmm3
pmuludq %xmm2,%xmm4
pshufd $0xe8,%xmm4,%xmm2
punpckldq %xmm3,%xmm2
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm2
paddd  %xmm1,%xmm2
pshufd $0x55,%xmm2,%xmm1
paddd  %xmm2,%xmm1
movd   %xmm1,%ebx
mov    %ebx,%ebp
cmp    %r8,%r15
je     1345 <curve25519_mult+0x235>
test   $0x1,%r15b
jne    12eb <curve25519_mult+0x1db>
mov    %r8,%rax
cmp    %r8,%r14
jne    1309 <curve25519_mult+0x1f9>
jmp    1345 <curve25519_mult+0x235>
nopl   0x0(%rax,%rax,1)
xor    %r8d,%r8d
xor    %ebx,%ebx
test   $0x1,%r15b
je     12ce <curve25519_mult+0x1be>
mov    %r14d,%eax
sub    %r8d,%eax
mov    (%rdx,%rax,4),%ebp
imul   (%rsi,%r8,4),%ebp
add    %ebx,%ebp
mov    %r8,%rax
or     $0x1,%rax
mov    %ebp,%ebx
cmp    %r8,%r14
je     1345 <curve25519_mult+0x235>
mov    %r14,%rcx
sub    %rax,%rcx
mov    %ebx,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ecx,%ebx
mov    (%rdx,%rbx,4),%ebx
imul   (%rsi,%rax,4),%ebx
add    %ebp,%ebx
lea    -0x1(%rcx),%ebp
mov    (%rdx,%rbp,4),%ebp
imul   0x4(%rsi,%rax,4),%ebp
add    %ebx,%ebp
add    $0x2,%rax
add    $0xfffffffffffffffe,%rcx
cmp    %rax,%r15
jne    1320 <curve25519_mult+0x210>
lea    0x1(%r14),%r12
cmp    $0x1e,%r14
ja     1160 <curve25519_mult+0x50>
mov    %r13,%rcx
mov    $0x1f,%r13d
sub    %r14,%r13
cmp    $0x8,%r13
jae    1370 <curve25519_mult+0x260>
mov    %r15,%rax
mov    %rcx,%r13
jmp    1459 <curve25519_mult+0x349>
mov    -0x10(%rsp),%r11
and    $0xfffffffffffffff8,%r11
mov    %r13,%r8
and    $0xfffffffffffffff8,%r8
lea    (%r15,%r8,1),%rax
movd   %ebp,%xmm2
pxor   %xmm1,%xmm1
mov    -0x8(%rsp),%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu -0x10(%r10,%rbp,4),%xmm3
movdqu (%r10,%rbp,4),%xmm4
movdqu -0x10(%rbx),%xmm5
movdqu (%rbx),%xmm6
pshufd $0x1b,%xmm6,%xmm7
pmuludq %xmm3,%xmm7
pshufd $0xf5,%xmm3,%xmm3
pshufd $0x4e,%xmm6,%xmm6
pmuludq %xmm3,%xmm6
pshufd $0x1b,%xmm5,%xmm3
pmuludq %xmm4,%xmm3
pshufd $0xf5,%xmm4,%xmm4
pshufd $0x4e,%xmm5,%xmm5
pmuludq %xmm4,%xmm5
pmuludq %xmm0,%xmm6
pshufd $0xe8,%xmm6,%xmm4
pmuludq %xmm0,%xmm7
pshufd $0xe8,%xmm7,%xmm6
punpckldq %xmm4,%xmm6
paddd  %xmm6,%xmm2
pmuludq %xmm0,%xmm5
pshufd $0xe8,%xmm5,%xmm4
pmuludq %xmm0,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm4,%xmm3
paddd  %xmm3,%xmm1
add    $0x8,%rbp
add    $0xffffffffffffffe0,%rbx
cmp    %rbp,%r11
jne    13a0 <curve25519_mult+0x290>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm2
paddd  %xmm1,%xmm2
pshufd $0x55,%xmm2,%xmm1
paddd  %xmm2,%xmm1
movd   %xmm1,%ebp
cmp    %r8,%r13
movabs $0x7ffffffffffffffc,%r11
ff ff 7f
mov    %rcx,%r13
je     1160 <curve25519_mult+0x50>
lea    0x0(,%rax,4),%rbx
mov    $0x80,%ecx
sub    %rbx,%rcx
lea    (%rsi,%rax,4),%rbx
nopl   (%rax)
mov    (%rbx),%eax
imul   (%r9,%rcx,1),%eax
imul   $0x26,%eax,%eax
add    %eax,%ebp
add    $0x4,%rbx
add    $0xfffffffffffffffc,%rcx
jne    1470 <curve25519_mult+0x360>
jmp    1160 <curve25519_mult+0x50>
pxor   %xmm1,%xmm1
xor    %ebp,%ebp
test   $0x1,%r12b
jne    1272 <curve25519_mult+0x162>
jmp    12ab <curve25519_mult+0x19b>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <curve25519_squeeze@plt>

LLVM IR (-O0):
define void @curve25519_mult(i32* %0, i32* %1, i32* %2) {
%4 = alloca i32*
%5 = alloca i32*
%6 = alloca i32*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
store i32* %0, i32** %4
store i32* %1, i32** %5
store i32* %2, i32** %6
store i32 0, i32* %7
br label %10
10: ; preds = %70, %3
%11 = load i32, i32* %7
%12 = icmp ult i32 %11, 32
br i1 %12, label %13, label %73
13: ; preds = %10
store i32 0, i32* %9
store i32 0, i32* %8
br label %14
14: ; preds = %34, %13
%15 = load i32, i32* %8
%16 = load i32, i32* %7
%17 = icmp ule i32 %15, %16
br i1 %17, label %18, label %37
18: ; preds = %14
%19 = load i32*, i32** %5
%20 = load i32, i32* %8
%21 = zext i32 %20 to i64
%22 = getelementptr inbounds i32, i32* %19, i64 %21
%23 = load i32, i32* %22
%24 = load i32*, i32** %6
%25 = load i32, i32* %7
%26 = load i32, i32* %8
%27 = sub i32 %25, %26
%28 = zext i32 %27 to i64
%29 = getelementptr inbounds i32, i32* %24, i64 %28
%30 = load i32, i32* %29
%31 = mul i32 %23, %30
%32 = load i32, i32* %9
%33 = add i32 %32, %31
store i32 %33, i32* %9
br label %34
34: ; preds = %18
%35 = load i32, i32* %8
%36 = add i32 %35, 1
store i32 %36, i32* %8
br label %14
37: ; preds = %14
%38 = load i32, i32* %7
%39 = add i32 %38, 1
store i32 %39, i32* %8
br label %40
40: ; preds = %61, %37
%41 = load i32, i32* %8
%42 = icmp ult i32 %41, 32
br i1 %42, label %43, label %64
43: ; preds = %40
%44 = load i32*, i32** %5
%45 = load i32, i32* %8
%46 = zext i32 %45 to i64
%47 = getelementptr inbounds i32, i32* %44, i64 %46
%48 = load i32, i32* %47
%49 = mul i32 38, %48
%50 = load i32*, i32** %6
%51 = load i32, i32* %7
%52 = add i32 %51, 32
%53 = load i32, i32* %8
%54 = sub i32 %52, %53
%55 = zext i32 %54 to i64
%56 = getelementptr inbounds i32, i32* %50, i64 %55
%57 = load i32, i32* %56
%58 = mul i32 %49, %57
%59 = load i32, i32* %9
%60 = add i32 %59, %58
store i32 %60, i32* %9
br label %61
61: ; preds = %43
%62 = load i32, i32* %8
%63 = add i32 %62, 1
store i32 %63, i32* %8
br label %40
64: ; preds = %40
%65 = load i32, i32* %9
%66 = load i32*, i32** %4
%67 = load i32, i32* %7
%68 = zext i32 %67 to i64
%69 = getelementptr inbounds i32, i32* %66, i64 %68
store i32 %65, i32* %69
br label %70
70: ; preds = %64
%71 = load i32, i32* %7
%72 = add i32 %71, 1
store i32 %72, i32* %7
br label %10
73: ; preds = %10
%74 = load i32*, i32** %4
%75 = call i32 @curve25519_squeeze(i32* %74)
ret void
}

LLVM IR (-O2):
define void @curve25519_mult(i32* %0, i32* nocapture %1, i32* nocapture %2) {
%4 = getelementptr inbounds i32, i32* %2, i64 -3
%5 = getelementptr inbounds i32, i32* %2, i64 -3
%6 = getelementptr inbounds i32, i32* %2, i64 -3
br label %7
7: ; preds = %3, %178
%8 = phi i64 [ 0, %3 ], [ %119, %178 ]
%9 = phi i64 [ 1, %3 ], [ %181, %178 ]
%10 = and i64 %9, 9223372036854775804
%11 = add nsw i64 %10, -4
%12 = lshr exact i64 %11, 2
%13 = add nuw nsw i64 %12, 1
%14 = sub nsw i64 31, %8
%15 = icmp ult i64 %9, 4
%16 = icmp ugt i64 %8, 4294967295
%17 = select i1 %15, i1 true, i1 %16
br i1 %17, label %75, label %18
18: ; preds = %7
%19 = and i64 %9, 9223372036854775804
%20 = and i64 %13, 1
%21 = icmp eq i64 %11, 0
br i1 %21, label %54, label %22
22: ; preds = %18
%23 = and i64 %13, 9223372036854775806
br label %24
24: ; preds = %24, %22
%25 = phi i64 [ 0, %22 ], [ %51, %24 ]
%26 = phi <4 x i32> [ zeroinitializer, %22 ], [ %50, %24 ]
%27 = phi i64 [ 0, %22 ], [ %52, %24 ]
%28 = getelementptr inbounds i32, i32* %1, i64 %25
%29 = bitcast i32* %28 to <4 x i32>*
%30 = load <4 x i32>, <4 x i32>* %29
%31 = sub nsw i64 %8, %25
%32 = and i64 %31, 4294967295
%33 = getelementptr inbounds i32, i32* %4, i64 %32
%34 = bitcast i32* %33 to <4 x i32>*
%35 = load <4 x i32>, <4 x i32>* %34
%36 = shufflevector <4 x i32> %35, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%37 = mul <4 x i32> %36, %30
%38 = add <4 x i32> %37, %26
%39 = or i64 %25, 4
%40 = getelementptr inbounds i32, i32* %1, i64 %39
%41 = bitcast i32* %40 to <4 x i32>*
%42 = load <4 x i32>, <4 x i32>* %41
%43 = sub nsw i64 %8, %39
%44 = and i64 %43, 4294967295
%45 = getelementptr inbounds i32, i32* %5, i64 %44
%46 = bitcast i32* %45 to <4 x i32>*
%47 = load <4 x i32>, <4 x i32>* %46
%48 = shufflevector <4 x i32> %47, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%49 = mul <4 x i32> %48, %42
%50 = add <4 x i32> %49, %38
%51 = add nuw i64 %25, 8
%52 = add i64 %27, 2
%53 = icmp eq i64 %52, %23
br i1 %53, label %54, label %24
54: ; preds = %24, %18
%55 = phi <4 x i32> [ undef, %18 ], [ %50, %24 ]
%56 = phi i64 [ 0, %18 ], [ %51, %24 ]
%57 = phi <4 x i32> [ zeroinitializer, %18 ], [ %50, %24 ]
%58 = icmp eq i64 %20, 0
br i1 %58, label %71, label %59
59: ; preds = %54
%60 = getelementptr inbounds i32, i32* %1, i64 %56
%61 = bitcast i32* %60 to <4 x i32>*
%62 = load <4 x i32>, <4 x i32>* %61
%63 = sub nsw i64 %8, %56
%64 = and i64 %63, 4294967295
%65 = getelementptr inbounds i32, i32* %6, i64 %64
%66 = bitcast i32* %65 to <4 x i32>*
%67 = load <4 x i32>, <4 x i32>* %66
%68 = shufflevector <4 x i32> %67, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%69 = mul <4 x i32> %68, %62
%70 = add <4 x i32> %69, %57
br label %71
71: ; preds = %54, %59
%72 = phi <4 x i32> [ %55, %54 ], [ %70, %59 ]
%73 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %72)
%74 = icmp eq i64 %9, %19
br i1 %74, label %117, label %75
75: ; preds = %7, %71
%76 = phi i64 [ 0, %7 ], [ %19, %71 ]
%77 = phi i32 [ 0, %7 ], [ %73, %71 ]
%78 = and i64 %9, 1
%79 = icmp eq i64 %78, 0
br i1 %79, label %90, label %80
80: ; preds = %75
%81 = getelementptr inbounds i32, i32* %1, i64 %76
%82 = load i32, i32* %81
%83 = sub nsw i64 %8, %76
%84 = and i64 %83, 4294967295
%85 = getelementptr inbounds i32, i32* %2, i64 %84
%86 = load i32, i32* %85
%87 = mul i32 %86, %82
%88 = add i32 %87, %77
%89 = or i64 %76, 1
br label %90
90: ; preds = %80, %75
%91 = phi i32 [ undef, %75 ], [ %88, %80 ]
%92 = phi i64 [ %76, %75 ], [ %89, %80 ]
%93 = phi i32 [ %77, %75 ], [ %88, %80 ]
%94 = icmp eq i64 %8, %76
br i1 %94, label %117, label %95
95: ; preds = %90, %95
%96 = phi i64 [ %115, %95 ], [ %92, %90 ]
%97 = phi i32 [ %114, %95 ], [ %93, %90 ]
%98 = getelementptr inbounds i32, i32* %1, i64 %96
%99 = load i32, i32* %98
%100 = sub nsw i64 %8, %96
%101 = and i64 %100, 4294967295
%102 = getelementptr inbounds i32, i32* %2, i64 %101
%103 = load i32, i32* %102
%104 = mul i32 %103, %99
%105 = add i32 %104, %97
%106 = add nuw nsw i64 %96, 1
%107 = getelementptr inbounds i32, i32* %1, i64 %106
%108 = load i32, i32* %107
%109 = sub nsw i64 %8, %106
%110 = and i64 %109, 4294967295
%111 = getelementptr inbounds i32, i32* %2, i64 %110
%112 = load i32, i32* %111
%113 = mul i32 %112, %108
%114 = add i32 %113, %105
%115 = add nuw nsw i64 %96, 2
%116 = icmp eq i64 %115, %9
br i1 %116, label %117, label %95
117: ; preds = %90, %95, %71
%118 = phi i32 [ %73, %71 ], [ %91, %90 ], [ %114, %95 ]
%119 = add nuw nsw i64 %8, 1
%120 = icmp ult i64 %8, 31
br i1 %120, label %121, label %178
121: ; preds = %117
%122 = add nuw nsw i64 %8, 32
%123 = icmp ult i64 %14, 8
br i1 %123, label %162, label %124
124: ; preds = %121
%125 = and i64 %14, -8
%126 = add i64 %9, %125
%127 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %118, i64 0
br label %128
128: ; preds = %128, %124
%129 = phi i64 [ 0, %124 ], [ %156, %128 ]
%130 = phi <4 x i32> [ %127, %124 ], [ %154, %128 ]
%131 = phi <4 x i32> [ zeroinitializer, %124 ], [ %155, %128 ]
%132 = add i64 %9, %129
%133 = getelementptr inbounds i32, i32* %1, i64 %132
%134 = bitcast i32* %133 to <4 x i32>*
%135 = load <4 x i32>, <4 x i32>* %134
%136 = getelementptr inbounds i32, i32* %133, i64 4
%137 = bitcast i32* %136 to <4 x i32>*
%138 = load <4 x i32>, <4 x i32>* %137
%139 = mul <4 x i32> %135, <i32 38, i32 38, i32 38, i32 38>
%140 = mul <4 x i32> %138, <i32 38, i32 38, i32 38, i32 38>
%141 = sub nuw nsw i64 %122, %132
%142 = getelementptr inbounds i32, i32* %2, i64 %141
%143 = getelementptr inbounds i32, i32* %142, i64 -3
%144 = bitcast i32* %143 to <4 x i32>*
%145 = load <4 x i32>, <4 x i32>* %144
%146 = shufflevector <4 x i32> %145, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%147 = getelementptr inbounds i32, i32* %142, i64 -4
%148 = getelementptr inbounds i32, i32* %147, i64 -3
%149 = bitcast i32* %148 to <4 x i32>*
%150 = load <4 x i32>, <4 x i32>* %149
%151 = shufflevector <4 x i32> %150, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%152 = mul <4 x i32> %139, %146
%153 = mul <4 x i32> %140, %151
%154 = add <4 x i32> %152, %130
%155 = add <4 x i32> %153, %131
%156 = add nuw i64 %129, 8
%157 = icmp eq i64 %156, %125
br i1 %157, label %158, label %128
158: ; preds = %128
%159 = add <4 x i32> %155, %154
%160 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %159)
%161 = icmp eq i64 %14, %125
br i1 %161, label %178, label %162
162: ; preds = %121, %158
%163 = phi i64 [ %9, %121 ], [ %126, %158 ]
%164 = phi i32 [ %118, %121 ], [ %160, %158 ]
br label %165
165: ; preds = %162, %165
%166 = phi i64 [ %176, %165 ], [ %163, %162 ]
%167 = phi i32 [ %175, %165 ], [ %164, %162 ]
%168 = getelementptr inbounds i32, i32* %1, i64 %166
%169 = load i32, i32* %168
%170 = mul i32 %169, 38
%171 = sub nuw nsw i64 %122, %166
%172 = getelementptr inbounds i32, i32* %2, i64 %171
%173 = load i32, i32* %172
%174 = mul i32 %170, %173
%175 = add i32 %174, %167
%176 = add nuw nsw i64 %166, 1
%177 = icmp eq i64 %176, 32
br i1 %177, label %178, label %165
178: ; preds = %165, %158, %117
%179 = phi i32 [ %118, %117 ], [ %160, %158 ], [ %175, %165 ]
%180 = getelementptr inbounds i32, i32* %0, i64 %8
store i32 %179, i32* %180
%181 = add nuw nsw i64 %9, 1
%182 = icmp eq i64 %119, 32
br i1 %182, label %183, label %7
183: ; preds = %178
%184 = tail call i32 @curve25519_squeeze(i32* %0)
ret void
}