void fpsconv(double *x_in, int lx, double *h0, double *h1, int lhm1,
             double *x_outl, double *x_outh) {
  int i, j, ind;
  double x0, x1;
  for (i = lx; i < lx + lhm1; i++)
    x_in[i] = *(x_in + (i - lx));
  ind = 0;
  for (i = 0; i < (lx); i += 2) {
    x0 = 0;
    x1 = 0;
    for (j = 0; j <= lhm1; j++) {
      x0 = x0 + x_in[i + j] * h0[lhm1 - j];
      x1 = x1 + x_in[i + j] * h1[lhm1 - j];
    }
    x_outl[ind] = x0;
    x_outh[ind++] = x1;
  }
}


x86 assembly (clang, -O0):
<fpsconv>:
push   %rbp
mov    %rsp,%rbp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jge    1163 <fpsconv+0x63>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1125 <fpsconv+0x25>
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1256 <fpsconv+0x156>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     121a <fpsconv+0x11a>
movsd  -0x48(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x50(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1194 <fpsconv+0x94>
movsd  -0x48(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x3c(%rbp)
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
jmp    1171 <fpsconv+0x71>
pop    %rbp
ret

x86 assembly (clang, -O2):
<fpsconv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rcx,-0x10(%rsp)
mov    %rdx,-0x18(%rsp)
test   %r8d,%r8d
jle    1283 <fpsconv+0x183>
lea    (%r8,%rsi,1),%eax
movslq %esi,%r11
cltq
lea    0x1(%r11),%rcx
cmp    %rax,%rcx
mov    %rax,%r10
cmovg  %rcx,%r10
sub    %r11,%r10
mov    %r11,%rbx
cmp    $0x4,%r10
jb     1257 <fpsconv+0x157>
cmp    %rax,%rcx
cmovle %rax,%rcx
lea    (%rdi,%r11,8),%rdx
mov    %rcx,%rbx
sub    %r11,%rbx
lea    (%rdi,%rbx,8),%rbx
cmp    %rbx,%rdx
jae    116e <fpsconv+0x6e>
lea    (%rdi,%rcx,8),%rcx
mov    %r11,%rbx
cmp    %rdi,%rcx
ja     1257 <fpsconv+0x157>
mov    %r10,%rbx
and    $0xfffffffffffffffc,%rbx
lea    -0x4(%rbx),%rdx
mov    %rdx,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %ecx,%r14d
and    $0x3,%r14d
cmp    $0xc,%rdx
jae    1195 <fpsconv+0x95>
xor    %ebp,%ebp
jmp    120c <fpsconv+0x10c>
and    $0xfffffffffffffffc,%rcx
lea    (%rdi,%r11,8),%rdx
add    $0x70,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rdi,%rbp,8),%xmm0
movups 0x10(%rdi,%rbp,8),%xmm1
movups %xmm0,-0x70(%rdx,%rbp,8)
movups %xmm1,-0x60(%rdx,%rbp,8)
movups 0x20(%rdi,%rbp,8),%xmm0
movups 0x30(%rdi,%rbp,8),%xmm1
movups %xmm0,-0x50(%rdx,%rbp,8)
movups %xmm1,-0x40(%rdx,%rbp,8)
movups 0x40(%rdi,%rbp,8),%xmm0
movups 0x50(%rdi,%rbp,8),%xmm1
movups %xmm0,-0x30(%rdx,%rbp,8)
movups %xmm1,-0x20(%rdx,%rbp,8)
movupd 0x60(%rdi,%rbp,8),%xmm0
movupd 0x70(%rdi,%rbp,8),%xmm1
movupd %xmm0,-0x10(%rdx,%rbp,8)
movupd %xmm1,(%rdx,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rcx
jne    11b0 <fpsconv+0xb0>
test   %r14,%r14
je     124f <fpsconv+0x14f>
lea    (%rdi,%rbp,8),%rcx
add    $0x10,%rcx
lea    (%rcx,%r11,8),%rdx
shl    $0x5,%r14
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x10(%rcx,%rbp,1),%xmm0
movupd (%rcx,%rbp,1),%xmm1
movupd %xmm0,-0x10(%rdx,%rbp,1)
movupd %xmm1,(%rdx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r14
jne    1230 <fpsconv+0x130>
cmp    %rbx,%r10
je     1283 <fpsconv+0x183>
add    %r11,%rbx
shl    $0x3,%r11
mov    %rdi,%rcx
sub    %r11,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,(%rdi,%rbx,8)
add    $0x1,%rbx
cmp    %rax,%rbx
jl     1270 <fpsconv+0x170>
test   %esi,%esi
jle    13c9 <fpsconv+0x2c9>
mov    0x38(%rsp),%rdx
movslq %r8d,%rbp
lea    0x1(%r8),%r14d
add    $0xffffffff,%esi
shr    %esi
add    $0x1,%esi
lea    0x8(%rdi),%r11
mov    -0x10(%rsp),%rax
lea    (%rax,%rbp,8),%rax
mov    -0x18(%rsp),%rcx
mov    %rbp,-0x8(%rsp)
lea    (%rcx,%rbp,8),%rbx
mov    %r14d,%r12d
and    $0xfffffffe,%r12d
neg    %r12
xor    %r13d,%r13d
xor    %ebp,%ebp
jmp    12f4 <fpsconv+0x1f4>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm1,%xmm1
movlpd %xmm1,(%r9,%rbp,8)
movhpd %xmm1,(%rdx,%rbp,8)
add    $0x1,%rbp
add    $0x2,%r13
add    $0x10,%r11
cmp    %rsi,%rbp
je     13c9 <fpsconv+0x2c9>
test   %r8d,%r8d
js     12d0 <fpsconv+0x1d0>
xorpd  %xmm0,%xmm0
je     1380 <fpsconv+0x280>
xor    %r10d,%r10d
mov    %r11,%r15
nopl   0x0(%rax)
movsd  -0x8(%r15),%xmm3
movsd  (%r15),%xmm4
unpcklpd %xmm3,%xmm3
movsd  -0x8(%rbx,%r10,8),%xmm1
movsd  (%rbx,%r10,8),%xmm2
movhpd (%rax,%r10,8),%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm0,%xmm2
unpcklpd %xmm4,%xmm4
movhpd -0x8(%rax,%r10,8),%xmm1
mulpd  %xmm4,%xmm1
movapd %xmm1,%xmm0
addpd  %xmm2,%xmm0
add    $0x10,%r15
add    $0xfffffffffffffffe,%r10
cmp    %r10,%r12
jne    1310 <fpsconv+0x210>
addpd  %xmm2,%xmm1
neg    %r10
test   $0x1,%r14b
je     12d4 <fpsconv+0x1d4>
jmp    138d <fpsconv+0x28d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %r10d,%r10d
test   $0x1,%r14b
je     12d4 <fpsconv+0x1d4>
mov    %rdx,%r15
mov    -0x8(%rsp),%rdx
sub    %r10,%rdx
add    %r13,%r10
movsd  (%rdi,%r10,8),%xmm2
unpcklpd %xmm2,%xmm2
mov    -0x18(%rsp),%rcx
movsd  (%rcx,%rdx,8),%xmm1
mov    -0x10(%rsp),%rcx
movhpd (%rcx,%rdx,8),%xmm1
mov    %r15,%rdx
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
jmp    12d4 <fpsconv+0x1d4>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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