void refinemesh(node_dim, arr, vector) int vector, node_dim[];
double arr[];
{
  int i, j;
  i = node_dim[vector];
  while ((i > 0) && (1 + node_dim[vector] < 50)) {
    if ((arr[i] - arr[i - 1]) > 7.5) {
      ++node_dim[vector];
      for (j = node_dim[vector]; j > i; --j)
        arr[j] = arr[j - 1];
      arr[i] = 0.5 * (arr[i + 1] - arr[i - 1]) + arr[i - 1];
      i += 2;
    }
    --i;
  }
}


x86 assembly (clang, -O0):
<refinemesh>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x18(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x18(%rbp)
mov    %al,-0x1d(%rbp)
jle    1143 <refinemesh+0x43>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    $0x1,%eax
cmp    $0x32,%eax
setl   %al
mov    %al,-0x1d(%rbp)
mov    -0x1d(%rbp),%al
test   $0x1,%al
jne    1153 <refinemesh+0x53>
jmp    1246 <refinemesh+0x146>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  0xe86(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1238 <refinemesh+0x138>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jle    11dc <refinemesh+0xdc>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    11a3 <refinemesh+0xa3>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xdee(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    111d <refinemesh+0x1d>
pop    %rbp
ret

x86 assembly (clang, -O2):
<refinemesh>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
movslq %edx,%r8
mov    (%rdi,%r8,4),%r11d
test   %r11d,%r11d
jle    13ce <refinemesh+0x2ce>
lea    0x8(%rsi),%rax
mov    %rax,-0x8(%rsp)
lea    -0x8(%rsi),%rax
mov    %rax,-0x10(%rsp)
movsd  0xecc(%rip),%xmm0
movsd  0xecc(%rip),%xmm1
mov    %r11d,%ebx
mov    %r8,-0x30(%rsp)
jmp    1184 <refinemesh+0x84>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rsi,%r15,8),%xmm2
lea    0x1(%rbx),%r15d
movsd  0x8(%rsi,%rcx,8),%xmm3
subsd  %xmm2,%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%rsi,%r12,8)
add    $0x2,%ebx
mov    %r13d,%r11d
cmp    $0x1,%ebx
mov    %r15d,%ebx
jle    13ce <refinemesh+0x2ce>
cmp    $0x30,%r11d
jg     13ce <refinemesh+0x2ce>
mov    %ebx,%r12d
movsd  (%rsi,%r12,8),%xmm3
lea    -0x1(%rbx),%r15d
movsd  (%rsi,%r15,8),%xmm2
subsd  %xmm2,%xmm3
ucomisd %xmm0,%xmm3
jbe    1178 <refinemesh+0x78>
lea    0x1(%r11),%r13d
mov    %r13d,(%rdi,%r8,4)
movslq %ebx,%rcx
cmp    %ebx,%r11d
jl     1156 <refinemesh+0x56>
movslq %r13d,%r14
lea    -0x1(%r14),%r9
cmp    %rcx,%r9
mov    %rcx,%rax
cmovl  %r9,%rax
mov    %r14,%r10
sub    %rax,%r10
cmp    $0x4,%r10
jb     13b0 <refinemesh+0x2b0>
cmp    %rcx,%r9
mov    %rcx,%rbp
cmovl  %r9,%rbp
not    %rbp
add    %r14,%rbp
mov    %rbp,%rax
mov    $0x8,%edx
mul    %rdx
seto   %r8b
cmp    %ebp,%r11d
jb     1393 <refinemesh+0x293>
shr    $0x20,%rbp
jne    139a <refinemesh+0x29a>
lea    (%rsi,%r14,8),%rdx
mov    %rdx,%rbp
sub    %rax,%rbp
cmp    %rdx,%rbp
ja     13a1 <refinemesh+0x2a1>
test   %r8b,%r8b
jne    13a8 <refinemesh+0x2a8>
mov    %r11d,%r11d
lea    (%rsi,%r11,8),%rbp
mov    %rbp,%rdx
sub    %rax,%rdx
cmp    %rbp,%rdx
ja     1343 <refinemesh+0x243>
test   %r8b,%r8b
jne    134a <refinemesh+0x24a>
cmp    %rcx,%r9
cmovge %rcx,%r9
mov    -0x8(%rsp),%rbp
lea    0x0(,%r9,8),%rax
add    %rbp,%rax
lea    0x0(,%r11,8),%rdx
add    %rbp,%rdx
cmp    %rdx,%rax
jae    129b <refinemesh+0x19b>
lea    0x0(,%r14,8),%rax
add    %rbp,%rax
add    %r11,%r9
sub    %r14,%r9
lea    0x0(,%r9,8),%rdx
add    %rbp,%rdx
cmp    %rax,%rdx
jae    129b <refinemesh+0x19b>
mov    -0x30(%rsp),%r8
jmp    13b0 <refinemesh+0x2b0>
mov    %r10,%rax
and    $0xfffffffffffffffc,%rax
lea    -0x4(%rax),%rbp
mov    %rbp,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rbp,%rbp
je     1351 <refinemesh+0x251>
mov    %rax,-0x20(%rsp)
mov    %rdi,-0x18(%rsp)
mov    %rdx,-0x28(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    -0x10(%rsp),%rax
lea    (%rax,%r14,8),%rax
mov    $0xffffffff,%edi
lea    (%r14,%rdi,1),%r9
add    $0xfffffffffffffffc,%r9
lea    (%r14,%rdi,1),%r8
xor    %ebp,%ebp
nopl   0x0(%rax)
lea    (%r8,%rbp,1),%r11d
movups -0x18(%rsi,%r11,8),%xmm2
movups -0x8(%rsi,%r11,8),%xmm3
movups %xmm3,(%rax,%rbp,8)
movups %xmm2,-0x10(%rax,%rbp,8)
lea    (%r9,%rbp,1),%edi
movupd -0x18(%rsi,%rdi,8),%xmm2
movupd -0x8(%rsi,%rdi,8),%xmm3
movupd %xmm3,-0x20(%rax,%rbp,8)
movupd %xmm2,-0x30(%rax,%rbp,8)
add    $0xfffffffffffffff8,%rbp
add    $0xfffffffffffffffe,%rdx
jne    12f0 <refinemesh+0x1f0>
neg    %rbp
mov    -0x18(%rsp),%rdi
mov    -0x20(%rsp),%rax
mov    -0x28(%rsp),%rdx
jmp    1353 <refinemesh+0x253>
mov    -0x30(%rsp),%r8
jmp    13b0 <refinemesh+0x2b0>
mov    -0x30(%rsp),%r8
jmp    13b0 <refinemesh+0x2b0>
xor    %ebp,%ebp
test   $0x1,%dl
mov    -0x30(%rsp),%r8
je     1385 <refinemesh+0x285>
mov    %r14,%r9
sub    %rbp,%r9
mov    $0xffffffff,%edx
add    %r9d,%edx
movupd -0x18(%rsi,%rdx,8),%xmm2
movupd -0x8(%rsi,%rdx,8),%xmm3
movupd %xmm3,-0x8(%rsi,%r9,8)
movupd %xmm2,-0x18(%rsi,%r9,8)
cmp    %rax,%r10
je     1150 <refinemesh+0x50>
sub    %rax,%r14
jmp    13b0 <refinemesh+0x2b0>
mov    -0x30(%rsp),%r8
jmp    13b0 <refinemesh+0x2b0>
mov    -0x30(%rsp),%r8
jmp    13b0 <refinemesh+0x2b0>
mov    -0x30(%rsp),%r8
jmp    13b0 <refinemesh+0x2b0>
mov    -0x30(%rsp),%r8
nopl   (%rax)
lea    -0x1(%r14),%rax
mov    %eax,%edx
movsd  (%rsi,%rdx,8),%xmm2
movsd  %xmm2,(%rsi,%r14,8)
mov    %rax,%r14
cmp    %rcx,%rax
jg     13b0 <refinemesh+0x2b0>
jmp    1150 <refinemesh+0x50>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @refinemesh(i32* %0, double* %1, i32 %2) {
%4 = alloca i32*
%5 = alloca double*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
store i32* %0, i32** %4
store double* %1, double** %5
store i32 %2, i32* %6
%9 = load i32*, i32** %4
%10 = load i32, i32* %6
%11 = sext i32 %10 to i64
%12 = getelementptr inbounds i32, i32* %9, i64 %11
%13 = load i32, i32* %12
store i32 %13, i32* %7
br label %14
14: ; preds = %98, %3
%15 = load i32, i32* %7
%16 = icmp sgt i32 %15, 0
br i1 %16, label %17, label %25
17: ; preds = %14
%18 = load i32*, i32** %4
%19 = load i32, i32* %6
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds i32, i32* %18, i64 %20
%22 = load i32, i32* %21
%23 = add nsw i32 1, %22
%24 = icmp slt i32 %23, 50
br label %25
25: ; preds = %17, %14
%26 = phi i1 [ false, %14 ], [ %24, %17 ]
br i1 %26, label %27, label %101
27: ; preds = %25
%28 = load double*, double** %5
%29 = load i32, i32* %7
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds double, double* %28, i64 %30
%32 = load double, double* %31
%33 = load double*, double** %5
%34 = load i32, i32* %7
%35 = sub nsw i32 %34, 1
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds double, double* %33, i64 %36
%38 = load double, double* %37
%39 = fsub double %32, %38
%40 = fcmp ogt double %39, 7.500000e+00
br i1 %40, label %41, label %98
41: ; preds = %27
%42 = load i32*, i32** %4
%43 = load i32, i32* %6
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds i32, i32* %42, i64 %44
%46 = load i32, i32* %45
%47 = add nsw i32 %46, 1
store i32 %47, i32* %45
%48 = load i32*, i32** %4
%49 = load i32, i32* %6
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds i32, i32* %48, i64 %50
%52 = load i32, i32* %51
store i32 %52, i32* %8
br label %53
53: ; preds = %68, %41
%54 = load i32, i32* %8
%55 = load i32, i32* %7
%56 = icmp sgt i32 %54, %55
br i1 %56, label %57, label %71
57: ; preds = %53
%58 = load double*, double** %5
%59 = load i32, i32* %8
%60 = sub nsw i32 %59, 1
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds double, double* %58, i64 %61
%63 = load double, double* %62
%64 = load double*, double** %5
%65 = load i32, i32* %8
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds double, double* %64, i64 %66
store double %63, double* %67
br label %68
68: ; preds = %57
%69 = load i32, i32* %8
%70 = add nsw i32 %69, -1
store i32 %70, i32* %8
br label %53
71: ; preds = %53
%72 = load double*, double** %5
%73 = load i32, i32* %7
%74 = add nsw i32 %73, 1
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds double, double* %72, i64 %75
%77 = load double, double* %76
%78 = load double*, double** %5
%79 = load i32, i32* %7
%80 = sub nsw i32 %79, 1
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds double, double* %78, i64 %81
%83 = load double, double* %82
%84 = fsub double %77, %83
%85 = load double*, double** %5
%86 = load i32, i32* %7
%87 = sub nsw i32 %86, 1
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds double, double* %85, i64 %88
%90 = load double, double* %89
%91 = call double @llvm.fmuladd.f64(double 5.000000e-01, double %84, double %90)
%92 = load double*, double** %5
%93 = load i32, i32* %7
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds double, double* %92, i64 %94
store double %91, double* %95
%96 = load i32, i32* %7
%97 = add nsw i32 %96, 2
store i32 %97, i32* %7
br label %98
98: ; preds = %71, %27
%99 = load i32, i32* %7
%100 = add nsw i32 %99, -1
store i32 %100, i32* %7
br label %14
101: ; preds = %25
ret void
}

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