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 - 4; k += 8) {
    x_0 = x[0];
    x_1 = x[1];
    x_2 = x[2];
    x_3 = x[3];
    y_0 += A[0 + lda * 0] * x_0;
    y_1 += A[0 + lda * 1] * x_0;
    y_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 += 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 = 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    1836 <kernel_strsv_t_2_lib8+0x736>
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    $0x4,%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    179e <kernel_strsv_t_2_lib8+0x69e>
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    -0x2c(%rbp),%eax
add    $0x4,%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    1420 <kernel_strsv_t_2_lib8+0x320>
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    -0x4(%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    13e9 <kernel_strsv_t_2_lib8+0x2e9>
movss  0x2c(%rsi),%xmm1
movss  (%rsi),%xmm8
movss  0x4(%rsi),%xmm9
movss  0x8(%rsi),%xmm10
movss  0xc(%rsi),%xmm2
unpcklps %xmm1,%xmm2
movss  (%rax),%xmm5
movss  0x4(%rax),%xmm6
movss  0x8(%rax),%xmm7
movss  0xc(%rax),%xmm1
shufps $0x0,%xmm1,%xmm1
movss  0x28(%rsi),%xmm3
unpcklps %xmm3,%xmm10
shufps $0x0,%xmm7,%xmm7
movss  0x24(%rsi),%xmm3
unpcklps %xmm3,%xmm9
shufps $0x0,%xmm6,%xmm6
movss  0x20(%rsi),%xmm3
unpcklps %xmm3,%xmm8
shufps $0x0,%xmm5,%xmm5
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movaps %xmm8,%xmm3
mulps  %xmm5,%xmm3
addps  %xmm0,%xmm3
movaps %xmm9,%xmm0
mulps  %xmm6,%xmm0
addps  %xmm3,%xmm0
movaps %xmm10,%xmm3
mulps  %xmm7,%xmm3
addps  %xmm0,%xmm3
movaps %xmm2,%xmm4
mulps  %xmm1,%xmm4
movaps %xmm4,%xmm0
addps  %xmm3,%xmm0
add    $0x4,%r9d
cmp    %edi,%r9d
jl     13b0 <kernel_strsv_t_2_lib8+0x2b0>
addps  %xmm3,%xmm4
movaps %xmm4,%xmm0
movss  (%r8),%xmm1
movss  0x4(%r8),%xmm2
movaps %xmm0,%xmm3
shufps $0x55,%xmm0,%xmm3
subss  %xmm3,%xmm2
mulss  0x24(%rdx),%xmm2
movss  %xmm2,0x4(%r8)
mulss  0x4(%rdx),%xmm2
subss  %xmm2,%xmm1
subss  %xmm0,%xmm1
mulss  (%rdx),%xmm1
movss  %xmm1,(%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 %383
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, 4
%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 = %345, %279
%281 = load i32, i32* %13
%282 = load i32, i32* %6
%283 = icmp slt i32 %281, %282
br i1 %283, label %284, label %348
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** %10
%289 = getelementptr inbounds float, float* %288, i64 1
%290 = load float, float* %289
store float %290, float* %17
%291 = load float*, float** %10
%292 = getelementptr inbounds float, float* %291, i64 2
%293 = load float, float* %292
store float %293, float* %18
%294 = load float*, float** %10
%295 = getelementptr inbounds float, float* %294, i64 3
%296 = load float, float* %295
store float %296, float* %19
%297 = load float*, float** %8
%298 = getelementptr inbounds float, float* %297, i64 0
%299 = load float, float* %298
%300 = load float, float* %16
%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** %8
%304 = getelementptr inbounds float, float* %303, i64 8
%305 = load float, float* %304
%306 = load float, float* %16
%307 = load float, float* %21
%308 = call float @llvm.fmuladd.f32(float %305, float %306, float %307)
store float %308, float* %21
%309 = load float*, float** %8
%310 = getelementptr inbounds float, float* %309, i64 1
%311 = load float, float* %310
%312 = load float, float* %17
%313 = load float, float* %20
%314 = call float @llvm.fmuladd.f32(float %311, float %312, float %313)
store float %314, float* %20
%315 = load float*, float** %8
%316 = getelementptr inbounds float, float* %315, i64 9
%317 = load float, float* %316
%318 = load float, float* %17
%319 = load float, float* %21
%320 = call float @llvm.fmuladd.f32(float %317, float %318, float %319)
store float %320, float* %21
%321 = load float*, float** %8
%322 = getelementptr inbounds float, float* %321, i64 2
%323 = load float, float* %322
%324 = load float, float* %18
%325 = load float, float* %20
%326 = call float @llvm.fmuladd.f32(float %323, float %324, float %325)
store float %326, float* %20
%327 = load float*, float** %8
%328 = getelementptr inbounds float, float* %327, i64 10
%329 = load float, float* %328
%330 = load float, float* %18
%331 = load float, float* %21
%332 = call float @llvm.fmuladd.f32(float %329, float %330, float %331)
store float %332, float* %21
%333 = load float*, float** %8
%334 = getelementptr inbounds float, float* %333, i64 3
%335 = load float, float* %334
%336 = load float, float* %19
%337 = load float, float* %20
%338 = call float @llvm.fmuladd.f32(float %335, float %336, float %337)
store float %338, float* %20
%339 = load float*, float** %8
%340 = getelementptr inbounds float, float* %339, i64 11
%341 = load float, float* %340
%342 = load float, float* %19
%343 = load float, float* %21
%344 = call float @llvm.fmuladd.f32(float %341, float %342, float %343)
store float %344, float* %21
br label %345
345: ; preds = %284
%346 = load i32, i32* %13
%347 = add nsw i32 %346, 4
store i32 %347, i32* %13
br label %280
348: ; preds = %280
%349 = load float*, float** %14
store float* %349, float** %8
%350 = load float*, float** %15
store float* %350, float** %10
%351 = load float*, float** %10
%352 = getelementptr inbounds float, float* %351, i64 1
%353 = load float, float* %352
%354 = load float, float* %21
%355 = fsub float %353, %354
store float %355, float* %21
%356 = load float*, float** %8
%357 = getelementptr inbounds float, float* %356, i64 9
%358 = load float, float* %357
%359 = load float, float* %21
%360 = fmul float %359, %358
store float %360, float* %21
%361 = load float, float* %21
%362 = load float*, float** %10
%363 = getelementptr inbounds float, float* %362, i64 1
store float %361, float* %363
%364 = load float*, float** %10
%365 = getelementptr inbounds float, float* %364, i64 0
%366 = load float, float* %365
%367 = load float*, float** %8
%368 = getelementptr inbounds float, float* %367, i64 1
%369 = load float, float* %368
%370 = load float, float* %21
%371 = fneg float %369
%372 = call float @llvm.fmuladd.f32(float %371, float %370, float %366)
%373 = load float, float* %20
%374 = fsub float %372, %373
store float %374, float* %20
%375 = load float*, float** %8
%376 = getelementptr inbounds float, float* %375, i64 0
%377 = load float, float* %376
%378 = load float, float* %20
%379 = fmul float %378, %377
store float %379, float* %20
%380 = load float, float* %20
%381 = load float*, float** %10
%382 = getelementptr inbounds float, float* %381, i64 0
store float %380, float* %382
br label %383
383: ; preds = %348, %24
ret void
}

LLVM IR (-O2):
define void @kernel_strsv_t_2_lib8(i32 %0, i32 %1, float* %2, i32 %3, float* nocapture %4) {
%6 = icmp slt i32 %0, 1
br i1 %6, label %300, 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, -4
%100 = icmp slt i32 %90, %99
br i1 %100, label %101, label %112
101: ; preds = %89
%102 = sext i32 %95 to i64
br label %173
103: ; preds = %173
%104 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %189, <2 x float> %191, <2 x float> %177)
%105 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %198, <2 x float> %200, <2 x float> %104)
%106 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %207, <2 x float> %209, <2 x float> %105)
%107 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %216, <2 x float> %218, <2 x float> %106)
%108 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %233, <2 x float> %235, <2 x float> %107)
%109 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %242, <2 x float> %244, <2 x float> %108)
%110 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %251, <2 x float> %253, <2 x float> %109)
%111 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %260, <2 x float> %262, <2 x float> %110)
br label %112
112: ; preds = %103, %89
%113 = phi i32 [ %90, %89 ], [ %266, %103 ]
%114 = phi float* [ %92, %89 ], [ %265, %103 ]
%115 = phi float* [ %98, %89 ], [ %264, %103 ]
%116 = phi <2 x float> [ %93, %89 ], [ %111, %103 ]
%117 = icmp slt i32 %113, %0
br i1 %117, label %118, label %282
118: ; preds = %112
%119 = load float, float* %114
%120 = getelementptr inbounds float, float* %114, i64 1
%121 = load float, float* %120
%122 = getelementptr inbounds float, float* %114, i64 2
%123 = load float, float* %122
%124 = getelementptr inbounds float, float* %114, i64 3
%125 = load float, float* %124
%126 = load float, float* %115
%127 = getelementptr inbounds float, float* %115, i64 8
%128 = load float, float* %127
%129 = getelementptr inbounds float, float* %115, i64 1
%130 = load float, float* %129
%131 = getelementptr inbounds float, float* %115, i64 9
%132 = load float, float* %131
%133 = getelementptr inbounds float, float* %115, i64 2
%134 = load float, float* %133
%135 = getelementptr inbounds float, float* %115, i64 10
%136 = load float, float* %135
%137 = getelementptr inbounds float, float* %115, i64 3
%138 = load float, float* %137
%139 = getelementptr inbounds float, float* %115, i64 11
%140 = load float, float* %139
%141 = insertelement <2 x float> poison, float %138, i64 0
%142 = insertelement <2 x float> %141, float %140, i64 1
%143 = insertelement <2 x float> poison, float %125, i64 0
%144 = shufflevector <2 x float> %143, <2 x float> poison, <2 x i32> zeroinitializer
%145 = insertelement <2 x float> poison, float %134, i64 0
%146 = insertelement <2 x float> %145, float %136, i64 1
%147 = insertelement <2 x float> poison, float %123, i64 0
%148 = shufflevector <2 x float> %147, <2 x float> poison, <2 x i32> zeroinitializer
%149 = insertelement <2 x float> poison, float %130, i64 0
%150 = insertelement <2 x float> %149, float %132, i64 1
%151 = insertelement <2 x float> poison, float %121, i64 0
%152 = shufflevector <2 x float> %151, <2 x float> poison, <2 x i32> zeroinitializer
%153 = insertelement <2 x float> poison, float %126, i64 0
%154 = insertelement <2 x float> %153, float %128, i64 1
%155 = insertelement <2 x float> poison, float %119, i64 0
%156 = shufflevector <2 x float> %155, <2 x float> poison, <2 x i32> zeroinitializer
%157 = insertelement <2 x float> poison, float %138, i64 0
%158 = insertelement <2 x float> %157, float %140, i64 1
%159 = insertelement <2 x float> poison, float %125, i64 0
%160 = shufflevector <2 x float> %159, <2 x float> poison, <2 x i32> zeroinitializer
%161 = insertelement <2 x float> poison, float %134, i64 0
%162 = insertelement <2 x float> %161, float %136, i64 1
%163 = insertelement <2 x float> poison, float %123, i64 0
%164 = shufflevector <2 x float> %163, <2 x float> poison, <2 x i32> zeroinitializer
%165 = insertelement <2 x float> poison, float %130, i64 0
%166 = insertelement <2 x float> %165, float %132, i64 1
%167 = insertelement <2 x float> poison, float %121, i64 0
%168 = shufflevector <2 x float> %167, <2 x float> poison, <2 x i32> zeroinitializer
%169 = insertelement <2 x float> poison, float %126, i64 0
%170 = insertelement <2 x float> %169, float %128, i64 1
%171 = insertelement <2 x float> poison, float %119, i64 0
%172 = shufflevector <2 x float> %171, <2 x float> poison, <2 x i32> zeroinitializer
br label %268
173: ; preds = %101, %173
%174 = phi float* [ %98, %101 ], [ %264, %173 ]
%175 = phi float* [ %92, %101 ], [ %265, %173 ]
%176 = phi i32 [ %90, %101 ], [ %266, %173 ]
%177 = phi <2 x float> [ %93, %101 ], [ %263, %173 ]
%178 = load float, float* %175
%179 = getelementptr inbounds float, float* %175, i64 1
%180 = load float, float* %179
%181 = getelementptr inbounds float, float* %175, i64 2
%182 = load float, float* %181
%183 = getelementptr inbounds float, float* %175, i64 3
%184 = load float, float* %183
%185 = load float, float* %174
%186 = getelementptr inbounds float, float* %174, i64 8
%187 = load float, float* %186
%188 = insertelement <2 x float> poison, float %185, i64 0
%189 = insertelement <2 x float> %188, float %187, i64 1
%190 = insertelement <2 x float> poison, float %178, i64 0
%191 = shufflevector <2 x float> %190, <2 x float> poison, <2 x i32> zeroinitializer
%192 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %189, <2 x float> %191, <2 x float> %177)
%193 = getelementptr inbounds float, float* %174, i64 1
%194 = load float, float* %193
%195 = getelementptr inbounds float, float* %174, i64 9
%196 = load float, float* %195
%197 = insertelement <2 x float> poison, float %194, i64 0
%198 = insertelement <2 x float> %197, float %196, i64 1
%199 = insertelement <2 x float> poison, float %180, i64 0
%200 = shufflevector <2 x float> %199, <2 x float> poison, <2 x i32> zeroinitializer
%201 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %198, <2 x float> %200, <2 x float> %192)
%202 = getelementptr inbounds float, float* %174, i64 2
%203 = load float, float* %202
%204 = getelementptr inbounds float, float* %174, i64 10
%205 = load float, float* %204
%206 = insertelement <2 x float> poison, float %203, i64 0
%207 = insertelement <2 x float> %206, float %205, i64 1
%208 = insertelement <2 x float> poison, float %182, i64 0
%209 = shufflevector <2 x float> %208, <2 x float> poison, <2 x i32> zeroinitializer
%210 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %207, <2 x float> %209, <2 x float> %201)
%211 = getelementptr inbounds float, float* %174, i64 3
%212 = load float, float* %211
%213 = getelementptr inbounds float, float* %174, i64 11
%214 = load float, float* %213
%215 = insertelement <2 x float> poison, float %212, i64 0
%216 = insertelement <2 x float> %215, float %214, i64 1
%217 = insertelement <2 x float> poison, float %184, i64 0
%218 = shufflevector <2 x float> %217, <2 x float> poison, <2 x i32> zeroinitializer
%219 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %216, <2 x float> %218, <2 x float> %210)
%220 = getelementptr inbounds float, float* %175, i64 4
%221 = load float, float* %220
%222 = getelementptr inbounds float, float* %175, i64 5
%223 = load float, float* %222
%224 = getelementptr inbounds float, float* %175, i64 6
%225 = load float, float* %224
%226 = getelementptr inbounds float, float* %175, i64 7
%227 = load float, float* %226
%228 = getelementptr inbounds float, float* %174, i64 4
%229 = load float, float* %228
%230 = getelementptr inbounds float, float* %174, i64 12
%231 = load float, float* %230
%232 = insertelement <2 x float> poison, float %229, i64 0
%233 = insertelement <2 x float> %232, float %231, i64 1
%234 = insertelement <2 x float> poison, float %221, i64 0
%235 = shufflevector <2 x float> %234, <2 x float> poison, <2 x i32> zeroinitializer
%236 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %233, <2 x float> %235, <2 x float> %219)
%237 = getelementptr inbounds float, float* %174, i64 5
%238 = load float, float* %237
%239 = getelementptr inbounds float, float* %174, i64 13
%240 = load float, float* %239
%241 = insertelement <2 x float> poison, float %238, i64 0
%242 = insertelement <2 x float> %241, float %240, i64 1
%243 = insertelement <2 x float> poison, float %223, i64 0
%244 = shufflevector <2 x float> %243, <2 x float> poison, <2 x i32> zeroinitializer
%245 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %242, <2 x float> %244, <2 x float> %236)
%246 = getelementptr inbounds float, float* %174, i64 6
%247 = load float, float* %246
%248 = getelementptr inbounds float, float* %174, i64 14
%249 = load float, float* %248
%250 = insertelement <2 x float> poison, float %247, i64 0
%251 = insertelement <2 x float> %250, float %249, i64 1
%252 = insertelement <2 x float> poison, float %225, i64 0
%253 = shufflevector <2 x float> %252, <2 x float> poison, <2 x i32> zeroinitializer
%254 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %251, <2 x float> %253, <2 x float> %245)
%255 = getelementptr inbounds float, float* %174, i64 7
%256 = load float, float* %255
%257 = getelementptr inbounds float, float* %174, i64 15
%258 = load float, float* %257
%259 = insertelement <2 x float> poison, float %256, i64 0
%260 = insertelement <2 x float> %259, float %258, i64 1
%261 = insertelement <2 x float> poison, float %227, i64 0
%262 = shufflevector <2 x float> %261, <2 x float> poison, <2 x i32> zeroinitializer
%263 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %260, <2 x float> %262, <2 x float> %254)
%264 = getelementptr inbounds float, float* %174, i64 %102
%265 = getelementptr inbounds float, float* %175, i64 8
%266 = add nuw nsw i32 %176, 8
%267 = icmp slt i32 %266, %99
br i1 %267, label %173, label %103
268: ; preds = %118, %268
%269 = phi i32 [ %113, %118 ], [ %275, %268 ]
%270 = phi <2 x float> [ %116, %118 ], [ %274, %268 ]
%271 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %170, <2 x float> %172, <2 x float> %270)
%272 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %166, <2 x float> %168, <2 x float> %271)
%273 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %162, <2 x float> %164, <2 x float> %272)
%274 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %158, <2 x float> %160, <2 x float> %273)
%275 = add nuw nsw i32 %269, 4
%276 = icmp slt i32 %275, %0
br i1 %276, label %268, label %277
277: ; preds = %268
%278 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %154, <2 x float> %156, <2 x float> %270)
%279 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %150, <2 x float> %152, <2 x float> %278)
%280 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %146, <2 x float> %148, <2 x float> %279)
%281 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %142, <2 x float> %144, <2 x float> %280)
br label %282
282: ; preds = %277, %112
%283 = phi <2 x float> [ %116, %112 ], [ %281, %277 ]
%284 = getelementptr inbounds float, float* %4, i64 1
%285 = load float, float* %284
%286 = extractelement <2 x float> %283, i64 1
%287 = fsub float %285, %286
%288 = getelementptr inbounds float, float* %2, i64 9
%289 = load float, float* %288
%290 = fmul float %287, %289
store float %290, float* %284
%291 = load float, float* %4
%292 = getelementptr inbounds float, float* %2, i64 1
%293 = load float, float* %292
%294 = fneg float %293
%295 = tail call float @llvm.fmuladd.f32(float %294, float %290, float %291)
%296 = extractelement <2 x float> %283, i64 0
%297 = fsub float %295, %296
%298 = load float, float* %2
%299 = fmul float %298, %297
store float %299, float* %4
br label %300
300: ; preds = %5, %282
ret void
}