#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 */
typedef int int16_t;

/* Variables and functions */
double exp(double);
void weightExpPartial(const int16_t ns, const int16_t nc, const int16_t dims,
                      const int16_t *restrict tcounts,
                      const int16_t *restrict fcounts,
                      const double *restrict weights,
                      const double *restrict dir, double *restrict tprob,
                      double *restrict tvec, double *restrict fprob,
                      double *restrict fvec) {
  for (int t = 0; t < ns * nc; ++t) {
    double lp = 0;
    double v = 0;
    for (int i = 0; i < dims; ++i) {
      lp += tcounts[t * dims + i] * weights[i];
      v += tcounts[t * dims + i] * dir[i];
    }
    double p = exp(-lp);
    tprob[t] = p;
    tvec[t] = p * v;
  }
  for (int t = 0; t < ns; ++t) {
    double lp = 0;
    double v = 0;
    for (int i = 0; i < dims; ++i) {
      lp += fcounts[t * dims + i] * weights[i];
      v += fcounts[t * dims + i] * dir[i];
    }
    double p = exp(-lp);
    fprob[t] = p;
    fvec[t] = p * v;
  }
}


x86 assembly (clang, -O0):
<weightExpPartial>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x8(%rbp),%ecx
cmp    %ecx,%eax
jge    1255 <weightExpPartial+0x145>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11f8 <weightExpPartial+0xe8>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1174 <weightExpPartial+0x64>
movsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
mov    0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    114b <weightExpPartial+0x3b>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1360 <weightExpPartial+0x250>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1303 <weightExpPartial+0x1f3>
mov    -0x20(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    127f <weightExpPartial+0x16f>
movsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
call   1030 <exp@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
mov    0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
mov    0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    125c <weightExpPartial+0x14c>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<weightExpPartial>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r9,%rbx
mov    %r8,0x38(%rsp)
mov    %rcx,0x30(%rsp)
mov    %edx,%r13d
mov    0x90(%rsp),%r12
mov    %edi,0x2c(%rsp)
imul   %edi,%esi
movslq %edx,%rax
mov    %rax,0x8(%rsp)
mov    %edx,%eax
mov    %rax,0x10(%rsp)
test   %esi,%esi
jle    12b4 <weightExpPartial+0x1a4>
mov    %esi,%eax
mov    %rax,0x20(%rsp)
mov    0x10(%rsp),%r15
and    $0xfffffffe,%r15d
mov    0x30(%rsp),%rax
lea    0x4(%rax),%r14
mov    0x8(%rsp),%rax
lea    0x0(,%rax,4),%rax
mov    %rax,0x18(%rsp)
xor    %ebp,%ebp
jmp    11e7 <weightExpPartial+0xd7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorpd  %xmm3,%xmm3
movapd %xmm3,0x40(%rsp)
movapd %xmm3,%xmm0
xorpd  0xe5a(%rip),%xmm0
call   1030 <exp@plt>
mov    0x98(%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
movapd 0x40(%rsp),%xmm1
unpckhpd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
mov    0xa0(%rsp),%rax
movsd  %xmm1,(%rax,%rbp,8)
add    $0x1,%rbp
add    0x18(%rsp),%r14
cmp    0x20(%rsp),%rbp
je     12b4 <weightExpPartial+0x1a4>
test   %r13d,%r13d
jle    1190 <weightExpPartial+0x80>
xorpd  %xmm0,%xmm0
cmp    $0x1,%r13d
jne    1210 <weightExpPartial+0x100>
xor    %eax,%eax
testb  $0x1,0x10(%rsp)
je     1194 <weightExpPartial+0x84>
jmp    127f <weightExpPartial+0x16f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorps  %xmm2,%xmm2
cvtsi2sdl -0x4(%r14,%rax,4),%xmm2
unpcklpd %xmm2,%xmm2
movsd  (%rbx,%rax,8),%xmm1
movhpd (%r12,%rax,8),%xmm1
movsd  0x8(%rbx,%rax,8),%xmm3
mulpd  %xmm2,%xmm1
xorps  %xmm2,%xmm2
cvtsi2sdl (%r14,%rax,4),%xmm2
addpd  %xmm0,%xmm1
unpcklpd %xmm2,%xmm2
movhpd 0x8(%r12,%rax,8),%xmm3
mulpd  %xmm2,%xmm3
movapd %xmm3,%xmm0
addpd  %xmm1,%xmm0
add    $0x2,%rax
cmp    %rax,%r15
jne    1220 <weightExpPartial+0x110>
addpd  %xmm1,%xmm3
testb  $0x1,0x10(%rsp)
je     1194 <weightExpPartial+0x84>
mov    %rbp,%rcx
imul   0x8(%rsp),%rcx
add    %rax,%rcx
mov    0x30(%rsp),%rdx
xorps  %xmm1,%xmm1
cvtsi2sdl (%rdx,%rcx,4),%xmm1
unpcklpd %xmm1,%xmm1
movsd  (%rbx,%rax,8),%xmm3
movhpd (%r12,%rax,8),%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm0,%xmm3
jmp    1194 <weightExpPartial+0x84>
mov    0x2c(%rsp),%eax
test   %eax,%eax
jle    1413 <weightExpPartial+0x303>
mov    %eax,%eax
mov    %rax,0x20(%rsp)
mov    0x10(%rsp),%r14
and    $0xfffffffe,%r14d
mov    0x38(%rsp),%rax
lea    0x4(%rax),%rbp
mov    0x8(%rsp),%rax
lea    0x0(,%rax,4),%rax
mov    %rax,0x18(%rsp)
xor    %r15d,%r15d
jmp    1349 <weightExpPartial+0x239>
xorpd  %xmm3,%xmm3
movapd %xmm3,0x40(%rsp)
movapd %xmm3,%xmm0
xorpd  0xcfa(%rip),%xmm0
call   1030 <exp@plt>
mov    0xa8(%rsp),%rax
movsd  %xmm0,(%rax,%r15,8)
movapd 0x40(%rsp),%xmm1
unpckhpd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
mov    0xb0(%rsp),%rax
movsd  %xmm1,(%rax,%r15,8)
add    $0x1,%r15
add    0x18(%rsp),%rbp
cmp    0x20(%rsp),%r15
je     1413 <weightExpPartial+0x303>
test   %r13d,%r13d
jle    12f0 <weightExpPartial+0x1e0>
xorpd  %xmm0,%xmm0
cmp    $0x1,%r13d
jne    1370 <weightExpPartial+0x260>
xor    %eax,%eax
testb  $0x1,0x10(%rsp)
je     12f4 <weightExpPartial+0x1e4>
jmp    13de <weightExpPartial+0x2ce>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorps  %xmm2,%xmm2
cvtsi2sdl -0x4(%rbp,%rax,4),%xmm2
unpcklpd %xmm2,%xmm2
movsd  (%rbx,%rax,8),%xmm1
movhpd (%r12,%rax,8),%xmm1
movsd  0x8(%rbx,%rax,8),%xmm3
mulpd  %xmm2,%xmm1
xorps  %xmm2,%xmm2
cvtsi2sdl 0x0(%rbp,%rax,4),%xmm2
addpd  %xmm0,%xmm1
unpcklpd %xmm2,%xmm2
movhpd 0x8(%r12,%rax,8),%xmm3
mulpd  %xmm2,%xmm3
movapd %xmm3,%xmm0
addpd  %xmm1,%xmm0
add    $0x2,%rax
cmp    %rax,%r14
jne    1380 <weightExpPartial+0x270>
addpd  %xmm1,%xmm3
testb  $0x1,0x10(%rsp)
je     12f4 <weightExpPartial+0x1e4>
mov    %r15,%rcx
imul   0x8(%rsp),%rcx
add    %rax,%rcx
mov    0x38(%rsp),%rdx
xorps  %xmm1,%xmm1
cvtsi2sdl (%rdx,%rcx,4),%xmm1
unpcklpd %xmm1,%xmm1
movsd  (%rbx,%rax,8),%xmm3
movhpd (%r12,%rax,8),%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm0,%xmm3
jmp    12f4 <weightExpPartial+0x1e4>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @weightExpPartial(i32 %0, i32 %1, i32 %2, i32* noalias %3, i32* noalias %4, double* noalias %5, double* noalias %6, double* noalias %7, double* noalias %8, double* noalias %9, double* noalias %10) {
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32*
%16 = alloca i32*
%17 = alloca double*
%18 = alloca double*
%19 = alloca double*
%20 = alloca double*
%21 = alloca double*
%22 = alloca double*
%23 = alloca i32
%24 = alloca double
%25 = alloca double
%26 = alloca i32
%27 = alloca double
%28 = alloca i32
%29 = alloca double
%30 = alloca double
%31 = alloca i32
%32 = alloca double
store i32 %0, i32* %12
store i32 %1, i32* %13
store i32 %2, i32* %14
store i32* %3, i32** %15
store i32* %4, i32** %16
store double* %5, double** %17
store double* %6, double** %18
store double* %7, double** %19
store double* %8, double** %20
store double* %9, double** %21
store double* %10, double** %22
store i32 0, i32* %23
br label %33
33: ; preds = %98, %11
%34 = load i32, i32* %23
%35 = load i32, i32* %12
%36 = load i32, i32* %13
%37 = mul nsw i32 %35, %36
%38 = icmp slt i32 %34, %37
br i1 %38, label %39, label %101
39: ; preds = %33
store double 0.000000e+00, double* %24
store double 0.000000e+00, double* %25
store i32 0, i32* %26
br label %40
40: ; preds = %79, %39
%41 = load i32, i32* %26
%42 = load i32, i32* %14
%43 = icmp slt i32 %41, %42
br i1 %43, label %44, label %82
44: ; preds = %40
%45 = load i32*, i32** %15
%46 = load i32, i32* %23
%47 = load i32, i32* %14
%48 = mul nsw i32 %46, %47
%49 = load i32, i32* %26
%50 = add nsw i32 %48, %49
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds i32, i32* %45, i64 %51
%53 = load i32, i32* %52
%54 = sitofp i32 %53 to double
%55 = load double*, double** %17
%56 = load i32, i32* %26
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds double, double* %55, i64 %57
%59 = load double, double* %58
%60 = load double, double* %24
%61 = call double @llvm.fmuladd.f64(double %54, double %59, double %60)
store double %61, double* %24
%62 = load i32*, i32** %15
%63 = load i32, i32* %23
%64 = load i32, i32* %14
%65 = mul nsw i32 %63, %64
%66 = load i32, i32* %26
%67 = add nsw i32 %65, %66
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds i32, i32* %62, i64 %68
%70 = load i32, i32* %69
%71 = sitofp i32 %70 to double
%72 = load double*, double** %18
%73 = load i32, i32* %26
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds double, double* %72, i64 %74
%76 = load double, double* %75
%77 = load double, double* %25
%78 = call double @llvm.fmuladd.f64(double %71, double %76, double %77)
store double %78, double* %25
br label %79
79: ; preds = %44
%80 = load i32, i32* %26
%81 = add nsw i32 %80, 1
store i32 %81, i32* %26
br label %40
82: ; preds = %40
%83 = load double, double* %24
%84 = fneg double %83
%85 = call double @exp(double %84)
store double %85, double* %27
%86 = load double, double* %27
%87 = load double*, double** %19
%88 = load i32, i32* %23
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds double, double* %87, i64 %89
store double %86, double* %90
%91 = load double, double* %27
%92 = load double, double* %25
%93 = fmul double %91, %92
%94 = load double*, double** %20
%95 = load i32, i32* %23
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds double, double* %94, i64 %96
store double %93, double* %97
br label %98
98: ; preds = %82
%99 = load i32, i32* %23
%100 = add nsw i32 %99, 1
store i32 %100, i32* %23
br label %33
101: ; preds = %33
store i32 0, i32* %28
br label %102
102: ; preds = %165, %101
%103 = load i32, i32* %28
%104 = load i32, i32* %12
%105 = icmp slt i32 %103, %104
br i1 %105, label %106, label %168
106: ; preds = %102
store double 0.000000e+00, double* %29
store double 0.000000e+00, double* %30
store i32 0, i32* %31
br label %107
107: ; preds = %146, %106
%108 = load i32, i32* %31
%109 = load i32, i32* %14
%110 = icmp slt i32 %108, %109
br i1 %110, label %111, label %149
111: ; preds = %107
%112 = load i32*, i32** %16
%113 = load i32, i32* %28
%114 = load i32, i32* %14
%115 = mul nsw i32 %113, %114
%116 = load i32, i32* %31
%117 = add nsw i32 %115, %116
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds i32, i32* %112, i64 %118
%120 = load i32, i32* %119
%121 = sitofp i32 %120 to double
%122 = load double*, double** %17
%123 = load i32, i32* %31
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds double, double* %122, i64 %124
%126 = load double, double* %125
%127 = load double, double* %29
%128 = call double @llvm.fmuladd.f64(double %121, double %126, double %127)
store double %128, double* %29
%129 = load i32*, i32** %16
%130 = load i32, i32* %28
%131 = load i32, i32* %14
%132 = mul nsw i32 %130, %131
%133 = load i32, i32* %31
%134 = add nsw i32 %132, %133
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds i32, i32* %129, i64 %135
%137 = load i32, i32* %136
%138 = sitofp i32 %137 to double
%139 = load double*, double** %18
%140 = load i32, i32* %31
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds double, double* %139, i64 %141
%143 = load double, double* %142
%144 = load double, double* %30
%145 = call double @llvm.fmuladd.f64(double %138, double %143, double %144)
store double %145, double* %30
br label %146
146: ; preds = %111
%147 = load i32, i32* %31
%148 = add nsw i32 %147, 1
store i32 %148, i32* %31
br label %107
149: ; preds = %107
%150 = load double, double* %29
%151 = fneg double %150
%152 = call double @exp(double %151)
store double %152, double* %32
%153 = load double, double* %32
%154 = load double*, double** %21
%155 = load i32, i32* %28
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds double, double* %154, i64 %156
store double %153, double* %157
%158 = load double, double* %32
%159 = load double, double* %30
%160 = fmul double %158, %159
%161 = load double*, double** %22
%162 = load i32, i32* %28
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds double, double* %161, i64 %163
store double %160, double* %164
br label %165
165: ; preds = %149
%166 = load i32, i32* %28
%167 = add nsw i32 %166, 1
store i32 %167, i32* %28
br label %102
168: ; preds = %102
ret void
}

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