double exppart(double *n, double *X, double *x, double *intshift, int g) {
  double tmp1[g];
  double tmp2[g];
  int i, j;
  for (i = 0; i < g; i++)
    tmp1[i] = n[i] - intshift[i];
  double sum;
  for (i = 0; i < g; i++) {
    sum = 0;
    for (j = 0; j < g; j++)
      sum += X[i * g + j] * tmp1[j];
    tmp2[i] = sum / 2.0;
  }
  for (i = 0; i < g; i++)
    tmp2[i] = tmp2[i] + x[i];
  double dot = 0;
  for (i = 0; i < g; i++)
    dot += tmp1[i] * tmp2[i];
  return 2 * 3.14159265358979323846 * dot;
}


x86 assembly (clang, -O0):
<exppart>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x30(%rbp)
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x68(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x38(%rbp)
mov    -0x24(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x60(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11ab <exppart+0xab>
mov    -0x68(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x44(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x20(%rbp),%rcx
movslq -0x44(%rbp),%rdx
subsd  (%rcx,%rdx,8),%xmm0
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    116a <exppart+0x6a>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1248 <exppart+0x148>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    121c <exppart+0x11c>
mov    -0x68(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x44(%rbp),%edx
imul   -0x24(%rbp),%edx
add    -0x48(%rbp),%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    11cd <exppart+0xcd>
mov    -0x60(%rbp),%rax
movsd  -0x50(%rbp),%xmm0
movsd  0xddb(%rip),%xmm1
divsd  %xmm1,%xmm0
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11b2 <exppart+0xb2>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    128c <exppart+0x18c>
mov    -0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rcx
movslq -0x44(%rbp),%rdx
addsd  (%rcx,%rdx,8),%xmm0
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    124f <exppart+0x14f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12e1 <exppart+0x1e1>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rcx
movslq -0x44(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    129b <exppart+0x19b>
movsd  0xd17(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<exppart>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %r8d,%r10d
mov    %rsp,%rax
lea    0xf(,%r10,8),%rbx
and    $0xfffffffffffffff0,%rbx
sub    %rbx,%rax
mov    %rax,%rsp
mov    %rsp,%r9
sub    %rbx,%r9
mov    %r9,%rsp
xorpd  %xmm0,%xmm0
test   %r8d,%r8d
jle    14ef <exppart+0x3ef>
cmp    $0x4,%r8d
jae    114a <exppart+0x4a>
xor    %r11d,%r11d
jmp    1220 <exppart+0x120>
mov    %r10d,%r11d
and    $0xfffffffc,%r11d
lea    -0x4(%r11),%rbx
mov    %rbx,%r14
shr    $0x2,%r14
add    $0x1,%r14
test   %rbx,%rbx
je     1447 <exppart+0x347>
mov    %r14,%r15
and    $0xfffffffffffffffe,%r15
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%rdi,%rbx,8),%xmm1
movupd 0x10(%rdi,%rbx,8),%xmm2
movupd (%rcx,%rbx,8),%xmm3
subpd  %xmm3,%xmm1
movupd 0x10(%rcx,%rbx,8),%xmm3
subpd  %xmm3,%xmm2
movapd %xmm1,(%rax,%rbx,8)
movapd %xmm2,0x10(%rax,%rbx,8)
movupd 0x20(%rdi,%rbx,8),%xmm1
movupd 0x30(%rdi,%rbx,8),%xmm2
movupd 0x20(%rcx,%rbx,8),%xmm3
subpd  %xmm3,%xmm1
movupd 0x30(%rcx,%rbx,8),%xmm3
subpd  %xmm3,%xmm2
movapd %xmm1,0x20(%rax,%rbx,8)
movapd %xmm2,0x30(%rax,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%r15
jne    1180 <exppart+0x80>
test   $0x1,%r14b
je     120e <exppart+0x10e>
movupd (%rdi,%rbx,8),%xmm1
movupd 0x10(%rdi,%rbx,8),%xmm2
movupd (%rcx,%rbx,8),%xmm3
subpd  %xmm3,%xmm1
movupd 0x10(%rcx,%rbx,8),%xmm3
subpd  %xmm3,%xmm2
movapd %xmm1,(%rax,%rbx,8)
movapd %xmm2,0x10(%rax,%rbx,8)
cmp    %r10,%r11
je     123b <exppart+0x13b>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdi,%r11,8),%xmm1
subsd  (%rcx,%r11,8),%xmm1
movsd  %xmm1,(%rax,%r11,8)
add    $0x1,%r11
cmp    %r11,%r10
jne    1220 <exppart+0x120>
test   %r8d,%r8d
jle    14ef <exppart+0x3ef>
mov    %r8d,-0x2c(%rbp)
lea    -0x1(%r10),%r8
mov    %r10d,%r13d
and    $0x3,%r13d
mov    %r10d,%r12d
and    $0xfffffffc,%r12d
lea    0x18(%rsi),%rbx
lea    0x0(,%r10,8),%r14
xor    %r15d,%r15d
movsd  0xd8f(%rip),%xmm0
jmp    129d <exppart+0x19d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r9,%r15,8)
add    $0x1,%r15
add    %r14,%rbx
add    %r14,%rsi
cmp    %r10,%r15
je     132e <exppart+0x22e>
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
cmp    $0x3,%r8
jb     12f7 <exppart+0x1f7>
nopl   0x0(%rax)
movsd  -0x18(%rbx,%rcx,8),%xmm2
movsd  -0x10(%rbx,%rcx,8),%xmm3
mulsd  (%rax,%rcx,8),%xmm2
mulsd  0x8(%rax,%rcx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  -0x8(%rbx,%rcx,8),%xmm4
mulsd  0x10(%rax,%rcx,8),%xmm4
addsd  %xmm2,%xmm3
movsd  (%rbx,%rcx,8),%xmm1
mulsd  0x18(%rax,%rcx,8),%xmm1
addsd  %xmm3,%xmm4
addsd  %xmm4,%xmm1
add    $0x4,%rcx
cmp    %rcx,%r12
jne    12b0 <exppart+0x1b0>
test   %r13,%r13
je     1280 <exppart+0x180>
lea    (%rax,%rcx,8),%rdi
lea    (%rsi,%rcx,8),%rcx
xor    %r11d,%r11d
nopw   0x0(%rax,%rax,1)
movsd  (%rcx,%r11,8),%xmm2
mulsd  (%rdi,%r11,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%r11
cmp    %r11,%r13
jne    1310 <exppart+0x210>
jmp    1280 <exppart+0x180>
xorpd  %xmm0,%xmm0
mov    -0x2c(%rbp),%r11d
test   %r11d,%r11d
jle    14ef <exppart+0x3ef>
cmp    $0x4,%r11d
jae    134c <exppart+0x24c>
xor    %ecx,%ecx
jmp    1410 <exppart+0x310>
mov    %r10d,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
test   %rsi,%rsi
je     14fe <exppart+0x3fe>
mov    %rdi,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%rdx,%rsi,8),%xmm1
movupd 0x10(%rdx,%rsi,8),%xmm2
addpd  (%r9,%rsi,8),%xmm1
addpd  0x10(%r9,%rsi,8),%xmm2
movapd %xmm1,(%r9,%rsi,8)
movapd %xmm2,0x10(%r9,%rsi,8)
movupd 0x20(%rdx,%rsi,8),%xmm1
movupd 0x30(%rdx,%rsi,8),%xmm2
addpd  0x20(%r9,%rsi,8),%xmm1
addpd  0x30(%r9,%rsi,8),%xmm2
movapd %xmm1,0x20(%r9,%rsi,8)
movapd %xmm2,0x30(%r9,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rbx
jne    1380 <exppart+0x280>
test   $0x1,%dil
je     1402 <exppart+0x302>
movupd (%rdx,%rsi,8),%xmm1
movupd 0x10(%rdx,%rsi,8),%xmm2
addpd  (%r9,%rsi,8),%xmm1
addpd  0x10(%r9,%rsi,8),%xmm2
movapd %xmm1,(%r9,%rsi,8)
movapd %xmm2,0x10(%r9,%rsi,8)
cmp    %r10,%rcx
je     142a <exppart+0x32a>
nopw   0x0(%rax,%rax,1)
movsd  (%r9,%rcx,8),%xmm1
addsd  (%rdx,%rcx,8),%xmm1
movsd  %xmm1,(%r9,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r10
jne    1410 <exppart+0x310>
test   %r11d,%r11d
jle    14ef <exppart+0x3ef>
mov    %r10d,%ecx
and    $0x3,%ecx
cmp    $0x3,%r8
jae    1458 <exppart+0x358>
xorpd  %xmm0,%xmm0
xor    %edx,%edx
jmp    14bb <exppart+0x3bb>
xor    %ebx,%ebx
test   $0x1,%r14b
jne    11e5 <exppart+0xe5>
jmp    120e <exppart+0x10e>
and    $0xfffffffc,%r10d
xorpd  %xmm0,%xmm0
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rax,%rdx,8),%xmm1
movsd  0x8(%rax,%rdx,8),%xmm2
mulsd  (%r9,%rdx,8),%xmm1
mulsd  0x8(%r9,%rdx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x10(%rax,%rdx,8),%xmm3
mulsd  0x10(%r9,%rdx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x18(%rax,%rdx,8),%xmm0
mulsd  0x18(%r9,%rdx,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rdx
cmp    %rdx,%r10
jne    1470 <exppart+0x370>
test   %rcx,%rcx
je     14e7 <exppart+0x3e7>
lea    (%r9,%rdx,8),%rsi
lea    (%rax,%rdx,8),%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm1
mulsd  (%rsi,%rdx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    14d0 <exppart+0x3d0>
mulsd  0xb19(%rip),%xmm0
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %esi,%esi
test   $0x1,%dil
jne    13dd <exppart+0x2dd>
jmp    1402 <exppart+0x302>

LLVM IR (-O0):
define double @exppart(double* %0, double* %1, double* %2, double* %3, i32 %4) {
%6 = alloca double*
%7 = alloca double*
%8 = alloca double*
%9 = alloca double*
%10 = alloca i32
%11 = alloca i8*
%12 = alloca i64
%13 = alloca i64
%14 = alloca i32
%15 = alloca i32
%16 = alloca double
%17 = alloca double
store double* %0, double** %6
store double* %1, double** %7
store double* %2, double** %8
store double* %3, double** %9
store i32 %4, i32* %10
%18 = load i32, i32* %10
%19 = zext i32 %18 to i64
%20 = call i8* @llvm.stacksave()
store i8* %20, i8** %11
%21 = alloca double, i64 %19
store i64 %19, i64* %12
%22 = load i32, i32* %10
%23 = zext i32 %22 to i64
%24 = alloca double, i64 %23
store i64 %23, i64* %13
store i32 0, i32* %14
br label %25
25: ; preds = %44, %5
%26 = load i32, i32* %14
%27 = load i32, i32* %10
%28 = icmp slt i32 %26, %27
br i1 %28, label %29, label %47
29: ; preds = %25
%30 = load double*, double** %6
%31 = load i32, i32* %14
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds double, double* %30, i64 %32
%34 = load double, double* %33
%35 = load double*, double** %9
%36 = load i32, i32* %14
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds double, double* %35, i64 %37
%39 = load double, double* %38
%40 = fsub double %34, %39
%41 = load i32, i32* %14
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds double, double* %21, i64 %42
store double %40, double* %43
br label %44
44: ; preds = %29
%45 = load i32, i32* %14
%46 = add nsw i32 %45, 1
store i32 %46, i32* %14
br label %25
47: ; preds = %25
store i32 0, i32* %14
br label %48
48: ; preds = %82, %47
%49 = load i32, i32* %14
%50 = load i32, i32* %10
%51 = icmp slt i32 %49, %50
br i1 %51, label %52, label %85
52: ; preds = %48
store double 0.000000e+00, double* %16
store i32 0, i32* %15
br label %53
53: ; preds = %73, %52
%54 = load i32, i32* %15
%55 = load i32, i32* %10
%56 = icmp slt i32 %54, %55
br i1 %56, label %57, label %76
57: ; preds = %53
%58 = load double*, double** %7
%59 = load i32, i32* %14
%60 = load i32, i32* %10
%61 = mul nsw i32 %59, %60
%62 = load i32, i32* %15
%63 = add nsw i32 %61, %62
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds double, double* %58, i64 %64
%66 = load double, double* %65
%67 = load i32, i32* %15
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds double, double* %21, i64 %68
%70 = load double, double* %69
%71 = load double, double* %16
%72 = call double @llvm.fmuladd.f64(double %66, double %70, double %71)
store double %72, double* %16
br label %73
73: ; preds = %57
%74 = load i32, i32* %15
%75 = add nsw i32 %74, 1
store i32 %75, i32* %15
br label %53
76: ; preds = %53
%77 = load double, double* %16
%78 = fdiv double %77, 2.000000e+00
%79 = load i32, i32* %14
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds double, double* %24, i64 %80
store double %78, double* %81
br label %82
82: ; preds = %76
%83 = load i32, i32* %14
%84 = add nsw i32 %83, 1
store i32 %84, i32* %14
br label %48
85: ; preds = %48
store i32 0, i32* %14
br label %86
86: ; preds = %104, %85
%87 = load i32, i32* %14
%88 = load i32, i32* %10
%89 = icmp slt i32 %87, %88
br i1 %89, label %90, label %107
90: ; preds = %86
%91 = load i32, i32* %14
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds double, double* %24, i64 %92
%94 = load double, double* %93
%95 = load double*, double** %8
%96 = load i32, i32* %14
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds double, double* %95, i64 %97
%99 = load double, double* %98
%100 = fadd double %94, %99
%101 = load i32, i32* %14
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds double, double* %24, i64 %102
store double %100, double* %103
br label %104
104: ; preds = %90
%105 = load i32, i32* %14
%106 = add nsw i32 %105, 1
store i32 %106, i32* %14
br label %86
107: ; preds = %86
store double 0.000000e+00, double* %17
store i32 0, i32* %14
br label %108
108: ; preds = %123, %107
%109 = load i32, i32* %14
%110 = load i32, i32* %10
%111 = icmp slt i32 %109, %110
br i1 %111, label %112, label %126
112: ; preds = %108
%113 = load i32, i32* %14
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds double, double* %21, i64 %114
%116 = load double, double* %115
%117 = load i32, i32* %14
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds double, double* %24, i64 %118
%120 = load double, double* %119
%121 = load double, double* %17
%122 = call double @llvm.fmuladd.f64(double %116, double %120, double %121)
store double %122, double* %17
br label %123
123: ; preds = %112
%124 = load i32, i32* %14
%125 = add nsw i32 %124, 1
store i32 %125, i32* %14
br label %108
126: ; preds = %108
%127 = load double, double* %17
%128 = fmul double 0x401921FB54442D18, %127
%129 = load i8*, i8** %11
ret double %128
}

LLVM IR (-O2):
define double @exppart(double* nocapture %0, double* nocapture %1, double* nocapture %2, double* nocapture %3, i32 %4) {
%6 = zext i32 %4 to i64
%7 = alloca double, i64 %6
%8 = alloca double, i64 %6
%9 = icmp sgt i32 %4, 0
br i1 %9, label %10, label %308
10: ; preds = %5
%11 = icmp ult i32 %4, 4
br i1 %11, label %88, label %12
12: ; preds = %10
%13 = and i64 %6, 4294967292
%14 = add nsw i64 %13, -4
%15 = lshr exact i64 %14, 2
%16 = add nuw nsw i64 %15, 1
%17 = and i64 %16, 1
%18 = icmp eq i64 %14, 0
br i1 %18, label %64, label %19
19: ; preds = %12
%20 = and i64 %16, 9223372036854775806
br label %21
21: ; preds = %21, %19
%22 = phi i64 [ 0, %19 ], [ %61, %21 ]
%23 = phi i64 [ 0, %19 ], [ %62, %21 ]
%24 = getelementptr inbounds double, double* %0, i64 %22
%25 = bitcast double* %24 to <2 x double>*
%26 = load <2 x double>, <2 x double>* %25
%27 = getelementptr inbounds double, double* %24, i64 2
%28 = bitcast double* %27 to <2 x double>*
%29 = load <2 x double>, <2 x double>* %28
%30 = getelementptr inbounds double, double* %3, i64 %22
%31 = bitcast double* %30 to <2 x double>*
%32 = load <2 x double>, <2 x double>* %31
%33 = getelementptr inbounds double, double* %30, i64 2
%34 = bitcast double* %33 to <2 x double>*
%35 = load <2 x double>, <2 x double>* %34
%36 = fsub <2 x double> %26, %32
%37 = fsub <2 x double> %29, %35
%38 = getelementptr inbounds double, double* %7, i64 %22
%39 = bitcast double* %38 to <2 x double>*
store <2 x double> %36, <2 x double>* %39
%40 = getelementptr inbounds double, double* %38, i64 2
%41 = bitcast double* %40 to <2 x double>*
store <2 x double> %37, <2 x double>* %41
%42 = or i64 %22, 4
%43 = getelementptr inbounds double, double* %0, i64 %42
%44 = bitcast double* %43 to <2 x double>*
%45 = load <2 x double>, <2 x double>* %44
%46 = getelementptr inbounds double, double* %43, i64 2
%47 = bitcast double* %46 to <2 x double>*
%48 = load <2 x double>, <2 x double>* %47
%49 = getelementptr inbounds double, double* %3, i64 %42
%50 = bitcast double* %49 to <2 x double>*
%51 = load <2 x double>, <2 x double>* %50
%52 = getelementptr inbounds double, double* %49, i64 2
%53 = bitcast double* %52 to <2 x double>*
%54 = load <2 x double>, <2 x double>* %53
%55 = fsub <2 x double> %45, %51
%56 = fsub <2 x double> %48, %54
%57 = getelementptr inbounds double, double* %7, i64 %42
%58 = bitcast double* %57 to <2 x double>*
store <2 x double> %55, <2 x double>* %58
%59 = getelementptr inbounds double, double* %57, i64 2
%60 = bitcast double* %59 to <2 x double>*
store <2 x double> %56, <2 x double>* %60
%61 = add nuw i64 %22, 8
%62 = add i64 %23, 2
%63 = icmp eq i64 %62, %20
br i1 %63, label %64, label %21
64: ; preds = %21, %12
%65 = phi i64 [ 0, %12 ], [ %61, %21 ]
%66 = icmp eq i64 %17, 0
br i1 %66, label %86, label %67
67: ; preds = %64
%68 = getelementptr inbounds double, double* %0, i64 %65
%69 = bitcast double* %68 to <2 x double>*
%70 = load <2 x double>, <2 x double>* %69
%71 = getelementptr inbounds double, double* %68, i64 2
%72 = bitcast double* %71 to <2 x double>*
%73 = load <2 x double>, <2 x double>* %72
%74 = getelementptr inbounds double, double* %3, i64 %65
%75 = bitcast double* %74 to <2 x double>*
%76 = load <2 x double>, <2 x double>* %75
%77 = getelementptr inbounds double, double* %74, i64 2
%78 = bitcast double* %77 to <2 x double>*
%79 = load <2 x double>, <2 x double>* %78
%80 = fsub <2 x double> %70, %76
%81 = fsub <2 x double> %73, %79
%82 = getelementptr inbounds double, double* %7, i64 %65
%83 = bitcast double* %82 to <2 x double>*
store <2 x double> %80, <2 x double>* %83
%84 = getelementptr inbounds double, double* %82, i64 2
%85 = bitcast double* %84 to <2 x double>*
store <2 x double> %81, <2 x double>* %85
br label %86
86: ; preds = %64, %67
%87 = icmp eq i64 %13, %6
br i1 %87, label %90, label %88
88: ; preds = %10, %86
%89 = phi i64 [ 0, %10 ], [ %13, %86 ]
br label %98
90: ; preds = %98, %86
br i1 %9, label %91, label %308
91: ; preds = %90
%92 = zext i32 %4 to i64
%93 = add nsw i64 %6, -1
%94 = and i64 %6, 3
%95 = icmp ult i64 %93, 3
%96 = and i64 %6, 4294967292
%97 = icmp eq i64 %94, 0
br label %108
98: ; preds = %88, %98
%99 = phi i64 [ %106, %98 ], [ %89, %88 ]
%100 = getelementptr inbounds double, double* %0, i64 %99
%101 = load double, double* %100
%102 = getelementptr inbounds double, double* %3, i64 %99
%103 = load double, double* %102
%104 = fsub double %101, %103
%105 = getelementptr inbounds double, double* %7, i64 %99
store double %104, double* %105
%106 = add nuw nsw i64 %99, 1
%107 = icmp eq i64 %106, %6
br i1 %107, label %90, label %98
108: ; preds = %237, %91
%109 = phi i64 [ 0, %91 ], [ %241, %237 ]
%110 = mul nsw i64 %109, %92
br i1 %95, label %220, label %186
111: ; preds = %237
br i1 %9, label %112, label %308
112: ; preds = %111
%113 = icmp ult i32 %4, 4
br i1 %113, label %184, label %114
114: ; preds = %112
%115 = and i64 %6, 4294967292
%116 = add nsw i64 %115, -4
%117 = lshr exact i64 %116, 2
%118 = add nuw nsw i64 %117, 1
%119 = and i64 %118, 1
%120 = icmp eq i64 %116, 0
br i1 %120, label %162, label %121
121: ; preds = %114
%122 = and i64 %118, 9223372036854775806
br label %123
123: ; preds = %123, %121
%124 = phi i64 [ 0, %121 ], [ %159, %123 ]
%125 = phi i64 [ 0, %121 ], [ %160, %123 ]
%126 = getelementptr inbounds double, double* %8, i64 %124
%127 = bitcast double* %126 to <2 x double>*
%128 = load <2 x double>, <2 x double>* %127
%129 = getelementptr inbounds double, double* %126, i64 2
%130 = bitcast double* %129 to <2 x double>*
%131 = load <2 x double>, <2 x double>* %130
%132 = getelementptr inbounds double, double* %2, i64 %124
%133 = bitcast double* %132 to <2 x double>*
%134 = load <2 x double>, <2 x double>* %133
%135 = getelementptr inbounds double, double* %132, i64 2
%136 = bitcast double* %135 to <2 x double>*
%137 = load <2 x double>, <2 x double>* %136
%138 = fadd <2 x double> %128, %134
%139 = fadd <2 x double> %131, %137
%140 = bitcast double* %126 to <2 x double>*
store <2 x double> %138, <2 x double>* %140
%141 = bitcast double* %129 to <2 x double>*
store <2 x double> %139, <2 x double>* %141
%142 = or i64 %124, 4
%143 = getelementptr inbounds double, double* %8, i64 %142
%144 = bitcast double* %143 to <2 x double>*
%145 = load <2 x double>, <2 x double>* %144
%146 = getelementptr inbounds double, double* %143, i64 2
%147 = bitcast double* %146 to <2 x double>*
%148 = load <2 x double>, <2 x double>* %147
%149 = getelementptr inbounds double, double* %2, i64 %142
%150 = bitcast double* %149 to <2 x double>*
%151 = load <2 x double>, <2 x double>* %150
%152 = getelementptr inbounds double, double* %149, i64 2
%153 = bitcast double* %152 to <2 x double>*
%154 = load <2 x double>, <2 x double>* %153
%155 = fadd <2 x double> %145, %151
%156 = fadd <2 x double> %148, %154
%157 = bitcast double* %143 to <2 x double>*
store <2 x double> %155, <2 x double>* %157
%158 = bitcast double* %146 to <2 x double>*
store <2 x double> %156, <2 x double>* %158
%159 = add nuw i64 %124, 8
%160 = add i64 %125, 2
%161 = icmp eq i64 %160, %122
br i1 %161, label %162, label %123
162: ; preds = %123, %114
%163 = phi i64 [ 0, %114 ], [ %159, %123 ]
%164 = icmp eq i64 %119, 0
br i1 %164, label %182, label %165
165: ; preds = %162
%166 = getelementptr inbounds double, double* %8, i64 %163
%167 = bitcast double* %166 to <2 x double>*
%168 = load <2 x double>, <2 x double>* %167
%169 = getelementptr inbounds double, double* %166, i64 2
%170 = bitcast double* %169 to <2 x double>*
%171 = load <2 x double>, <2 x double>* %170
%172 = getelementptr inbounds double, double* %2, i64 %163
%173 = bitcast double* %172 to <2 x double>*
%174 = load <2 x double>, <2 x double>* %173
%175 = getelementptr inbounds double, double* %172, i64 2
%176 = bitcast double* %175 to <2 x double>*
%177 = load <2 x double>, <2 x double>* %176
%178 = fadd <2 x double> %168, %174
%179 = fadd <2 x double> %171, %177
%180 = bitcast double* %166 to <2 x double>*
store <2 x double> %178, <2 x double>* %180
%181 = bitcast double* %169 to <2 x double>*
store <2 x double> %179, <2 x double>* %181
br label %182
182: ; preds = %162, %165
%183 = icmp eq i64 %115, %6
br i1 %183, label %243, label %184
184: ; preds = %112, %182
%185 = phi i64 [ 0, %112 ], [ %115, %182 ]
br label %249
186: ; preds = %108, %186
%187 = phi i64 [ %217, %186 ], [ 0, %108 ]
%188 = phi double [ %216, %186 ], [ 0.000000e+00, %108 ]
%189 = phi i64 [ %218, %186 ], [ 0, %108 ]
%190 = add nuw nsw i64 %187, %110
%191 = getelementptr inbounds double, double* %1, i64 %190
%192 = load double, double* %191
%193 = getelementptr inbounds double, double* %7, i64 %187
%194 = load double, double* %193
%195 = tail call double @llvm.fmuladd.f64(double %192, double %194, double %188)
%196 = or i64 %187, 1
%197 = add nuw nsw i64 %196, %110
%198 = getelementptr inbounds double, double* %1, i64 %197
%199 = load double, double* %198
%200 = getelementptr inbounds double, double* %7, i64 %196
%201 = load double, double* %200
%202 = tail call double @llvm.fmuladd.f64(double %199, double %201, double %195)
%203 = or i64 %187, 2
%204 = add nuw nsw i64 %203, %110
%205 = getelementptr inbounds double, double* %1, i64 %204
%206 = load double, double* %205
%207 = getelementptr inbounds double, double* %7, i64 %203
%208 = load double, double* %207
%209 = tail call double @llvm.fmuladd.f64(double %206, double %208, double %202)
%210 = or i64 %187, 3
%211 = add nuw nsw i64 %210, %110
%212 = getelementptr inbounds double, double* %1, i64 %211
%213 = load double, double* %212
%214 = getelementptr inbounds double, double* %7, i64 %210
%215 = load double, double* %214
%216 = tail call double @llvm.fmuladd.f64(double %213, double %215, double %209)
%217 = add nuw nsw i64 %187, 4
%218 = add i64 %189, 4
%219 = icmp eq i64 %218, %96
br i1 %219, label %220, label %186
220: ; preds = %186, %108
%221 = phi double [ undef, %108 ], [ %216, %186 ]
%222 = phi i64 [ 0, %108 ], [ %217, %186 ]
%223 = phi double [ 0.000000e+00, %108 ], [ %216, %186 ]
br i1 %97, label %237, label %224
224: ; preds = %220, %224
%225 = phi i64 [ %234, %224 ], [ %222, %220 ]
%226 = phi double [ %233, %224 ], [ %223, %220 ]
%227 = phi i64 [ %235, %224 ], [ 0, %220 ]
%228 = add nuw nsw i64 %225, %110
%229 = getelementptr inbounds double, double* %1, i64 %228
%230 = load double, double* %229
%231 = getelementptr inbounds double, double* %7, i64 %225
%232 = load double, double* %231
%233 = tail call double @llvm.fmuladd.f64(double %230, double %232, double %226)
%234 = add nuw nsw i64 %225, 1
%235 = add i64 %227, 1
%236 = icmp eq i64 %235, %94
br i1 %236, label %237, label %224
237: ; preds = %224, %220
%238 = phi double [ %221, %220 ], [ %233, %224 ]
%239 = fmul double %238, 5.000000e-01
%240 = getelementptr inbounds double, double* %8, i64 %109
store double %239, double* %240
%241 = add nuw nsw i64 %109, 1
%242 = icmp eq i64 %241, %6
br i1 %242, label %111, label %108
243: ; preds = %249, %182
br i1 %9, label %244, label %308
244: ; preds = %243
%245 = and i64 %6, 3
%246 = icmp ult i64 %93, 3
br i1 %246, label %288, label %247
247: ; preds = %244
%248 = and i64 %6, 4294967292
br label %258
249: ; preds = %184, %249
%250 = phi i64 [ %256, %249 ], [ %185, %184 ]
%251 = getelementptr inbounds double, double* %8, i64 %250
%252 = load double, double* %251
%253 = getelementptr inbounds double, double* %2, i64 %250
%254 = load double, double* %253
%255 = fadd double %252, %254
store double %255, double* %251
%256 = add nuw nsw i64 %250, 1
%257 = icmp eq i64 %256, %6
br i1 %257, label %243, label %249
258: ; preds = %258, %247
%259 = phi i64 [ 0, %247 ], [ %285, %258 ]
%260 = phi double [ 0.000000e+00, %247 ], [ %284, %258 ]
%261 = phi i64 [ 0, %247 ], [ %286, %258 ]
%262 = getelementptr inbounds double, double* %7, i64 %259
%263 = load double, double* %262
%264 = getelementptr inbounds double, double* %8, i64 %259
%265 = load double, double* %264
%266 = tail call double @llvm.fmuladd.f64(double %263, double %265, double %260)
%267 = or i64 %259, 1
%268 = getelementptr inbounds double, double* %7, i64 %267
%269 = load double, double* %268
%270 = getelementptr inbounds double, double* %8, i64 %267
%271 = load double, double* %270
%272 = tail call double @llvm.fmuladd.f64(double %269, double %271, double %266)
%273 = or i64 %259, 2
%274 = getelementptr inbounds double, double* %7, i64 %273
%275 = load double, double* %274
%276 = getelementptr inbounds double, double* %8, i64 %273
%277 = load double, double* %276
%278 = tail call double @llvm.fmuladd.f64(double %275, double %277, double %272)
%279 = or i64 %259, 3
%280 = getelementptr inbounds double, double* %7, i64 %279
%281 = load double, double* %280
%282 = getelementptr inbounds double, double* %8, i64 %279
%283 = load double, double* %282
%284 = tail call double @llvm.fmuladd.f64(double %281, double %283, double %278)
%285 = add nuw nsw i64 %259, 4
%286 = add i64 %261, 4
%287 = icmp eq i64 %286, %248
br i1 %287, label %288, label %258
288: ; preds = %258, %244
%289 = phi double [ undef, %244 ], [ %284, %258 ]
%290 = phi i64 [ 0, %244 ], [ %285, %258 ]
%291 = phi double [ 0.000000e+00, %244 ], [ %284, %258 ]
%292 = icmp eq i64 %245, 0
br i1 %292, label %305, label %293
293: ; preds = %288, %293
%294 = phi i64 [ %302, %293 ], [ %290, %288 ]
%295 = phi double [ %301, %293 ], [ %291, %288 ]
%296 = phi i64 [ %303, %293 ], [ 0, %288 ]
%297 = getelementptr inbounds double, double* %7, i64 %294
%298 = load double, double* %297
%299 = getelementptr inbounds double, double* %8, i64 %294
%300 = load double, double* %299
%301 = tail call double @llvm.fmuladd.f64(double %298, double %300, double %295)
%302 = add nuw nsw i64 %294, 1
%303 = add i64 %296, 1
%304 = icmp eq i64 %303, %245
br i1 %304, label %305, label %293
305: ; preds = %293, %288
%306 = phi double [ %289, %288 ], [ %301, %293 ]
%307 = fmul double %306, 0x401921FB54442D18
br label %308
308: ; preds = %5, %90, %111, %305, %243
%309 = phi double [ 0.000000e+00, %243 ], [ %307, %305 ], [ 0.000000e+00, %111 ], [ 0.000000e+00, %90 ], [ 0.000000e+00, %5 ]
ret double %309
}