void kernel_strsv_t_3_lib4(int kmax, float *A, int sda, float *x) {
  if (kmax <= 0)
    return;
  const int lda = 4;
  const int bs = 4;
  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;
  x_3 = x[3];
  y_0 += A[3 + lda * 0] * x_3;
  y_1 += A[3 + lda * 1] * x_3;
  y_2 += A[3 + lda * 2] * x_3;
  k = 4;
  A += 4 + (sda - 1) * lda;
  x += 4;
  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_0 += A[1 + lda * 0] * x_1;
    y_1 += A[1 + lda * 1] * x_1;
    y_2 += A[1 + lda * 2] * 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_0 += A[3 + lda * 0] * x_3;
    y_1 += A[3 + lda * 1] * x_3;
    y_2 += A[3 + lda * 2] * 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_0 += A[1 + lda * 0] * x_1;
    y_1 += A[1 + lda * 1] * x_1;
    y_2 += A[1 + lda * 2] * 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_0 += A[3 + lda * 0] * x_3;
    y_1 += A[3 + lda * 1] * x_3;
    y_2 += A[3 + lda * 2] * x_3;
    A += sda * bs;
    x += 4;
  }
  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_0 += A[1 + lda * 0] * x_1;
    y_1 += A[1 + lda * 1] * x_1;
    y_2 += A[1 + lda * 2] * 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_0 += A[3 + lda * 0] * x_3;
    y_1 += A[3 + lda * 1] * x_3;
    y_2 += A[3 + lda * 2] * x_3;
    A += sda * bs;
    x += 4;
  }
  A = tA;
  x = tx;
  y_2 = x[2] - y_2;
  y_2 *= A[2 + lda * 2];
  x[2] = y_2;
  y_0 += A[2 + lda * 0] * y_2;
  y_1 += A[2 + lda * 1] * y_2;
  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_3_lib4>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
cmpl   $0x0,-0x4(%rbp)
jg     1121 <kernel_strsv_t_3_lib4+0x21>
jmp    18ce <kernel_strsv_t_3_lib4+0x7ce>
movl   $0x4,-0x24(%rbp)
movl   $0x4,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x40(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movl   $0x4,-0x2c(%rbp)
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x2,%ecx
add    $0x4,%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    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x4,%ecx
cmp    %ecx,%eax
jge    15c9 <kernel_strsv_t_3_lib4+0x4c9>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  (%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  0x10(%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  0x20(%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  0x4(%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  0x14(%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  0x24(%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  0x8(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%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,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  (%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  0x10(%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  0x20(%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  0x4(%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  0x14(%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  0x24(%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  0x8(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%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    -0x2c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x2c(%rbp)
jmp    11f6 <kernel_strsv_t_3_lib4+0xf6>
jmp    15ce <kernel_strsv_t_3_lib4+0x4ce>
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    17c2 <kernel_strsv_t_3_lib4+0x6c2>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  (%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  0x10(%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  0x20(%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  0x4(%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  0x14(%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  0x24(%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  0x8(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%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    -0x2c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x2c(%rbp)
jmp    15ce <kernel_strsv_t_3_lib4+0x4ce>
mov    -0x38(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
subss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
mulss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
subss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
mulss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x58(%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  -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  (%rax),%xmm0
mulss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_strsv_t_3_lib4>:
test   %edi,%edi
jle    1446 <kernel_strsv_t_3_lib4+0x346>
push   %rbp
push   %r14
push   %rbx
movss  0xc(%rcx),%xmm2
movss  0xc(%rsi),%xmm1
mulss  %xmm2,%xmm1
xorps  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x1c(%rsi),%xmm1
movss  0x2c(%rsi),%xmm3
unpcklps %xmm3,%xmm1
shufps $0x0,%xmm2,%xmm2
mulps  %xmm1,%xmm2
xorps  %xmm1,%xmm1
addps  %xmm2,%xmm1
shl    $0x2,%edx
movslq %edx,%r8
lea    (%rsi,%r8,4),%rbp
lea    0x10(%rcx),%rdx
mov    $0x4,%r9d
cmp    $0x9,%edi
jb     130d <kernel_strsv_t_3_lib4+0x20d>
lea    -0x4(%rdi),%r10d
lea    -0x9(%rdi),%r9d
and    $0xfffffff8,%r9d
lea    0x0(,%r8,8),%r11
lea    0x0(,%r8,4),%rbx
mov    $0x4,%r14d
nopw   0x0(%rax,%rax,1)
mov    %rbp,%rax
movss  (%rdx),%xmm5
movss  0x4(%rdx),%xmm4
movss  0x8(%rdx),%xmm2
movss  0xc(%rdx),%xmm3
movss  0x0(%rbp),%xmm7
mulss  %xmm5,%xmm7
addss  %xmm0,%xmm7
movss  0x20(%rbp),%xmm0
movss  0x10(%rbp),%xmm6
unpcklps %xmm0,%xmm6
movss  0x14(%rbp),%xmm0
movss  0x18(%rbp),%xmm9
movss  0x1c(%rbp),%xmm8
shufps $0x0,%xmm5,%xmm5
mulps  %xmm6,%xmm5
addps  %xmm1,%xmm5
movss  0x4(%rbp),%xmm1
mulss  %xmm4,%xmm1
addss  %xmm7,%xmm1
movss  0x24(%rbp),%xmm6
unpcklps %xmm6,%xmm0
shufps $0x0,%xmm4,%xmm4
mulps  %xmm0,%xmm4
addps  %xmm5,%xmm4
movss  0x8(%rbp),%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x28(%rbp),%xmm1
unpcklps %xmm1,%xmm9
shufps $0x0,%xmm2,%xmm2
mulps  %xmm9,%xmm2
addps  %xmm4,%xmm2
movss  0xc(%rbp),%xmm1
mulss  %xmm3,%xmm1
addss  %xmm0,%xmm1
movss  0x2c(%rbp),%xmm0
unpcklps %xmm0,%xmm8
shufps $0x0,%xmm3,%xmm3
mulps  %xmm8,%xmm3
addps  %xmm2,%xmm3
movss  0x10(%rdx),%xmm5
movss  0x14(%rdx),%xmm0
movss  0x18(%rdx),%xmm4
movss  0x1c(%rdx),%xmm2
lea    0x0(%rbp,%rbx,1),%rbp
movss  (%rax,%rbx,1),%xmm7
mulss  %xmm5,%xmm7
addss  %xmm1,%xmm7
movss  0x20(%rax,%rbx,1),%xmm1
movss  0x10(%rax,%rbx,1),%xmm6
unpcklps %xmm1,%xmm6
movss  0x14(%rax,%rbx,1),%xmm1
movss  0x18(%rax,%rbx,1),%xmm9
movss  0x1c(%rax,%rbx,1),%xmm8
shufps $0x0,%xmm5,%xmm5
mulps  %xmm6,%xmm5
addps  %xmm3,%xmm5
movss  0x4(%rax,%rbx,1),%xmm3
mulss  %xmm0,%xmm3
addss  %xmm7,%xmm3
movss  0x24(%rax,%rbx,1),%xmm6
unpcklps %xmm6,%xmm1
shufps $0x0,%xmm0,%xmm0
mulps  %xmm1,%xmm0
addps  %xmm5,%xmm0
movss  0x8(%rax,%rbx,1),%xmm1
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
movss  0x28(%rax,%rbx,1),%xmm3
unpcklps %xmm3,%xmm9
shufps $0x0,%xmm4,%xmm4
mulps  %xmm9,%xmm4
addps  %xmm0,%xmm4
movss  0xc(%rax,%rbx,1),%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x2c(%rax,%rbx,1),%xmm1
unpcklps %xmm1,%xmm8
shufps $0x0,%xmm2,%xmm2
mulps  %xmm8,%xmm2
movaps %xmm2,%xmm1
addps  %xmm4,%xmm1
add    $0x8,%r14d
add    $0x20,%rdx
add    %rbx,%rbp
cmp    %r10d,%r14d
jl     1180 <kernel_strsv_t_3_lib4+0x80>
add    %r11,%rax
addps  %xmm4,%xmm2
add    $0xc,%r9d
mov    %rax,%rbp
movaps %xmm2,%xmm1
cmp    %edi,%r9d
jge    13e6 <kernel_strsv_t_3_lib4+0x2e6>
add    $0x2c,%rbp
shl    $0x2,%r8
xchg   %ax,%ax
movss  (%rdx),%xmm6
movss  0x4(%rdx),%xmm4
movss  0x8(%rdx),%xmm3
movss  0xc(%rdx),%xmm2
movss  -0x2c(%rbp),%xmm7
mulss  %xmm6,%xmm7
addss  %xmm0,%xmm7
movss  -0xc(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm5
unpcklps %xmm0,%xmm5
movss  -0x18(%rbp),%xmm0
movss  -0x14(%rbp),%xmm9
movss  -0x10(%rbp),%xmm8
shufps $0x0,%xmm6,%xmm6
mulps  %xmm5,%xmm6
addps  %xmm1,%xmm6
movss  -0x28(%rbp),%xmm1
mulss  %xmm4,%xmm1
addss  %xmm7,%xmm1
movss  -0x8(%rbp),%xmm5
unpcklps %xmm5,%xmm0
shufps $0x0,%xmm4,%xmm4
mulps  %xmm0,%xmm4
addps  %xmm6,%xmm4
movss  -0x24(%rbp),%xmm5
mulss  %xmm3,%xmm5
addss  %xmm1,%xmm5
movss  -0x4(%rbp),%xmm0
unpcklps %xmm0,%xmm9
shufps $0x0,%xmm3,%xmm3
mulps  %xmm9,%xmm3
addps  %xmm4,%xmm3
movss  -0x20(%rbp),%xmm0
mulss  %xmm2,%xmm0
addss  %xmm5,%xmm0
movss  0x0(%rbp),%xmm1
unpcklps %xmm1,%xmm8
shufps $0x0,%xmm2,%xmm2
mulps  %xmm8,%xmm2
movaps %xmm2,%xmm1
addps  %xmm3,%xmm1
add    $0x4,%r9d
add    %r8,%rbp
add    $0x10,%rdx
cmp    %edi,%r9d
jl     1320 <kernel_strsv_t_3_lib4+0x220>
addps  %xmm3,%xmm2
movaps %xmm2,%xmm1
movss  0x8(%rcx),%xmm2
movaps %xmm1,%xmm3
shufps $0x55,%xmm1,%xmm3
subss  %xmm3,%xmm2
mulss  0x28(%rsi),%xmm2
movss  %xmm2,0x8(%rcx)
movss  0x8(%rsi),%xmm3
mulss  %xmm2,%xmm3
addss  %xmm0,%xmm3
mulss  0x18(%rsi),%xmm2
addss  %xmm1,%xmm2
movss  (%rcx),%xmm0
movss  0x4(%rcx),%xmm1
subss  %xmm2,%xmm1
mulss  0x14(%rsi),%xmm1
movss  %xmm1,0x4(%rcx)
mulss  0x4(%rsi),%xmm1
subss  %xmm1,%xmm0
subss  %xmm3,%xmm0
mulss  (%rsi),%xmm0
movss  %xmm0,(%rcx)
pop    %rbx
pop    %r14
pop    %rbp
ret

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

LLVM IR (-O2):
define void @kernel_strsv_t_3_lib4(i32 %0, float* nocapture %1, i32 %2, float* nocapture %3) {
%5 = icmp slt i32 %0, 1
br i1 %5, label %268, label %6
6: ; preds = %4
%7 = getelementptr inbounds float, float* %3, i64 3
%8 = load float, float* %7
%9 = getelementptr inbounds float, float* %1, i64 3
%10 = load float, float* %9
%11 = tail call float @llvm.fmuladd.f32(float %10, float %8, float 0.000000e+00)
%12 = getelementptr inbounds float, float* %1, i64 7
%13 = load float, float* %12
%14 = getelementptr inbounds float, float* %1, i64 11
%15 = load float, float* %14
%16 = insertelement <2 x float> poison, float %13, i64 0
%17 = insertelement <2 x float> %16, float %15, i64 1
%18 = insertelement <2 x float> poison, float %8, i64 0
%19 = shufflevector <2 x float> %18, <2 x float> poison, <2 x i32> zeroinitializer
%20 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %17, <2 x float> %19, <2 x float> zeroinitializer)
%21 = shl i32 %2, 2
%22 = sext i32 %21 to i64
%23 = add nsw i32 %0, -4
%24 = getelementptr inbounds float, float* %1, i64 %22
%25 = getelementptr inbounds float, float* %3, i64 4
%26 = icmp ugt i32 %0, 8
br i1 %26, label %27, label %40
27: ; preds = %6
%28 = add nsw i32 %0, -9
%29 = and i32 %28, -8
br label %47
30: ; preds = %47
%31 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %68, <2 x float> %70, <2 x float> %53)
%32 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %80, <2 x float> %82, <2 x float> %31)
%33 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %92, <2 x float> %94, <2 x float> %32)
%34 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %104, <2 x float> %106, <2 x float> %33)
%35 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %124, <2 x float> %126, <2 x float> %34)
%36 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %136, <2 x float> %138, <2 x float> %35)
%37 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %148, <2 x float> %150, <2 x float> %36)
%38 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %160, <2 x float> %162, <2 x float> %37)
%39 = add i32 %29, 12
br label %40
40: ; preds = %30, %6
%41 = phi i32 [ 4, %6 ], [ %39, %30 ]
%42 = phi float [ %11, %6 ], [ %154, %30 ]
%43 = phi float* [ %24, %6 ], [ %165, %30 ]
%44 = phi float* [ %25, %6 ], [ %166, %30 ]
%45 = phi <2 x float> [ %20, %6 ], [ %38, %30 ]
%46 = icmp slt i32 %41, %0
br i1 %46, label %168, label %237
47: ; preds = %27, %47
%48 = phi float* [ %166, %47 ], [ %25, %27 ]
%49 = phi float* [ %165, %47 ], [ %24, %27 ]
%50 = phi float [ %154, %47 ], [ %11, %27 ]
%51 = phi float* [ %109, %47 ], [ %3, %27 ]
%52 = phi i32 [ %164, %47 ], [ 4, %27 ]
%53 = phi <2 x float> [ %163, %47 ], [ %20, %27 ]
%54 = load float, float* %48
%55 = getelementptr inbounds float, float* %51, i64 5
%56 = load float, float* %55
%57 = getelementptr inbounds float, float* %51, i64 6
%58 = load float, float* %57
%59 = getelementptr inbounds float, float* %51, i64 7
%60 = load float, float* %59
%61 = load float, float* %49
%62 = tail call float @llvm.fmuladd.f32(float %61, float %54, float %50)
%63 = getelementptr inbounds float, float* %49, i64 4
%64 = load float, float* %63
%65 = getelementptr inbounds float, float* %49, i64 8
%66 = load float, float* %65
%67 = insertelement <2 x float> poison, float %64, i64 0
%68 = insertelement <2 x float> %67, float %66, i64 1
%69 = insertelement <2 x float> poison, float %54, i64 0
%70 = shufflevector <2 x float> %69, <2 x float> poison, <2 x i32> zeroinitializer
%71 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %68, <2 x float> %70, <2 x float> %53)
%72 = getelementptr inbounds float, float* %49, i64 1
%73 = load float, float* %72
%74 = tail call float @llvm.fmuladd.f32(float %73, float %56, float %62)
%75 = getelementptr inbounds float, float* %49, i64 5
%76 = load float, float* %75
%77 = getelementptr inbounds float, float* %49, i64 9
%78 = load float, float* %77
%79 = insertelement <2 x float> poison, float %76, i64 0
%80 = insertelement <2 x float> %79, float %78, i64 1
%81 = insertelement <2 x float> poison, float %56, i64 0
%82 = shufflevector <2 x float> %81, <2 x float> poison, <2 x i32> zeroinitializer
%83 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %80, <2 x float> %82, <2 x float> %71)
%84 = getelementptr inbounds float, float* %49, i64 2
%85 = load float, float* %84
%86 = tail call float @llvm.fmuladd.f32(float %85, float %58, float %74)
%87 = getelementptr inbounds float, float* %49, i64 6
%88 = load float, float* %87
%89 = getelementptr inbounds float, float* %49, i64 10
%90 = load float, float* %89
%91 = insertelement <2 x float> poison, float %88, i64 0
%92 = insertelement <2 x float> %91, float %90, i64 1
%93 = insertelement <2 x float> poison, float %58, i64 0
%94 = shufflevector <2 x float> %93, <2 x float> poison, <2 x i32> zeroinitializer
%95 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %92, <2 x float> %94, <2 x float> %83)
%96 = getelementptr inbounds float, float* %49, i64 3
%97 = load float, float* %96
%98 = tail call float @llvm.fmuladd.f32(float %97, float %60, float %86)
%99 = getelementptr inbounds float, float* %49, i64 7
%100 = load float, float* %99
%101 = getelementptr inbounds float, float* %49, i64 11
%102 = load float, float* %101
%103 = insertelement <2 x float> poison, float %100, i64 0
%104 = insertelement <2 x float> %103, float %102, i64 1
%105 = insertelement <2 x float> poison, float %60, i64 0
%106 = shufflevector <2 x float> %105, <2 x float> poison, <2 x i32> zeroinitializer
%107 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %104, <2 x float> %106, <2 x float> %95)
%108 = getelementptr inbounds float, float* %49, i64 %22
%109 = getelementptr inbounds float, float* %51, i64 8
%110 = load float, float* %109
%111 = getelementptr inbounds float, float* %51, i64 9
%112 = load float, float* %111
%113 = getelementptr inbounds float, float* %51, i64 10
%114 = load float, float* %113
%115 = getelementptr inbounds float, float* %51, i64 11
%116 = load float, float* %115
%117 = load float, float* %108
%118 = tail call float @llvm.fmuladd.f32(float %117, float %110, float %98)
%119 = getelementptr inbounds float, float* %108, i64 4
%120 = load float, float* %119
%121 = getelementptr inbounds float, float* %108, i64 8
%122 = load float, float* %121
%123 = insertelement <2 x float> poison, float %120, i64 0
%124 = insertelement <2 x float> %123, float %122, i64 1
%125 = insertelement <2 x float> poison, float %110, i64 0
%126 = shufflevector <2 x float> %125, <2 x float> poison, <2 x i32> zeroinitializer
%127 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %124, <2 x float> %126, <2 x float> %107)
%128 = getelementptr inbounds float, float* %108, i64 1
%129 = load float, float* %128
%130 = tail call float @llvm.fmuladd.f32(float %129, float %112, float %118)
%131 = getelementptr inbounds float, float* %108, i64 5
%132 = load float, float* %131
%133 = getelementptr inbounds float, float* %108, i64 9
%134 = load float, float* %133
%135 = insertelement <2 x float> poison, float %132, i64 0
%136 = insertelement <2 x float> %135, float %134, i64 1
%137 = insertelement <2 x float> poison, float %112, i64 0
%138 = shufflevector <2 x float> %137, <2 x float> poison, <2 x i32> zeroinitializer
%139 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %136, <2 x float> %138, <2 x float> %127)
%140 = getelementptr inbounds float, float* %108, i64 2
%141 = load float, float* %140
%142 = tail call float @llvm.fmuladd.f32(float %141, float %114, float %130)
%143 = getelementptr inbounds float, float* %108, i64 6
%144 = load float, float* %143
%145 = getelementptr inbounds float, float* %108, i64 10
%146 = load float, float* %145
%147 = insertelement <2 x float> poison, float %144, i64 0
%148 = insertelement <2 x float> %147, float %146, i64 1
%149 = insertelement <2 x float> poison, float %114, i64 0
%150 = shufflevector <2 x float> %149, <2 x float> poison, <2 x i32> zeroinitializer
%151 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %148, <2 x float> %150, <2 x float> %139)
%152 = getelementptr inbounds float, float* %108, i64 3
%153 = load float, float* %152
%154 = tail call float @llvm.fmuladd.f32(float %153, float %116, float %142)
%155 = getelementptr inbounds float, float* %108, i64 7
%156 = load float, float* %155
%157 = getelementptr inbounds float, float* %108, i64 11
%158 = load float, float* %157
%159 = insertelement <2 x float> poison, float %156, i64 0
%160 = insertelement <2 x float> %159, float %158, i64 1
%161 = insertelement <2 x float> poison, float %116, i64 0
%162 = shufflevector <2 x float> %161, <2 x float> poison, <2 x i32> zeroinitializer
%163 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %160, <2 x float> %162, <2 x float> %151)
%164 = add nuw nsw i32 %52, 8
%165 = getelementptr inbounds float, float* %108, i64 %22
%166 = getelementptr inbounds float, float* %51, i64 12
%167 = icmp slt i32 %164, %23
br i1 %167, label %47, label %30
168: ; preds = %40, %168
%169 = phi float [ %218, %168 ], [ %42, %40 ]
%170 = phi float* [ %228, %168 ], [ %43, %40 ]
%171 = phi float* [ %229, %168 ], [ %44, %40 ]
%172 = phi i32 [ %230, %168 ], [ %41, %40 ]
%173 = phi <2 x float> [ %227, %168 ], [ %45, %40 ]
%174 = load float, float* %171
%175 = getelementptr inbounds float, float* %171, i64 1
%176 = load float, float* %175
%177 = getelementptr inbounds float, float* %171, i64 2
%178 = load float, float* %177
%179 = getelementptr inbounds float, float* %171, i64 3
%180 = load float, float* %179
%181 = load float, float* %170
%182 = tail call float @llvm.fmuladd.f32(float %181, float %174, float %169)
%183 = getelementptr inbounds float, float* %170, i64 4
%184 = load float, float* %183
%185 = getelementptr inbounds float, float* %170, i64 8
%186 = load float, float* %185
%187 = insertelement <2 x float> poison, float %184, i64 0
%188 = insertelement <2 x float> %187, float %186, i64 1
%189 = insertelement <2 x float> poison, float %174, i64 0
%190 = shufflevector <2 x float> %189, <2 x float> poison, <2 x i32> zeroinitializer
%191 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %188, <2 x float> %190, <2 x float> %173)
%192 = getelementptr inbounds float, float* %170, i64 1
%193 = load float, float* %192
%194 = tail call float @llvm.fmuladd.f32(float %193, float %176, float %182)
%195 = getelementptr inbounds float, float* %170, i64 5
%196 = load float, float* %195
%197 = getelementptr inbounds float, float* %170, i64 9
%198 = load float, float* %197
%199 = insertelement <2 x float> poison, float %196, i64 0
%200 = insertelement <2 x float> %199, float %198, i64 1
%201 = insertelement <2 x float> poison, float %176, i64 0
%202 = shufflevector <2 x float> %201, <2 x float> poison, <2 x i32> zeroinitializer
%203 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %200, <2 x float> %202, <2 x float> %191)
%204 = getelementptr inbounds float, float* %170, i64 2
%205 = load float, float* %204
%206 = tail call float @llvm.fmuladd.f32(float %205, float %178, float %194)
%207 = getelementptr inbounds float, float* %170, i64 6
%208 = load float, float* %207
%209 = getelementptr inbounds float, float* %170, i64 10
%210 = load float, float* %209
%211 = insertelement <2 x float> poison, float %208, i64 0
%212 = insertelement <2 x float> %211, float %210, i64 1
%213 = insertelement <2 x float> poison, float %178, i64 0
%214 = shufflevector <2 x float> %213, <2 x float> poison, <2 x i32> zeroinitializer
%215 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %212, <2 x float> %214, <2 x float> %203)
%216 = getelementptr inbounds float, float* %170, i64 3
%217 = load float, float* %216
%218 = tail call float @llvm.fmuladd.f32(float %217, float %180, float %206)
%219 = getelementptr inbounds float, float* %170, i64 7
%220 = load float, float* %219
%221 = getelementptr inbounds float, float* %170, i64 11
%222 = load float, float* %221
%223 = insertelement <2 x float> poison, float %220, i64 0
%224 = insertelement <2 x float> %223, float %222, i64 1
%225 = insertelement <2 x float> poison, float %180, i64 0
%226 = shufflevector <2 x float> %225, <2 x float> poison, <2 x i32> zeroinitializer
%227 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %224, <2 x float> %226, <2 x float> %215)
%228 = getelementptr inbounds float, float* %170, i64 %22
%229 = getelementptr inbounds float, float* %171, i64 4
%230 = add nuw nsw i32 %172, 4
%231 = icmp slt i32 %230, %0
br i1 %231, label %168, label %232
232: ; preds = %168
%233 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %188, <2 x float> %190, <2 x float> %173)
%234 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %200, <2 x float> %202, <2 x float> %233)
%235 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %212, <2 x float> %214, <2 x float> %234)
%236 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %224, <2 x float> %226, <2 x float> %235)
br label %237
237: ; preds = %232, %40
%238 = phi float [ %42, %40 ], [ %218, %232 ]
%239 = phi <2 x float> [ %45, %40 ], [ %236, %232 ]
%240 = getelementptr inbounds float, float* %3, i64 2
%241 = load float, float* %240
%242 = extractelement <2 x float> %239, i64 1
%243 = fsub float %241, %242
%244 = getelementptr inbounds float, float* %1, i64 10
%245 = load float, float* %244
%246 = fmul float %243, %245
store float %246, float* %240
%247 = getelementptr inbounds float, float* %1, i64 2
%248 = load float, float* %247
%249 = tail call float @llvm.fmuladd.f32(float %248, float %246, float %238)
%250 = getelementptr inbounds float, float* %1, i64 6
%251 = load float, float* %250
%252 = extractelement <2 x float> %239, i64 0
%253 = tail call float @llvm.fmuladd.f32(float %251, float %246, float %252)
%254 = getelementptr inbounds float, float* %3, i64 1
%255 = load float, float* %254
%256 = fsub float %255, %253
%257 = getelementptr inbounds float, float* %1, i64 5
%258 = load float, float* %257
%259 = fmul float %256, %258
store float %259, float* %254
%260 = load float, float* %3
%261 = getelementptr inbounds float, float* %1, i64 1
%262 = load float, float* %261
%263 = fneg float %262
%264 = tail call float @llvm.fmuladd.f32(float %263, float %259, float %260)
%265 = fsub float %264, %249
%266 = load float, float* %1
%267 = fmul float %266, %265
store float %267, float* %3
br label %268
268: ; preds = %4, %237
ret void
}