void kernel_strsv_t_2_lib8(int kmax, int kna, float *A, int sda, float *x) {
  if (kmax <= 0)
    return;
  const int lda = 8;
  const int bs = 8;
  int k;
  float *tA, *tx;
  tA = A;
  tx = x;
  float x_0, x_1, x_2, x_3, y_0 = 0, y_1 = 0;
  x_2 = x[2];
  x_3 = x[3];
  y_0 += A[2 + lda * 0] * x_2;
  y_1 += A[2 + lda * 1] * x_2;
  y_0 += A[3 + lda * 0] * x_3;
  y_1 += A[3 + lda * 1] * x_3;
  k = 4;
  A += 4;
  x += 4;
  for (; k < 4 + kna - 3; k += 4) {
    x_0 = x[0];
    x_1 = x[1];
    x_2 = x[2];
    x_3 = x[3];
    y_0 += A[0 + lda * 0] * x_0;
    y_1 += A[0 + lda * 1] * x_0;
    y_0 += A[1 + lda * 0] * x_1;
    y_1 += A[1 + lda * 1] * x_1;
    y_0 += A[2 + lda * 0] * x_2;
    y_1 += A[2 + lda * 1] * x_2;
    y_0 += A[3 + lda * 0] * x_3;
    y_1 += A[3 + lda * 1] * x_3;
    A += 4;
    x += 4;
  }
  A += (sda - 1) * bs;
  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_0 += A[1 + lda * 0] * x_1;
    y_1 += A[1 + lda * 1] * x_1;
    y_0 += A[2 + lda * 0] * x_2;
    y_1 += A[2 + lda * 1] * x_2;
    y_0 += A[3 + lda * 0] * x_3;
    y_1 += A[3 + lda * 1] * x_3;
    x_0 = x[4];
    x_1 = x[5];
    x_2 = x[6];
    x_3 = x[7];
    y_0 += A[4 + lda * 0] * x_0;
    y_1 += A[4 + lda * 1] * x_0;
    y_0 += A[5 + lda * 0] * x_1;
    y_1 += A[5 + lda * 1] * x_1;
    y_0 += A[6 + lda * 0] * x_2;
    y_1 += A[6 + lda * 1] * x_2;
    y_0 += A[7 + lda * 0] * x_3;
    y_1 += A[7 + lda * 1] * x_3;
    A += sda * bs;
    x += 8;
  }
  for (; k < kmax; k++) {
    x_0 = x[0];
    y_0 += A[0 + lda * 0] * x_0;
    y_1 += A[0 + lda * 1] * x_0;
    A += 1;
    x += 1;
  }
  A = tA;
  x = tx;
  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_2_lib8>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
cmpl   $0x0,-0x4(%rbp)
jg     1124 <kernel_strsv_t_2_lib8+0x24>
jmp    1764 <kernel_strsv_t_2_lib8+0x664>
movl   $0x8,-0x24(%rbp)
movl   $0x8,-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)
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  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  0x28(%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  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  0x2c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movl   $0x4,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    $0x4,%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    137d <kernel_strsv_t_2_lib8+0x27d>
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  0x20(%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  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  0x24(%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  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  0x28(%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  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  0x2c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x2c(%rbp)
jmp    120d <kernel_strsv_t_2_lib8+0x10d>
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x3,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x7,%ecx
cmp    %ecx,%eax
jge    1649 <kernel_strsv_t_2_lib8+0x549>
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  0x20(%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  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  0x24(%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  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  0x28(%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  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  0x2c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%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  0x30(%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  0x14(%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  0x34(%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  0x18(%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  0x38(%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  0x1c(%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  0x3c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x14(%rbp),%ecx
shl    $0x3,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x2c(%rbp)
jmp    1398 <kernel_strsv_t_2_lib8+0x298>
jmp    164e <kernel_strsv_t_2_lib8+0x54e>
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    16cc <kernel_strsv_t_2_lib8+0x5cc>
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  0x20(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%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    164e <kernel_strsv_t_2_lib8+0x54e>
mov    -0x38(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
subss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%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_2_lib8>:
test   %edi,%edi
jle    1421 <kernel_strsv_t_2_lib8+0x321>
movss  0x8(%rdx),%xmm1
movss  0xc(%rdx),%xmm2
movss  0x28(%rdx),%xmm0
unpcklps %xmm0,%xmm1
movss  0x2c(%rdx),%xmm0
unpcklps %xmm0,%xmm2
movss  0x8(%r8),%xmm3
movss  0xc(%r8),%xmm0
shufps $0x0,%xmm3,%xmm3
mulps  %xmm1,%xmm3
xorps  %xmm1,%xmm1
addps  %xmm3,%xmm1
shufps $0x0,%xmm0,%xmm0
mulps  %xmm2,%xmm0
addps  %xmm1,%xmm0
lea    0x10(%r8),%rax
mov    $0x4,%r9d
cmp    $0x4,%esi
jge    115c <kernel_strsv_t_2_lib8+0x5c>
mov    %rdx,%r10
jmp    1208 <kernel_strsv_t_2_lib8+0x108>
mov    $0x4,%r9d
mov    %rdx,%r10
cs nopw 0x0(%rax,%rax,1)
nop
movss  0x30(%r10),%xmm5
movss  0x10(%r10),%xmm4
movss  0x14(%r10),%xmm3
movss  0x18(%r10),%xmm2
movss  0x1c(%r10),%xmm1
movss  0x34(%r10),%xmm8
movss  0x38(%r10),%xmm9
movss  0x3c(%r10),%xmm10
add    $0x10,%r10
unpcklps %xmm5,%xmm4
movss  (%rax),%xmm7
shufps $0x0,%xmm7,%xmm7
mulps  %xmm4,%xmm7
movss  0x4(%rax),%xmm6
addps  %xmm0,%xmm7
movss  0x8(%rax),%xmm5
unpcklps %xmm8,%xmm3
movss  0xc(%rax),%xmm4
shufps $0x0,%xmm6,%xmm6
mulps  %xmm3,%xmm6
addps  %xmm7,%xmm6
unpcklps %xmm9,%xmm2
shufps $0x0,%xmm5,%xmm5
mulps  %xmm2,%xmm5
addps  %xmm6,%xmm5
unpcklps %xmm10,%xmm1
shufps $0x0,%xmm4,%xmm4
mulps  %xmm1,%xmm4
movaps %xmm4,%xmm0
addps  %xmm5,%xmm0
add    $0x4,%r9d
add    $0x10,%rax
cmp    %esi,%r9d
jle    1170 <kernel_strsv_t_2_lib8+0x70>
addps  %xmm5,%xmm4
movaps %xmm4,%xmm0
lea    -0x8(,%rcx,8),%esi
movslq %esi,%rsi
lea    (%r10,%rsi,4),%rsi
add    $0x10,%rsi
lea    -0x7(%rdi),%r10d
cmp    %r10d,%r9d
jge    133e <kernel_strsv_t_2_lib8+0x23e>
shl    $0x3,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x20(%rsi),%xmm1
movss  (%rsi),%xmm4
unpcklps %xmm1,%xmm4
movss  0x4(%rsi),%xmm5
movss  0x8(%rsi),%xmm6
movss  0xc(%rsi),%xmm8
movss  (%rax),%xmm7
movss  0x4(%rax),%xmm2
movss  0x8(%rax),%xmm3
movss  0xc(%rax),%xmm1
shufps $0x0,%xmm7,%xmm7
mulps  %xmm4,%xmm7
addps  %xmm0,%xmm7
movss  0x24(%rsi),%xmm0
unpcklps %xmm0,%xmm5
shufps $0x0,%xmm2,%xmm2
mulps  %xmm5,%xmm2
addps  %xmm7,%xmm2
movss  0x28(%rsi),%xmm0
unpcklps %xmm0,%xmm6
shufps $0x0,%xmm3,%xmm3
mulps  %xmm6,%xmm3
addps  %xmm2,%xmm3
movss  0x2c(%rsi),%xmm0
unpcklps %xmm0,%xmm8
shufps $0x0,%xmm1,%xmm1
mulps  %xmm8,%xmm1
addps  %xmm3,%xmm1
movss  0x30(%rsi),%xmm0
movss  0x10(%rsi),%xmm2
unpcklps %xmm0,%xmm2
movss  0x10(%rax),%xmm0
shufps $0x0,%xmm0,%xmm0
mulps  %xmm2,%xmm0
addps  %xmm1,%xmm0
movss  0x34(%rsi),%xmm1
movss  0x14(%rsi),%xmm2
unpcklps %xmm1,%xmm2
movss  0x14(%rax),%xmm3
shufps $0x0,%xmm3,%xmm3
mulps  %xmm2,%xmm3
addps  %xmm0,%xmm3
movss  0x38(%rsi),%xmm0
movss  0x18(%rsi),%xmm2
unpcklps %xmm0,%xmm2
movss  0x18(%rax),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm2,%xmm1
addps  %xmm3,%xmm1
movss  0x3c(%rsi),%xmm0
movss  0x1c(%rsi),%xmm3
unpcklps %xmm0,%xmm3
movss  0x1c(%rax),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm3,%xmm2
movaps %xmm2,%xmm0
addps  %xmm1,%xmm0
add    $0x20,%rax
add    $0x8,%r9d
add    %rcx,%rsi
cmp    %r10d,%r9d
jl     1240 <kernel_strsv_t_2_lib8+0x140>
addps  %xmm1,%xmm2
movaps %xmm2,%xmm0
cmp    %edi,%r9d
jge    135d <kernel_strsv_t_2_lib8+0x25d>
mov    %edi,%ecx
sub    %r9d,%ecx
mov    %r9d,%r10d
not    %r10d
test   $0x1,%cl
jne    1365 <kernel_strsv_t_2_lib8+0x265>
add    %edi,%r10d
jne    1393 <kernel_strsv_t_2_lib8+0x293>
jmp    13ea <kernel_strsv_t_2_lib8+0x2ea>
movaps %xmm0,%xmm1
jmp    13ea <kernel_strsv_t_2_lib8+0x2ea>
movss  (%rsi),%xmm2
movss  0x20(%rsi),%xmm1
unpcklps %xmm1,%xmm2
movss  (%rax),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm2,%xmm1
addps  %xmm0,%xmm1
add    $0x4,%rsi
add    $0x4,%rax
add    $0x1,%r9d
movaps %xmm1,%xmm0
add    %edi,%r10d
je     13ea <kernel_strsv_t_2_lib8+0x2ea>
sub    %r9d,%edi
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movss  (%rsi,%rcx,4),%xmm3
movss  0x4(%rsi,%rcx,4),%xmm4
movss  0x20(%rsi,%rcx,4),%xmm1
unpcklps %xmm1,%xmm3
movss  0x24(%rsi,%rcx,4),%xmm1
unpcklps %xmm1,%xmm4
movss  (%rax,%rcx,4),%xmm2
movss  0x4(%rax,%rcx,4),%xmm1
shufps $0x0,%xmm2,%xmm2
mulps  %xmm3,%xmm2
addps  %xmm0,%xmm2
shufps $0x0,%xmm1,%xmm1
mulps  %xmm4,%xmm1
movaps %xmm1,%xmm0
addps  %xmm2,%xmm0
add    $0x2,%rcx
cmp    %ecx,%edi
jne    13a0 <kernel_strsv_t_2_lib8+0x2a0>
addps  %xmm2,%xmm1
movss  (%r8),%xmm0
movss  0x4(%r8),%xmm2
movaps %xmm1,%xmm3
shufps $0x55,%xmm1,%xmm3
subss  %xmm3,%xmm2
mulss  0x24(%rdx),%xmm2
movss  %xmm2,0x4(%r8)
mulss  0x4(%rdx),%xmm2
subss  %xmm2,%xmm0
subss  %xmm1,%xmm0
mulss  (%rdx),%xmm0
movss  %xmm0,(%r8)
ret

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

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