void compute_mean_vector(double *res, const double *X, int m, int n) {
  int i, j;
  const double *v;
  for (i = 0; i < n; i++) {
    res[i] = 0.0;
  }
  for (j = 0; j < m; j++) {
    v = X + (j * n);
    for (i = 0; i < n; i++) {
      res[i] += v[i];
    }
  }
  for (i = 0; i < n; i++) {
    res[i] /= (double)m;
  }
}


x86 assembly (clang, -O0):
<compute_mean_vector>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1143 <compute_mean_vector+0x43>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1119 <compute_mean_vector+0x19>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11c2 <compute_mean_vector+0xc2>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x18(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    11af <compute_mean_vector+0xaf>
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1176 <compute_mean_vector+0x76>
jmp    11b4 <compute_mean_vector+0xb4>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    114a <compute_mean_vector+0x4a>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    11fe <compute_mean_vector+0xfe>
cvtsi2sdl -0x14(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11c9 <compute_mean_vector+0xc9>
pop    %rbp
ret

x86 assembly (clang, -O2):
<compute_mean_vector>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %ecx,%r12d
mov    %edx,%r14d
mov    %rsi,%r13
mov    %rdi,%rbx
mov    %ecx,%ebp
test   %ecx,%ecx
jle    1142 <compute_mean_vector+0x32>
lea    0x0(,%rbp,8),%rdx
mov    %rbx,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
mov    %r14d,0xc(%rsp)
test   %r14d,%r14d
jle    1386 <compute_mean_vector+0x276>
movslq %r12d,%r10
mov    0xc(%rsp),%r9d
lea    (%rbx,%rbp,8),%rax
mov    %rax,0x30(%rsp)
mov    %ebp,%eax
and    $0xfffffffc,%eax
mov    %rax,0x28(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x20(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x18(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x10(%rsp)
mov    %ebp,%r8d
and    $0x3,%r8d
lea    0x30(%r13),%rdi
lea    0x0(,%r10,8),%rax
xor    %r14d,%r14d
mov    %r13,%r15
jmp    11c3 <compute_mean_vector+0xb3>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14
add    %rax,%rdi
add    %rax,%r15
cmp    %r9,%r14
je     1386 <compute_mean_vector+0x276>
test   %r12d,%r12d
jle    11b0 <compute_mean_vector+0xa0>
cmp    $0x4,%r12d
jb     1202 <compute_mean_vector+0xf2>
mov    %r14,%rcx
imul   %r10,%rcx
lea    0x0(,%rcx,8),%rsi
add    %r13,%rsi
add    %rbp,%rcx
lea    0x0(,%rcx,8),%rcx
add    %r13,%rcx
cmp    %rbx,%rcx
jbe    12a7 <compute_mean_vector+0x197>
cmp    0x30(%rsp),%rsi
jae    12a7 <compute_mean_vector+0x197>
xor    %esi,%esi
mov    %rsi,%rcx
not    %rcx
add    %rbp,%rcx
test   %r8,%r8
je     123a <compute_mean_vector+0x12a>
mov    %r8,%rdx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r15,%rsi,8),%xmm0
addsd  (%rbx,%rsi,8),%xmm0
movsd  %xmm0,(%rbx,%rsi,8)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdx
jne    1220 <compute_mean_vector+0x110>
cmp    $0x3,%rcx
jb     11b0 <compute_mean_vector+0xa0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r15,%rsi,8),%xmm0
addsd  (%rbx,%rsi,8),%xmm0
movsd  %xmm0,(%rbx,%rsi,8)
movsd  0x8(%r15,%rsi,8),%xmm0
addsd  0x8(%rbx,%rsi,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rsi,8)
movsd  0x10(%r15,%rsi,8),%xmm0
addsd  0x10(%rbx,%rsi,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rsi,8)
movsd  0x18(%r15,%rsi,8),%xmm0
addsd  0x18(%rbx,%rsi,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rbp
jne    1250 <compute_mean_vector+0x140>
jmp    11b0 <compute_mean_vector+0xa0>
mov    %r10,%rcx
cmpq   $0x0,0x20(%rsp)
je     137a <compute_mean_vector+0x26a>
mov    0x10(%rsp),%r11
xor    %r10d,%r10d
xchg   %ax,%ax
movupd -0x30(%rdi,%r10,8),%xmm0
movupd -0x20(%rdi,%r10,8),%xmm1
movupd (%rbx,%r10,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rbx,%r10,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x20(%rbx,%r10,8),%xmm1
movupd 0x30(%rbx,%r10,8),%xmm3
movupd %xmm2,(%rbx,%r10,8)
movupd %xmm0,0x10(%rbx,%r10,8)
movupd -0x10(%rdi,%r10,8),%xmm0
addpd  %xmm1,%xmm0
movupd (%rdi,%r10,8),%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,0x20(%rbx,%r10,8)
movupd %xmm1,0x30(%rbx,%r10,8)
add    $0x8,%r10
add    $0xfffffffffffffffe,%r11
jne    12c0 <compute_mean_vector+0x1b0>
testb  $0x1,0x18(%rsp)
je     1361 <compute_mean_vector+0x251>
movupd (%rsi,%r10,8),%xmm0
movupd 0x10(%rsi,%r10,8),%xmm1
movupd (%rbx,%r10,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rbx,%r10,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rbx,%r10,8)
movupd %xmm0,0x10(%rbx,%r10,8)
mov    0x28(%rsp),%rdx
mov    %rdx,%rsi
cmp    %rbp,%rdx
mov    %rcx,%r10
je     11b0 <compute_mean_vector+0xa0>
jmp    1204 <compute_mean_vector+0xf4>
xor    %r10d,%r10d
testb  $0x1,0x18(%rsp)
jne    1332 <compute_mean_vector+0x222>
jmp    1361 <compute_mean_vector+0x251>
test   %r12d,%r12d
jle    1427 <compute_mean_vector+0x317>
xorps  %xmm0,%xmm0
cvtsi2sdl 0xc(%rsp),%xmm0
cmp    $0x1,%r12d
jne    13a2 <compute_mean_vector+0x292>
xor    %eax,%eax
jmp    1410 <compute_mean_vector+0x300>
mov    %ebp,%eax
and    $0xfffffffe,%eax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x2(%rax),%rdx
mov    %rdx,%rcx
shr    %rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     1436 <compute_mean_vector+0x326>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movupd (%rbx,%rdx,8),%xmm2
movupd 0x10(%rbx,%rdx,8),%xmm3
divpd  %xmm1,%xmm2
movupd %xmm2,(%rbx,%rdx,8)
divpd  %xmm1,%xmm3
movupd %xmm3,0x10(%rbx,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rsi
jne    13d0 <compute_mean_vector+0x2c0>
test   $0x1,%cl
je     140b <compute_mean_vector+0x2fb>
movupd (%rbx,%rdx,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rbx,%rdx,8)
cmp    %rbp,%rax
je     1427 <compute_mean_vector+0x317>
movsd  (%rbx,%rax,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbp
jne    1410 <compute_mean_vector+0x300>
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%cl
jne    13fd <compute_mean_vector+0x2ed>
jmp    140b <compute_mean_vector+0x2fb>

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

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