int getFilteredPos(double *x, double *y, double *z, double *Apos, double *Hpos,
                   int *typeNs, double rCutSqr, int Ihpos, int Itype) {
  int shiftType = 0;
  int count = 0;
  double X = 0;
  double Y = 0;
  double Z = 0;
  for (int i = 0; i < Itype; i++) {
    shiftType += typeNs[i];
  }
  for (int i = 0; i < typeNs[Itype]; i++) {
    X = Apos[3 * shiftType + 3 * i] - Hpos[3 * Ihpos];
    Y = Apos[3 * shiftType + 3 * i + 1] - Hpos[3 * Ihpos + 1];
    Z = Apos[3 * shiftType + 3 * i + 2] - Hpos[3 * Ihpos + 2];
    if (X * X + Y * Y + Z * Z < rCutSqr) {
      x[count] = X;
      y[count] = Y;
      z[count] = Z;
      count++;
    }
  }
  return count;
}


x86 assembly (clang, -O0):
<getFilteredPos>:
push   %rbp
mov    %rsp,%rbp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    117f <getFilteredPos+0x7f>
mov    -0x30(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1154 <getFilteredPos+0x54>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x30(%rbp),%rcx
movslq 0x18(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    12b6 <getFilteredPos+0x1b6>
mov    -0x20(%rbp),%rax
imul   $0x3,-0x3c(%rbp),%ecx
imul   $0x3,-0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
imul   $0x3,0x10(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
imul   $0x3,-0x3c(%rbp),%ecx
imul   $0x3,-0x60(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
imul   $0x3,0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
imul   $0x3,-0x3c(%rbp),%ecx
imul   $0x3,-0x60(%rbp),%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
imul   $0x3,0x10(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x58(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    12a3 <getFilteredPos+0x1a3>
movsd  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    12a8 <getFilteredPos+0x1a8>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1186 <getFilteredPos+0x86>
mov    -0x40(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<getFilteredPos>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    0x38(%rsp),%r10d
xor    %eax,%eax
mov    $0x0,%ebp
test   %r10d,%r10d
jle    123d <getFilteredPos+0x13d>
mov    %r10d,%r11d
cmp    $0x8,%r10d
jae    1130 <getFilteredPos+0x30>
xor    %r15d,%r15d
xor    %ebp,%ebp
jmp    1230 <getFilteredPos+0x130>
mov    %r11d,%r15d
and    $0xfffffff8,%r15d
lea    -0x8(%r15),%rbx
mov    %rbx,%r12
shr    $0x3,%r12
add    $0x1,%r12
mov    %r12d,%r14d
and    $0x3,%r14d
cmp    $0x18,%rbx
jae    115f <getFilteredPos+0x5f>
pxor   %xmm1,%xmm1
xor    %ebx,%ebx
pxor   %xmm2,%xmm2
jmp    11d1 <getFilteredPos+0xd1>
and    $0xfffffffffffffffc,%r12
pxor   %xmm1,%xmm1
xor    %ebx,%ebx
pxor   %xmm2,%xmm2
nopl   (%rax)
movdqu (%r9,%rbx,4),%xmm3
paddd  %xmm1,%xmm3
movdqu 0x10(%r9,%rbx,4),%xmm1
paddd  %xmm2,%xmm1
movdqu 0x20(%r9,%rbx,4),%xmm2
movdqu 0x30(%r9,%rbx,4),%xmm4
movdqu 0x40(%r9,%rbx,4),%xmm5
paddd  %xmm2,%xmm5
paddd  %xmm3,%xmm5
movdqu 0x50(%r9,%rbx,4),%xmm3
paddd  %xmm4,%xmm3
paddd  %xmm1,%xmm3
movdqu 0x60(%r9,%rbx,4),%xmm1
paddd  %xmm5,%xmm1
movdqu 0x70(%r9,%rbx,4),%xmm2
paddd  %xmm3,%xmm2
add    $0x20,%rbx
add    $0xfffffffffffffffc,%r12
jne    1170 <getFilteredPos+0x70>
test   %r14,%r14
je     120c <getFilteredPos+0x10c>
lea    (%r9,%rbx,4),%rbx
add    $0x10,%rbx
shl    $0x5,%r14
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu -0x10(%rbx,%rbp,1),%xmm3
paddd  %xmm3,%xmm1
movdqu (%rbx,%rbp,1),%xmm3
paddd  %xmm3,%xmm2
add    $0x20,%rbp
cmp    %rbp,%r14
jne    11f0 <getFilteredPos+0xf0>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm2
paddd  %xmm1,%xmm2
pshufd $0x55,%xmm2,%xmm1
paddd  %xmm2,%xmm1
movd   %xmm1,%ebp
cmp    %r11,%r15
je     123d <getFilteredPos+0x13d>
nopl   0x0(%rax,%rax,1)
add    (%r9,%r15,4),%ebp
add    $0x1,%r15
cmp    %r15,%r11
jne    1230 <getFilteredPos+0x130>
movslq %r10d,%rbx
mov    (%r9,%rbx,4),%r14d
test   %r14d,%r14d
jle    12f6 <getFilteredPos+0x1f6>
mov    0x30(%rsp),%r11d
lea    (%r11,%r11,2),%eax
movslq %eax,%r9
lea    (%r11,%r11,2),%eax
add    $0x1,%eax
movslq %eax,%r10
lea    (%r11,%r11,2),%eax
add    $0x2,%eax
movslq %eax,%r11
lea    0x0(%rbp,%rbp,2),%r15d
xor    %eax,%eax
jmp    128a <getFilteredPos+0x18a>
cs nopw 0x0(%rax,%rax,1)
add    $0x3,%r15d
add    $0xffffffffffffffff,%r14
je     12f6 <getFilteredPos+0x1f6>
movslq %r15d,%rbx
movsd  (%rcx,%rbx,8),%xmm1
subsd  (%r8,%r9,8),%xmm1
lea    0x1(%rbx),%ebp
movslq %ebp,%rbp
movsd  (%rcx,%rbp,8),%xmm2
subsd  (%r8,%r10,8),%xmm2
add    $0x2,%ebx
movslq %ebx,%rbx
movsd  (%rcx,%rbx,8),%xmm3
subsd  (%r8,%r11,8),%xmm3
movapd %xmm2,%xmm4
mulsd  %xmm2,%xmm4
movapd %xmm1,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
movapd %xmm3,%xmm4
mulsd  %xmm3,%xmm4
addsd  %xmm5,%xmm4
ucomisd %xmm4,%xmm0
jbe    1280 <getFilteredPos+0x180>
cltq
movsd  %xmm1,(%rdi,%rax,8)
movsd  %xmm2,(%rsi,%rax,8)
movsd  %xmm3,(%rdx,%rax,8)
add    $0x1,%eax
jmp    1280 <getFilteredPos+0x180>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

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