void kernel_strsv_lt_inv_3_lib4(int kmax, float *A, int sda, float *inv_diag_A,
                                float *x, float *y, float *z) {
  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;
  k = 3;
  if (kmax > 4) {
    x_3 = x[3];
    y_0 -= A[3 + bs * 0] * x_3;
    y_1 -= A[3 + bs * 1] * x_3;
    y_2 -= A[3 + bs * 2] * x_3;
    k = 4;
    A += 4 + (sda - 1) * bs;
    x += 4;
    for (; k < kmax - 3; k += 4) {
      x_0 = x[0];
      x_1 = x[1];
      x_2 = x[2];
      x_3 = x[3];
      y_0 -= A[0 + bs * 0] * x_0;
      y_1 -= A[0 + bs * 1] * x_0;
      y_2 -= A[0 + bs * 2] * x_0;
      y_0 -= A[1 + bs * 0] * x_1;
      y_1 -= A[1 + bs * 1] * x_1;
      y_2 -= A[1 + bs * 2] * x_1;
      y_0 -= A[2 + bs * 0] * x_2;
      y_1 -= A[2 + bs * 1] * x_2;
      y_2 -= A[2 + bs * 2] * x_2;
      y_0 -= A[3 + bs * 0] * x_3;
      y_1 -= A[3 + bs * 1] * x_3;
      y_2 -= A[3 + bs * 2] * x_3;
      A += sda * bs;
      x += 4;
    }
  } else {
    A += 3;
    x += 1;
  }
  for (; k < kmax; k++) {
    x_0 = x[0];
    y_0 -= A[0 + bs * 0] * x_0;
    y_1 -= A[0 + bs * 1] * x_0;
    y_2 -= A[0 + bs * 2] * x_0;
    A += 1;
    x += 1;
  }
  y_0 = y[0] + y_0;
  y_1 = y[1] + y_1;
  y_2 = y[2] + y_2;
  A = tA;
  x = tx;
  y_2 *= inv_diag_A[2];
  z[2] = y_2;
  y_0 -= A[2 + bs * 0] * y_2;
  y_1 -= A[2 + bs * 1] * y_2;
  y_1 *= inv_diag_A[1];
  z[1] = y_1;
  y_0 -= A[1 + bs * 0] * y_1;
  y_0 *= inv_diag_A[0];
  z[0] = y_0;
}


x86 assembly (clang, -O0):
<kernel_strsv_lt_inv_3_lib4>:
push   %rbp
mov    %rsp,%rbp
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x4,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x48(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
movl   $0x3,-0x38(%rbp)
cmpl   $0x4,-0x4(%rbp)
jle    14be <kernel_strsv_lt_inv_3_lib4+0x3be>
mov    -0x28(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movl   $0x4,-0x38(%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    -0x28(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    14b9 <kernel_strsv_lt_inv_3_lib4+0x3b9>
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x28(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%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    -0x28(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x38(%rbp)
jmp    1224 <kernel_strsv_lt_inv_3_lib4+0x124>
jmp    14d6 <kernel_strsv_lt_inv_3_lib4+0x3d6>
mov    -0x10(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x10(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
jmp    14db <kernel_strsv_lt_inv_3_lib4+0x3db>
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15a0 <kernel_strsv_lt_inv_3_lib4+0x4a0>
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x10(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    14db <kernel_strsv_lt_inv_3_lib4+0x3db>
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
addss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x30(%rbp),%rax
movss  0x4(%rax),%xmm0
addss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x30(%rbp),%rax
movss  0x8(%rax),%xmm0
addss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
mulss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x64(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x64(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x64(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
mulss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x60(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x60(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
mulss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_strsv_lt_inv_3_lib4>:
cmp    $0x5,%edi
jl     127a <kernel_strsv_lt_inv_3_lib4+0x17a>
movss  0xc(%r8),%xmm2
movss  0xc(%rsi),%xmm1
mulss  %xmm2,%xmm1
xorps  %xmm0,%xmm0
subss  %xmm1,%xmm0
movss  0x1c(%rsi),%xmm1
movss  0x2c(%rsi),%xmm3
unpcklps %xmm3,%xmm1
shufps $0x0,%xmm2,%xmm2
mulps  %xmm1,%xmm2
xorps  %xmm1,%xmm1
subps  %xmm2,%xmm1
shl    $0x2,%edx
movslq %edx,%r11
lea    (%rsi,%r11,4),%rax
add    $0x10,%r8
mov    $0x4,%edx
cmp    $0x8,%edi
jb     128d <kernel_strsv_lt_inv_3_lib4+0x18d>
lea    -0x3(%rdi),%r10d
shl    $0x2,%r11
mov    $0x4,%edx
movaps 0xe96(%rip),%xmm8
nopw   0x0(%rax,%rax,1)
movaps %xmm1,%xmm9
movss  (%r8),%xmm4
movss  0x4(%r8),%xmm7
movss  0x8(%r8),%xmm5
movss  0xc(%r8),%xmm11
movss  (%rax),%xmm2
mulss  %xmm4,%xmm2
subss  %xmm2,%xmm0
movss  0x20(%rax),%xmm2
movss  0x10(%rax),%xmm3
unpcklps %xmm2,%xmm3
movss  0x14(%rax),%xmm6
movss  0x18(%rax),%xmm12
movss  0x1c(%rax),%xmm10
shufps $0x0,%xmm4,%xmm4
movaps %xmm3,%xmm2
mulps  %xmm4,%xmm2
subps  %xmm2,%xmm1
movss  0x4(%rax),%xmm2
mulss  %xmm7,%xmm2
subss  %xmm2,%xmm0
movss  0x24(%rax),%xmm2
unpcklps %xmm2,%xmm6
shufps $0x0,%xmm7,%xmm7
movaps %xmm6,%xmm2
mulps  %xmm7,%xmm2
subps  %xmm2,%xmm1
movss  0x8(%rax),%xmm2
mulss  %xmm5,%xmm2
subss  %xmm2,%xmm0
movss  0x28(%rax),%xmm2
unpcklps %xmm2,%xmm12
shufps $0x0,%xmm5,%xmm5
movaps %xmm12,%xmm2
mulps  %xmm5,%xmm2
subps  %xmm2,%xmm1
movss  0xc(%rax),%xmm2
mulss  %xmm11,%xmm2
subss  %xmm2,%xmm0
movss  0x2c(%rax),%xmm2
unpcklps %xmm2,%xmm10
shufps $0x0,%xmm11,%xmm11
movaps %xmm10,%xmm2
mulps  %xmm11,%xmm2
subps  %xmm2,%xmm1
add    $0x4,%edx
add    $0x10,%r8
add    %r11,%rax
cmp    %r10d,%edx
jl     1170 <kernel_strsv_lt_inv_3_lib4+0x70>
xorps  %xmm8,%xmm3
xorps  %xmm8,%xmm6
xorps  %xmm8,%xmm12
xorps  %xmm8,%xmm10
mulps  %xmm4,%xmm3
addps  %xmm9,%xmm3
mulps  %xmm7,%xmm6
addps  %xmm3,%xmm6
mulps  %xmm5,%xmm12
addps  %xmm6,%xmm12
mulps  %xmm11,%xmm10
addps  %xmm12,%xmm10
mov    %edi,%edx
and    $0xfffffffc,%edx
movaps %xmm10,%xmm1
jmp    128d <kernel_strsv_lt_inv_3_lib4+0x18d>
lea    0xc(%rsi),%rax
add    $0x4,%r8
xorps  %xmm1,%xmm1
xorps  %xmm0,%xmm0
mov    $0x3,%edx
mov    0x8(%rsp),%r10
cmp    %edi,%edx
jge    12f6 <kernel_strsv_lt_inv_3_lib4+0x1f6>
sub    %edx,%edi
xor    %edx,%edx
movaps 0xd5f(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movaps %xmm1,%xmm3
movss  (%r8,%rdx,4),%xmm4
movss  (%rax,%rdx,4),%xmm5
mulss  %xmm4,%xmm5
subss  %xmm5,%xmm0
movss  0x10(%rax,%rdx,4),%xmm5
movss  0x20(%rax,%rdx,4),%xmm6
unpcklps %xmm6,%xmm5
shufps $0x0,%xmm4,%xmm4
movaps %xmm5,%xmm6
mulps  %xmm4,%xmm6
subps  %xmm6,%xmm1
add    $0x1,%rdx
cmp    %edx,%edi
jne    12b0 <kernel_strsv_lt_inv_3_lib4+0x1b0>
xorps  %xmm2,%xmm5
mulps  %xmm4,%xmm5
addps  %xmm3,%xmm5
movaps %xmm5,%xmm1
addss  (%r9),%xmm0
movss  0x4(%r9),%xmm2
addss  %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm1
addss  0x8(%r9),%xmm1
mulss  0x8(%rcx),%xmm1
movss  %xmm1,0x8(%r10)
movss  0x8(%rsi),%xmm3
mulss  %xmm1,%xmm3
mulss  0x18(%rsi),%xmm1
subss  %xmm1,%xmm2
mulss  0x4(%rcx),%xmm2
subss  %xmm3,%xmm0
movss  %xmm2,0x4(%r10)
mulss  0x4(%rsi),%xmm2
subss  %xmm2,%xmm0
mulss  (%rcx),%xmm0
movss  %xmm0,(%r10)
ret

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

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