#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_vec_mat_k2(double *restrict x, double *restrict y,
                        double *restrict z, int m) {
  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);
  int i = 0;
  {
    double t[2] = {x[0], x[1]};
    while (i <= m - 4) {
      z[i + 0] = t[0] * y[0] + t[1] * y[1];
      z[i + 1] = t[0] * y[2] + t[1] * y[3];
      z[i + 2] = t[0] * y[4] + t[1] * y[5];
      z[i + 3] = t[0] * y[6] + t[1] * y[7];
      y += 8;
      i += 4;
    }
    if (i <= m - 2) {
      z[i + 0] = t[0] * y[0] + t[1] * y[1];
      z[i + 1] = t[0] * y[2] + t[1] * y[3];
      y += 4;
      i += 2;
    }
    if (i < m) {
      z[i] = t[0] * y[0] + t[1] * y[1];
    }
  }
}


x86 assembly (clang, -O0):
<matprod_vec_mat_k2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%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)
movl   $0x0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x4,%ecx
cmp    %ecx,%eax
jg     12ae <matprod_vec_mat_k2+0x19e>
movsd  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x28(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
movsd  -0x28(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x18(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
movsd  -0x28(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x28(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
movsd  -0x28(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x38(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x20(%rbp)
jmp    11ac <matprod_vec_mat_k2+0x9c>
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jg     133f <matprod_vec_mat_k2+0x22f>
movsd  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x28(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
movsd  -0x28(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x18(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    137b <matprod_vec_mat_k2+0x26b>
movsd  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x28(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<matprod_vec_mat_k2>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %ecx,%r14d
mov    %rdx,%r15
mov    %rsi,%rbx
mov    %rdi,%r12
mov    $0x1,%edi
call   1030 <assert@plt>
mov    $0x1,%edi
call   1030 <assert@plt>
mov    $0x1,%edi
call   1030 <assert@plt>
movsd  (%r12),%xmm9
movsd  0x8(%r12),%xmm8
xor    %eax,%eax
cmp    $0x4,%r14d
jl     131e <matprod_vec_mat_k2+0x20e>
lea    -0x4(%r14),%ecx
cmp    $0x4,%ecx
jae    116e <matprod_vec_mat_k2+0x5e>
xor    %eax,%eax
mov    %rbx,%rdx
jmp    1290 <matprod_vec_mat_k2+0x180>
mov    %rcx,%r8
shr    $0x2,%r8
add    $0x1,%r8
mov    %r8d,%r9d
and    $0xfffffffe,%r9d
lea    0x0(,%r9,4),%rax
mov    %r9,%rdx
shl    $0x6,%rdx
add    %rbx,%rdx
movapd %xmm8,%xmm10
unpcklpd %xmm8,%xmm10
movapd %xmm9,%xmm11
unpcklpd %xmm9,%xmm11
xor    %esi,%esi
mov    %r9,%rdi
nopl   0x0(%rax,%rax,1)
movupd 0x70(%rbx,%rsi,2),%xmm12
movupd 0x60(%rbx,%rsi,2),%xmm6
movupd 0x50(%rbx,%rsi,2),%xmm7
movupd 0x40(%rbx,%rsi,2),%xmm5
movupd (%rbx,%rsi,2),%xmm4
movupd 0x10(%rbx,%rsi,2),%xmm2
movupd 0x20(%rbx,%rsi,2),%xmm0
movupd 0x30(%rbx,%rsi,2),%xmm1
movapd %xmm4,%xmm3
unpcklpd %xmm5,%xmm3
unpckhpd %xmm5,%xmm4
movapd %xmm2,%xmm5
unpcklpd %xmm7,%xmm5
unpckhpd %xmm7,%xmm2
movapd %xmm0,%xmm7
unpcklpd %xmm6,%xmm7
unpckhpd %xmm6,%xmm0
movapd %xmm1,%xmm6
unpcklpd %xmm12,%xmm6
unpckhpd %xmm12,%xmm1
mulpd  %xmm10,%xmm4
mulpd  %xmm11,%xmm3
addpd  %xmm4,%xmm3
mulpd  %xmm10,%xmm2
mulpd  %xmm11,%xmm5
addpd  %xmm2,%xmm5
mulpd  %xmm10,%xmm0
mulpd  %xmm11,%xmm7
addpd  %xmm0,%xmm7
mulpd  %xmm10,%xmm1
mulpd  %xmm11,%xmm6
addpd  %xmm1,%xmm6
movapd %xmm7,%xmm0
unpcklpd %xmm6,%xmm0
movapd %xmm3,%xmm1
unpcklpd %xmm5,%xmm1
movhlps %xmm7,%xmm6
movhlps %xmm3,%xmm5
movups %xmm5,0x20(%r15,%rsi,1)
movups %xmm6,0x30(%r15,%rsi,1)
movupd %xmm1,(%r15,%rsi,1)
movupd %xmm0,0x10(%r15,%rsi,1)
add    $0x40,%rsi
add    $0xfffffffffffffffe,%rdi
jne    11b0 <matprod_vec_mat_k2+0xa0>
cmp    %r9,%r8
je     131b <matprod_vec_mat_k2+0x20b>
movsd  0x8(%rdx),%xmm0
mulsd  %xmm8,%xmm0
movsd  (%rdx),%xmm1
mulsd  %xmm9,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rax,8)
movsd  0x18(%rdx),%xmm0
mulsd  %xmm8,%xmm0
movsd  0x10(%rdx),%xmm1
mulsd  %xmm9,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r15,%rax,8)
movsd  0x28(%rdx),%xmm0
mulsd  %xmm8,%xmm0
movsd  0x20(%rdx),%xmm1
mulsd  %xmm9,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r15,%rax,8)
movsd  0x38(%rdx),%xmm0
mulsd  %xmm8,%xmm0
movsd  0x30(%rdx),%xmm1
mulsd  %xmm9,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%r15,%rax,8)
add    $0x40,%rdx
add    $0x4,%rax
cmp    %rcx,%rax
jbe    1290 <matprod_vec_mat_k2+0x180>
mov    %rdx,%rbx
lea    -0x2(%r14),%ecx
cmp    %ecx,%eax
jg     136f <matprod_vec_mat_k2+0x25f>
movsd  0x8(%rbx),%xmm0
mulsd  %xmm8,%xmm0
movsd  (%rbx),%xmm1
mulsd  %xmm9,%xmm1
addsd  %xmm0,%xmm1
mov    %eax,%ecx
movsd  %xmm1,(%r15,%rcx,8)
movsd  0x18(%rbx),%xmm0
mulsd  %xmm8,%xmm0
movsd  0x10(%rbx),%xmm1
mulsd  %xmm9,%xmm1
addsd  %xmm0,%xmm1
mov    %eax,%ecx
or     $0x1,%ecx
movsd  %xmm1,(%r15,%rcx,8)
add    $0x20,%rbx
or     $0x2,%eax
cmp    %r14d,%eax
jge    138c <matprod_vec_mat_k2+0x27c>
mulsd  0x8(%rbx),%xmm8
mulsd  (%rbx),%xmm9
addsd  %xmm8,%xmm9
cltq
movsd  %xmm9,(%r15,%rax,8)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define void @matprod_vec_mat_k2(double* noalias nocapture %0, double* noalias nocapture %1, double* noalias nocapture writeonly %2, i32 %3) {
%5 = tail call i32 @assert(i32 1)
%6 = tail call i32 @assert(i32 1)
%7 = tail call i32 @assert(i32 1)
%8 = load double, double* %0
%9 = getelementptr inbounds double, double* %0, i64 1
%10 = load double, double* %9
%11 = icmp slt i32 %3, 4
br i1 %11, label %104, label %12
12: ; preds = %4
%13 = add nsw i32 %3, -4
%14 = zext i32 %13 to i64
%15 = lshr i64 %14, 2
%16 = add nuw nsw i64 %15, 1
%17 = icmp ult i32 %13, 4
br i1 %17, label %61, label %18
18: ; preds = %12
%19 = and i64 %16, 2147483646
%20 = shl nuw nsw i64 %19, 2
%21 = shl nuw nsw i64 %19, 3
%22 = getelementptr double, double* %1, i64 %21
%23 = insertelement <2 x double> poison, double %10, i64 0
%24 = shufflevector <2 x double> %23, <2 x double> poison, <2 x i32> zeroinitializer
%25 = insertelement <2 x double> poison, double %8, i64 0
%26 = shufflevector <2 x double> %25, <2 x double> poison, <2 x i32> zeroinitializer
%27 = getelementptr inbounds double, double* %2, i64 -3
br label %28
28: ; preds = %28, %18
%29 = phi i64 [ 0, %18 ], [ %57, %28 ]
%30 = shl i64 %29, 2
%31 = shl i64 %29, 3
%32 = getelementptr double, double* %1, i64 %31
%33 = bitcast double* %32 to <16 x double>*
%34 = load <16 x double>, <16 x double>* %33
%35 = shufflevector <16 x double> %34, <16 x double> poison, <2 x i32> <i32 0, i32 8>
%36 = shufflevector <16 x double> %34, <16 x double> poison, <2 x i32> <i32 1, i32 9>
%37 = shufflevector <16 x double> %34, <16 x double> poison, <2 x i32> <i32 2, i32 10>
%38 = shufflevector <16 x double> %34, <16 x double> poison, <2 x i32> <i32 3, i32 11>
%39 = shufflevector <16 x double> %34, <16 x double> poison, <2 x i32> <i32 4, i32 12>
%40 = shufflevector <16 x double> %34, <16 x double> poison, <2 x i32> <i32 5, i32 13>
%41 = shufflevector <16 x double> %34, <16 x double> poison, <2 x i32> <i32 6, i32 14>
%42 = shufflevector <16 x double> %34, <16 x double> poison, <2 x i32> <i32 7, i32 15>
%43 = fmul <2 x double> %24, %36
%44 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %26, <2 x double> %35, <2 x double> %43)
%45 = fmul <2 x double> %24, %38
%46 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %26, <2 x double> %37, <2 x double> %45)
%47 = fmul <2 x double> %24, %40
%48 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %26, <2 x double> %39, <2 x double> %47)
%49 = fmul <2 x double> %24, %42
%50 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %26, <2 x double> %41, <2 x double> %49)
%51 = or i64 %30, 3
%52 = getelementptr inbounds double, double* %27, i64 %51
%53 = bitcast double* %52 to <8 x double>*
%54 = shufflevector <2 x double> %44, <2 x double> %46, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%55 = shufflevector <2 x double> %48, <2 x double> %50, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%56 = shufflevector <4 x double> %54, <4 x double> %55, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 1, i32 3, i32 5, i32 7>
store <8 x double> %56, <8 x double>* %53
%57 = add nuw i64 %29, 2
%58 = icmp eq i64 %57, %19
br i1 %58, label %59, label %28
59: ; preds = %28
%60 = icmp eq i64 %16, %19
br i1 %60, label %100, label %61
61: ; preds = %12, %59
%62 = phi i64 [ 0, %12 ], [ %20, %59 ]
%63 = phi double* [ %1, %12 ], [ %22, %59 ]
br label %64
64: ; preds = %61, %64
%65 = phi i64 [ %98, %64 ], [ %62, %61 ]
%66 = phi double* [ %97, %64 ], [ %63, %61 ]
%67 = load double, double* %66
%68 = getelementptr inbounds double, double* %66, i64 1
%69 = load double, double* %68
%70 = fmul double %10, %69
%71 = tail call double @llvm.fmuladd.f64(double %8, double %67, double %70)
%72 = getelementptr inbounds double, double* %2, i64 %65
store double %71, double* %72
%73 = getelementptr inbounds double, double* %66, i64 2
%74 = load double, double* %73
%75 = getelementptr inbounds double, double* %66, i64 3
%76 = load double, double* %75
%77 = fmul double %10, %76
%78 = tail call double @llvm.fmuladd.f64(double %8, double %74, double %77)
%79 = or i64 %65, 1
%80 = getelementptr inbounds double, double* %2, i64 %79
store double %78, double* %80
%81 = getelementptr inbounds double, double* %66, i64 4
%82 = load double, double* %81
%83 = getelementptr inbounds double, double* %66, i64 5
%84 = load double, double* %83
%85 = fmul double %10, %84
%86 = tail call double @llvm.fmuladd.f64(double %8, double %82, double %85)
%87 = or i64 %65, 2
%88 = getelementptr inbounds double, double* %2, i64 %87
store double %86, double* %88
%89 = getelementptr inbounds double, double* %66, i64 6
%90 = load double, double* %89
%91 = getelementptr inbounds double, double* %66, i64 7
%92 = load double, double* %91
%93 = fmul double %10, %92
%94 = tail call double @llvm.fmuladd.f64(double %8, double %90, double %93)
%95 = or i64 %65, 3
%96 = getelementptr inbounds double, double* %2, i64 %95
store double %94, double* %96
%97 = getelementptr inbounds double, double* %66, i64 8
%98 = add nuw nsw i64 %65, 4
%99 = icmp ugt i64 %98, %14
br i1 %99, label %100, label %64
100: ; preds = %64, %59
%101 = phi double* [ %22, %59 ], [ %97, %64 ]
%102 = phi i64 [ %20, %59 ], [ %98, %64 ]
%103 = trunc i64 %102 to i32
br label %104
104: ; preds = %100, %4
%105 = phi i32 [ 0, %4 ], [ %103, %100 ]
%106 = phi double* [ %1, %4 ], [ %101, %100 ]
%107 = add nsw i32 %3, -2
%108 = icmp sgt i32 %105, %107
br i1 %108, label %128, label %109
109: ; preds = %104
%110 = load double, double* %106
%111 = getelementptr inbounds double, double* %106, i64 1
%112 = load double, double* %111
%113 = fmul double %10, %112
%114 = tail call double @llvm.fmuladd.f64(double %8, double %110, double %113)
%115 = zext i32 %105 to i64
%116 = getelementptr inbounds double, double* %2, i64 %115
store double %114, double* %116
%117 = getelementptr inbounds double, double* %106, i64 2
%118 = load double, double* %117
%119 = getelementptr inbounds double, double* %106, i64 3
%120 = load double, double* %119
%121 = fmul double %10, %120
%122 = tail call double @llvm.fmuladd.f64(double %8, double %118, double %121)
%123 = or i32 %105, 1
%124 = zext i32 %123 to i64
%125 = getelementptr inbounds double, double* %2, i64 %124
store double %122, double* %125
%126 = getelementptr inbounds double, double* %106, i64 4
%127 = or i32 %105, 2
br label %128
128: ; preds = %109, %104
%129 = phi i32 [ %127, %109 ], [ %105, %104 ]
%130 = phi double* [ %126, %109 ], [ %106, %104 ]
%131 = icmp slt i32 %129, %3
br i1 %131, label %132, label %140
132: ; preds = %128
%133 = load double, double* %130
%134 = getelementptr inbounds double, double* %130, i64 1
%135 = load double, double* %134
%136 = fmul double %10, %135
%137 = tail call double @llvm.fmuladd.f64(double %8, double %133, double %136)
%138 = sext i32 %129 to i64
%139 = getelementptr inbounds double, double* %2, i64 %138
store double %137, double* %139
br label %140
140: ; preds = %132, %128
ret void
}