#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef scalar_t__ z;
typedef scalar_t__ y;
typedef scalar_t__ x;

/* Variables and functions */
int /*<<< orphan*/ assert(int);
void matprod_mat_vec_n4(double *restrict x, double *restrict y,
                        double *restrict z, int k, int add) {
  assert(((uintptr_t)(x) & (1 - 1)) == 0);
  assert(((uintptr_t)(y) & (1 - 1)) == 0);
  assert(((uintptr_t)(z) & (1 - 1)) == 0);
  x = (x);
  y = (y);
  z = (z);
  {
    double s[4];
    if (add) {
      s[0] = z[0];
      s[1] = z[1];
      s[2] = z[2];
      s[3] = z[3];
    } else
      s[0] = s[1] = s[2] = s[3] = 0;
    while (k > 1) {
      s[0] = (s[0] + (x[0] * y[0])) + (x[4] * y[1]);
      s[1] = (s[1] + (x[1] * y[0])) + (x[5] * y[1]);
      s[2] = (s[2] + (x[2] * y[0])) + (x[6] * y[1]);
      s[3] = (s[3] + (x[3] * y[0])) + (x[7] * y[1]);
      x += 8;
      y += 2;
      k -= 2;
    }
    if (k >= 1) {
      s[0] += x[0] * y[0];
      s[1] += x[1] * y[0];
      s[2] += x[2] * y[0];
      s[3] += x[3] * y[0];
    }
    z[0] = s[0];
    z[1] = s[1];
    z[2] = s[2];
    z[3] = s[3];
  }
}


x86 assembly (clang, -O0):
<matprod_mat_vec_n4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    -0x8(%rbp),%rax
and    $0x0,%rax
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x10(%rbp),%rax
and    $0x0,%rax
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x18(%rbp),%rax
and    $0x0,%rax
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x8(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
cmpl   $0x0,-0x20(%rbp)
je     11d4 <matprod_mat_vec_n4+0xc4>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x28(%rbp)
jmp    11f4 <matprod_mat_vec_n4+0xe4>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    11f9 <matprod_mat_vec_n4+0xe9>
cmpl   $0x1,-0x1c(%rbp)
jle    131c <matprod_mat_vec_n4+0x20c>
movsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x38(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x10(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    11f9 <matprod_mat_vec_n4+0xe9>
cmpl   $0x1,-0x1c(%rbp)
jl     13b1 <matprod_mat_vec_n4+0x2a1>
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x28(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x30(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x28(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x18(%rax)
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<matprod_mat_vec_n4>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %r8d,%r12d
mov    %ecx,%ebp
mov    %rdx,%r14
mov    %rsi,%r15
mov    %rdi,%rbx
mov    $0x1,%edi
call   1030 <assert@plt>
mov    $0x1,%edi
call   1030 <assert@plt>
mov    $0x1,%edi
call   1030 <assert@plt>
test   %r12d,%r12d
je     1194 <matprod_mat_vec_n4+0x84>
movupd (%r14),%xmm0
movupd 0x10(%r14),%xmm1
cmp    $0x2,%ebp
jge    11b0 <matprod_mat_vec_n4+0xa0>
cmp    $0x1,%ebp
jne    1180 <matprod_mat_vec_n4+0x70>
movsd  (%r15),%xmm2
unpcklpd %xmm2,%xmm2
movupd (%rbx),%xmm3
movupd 0x10(%rbx),%xmm4
mulpd  %xmm2,%xmm3
addpd  %xmm3,%xmm0
mulpd  %xmm2,%xmm4
addpd  %xmm4,%xmm1
movupd %xmm0,(%r14)
movupd %xmm1,0x10(%r14)
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
xorpd  %xmm0,%xmm0
xorpd  %xmm1,%xmm1
cmp    $0x2,%ebp
jl     1159 <matprod_mat_vec_n4+0x49>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ebp,%eax
movupd (%rbx),%xmm3
movupd 0x10(%rbx),%xmm6
movupd 0x20(%rbx),%xmm2
movupd 0x30(%rbx),%xmm7
movsd  (%r15),%xmm5
movsd  0x8(%r15),%xmm4
unpcklpd %xmm5,%xmm5
mulpd  %xmm5,%xmm3
addpd  %xmm0,%xmm3
unpcklpd %xmm4,%xmm4
mulpd  %xmm4,%xmm2
movapd %xmm2,%xmm0
addpd  %xmm3,%xmm0
mulpd  %xmm6,%xmm5
addpd  %xmm1,%xmm5
mulpd  %xmm7,%xmm4
movapd %xmm4,%xmm1
addpd  %xmm5,%xmm1
add    $0x40,%rbx
add    $0x10,%r15
lea    -0x2(%rax),%ebp
cmp    $0x3,%eax
ja     11b0 <matprod_mat_vec_n4+0xa0>
addpd  %xmm5,%xmm4
addpd  %xmm3,%xmm2
movapd %xmm2,%xmm0
movapd %xmm4,%xmm1
cmp    $0x1,%ebp
je     115e <matprod_mat_vec_n4+0x4e>
jmp    1180 <matprod_mat_vec_n4+0x70>

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

LLVM IR (-O2):
define void @matprod_mat_vec_n4(double* noalias nocapture %0, double* noalias nocapture %1, double* noalias nocapture %2, i32 %3, i32 %4) {
%6 = tail call i32 @assert(i32 1)
%7 = tail call i32 @assert(i32 1)
%8 = tail call i32 @assert(i32 1)
%9 = icmp eq i32 %4, 0
br i1 %9, label %16, label %10
10: ; preds = %5
%11 = bitcast double* %2 to <2 x double>*
%12 = load <2 x double>, <2 x double>* %11
%13 = getelementptr inbounds double, double* %2, i64 2
%14 = bitcast double* %13 to <2 x double>*
%15 = load <2 x double>, <2 x double>* %14
br label %16
16: ; preds = %5, %10
%17 = phi <2 x double> [ %12, %10 ], [ zeroinitializer, %5 ]
%18 = phi <2 x double> [ %15, %10 ], [ zeroinitializer, %5 ]
%19 = icmp sgt i32 %3, 1
br i1 %19, label %20, label %57
20: ; preds = %16, %20
%21 = phi double* [ %48, %20 ], [ %0, %16 ]
%22 = phi i32 [ %50, %20 ], [ %3, %16 ]
%23 = phi double* [ %49, %20 ], [ %1, %16 ]
%24 = phi <2 x double> [ %39, %20 ], [ %17, %16 ]
%25 = phi <2 x double> [ %47, %20 ], [ %18, %16 ]
%26 = load double, double* %23
%27 = getelementptr inbounds double, double* %21, i64 4
%28 = getelementptr inbounds double, double* %23, i64 1
%29 = load double, double* %28
%30 = bitcast double* %21 to <2 x double>*
%31 = load <2 x double>, <2 x double>* %30
%32 = insertelement <2 x double> poison, double %26, i64 0
%33 = shufflevector <2 x double> %32, <2 x double> poison, <2 x i32> zeroinitializer
%34 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %31, <2 x double> %33, <2 x double> %24)
%35 = bitcast double* %27 to <2 x double>*
%36 = load <2 x double>, <2 x double>* %35
%37 = insertelement <2 x double> poison, double %29, i64 0
%38 = shufflevector <2 x double> %37, <2 x double> poison, <2 x i32> zeroinitializer
%39 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %36, <2 x double> %38, <2 x double> %34)
%40 = getelementptr inbounds double, double* %21, i64 2
%41 = getelementptr inbounds double, double* %21, i64 6
%42 = bitcast double* %40 to <2 x double>*
%43 = load <2 x double>, <2 x double>* %42
%44 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %43, <2 x double> %33, <2 x double> %25)
%45 = bitcast double* %41 to <2 x double>*
%46 = load <2 x double>, <2 x double>* %45
%47 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %46, <2 x double> %38, <2 x double> %44)
%48 = getelementptr inbounds double, double* %21, i64 8
%49 = getelementptr inbounds double, double* %23, i64 2
%50 = add nsw i32 %22, -2
%51 = icmp ugt i32 %22, 3
br i1 %51, label %20, label %52
52: ; preds = %20
%53 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %43, <2 x double> %33, <2 x double> %25)
%54 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %46, <2 x double> %38, <2 x double> %53)
%55 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %31, <2 x double> %33, <2 x double> %24)
%56 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %36, <2 x double> %38, <2 x double> %55)
br label %57
57: ; preds = %52, %16
%58 = phi double* [ %1, %16 ], [ %49, %52 ]
%59 = phi i32 [ %3, %16 ], [ %50, %52 ]
%60 = phi double* [ %0, %16 ], [ %48, %52 ]
%61 = phi <2 x double> [ %17, %16 ], [ %56, %52 ]
%62 = phi <2 x double> [ %18, %16 ], [ %54, %52 ]
%63 = icmp eq i32 %59, 1
br i1 %63, label %64, label %75
64: ; preds = %57
%65 = load double, double* %58
%66 = bitcast double* %60 to <2 x double>*
%67 = load <2 x double>, <2 x double>* %66
%68 = insertelement <2 x double> poison, double %65, i64 0
%69 = shufflevector <2 x double> %68, <2 x double> poison, <2 x i32> zeroinitializer
%70 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %67, <2 x double> %69, <2 x double> %61)
%71 = getelementptr inbounds double, double* %60, i64 2
%72 = bitcast double* %71 to <2 x double>*
%73 = load <2 x double>, <2 x double>* %72
%74 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %73, <2 x double> %69, <2 x double> %62)
br label %75
75: ; preds = %64, %57
%76 = phi <2 x double> [ %70, %64 ], [ %61, %57 ]
%77 = phi <2 x double> [ %74, %64 ], [ %62, %57 ]
%78 = bitcast double* %2 to <2 x double>*
store <2 x double> %76, <2 x double>* %78
%79 = getelementptr inbounds double, double* %2, i64 2
%80 = bitcast double* %79 to <2 x double>*
store <2 x double> %77, <2 x double>* %80
ret void
}