void kernel_strsv_t_3_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, y_2 = 0;
  x_3 = x[3];
  y_0 += A[3 + lda * 0] * x_3;
  y_1 += A[3 + lda * 1] * x_3;
  y_2 += A[3 + lda * 2] * x_3;
  k = 4;
  A += 4;
  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_2 += A[0 + lda * 2] * x_0;
    y_0 += A[1 + lda * 0] * x_1;
    y_1 += A[1 + lda * 1] * x_1;
    y_2 += A[1 + lda * 2] * x_1;
    y_0 += A[2 + lda * 0] * x_2;
    y_1 += A[2 + lda * 1] * x_2;
    y_2 += A[2 + lda * 2] * x_2;
    y_0 += A[3 + lda * 0] * x_3;
    y_1 += A[3 + lda * 1] * x_3;
    y_2 += A[3 + lda * 2] * x_3;
    A += 4;
    x += 4;
  }
  A += (sda - 1) * lda;
  for (; k < kmax - 4; k += 8) {
    x_0 = x[0];
    x_1 = x[1];
    x_2 = x[2];
    x_3 = x[3];
    y_0 += A[0 + lda * 0] * x_0;
    y_1 += A[0 + lda * 1] * x_0;
    y_2 += A[0 + lda * 2] * x_0;
    y_0 += A[1 + lda * 0] * x_1;
    y_1 += A[1 + lda * 1] * x_1;
    y_2 += A[1 + lda * 2] * x_1;
    y_0 += A[2 + lda * 0] * x_2;
    y_1 += A[2 + lda * 1] * x_2;
    y_2 += A[2 + lda * 2] * x_2;
    y_0 += A[3 + lda * 0] * x_3;
    y_1 += A[3 + lda * 1] * x_3;
    y_2 += A[3 + lda * 2] * x_3;
    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_2 += A[4 + lda * 2] * x_0;
    y_0 += A[5 + lda * 0] * x_1;
    y_1 += A[5 + lda * 1] * x_1;
    y_2 += A[5 + lda * 2] * x_1;
    y_0 += A[6 + lda * 0] * x_2;
    y_1 += A[6 + lda * 1] * x_2;
    y_2 += A[6 + lda * 2] * x_2;
    y_0 += A[7 + lda * 0] * x_3;
    y_1 += A[7 + lda * 1] * x_3;
    y_2 += A[7 + lda * 2] * 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_2 += A[0 + lda * 2] * x_0;
    y_0 += A[1 + lda * 0] * x_1;
    y_1 += A[1 + lda * 1] * x_1;
    y_2 += A[1 + lda * 2] * x_1;
    y_0 += A[2 + lda * 0] * x_2;
    y_1 += A[2 + lda * 1] * x_2;
    y_2 += A[2 + lda * 2] * x_2;
    y_0 += A[3 + lda * 0] * x_3;
    y_1 += A[3 + lda * 1] * x_3;
    y_2 += A[3 + lda * 2] * x_3;
    A += sda * bs;
    x += 4;
  }
  A = tA;
  x = tx;
  y_2 = x[2] - y_2;
  y_2 *= A[2 + lda * 2];
  x[2] = y_2;
  y_0 += A[2 + lda * 0] * y_2;
  y_1 += A[2 + lda * 1] * y_2;
  y_1 = x[1] - y_1;
  y_1 *= A[1 + lda * 1];
  x[1] = y_1;
  y_0 = x[0] - A[1 + lda * 0] * y_1 - y_0;
  y_0 *= A[0 + lda * 0];
  x[0] = y_0;
}


x86 assembly (clang, -O0):
<kernel_strsv_t_3_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_3_lib8+0x24>
jmp    1aa8 <kernel_strsv_t_3_lib8+0x9a8>
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)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  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
movss  0x4c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movl   $0x4,-0x2c(%rbp)
mov    -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    13d7 <kernel_strsv_t_3_lib8+0x2d7>
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  0x40(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  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  0x44(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  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  0x48(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  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
movss  0x4c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%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    11e7 <kernel_strsv_t_3_lib8+0xe7>
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    17a3 <kernel_strsv_t_3_lib8+0x6a3>
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  0x40(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  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  0x44(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  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  0x48(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  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
movss  0x4c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%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  0x50(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  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  0x54(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  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  0x58(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  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    -0x10(%rbp),%rax
movss  0x5c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x14(%rbp),%ecx
shl    $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    13f2 <kernel_strsv_t_3_lib8+0x2f2>
jmp    17a8 <kernel_strsv_t_3_lib8+0x6a8>
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    199c <kernel_strsv_t_3_lib8+0x89c>
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  0x40(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  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  0x44(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  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  0x48(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  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
movss  0x4c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x14(%rbp),%ecx
shl    $0x3,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x2c(%rbp)
jmp    17a8 <kernel_strsv_t_3_lib8+0x6a8>
mov    -0x38(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
subss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x48(%rax),%xmm0
mulss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
subss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  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_3_lib8>:
test   %edi,%edi
jle    1508 <kernel_strsv_t_3_lib8+0x408>
push   %rbx
movss  0xc(%r8),%xmm2
movss  0xc(%rdx),%xmm1
mulss  %xmm2,%xmm1
xorps  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x2c(%rdx),%xmm1
movss  0x4c(%rdx),%xmm3
unpcklps %xmm3,%xmm1
shufps $0x0,%xmm2,%xmm2
mulps  %xmm1,%xmm2
xorps  %xmm1,%xmm1
addps  %xmm2,%xmm1
lea    0x10(%r8),%rbx
mov    $0x4,%r9d
cmp    $0x4,%esi
jge    1150 <kernel_strsv_t_3_lib8+0x50>
mov    %rdx,%rax
jmp    1226 <kernel_strsv_t_3_lib8+0x126>
mov    $0x4,%r9d
mov    %rdx,%rax
nopl   0x0(%rax)
movss  (%rbx),%xmm3
movss  0x4(%rbx),%xmm2
movss  0x10(%rax),%xmm7
mulss  %xmm3,%xmm7
addss  %xmm0,%xmm7
movss  0x50(%rax),%xmm0
movss  0x30(%rax),%xmm4
unpcklps %xmm0,%xmm4
movss  0x34(%rax),%xmm6
movss  0x38(%rax),%xmm5
movss  0x3c(%rax),%xmm8
shufps $0x0,%xmm3,%xmm3
mulps  %xmm4,%xmm3
addps  %xmm1,%xmm3
movss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm1
addss  %xmm7,%xmm1
movss  0x54(%rax),%xmm0
unpcklps %xmm0,%xmm6
movss  0x18(%rax),%xmm4
movss  0x58(%rax),%xmm9
movss  0x1c(%rax),%xmm0
movss  0x5c(%rax),%xmm7
lea    0x10(%rax),%rax
shufps $0x0,%xmm2,%xmm2
mulps  %xmm6,%xmm2
movss  0x8(%rbx),%xmm6
addps  %xmm3,%xmm2
movss  0xc(%rbx),%xmm3
mulss  %xmm6,%xmm4
addss  %xmm1,%xmm4
unpcklps %xmm9,%xmm5
shufps $0x0,%xmm6,%xmm6
mulps  %xmm5,%xmm6
addps  %xmm2,%xmm6
mulss  %xmm3,%xmm0
addss  %xmm4,%xmm0
unpcklps %xmm7,%xmm8
shufps $0x0,%xmm3,%xmm3
mulps  %xmm8,%xmm3
movaps %xmm3,%xmm1
addps  %xmm6,%xmm1
add    $0x4,%r9d
add    $0x10,%rbx
cmp    %esi,%r9d
jle    1160 <kernel_strsv_t_3_lib8+0x60>
addps  %xmm6,%xmm3
movaps %xmm3,%xmm1
mov    %ecx,%esi
shl    $0x3,%esi
lea    -0x8(,%rcx,8),%ecx
movslq %ecx,%rcx
lea    (%rax,%rcx,4),%rcx
add    $0x10,%rcx
lea    -0x4(%rdi),%eax
movslq %esi,%r10
cmp    %eax,%r9d
jge    13c9 <kernel_strsv_t_3_lib8+0x2c9>
lea    0x0(,%r10,4),%r11
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rbx),%xmm5
movss  0x4(%rbx),%xmm3
movss  0x8(%rbx),%xmm2
movss  0xc(%rbx),%xmm4
movss  (%rcx),%xmm7
mulss  %xmm5,%xmm7
addss  %xmm0,%xmm7
movss  0x40(%rcx),%xmm0
movss  0x20(%rcx),%xmm6
unpcklps %xmm0,%xmm6
movss  0x24(%rcx),%xmm0
movss  0x28(%rcx),%xmm9
movss  0x2c(%rcx),%xmm8
shufps $0x0,%xmm5,%xmm5
mulps  %xmm6,%xmm5
addps  %xmm1,%xmm5
movss  0x4(%rcx),%xmm1
mulss  %xmm3,%xmm1
addss  %xmm7,%xmm1
movss  0x44(%rcx),%xmm6
unpcklps %xmm6,%xmm0
shufps $0x0,%xmm3,%xmm3
mulps  %xmm0,%xmm3
addps  %xmm5,%xmm3
movss  0x8(%rcx),%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x48(%rcx),%xmm1
unpcklps %xmm1,%xmm9
shufps $0x0,%xmm2,%xmm2
mulps  %xmm9,%xmm2
addps  %xmm3,%xmm2
movss  0xc(%rcx),%xmm5
mulss  %xmm4,%xmm5
addss  %xmm0,%xmm5
movss  0x4c(%rcx),%xmm0
unpcklps %xmm0,%xmm8
shufps $0x0,%xmm4,%xmm4
mulps  %xmm8,%xmm4
addps  %xmm2,%xmm4
movss  0x10(%rbx),%xmm1
movss  0x14(%rbx),%xmm0
movss  0x18(%rbx),%xmm3
movss  0x1c(%rbx),%xmm2
movss  0x10(%rcx),%xmm6
mulss  %xmm1,%xmm6
addss  %xmm5,%xmm6
movss  0x50(%rcx),%xmm5
movss  0x30(%rcx),%xmm7
unpcklps %xmm5,%xmm7
shufps $0x0,%xmm1,%xmm1
mulps  %xmm7,%xmm1
addps  %xmm4,%xmm1
movss  0x14(%rcx),%xmm4
mulss  %xmm0,%xmm4
addss  %xmm6,%xmm4
movss  0x54(%rcx),%xmm5
movss  0x34(%rcx),%xmm6
unpcklps %xmm5,%xmm6
shufps $0x0,%xmm0,%xmm0
mulps  %xmm6,%xmm0
addps  %xmm1,%xmm0
movss  0x18(%rcx),%xmm1
mulss  %xmm3,%xmm1
addss  %xmm4,%xmm1
movss  0x58(%rcx),%xmm4
movss  0x38(%rcx),%xmm5
unpcklps %xmm4,%xmm5
shufps $0x0,%xmm3,%xmm3
mulps  %xmm5,%xmm3
addps  %xmm0,%xmm3
movss  0x1c(%rcx),%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x5c(%rcx),%xmm1
movss  0x3c(%rcx),%xmm4
unpcklps %xmm1,%xmm4
shufps $0x0,%xmm2,%xmm2
mulps  %xmm4,%xmm2
movaps %xmm2,%xmm1
addps  %xmm3,%xmm1
add    $0x20,%rbx
add    $0x8,%r9d
add    %r11,%rcx
cmp    %eax,%r9d
jl     1260 <kernel_strsv_t_3_lib8+0x160>
addps  %xmm3,%xmm2
movaps %xmm2,%xmm1
cmp    %edi,%r9d
jge    14a5 <kernel_strsv_t_3_lib8+0x3a5>
add    $0x4c,%rcx
shl    $0x2,%r10
nopw   0x0(%rax,%rax,1)
movss  (%rbx),%xmm6
movss  0x4(%rbx),%xmm4
movss  0x8(%rbx),%xmm3
movss  0xc(%rbx),%xmm2
movss  -0x4c(%rcx),%xmm7
mulss  %xmm6,%xmm7
addss  %xmm0,%xmm7
movss  -0xc(%rcx),%xmm0
movss  -0x2c(%rcx),%xmm5
unpcklps %xmm0,%xmm5
movss  -0x28(%rcx),%xmm0
movss  -0x24(%rcx),%xmm9
movss  -0x20(%rcx),%xmm8
shufps $0x0,%xmm6,%xmm6
mulps  %xmm5,%xmm6
addps  %xmm1,%xmm6
movss  -0x48(%rcx),%xmm1
mulss  %xmm4,%xmm1
addss  %xmm7,%xmm1
movss  -0x8(%rcx),%xmm5
unpcklps %xmm5,%xmm0
shufps $0x0,%xmm4,%xmm4
mulps  %xmm0,%xmm4
addps  %xmm6,%xmm4
movss  -0x44(%rcx),%xmm5
mulss  %xmm3,%xmm5
addss  %xmm1,%xmm5
movss  -0x4(%rcx),%xmm0
unpcklps %xmm0,%xmm9
shufps $0x0,%xmm3,%xmm3
mulps  %xmm9,%xmm3
addps  %xmm4,%xmm3
movss  -0x40(%rcx),%xmm0
mulss  %xmm2,%xmm0
addss  %xmm5,%xmm0
movss  (%rcx),%xmm1
unpcklps %xmm1,%xmm8
shufps $0x0,%xmm2,%xmm2
mulps  %xmm8,%xmm2
movaps %xmm2,%xmm1
addps  %xmm3,%xmm1
add    $0x4,%r9d
add    %r10,%rcx
add    $0x10,%rbx
cmp    %edi,%r9d
jl     13e0 <kernel_strsv_t_3_lib8+0x2e0>
addps  %xmm3,%xmm2
movaps %xmm2,%xmm1
movss  0x8(%r8),%xmm2
movaps %xmm1,%xmm3
shufps $0x55,%xmm1,%xmm3
subss  %xmm3,%xmm2
mulss  0x48(%rdx),%xmm2
movss  %xmm2,0x8(%r8)
movss  0x8(%rdx),%xmm3
mulss  %xmm2,%xmm3
addss  %xmm0,%xmm3
mulss  0x28(%rdx),%xmm2
addss  %xmm1,%xmm2
movss  (%r8),%xmm0
movss  0x4(%r8),%xmm1
subss  %xmm2,%xmm1
mulss  0x24(%rdx),%xmm1
movss  %xmm1,0x4(%r8)
mulss  0x4(%rdx),%xmm1
subss  %xmm1,%xmm0
subss  %xmm3,%xmm0
mulss  (%rdx),%xmm0
movss  %xmm0,(%r8)
pop    %rbx
ret

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

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