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 - 7; k += 8) {
    x_0 = x[0];
    x_1 = x[1];
    x_2 = x[2];
    x_3 = x[3];
    y_0 += A[0 + lda * 0] * x_0;
    y_1 += A[0 + lda * 1] * x_0;
    y_2 += A[0 + lda * 2] * x_0;
    y_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 - 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_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++) {
    x_0 = x[0];
    y_0 += A[0 + lda * 0] * x_0;
    y_1 += A[0 + lda * 1] * x_0;
    y_2 += A[0 + lda * 2] * x_0;
    A += 1;
    x += 1;
  }
  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    1976 <kernel_strsv_t_3_lib4+0x876>
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    $0x7,%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
mov    -0x4(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    17c7 <kernel_strsv_t_3_lib4+0x6c7>
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>
jmp    17cc <kernel_strsv_t_3_lib4+0x6cc>
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    186a <kernel_strsv_t_3_lib4+0x76a>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x44(%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
add    $0x4,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    17cc <kernel_strsv_t_3_lib4+0x6cc>
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    1490 <kernel_strsv_t_3_lib4+0x390>
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),%rax
mov    $0x4,%r9d
cmp    $0xc,%edi
jb     130d <kernel_strsv_t_3_lib4+0x20d>
lea    -0x7(%rdi),%r10d
lea    -0xc(%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,%rdx
movss  (%rax),%xmm5
movss  0x4(%rax),%xmm4
movss  0x8(%rax),%xmm2
movss  0xc(%rax),%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(%rax),%xmm5
movss  0x14(%rax),%xmm0
movss  0x18(%rax),%xmm4
movss  0x1c(%rax),%xmm2
lea    0x0(%rbp,%rbx,1),%rbp
movss  (%rdx,%rbx,1),%xmm7
mulss  %xmm5,%xmm7
addss  %xmm1,%xmm7
movss  0x20(%rdx,%rbx,1),%xmm1
movss  0x10(%rdx,%rbx,1),%xmm6
unpcklps %xmm1,%xmm6
movss  0x14(%rdx,%rbx,1),%xmm1
movss  0x18(%rdx,%rbx,1),%xmm9
movss  0x1c(%rdx,%rbx,1),%xmm8
shufps $0x0,%xmm5,%xmm5
mulps  %xmm6,%xmm5
addps  %xmm3,%xmm5
movss  0x4(%rdx,%rbx,1),%xmm3
mulss  %xmm0,%xmm3
addss  %xmm7,%xmm3
movss  0x24(%rdx,%rbx,1),%xmm6
unpcklps %xmm6,%xmm1
shufps $0x0,%xmm0,%xmm0
mulps  %xmm1,%xmm0
addps  %xmm5,%xmm0
movss  0x8(%rdx,%rbx,1),%xmm1
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
movss  0x28(%rdx,%rbx,1),%xmm3
unpcklps %xmm3,%xmm9
shufps $0x0,%xmm4,%xmm4
mulps  %xmm9,%xmm4
addps  %xmm0,%xmm4
movss  0xc(%rdx,%rbx,1),%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x2c(%rdx,%rbx,1),%xmm1
unpcklps %xmm1,%xmm8
shufps $0x0,%xmm2,%xmm2
mulps  %xmm8,%xmm2
movaps %xmm2,%xmm1
addps  %xmm4,%xmm1
add    $0x8,%r14d
add    $0x20,%rax
add    %rbx,%rbp
cmp    %r10d,%r14d
jl     1180 <kernel_strsv_t_3_lib4+0x80>
add    %r11,%rdx
addps  %xmm4,%xmm2
add    $0xc,%r9d
mov    %rdx,%rbp
movaps %xmm2,%xmm1
lea    -0x3(%rdi),%edx
cmp    %edx,%r9d
jge    13e6 <kernel_strsv_t_3_lib4+0x2e6>
shl    $0x2,%r8
nopl   (%rax)
movss  (%rax),%xmm6
movss  0x4(%rax),%xmm4
movss  0x8(%rax),%xmm3
movss  0xc(%rax),%xmm2
movss  0x0(%rbp),%xmm7
mulss  %xmm6,%xmm7
addss  %xmm0,%xmm7
movss  0x20(%rbp),%xmm0
movss  0x10(%rbp),%xmm5
unpcklps %xmm0,%xmm5
movss  0x14(%rbp),%xmm0
movss  0x18(%rbp),%xmm9
movss  0x1c(%rbp),%xmm8
shufps $0x0,%xmm6,%xmm6
mulps  %xmm5,%xmm6
addps  %xmm1,%xmm6
movss  0x4(%rbp),%xmm1
mulss  %xmm4,%xmm1
addss  %xmm7,%xmm1
movss  0x24(%rbp),%xmm5
unpcklps %xmm5,%xmm0
shufps $0x0,%xmm4,%xmm4
mulps  %xmm0,%xmm4
addps  %xmm6,%xmm4
movss  0x8(%rbp),%xmm5
mulss  %xmm3,%xmm5
addss  %xmm1,%xmm5
movss  0x28(%rbp),%xmm0
unpcklps %xmm0,%xmm9
shufps $0x0,%xmm3,%xmm3
mulps  %xmm9,%xmm3
addps  %xmm4,%xmm3
movss  0xc(%rbp),%xmm0
mulss  %xmm2,%xmm0
addss  %xmm5,%xmm0
movss  0x2c(%rbp),%xmm1
unpcklps %xmm1,%xmm8
shufps $0x0,%xmm2,%xmm2
mulps  %xmm8,%xmm2
movaps %xmm2,%xmm1
addps  %xmm3,%xmm1
add    $0x10,%rax
add    $0x4,%r9d
add    %r8,%rbp
cmp    %edx,%r9d
jl     1320 <kernel_strsv_t_3_lib4+0x220>
addps  %xmm3,%xmm2
movaps %xmm2,%xmm1
cmp    %edi,%r9d
jge    1430 <kernel_strsv_t_3_lib4+0x330>
sub    %r9d,%edi
xor    %edx,%edx
movaps %xmm1,%xmm2
movss  (%rax,%rdx,4),%xmm3
movss  0x0(%rbp,%rdx,4),%xmm1
mulss  %xmm3,%xmm1
addss  %xmm1,%xmm0
movss  0x10(%rbp,%rdx,4),%xmm1
movss  0x20(%rbp,%rdx,4),%xmm4
unpcklps %xmm4,%xmm1
shufps $0x0,%xmm3,%xmm3
mulps  %xmm1,%xmm3
movaps %xmm3,%xmm1
addps  %xmm2,%xmm1
add    $0x1,%rdx
cmp    %edx,%edi
jne    13f0 <kernel_strsv_t_3_lib4+0x2f0>
addps  %xmm2,%xmm3
movaps %xmm3,%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 %443
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, 7
%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 = %346, %248
%250 = load i32, i32* %11
%251 = load i32, i32* %5
%252 = sub nsw i32 %251, 3
%253 = icmp slt i32 %250, %252
br i1 %253, label %254, label %349
254: ; preds = %249
%255 = load float*, float** %8
%256 = getelementptr inbounds float, float* %255, i64 0
%257 = load float, float* %256
store float %257, float* %14
%258 = load float*, float** %8
%259 = getelementptr inbounds float, float* %258, i64 1
%260 = load float, float* %259
store float %260, float* %15
%261 = load float*, float** %8
%262 = getelementptr inbounds float, float* %261, i64 2
%263 = load float, float* %262
store float %263, float* %16
%264 = load float*, float** %8
%265 = getelementptr inbounds float, float* %264, i64 3
%266 = load float, float* %265
store float %266, float* %17
%267 = load float*, float** %6
%268 = getelementptr inbounds float, float* %267, i64 0
%269 = load float, float* %268
%270 = load float, float* %14
%271 = load float, float* %18
%272 = call float @llvm.fmuladd.f32(float %269, float %270, float %271)
store float %272, float* %18
%273 = load float*, float** %6
%274 = getelementptr inbounds float, float* %273, i64 4
%275 = load float, float* %274
%276 = load float, float* %14
%277 = load float, float* %19
%278 = call float @llvm.fmuladd.f32(float %275, float %276, float %277)
store float %278, float* %19
%279 = load float*, float** %6
%280 = getelementptr inbounds float, float* %279, i64 8
%281 = load float, float* %280
%282 = load float, float* %14
%283 = load float, float* %20
%284 = call float @llvm.fmuladd.f32(float %281, float %282, float %283)
store float %284, float* %20
%285 = load float*, float** %6
%286 = getelementptr inbounds float, float* %285, i64 1
%287 = load float, float* %286
%288 = load float, float* %15
%289 = load float, float* %18
%290 = call float @llvm.fmuladd.f32(float %287, float %288, float %289)
store float %290, float* %18
%291 = load float*, float** %6
%292 = getelementptr inbounds float, float* %291, i64 5
%293 = load float, float* %292
%294 = load float, float* %15
%295 = load float, float* %19
%296 = call float @llvm.fmuladd.f32(float %293, float %294, float %295)
store float %296, float* %19
%297 = load float*, float** %6
%298 = getelementptr inbounds float, float* %297, i64 9
%299 = load float, float* %298
%300 = load float, float* %15
%301 = load float, float* %20
%302 = call float @llvm.fmuladd.f32(float %299, float %300, float %301)
store float %302, float* %20
%303 = load float*, float** %6
%304 = getelementptr inbounds float, float* %303, i64 2
%305 = load float, float* %304
%306 = load float, float* %16
%307 = load float, float* %18
%308 = call float @llvm.fmuladd.f32(float %305, float %306, float %307)
store float %308, float* %18
%309 = load float*, float** %6
%310 = getelementptr inbounds float, float* %309, i64 6
%311 = load float, float* %310
%312 = load float, float* %16
%313 = load float, float* %19
%314 = call float @llvm.fmuladd.f32(float %311, float %312, float %313)
store float %314, float* %19
%315 = load float*, float** %6
%316 = getelementptr inbounds float, float* %315, i64 10
%317 = load float, float* %316
%318 = load float, float* %16
%319 = load float, float* %20
%320 = call float @llvm.fmuladd.f32(float %317, float %318, float %319)
store float %320, float* %20
%321 = load float*, float** %6
%322 = getelementptr inbounds float, float* %321, i64 3
%323 = load float, float* %322
%324 = load float, float* %17
%325 = load float, float* %18
%326 = call float @llvm.fmuladd.f32(float %323, float %324, float %325)
store float %326, float* %18
%327 = load float*, float** %6
%328 = getelementptr inbounds float, float* %327, i64 7
%329 = load float, float* %328
%330 = load float, float* %17
%331 = load float, float* %19
%332 = call float @llvm.fmuladd.f32(float %329, float %330, float %331)
store float %332, float* %19
%333 = load float*, float** %6
%334 = getelementptr inbounds float, float* %333, i64 11
%335 = load float, float* %334
%336 = load float, float* %17
%337 = load float, float* %20
%338 = call float @llvm.fmuladd.f32(float %335, float %336, float %337)
store float %338, float* %20
%339 = load i32, i32* %7
%340 = mul nsw i32 %339, 4
%341 = load float*, float** %6
%342 = sext i32 %340 to i64
%343 = getelementptr inbounds float, float* %341, i64 %342
store float* %343, float** %6
%344 = load float*, float** %8
%345 = getelementptr inbounds float, float* %344, i64 4
store float* %345, float** %8
br label %346
346: ; preds = %254
%347 = load i32, i32* %11
%348 = add nsw i32 %347, 4
store i32 %348, i32* %11
br label %249
349: ; preds = %249
br label %350
350: ; preds = %380, %349
%351 = load i32, i32* %11
%352 = load i32, i32* %5
%353 = icmp slt i32 %351, %352
br i1 %353, label %354, label %383
354: ; preds = %350
%355 = load float*, float** %8
%356 = getelementptr inbounds float, float* %355, i64 0
%357 = load float, float* %356
store float %357, float* %14
%358 = load float*, float** %6
%359 = getelementptr inbounds float, float* %358, i64 0
%360 = load float, float* %359
%361 = load float, float* %14
%362 = load float, float* %18
%363 = call float @llvm.fmuladd.f32(float %360, float %361, float %362)
store float %363, float* %18
%364 = load float*, float** %6
%365 = getelementptr inbounds float, float* %364, i64 4
%366 = load float, float* %365
%367 = load float, float* %14
%368 = load float, float* %19
%369 = call float @llvm.fmuladd.f32(float %366, float %367, float %368)
store float %369, float* %19
%370 = load float*, float** %6
%371 = getelementptr inbounds float, float* %370, i64 8
%372 = load float, float* %371
%373 = load float, float* %14
%374 = load float, float* %20
%375 = call float @llvm.fmuladd.f32(float %372, float %373, float %374)
store float %375, float* %20
%376 = load float*, float** %6
%377 = getelementptr inbounds float, float* %376, i64 1
store float* %377, float** %6
%378 = load float*, float** %8
%379 = getelementptr inbounds float, float* %378, i64 1
store float* %379, float** %8
br label %380
380: ; preds = %354
%381 = load i32, i32* %11
%382 = add nsw i32 %381, 1
store i32 %382, i32* %11
br label %350
383: ; preds = %350
%384 = load float*, float** %12
store float* %384, float** %6
%385 = load float*, float** %13
store float* %385, float** %8
%386 = load float*, float** %8
%387 = getelementptr inbounds float, float* %386, i64 2
%388 = load float, float* %387
%389 = load float, float* %20
%390 = fsub float %388, %389
store float %390, float* %20
%391 = load float*, float** %6
%392 = getelementptr inbounds float, float* %391, i64 10
%393 = load float, float* %392
%394 = load float, float* %20
%395 = fmul float %394, %393
store float %395, float* %20
%396 = load float, float* %20
%397 = load float*, float** %8
%398 = getelementptr inbounds float, float* %397, i64 2
store float %396, float* %398
%399 = load float*, float** %6
%400 = getelementptr inbounds float, float* %399, i64 2
%401 = load float, float* %400
%402 = load float, float* %20
%403 = load float, float* %18
%404 = call float @llvm.fmuladd.f32(float %401, float %402, float %403)
store float %404, float* %18
%405 = load float*, float** %6
%406 = getelementptr inbounds float, float* %405, i64 6
%407 = load float, float* %406
%408 = load float, float* %20
%409 = load float, float* %19
%410 = call float @llvm.fmuladd.f32(float %407, float %408, float %409)
store float %410, float* %19
%411 = load float*, float** %8
%412 = getelementptr inbounds float, float* %411, i64 1
%413 = load float, float* %412
%414 = load float, float* %19
%415 = fsub float %413, %414
store float %415, float* %19
%416 = load float*, float** %6
%417 = getelementptr inbounds float, float* %416, i64 5
%418 = load float, float* %417
%419 = load float, float* %19
%420 = fmul float %419, %418
store float %420, float* %19
%421 = load float, float* %19
%422 = load float*, float** %8
%423 = getelementptr inbounds float, float* %422, i64 1
store float %421, float* %423
%424 = load float*, float** %8
%425 = getelementptr inbounds float, float* %424, i64 0
%426 = load float, float* %425
%427 = load float*, float** %6
%428 = getelementptr inbounds float, float* %427, i64 1
%429 = load float, float* %428
%430 = load float, float* %19
%431 = fneg float %429
%432 = call float @llvm.fmuladd.f32(float %431, float %430, float %426)
%433 = load float, float* %18
%434 = fsub float %432, %433
store float %434, float* %18
%435 = load float*, float** %6
%436 = getelementptr inbounds float, float* %435, i64 0
%437 = load float, float* %436
%438 = load float, float* %18
%439 = fmul float %438, %437
store float %439, float* %18
%440 = load float, float* %18
%441 = load float*, float** %8
%442 = getelementptr inbounds float, float* %441, i64 0
store float %440, float* %442
br label %443
443: ; preds = %383, %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 %300, 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, -7
%24 = getelementptr inbounds float, float* %1, i64 %22
%25 = getelementptr inbounds float, float* %3, i64 4
%26 = icmp ugt i32 %0, 11
br i1 %26, label %27, label %40
27: ; preds = %6
%28 = add nsw i32 %0, -12
%29 = and i32 %28, -8
br label %48
30: ; preds = %48
%31 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %69, <2 x float> %71, <2 x float> %54)
%32 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %81, <2 x float> %83, <2 x float> %31)
%33 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %93, <2 x float> %95, <2 x float> %32)
%34 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %105, <2 x float> %107, <2 x float> %33)
%35 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %125, <2 x float> %127, <2 x float> %34)
%36 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %137, <2 x float> %139, <2 x float> %35)
%37 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %149, <2 x float> %151, <2 x float> %36)
%38 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %161, <2 x float> %163, <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 ], [ %155, %30 ]
%43 = phi float* [ %24, %6 ], [ %166, %30 ]
%44 = phi float* [ %25, %6 ], [ %167, %30 ]
%45 = phi <2 x float> [ %20, %6 ], [ %38, %30 ]
%46 = add nsw i32 %0, -3
%47 = icmp slt i32 %41, %46
br i1 %47, label %181, label %174
48: ; preds = %27, %48
%49 = phi float* [ %167, %48 ], [ %25, %27 ]
%50 = phi float* [ %166, %48 ], [ %24, %27 ]
%51 = phi float [ %155, %48 ], [ %11, %27 ]
%52 = phi float* [ %110, %48 ], [ %3, %27 ]
%53 = phi i32 [ %165, %48 ], [ 4, %27 ]
%54 = phi <2 x float> [ %164, %48 ], [ %20, %27 ]
%55 = load float, float* %49
%56 = getelementptr inbounds float, float* %52, i64 5
%57 = load float, float* %56
%58 = getelementptr inbounds float, float* %52, i64 6
%59 = load float, float* %58
%60 = getelementptr inbounds float, float* %52, i64 7
%61 = load float, float* %60
%62 = load float, float* %50
%63 = tail call float @llvm.fmuladd.f32(float %62, float %55, float %51)
%64 = getelementptr inbounds float, float* %50, i64 4
%65 = load float, float* %64
%66 = getelementptr inbounds float, float* %50, i64 8
%67 = load float, float* %66
%68 = insertelement <2 x float> poison, float %65, i64 0
%69 = insertelement <2 x float> %68, float %67, i64 1
%70 = insertelement <2 x float> poison, float %55, 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> %54)
%73 = getelementptr inbounds float, float* %50, i64 1
%74 = load float, float* %73
%75 = tail call float @llvm.fmuladd.f32(float %74, float %57, float %63)
%76 = getelementptr inbounds float, float* %50, i64 5
%77 = load float, float* %76
%78 = getelementptr inbounds float, float* %50, i64 9
%79 = load float, float* %78
%80 = insertelement <2 x float> poison, float %77, i64 0
%81 = insertelement <2 x float> %80, float %79, i64 1
%82 = insertelement <2 x float> poison, float %57, i64 0
%83 = shufflevector <2 x float> %82, <2 x float> poison, <2 x i32> zeroinitializer
%84 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %81, <2 x float> %83, <2 x float> %72)
%85 = getelementptr inbounds float, float* %50, i64 2
%86 = load float, float* %85
%87 = tail call float @llvm.fmuladd.f32(float %86, float %59, float %75)
%88 = getelementptr inbounds float, float* %50, i64 6
%89 = load float, float* %88
%90 = getelementptr inbounds float, float* %50, i64 10
%91 = load float, float* %90
%92 = insertelement <2 x float> poison, float %89, i64 0
%93 = insertelement <2 x float> %92, float %91, i64 1
%94 = insertelement <2 x float> poison, float %59, i64 0
%95 = shufflevector <2 x float> %94, <2 x float> poison, <2 x i32> zeroinitializer
%96 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %93, <2 x float> %95, <2 x float> %84)
%97 = getelementptr inbounds float, float* %50, i64 3
%98 = load float, float* %97
%99 = tail call float @llvm.fmuladd.f32(float %98, float %61, float %87)
%100 = getelementptr inbounds float, float* %50, i64 7
%101 = load float, float* %100
%102 = getelementptr inbounds float, float* %50, i64 11
%103 = load float, float* %102
%104 = insertelement <2 x float> poison, float %101, i64 0
%105 = insertelement <2 x float> %104, float %103, i64 1
%106 = insertelement <2 x float> poison, float %61, i64 0
%107 = shufflevector <2 x float> %106, <2 x float> poison, <2 x i32> zeroinitializer
%108 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %105, <2 x float> %107, <2 x float> %96)
%109 = getelementptr inbounds float, float* %50, i64 %22
%110 = getelementptr inbounds float, float* %52, i64 8
%111 = load float, float* %110
%112 = getelementptr inbounds float, float* %52, i64 9
%113 = load float, float* %112
%114 = getelementptr inbounds float, float* %52, i64 10
%115 = load float, float* %114
%116 = getelementptr inbounds float, float* %52, i64 11
%117 = load float, float* %116
%118 = load float, float* %109
%119 = tail call float @llvm.fmuladd.f32(float %118, float %111, float %99)
%120 = getelementptr inbounds float, float* %109, i64 4
%121 = load float, float* %120
%122 = getelementptr inbounds float, float* %109, i64 8
%123 = load float, float* %122
%124 = insertelement <2 x float> poison, float %121, i64 0
%125 = insertelement <2 x float> %124, float %123, i64 1
%126 = insertelement <2 x float> poison, float %111, i64 0
%127 = shufflevector <2 x float> %126, <2 x float> poison, <2 x i32> zeroinitializer
%128 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %125, <2 x float> %127, <2 x float> %108)
%129 = getelementptr inbounds float, float* %109, i64 1
%130 = load float, float* %129
%131 = tail call float @llvm.fmuladd.f32(float %130, float %113, float %119)
%132 = getelementptr inbounds float, float* %109, i64 5
%133 = load float, float* %132
%134 = getelementptr inbounds float, float* %109, i64 9
%135 = load float, float* %134
%136 = insertelement <2 x float> poison, float %133, i64 0
%137 = insertelement <2 x float> %136, float %135, i64 1
%138 = insertelement <2 x float> poison, float %113, 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> %128)
%141 = getelementptr inbounds float, float* %109, i64 2
%142 = load float, float* %141
%143 = tail call float @llvm.fmuladd.f32(float %142, float %115, float %131)
%144 = getelementptr inbounds float, float* %109, i64 6
%145 = load float, float* %144
%146 = getelementptr inbounds float, float* %109, i64 10
%147 = load float, float* %146
%148 = insertelement <2 x float> poison, float %145, i64 0
%149 = insertelement <2 x float> %148, float %147, i64 1
%150 = insertelement <2 x float> poison, float %115, i64 0
%151 = shufflevector <2 x float> %150, <2 x float> poison, <2 x i32> zeroinitializer
%152 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %149, <2 x float> %151, <2 x float> %140)
%153 = getelementptr inbounds float, float* %109, i64 3
%154 = load float, float* %153
%155 = tail call float @llvm.fmuladd.f32(float %154, float %117, float %143)
%156 = getelementptr inbounds float, float* %109, i64 7
%157 = load float, float* %156
%158 = getelementptr inbounds float, float* %109, i64 11
%159 = load float, float* %158
%160 = insertelement <2 x float> poison, float %157, i64 0
%161 = insertelement <2 x float> %160, float %159, i64 1
%162 = insertelement <2 x float> poison, float %117, i64 0
%163 = shufflevector <2 x float> %162, <2 x float> poison, <2 x i32> zeroinitializer
%164 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %161, <2 x float> %163, <2 x float> %152)
%165 = add nuw nsw i32 %53, 8
%166 = getelementptr inbounds float, float* %109, i64 %22
%167 = getelementptr inbounds float, float* %52, i64 12
%168 = icmp slt i32 %165, %23
br i1 %168, label %48, label %30
169: ; preds = %181
%170 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %201, <2 x float> %203, <2 x float> %186)
%171 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %213, <2 x float> %215, <2 x float> %170)
%172 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %225, <2 x float> %227, <2 x float> %171)
%173 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %237, <2 x float> %239, <2 x float> %172)
br label %174
174: ; preds = %169, %40
%175 = phi i32 [ %41, %40 ], [ %243, %169 ]
%176 = phi float* [ %44, %40 ], [ %242, %169 ]
%177 = phi float* [ %43, %40 ], [ %241, %169 ]
%178 = phi float [ %42, %40 ], [ %231, %169 ]
%179 = phi <2 x float> [ %45, %40 ], [ %173, %169 ]
%180 = icmp slt i32 %175, %0
br i1 %180, label %245, label %269
181: ; preds = %40, %181
%182 = phi float [ %231, %181 ], [ %42, %40 ]
%183 = phi float* [ %241, %181 ], [ %43, %40 ]
%184 = phi float* [ %242, %181 ], [ %44, %40 ]
%185 = phi i32 [ %243, %181 ], [ %41, %40 ]
%186 = phi <2 x float> [ %240, %181 ], [ %45, %40 ]
%187 = load float, float* %184
%188 = getelementptr inbounds float, float* %184, i64 1
%189 = load float, float* %188
%190 = getelementptr inbounds float, float* %184, i64 2
%191 = load float, float* %190
%192 = getelementptr inbounds float, float* %184, i64 3
%193 = load float, float* %192
%194 = load float, float* %183
%195 = tail call float @llvm.fmuladd.f32(float %194, float %187, float %182)
%196 = getelementptr inbounds float, float* %183, i64 4
%197 = load float, float* %196
%198 = getelementptr inbounds float, float* %183, i64 8
%199 = load float, float* %198
%200 = insertelement <2 x float> poison, float %197, i64 0
%201 = insertelement <2 x float> %200, float %199, i64 1
%202 = insertelement <2 x float> poison, float %187, i64 0
%203 = shufflevector <2 x float> %202, <2 x float> poison, <2 x i32> zeroinitializer
%204 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %201, <2 x float> %203, <2 x float> %186)
%205 = getelementptr inbounds float, float* %183, i64 1
%206 = load float, float* %205
%207 = tail call float @llvm.fmuladd.f32(float %206, float %189, float %195)
%208 = getelementptr inbounds float, float* %183, i64 5
%209 = load float, float* %208
%210 = getelementptr inbounds float, float* %183, i64 9
%211 = load float, float* %210
%212 = insertelement <2 x float> poison, float %209, i64 0
%213 = insertelement <2 x float> %212, float %211, i64 1
%214 = insertelement <2 x float> poison, float %189, i64 0
%215 = shufflevector <2 x float> %214, <2 x float> poison, <2 x i32> zeroinitializer
%216 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %213, <2 x float> %215, <2 x float> %204)
%217 = getelementptr inbounds float, float* %183, i64 2
%218 = load float, float* %217
%219 = tail call float @llvm.fmuladd.f32(float %218, float %191, float %207)
%220 = getelementptr inbounds float, float* %183, i64 6
%221 = load float, float* %220
%222 = getelementptr inbounds float, float* %183, i64 10
%223 = load float, float* %222
%224 = insertelement <2 x float> poison, float %221, i64 0
%225 = insertelement <2 x float> %224, float %223, i64 1
%226 = insertelement <2 x float> poison, float %191, i64 0
%227 = shufflevector <2 x float> %226, <2 x float> poison, <2 x i32> zeroinitializer
%228 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %225, <2 x float> %227, <2 x float> %216)
%229 = getelementptr inbounds float, float* %183, i64 3
%230 = load float, float* %229
%231 = tail call float @llvm.fmuladd.f32(float %230, float %193, float %219)
%232 = getelementptr inbounds float, float* %183, i64 7
%233 = load float, float* %232
%234 = getelementptr inbounds float, float* %183, i64 11
%235 = load float, float* %234
%236 = insertelement <2 x float> poison, float %233, i64 0
%237 = insertelement <2 x float> %236, float %235, i64 1
%238 = insertelement <2 x float> poison, float %193, i64 0
%239 = shufflevector <2 x float> %238, <2 x float> poison, <2 x i32> zeroinitializer
%240 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %237, <2 x float> %239, <2 x float> %228)
%241 = getelementptr inbounds float, float* %183, i64 %22
%242 = getelementptr inbounds float, float* %184, i64 4
%243 = add nuw nsw i32 %185, 4
%244 = icmp slt i32 %243, %46
br i1 %244, label %181, label %169
245: ; preds = %174, %245
%246 = phi float [ %253, %245 ], [ %178, %174 ]
%247 = phi float* [ %263, %245 ], [ %177, %174 ]
%248 = phi float* [ %264, %245 ], [ %176, %174 ]
%249 = phi i32 [ %265, %245 ], [ %175, %174 ]
%250 = phi <2 x float> [ %262, %245 ], [ %179, %174 ]
%251 = load float, float* %248
%252 = load float, float* %247
%253 = tail call float @llvm.fmuladd.f32(float %252, float %251, float %246)
%254 = getelementptr inbounds float, float* %247, i64 4
%255 = load float, float* %254
%256 = getelementptr inbounds float, float* %247, i64 8
%257 = load float, float* %256
%258 = insertelement <2 x float> poison, float %255, i64 0
%259 = insertelement <2 x float> %258, float %257, i64 1
%260 = insertelement <2 x float> poison, float %251, i64 0
%261 = shufflevector <2 x float> %260, <2 x float> poison, <2 x i32> zeroinitializer
%262 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %259, <2 x float> %261, <2 x float> %250)
%263 = getelementptr inbounds float, float* %247, i64 1
%264 = getelementptr inbounds float, float* %248, i64 1
%265 = add nuw nsw i32 %249, 1
%266 = icmp eq i32 %265, %0
br i1 %266, label %267, label %245
267: ; preds = %245
%268 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %259, <2 x float> %261, <2 x float> %250)
br label %269
269: ; preds = %267, %174
%270 = phi float [ %178, %174 ], [ %253, %267 ]
%271 = phi <2 x float> [ %179, %174 ], [ %268, %267 ]
%272 = getelementptr inbounds float, float* %3, i64 2
%273 = load float, float* %272
%274 = extractelement <2 x float> %271, i64 1
%275 = fsub float %273, %274
%276 = getelementptr inbounds float, float* %1, i64 10
%277 = load float, float* %276
%278 = fmul float %275, %277
store float %278, float* %272
%279 = getelementptr inbounds float, float* %1, i64 2
%280 = load float, float* %279
%281 = tail call float @llvm.fmuladd.f32(float %280, float %278, float %270)
%282 = getelementptr inbounds float, float* %1, i64 6
%283 = load float, float* %282
%284 = extractelement <2 x float> %271, i64 0
%285 = tail call float @llvm.fmuladd.f32(float %283, float %278, float %284)
%286 = getelementptr inbounds float, float* %3, i64 1
%287 = load float, float* %286
%288 = fsub float %287, %285
%289 = getelementptr inbounds float, float* %1, i64 5
%290 = load float, float* %289
%291 = fmul float %288, %290
store float %291, float* %286
%292 = load float, float* %3
%293 = getelementptr inbounds float, float* %1, i64 1
%294 = load float, float* %293
%295 = fneg float %294
%296 = tail call float @llvm.fmuladd.f32(float %295, float %291, float %292)
%297 = fsub float %296, %281
%298 = load float, float* %1
%299 = fmul float %298, %297
store float %299, float* %3
br label %300
300: ; preds = %4, %269
ret void
}