void kernel_strsv_t_4_lib8(int kmax, int kna, float *A, int sda, float *x) {
  if (kmax <= 0)
    return;
  const int lda = 8;
  int k;
  float *tA, *tx;
  tA = A;
  tx = x;
  float x_0, x_1, x_2, x_3, y_0 = 0, y_1 = 0, y_2 = 0, y_3 = 0;
  k = 4;
  A += 4;
  x += 4;
  for (; k < 4 + kna - 3; k += 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_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_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_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;
    A += 4;
    x += 4;
  }
  A += (sda - 1) * lda;
  for (; k < kmax - 4; 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_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_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_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;
    x_0 = x[4];
    x_1 = x[5];
    x_2 = x[6];
    x_3 = x[7];
    y_0 += A[4 + lda * 0] * x_0;
    y_1 += A[4 + lda * 1] * x_0;
    y_2 += A[4 + lda * 2] * x_0;
    y_3 += A[4 + lda * 3] * x_0;
    y_0 += A[5 + lda * 0] * x_1;
    y_1 += A[5 + lda * 1] * x_1;
    y_2 += A[5 + lda * 2] * x_1;
    y_3 += A[5 + lda * 3] * x_1;
    y_0 += A[6 + lda * 0] * x_2;
    y_1 += A[6 + lda * 1] * x_2;
    y_2 += A[6 + lda * 2] * x_2;
    y_3 += A[6 + lda * 3] * x_2;
    y_0 += A[7 + lda * 0] * x_3;
    y_1 += A[7 + lda * 1] * x_3;
    y_2 += A[7 + lda * 2] * x_3;
    y_3 += A[7 + lda * 3] * x_3;
    A += sda * lda;
    x += 8;
  }
  for (; k < kmax; k += 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_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_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_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;
  }
  A = tA;
  x = tx;
  y_3 = x[3] - y_3;
  y_3 *= A[3 + lda * 3];
  x[3] = y_3;
  y_2 = x[2] - A[3 + lda * 2] * y_3 - y_2;
  y_2 *= A[2 + lda * 2];
  x[2] = y_2;
  y_0 += A[2 + lda * 0] * y_2 + A[3 + lda * 0] * y_3;
  y_1 += A[2 + lda * 1] * y_2 + A[3 + lda * 1] * y_3;
  y_1 = x[1] - y_1;
  y_1 *= A[1 + lda * 1];
  x[1] = y_1;
  y_0 = x[0] - A[1 + lda * 0] * y_1 - y_0;
  y_0 *= A[0 + lda * 0];
  x[0] = y_0;
}


x86 assembly (clang, -O0):
<kernel_strsv_t_4_lib8>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
cmpl   $0x0,-0x4(%rbp)
jg     1124 <kernel_strsv_t_4_lib8+0x24>
jmp    1c8a <kernel_strsv_t_4_lib8+0xb8a>
movl   $0x8,-0x24(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x38(%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)
movl   $0x4,-0x28(%rbp)
mov    -0x10(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    $0x4,%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    13ea <kernel_strsv_t_4_lib8+0x2ea>
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  0x20(%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  0x40(%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  0x60(%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  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  0x24(%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  0x44(%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  0x64(%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  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  0x28(%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  0x48(%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  0x68(%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  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  0x2c(%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  0x4c(%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  0x6c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x28(%rbp)
jmp    117a <kernel_strsv_t_4_lib8+0x7a>
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x3,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x4,%ecx
cmp    %ecx,%eax
jge    18b6 <kernel_strsv_t_4_lib8+0x7b6>
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  0x20(%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  0x40(%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  0x60(%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  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  0x24(%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  0x44(%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  0x64(%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  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  0x28(%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  0x48(%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  0x68(%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  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  0x2c(%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  0x4c(%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  0x6c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%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  0x30(%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  0x50(%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  0x70(%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  0x14(%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  0x34(%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  0x54(%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  0x74(%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  0x18(%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  0x38(%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  0x58(%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  0x78(%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  0x1c(%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  0x3c(%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  0x5c(%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  0x7c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x14(%rbp),%ecx
shl    $0x3,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x28(%rbp)
jmp    1405 <kernel_strsv_t_4_lib8+0x305>
jmp    18bb <kernel_strsv_t_4_lib8+0x7bb>
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1b0b <kernel_strsv_t_4_lib8+0xa0b>
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  0x20(%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  0x40(%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  0x60(%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  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  0x24(%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  0x44(%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  0x64(%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  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  0x28(%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  0x48(%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  0x68(%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  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  0x2c(%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  0x4c(%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  0x6c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x28(%rbp)
jmp    18bb <kernel_strsv_t_4_lib8+0x7bb>
mov    -0x30(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
subss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x6c(%rax),%xmm0
mulss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x4c(%rax),%xmm0
movss  -0x58(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
subss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x48(%rax),%xmm0
mulss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm1
mulss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm1
mulss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
subss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
subss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_strsv_t_4_lib8>:
test   %edi,%edi
jle    1536 <kernel_strsv_t_4_lib8+0x436>
lea    0x10(%r8),%r11
cmp    $0x4,%esi
jge    1122 <kernel_strsv_t_4_lib8+0x22>
xorps  %xmm0,%xmm0
mov    $0x4,%r9d
mov    %rdx,%rax
jmp    1200 <kernel_strsv_t_4_lib8+0x100>
xorps  %xmm4,%xmm4
mov    $0x4,%r9d
mov    %rdx,%rax
xchg   %ax,%ax
movss  0x70(%rax),%xmm0
movss  0x50(%rax),%xmm1
unpcklps %xmm0,%xmm1
movss  0x30(%rax),%xmm0
movss  0x10(%rax),%xmm5
unpcklps %xmm0,%xmm5
movlhps %xmm1,%xmm5
movss  0x14(%rax),%xmm0
movss  0x18(%rax),%xmm2
movss  0x1c(%rax),%xmm1
movss  (%r11),%xmm6
movss  0x4(%r11),%xmm3
shufps $0x0,%xmm6,%xmm6
mulps  %xmm5,%xmm6
addps  %xmm4,%xmm6
movss  0x74(%rax),%xmm4
movss  0x54(%rax),%xmm5
unpcklps %xmm4,%xmm5
movss  0x34(%rax),%xmm4
unpcklps %xmm4,%xmm0
movlhps %xmm5,%xmm0
shufps $0x0,%xmm3,%xmm3
mulps  %xmm0,%xmm3
addps  %xmm6,%xmm3
movss  0x78(%rax),%xmm5
movss  0x58(%rax),%xmm4
movss  0x38(%rax),%xmm0
movss  0x7c(%rax),%xmm8
movss  0x5c(%rax),%xmm6
movss  0x3c(%rax),%xmm7
lea    0x10(%rax),%rax
unpcklps %xmm5,%xmm4
movss  0x8(%r11),%xmm5
unpcklps %xmm0,%xmm2
movss  0xc(%r11),%xmm0
movlhps %xmm4,%xmm2
shufps $0x0,%xmm5,%xmm5
mulps  %xmm2,%xmm5
addps  %xmm3,%xmm5
unpcklps %xmm8,%xmm6
unpcklps %xmm7,%xmm1
movlhps %xmm6,%xmm1
shufps $0x0,%xmm0,%xmm0
mulps  %xmm1,%xmm0
movaps %xmm0,%xmm4
addps  %xmm5,%xmm4
add    $0x4,%r9d
add    $0x10,%r11
cmp    %esi,%r9d
jle    1130 <kernel_strsv_t_4_lib8+0x30>
addps  %xmm5,%xmm0
lea    -0x8(,%rcx,8),%esi
movslq %esi,%rsi
lea    (%rax,%rsi,4),%rsi
add    $0x10,%rsi
lea    -0x4(%rdi),%r10d
cmp    %r10d,%r9d
jge    13b7 <kernel_strsv_t_4_lib8+0x2b7>
shl    $0x3,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
nopl   0x0(%rax)
movss  0x60(%rsi),%xmm1
movss  0x40(%rsi),%xmm2
unpcklps %xmm1,%xmm2
movss  0x20(%rsi),%xmm1
movss  (%rsi),%xmm6
unpcklps %xmm1,%xmm6
movlhps %xmm2,%xmm6
movss  0x4(%rsi),%xmm7
movss  0x8(%rsi),%xmm4
movss  0xc(%rsi),%xmm8
movss  (%r11),%xmm2
movss  0x4(%r11),%xmm5
movss  0x8(%r11),%xmm3
movss  0xc(%r11),%xmm1
shufps $0x0,%xmm2,%xmm2
mulps  %xmm6,%xmm2
addps  %xmm0,%xmm2
movss  0x64(%rsi),%xmm0
movss  0x44(%rsi),%xmm6
unpcklps %xmm0,%xmm6
movss  0x24(%rsi),%xmm0
unpcklps %xmm0,%xmm7
movlhps %xmm6,%xmm7
shufps $0x0,%xmm5,%xmm5
mulps  %xmm7,%xmm5
addps  %xmm2,%xmm5
movss  0x68(%rsi),%xmm0
movss  0x48(%rsi),%xmm2
unpcklps %xmm0,%xmm2
movss  0x28(%rsi),%xmm0
unpcklps %xmm0,%xmm4
movlhps %xmm2,%xmm4
shufps $0x0,%xmm3,%xmm3
mulps  %xmm4,%xmm3
addps  %xmm5,%xmm3
movss  0x6c(%rsi),%xmm0
movss  0x4c(%rsi),%xmm2
unpcklps %xmm0,%xmm2
movss  0x2c(%rsi),%xmm0
unpcklps %xmm0,%xmm8
movlhps %xmm2,%xmm8
shufps $0x0,%xmm1,%xmm1
mulps  %xmm8,%xmm1
addps  %xmm3,%xmm1
movss  0x70(%rsi),%xmm0
movss  0x50(%rsi),%xmm2
unpcklps %xmm0,%xmm2
movss  0x30(%rsi),%xmm0
movss  0x10(%rsi),%xmm3
unpcklps %xmm0,%xmm3
movlhps %xmm2,%xmm3
movss  0x10(%r11),%xmm0
shufps $0x0,%xmm0,%xmm0
mulps  %xmm3,%xmm0
addps  %xmm1,%xmm0
movss  0x74(%rsi),%xmm1
movss  0x54(%rsi),%xmm2
unpcklps %xmm1,%xmm2
movss  0x34(%rsi),%xmm1
movss  0x14(%rsi),%xmm3
unpcklps %xmm1,%xmm3
movlhps %xmm2,%xmm3
movss  0x14(%r11),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm3,%xmm2
addps  %xmm0,%xmm2
movss  0x78(%rsi),%xmm0
movss  0x58(%rsi),%xmm1
unpcklps %xmm0,%xmm1
movss  0x38(%rsi),%xmm0
movss  0x18(%rsi),%xmm3
unpcklps %xmm0,%xmm3
movlhps %xmm1,%xmm3
movss  0x18(%r11),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm3,%xmm1
addps  %xmm2,%xmm1
movss  0x7c(%rsi),%xmm0
movss  0x5c(%rsi),%xmm2
unpcklps %xmm0,%xmm2
movss  0x3c(%rsi),%xmm0
movss  0x1c(%rsi),%xmm3
unpcklps %xmm0,%xmm3
movlhps %xmm2,%xmm3
movss  0x1c(%r11),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm3,%xmm2
movaps %xmm2,%xmm0
addps  %xmm1,%xmm0
add    $0x20,%r11
add    $0x8,%r9d
add    %rcx,%rsi
cmp    %r10d,%r9d
jl     1230 <kernel_strsv_t_4_lib8+0x130>
addps  %xmm1,%xmm2
movaps %xmm2,%xmm0
cmp    %edi,%r9d
jge    1491 <kernel_strsv_t_4_lib8+0x391>
movss  0x6c(%rsi),%xmm1
movss  0x4c(%rsi),%xmm2
unpcklps %xmm1,%xmm2
movss  0x2c(%rsi),%xmm1
movss  (%rsi),%xmm8
movss  0x4(%rsi),%xmm10
movss  0x8(%rsi),%xmm7
movss  0xc(%rsi),%xmm5
unpcklps %xmm1,%xmm5
movlhps %xmm2,%xmm5
movss  (%r11),%xmm2
movss  0x4(%r11),%xmm3
movss  0x8(%r11),%xmm4
movss  0xc(%r11),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm5,%xmm1
movss  0x68(%rsi),%xmm9
movss  0x48(%rsi),%xmm5
unpcklps %xmm9,%xmm5
movss  0x28(%rsi),%xmm6
unpcklps %xmm6,%xmm7
movlhps %xmm5,%xmm7
shufps $0x0,%xmm4,%xmm4
mulps  %xmm7,%xmm4
movss  0x64(%rsi),%xmm5
movss  0x44(%rsi),%xmm6
unpcklps %xmm5,%xmm6
movss  0x24(%rsi),%xmm5
unpcklps %xmm5,%xmm10
movlhps %xmm6,%xmm10
shufps $0x0,%xmm3,%xmm3
mulps  %xmm10,%xmm3
movss  0x60(%rsi),%xmm5
movss  0x40(%rsi),%xmm6
unpcklps %xmm5,%xmm6
movss  0x20(%rsi),%xmm5
unpcklps %xmm5,%xmm8
movlhps %xmm6,%xmm8
shufps $0x0,%xmm2,%xmm2
mulps  %xmm8,%xmm2
addps  %xmm2,%xmm0
addps  %xmm3,%xmm0
movaps %xmm0,%xmm5
addps  %xmm4,%xmm5
movaps %xmm1,%xmm0
addps  %xmm5,%xmm0
add    $0x4,%r9d
cmp    %edi,%r9d
jl     1470 <kernel_strsv_t_4_lib8+0x370>
addps  %xmm5,%xmm1
movaps %xmm1,%xmm0
movss  0xc(%r8),%xmm1
movaps %xmm0,%xmm2
shufps $0xff,%xmm0,%xmm2
subss  %xmm2,%xmm1
mulss  0x6c(%rdx),%xmm1
movss  %xmm1,0xc(%r8)
movss  0x8(%r8),%xmm2
movss  0x4c(%rdx),%xmm3
mulss  %xmm1,%xmm3
subss  %xmm3,%xmm2
movaps %xmm0,%xmm3
unpckhpd %xmm0,%xmm3
subss  %xmm3,%xmm2
mulss  0x48(%rdx),%xmm2
movss  %xmm2,0x8(%r8)
movss  0xc(%rdx),%xmm3
mulss  %xmm1,%xmm3
movss  0x8(%rdx),%xmm4
mulss  %xmm2,%xmm4
addss  %xmm3,%xmm4
addss  %xmm0,%xmm4
mulss  0x2c(%rdx),%xmm1
mulss  0x28(%rdx),%xmm2
addss  %xmm1,%xmm2
shufps $0x55,%xmm0,%xmm0
addss  %xmm2,%xmm0
movss  (%r8),%xmm1
movss  0x4(%r8),%xmm2
subss  %xmm0,%xmm2
mulss  0x24(%rdx),%xmm2
movss  %xmm2,0x4(%r8)
mulss  0x4(%rdx),%xmm2
subss  %xmm2,%xmm1
subss  %xmm4,%xmm1
mulss  (%rdx),%xmm1
movss  %xmm1,(%r8)
ret

LLVM IR (-O0):
define void @kernel_strsv_t_4_lib8(i32 %0, i32 %1, float* %2, i32 %3, float* %4) {
%6 = alloca i32
%7 = alloca i32
%8 = alloca float*
%9 = alloca i32
%10 = alloca float*
%11 = alloca i32
%12 = alloca i32
%13 = alloca float*
%14 = alloca float*
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
store i32 %0, i32* %6
store i32 %1, i32* %7
store float* %2, float** %8
store i32 %3, i32* %9
store float* %4, float** %10
%23 = load i32, i32* %6
%24 = icmp sle i32 %23, 0
br i1 %24, label %25, label %26
25: ; preds = %5
br label %602
26: ; preds = %5
store i32 8, i32* %11
%27 = load float*, float** %8
store float* %27, float** %13
%28 = load float*, float** %10
store float* %28, float** %14
store float 0.000000e+00, float* %19
store float 0.000000e+00, float* %20
store float 0.000000e+00, float* %21
store float 0.000000e+00, float* %22
store i32 4, i32* %12
%29 = load float*, float** %8
%30 = getelementptr inbounds float, float* %29, i64 4
store float* %30, float** %8
%31 = load float*, float** %10
%32 = getelementptr inbounds float, float* %31, i64 4
store float* %32, float** %10
br label %33
33: ; preds = %152, %26
%34 = load i32, i32* %12
%35 = load i32, i32* %7
%36 = add nsw i32 4, %35
%37 = sub nsw i32 %36, 3
%38 = icmp slt i32 %34, %37
br i1 %38, label %39, label %155
39: ; preds = %33
%40 = load float*, float** %10
%41 = getelementptr inbounds float, float* %40, i64 0
%42 = load float, float* %41
store float %42, float* %15
%43 = load float*, float** %10
%44 = getelementptr inbounds float, float* %43, i64 1
%45 = load float, float* %44
store float %45, float* %16
%46 = load float*, float** %10
%47 = getelementptr inbounds float, float* %46, i64 2
%48 = load float, float* %47
store float %48, float* %17
%49 = load float*, float** %10
%50 = getelementptr inbounds float, float* %49, i64 3
%51 = load float, float* %50
store float %51, float* %18
%52 = load float*, float** %8
%53 = getelementptr inbounds float, float* %52, i64 0
%54 = load float, float* %53
%55 = load float, float* %15
%56 = load float, float* %19
%57 = call float @llvm.fmuladd.f32(float %54, float %55, float %56)
store float %57, float* %19
%58 = load float*, float** %8
%59 = getelementptr inbounds float, float* %58, i64 8
%60 = load float, float* %59
%61 = load float, float* %15
%62 = load float, float* %20
%63 = call float @llvm.fmuladd.f32(float %60, float %61, float %62)
store float %63, float* %20
%64 = load float*, float** %8
%65 = getelementptr inbounds float, float* %64, i64 16
%66 = load float, float* %65
%67 = load float, float* %15
%68 = load float, float* %21
%69 = call float @llvm.fmuladd.f32(float %66, float %67, float %68)
store float %69, float* %21
%70 = load float*, float** %8
%71 = getelementptr inbounds float, float* %70, i64 24
%72 = load float, float* %71
%73 = load float, float* %15
%74 = load float, float* %22
%75 = call float @llvm.fmuladd.f32(float %72, float %73, float %74)
store float %75, float* %22
%76 = load float*, float** %8
%77 = getelementptr inbounds float, float* %76, i64 1
%78 = load float, float* %77
%79 = load float, float* %16
%80 = load float, float* %19
%81 = call float @llvm.fmuladd.f32(float %78, float %79, float %80)
store float %81, float* %19
%82 = load float*, float** %8
%83 = getelementptr inbounds float, float* %82, i64 9
%84 = load float, float* %83
%85 = load float, float* %16
%86 = load float, float* %20
%87 = call float @llvm.fmuladd.f32(float %84, float %85, float %86)
store float %87, float* %20
%88 = load float*, float** %8
%89 = getelementptr inbounds float, float* %88, i64 17
%90 = load float, float* %89
%91 = load float, float* %16
%92 = load float, float* %21
%93 = call float @llvm.fmuladd.f32(float %90, float %91, float %92)
store float %93, float* %21
%94 = load float*, float** %8
%95 = getelementptr inbounds float, float* %94, i64 25
%96 = load float, float* %95
%97 = load float, float* %16
%98 = load float, float* %22
%99 = call float @llvm.fmuladd.f32(float %96, float %97, float %98)
store float %99, float* %22
%100 = load float*, float** %8
%101 = getelementptr inbounds float, float* %100, i64 2
%102 = load float, float* %101
%103 = load float, float* %17
%104 = load float, float* %19
%105 = call float @llvm.fmuladd.f32(float %102, float %103, float %104)
store float %105, float* %19
%106 = load float*, float** %8
%107 = getelementptr inbounds float, float* %106, i64 10
%108 = load float, float* %107
%109 = load float, float* %17
%110 = load float, float* %20
%111 = call float @llvm.fmuladd.f32(float %108, float %109, float %110)
store float %111, float* %20
%112 = load float*, float** %8
%113 = getelementptr inbounds float, float* %112, i64 18
%114 = load float, float* %113
%115 = load float, float* %17
%116 = load float, float* %21
%117 = call float @llvm.fmuladd.f32(float %114, float %115, float %116)
store float %117, float* %21
%118 = load float*, float** %8
%119 = getelementptr inbounds float, float* %118, i64 26
%120 = load float, float* %119
%121 = load float, float* %17
%122 = load float, float* %22
%123 = call float @llvm.fmuladd.f32(float %120, float %121, float %122)
store float %123, float* %22
%124 = load float*, float** %8
%125 = getelementptr inbounds float, float* %124, i64 3
%126 = load float, float* %125
%127 = load float, float* %18
%128 = load float, float* %19
%129 = call float @llvm.fmuladd.f32(float %126, float %127, float %128)
store float %129, float* %19
%130 = load float*, float** %8
%131 = getelementptr inbounds float, float* %130, i64 11
%132 = load float, float* %131
%133 = load float, float* %18
%134 = load float, float* %20
%135 = call float @llvm.fmuladd.f32(float %132, float %133, float %134)
store float %135, float* %20
%136 = load float*, float** %8
%137 = getelementptr inbounds float, float* %136, i64 19
%138 = load float, float* %137
%139 = load float, float* %18
%140 = load float, float* %21
%141 = call float @llvm.fmuladd.f32(float %138, float %139, float %140)
store float %141, float* %21
%142 = load float*, float** %8
%143 = getelementptr inbounds float, float* %142, i64 27
%144 = load float, float* %143
%145 = load float, float* %18
%146 = load float, float* %22
%147 = call float @llvm.fmuladd.f32(float %144, float %145, float %146)
store float %147, float* %22
%148 = load float*, float** %8
%149 = getelementptr inbounds float, float* %148, i64 4
store float* %149, float** %8
%150 = load float*, float** %10
%151 = getelementptr inbounds float, float* %150, i64 4
store float* %151, float** %10
br label %152
152: ; preds = %39
%153 = load i32, i32* %12
%154 = add nsw i32 %153, 4
store i32 %154, i32* %12
br label %33
155: ; preds = %33
%156 = load i32, i32* %9
%157 = sub nsw i32 %156, 1
%158 = mul nsw i32 %157, 8
%159 = load float*, float** %8
%160 = sext i32 %158 to i64
%161 = getelementptr inbounds float, float* %159, i64 %160
store float* %161, float** %8
br label %162
162: ; preds = %391, %155
%163 = load i32, i32* %12
%164 = load i32, i32* %6
%165 = sub nsw i32 %164, 4
%166 = icmp slt i32 %163, %165
br i1 %166, label %167, label %394
167: ; preds = %162
%168 = load float*, float** %10
%169 = getelementptr inbounds float, float* %168, i64 0
%170 = load float, float* %169
store float %170, float* %15
%171 = load float*, float** %10
%172 = getelementptr inbounds float, float* %171, i64 1
%173 = load float, float* %172
store float %173, float* %16
%174 = load float*, float** %10
%175 = getelementptr inbounds float, float* %174, i64 2
%176 = load float, float* %175
store float %176, float* %17
%177 = load float*, float** %10
%178 = getelementptr inbounds float, float* %177, i64 3
%179 = load float, float* %178
store float %179, float* %18
%180 = load float*, float** %8
%181 = getelementptr inbounds float, float* %180, i64 0
%182 = load float, float* %181
%183 = load float, float* %15
%184 = load float, float* %19
%185 = call float @llvm.fmuladd.f32(float %182, float %183, float %184)
store float %185, float* %19
%186 = load float*, float** %8
%187 = getelementptr inbounds float, float* %186, i64 8
%188 = load float, float* %187
%189 = load float, float* %15
%190 = load float, float* %20
%191 = call float @llvm.fmuladd.f32(float %188, float %189, float %190)
store float %191, float* %20
%192 = load float*, float** %8
%193 = getelementptr inbounds float, float* %192, i64 16
%194 = load float, float* %193
%195 = load float, float* %15
%196 = load float, float* %21
%197 = call float @llvm.fmuladd.f32(float %194, float %195, float %196)
store float %197, float* %21
%198 = load float*, float** %8
%199 = getelementptr inbounds float, float* %198, i64 24
%200 = load float, float* %199
%201 = load float, float* %15
%202 = load float, float* %22
%203 = call float @llvm.fmuladd.f32(float %200, float %201, float %202)
store float %203, float* %22
%204 = load float*, float** %8
%205 = getelementptr inbounds float, float* %204, i64 1
%206 = load float, float* %205
%207 = load float, float* %16
%208 = load float, float* %19
%209 = call float @llvm.fmuladd.f32(float %206, float %207, float %208)
store float %209, float* %19
%210 = load float*, float** %8
%211 = getelementptr inbounds float, float* %210, i64 9
%212 = load float, float* %211
%213 = load float, float* %16
%214 = load float, float* %20
%215 = call float @llvm.fmuladd.f32(float %212, float %213, float %214)
store float %215, float* %20
%216 = load float*, float** %8
%217 = getelementptr inbounds float, float* %216, i64 17
%218 = load float, float* %217
%219 = load float, float* %16
%220 = load float, float* %21
%221 = call float @llvm.fmuladd.f32(float %218, float %219, float %220)
store float %221, float* %21
%222 = load float*, float** %8
%223 = getelementptr inbounds float, float* %222, i64 25
%224 = load float, float* %223
%225 = load float, float* %16
%226 = load float, float* %22
%227 = call float @llvm.fmuladd.f32(float %224, float %225, float %226)
store float %227, float* %22
%228 = load float*, float** %8
%229 = getelementptr inbounds float, float* %228, i64 2
%230 = load float, float* %229
%231 = load float, float* %17
%232 = load float, float* %19
%233 = call float @llvm.fmuladd.f32(float %230, float %231, float %232)
store float %233, float* %19
%234 = load float*, float** %8
%235 = getelementptr inbounds float, float* %234, i64 10
%236 = load float, float* %235
%237 = load float, float* %17
%238 = load float, float* %20
%239 = call float @llvm.fmuladd.f32(float %236, float %237, float %238)
store float %239, float* %20
%240 = load float*, float** %8
%241 = getelementptr inbounds float, float* %240, i64 18
%242 = load float, float* %241
%243 = load float, float* %17
%244 = load float, float* %21
%245 = call float @llvm.fmuladd.f32(float %242, float %243, float %244)
store float %245, float* %21
%246 = load float*, float** %8
%247 = getelementptr inbounds float, float* %246, i64 26
%248 = load float, float* %247
%249 = load float, float* %17
%250 = load float, float* %22
%251 = call float @llvm.fmuladd.f32(float %248, float %249, float %250)
store float %251, float* %22
%252 = load float*, float** %8
%253 = getelementptr inbounds float, float* %252, i64 3
%254 = load float, float* %253
%255 = load float, float* %18
%256 = load float, float* %19
%257 = call float @llvm.fmuladd.f32(float %254, float %255, float %256)
store float %257, float* %19
%258 = load float*, float** %8
%259 = getelementptr inbounds float, float* %258, i64 11
%260 = load float, float* %259
%261 = load float, float* %18
%262 = load float, float* %20
%263 = call float @llvm.fmuladd.f32(float %260, float %261, float %262)
store float %263, float* %20
%264 = load float*, float** %8
%265 = getelementptr inbounds float, float* %264, i64 19
%266 = load float, float* %265
%267 = load float, float* %18
%268 = load float, float* %21
%269 = call float @llvm.fmuladd.f32(float %266, float %267, float %268)
store float %269, float* %21
%270 = load float*, float** %8
%271 = getelementptr inbounds float, float* %270, i64 27
%272 = load float, float* %271
%273 = load float, float* %18
%274 = load float, float* %22
%275 = call float @llvm.fmuladd.f32(float %272, float %273, float %274)
store float %275, float* %22
%276 = load float*, float** %10
%277 = getelementptr inbounds float, float* %276, i64 4
%278 = load float, float* %277
store float %278, float* %15
%279 = load float*, float** %10
%280 = getelementptr inbounds float, float* %279, i64 5
%281 = load float, float* %280
store float %281, float* %16
%282 = load float*, float** %10
%283 = getelementptr inbounds float, float* %282, i64 6
%284 = load float, float* %283
store float %284, float* %17
%285 = load float*, float** %10
%286 = getelementptr inbounds float, float* %285, i64 7
%287 = load float, float* %286
store float %287, float* %18
%288 = load float*, float** %8
%289 = getelementptr inbounds float, float* %288, i64 4
%290 = load float, float* %289
%291 = load float, float* %15
%292 = load float, float* %19
%293 = call float @llvm.fmuladd.f32(float %290, float %291, float %292)
store float %293, float* %19
%294 = load float*, float** %8
%295 = getelementptr inbounds float, float* %294, i64 12
%296 = load float, float* %295
%297 = load float, float* %15
%298 = load float, float* %20
%299 = call float @llvm.fmuladd.f32(float %296, float %297, float %298)
store float %299, float* %20
%300 = load float*, float** %8
%301 = getelementptr inbounds float, float* %300, i64 20
%302 = load float, float* %301
%303 = load float, float* %15
%304 = load float, float* %21
%305 = call float @llvm.fmuladd.f32(float %302, float %303, float %304)
store float %305, float* %21
%306 = load float*, float** %8
%307 = getelementptr inbounds float, float* %306, i64 28
%308 = load float, float* %307
%309 = load float, float* %15
%310 = load float, float* %22
%311 = call float @llvm.fmuladd.f32(float %308, float %309, float %310)
store float %311, float* %22
%312 = load float*, float** %8
%313 = getelementptr inbounds float, float* %312, i64 5
%314 = load float, float* %313
%315 = load float, float* %16
%316 = load float, float* %19
%317 = call float @llvm.fmuladd.f32(float %314, float %315, float %316)
store float %317, float* %19
%318 = load float*, float** %8
%319 = getelementptr inbounds float, float* %318, i64 13
%320 = load float, float* %319
%321 = load float, float* %16
%322 = load float, float* %20
%323 = call float @llvm.fmuladd.f32(float %320, float %321, float %322)
store float %323, float* %20
%324 = load float*, float** %8
%325 = getelementptr inbounds float, float* %324, i64 21
%326 = load float, float* %325
%327 = load float, float* %16
%328 = load float, float* %21
%329 = call float @llvm.fmuladd.f32(float %326, float %327, float %328)
store float %329, float* %21
%330 = load float*, float** %8
%331 = getelementptr inbounds float, float* %330, i64 29
%332 = load float, float* %331
%333 = load float, float* %16
%334 = load float, float* %22
%335 = call float @llvm.fmuladd.f32(float %332, float %333, float %334)
store float %335, float* %22
%336 = load float*, float** %8
%337 = getelementptr inbounds float, float* %336, i64 6
%338 = load float, float* %337
%339 = load float, float* %17
%340 = load float, float* %19
%341 = call float @llvm.fmuladd.f32(float %338, float %339, float %340)
store float %341, float* %19
%342 = load float*, float** %8
%343 = getelementptr inbounds float, float* %342, i64 14
%344 = load float, float* %343
%345 = load float, float* %17
%346 = load float, float* %20
%347 = call float @llvm.fmuladd.f32(float %344, float %345, float %346)
store float %347, float* %20
%348 = load float*, float** %8
%349 = getelementptr inbounds float, float* %348, i64 22
%350 = load float, float* %349
%351 = load float, float* %17
%352 = load float, float* %21
%353 = call float @llvm.fmuladd.f32(float %350, float %351, float %352)
store float %353, float* %21
%354 = load float*, float** %8
%355 = getelementptr inbounds float, float* %354, i64 30
%356 = load float, float* %355
%357 = load float, float* %17
%358 = load float, float* %22
%359 = call float @llvm.fmuladd.f32(float %356, float %357, float %358)
store float %359, float* %22
%360 = load float*, float** %8
%361 = getelementptr inbounds float, float* %360, i64 7
%362 = load float, float* %361
%363 = load float, float* %18
%364 = load float, float* %19
%365 = call float @llvm.fmuladd.f32(float %362, float %363, float %364)
store float %365, float* %19
%366 = load float*, float** %8
%367 = getelementptr inbounds float, float* %366, i64 15
%368 = load float, float* %367
%369 = load float, float* %18
%370 = load float, float* %20
%371 = call float @llvm.fmuladd.f32(float %368, float %369, float %370)
store float %371, float* %20
%372 = load float*, float** %8
%373 = getelementptr inbounds float, float* %372, i64 23
%374 = load float, float* %373
%375 = load float, float* %18
%376 = load float, float* %21
%377 = call float @llvm.fmuladd.f32(float %374, float %375, float %376)
store float %377, float* %21
%378 = load float*, float** %8
%379 = getelementptr inbounds float, float* %378, i64 31
%380 = load float, float* %379
%381 = load float, float* %18
%382 = load float, float* %22
%383 = call float @llvm.fmuladd.f32(float %380, float %381, float %382)
store float %383, float* %22
%384 = load i32, i32* %9
%385 = mul nsw i32 %384, 8
%386 = load float*, float** %8
%387 = sext i32 %385 to i64
%388 = getelementptr inbounds float, float* %386, i64 %387
store float* %388, float** %8
%389 = load float*, float** %10
%390 = getelementptr inbounds float, float* %389, i64 8
store float* %390, float** %10
br label %391
391: ; preds = %167
%392 = load i32, i32* %12
%393 = add nsw i32 %392, 8
store i32 %393, i32* %12
br label %162
394: ; preds = %162
br label %395
395: ; preds = %508, %394
%396 = load i32, i32* %12
%397 = load i32, i32* %6
%398 = icmp slt i32 %396, %397
br i1 %398, label %399, label %511
399: ; preds = %395
%400 = load float*, float** %10
%401 = getelementptr inbounds float, float* %400, i64 0
%402 = load float, float* %401
store float %402, float* %15
%403 = load float*, float** %10
%404 = getelementptr inbounds float, float* %403, i64 1
%405 = load float, float* %404
store float %405, float* %16
%406 = load float*, float** %10
%407 = getelementptr inbounds float, float* %406, i64 2
%408 = load float, float* %407
store float %408, float* %17
%409 = load float*, float** %10
%410 = getelementptr inbounds float, float* %409, i64 3
%411 = load float, float* %410
store float %411, float* %18
%412 = load float*, float** %8
%413 = getelementptr inbounds float, float* %412, i64 0
%414 = load float, float* %413
%415 = load float, float* %15
%416 = load float, float* %19
%417 = call float @llvm.fmuladd.f32(float %414, float %415, float %416)
store float %417, float* %19
%418 = load float*, float** %8
%419 = getelementptr inbounds float, float* %418, i64 8
%420 = load float, float* %419
%421 = load float, float* %15
%422 = load float, float* %20
%423 = call float @llvm.fmuladd.f32(float %420, float %421, float %422)
store float %423, float* %20
%424 = load float*, float** %8
%425 = getelementptr inbounds float, float* %424, i64 16
%426 = load float, float* %425
%427 = load float, float* %15
%428 = load float, float* %21
%429 = call float @llvm.fmuladd.f32(float %426, float %427, float %428)
store float %429, float* %21
%430 = load float*, float** %8
%431 = getelementptr inbounds float, float* %430, i64 24
%432 = load float, float* %431
%433 = load float, float* %15
%434 = load float, float* %22
%435 = call float @llvm.fmuladd.f32(float %432, float %433, float %434)
store float %435, float* %22
%436 = load float*, float** %8
%437 = getelementptr inbounds float, float* %436, i64 1
%438 = load float, float* %437
%439 = load float, float* %16
%440 = load float, float* %19
%441 = call float @llvm.fmuladd.f32(float %438, float %439, float %440)
store float %441, float* %19
%442 = load float*, float** %8
%443 = getelementptr inbounds float, float* %442, i64 9
%444 = load float, float* %443
%445 = load float, float* %16
%446 = load float, float* %20
%447 = call float @llvm.fmuladd.f32(float %444, float %445, float %446)
store float %447, float* %20
%448 = load float*, float** %8
%449 = getelementptr inbounds float, float* %448, i64 17
%450 = load float, float* %449
%451 = load float, float* %16
%452 = load float, float* %21
%453 = call float @llvm.fmuladd.f32(float %450, float %451, float %452)
store float %453, float* %21
%454 = load float*, float** %8
%455 = getelementptr inbounds float, float* %454, i64 25
%456 = load float, float* %455
%457 = load float, float* %16
%458 = load float, float* %22
%459 = call float @llvm.fmuladd.f32(float %456, float %457, float %458)
store float %459, float* %22
%460 = load float*, float** %8
%461 = getelementptr inbounds float, float* %460, i64 2
%462 = load float, float* %461
%463 = load float, float* %17
%464 = load float, float* %19
%465 = call float @llvm.fmuladd.f32(float %462, float %463, float %464)
store float %465, float* %19
%466 = load float*, float** %8
%467 = getelementptr inbounds float, float* %466, i64 10
%468 = load float, float* %467
%469 = load float, float* %17
%470 = load float, float* %20
%471 = call float @llvm.fmuladd.f32(float %468, float %469, float %470)
store float %471, float* %20
%472 = load float*, float** %8
%473 = getelementptr inbounds float, float* %472, i64 18
%474 = load float, float* %473
%475 = load float, float* %17
%476 = load float, float* %21
%477 = call float @llvm.fmuladd.f32(float %474, float %475, float %476)
store float %477, float* %21
%478 = load float*, float** %8
%479 = getelementptr inbounds float, float* %478, i64 26
%480 = load float, float* %479
%481 = load float, float* %17
%482 = load float, float* %22
%483 = call float @llvm.fmuladd.f32(float %480, float %481, float %482)
store float %483, float* %22
%484 = load float*, float** %8
%485 = getelementptr inbounds float, float* %484, i64 3
%486 = load float, float* %485
%487 = load float, float* %18
%488 = load float, float* %19
%489 = call float @llvm.fmuladd.f32(float %486, float %487, float %488)
store float %489, float* %19
%490 = load float*, float** %8
%491 = getelementptr inbounds float, float* %490, i64 11
%492 = load float, float* %491
%493 = load float, float* %18
%494 = load float, float* %20
%495 = call float @llvm.fmuladd.f32(float %492, float %493, float %494)
store float %495, float* %20
%496 = load float*, float** %8
%497 = getelementptr inbounds float, float* %496, i64 19
%498 = load float, float* %497
%499 = load float, float* %18
%500 = load float, float* %21
%501 = call float @llvm.fmuladd.f32(float %498, float %499, float %500)
store float %501, float* %21
%502 = load float*, float** %8
%503 = getelementptr inbounds float, float* %502, i64 27
%504 = load float, float* %503
%505 = load float, float* %18
%506 = load float, float* %22
%507 = call float @llvm.fmuladd.f32(float %504, float %505, float %506)
store float %507, float* %22
br label %508
508: ; preds = %399
%509 = load i32, i32* %12
%510 = add nsw i32 %509, 4
store i32 %510, i32* %12
br label %395
511: ; preds = %395
%512 = load float*, float** %13
store float* %512, float** %8
%513 = load float*, float** %14
store float* %513, float** %10
%514 = load float*, float** %10
%515 = getelementptr inbounds float, float* %514, i64 3
%516 = load float, float* %515
%517 = load float, float* %22
%518 = fsub float %516, %517
store float %518, float* %22
%519 = load float*, float** %8
%520 = getelementptr inbounds float, float* %519, i64 27
%521 = load float, float* %520
%522 = load float, float* %22
%523 = fmul float %522, %521
store float %523, float* %22
%524 = load float, float* %22
%525 = load float*, float** %10
%526 = getelementptr inbounds float, float* %525, i64 3
store float %524, float* %526
%527 = load float*, float** %10
%528 = getelementptr inbounds float, float* %527, i64 2
%529 = load float, float* %528
%530 = load float*, float** %8
%531 = getelementptr inbounds float, float* %530, i64 19
%532 = load float, float* %531
%533 = load float, float* %22
%534 = fneg float %532
%535 = call float @llvm.fmuladd.f32(float %534, float %533, float %529)
%536 = load float, float* %21
%537 = fsub float %535, %536
store float %537, float* %21
%538 = load float*, float** %8
%539 = getelementptr inbounds float, float* %538, i64 18
%540 = load float, float* %539
%541 = load float, float* %21
%542 = fmul float %541, %540
store float %542, float* %21
%543 = load float, float* %21
%544 = load float*, float** %10
%545 = getelementptr inbounds float, float* %544, i64 2
store float %543, float* %545
%546 = load float*, float** %8
%547 = getelementptr inbounds float, float* %546, i64 2
%548 = load float, float* %547
%549 = load float, float* %21
%550 = load float*, float** %8
%551 = getelementptr inbounds float, float* %550, i64 3
%552 = load float, float* %551
%553 = load float, float* %22
%554 = fmul float %552, %553
%555 = call float @llvm.fmuladd.f32(float %548, float %549, float %554)
%556 = load float, float* %19
%557 = fadd float %556, %555
store float %557, float* %19
%558 = load float*, float** %8
%559 = getelementptr inbounds float, float* %558, i64 10
%560 = load float, float* %559
%561 = load float, float* %21
%562 = load float*, float** %8
%563 = getelementptr inbounds float, float* %562, i64 11
%564 = load float, float* %563
%565 = load float, float* %22
%566 = fmul float %564, %565
%567 = call float @llvm.fmuladd.f32(float %560, float %561, float %566)
%568 = load float, float* %20
%569 = fadd float %568, %567
store float %569, float* %20
%570 = load float*, float** %10
%571 = getelementptr inbounds float, float* %570, i64 1
%572 = load float, float* %571
%573 = load float, float* %20
%574 = fsub float %572, %573
store float %574, float* %20
%575 = load float*, float** %8
%576 = getelementptr inbounds float, float* %575, i64 9
%577 = load float, float* %576
%578 = load float, float* %20
%579 = fmul float %578, %577
store float %579, float* %20
%580 = load float, float* %20
%581 = load float*, float** %10
%582 = getelementptr inbounds float, float* %581, i64 1
store float %580, float* %582
%583 = load float*, float** %10
%584 = getelementptr inbounds float, float* %583, i64 0
%585 = load float, float* %584
%586 = load float*, float** %8
%587 = getelementptr inbounds float, float* %586, i64 1
%588 = load float, float* %587
%589 = load float, float* %20
%590 = fneg float %588
%591 = call float @llvm.fmuladd.f32(float %590, float %589, float %585)
%592 = load float, float* %19
%593 = fsub float %591, %592
store float %593, float* %19
%594 = load float*, float** %8
%595 = getelementptr inbounds float, float* %594, i64 0
%596 = load float, float* %595
%597 = load float, float* %19
%598 = fmul float %597, %596
store float %598, float* %19
%599 = load float, float* %19
%600 = load float*, float** %10
%601 = getelementptr inbounds float, float* %600, i64 0
store float %599, float* %601
br label %602
602: ; preds = %511, %25
ret void
}

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