void bpsconv(double *x_out, int lx, double *g0, double *g1, int lhm1, int lhhm1,
             double *x_inl, double *x_inh) {
  int i, j, ind, tj;
  double x0, x1;
  for (i = lhhm1 - 1; i > -1; i--) {
    x_inl[i] = x_inl[lx + i];
    x_inh[i] = x_inh[lx + i];
  }
  ind = 0;
  for (i = 0; i < (lx); i++) {
    x0 = 0;
    x1 = 0;
    tj = -2;
    for (j = 0; j <= lhhm1; j++) {
      tj += 2;
      x0 = x0 + x_inl[i + j] * g0[lhm1 - 1 - tj] +
           x_inh[i + j] * g1[lhm1 - 1 - tj];
      x1 = x1 + x_inl[i + j] * g0[lhm1 - tj] + x_inh[i + j] * g1[lhm1 - tj];
    }
    x_out[ind++] = x0;
    x_out[ind++] = x1;
  }
}


x86 assembly (clang, -O0):
<bpsconv>:
push   %rbp
mov    %rsp,%rbp
mov    0x18(%rbp),%rax
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    %r9d,-0x28(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0xffffffff,-0x2c(%rbp)
jle    1182 <bpsconv+0x82>
mov    0x10(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    112c <bpsconv+0x2c>
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12ed <bpsconv+0x1ed>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0xfffffffe,-0x38(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     12a7 <bpsconv+0x1a7>
mov    -0x38(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x38(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x48(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x30(%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,-0x48(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11ba <bpsconv+0xba>
movsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1190 <bpsconv+0x90>
pop    %rbp
ret

x86 assembly (clang, -O2):
<bpsconv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rdx,%r10
mov    %rdi,-0x8(%rsp)
mov    0x40(%rsp),%r11
mov    0x38(%rsp),%r12
mov    %r9,-0x10(%rsp)
test   %r9d,%r9d
jle    1176 <bpsconv+0x76>
mov    -0x10(%rsp),%rax
mov    %eax,%r14d
movslq %esi,%r9
cmp    $0x1,%eax
jne    1258 <bpsconv+0x158>
add    $0x1,%r14
lea    (%r12,%r9,8),%rax
lea    (%r11,%r9,8),%rdx
cs nopw 0x0(%rax,%rax,1)
movsd  -0x10(%rax,%r14,8),%xmm0
movsd  %xmm0,-0x10(%r12,%r14,8)
movsd  -0x10(%rdx,%r14,8),%xmm0
movsd  %xmm0,-0x10(%r11,%r14,8)
add    $0xffffffffffffffff,%r14
cmp    $0x1,%r14
ja     1150 <bpsconv+0x50>
test   %esi,%esi
jle    124d <bpsconv+0x14d>
movslq %r8d,%rax
mov    -0x10(%rsp),%rdx
lea    0x1(%rdx),%r13d
mov    %esi,%r9d
add    %r13,%r13
lea    -0x1(%rax),%esi
lea    (%r10,%rax,8),%rdx
lea    (%rcx,%rax,8),%rbx
xor    %r14d,%r14d
xor    %r15d,%r15d
jmp    11d4 <bpsconv+0xd4>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorpd  %xmm2,%xmm2
mov    -0x8(%rsp),%rax
movupd %xmm2,(%rax,%r15,8)
add    $0x2,%r15
add    $0x1,%r14
add    $0x8,%r11
add    $0x8,%r12
cmp    %r9,%r14
je     124d <bpsconv+0x14d>
cmpl   $0x0,-0x10(%rsp)
js     11b0 <bpsconv+0xb0>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rsi,%rax,1),%r8d
movslq %r8d,%rdi
movsd  (%r12,%rbp,1),%xmm2
unpcklpd %xmm2,%xmm2
movsd  (%r10,%rdi,8),%xmm1
movhpd (%rdx,%rax,8),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movsd  (%r11,%rbp,1),%xmm0
unpcklpd %xmm0,%xmm0
movsd  (%rcx,%rdi,8),%xmm2
movhpd (%rbx,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm2,%xmm0
addpd  %xmm1,%xmm0
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rax
mov    %r13,%rdi
add    %rax,%rdi
jne    11f0 <bpsconv+0xf0>
addpd  %xmm1,%xmm2
jmp    11b4 <bpsconv+0xb4>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x1(%r14),%rax
mov    $0x8,%edx
mul    %rdx
lea    -0x8(%r12,%r14,8),%rbp
seto   %bl
mov    %rbp,%rdx
sub    %rax,%rdx
cmp    %rbp,%rdx
ja     113a <bpsconv+0x3a>
test   %bl,%bl
jne    113a <bpsconv+0x3a>
lea    (%r11,%r14,8),%rbp
add    $0xfffffffffffffff8,%rbp
mov    %rbp,%rdx
sub    %rax,%rdx
cmp    %rbp,%rdx
ja     113a <bpsconv+0x3a>
test   %bl,%bl
jne    113a <bpsconv+0x3a>
lea    (%r9,%r14,1),%rdi
lea    (%r12,%rdi,8),%rdx
add    $0xfffffffffffffff8,%rdx
mov    %rdx,%rbp
sub    %rax,%rbp
cmp    %rdx,%rbp
ja     113a <bpsconv+0x3a>
test   %bl,%bl
jne    113a <bpsconv+0x3a>
lea    (%r11,%rdi,8),%rbp
add    $0xfffffffffffffff8,%rbp
mov    %rbp,%rdx
sub    %rax,%rdx
cmp    %rbp,%rdx
ja     113a <bpsconv+0x3a>
test   %bl,%bl
jne    113a <bpsconv+0x3a>
lea    (%r12,%r14,8),%rdx
lea    (%r11,%r14,8),%r13
lea    (%r12,%r9,8),%rbp
cmp    %r12,%r13
seta   -0x18(%rsp)
lea    (%r12,%rdi,8),%rbx
cmp    %r11,%rdx
seta   -0x19(%rsp)
lea    (%r11,%r9,8),%r15
cmp    %r12,%rbx
seta   -0x1a(%rsp)
lea    (%r11,%rdi,8),%rax
cmp    %rdx,%rbp
setb   -0x1b(%rsp)
cmp    %r12,%rax
seta   -0x1c(%rsp)
cmp    %rdx,%r15
setb   -0x1d(%rsp)
cmp    %r11,%rbx
seta   %dl
cmp    %r13,%rbp
setb   %bl
cmp    %r11,%rax
seta   %bpl
cmp    %r13,%r15
setb   %r15b
mov    -0x19(%rsp),%al
test   %al,-0x18(%rsp)
jne    113a <bpsconv+0x3a>
mov    -0x1b(%rsp),%al
and    %al,-0x1a(%rsp)
jne    113a <bpsconv+0x3a>
mov    -0x1d(%rsp),%al
and    %al,-0x1c(%rsp)
jne    113a <bpsconv+0x3a>
and    %bl,%dl
jne    113a <bpsconv+0x3a>
and    %r15b,%bpl
jne    113a <bpsconv+0x3a>
mov    %r14d,%r15d
and    $0xfffffffe,%r15d
lea    -0x2(%r15),%rax
mov    %rax,%rbx
shr    %rbx
add    $0x1,%rbx
test   %rax,%rax
je     1445 <bpsconv+0x345>
mov    %rbx,-0x18(%rsp)
and    $0xfffffffffffffffe,%rbx
lea    (%r11,%r14,8),%rax
add    $0xfffffffffffffff0,%rax
lea    (%r12,%r14,8),%r13
add    $0xfffffffffffffff0,%r13
lea    (%r11,%rdi,8),%rbp
add    $0xfffffffffffffff0,%rbp
lea    (%r12,%rdi,8),%rdi
add    $0xfffffffffffffff0,%rdi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups (%rdi,%rdx,8),%xmm0
movups %xmm0,0x0(%r13,%rdx,8)
movups 0x0(%rbp,%rdx,8),%xmm0
movups %xmm0,(%rax,%rdx,8)
movups -0x10(%rdi,%rdx,8),%xmm0
movups %xmm0,-0x10(%r13,%rdx,8)
movupd -0x10(%rbp,%rdx,8),%xmm0
movupd %xmm0,-0x10(%rax,%rdx,8)
add    $0xfffffffffffffffc,%rdx
add    $0xfffffffffffffffe,%rbx
jne    13d0 <bpsconv+0x2d0>
add    $0xffffffffffffffff,%rdx
mov    -0x18(%rsp),%rbx
test   $0x1,%bl
je     1433 <bpsconv+0x333>
add    %r14,%rdx
lea    (%rdx,%r9,1),%rax
movups -0x8(%r12,%rax,8),%xmm0
movups %xmm0,-0x8(%r12,%rdx,8)
movupd -0x8(%r11,%rax,8),%xmm0
movupd %xmm0,-0x8(%r11,%rdx,8)
cmp    %r14,%r15
je     1176 <bpsconv+0x76>
and    $0x1,%r14d
jmp    113a <bpsconv+0x3a>
mov    $0xffffffffffffffff,%rdx
test   $0x1,%bl
jne    1412 <bpsconv+0x312>
jmp    1433 <bpsconv+0x333>

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

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