void kernel_strmv_u_t_8_lib4(int kmax, float *A, int sda, float *x, float *y,
                             int alg) {
  const int lda = 4;
  const int bs = 4;
  int k;
  float x_0, x_1, x_2, x_3, y_0 = 0, y_1 = 0, y_2 = 0, y_3 = 0, y_4 = 0,
                            y_5 = 0, y_6 = 0, y_7 = 0;
  k = 0;
  for (; k < kmax - 7; k += 8) {
    x_0 = x[0];
    x_1 = x[1];
    x_2 = x[2];
    x_3 = x[3];
    y_0 += A[0 + lda * 0] * x_0;
    y_1 += A[0 + lda * 1] * x_0;
    y_2 += A[0 + lda * 2] * x_0;
    y_3 += A[0 + lda * 3] * x_0;
    y_4 += A[0 + lda * 4] * x_0;
    y_5 += A[0 + lda * 5] * x_0;
    y_6 += A[0 + lda * 6] * x_0;
    y_7 += A[0 + lda * 7] * x_0;
    y_0 += A[1 + lda * 0] * x_1;
    y_1 += A[1 + lda * 1] * x_1;
    y_2 += A[1 + lda * 2] * x_1;
    y_3 += A[1 + lda * 3] * x_1;
    y_4 += A[1 + lda * 4] * x_1;
    y_5 += A[1 + lda * 5] * x_1;
    y_6 += A[1 + lda * 6] * x_1;
    y_7 += A[1 + lda * 7] * x_1;
    y_0 += A[2 + lda * 0] * x_2;
    y_1 += A[2 + lda * 1] * x_2;
    y_2 += A[2 + lda * 2] * x_2;
    y_3 += A[2 + lda * 3] * x_2;
    y_4 += A[2 + lda * 4] * x_2;
    y_5 += A[2 + lda * 5] * x_2;
    y_6 += A[2 + lda * 6] * x_2;
    y_7 += A[2 + lda * 7] * x_2;
    y_0 += A[3 + lda * 0] * x_3;
    y_1 += A[3 + lda * 1] * x_3;
    y_2 += A[3 + lda * 2] * x_3;
    y_3 += A[3 + lda * 3] * x_3;
    y_4 += A[3 + lda * 4] * x_3;
    y_5 += A[3 + lda * 5] * x_3;
    y_6 += A[3 + lda * 6] * x_3;
    y_7 += A[3 + lda * 7] * x_3;
    A += sda * bs;
    x += 4;
    x_0 = x[0];
    x_1 = x[1];
    x_2 = x[2];
    x_3 = x[3];
    y_0 += A[0 + lda * 0] * x_0;
    y_1 += A[0 + lda * 1] * x_0;
    y_2 += A[0 + lda * 2] * x_0;
    y_3 += A[0 + lda * 3] * x_0;
    y_4 += A[0 + lda * 4] * x_0;
    y_5 += A[0 + lda * 5] * x_0;
    y_6 += A[0 + lda * 6] * x_0;
    y_7 += A[0 + lda * 7] * x_0;
    y_0 += A[1 + lda * 0] * x_1;
    y_1 += A[1 + lda * 1] * x_1;
    y_2 += A[1 + lda * 2] * x_1;
    y_3 += A[1 + lda * 3] * x_1;
    y_4 += A[1 + lda * 4] * x_1;
    y_5 += A[1 + lda * 5] * x_1;
    y_6 += A[1 + lda * 6] * x_1;
    y_7 += A[1 + lda * 7] * x_1;
    y_0 += A[2 + lda * 0] * x_2;
    y_1 += A[2 + lda * 1] * x_2;
    y_2 += A[2 + lda * 2] * x_2;
    y_3 += A[2 + lda * 3] * x_2;
    y_4 += A[2 + lda * 4] * x_2;
    y_5 += A[2 + lda * 5] * x_2;
    y_6 += A[2 + lda * 6] * x_2;
    y_7 += A[2 + lda * 7] * x_2;
    y_0 += A[3 + lda * 0] * x_3;
    y_1 += A[3 + lda * 1] * x_3;
    y_2 += A[3 + lda * 2] * x_3;
    y_3 += A[3 + lda * 3] * x_3;
    y_4 += A[3 + lda * 4] * x_3;
    y_5 += A[3 + lda * 5] * x_3;
    y_6 += A[3 + lda * 6] * x_3;
    y_7 += A[3 + lda * 7] * x_3;
    A += sda * bs;
    x += 4;
  }
  x_0 = x[0];
  x_1 = x[1];
  x_2 = x[2];
  x_3 = x[3];
  y_0 += A[0 + lda * 0] * x_0;
  y_1 += A[0 + lda * 1] * x_0;
  y_2 += A[0 + lda * 2] * x_0;
  y_3 += A[0 + lda * 3] * x_0;
  y_4 += A[0 + lda * 4] * x_0;
  y_5 += A[0 + lda * 5] * x_0;
  y_6 += A[0 + lda * 6] * x_0;
  y_7 += A[0 + lda * 7] * x_0;
  y_1 += A[1 + lda * 1] * x_1;
  y_2 += A[1 + lda * 2] * x_1;
  y_3 += A[1 + lda * 3] * x_1;
  y_4 += A[1 + lda * 4] * x_1;
  y_5 += A[1 + lda * 5] * x_1;
  y_6 += A[1 + lda * 6] * x_1;
  y_7 += A[1 + lda * 7] * x_1;
  y_2 += A[2 + lda * 2] * x_2;
  y_3 += A[2 + lda * 3] * x_2;
  y_4 += A[2 + lda * 4] * x_2;
  y_5 += A[2 + lda * 5] * x_2;
  y_6 += A[2 + lda * 6] * x_2;
  y_7 += A[2 + lda * 7] * x_2;
  y_3 += A[3 + lda * 3] * x_3;
  y_4 += A[3 + lda * 4] * x_3;
  y_5 += A[3 + lda * 5] * x_3;
  y_6 += A[3 + lda * 6] * x_3;
  y_7 += A[3 + lda * 7] * x_3;
  A += sda * bs;
  x += 4;
  x_0 = x[0];
  x_1 = x[1];
  x_2 = x[2];
  x_3 = x[3];
  y_4 += A[0 + lda * 4] * x_0;
  y_5 += A[0 + lda * 5] * x_0;
  y_6 += A[0 + lda * 6] * x_0;
  y_7 += A[0 + lda * 7] * x_0;
  y_5 += A[1 + lda * 5] * x_1;
  y_6 += A[1 + lda * 6] * x_1;
  y_7 += A[1 + lda * 7] * x_1;
  y_6 += A[2 + lda * 6] * x_2;
  y_7 += A[2 + lda * 7] * x_2;
  y_7 += A[3 + lda * 7] * x_3;
  if (alg == 0) {
    y[0] = y_0;
    y[1] = y_1;
    y[2] = y_2;
    y[3] = y_3;
    y[4] = y_4;
    y[5] = y_5;
    y[6] = y_6;
    y[7] = y_7;
  } else if (alg == 1) {
    y[0] += y_0;
    y[1] += y_1;
    y[2] += y_2;
    y[3] += y_3;
    y[4] += y_4;
    y[5] += y_5;
    y[6] += y_6;
    y[7] += y_7;
  } else {
    y[0] -= y_0;
    y[1] -= y_1;
    y[2] -= y_2;
    y[3] -= y_3;
    y[4] -= y_4;
    y[5] -= y_5;
    y[6] -= y_6;
    y[7] -= y_7;
  }
}


x86 assembly (clang, -O0):
<kernel_strmv_u_t_8_lib4>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movl   $0x4,-0x30(%rbp)
movl   $0x4,-0x34(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x7,%ecx
cmp    %ecx,%eax
jge    1a42 <kernel_strmv_u_t_8_lib4+0x942>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x40(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x50(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x60(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x70(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x44(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x54(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x64(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x74(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x48(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x58(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x68(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x78(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x5c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x6c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x7c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x14(%rbp),%ecx
shl    $0x2,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x40(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x50(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x60(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x70(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x44(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x54(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x64(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x74(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x48(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x58(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x68(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x78(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x5c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x6c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x7c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x14(%rbp),%ecx
shl    $0x2,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x20(%rbp)
mov    -0x38(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x38(%rbp)
jmp    116f <kernel_strmv_u_t_8_lib4+0x6f>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x40(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x50(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x60(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x70(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x44(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x54(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x64(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x74(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x48(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x58(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x68(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x78(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x5c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x6c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x7c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x14(%rbp),%ecx
shl    $0x2,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x40(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x50(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x60(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x70(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0x54(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x64(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x74(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0x68(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x78(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0x7c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jne    1fd1 <kernel_strmv_u_t_8_lib4+0xed1>
movss  -0x4c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x5c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x64(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x68(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x1c(%rax)
jmp    2131 <kernel_strmv_u_t_8_lib4+0x1031>
cmpl   $0x1,-0x2c(%rbp)
jne    2076 <kernel_strmv_u_t_8_lib4+0xf76>
movss  -0x4c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x4(%rax),%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x8(%rax),%xmm0
movss  %xmm0,0x8(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0xc(%rax),%xmm0
movss  %xmm0,0xc(%rax)
movss  -0x5c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x10(%rax),%xmm0
movss  %xmm0,0x10(%rax)
movss  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x14(%rax),%xmm0
movss  %xmm0,0x14(%rax)
movss  -0x64(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x18(%rax),%xmm0
movss  %xmm0,0x18(%rax)
movss  -0x68(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x1c(%rax),%xmm0
movss  %xmm0,0x1c(%rax)
jmp    212c <kernel_strmv_u_t_8_lib4+0x102c>
movss  -0x4c(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  -0x50(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x54(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x8(%rax)
movss  -0x58(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0xc(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0xc(%rax)
movss  -0x5c(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x10(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x10(%rax)
movss  -0x60(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x14(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x14(%rax)
movss  -0x64(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x18(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x18(%rax)
movss  -0x68(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x1c(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x1c(%rax)
jmp    2131 <kernel_strmv_u_t_8_lib4+0x1031>
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_strmv_u_t_8_lib4>:
push   %rbx
shl    $0x2,%edx
movslq %edx,%r11
xorps  %xmm4,%xmm4
cmp    $0x8,%edi
jl     1401 <kernel_strmv_u_t_8_lib4+0x301>
add    $0xfffffff9,%edi
lea    0x0(,%r11,8),%r10
lea    0x0(,%r11,4),%rdx
xorps  %xmm6,%xmm6
xor    %eax,%eax
xorps  %xmm5,%xmm5
xchg   %ax,%ax
mov    %rsi,%rbx
movss  0x70(%rsi),%xmm0
movss  0x60(%rsi),%xmm1
unpcklps %xmm0,%xmm1
movss  0x50(%rsi),%xmm0
movss  0x40(%rsi),%xmm3
unpcklps %xmm0,%xmm3
movlhps %xmm1,%xmm3
movss  0x30(%rsi),%xmm0
movss  0x20(%rsi),%xmm1
unpcklps %xmm0,%xmm1
movss  0x10(%rsi),%xmm0
movss  (%rsi),%xmm7
unpcklps %xmm0,%xmm7
movlhps %xmm1,%xmm7
movss  0x4(%rsi),%xmm2
movss  0x8(%rsi),%xmm1
movss  0xc(%rsi),%xmm8
movss  (%rcx),%xmm0
movss  0x4(%rcx),%xmm4
movss  0x8(%rcx),%xmm10
movss  0xc(%rcx),%xmm9
shufps $0x0,%xmm0,%xmm0
mulps  %xmm0,%xmm7
addps  %xmm6,%xmm7
mulps  %xmm3,%xmm0
addps  %xmm5,%xmm0
movss  0x34(%rsi),%xmm3
movss  0x24(%rsi),%xmm5
unpcklps %xmm3,%xmm5
movss  0x14(%rsi),%xmm3
unpcklps %xmm3,%xmm2
movlhps %xmm5,%xmm2
movss  0x74(%rsi),%xmm3
movss  0x64(%rsi),%xmm6
unpcklps %xmm3,%xmm6
movss  0x54(%rsi),%xmm3
movss  0x44(%rsi),%xmm5
unpcklps %xmm3,%xmm5
movlhps %xmm6,%xmm5
shufps $0x0,%xmm4,%xmm4
mulps  %xmm4,%xmm5
addps  %xmm0,%xmm5
mulps  %xmm2,%xmm4
addps  %xmm7,%xmm4
movss  0x78(%rsi),%xmm0
movss  0x68(%rsi),%xmm2
unpcklps %xmm0,%xmm2
movss  0x58(%rsi),%xmm0
movss  0x48(%rsi),%xmm3
unpcklps %xmm0,%xmm3
movlhps %xmm2,%xmm3
movss  0x38(%rsi),%xmm0
movss  0x28(%rsi),%xmm2
unpcklps %xmm0,%xmm2
movss  0x18(%rsi),%xmm0
unpcklps %xmm0,%xmm1
movlhps %xmm2,%xmm1
shufps $0x0,%xmm10,%xmm10
mulps  %xmm10,%xmm1
addps  %xmm4,%xmm1
mulps  %xmm3,%xmm10
addps  %xmm5,%xmm10
movss  0x3c(%rsi),%xmm0
movss  0x2c(%rsi),%xmm2
unpcklps %xmm0,%xmm2
movss  0x1c(%rsi),%xmm0
unpcklps %xmm0,%xmm8
movlhps %xmm2,%xmm8
movss  0x7c(%rsi),%xmm0
movss  0x6c(%rsi),%xmm2
unpcklps %xmm0,%xmm2
movss  0x5c(%rsi),%xmm0
movss  0x4c(%rsi),%xmm4
unpcklps %xmm0,%xmm4
movlhps %xmm2,%xmm4
shufps $0x0,%xmm9,%xmm9
mulps  %xmm9,%xmm4
addps  %xmm10,%xmm4
mulps  %xmm8,%xmm9
addps  %xmm1,%xmm9
lea    (%rsi,%rdx,1),%rsi
movss  0x70(%rbx,%rdx,1),%xmm0
movss  0x60(%rbx,%rdx,1),%xmm1
unpcklps %xmm0,%xmm1
movss  0x50(%rbx,%rdx,1),%xmm0
movss  0x40(%rbx,%rdx,1),%xmm6
unpcklps %xmm0,%xmm6
movlhps %xmm1,%xmm6
movss  0x30(%rbx,%rdx,1),%xmm0
movss  0x20(%rbx,%rdx,1),%xmm1
unpcklps %xmm0,%xmm1
movss  0x10(%rbx,%rdx,1),%xmm0
movss  (%rbx,%rdx,1),%xmm3
unpcklps %xmm0,%xmm3
movlhps %xmm1,%xmm3
movss  0x4(%rbx,%rdx,1),%xmm5
movss  0x8(%rbx,%rdx,1),%xmm1
movss  0xc(%rbx,%rdx,1),%xmm2
movss  0x10(%rcx),%xmm0
shufps $0x0,%xmm0,%xmm0
mulps  %xmm0,%xmm3
addps  %xmm9,%xmm3
mulps  %xmm6,%xmm0
addps  %xmm4,%xmm0
movss  0x34(%rbx,%rdx,1),%xmm4
movss  0x24(%rbx,%rdx,1),%xmm6
unpcklps %xmm4,%xmm6
movss  0x14(%rbx,%rdx,1),%xmm4
unpcklps %xmm4,%xmm5
movlhps %xmm6,%xmm5
movss  0x74(%rbx,%rdx,1),%xmm4
movss  0x64(%rbx,%rdx,1),%xmm6
unpcklps %xmm4,%xmm6
movss  0x54(%rbx,%rdx,1),%xmm7
movss  0x44(%rbx,%rdx,1),%xmm4
unpcklps %xmm7,%xmm4
movlhps %xmm6,%xmm4
movss  0x14(%rcx),%xmm6
shufps $0x0,%xmm6,%xmm6
mulps  %xmm6,%xmm4
addps  %xmm0,%xmm4
mulps  %xmm5,%xmm6
addps  %xmm3,%xmm6
movss  0x78(%rbx,%rdx,1),%xmm0
movss  0x68(%rbx,%rdx,1),%xmm3
unpcklps %xmm0,%xmm3
movss  0x58(%rbx,%rdx,1),%xmm0
movss  0x48(%rbx,%rdx,1),%xmm5
unpcklps %xmm0,%xmm5
movlhps %xmm3,%xmm5
movss  0x38(%rbx,%rdx,1),%xmm0
movss  0x28(%rbx,%rdx,1),%xmm3
unpcklps %xmm0,%xmm3
movss  0x18(%rbx,%rdx,1),%xmm0
unpcklps %xmm0,%xmm1
movlhps %xmm3,%xmm1
movss  0x18(%rcx),%xmm0
shufps $0x0,%xmm0,%xmm0
mulps  %xmm0,%xmm1
addps  %xmm6,%xmm1
mulps  %xmm5,%xmm0
addps  %xmm4,%xmm0
movss  0x3c(%rbx,%rdx,1),%xmm3
movss  0x2c(%rbx,%rdx,1),%xmm4
unpcklps %xmm3,%xmm4
movss  0x1c(%rbx,%rdx,1),%xmm3
unpcklps %xmm3,%xmm2
movlhps %xmm4,%xmm2
movss  0x7c(%rbx,%rdx,1),%xmm3
movss  0x6c(%rbx,%rdx,1),%xmm4
unpcklps %xmm3,%xmm4
movss  0x5c(%rbx,%rdx,1),%xmm5
movss  0x4c(%rbx,%rdx,1),%xmm3
unpcklps %xmm5,%xmm3
movlhps %xmm4,%xmm3
movss  0x1c(%rcx),%xmm4
shufps $0x0,%xmm4,%xmm4
mulps  %xmm4,%xmm3
movaps %xmm3,%xmm5
addps  %xmm0,%xmm5
mulps  %xmm2,%xmm4
movaps %xmm4,%xmm6
addps  %xmm1,%xmm6
add    $0x20,%rcx
add    $0x8,%eax
add    %rdx,%rsi
cmp    %edi,%eax
jl     1130 <kernel_strmv_u_t_8_lib4+0x30>
add    %r10,%rbx
addps  %xmm1,%xmm4
addps  %xmm0,%xmm3
mov    %rbx,%rsi
jmp    1404 <kernel_strmv_u_t_8_lib4+0x304>
xorps  %xmm3,%xmm3
movups (%rcx),%xmm0
movups 0x10(%rcx),%xmm8
movaps %xmm4,%xmm1
shufps $0x55,%xmm4,%xmm1
movss  0x10(%rsi),%xmm12
mulss  %xmm0,%xmm12
addss  %xmm1,%xmm12
movaps %xmm4,%xmm1
shufps $0xff,%xmm4,%xmm1
movss  0x30(%rsi),%xmm2
mulss  %xmm0,%xmm2
addss  %xmm1,%xmm2
movaps %xmm3,%xmm1
shufps $0x55,%xmm3,%xmm1
movss  0x50(%rsi),%xmm10
mulss  %xmm0,%xmm10
addss  %xmm1,%xmm10
movaps %xmm3,%xmm1
shufps $0xff,%xmm3,%xmm1
movss  0x70(%rsi),%xmm5
mulss  %xmm0,%xmm5
addss  %xmm1,%xmm5
movss  0x34(%rsi),%xmm11
movss  (%rsi),%xmm9
movss  0x14(%rsi),%xmm7
unpcklps %xmm7,%xmm9
movss  0x20(%rsi),%xmm1
unpcklps %xmm11,%xmm1
movss  0x24(%rsi),%xmm7
movaps %xmm4,%xmm6
unpckhpd %xmm4,%xmm6
unpcklps %xmm2,%xmm6
mulps  %xmm0,%xmm1
addps  %xmm6,%xmm1
movss  0x74(%rsi),%xmm2
movss  0x60(%rsi),%xmm6
unpcklps %xmm2,%xmm6
movaps %xmm3,%xmm2
unpckhpd %xmm3,%xmm2
unpcklps %xmm5,%xmm2
mulps  %xmm0,%xmm6
addps  %xmm2,%xmm6
movss  0x38(%rsi),%xmm2
unpcklps %xmm2,%xmm7
movaps %xmm0,%xmm2
shufps $0xe9,%xmm0,%xmm2
mulps  %xmm2,%xmm7
addps  %xmm1,%xmm7
movss  0x78(%rsi),%xmm5
movss  0x64(%rsi),%xmm1
unpcklps %xmm5,%xmm1
mulps  %xmm2,%xmm1
addps  %xmm6,%xmm1
movss  0x3c(%rsi),%xmm2
movss  0x28(%rsi),%xmm5
unpcklps %xmm2,%xmm5
movlhps %xmm5,%xmm9
movlhps %xmm4,%xmm12
shufps $0x42,%xmm7,%xmm12
mulps  %xmm0,%xmm9
addps  %xmm12,%xmm9
movss  0x7c(%rsi),%xmm2
movss  0x68(%rsi),%xmm4
unpcklps %xmm2,%xmm4
movss  0x54(%rsi),%xmm2
movss  0x40(%rsi),%xmm5
unpcklps %xmm2,%xmm5
movlhps %xmm4,%xmm5
movlhps %xmm3,%xmm10
shufps $0x42,%xmm1,%xmm10
mulps  %xmm0,%xmm5
addps  %xmm10,%xmm5
movss  0x70(%rsi,%r11,4),%xmm1
movss  0x6c(%rsi),%xmm2
unpcklps %xmm1,%xmm2
movss  0x58(%rsi),%xmm1
movss  0x44(%rsi),%xmm3
unpcklps %xmm1,%xmm3
movlhps %xmm2,%xmm3
movaps %xmm8,%xmm1
shufps $0x30,%xmm0,%xmm1
movaps %xmm0,%xmm2
shufps $0x29,%xmm1,%xmm2
mulps  %xmm3,%xmm2
addps  %xmm5,%xmm2
movss  0x74(%rsi,%r11,4),%xmm1
movss  0x40(%rsi,%r11,4),%xmm3
movss  0x50(%rsi,%r11,4),%xmm4
movss  0x54(%rsi,%r11,4),%xmm5
unpcklps %xmm5,%xmm3
movss  0x60(%rsi,%r11,4),%xmm5
unpcklps %xmm1,%xmm5
movss  0x5c(%rsi),%xmm1
movss  0x48(%rsi),%xmm6
unpcklps %xmm1,%xmm6
movlhps %xmm5,%xmm6
movaps %xmm0,%xmm1
shufps $0x4e,%xmm8,%xmm1
mulps  %xmm6,%xmm1
addps  %xmm2,%xmm1
movss  0x78(%rsi,%r11,4),%xmm2
movss  0x64(%rsi,%r11,4),%xmm5
unpcklps %xmm2,%xmm5
movss  0x4c(%rsi),%xmm2
unpcklps %xmm4,%xmm2
movlhps %xmm5,%xmm2
shufps $0x3,%xmm8,%xmm0
shufps $0x98,%xmm8,%xmm0
mulps  %xmm2,%xmm0
addps  %xmm1,%xmm0
movss  0x7c(%rsi,%r11,4),%xmm1
movss  0x68(%rsi,%r11,4),%xmm2
unpcklps %xmm1,%xmm2
movlhps %xmm2,%xmm3
mulps  %xmm8,%xmm3
addps  %xmm0,%xmm3
cmp    $0x1,%r9d
je     15fb <kernel_strmv_u_t_8_lib4+0x4fb>
test   %r9d,%r9d
jne    1616 <kernel_strmv_u_t_8_lib4+0x516>
movups %xmm9,(%r8)
jmp    160f <kernel_strmv_u_t_8_lib4+0x50f>
movups (%r8),%xmm0
movups 0x10(%r8),%xmm1
addps  %xmm0,%xmm9
movups %xmm9,(%r8)
addps  %xmm1,%xmm3
movups %xmm3,0x10(%r8)
pop    %rbx
ret
movups (%r8),%xmm0
movups 0x10(%r8),%xmm1
subps  %xmm9,%xmm0
movups %xmm0,(%r8)
subps  %xmm3,%xmm1
movups %xmm1,0x10(%r8)
pop    %rbx
ret

LLVM IR (-O0):
define void @kernel_strmv_u_t_8_lib4(i32 %0, float* %1, i32 %2, float* %3, float* %4, i32 %5) {
%7 = alloca i32
%8 = alloca float*
%9 = alloca i32
%10 = alloca float*
%11 = alloca float*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca float
%27 = alloca float
store i32 %0, i32* %7
store float* %1, float** %8
store i32 %2, i32* %9
store float* %3, float** %10
store float* %4, float** %11
store i32 %5, i32* %12
store i32 4, i32* %13
store i32 4, i32* %14
store float 0.000000e+00, float* %20
store float 0.000000e+00, float* %21
store float 0.000000e+00, float* %22
store float 0.000000e+00, float* %23
store float 0.000000e+00, float* %24
store float 0.000000e+00, float* %25
store float 0.000000e+00, float* %26
store float 0.000000e+00, float* %27
store i32 0, i32* %15
br label %28
28: ; preds = %456, %6
%29 = load i32, i32* %15
%30 = load i32, i32* %7
%31 = sub nsw i32 %30, 7
%32 = icmp slt i32 %29, %31
br i1 %32, label %33, label %459
33: ; preds = %28
%34 = load float*, float** %10
%35 = getelementptr inbounds float, float* %34, i64 0
%36 = load float, float* %35
store float %36, float* %16
%37 = load float*, float** %10
%38 = getelementptr inbounds float, float* %37, i64 1
%39 = load float, float* %38
store float %39, float* %17
%40 = load float*, float** %10
%41 = getelementptr inbounds float, float* %40, i64 2
%42 = load float, float* %41
store float %42, float* %18
%43 = load float*, float** %10
%44 = getelementptr inbounds float, float* %43, i64 3
%45 = load float, float* %44
store float %45, float* %19
%46 = load float*, float** %8
%47 = getelementptr inbounds float, float* %46, i64 0
%48 = load float, float* %47
%49 = load float, float* %16
%50 = load float, float* %20
%51 = call float @llvm.fmuladd.f32(float %48, float %49, float %50)
store float %51, float* %20
%52 = load float*, float** %8
%53 = getelementptr inbounds float, float* %52, i64 4
%54 = load float, float* %53
%55 = load float, float* %16
%56 = load float, float* %21
%57 = call float @llvm.fmuladd.f32(float %54, float %55, float %56)
store float %57, float* %21
%58 = load float*, float** %8
%59 = getelementptr inbounds float, float* %58, i64 8
%60 = load float, float* %59
%61 = load float, float* %16
%62 = load float, float* %22
%63 = call float @llvm.fmuladd.f32(float %60, float %61, float %62)
store float %63, float* %22
%64 = load float*, float** %8
%65 = getelementptr inbounds float, float* %64, i64 12
%66 = load float, float* %65
%67 = load float, float* %16
%68 = load float, float* %23
%69 = call float @llvm.fmuladd.f32(float %66, float %67, float %68)
store float %69, float* %23
%70 = load float*, float** %8
%71 = getelementptr inbounds float, float* %70, i64 16
%72 = load float, float* %71
%73 = load float, float* %16
%74 = load float, float* %24
%75 = call float @llvm.fmuladd.f32(float %72, float %73, float %74)
store float %75, float* %24
%76 = load float*, float** %8
%77 = getelementptr inbounds float, float* %76, i64 20
%78 = load float, float* %77
%79 = load float, float* %16
%80 = load float, float* %25
%81 = call float @llvm.fmuladd.f32(float %78, float %79, float %80)
store float %81, float* %25
%82 = load float*, float** %8
%83 = getelementptr inbounds float, float* %82, i64 24
%84 = load float, float* %83
%85 = load float, float* %16
%86 = load float, float* %26
%87 = call float @llvm.fmuladd.f32(float %84, float %85, float %86)
store float %87, float* %26
%88 = load float*, float** %8
%89 = getelementptr inbounds float, float* %88, i64 28
%90 = load float, float* %89
%91 = load float, float* %16
%92 = load float, float* %27
%93 = call float @llvm.fmuladd.f32(float %90, float %91, float %92)
store float %93, float* %27
%94 = load float*, float** %8
%95 = getelementptr inbounds float, float* %94, i64 1
%96 = load float, float* %95
%97 = load float, float* %17
%98 = load float, float* %20
%99 = call float @llvm.fmuladd.f32(float %96, float %97, float %98)
store float %99, float* %20
%100 = load float*, float** %8
%101 = getelementptr inbounds float, float* %100, i64 5
%102 = load float, float* %101
%103 = load float, float* %17
%104 = load float, float* %21
%105 = call float @llvm.fmuladd.f32(float %102, float %103, float %104)
store float %105, float* %21
%106 = load float*, float** %8
%107 = getelementptr inbounds float, float* %106, i64 9
%108 = load float, float* %107
%109 = load float, float* %17
%110 = load float, float* %22
%111 = call float @llvm.fmuladd.f32(float %108, float %109, float %110)
store float %111, float* %22
%112 = load float*, float** %8
%113 = getelementptr inbounds float, float* %112, i64 13
%114 = load float, float* %113
%115 = load float, float* %17
%116 = load float, float* %23
%117 = call float @llvm.fmuladd.f32(float %114, float %115, float %116)
store float %117, float* %23
%118 = load float*, float** %8
%119 = getelementptr inbounds float, float* %118, i64 17
%120 = load float, float* %119
%121 = load float, float* %17
%122 = load float, float* %24
%123 = call float @llvm.fmuladd.f32(float %120, float %121, float %122)
store float %123, float* %24
%124 = load float*, float** %8
%125 = getelementptr inbounds float, float* %124, i64 21
%126 = load float, float* %125
%127 = load float, float* %17
%128 = load float, float* %25
%129 = call float @llvm.fmuladd.f32(float %126, float %127, float %128)
store float %129, float* %25
%130 = load float*, float** %8
%131 = getelementptr inbounds float, float* %130, i64 25
%132 = load float, float* %131
%133 = load float, float* %17
%134 = load float, float* %26
%135 = call float @llvm.fmuladd.f32(float %132, float %133, float %134)
store float %135, float* %26
%136 = load float*, float** %8
%137 = getelementptr inbounds float, float* %136, i64 29
%138 = load float, float* %137
%139 = load float, float* %17
%140 = load float, float* %27
%141 = call float @llvm.fmuladd.f32(float %138, float %139, float %140)
store float %141, float* %27
%142 = load float*, float** %8
%143 = getelementptr inbounds float, float* %142, i64 2
%144 = load float, float* %143
%145 = load float, float* %18
%146 = load float, float* %20
%147 = call float @llvm.fmuladd.f32(float %144, float %145, float %146)
store float %147, float* %20
%148 = load float*, float** %8
%149 = getelementptr inbounds float, float* %148, i64 6
%150 = load float, float* %149
%151 = load float, float* %18
%152 = load float, float* %21
%153 = call float @llvm.fmuladd.f32(float %150, float %151, float %152)
store float %153, float* %21
%154 = load float*, float** %8
%155 = getelementptr inbounds float, float* %154, i64 10
%156 = load float, float* %155
%157 = load float, float* %18
%158 = load float, float* %22
%159 = call float @llvm.fmuladd.f32(float %156, float %157, float %158)
store float %159, float* %22
%160 = load float*, float** %8
%161 = getelementptr inbounds float, float* %160, i64 14
%162 = load float, float* %161
%163 = load float, float* %18
%164 = load float, float* %23
%165 = call float @llvm.fmuladd.f32(float %162, float %163, float %164)
store float %165, float* %23
%166 = load float*, float** %8
%167 = getelementptr inbounds float, float* %166, i64 18
%168 = load float, float* %167
%169 = load float, float* %18
%170 = load float, float* %24
%171 = call float @llvm.fmuladd.f32(float %168, float %169, float %170)
store float %171, float* %24
%172 = load float*, float** %8
%173 = getelementptr inbounds float, float* %172, i64 22
%174 = load float, float* %173
%175 = load float, float* %18
%176 = load float, float* %25
%177 = call float @llvm.fmuladd.f32(float %174, float %175, float %176)
store float %177, float* %25
%178 = load float*, float** %8
%179 = getelementptr inbounds float, float* %178, i64 26
%180 = load float, float* %179
%181 = load float, float* %18
%182 = load float, float* %26
%183 = call float @llvm.fmuladd.f32(float %180, float %181, float %182)
store float %183, float* %26
%184 = load float*, float** %8
%185 = getelementptr inbounds float, float* %184, i64 30
%186 = load float, float* %185
%187 = load float, float* %18
%188 = load float, float* %27
%189 = call float @llvm.fmuladd.f32(float %186, float %187, float %188)
store float %189, float* %27
%190 = load float*, float** %8
%191 = getelementptr inbounds float, float* %190, i64 3
%192 = load float, float* %191
%193 = load float, float* %19
%194 = load float, float* %20
%195 = call float @llvm.fmuladd.f32(float %192, float %193, float %194)
store float %195, float* %20
%196 = load float*, float** %8
%197 = getelementptr inbounds float, float* %196, i64 7
%198 = load float, float* %197
%199 = load float, float* %19
%200 = load float, float* %21
%201 = call float @llvm.fmuladd.f32(float %198, float %199, float %200)
store float %201, float* %21
%202 = load float*, float** %8
%203 = getelementptr inbounds float, float* %202, i64 11
%204 = load float, float* %203
%205 = load float, float* %19
%206 = load float, float* %22
%207 = call float @llvm.fmuladd.f32(float %204, float %205, float %206)
store float %207, float* %22
%208 = load float*, float** %8
%209 = getelementptr inbounds float, float* %208, i64 15
%210 = load float, float* %209
%211 = load float, float* %19
%212 = load float, float* %23
%213 = call float @llvm.fmuladd.f32(float %210, float %211, float %212)
store float %213, float* %23
%214 = load float*, float** %8
%215 = getelementptr inbounds float, float* %214, i64 19
%216 = load float, float* %215
%217 = load float, float* %19
%218 = load float, float* %24
%219 = call float @llvm.fmuladd.f32(float %216, float %217, float %218)
store float %219, float* %24
%220 = load float*, float** %8
%221 = getelementptr inbounds float, float* %220, i64 23
%222 = load float, float* %221
%223 = load float, float* %19
%224 = load float, float* %25
%225 = call float @llvm.fmuladd.f32(float %222, float %223, float %224)
store float %225, float* %25
%226 = load float*, float** %8
%227 = getelementptr inbounds float, float* %226, i64 27
%228 = load float, float* %227
%229 = load float, float* %19
%230 = load float, float* %26
%231 = call float @llvm.fmuladd.f32(float %228, float %229, float %230)
store float %231, float* %26
%232 = load float*, float** %8
%233 = getelementptr inbounds float, float* %232, i64 31
%234 = load float, float* %233
%235 = load float, float* %19
%236 = load float, float* %27
%237 = call float @llvm.fmuladd.f32(float %234, float %235, float %236)
store float %237, float* %27
%238 = load i32, i32* %9
%239 = mul nsw i32 %238, 4
%240 = load float*, float** %8
%241 = sext i32 %239 to i64
%242 = getelementptr inbounds float, float* %240, i64 %241
store float* %242, float** %8
%243 = load float*, float** %10
%244 = getelementptr inbounds float, float* %243, i64 4
store float* %244, float** %10
%245 = load float*, float** %10
%246 = getelementptr inbounds float, float* %245, i64 0
%247 = load float, float* %246
store float %247, float* %16
%248 = load float*, float** %10
%249 = getelementptr inbounds float, float* %248, i64 1
%250 = load float, float* %249
store float %250, float* %17
%251 = load float*, float** %10
%252 = getelementptr inbounds float, float* %251, i64 2
%253 = load float, float* %252
store float %253, float* %18
%254 = load float*, float** %10
%255 = getelementptr inbounds float, float* %254, i64 3
%256 = load float, float* %255
store float %256, float* %19
%257 = load float*, float** %8
%258 = getelementptr inbounds float, float* %257, i64 0
%259 = load float, float* %258
%260 = load float, float* %16
%261 = load float, float* %20
%262 = call float @llvm.fmuladd.f32(float %259, float %260, float %261)
store float %262, float* %20
%263 = load float*, float** %8
%264 = getelementptr inbounds float, float* %263, i64 4
%265 = load float, float* %264
%266 = load float, float* %16
%267 = load float, float* %21
%268 = call float @llvm.fmuladd.f32(float %265, float %266, float %267)
store float %268, float* %21
%269 = load float*, float** %8
%270 = getelementptr inbounds float, float* %269, i64 8
%271 = load float, float* %270
%272 = load float, float* %16
%273 = load float, float* %22
%274 = call float @llvm.fmuladd.f32(float %271, float %272, float %273)
store float %274, float* %22
%275 = load float*, float** %8
%276 = getelementptr inbounds float, float* %275, i64 12
%277 = load float, float* %276
%278 = load float, float* %16
%279 = load float, float* %23
%280 = call float @llvm.fmuladd.f32(float %277, float %278, float %279)
store float %280, float* %23
%281 = load float*, float** %8
%282 = getelementptr inbounds float, float* %281, i64 16
%283 = load float, float* %282
%284 = load float, float* %16
%285 = load float, float* %24
%286 = call float @llvm.fmuladd.f32(float %283, float %284, float %285)
store float %286, float* %24
%287 = load float*, float** %8
%288 = getelementptr inbounds float, float* %287, i64 20
%289 = load float, float* %288
%290 = load float, float* %16
%291 = load float, float* %25
%292 = call float @llvm.fmuladd.f32(float %289, float %290, float %291)
store float %292, float* %25
%293 = load float*, float** %8
%294 = getelementptr inbounds float, float* %293, i64 24
%295 = load float, float* %294
%296 = load float, float* %16
%297 = load float, float* %26
%298 = call float @llvm.fmuladd.f32(float %295, float %296, float %297)
store float %298, float* %26
%299 = load float*, float** %8
%300 = getelementptr inbounds float, float* %299, i64 28
%301 = load float, float* %300
%302 = load float, float* %16
%303 = load float, float* %27
%304 = call float @llvm.fmuladd.f32(float %301, float %302, float %303)
store float %304, float* %27
%305 = load float*, float** %8
%306 = getelementptr inbounds float, float* %305, i64 1
%307 = load float, float* %306
%308 = load float, float* %17
%309 = load float, float* %20
%310 = call float @llvm.fmuladd.f32(float %307, float %308, float %309)
store float %310, float* %20
%311 = load float*, float** %8
%312 = getelementptr inbounds float, float* %311, i64 5
%313 = load float, float* %312
%314 = load float, float* %17
%315 = load float, float* %21
%316 = call float @llvm.fmuladd.f32(float %313, float %314, float %315)
store float %316, float* %21
%317 = load float*, float** %8
%318 = getelementptr inbounds float, float* %317, i64 9
%319 = load float, float* %318
%320 = load float, float* %17
%321 = load float, float* %22
%322 = call float @llvm.fmuladd.f32(float %319, float %320, float %321)
store float %322, float* %22
%323 = load float*, float** %8
%324 = getelementptr inbounds float, float* %323, i64 13
%325 = load float, float* %324
%326 = load float, float* %17
%327 = load float, float* %23
%328 = call float @llvm.fmuladd.f32(float %325, float %326, float %327)
store float %328, float* %23
%329 = load float*, float** %8
%330 = getelementptr inbounds float, float* %329, i64 17
%331 = load float, float* %330
%332 = load float, float* %17
%333 = load float, float* %24
%334 = call float @llvm.fmuladd.f32(float %331, float %332, float %333)
store float %334, float* %24
%335 = load float*, float** %8
%336 = getelementptr inbounds float, float* %335, i64 21
%337 = load float, float* %336
%338 = load float, float* %17
%339 = load float, float* %25
%340 = call float @llvm.fmuladd.f32(float %337, float %338, float %339)
store float %340, float* %25
%341 = load float*, float** %8
%342 = getelementptr inbounds float, float* %341, i64 25
%343 = load float, float* %342
%344 = load float, float* %17
%345 = load float, float* %26
%346 = call float @llvm.fmuladd.f32(float %343, float %344, float %345)
store float %346, float* %26
%347 = load float*, float** %8
%348 = getelementptr inbounds float, float* %347, i64 29
%349 = load float, float* %348
%350 = load float, float* %17
%351 = load float, float* %27
%352 = call float @llvm.fmuladd.f32(float %349, float %350, float %351)
store float %352, float* %27
%353 = load float*, float** %8
%354 = getelementptr inbounds float, float* %353, i64 2
%355 = load float, float* %354
%356 = load float, float* %18
%357 = load float, float* %20
%358 = call float @llvm.fmuladd.f32(float %355, float %356, float %357)
store float %358, float* %20
%359 = load float*, float** %8
%360 = getelementptr inbounds float, float* %359, i64 6
%361 = load float, float* %360
%362 = load float, float* %18
%363 = load float, float* %21
%364 = call float @llvm.fmuladd.f32(float %361, float %362, float %363)
store float %364, float* %21
%365 = load float*, float** %8
%366 = getelementptr inbounds float, float* %365, i64 10
%367 = load float, float* %366
%368 = load float, float* %18
%369 = load float, float* %22
%370 = call float @llvm.fmuladd.f32(float %367, float %368, float %369)
store float %370, float* %22
%371 = load float*, float** %8
%372 = getelementptr inbounds float, float* %371, i64 14
%373 = load float, float* %372
%374 = load float, float* %18
%375 = load float, float* %23
%376 = call float @llvm.fmuladd.f32(float %373, float %374, float %375)
store float %376, float* %23
%377 = load float*, float** %8
%378 = getelementptr inbounds float, float* %377, i64 18
%379 = load float, float* %378
%380 = load float, float* %18
%381 = load float, float* %24
%382 = call float @llvm.fmuladd.f32(float %379, float %380, float %381)
store float %382, float* %24
%383 = load float*, float** %8
%384 = getelementptr inbounds float, float* %383, i64 22
%385 = load float, float* %384
%386 = load float, float* %18
%387 = load float, float* %25
%388 = call float @llvm.fmuladd.f32(float %385, float %386, float %387)
store float %388, float* %25
%389 = load float*, float** %8
%390 = getelementptr inbounds float, float* %389, i64 26
%391 = load float, float* %390
%392 = load float, float* %18
%393 = load float, float* %26
%394 = call float @llvm.fmuladd.f32(float %391, float %392, float %393)
store float %394, float* %26
%395 = load float*, float** %8
%396 = getelementptr inbounds float, float* %395, i64 30
%397 = load float, float* %396
%398 = load float, float* %18
%399 = load float, float* %27
%400 = call float @llvm.fmuladd.f32(float %397, float %398, float %399)
store float %400, float* %27
%401 = load float*, float** %8
%402 = getelementptr inbounds float, float* %401, i64 3
%403 = load float, float* %402
%404 = load float, float* %19
%405 = load float, float* %20
%406 = call float @llvm.fmuladd.f32(float %403, float %404, float %405)
store float %406, float* %20
%407 = load float*, float** %8
%408 = getelementptr inbounds float, float* %407, i64 7
%409 = load float, float* %408
%410 = load float, float* %19
%411 = load float, float* %21
%412 = call float @llvm.fmuladd.f32(float %409, float %410, float %411)
store float %412, float* %21
%413 = load float*, float** %8
%414 = getelementptr inbounds float, float* %413, i64 11
%415 = load float, float* %414
%416 = load float, float* %19
%417 = load float, float* %22
%418 = call float @llvm.fmuladd.f32(float %415, float %416, float %417)
store float %418, float* %22
%419 = load float*, float** %8
%420 = getelementptr inbounds float, float* %419, i64 15
%421 = load float, float* %420
%422 = load float, float* %19
%423 = load float, float* %23
%424 = call float @llvm.fmuladd.f32(float %421, float %422, float %423)
store float %424, float* %23
%425 = load float*, float** %8
%426 = getelementptr inbounds float, float* %425, i64 19
%427 = load float, float* %426
%428 = load float, float* %19
%429 = load float, float* %24
%430 = call float @llvm.fmuladd.f32(float %427, float %428, float %429)
store float %430, float* %24
%431 = load float*, float** %8
%432 = getelementptr inbounds float, float* %431, i64 23
%433 = load float, float* %432
%434 = load float, float* %19
%435 = load float, float* %25
%436 = call float @llvm.fmuladd.f32(float %433, float %434, float %435)
store float %436, float* %25
%437 = load float*, float** %8
%438 = getelementptr inbounds float, float* %437, i64 27
%439 = load float, float* %438
%440 = load float, float* %19
%441 = load float, float* %26
%442 = call float @llvm.fmuladd.f32(float %439, float %440, float %441)
store float %442, float* %26
%443 = load float*, float** %8
%444 = getelementptr inbounds float, float* %443, i64 31
%445 = load float, float* %444
%446 = load float, float* %19
%447 = load float, float* %27
%448 = call float @llvm.fmuladd.f32(float %445, float %446, float %447)
store float %448, float* %27
%449 = load i32, i32* %9
%450 = mul nsw i32 %449, 4
%451 = load float*, float** %8
%452 = sext i32 %450 to i64
%453 = getelementptr inbounds float, float* %451, i64 %452
store float* %453, float** %8
%454 = load float*, float** %10
%455 = getelementptr inbounds float, float* %454, i64 4
store float* %455, float** %10
br label %456
456: ; preds = %33
%457 = load i32, i32* %15
%458 = add nsw i32 %457, 8
store i32 %458, i32* %15
br label %28
459: ; preds = %28
%460 = load float*, float** %10
%461 = getelementptr inbounds float, float* %460, i64 0
%462 = load float, float* %461
store float %462, float* %16
%463 = load float*, float** %10
%464 = getelementptr inbounds float, float* %463, i64 1
%465 = load float, float* %464
store float %465, float* %17
%466 = load float*, float** %10
%467 = getelementptr inbounds float, float* %466, i64 2
%468 = load float, float* %467
store float %468, float* %18
%469 = load float*, float** %10
%470 = getelementptr inbounds float, float* %469, i64 3
%471 = load float, float* %470
store float %471, float* %19
%472 = load float*, float** %8
%473 = getelementptr inbounds float, float* %472, i64 0
%474 = load float, float* %473
%475 = load float, float* %16
%476 = load float, float* %20
%477 = call float @llvm.fmuladd.f32(float %474, float %475, float %476)
store float %477, float* %20
%478 = load float*, float** %8
%479 = getelementptr inbounds float, float* %478, i64 4
%480 = load float, float* %479
%481 = load float, float* %16
%482 = load float, float* %21
%483 = call float @llvm.fmuladd.f32(float %480, float %481, float %482)
store float %483, float* %21
%484 = load float*, float** %8
%485 = getelementptr inbounds float, float* %484, i64 8
%486 = load float, float* %485
%487 = load float, float* %16
%488 = load float, float* %22
%489 = call float @llvm.fmuladd.f32(float %486, float %487, float %488)
store float %489, float* %22
%490 = load float*, float** %8
%491 = getelementptr inbounds float, float* %490, i64 12
%492 = load float, float* %491
%493 = load float, float* %16
%494 = load float, float* %23
%495 = call float @llvm.fmuladd.f32(float %492, float %493, float %494)
store float %495, float* %23
%496 = load float*, float** %8
%497 = getelementptr inbounds float, float* %496, i64 16
%498 = load float, float* %497
%499 = load float, float* %16
%500 = load float, float* %24
%501 = call float @llvm.fmuladd.f32(float %498, float %499, float %500)
store float %501, float* %24
%502 = load float*, float** %8
%503 = getelementptr inbounds float, float* %502, i64 20
%504 = load float, float* %503
%505 = load float, float* %16
%506 = load float, float* %25
%507 = call float @llvm.fmuladd.f32(float %504, float %505, float %506)
store float %507, float* %25
%508 = load float*, float** %8
%509 = getelementptr inbounds float, float* %508, i64 24
%510 = load float, float* %509
%511 = load float, float* %16
%512 = load float, float* %26
%513 = call float @llvm.fmuladd.f32(float %510, float %511, float %512)
store float %513, float* %26
%514 = load float*, float** %8
%515 = getelementptr inbounds float, float* %514, i64 28
%516 = load float, float* %515
%517 = load float, float* %16
%518 = load float, float* %27
%519 = call float @llvm.fmuladd.f32(float %516, float %517, float %518)
store float %519, float* %27
%520 = load float*, float** %8
%521 = getelementptr inbounds float, float* %520, i64 5
%522 = load float, float* %521
%523 = load float, float* %17
%524 = load float, float* %21
%525 = call float @llvm.fmuladd.f32(float %522, float %523, float %524)
store float %525, float* %21
%526 = load float*, float** %8
%527 = getelementptr inbounds float, float* %526, i64 9
%528 = load float, float* %527
%529 = load float, float* %17
%530 = load float, float* %22
%531 = call float @llvm.fmuladd.f32(float %528, float %529, float %530)
store float %531, float* %22
%532 = load float*, float** %8
%533 = getelementptr inbounds float, float* %532, i64 13
%534 = load float, float* %533
%535 = load float, float* %17
%536 = load float, float* %23
%537 = call float @llvm.fmuladd.f32(float %534, float %535, float %536)
store float %537, float* %23
%538 = load float*, float** %8
%539 = getelementptr inbounds float, float* %538, i64 17
%540 = load float, float* %539
%541 = load float, float* %17
%542 = load float, float* %24
%543 = call float @llvm.fmuladd.f32(float %540, float %541, float %542)
store float %543, float* %24
%544 = load float*, float** %8
%545 = getelementptr inbounds float, float* %544, i64 21
%546 = load float, float* %545
%547 = load float, float* %17
%548 = load float, float* %25
%549 = call float @llvm.fmuladd.f32(float %546, float %547, float %548)
store float %549, float* %25
%550 = load float*, float** %8
%551 = getelementptr inbounds float, float* %550, i64 25
%552 = load float, float* %551
%553 = load float, float* %17
%554 = load float, float* %26
%555 = call float @llvm.fmuladd.f32(float %552, float %553, float %554)
store float %555, float* %26
%556 = load float*, float** %8
%557 = getelementptr inbounds float, float* %556, i64 29
%558 = load float, float* %557
%559 = load float, float* %17
%560 = load float, float* %27
%561 = call float @llvm.fmuladd.f32(float %558, float %559, float %560)
store float %561, float* %27
%562 = load float*, float** %8
%563 = getelementptr inbounds float, float* %562, i64 10
%564 = load float, float* %563
%565 = load float, float* %18
%566 = load float, float* %22
%567 = call float @llvm.fmuladd.f32(float %564, float %565, float %566)
store float %567, float* %22
%568 = load float*, float** %8
%569 = getelementptr inbounds float, float* %568, i64 14
%570 = load float, float* %569
%571 = load float, float* %18
%572 = load float, float* %23
%573 = call float @llvm.fmuladd.f32(float %570, float %571, float %572)
store float %573, float* %23
%574 = load float*, float** %8
%575 = getelementptr inbounds float, float* %574, i64 18
%576 = load float, float* %575
%577 = load float, float* %18
%578 = load float, float* %24
%579 = call float @llvm.fmuladd.f32(float %576, float %577, float %578)
store float %579, float* %24
%580 = load float*, float** %8
%581 = getelementptr inbounds float, float* %580, i64 22
%582 = load float, float* %581
%583 = load float, float* %18
%584 = load float, float* %25
%585 = call float @llvm.fmuladd.f32(float %582, float %583, float %584)
store float %585, float* %25
%586 = load float*, float** %8
%587 = getelementptr inbounds float, float* %586, i64 26
%588 = load float, float* %587
%589 = load float, float* %18
%590 = load float, float* %26
%591 = call float @llvm.fmuladd.f32(float %588, float %589, float %590)
store float %591, float* %26
%592 = load float*, float** %8
%593 = getelementptr inbounds float, float* %592, i64 30
%594 = load float, float* %593
%595 = load float, float* %18
%596 = load float, float* %27
%597 = call float @llvm.fmuladd.f32(float %594, float %595, float %596)
store float %597, float* %27
%598 = load float*, float** %8
%599 = getelementptr inbounds float, float* %598, i64 15
%600 = load float, float* %599
%601 = load float, float* %19
%602 = load float, float* %23
%603 = call float @llvm.fmuladd.f32(float %600, float %601, float %602)
store float %603, float* %23
%604 = load float*, float** %8
%605 = getelementptr inbounds float, float* %604, i64 19
%606 = load float, float* %605
%607 = load float, float* %19
%608 = load float, float* %24
%609 = call float @llvm.fmuladd.f32(float %606, float %607, float %608)
store float %609, float* %24
%610 = load float*, float** %8
%611 = getelementptr inbounds float, float* %610, i64 23
%612 = load float, float* %611
%613 = load float, float* %19
%614 = load float, float* %25
%615 = call float @llvm.fmuladd.f32(float %612, float %613, float %614)
store float %615, float* %25
%616 = load float*, float** %8
%617 = getelementptr inbounds float, float* %616, i64 27
%618 = load float, float* %617
%619 = load float, float* %19
%620 = load float, float* %26
%621 = call float @llvm.fmuladd.f32(float %618, float %619, float %620)
store float %621, float* %26
%622 = load float*, float** %8
%623 = getelementptr inbounds float, float* %622, i64 31
%624 = load float, float* %623
%625 = load float, float* %19
%626 = load float, float* %27
%627 = call float @llvm.fmuladd.f32(float %624, float %625, float %626)
store float %627, float* %27
%628 = load i32, i32* %9
%629 = mul nsw i32 %628, 4
%630 = load float*, float** %8
%631 = sext i32 %629 to i64
%632 = getelementptr inbounds float, float* %630, i64 %631
store float* %632, float** %8
%633 = load float*, float** %10
%634 = getelementptr inbounds float, float* %633, i64 4
store float* %634, float** %10
%635 = load float*, float** %10
%636 = getelementptr inbounds float, float* %635, i64 0
%637 = load float, float* %636
store float %637, float* %16
%638 = load float*, float** %10
%639 = getelementptr inbounds float, float* %638, i64 1
%640 = load float, float* %639
store float %640, float* %17
%641 = load float*, float** %10
%642 = getelementptr inbounds float, float* %641, i64 2
%643 = load float, float* %642
store float %643, float* %18
%644 = load float*, float** %10
%645 = getelementptr inbounds float, float* %644, i64 3
%646 = load float, float* %645
store float %646, float* %19
%647 = load float*, float** %8
%648 = getelementptr inbounds float, float* %647, i64 16
%649 = load float, float* %648
%650 = load float, float* %16
%651 = load float, float* %24
%652 = call float @llvm.fmuladd.f32(float %649, float %650, float %651)
store float %652, float* %24
%653 = load float*, float** %8
%654 = getelementptr inbounds float, float* %653, i64 20
%655 = load float, float* %654
%656 = load float, float* %16
%657 = load float, float* %25
%658 = call float @llvm.fmuladd.f32(float %655, float %656, float %657)
store float %658, float* %25
%659 = load float*, float** %8
%660 = getelementptr inbounds float, float* %659, i64 24
%661 = load float, float* %660
%662 = load float, float* %16
%663 = load float, float* %26
%664 = call float @llvm.fmuladd.f32(float %661, float %662, float %663)
store float %664, float* %26
%665 = load float*, float** %8
%666 = getelementptr inbounds float, float* %665, i64 28
%667 = load float, float* %666
%668 = load float, float* %16
%669 = load float, float* %27
%670 = call float @llvm.fmuladd.f32(float %667, float %668, float %669)
store float %670, float* %27
%671 = load float*, float** %8
%672 = getelementptr inbounds float, float* %671, i64 21
%673 = load float, float* %672
%674 = load float, float* %17
%675 = load float, float* %25
%676 = call float @llvm.fmuladd.f32(float %673, float %674, float %675)
store float %676, float* %25
%677 = load float*, float** %8
%678 = getelementptr inbounds float, float* %677, i64 25
%679 = load float, float* %678
%680 = load float, float* %17
%681 = load float, float* %26
%682 = call float @llvm.fmuladd.f32(float %679, float %680, float %681)
store float %682, float* %26
%683 = load float*, float** %8
%684 = getelementptr inbounds float, float* %683, i64 29
%685 = load float, float* %684
%686 = load float, float* %17
%687 = load float, float* %27
%688 = call float @llvm.fmuladd.f32(float %685, float %686, float %687)
store float %688, float* %27
%689 = load float*, float** %8
%690 = getelementptr inbounds float, float* %689, i64 26
%691 = load float, float* %690
%692 = load float, float* %18
%693 = load float, float* %26
%694 = call float @llvm.fmuladd.f32(float %691, float %692, float %693)
store float %694, float* %26
%695 = load float*, float** %8
%696 = getelementptr inbounds float, float* %695, i64 30
%697 = load float, float* %696
%698 = load float, float* %18
%699 = load float, float* %27
%700 = call float @llvm.fmuladd.f32(float %697, float %698, float %699)
store float %700, float* %27
%701 = load float*, float** %8
%702 = getelementptr inbounds float, float* %701, i64 31
%703 = load float, float* %702
%704 = load float, float* %19
%705 = load float, float* %27
%706 = call float @llvm.fmuladd.f32(float %703, float %704, float %705)
store float %706, float* %27
%707 = load i32, i32* %12
%708 = icmp eq i32 %707, 0
br i1 %708, label %709, label %734
709: ; preds = %459
%710 = load float, float* %20
%711 = load float*, float** %11
%712 = getelementptr inbounds float, float* %711, i64 0
store float %710, float* %712
%713 = load float, float* %21
%714 = load float*, float** %11
%715 = getelementptr inbounds float, float* %714, i64 1
store float %713, float* %715
%716 = load float, float* %22
%717 = load float*, float** %11
%718 = getelementptr inbounds float, float* %717, i64 2
store float %716, float* %718
%719 = load float, float* %23
%720 = load float*, float** %11
%721 = getelementptr inbounds float, float* %720, i64 3
store float %719, float* %721
%722 = load float, float* %24
%723 = load float*, float** %11
%724 = getelementptr inbounds float, float* %723, i64 4
store float %722, float* %724
%725 = load float, float* %25
%726 = load float*, float** %11
%727 = getelementptr inbounds float, float* %726, i64 5
store float %725, float* %727
%728 = load float, float* %26
%729 = load float*, float** %11
%730 = getelementptr inbounds float, float* %729, i64 6
store float %728, float* %730
%731 = load float, float* %27
%732 = load float*, float** %11
%733 = getelementptr inbounds float, float* %732, i64 7
store float %731, float* %733
br label %820
734: ; preds = %459
%735 = load i32, i32* %12
%736 = icmp eq i32 %735, 1
br i1 %736, label %737, label %778
737: ; preds = %734
%738 = load float, float* %20
%739 = load float*, float** %11
%740 = getelementptr inbounds float, float* %739, i64 0
%741 = load float, float* %740
%742 = fadd float %741, %738
store float %742, float* %740
%743 = load float, float* %21
%744 = load float*, float** %11
%745 = getelementptr inbounds float, float* %744, i64 1
%746 = load float, float* %745
%747 = fadd float %746, %743
store float %747, float* %745
%748 = load float, float* %22
%749 = load float*, float** %11
%750 = getelementptr inbounds float, float* %749, i64 2
%751 = load float, float* %750
%752 = fadd float %751, %748
store float %752, float* %750
%753 = load float, float* %23
%754 = load float*, float** %11
%755 = getelementptr inbounds float, float* %754, i64 3
%756 = load float, float* %755
%757 = fadd float %756, %753
store float %757, float* %755
%758 = load float, float* %24
%759 = load float*, float** %11
%760 = getelementptr inbounds float, float* %759, i64 4
%761 = load float, float* %760
%762 = fadd float %761, %758
store float %762, float* %760
%763 = load float, float* %25
%764 = load float*, float** %11
%765 = getelementptr inbounds float, float* %764, i64 5
%766 = load float, float* %765
%767 = fadd float %766, %763
store float %767, float* %765
%768 = load float, float* %26
%769 = load float*, float** %11
%770 = getelementptr inbounds float, float* %769, i64 6
%771 = load float, float* %770
%772 = fadd float %771, %768
store float %772, float* %770
%773 = load float, float* %27
%774 = load float*, float** %11
%775 = getelementptr inbounds float, float* %774, i64 7
%776 = load float, float* %775
%777 = fadd float %776, %773
store float %777, float* %775
br label %819
778: ; preds = %734
%779 = load float, float* %20
%780 = load float*, float** %11
%781 = getelementptr inbounds float, float* %780, i64 0
%782 = load float, float* %781
%783 = fsub float %782, %779
store float %783, float* %781
%784 = load float, float* %21
%785 = load float*, float** %11
%786 = getelementptr inbounds float, float* %785, i64 1
%787 = load float, float* %786
%788 = fsub float %787, %784
store float %788, float* %786
%789 = load float, float* %22
%790 = load float*, float** %11
%791 = getelementptr inbounds float, float* %790, i64 2
%792 = load float, float* %791
%793 = fsub float %792, %789
store float %793, float* %791
%794 = load float, float* %23
%795 = load float*, float** %11
%796 = getelementptr inbounds float, float* %795, i64 3
%797 = load float, float* %796
%798 = fsub float %797, %794
store float %798, float* %796
%799 = load float, float* %24
%800 = load float*, float** %11
%801 = getelementptr inbounds float, float* %800, i64 4
%802 = load float, float* %801
%803 = fsub float %802, %799
store float %803, float* %801
%804 = load float, float* %25
%805 = load float*, float** %11
%806 = getelementptr inbounds float, float* %805, i64 5
%807 = load float, float* %806
%808 = fsub float %807, %804
store float %808, float* %806
%809 = load float, float* %26
%810 = load float*, float** %11
%811 = getelementptr inbounds float, float* %810, i64 6
%812 = load float, float* %811
%813 = fsub float %812, %809
store float %813, float* %811
%814 = load float, float* %27
%815 = load float*, float** %11
%816 = getelementptr inbounds float, float* %815, i64 7
%817 = load float, float* %816
%818 = fsub float %817, %814
store float %818, float* %816
br label %819
819: ; preds = %778, %737
br label %820
820: ; preds = %819, %709
ret void
}

LLVM IR (-O2):
define void @kernel_strmv_u_t_8_lib4(i32 %0, float* %1, i32 %2, float* nocapture %3, float* %4, i32 %5) {
%7 = add nsw i32 %0, -7
%8 = icmp sgt i32 %0, 7
%9 = shl nsw i32 %2, 2
%10 = sext i32 %9 to i64
br i1 %8, label %11, label %259
11: ; preds = %6, %11
%12 = phi i32 [ %248, %11 ], [ 0, %6 ]
%13 = phi float* [ %246, %11 ], [ %1, %6 ]
%14 = phi float* [ %247, %11 ], [ %3, %6 ]
%15 = phi <8 x float> [ %245, %11 ], [ zeroinitializer, %6 ]
%16 = load float, float* %14
%17 = getelementptr inbounds float, float* %14, i64 1
%18 = load float, float* %17
%19 = getelementptr inbounds float, float* %14, i64 2
%20 = load float, float* %19
%21 = getelementptr inbounds float, float* %14, i64 3
%22 = load float, float* %21
%23 = load float, float* %13
%24 = getelementptr inbounds float, float* %13, i64 4
%25 = load float, float* %24
%26 = getelementptr inbounds float, float* %13, i64 8
%27 = load float, float* %26
%28 = getelementptr inbounds float, float* %13, i64 12
%29 = load float, float* %28
%30 = getelementptr inbounds float, float* %13, i64 16
%31 = load float, float* %30
%32 = getelementptr inbounds float, float* %13, i64 20
%33 = load float, float* %32
%34 = getelementptr inbounds float, float* %13, i64 24
%35 = load float, float* %34
%36 = getelementptr inbounds float, float* %13, i64 28
%37 = load float, float* %36
%38 = insertelement <8 x float> poison, float %23, i64 0
%39 = insertelement <8 x float> %38, float %25, i64 1
%40 = insertelement <8 x float> %39, float %27, i64 2
%41 = insertelement <8 x float> %40, float %29, i64 3
%42 = insertelement <8 x float> %41, float %31, i64 4
%43 = insertelement <8 x float> %42, float %33, i64 5
%44 = insertelement <8 x float> %43, float %35, i64 6
%45 = insertelement <8 x float> %44, float %37, i64 7
%46 = insertelement <8 x float> poison, float %16, i64 0
%47 = shufflevector <8 x float> %46, <8 x float> poison, <8 x i32> zeroinitializer
%48 = call <8 x float> @llvm.fmuladd.v8f32(<8 x float> %45, <8 x float> %47, <8 x float> %15)
%49 = getelementptr inbounds float, float* %13, i64 1
%50 = load float, float* %49
%51 = getelementptr inbounds float, float* %13, i64 5
%52 = load float, float* %51
%53 = getelementptr inbounds float, float* %13, i64 9
%54 = load float, float* %53
%55 = getelementptr inbounds float, float* %13, i64 13
%56 = load float, float* %55
%57 = getelementptr inbounds float, float* %13, i64 17
%58 = load float, float* %57
%59 = getelementptr inbounds float, float* %13, i64 21
%60 = load float, float* %59
%61 = getelementptr inbounds float, float* %13, i64 25
%62 = load float, float* %61
%63 = getelementptr inbounds float, float* %13, i64 29
%64 = load float, float* %63
%65 = insertelement <8 x float> poison, float %50, i64 0
%66 = insertelement <8 x float> %65, float %52, i64 1
%67 = insertelement <8 x float> %66, float %54, i64 2
%68 = insertelement <8 x float> %67, float %56, i64 3
%69 = insertelement <8 x float> %68, float %58, i64 4
%70 = insertelement <8 x float> %69, float %60, i64 5
%71 = insertelement <8 x float> %70, float %62, i64 6
%72 = insertelement <8 x float> %71, float %64, i64 7
%73 = insertelement <8 x float> poison, float %18, i64 0
%74 = shufflevector <8 x float> %73, <8 x float> poison, <8 x i32> zeroinitializer
%75 = call <8 x float> @llvm.fmuladd.v8f32(<8 x float> %72, <8 x float> %74, <8 x float> %48)
%76 = getelementptr inbounds float, float* %13, i64 2
%77 = load float, float* %76
%78 = getelementptr inbounds float, float* %13, i64 6
%79 = load float, float* %78
%80 = getelementptr inbounds float, float* %13, i64 10
%81 = load float, float* %80
%82 = getelementptr inbounds float, float* %13, i64 14
%83 = load float, float* %82
%84 = getelementptr inbounds float, float* %13, i64 18
%85 = load float, float* %84
%86 = getelementptr inbounds float, float* %13, i64 22
%87 = load float, float* %86
%88 = getelementptr inbounds float, float* %13, i64 26
%89 = load float, float* %88
%90 = getelementptr inbounds float, float* %13, i64 30
%91 = load float, float* %90
%92 = insertelement <8 x float> poison, float %77, i64 0
%93 = insertelement <8 x float> %92, float %79, i64 1
%94 = insertelement <8 x float> %93, float %81, i64 2
%95 = insertelement <8 x float> %94, float %83, i64 3
%96 = insertelement <8 x float> %95, float %85, i64 4
%97 = insertelement <8 x float> %96, float %87, i64 5
%98 = insertelement <8 x float> %97, float %89, i64 6
%99 = insertelement <8 x float> %98, float %91, i64 7
%100 = insertelement <8 x float> poison, float %20, i64 0
%101 = shufflevector <8 x float> %100, <8 x float> poison, <8 x i32> zeroinitializer
%102 = call <8 x float> @llvm.fmuladd.v8f32(<8 x float> %99, <8 x float> %101, <8 x float> %75)
%103 = getelementptr inbounds float, float* %13, i64 3
%104 = load float, float* %103
%105 = getelementptr inbounds float, float* %13, i64 7
%106 = load float, float* %105
%107 = getelementptr inbounds float, float* %13, i64 11
%108 = load float, float* %107
%109 = getelementptr inbounds float, float* %13, i64 15
%110 = load float, float* %109
%111 = getelementptr inbounds float, float* %13, i64 19
%112 = load float, float* %111
%113 = getelementptr inbounds float, float* %13, i64 23
%114 = load float, float* %113
%115 = getelementptr inbounds float, float* %13, i64 27
%116 = load float, float* %115
%117 = getelementptr inbounds float, float* %13, i64 31
%118 = load float, float* %117
%119 = insertelement <8 x float> poison, float %104, i64 0
%120 = insertelement <8 x float> %119, float %106, i64 1
%121 = insertelement <8 x float> %120, float %108, i64 2
%122 = insertelement <8 x float> %121, float %110, i64 3
%123 = insertelement <8 x float> %122, float %112, i64 4
%124 = insertelement <8 x float> %123, float %114, i64 5
%125 = insertelement <8 x float> %124, float %116, i64 6
%126 = insertelement <8 x float> %125, float %118, i64 7
%127 = insertelement <8 x float> poison, float %22, i64 0
%128 = shufflevector <8 x float> %127, <8 x float> poison, <8 x i32> zeroinitializer
%129 = call <8 x float> @llvm.fmuladd.v8f32(<8 x float> %126, <8 x float> %128, <8 x float> %102)
%130 = getelementptr inbounds float, float* %13, i64 %10
%131 = getelementptr inbounds float, float* %14, i64 4
%132 = load float, float* %131
%133 = getelementptr inbounds float, float* %14, i64 5
%134 = load float, float* %133
%135 = getelementptr inbounds float, float* %14, i64 6
%136 = load float, float* %135
%137 = getelementptr inbounds float, float* %14, i64 7
%138 = load float, float* %137
%139 = load float, float* %130
%140 = getelementptr inbounds float, float* %130, i64 4
%141 = load float, float* %140
%142 = getelementptr inbounds float, float* %130, i64 8
%143 = load float, float* %142
%144 = getelementptr inbounds float, float* %130, i64 12
%145 = load float, float* %144
%146 = getelementptr inbounds float, float* %130, i64 16
%147 = load float, float* %146
%148 = getelementptr inbounds float, float* %130, i64 20
%149 = load float, float* %148
%150 = getelementptr inbounds float, float* %130, i64 24
%151 = load float, float* %150
%152 = getelementptr inbounds float, float* %130, i64 28
%153 = load float, float* %152
%154 = insertelement <8 x float> poison, float %139, i64 0
%155 = insertelement <8 x float> %154, float %141, i64 1
%156 = insertelement <8 x float> %155, float %143, i64 2
%157 = insertelement <8 x float> %156, float %145, i64 3
%158 = insertelement <8 x float> %157, float %147, i64 4
%159 = insertelement <8 x float> %158, float %149, i64 5
%160 = insertelement <8 x float> %159, float %151, i64 6
%161 = insertelement <8 x float> %160, float %153, i64 7
%162 = insertelement <8 x float> poison, float %132, i64 0
%163 = shufflevector <8 x float> %162, <8 x float> poison, <8 x i32> zeroinitializer
%164 = call <8 x float> @llvm.fmuladd.v8f32(<8 x float> %161, <8 x float> %163, <8 x float> %129)
%165 = getelementptr inbounds float, float* %130, i64 1
%166 = load float, float* %165
%167 = getelementptr inbounds float, float* %130, i64 5
%168 = load float, float* %167
%169 = getelementptr inbounds float, float* %130, i64 9
%170 = load float, float* %169
%171 = getelementptr inbounds float, float* %130, i64 13
%172 = load float, float* %171
%173 = getelementptr inbounds float, float* %130, i64 17
%174 = load float, float* %173
%175 = getelementptr inbounds float, float* %130, i64 21
%176 = load float, float* %175
%177 = getelementptr inbounds float, float* %130, i64 25
%178 = load float, float* %177
%179 = getelementptr inbounds float, float* %130, i64 29
%180 = load float, float* %179
%181 = insertelement <8 x float> poison, float %166, i64 0
%182 = insertelement <8 x float> %181, float %168, i64 1
%183 = insertelement <8 x float> %182, float %170, i64 2
%184 = insertelement <8 x float> %183, float %172, i64 3
%185 = insertelement <8 x float> %184, float %174, i64 4
%186 = insertelement <8 x float> %185, float %176, i64 5
%187 = insertelement <8 x float> %186, float %178, i64 6
%188 = insertelement <8 x float> %187, float %180, i64 7
%189 = insertelement <8 x float> poison, float %134, i64 0
%190 = shufflevector <8 x float> %189, <8 x float> poison, <8 x i32> zeroinitializer
%191 = call <8 x float> @llvm.fmuladd.v8f32(<8 x float> %188, <8 x float> %190, <8 x float> %164)
%192 = getelementptr inbounds float, float* %130, i64 2
%193 = load float, float* %192
%194 = getelementptr inbounds float, float* %130, i64 6
%195 = load float, float* %194
%196 = getelementptr inbounds float, float* %130, i64 10
%197 = load float, float* %196
%198 = getelementptr inbounds float, float* %130, i64 14
%199 = load float, float* %198
%200 = getelementptr inbounds float, float* %130, i64 18
%201 = load float, float* %200
%202 = getelementptr inbounds float, float* %130, i64 22
%203 = load float, float* %202
%204 = getelementptr inbounds float, float* %130, i64 26
%205 = load float, float* %204
%206 = getelementptr inbounds float, float* %130, i64 30
%207 = load float, float* %206
%208 = insertelement <8 x float> poison, float %193, i64 0
%209 = insertelement <8 x float> %208, float %195, i64 1
%210 = insertelement <8 x float> %209, float %197, i64 2
%211 = insertelement <8 x float> %210, float %199, i64 3
%212 = insertelement <8 x float> %211, float %201, i64 4
%213 = insertelement <8 x float> %212, float %203, i64 5
%214 = insertelement <8 x float> %213, float %205, i64 6
%215 = insertelement <8 x float> %214, float %207, i64 7
%216 = insertelement <8 x float> poison, float %136, i64 0
%217 = shufflevector <8 x float> %216, <8 x float> poison, <8 x i32> zeroinitializer
%218 = call <8 x float> @llvm.fmuladd.v8f32(<8 x float> %215, <8 x float> %217, <8 x float> %191)
%219 = getelementptr inbounds float, float* %130, i64 3
%220 = load float, float* %219
%221 = getelementptr inbounds float, float* %130, i64 7
%222 = load float, float* %221
%223 = getelementptr inbounds float, float* %130, i64 11
%224 = load float, float* %223
%225 = getelementptr inbounds float, float* %130, i64 15
%226 = load float, float* %225
%227 = getelementptr inbounds float, float* %130, i64 19
%228 = load float, float* %227
%229 = getelementptr inbounds float, float* %130, i64 23
%230 = load float, float* %229
%231 = getelementptr inbounds float, float* %130, i64 27
%232 = load float, float* %231
%233 = getelementptr inbounds float, float* %130, i64 31
%234 = load float, float* %233
%235 = insertelement <8 x float> poison, float %220, i64 0
%236 = insertelement <8 x float> %235, float %222, i64 1
%237 = insertelement <8 x float> %236, float %224, i64 2
%238 = insertelement <8 x float> %237, float %226, i64 3
%239 = insertelement <8 x float> %238, float %228, i64 4
%240 = insertelement <8 x float> %239, float %230, i64 5
%241 = insertelement <8 x float> %240, float %232, i64 6
%242 = insertelement <8 x float> %241, float %234, i64 7
%243 = insertelement <8 x float> poison, float %138, i64 0
%244 = shufflevector <8 x float> %243, <8 x float> poison, <8 x i32> zeroinitializer
%245 = call <8 x float> @llvm.fmuladd.v8f32(<8 x float> %242, <8 x float> %244, <8 x float> %218)
%246 = getelementptr inbounds float, float* %130, i64 %10
%247 = getelementptr inbounds float, float* %14, i64 8
%248 = add nuw nsw i32 %12, 8
%249 = icmp slt i32 %248, %7
br i1 %249, label %11, label %250
250: ; preds = %11
%251 = call <8 x float> @llvm.fmuladd.v8f32(<8 x float> %45, <8 x float> %47, <8 x float> %15)
%252 = call <8 x float> @llvm.fmuladd.v8f32(<8 x float> %72, <8 x float> %74, <8 x float> %251)
%253 = call <8 x float> @llvm.fmuladd.v8f32(<8 x float> %99, <8 x float> %101, <8 x float> %252)
%254 = call <8 x float> @llvm.fmuladd.v8f32(<8 x float> %126, <8 x float> %128, <8 x float> %253)
%255 = call <8 x float> @llvm.fmuladd.v8f32(<8 x float> %161, <8 x float> %163, <8 x float> %254)
%256 = call <8 x float> @llvm.fmuladd.v8f32(<8 x float> %188, <8 x float> %190, <8 x float> %255)
%257 = call <8 x float> @llvm.fmuladd.v8f32(<8 x float> %215, <8 x float> %217, <8 x float> %256)
%258 = call <8 x float> @llvm.fmuladd.v8f32(<8 x float> %242, <8 x float> %244, <8 x float> %257)
br label %259
259: ; preds = %250, %6
%260 = phi float* [ %3, %6 ], [ %247, %250 ]
%261 = phi float* [ %1, %6 ], [ %246, %250 ]
%262 = phi <8 x float> [ zeroinitializer, %6 ], [ %258, %250 ]
%263 = bitcast float* %260 to <4 x float>*
%264 = load <4 x float>, <4 x float>* %263
%265 = load float, float* %261
%266 = getelementptr inbounds float, float* %261, i64 4
%267 = load float, float* %266
%268 = extractelement <4 x float> %264, i64 0
%269 = extractelement <8 x float> %262, i64 1
%270 = tail call float @llvm.fmuladd.f32(float %267, float %268, float %269)
%271 = getelementptr inbounds float, float* %261, i64 8
%272 = load float, float* %271
%273 = extractelement <8 x float> %262, i64 2
%274 = getelementptr inbounds float, float* %261, i64 12
%275 = load float, float* %274
%276 = extractelement <8 x float> %262, i64 3
%277 = tail call float @llvm.fmuladd.f32(float %275, float %268, float %276)
%278 = getelementptr inbounds float, float* %261, i64 16
%279 = load float, float* %278
%280 = getelementptr inbounds float, float* %261, i64 20
%281 = load float, float* %280
%282 = extractelement <8 x float> %262, i64 5
%283 = tail call float @llvm.fmuladd.f32(float %281, float %268, float %282)
%284 = getelementptr inbounds float, float* %261, i64 24
%285 = load float, float* %284
%286 = extractelement <8 x float> %262, i64 6
%287 = getelementptr inbounds float, float* %261, i64 28
%288 = load float, float* %287
%289 = extractelement <8 x float> %262, i64 7
%290 = tail call float @llvm.fmuladd.f32(float %288, float %268, float %289)
%291 = getelementptr inbounds float, float* %261, i64 5
%292 = load float, float* %291
%293 = getelementptr inbounds float, float* %261, i64 9
%294 = load float, float* %293
%295 = getelementptr inbounds float, float* %261, i64 13
%296 = load float, float* %295
%297 = insertelement <2 x float> poison, float %272, i64 0
%298 = insertelement <2 x float> %297, float %296, i64 1
%299 = shufflevector <4 x float> %264, <4 x float> undef, <2 x i32> <i32 0, i32 1>
%300 = insertelement <2 x float> poison, float %273, i64 0
%301 = insertelement <2 x float> %300, float %277, i64 1
%302 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %298, <2 x float> %299, <2 x float> %301)
%303 = getelementptr inbounds float, float* %261, i64 17
%304 = load float, float* %303
%305 = getelementptr inbounds float, float* %261, i64 21
%306 = load float, float* %305
%307 = getelementptr inbounds float, float* %261, i64 25
%308 = load float, float* %307
%309 = getelementptr inbounds float, float* %261, i64 29
%310 = load float, float* %309
%311 = insertelement <2 x float> poison, float %285, i64 0
%312 = insertelement <2 x float> %311, float %310, i64 1
%313 = insertelement <2 x float> poison, float %286, i64 0
%314 = insertelement <2 x float> %313, float %290, i64 1
%315 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %312, <2 x float> %299, <2 x float> %314)
%316 = getelementptr inbounds float, float* %261, i64 10
%317 = load float, float* %316
%318 = getelementptr inbounds float, float* %261, i64 14
%319 = load float, float* %318
%320 = insertelement <2 x float> poison, float %294, i64 0
%321 = insertelement <2 x float> %320, float %319, i64 1
%322 = shufflevector <4 x float> %264, <4 x float> undef, <2 x i32> <i32 1, i32 2>
%323 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %321, <2 x float> %322, <2 x float> %302)
%324 = getelementptr inbounds float, float* %261, i64 18
%325 = load float, float* %324
%326 = getelementptr inbounds float, float* %261, i64 22
%327 = load float, float* %326
%328 = getelementptr inbounds float, float* %261, i64 26
%329 = load float, float* %328
%330 = getelementptr inbounds float, float* %261, i64 30
%331 = load float, float* %330
%332 = insertelement <2 x float> poison, float %308, i64 0
%333 = insertelement <2 x float> %332, float %331, i64 1
%334 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %333, <2 x float> %322, <2 x float> %315)
%335 = getelementptr inbounds float, float* %261, i64 15
%336 = load float, float* %335
%337 = insertelement <4 x float> poison, float %265, i64 0
%338 = insertelement <4 x float> %337, float %292, i64 1
%339 = insertelement <4 x float> %338, float %317, i64 2
%340 = insertelement <4 x float> %339, float %336, i64 3
%341 = extractelement <8 x float> %262, i64 0
%342 = insertelement <4 x float> poison, float %341, i64 0
%343 = insertelement <4 x float> %342, float %270, i64 1
%344 = shufflevector <2 x float> %323, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%345 = shufflevector <4 x float> %343, <4 x float> %344, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
%346 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %340, <4 x float> %264, <4 x float> %345)
%347 = getelementptr inbounds float, float* %261, i64 19
%348 = load float, float* %347
%349 = getelementptr inbounds float, float* %261, i64 23
%350 = load float, float* %349
%351 = getelementptr inbounds float, float* %261, i64 27
%352 = load float, float* %351
%353 = getelementptr inbounds float, float* %261, i64 31
%354 = load float, float* %353
%355 = insertelement <4 x float> poison, float %279, i64 0
%356 = insertelement <4 x float> %355, float %306, i64 1
%357 = insertelement <4 x float> %356, float %329, i64 2
%358 = insertelement <4 x float> %357, float %354, i64 3
%359 = extractelement <8 x float> %262, i64 4
%360 = insertelement <4 x float> poison, float %359, i64 0
%361 = insertelement <4 x float> %360, float %283, i64 1
%362 = shufflevector <2 x float> %334, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%363 = shufflevector <4 x float> %361, <4 x float> %362, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
%364 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %358, <4 x float> %264, <4 x float> %363)
%365 = getelementptr inbounds float, float* %261, i64 %10
%366 = getelementptr inbounds float, float* %260, i64 4
%367 = bitcast float* %366 to <4 x float>*
%368 = load <4 x float>, <4 x float>* %367
%369 = getelementptr inbounds float, float* %365, i64 16
%370 = load float, float* %369
%371 = getelementptr inbounds float, float* %365, i64 20
%372 = load float, float* %371
%373 = getelementptr inbounds float, float* %365, i64 24
%374 = load float, float* %373
%375 = getelementptr inbounds float, float* %365, i64 28
%376 = load float, float* %375
%377 = insertelement <4 x float> poison, float %304, i64 0
%378 = insertelement <4 x float> %377, float %327, i64 1
%379 = insertelement <4 x float> %378, float %352, i64 2
%380 = insertelement <4 x float> %379, float %376, i64 3
%381 = shufflevector <4 x float> %264, <4 x float> %368, <4 x i32> <i32 1, i32 2, i32 3, i32 4>
%382 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %380, <4 x float> %381, <4 x float> %364)
%383 = getelementptr inbounds float, float* %365, i64 21
%384 = load float, float* %383
%385 = getelementptr inbounds float, float* %365, i64 25
%386 = load float, float* %385
%387 = getelementptr inbounds float, float* %365, i64 29
%388 = load float, float* %387
%389 = insertelement <4 x float> poison, float %325, i64 0
%390 = insertelement <4 x float> %389, float %350, i64 1
%391 = insertelement <4 x float> %390, float %374, i64 2
%392 = insertelement <4 x float> %391, float %388, i64 3
%393 = shufflevector <4 x float> %264, <4 x float> %368, <4 x i32> <i32 2, i32 3, i32 4, i32 5>
%394 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %392, <4 x float> %393, <4 x float> %382)
%395 = getelementptr inbounds float, float* %365, i64 26
%396 = load float, float* %395
%397 = getelementptr inbounds float, float* %365, i64 30
%398 = load float, float* %397
%399 = insertelement <4 x float> poison, float %348, i64 0
%400 = insertelement <4 x float> %399, float %372, i64 1
%401 = insertelement <4 x float> %400, float %386, i64 2
%402 = insertelement <4 x float> %401, float %398, i64 3
%403 = shufflevector <4 x float> %264, <4 x float> %368, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%404 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %402, <4 x float> %403, <4 x float> %394)
%405 = getelementptr inbounds float, float* %365, i64 31
%406 = load float, float* %405
%407 = insertelement <4 x float> poison, float %370, i64 0
%408 = insertelement <4 x float> %407, float %384, i64 1
%409 = insertelement <4 x float> %408, float %396, i64 2
%410 = insertelement <4 x float> %409, float %406, i64 3
%411 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %410, <4 x float> %368, <4 x float> %404)
switch i32 %5, label %426 [
i32 0, label %412
i32 1, label %416
]
412: ; preds = %259
%413 = bitcast float* %4 to <4 x float>*
store <4 x float> %346, <4 x float>* %413
%414 = getelementptr inbounds float, float* %4, i64 4
%415 = bitcast float* %414 to <4 x float>*
store <4 x float> %411, <4 x float>* %415
br label %436
416: ; preds = %259
%417 = bitcast float* %4 to <4 x float>*
%418 = load <4 x float>, <4 x float>* %417
%419 = fadd <4 x float> %346, %418
%420 = bitcast float* %4 to <4 x float>*
store <4 x float> %419, <4 x float>* %420
%421 = getelementptr inbounds float, float* %4, i64 4
%422 = bitcast float* %421 to <4 x float>*
%423 = load <4 x float>, <4 x float>* %422
%424 = fadd <4 x float> %411, %423
%425 = bitcast float* %421 to <4 x float>*
store <4 x float> %424, <4 x float>* %425
br label %436
426: ; preds = %259
%427 = bitcast float* %4 to <4 x float>*
%428 = load <4 x float>, <4 x float>* %427
%429 = fsub <4 x float> %428, %346
%430 = bitcast float* %4 to <4 x float>*
store <4 x float> %429, <4 x float>* %430
%431 = getelementptr inbounds float, float* %4, i64 4
%432 = bitcast float* %431 to <4 x float>*
%433 = load <4 x float>, <4 x float>* %432
%434 = fsub <4 x float> %433, %411
%435 = bitcast float* %431 to <4 x float>*
store <4 x float> %434, <4 x float>* %435
br label %436
436: ; preds = %416, %426, %412
ret void
}