void bspline_coeff_derivative(unsigned int n, unsigned int p, double t2[n - 1],
                              double v2[n - p - 1], const double t[n + 1],
                              const double v[n - p]) {
  for (unsigned int i = 1; i < n; i++)
    t2[i - 1] = t[i];
  for (unsigned int i = 0; i < n - p - 1; i++)
    v2[i] = (float)p / (t[i + p + 1] - t[i + 1]) * (v[i + 1] - v[i]);
}


x86 assembly (clang, -O0):
<bspline_coeff_derivative>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    1158 <bspline_coeff_derivative+0x58>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1121 <bspline_coeff_derivative+0x21>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jae    11e3 <bspline_coeff_derivative+0xe3>
mov    -0x8(%rbp),%eax
cvtsi2ss %rax,%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x8(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    115f <bspline_coeff_derivative+0x5f>
pop    %rbp
ret

x86 assembly (clang, -O2):
<bspline_coeff_derivative>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %esi,%r10d
not    %r10d
add    %edi,%r10d
cmp    $0x2,%edi
jb     129b <bspline_coeff_derivative+0x19b>
mov    %edi,%r14d
lea    -0x1(%r14),%r11
mov    $0x1,%eax
cmp    $0x4,%r11
jb     1223 <bspline_coeff_derivative+0x123>
lea    (%r8,%r14,8),%rdi
cmp    %rdx,%rdi
jbe    114e <bspline_coeff_derivative+0x4e>
lea    (%rdx,%r14,8),%rdi
add    $0xfffffffffffffff8,%rdi
lea    0x8(%r8),%rbx
cmp    %rdi,%rbx
jb     1223 <bspline_coeff_derivative+0x123>
mov    %r11,%rax
and    $0xfffffffffffffffc,%rax
lea    -0x4(%rax),%rdi
mov    %rdi,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
mov    %ebx,%r15d
and    $0x3,%r15d
cmp    $0xc,%rdi
jae    1175 <bspline_coeff_derivative+0x75>
xor    %edi,%edi
jmp    11e1 <bspline_coeff_derivative+0xe1>
and    $0xfffffffffffffffc,%rbx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups 0x8(%r8,%rdi,8),%xmm0
movups 0x18(%r8,%rdi,8),%xmm1
movups %xmm0,(%rdx,%rdi,8)
movups %xmm1,0x10(%rdx,%rdi,8)
movups 0x28(%r8,%rdi,8),%xmm0
movups 0x38(%r8,%rdi,8),%xmm1
movups %xmm0,0x20(%rdx,%rdi,8)
movups %xmm1,0x30(%rdx,%rdi,8)
movups 0x48(%r8,%rdi,8),%xmm0
movups 0x58(%r8,%rdi,8),%xmm1
movups %xmm0,0x40(%rdx,%rdi,8)
movups %xmm1,0x50(%rdx,%rdi,8)
movups 0x68(%r8,%rdi,8),%xmm0
movups 0x78(%r8,%rdi,8),%xmm1
movups %xmm0,0x60(%rdx,%rdi,8)
movups %xmm1,0x70(%rdx,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rbx
jne    1180 <bspline_coeff_derivative+0x80>
test   %r15,%r15
je     121a <bspline_coeff_derivative+0x11a>
cs nopw 0x0(%rax,%rax,1)
lea    0x0(,%rdi,8),%rbx
or     $0x8,%rbx
movups (%r8,%rbx,1),%xmm0
movups 0x10(%r8,%rbx,1),%xmm1
movups %xmm0,(%rdx,%rdi,8)
movups %xmm1,0x10(%rdx,%rdi,8)
add    $0x4,%rdi
add    $0xffffffffffffffff,%r15
jne    11f0 <bspline_coeff_derivative+0xf0>
cmp    %rax,%r11
je     129b <bspline_coeff_derivative+0x19b>
or     $0x1,%rax
mov    %r14d,%ebx
sub    %eax,%ebx
mov    %rax,%rdi
not    %rdi
add    %r14,%rdi
and    $0x3,%rbx
je     1256 <bspline_coeff_derivative+0x156>
nopw   0x0(%rax,%rax,1)
movsd  (%r8,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rdx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbx
jne    1240 <bspline_coeff_derivative+0x140>
cmp    $0x3,%rdi
jb     129b <bspline_coeff_derivative+0x19b>
nopl   0x0(%rax)
movsd  (%r8,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rdx,%rax,8)
movsd  0x8(%r8,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
movsd  0x10(%r8,%rax,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rax,8)
movsd  0x18(%r8,%rax,8),%xmm0
movsd  %xmm0,0x10(%rdx,%rax,8)
add    $0x4,%rax
cmp    %rax,%r14
jne    1260 <bspline_coeff_derivative+0x160>
test   %r10d,%r10d
je     13d9 <bspline_coeff_derivative+0x2d9>
mov    %esi,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r10d,%eax
cmp    $0x1,%r10d
jne    12c2 <bspline_coeff_derivative+0x1c2>
xor    %edx,%edx
jmp    1393 <bspline_coeff_derivative+0x293>
lea    -0x1(%rax),%rdi
mov    $0xfffffffe,%ebp
sub    %esi,%ebp
xor    %edx,%edx
cmp    %edi,%ebp
jb     1393 <bspline_coeff_derivative+0x293>
shr    $0x20,%rdi
jne    1393 <bspline_coeff_derivative+0x293>
lea    (%rcx,%rax,8),%rdx
lea    0x8(%r8),%r10
lea    (%r8,%rax,8),%rbx
add    $0x8,%rbx
lea    0x1(%rsi),%edi
lea    (%r8,%rdi,8),%r11
lea    (%rax,%rdi,1),%rbp
lea    (%r8,%rbp,8),%rbp
cmp    %rcx,%rbx
seta   %r14b
lea    (%r9,%rax,8),%r15
add    $0x8,%r15
cmp    %rdx,%r10
setb   %r12b
cmp    %rcx,%rbp
seta   %bl
cmp    %rdx,%r11
setb   %r11b
cmp    %rcx,%r15
seta   %r10b
cmp    %r9,%rdx
seta   %bpl
xor    %edx,%edx
test   %r12b,%r14b
jne    1393 <bspline_coeff_derivative+0x293>
and    %r11b,%bl
jne    1393 <bspline_coeff_derivative+0x293>
and    %bpl,%r10b
jne    1393 <bspline_coeff_derivative+0x293>
mov    %eax,%edx
and    $0xfffffffe,%edx
movaps %xmm0,%xmm1
movlhps %xmm0,%xmm1
xor    %ebx,%ebx
nop
lea    (%rdi,%rbx,1),%ebp
movupd (%r8,%rbp,8),%xmm2
movupd 0x8(%r8,%rbx,8),%xmm3
subpd  %xmm3,%xmm2
movaps %xmm1,%xmm3
divpd  %xmm2,%xmm3
movupd (%r9,%rbx,8),%xmm2
movupd 0x8(%r9,%rbx,8),%xmm4
subpd  %xmm2,%xmm4
mulpd  %xmm3,%xmm4
movupd %xmm4,(%rcx,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%rdx
jne    1350 <bspline_coeff_derivative+0x250>
cmp    %rax,%rdx
je     13d9 <bspline_coeff_derivative+0x2d9>
add    $0x1,%esi
cs nopw 0x0(%rax,%rax,1)
lea    (%rsi,%rdx,1),%edi
movsd  (%r8,%rdi,8),%xmm1
subsd  0x8(%r8,%rdx,8),%xmm1
movaps %xmm0,%xmm2
divsd  %xmm1,%xmm2
movsd  0x8(%r9,%rdx,8),%xmm1
subsd  (%r9,%rdx,8),%xmm1
mulsd  %xmm2,%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
lea    0x1(%rdx),%rdi
mov    %rdi,%rdx
cmp    %rdi,%rax
jne    13a0 <bspline_coeff_derivative+0x2a0>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @bspline_coeff_derivative(i32 %0, i32 %1, double* %2, double* %3, double* %4, double* %5) {
%7 = alloca i32
%8 = alloca i32
%9 = alloca double*
%10 = alloca double*
%11 = alloca double*
%12 = alloca double*
%13 = alloca i32
%14 = alloca i32
store i32 %0, i32* %7
store i32 %1, i32* %8
store double* %2, double** %9
store double* %3, double** %10
store double* %4, double** %11
store double* %5, double** %12
%15 = load i32, i32* %7
%16 = sub i32 %15, 1
%17 = zext i32 %16 to i64
%18 = load i32, i32* %7
%19 = load i32, i32* %8
%20 = sub i32 %18, %19
%21 = sub i32 %20, 1
%22 = zext i32 %21 to i64
%23 = load i32, i32* %7
%24 = add i32 %23, 1
%25 = zext i32 %24 to i64
%26 = load i32, i32* %7
%27 = load i32, i32* %8
%28 = sub i32 %26, %27
%29 = zext i32 %28 to i64
store i32 1, i32* %13
br label %30
30: ; preds = %45, %6
%31 = load i32, i32* %13
%32 = load i32, i32* %7
%33 = icmp ult i32 %31, %32
br i1 %33, label %34, label %48
34: ; preds = %30
%35 = load double*, double** %11
%36 = load i32, i32* %13
%37 = zext i32 %36 to i64
%38 = getelementptr inbounds double, double* %35, i64 %37
%39 = load double, double* %38
%40 = load double*, double** %9
%41 = load i32, i32* %13
%42 = sub i32 %41, 1
%43 = zext i32 %42 to i64
%44 = getelementptr inbounds double, double* %40, i64 %43
store double %39, double* %44
br label %45
45: ; preds = %34
%46 = load i32, i32* %13
%47 = add i32 %46, 1
store i32 %47, i32* %13
br label %30
48: ; preds = %30
store i32 0, i32* %14
br label %49
49: ; preds = %93, %48
%50 = load i32, i32* %14
%51 = load i32, i32* %7
%52 = load i32, i32* %8
%53 = sub i32 %51, %52
%54 = sub i32 %53, 1
%55 = icmp ult i32 %50, %54
br i1 %55, label %56, label %96
56: ; preds = %49
%57 = load i32, i32* %8
%58 = uitofp i32 %57 to float
%59 = fpext float %58 to double
%60 = load double*, double** %11
%61 = load i32, i32* %14
%62 = load i32, i32* %8
%63 = add i32 %61, %62
%64 = add i32 %63, 1
%65 = zext i32 %64 to i64
%66 = getelementptr inbounds double, double* %60, i64 %65
%67 = load double, double* %66
%68 = load double*, double** %11
%69 = load i32, i32* %14
%70 = add i32 %69, 1
%71 = zext i32 %70 to i64
%72 = getelementptr inbounds double, double* %68, i64 %71
%73 = load double, double* %72
%74 = fsub double %67, %73
%75 = fdiv double %59, %74
%76 = load double*, double** %12
%77 = load i32, i32* %14
%78 = add i32 %77, 1
%79 = zext i32 %78 to i64
%80 = getelementptr inbounds double, double* %76, i64 %79
%81 = load double, double* %80
%82 = load double*, double** %12
%83 = load i32, i32* %14
%84 = zext i32 %83 to i64
%85 = getelementptr inbounds double, double* %82, i64 %84
%86 = load double, double* %85
%87 = fsub double %81, %86
%88 = fmul double %75, %87
%89 = load double*, double** %10
%90 = load i32, i32* %14
%91 = zext i32 %90 to i64
%92 = getelementptr inbounds double, double* %89, i64 %91
store double %88, double* %92
br label %93
93: ; preds = %56
%94 = load i32, i32* %14
%95 = add i32 %94, 1
store i32 %95, i32* %14
br label %49
96: ; preds = %49
ret void
}

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