void kernel_strsv_n_8_lib8(int kmax, int ksv, float *A, float *x, float *y) {
  const int lda = 8;
  int k;
  float x_0, x_1, x_2, x_3, y_0 = 0, y_1 = 0, y_2 = 0, y_3 = 0, y_4 = 0,
                            y_5 = 0, y_6 = 0, y_7 = 0;
  k = 0;
  for (; k < kmax - 7; k += 8) {
    x_0 = x[0];
    x_1 = x[1];
    x_2 = x[2];
    x_3 = x[3];
    y_0 += A[0 + lda * 0] * x_0;
    y_1 += A[1 + lda * 0] * x_0;
    y_2 += A[2 + lda * 0] * x_0;
    y_3 += A[3 + lda * 0] * x_0;
    y_4 += A[4 + lda * 0] * x_0;
    y_5 += A[5 + lda * 0] * x_0;
    y_6 += A[6 + lda * 0] * x_0;
    y_7 += A[7 + lda * 0] * x_0;
    y_0 += A[0 + lda * 1] * x_1;
    y_1 += A[1 + lda * 1] * x_1;
    y_2 += A[2 + lda * 1] * x_1;
    y_3 += A[3 + lda * 1] * x_1;
    y_4 += A[4 + lda * 1] * x_1;
    y_5 += A[5 + lda * 1] * x_1;
    y_6 += A[6 + lda * 1] * x_1;
    y_7 += A[7 + lda * 1] * x_1;
    y_0 += A[0 + lda * 2] * x_2;
    y_1 += A[1 + lda * 2] * x_2;
    y_2 += A[2 + lda * 2] * x_2;
    y_3 += A[3 + lda * 2] * x_2;
    y_4 += A[4 + lda * 2] * x_2;
    y_5 += A[5 + lda * 2] * x_2;
    y_6 += A[6 + lda * 2] * x_2;
    y_7 += A[7 + lda * 2] * x_2;
    y_0 += A[0 + lda * 3] * x_3;
    y_1 += A[1 + lda * 3] * x_3;
    y_2 += A[2 + lda * 3] * x_3;
    y_3 += A[3 + lda * 3] * x_3;
    y_4 += A[4 + lda * 3] * x_3;
    y_5 += A[5 + lda * 3] * x_3;
    y_6 += A[6 + lda * 3] * x_3;
    y_7 += A[7 + lda * 3] * x_3;
    A += 4 * lda;
    x += 4;
    x_0 = x[0];
    x_1 = x[1];
    x_2 = x[2];
    x_3 = x[3];
    y_0 += A[0 + lda * 0] * x_0;
    y_1 += A[1 + lda * 0] * x_0;
    y_2 += A[2 + lda * 0] * x_0;
    y_3 += A[3 + lda * 0] * x_0;
    y_4 += A[4 + lda * 0] * x_0;
    y_5 += A[5 + lda * 0] * x_0;
    y_6 += A[6 + lda * 0] * x_0;
    y_7 += A[7 + lda * 0] * x_0;
    y_0 += A[0 + lda * 1] * x_1;
    y_1 += A[1 + lda * 1] * x_1;
    y_2 += A[2 + lda * 1] * x_1;
    y_3 += A[3 + lda * 1] * x_1;
    y_4 += A[4 + lda * 1] * x_1;
    y_5 += A[5 + lda * 1] * x_1;
    y_6 += A[6 + lda * 1] * x_1;
    y_7 += A[7 + lda * 1] * x_1;
    y_0 += A[0 + lda * 2] * x_2;
    y_1 += A[1 + lda * 2] * x_2;
    y_2 += A[2 + lda * 2] * x_2;
    y_3 += A[3 + lda * 2] * x_2;
    y_4 += A[4 + lda * 2] * x_2;
    y_5 += A[5 + lda * 2] * x_2;
    y_6 += A[6 + lda * 2] * x_2;
    y_7 += A[7 + lda * 2] * x_2;
    y_0 += A[0 + lda * 3] * x_3;
    y_1 += A[1 + lda * 3] * x_3;
    y_2 += A[2 + lda * 3] * x_3;
    y_3 += A[3 + lda * 3] * x_3;
    y_4 += A[4 + lda * 3] * x_3;
    y_5 += A[5 + lda * 3] * x_3;
    y_6 += A[6 + lda * 3] * x_3;
    y_7 += A[7 + lda * 3] * x_3;
    A += 4 * lda;
    x += 4;
  }
  y_0 = y[0] - y_0;
  y_1 = y[1] - y_1;
  y_2 = y[2] - y_2;
  y_3 = y[3] - y_3;
  y_4 = y[4] - y_4;
  y_5 = y[5] - y_5;
  y_6 = y[6] - y_6;
  y_7 = y[7] - y_7;
  float a_00, a_10, a_20, a_30, a_40, a_50, a_60, a_70;
  a_00 = A[0 + lda * 0];
  a_10 = A[1 + lda * 0];
  a_20 = A[2 + lda * 0];
  a_30 = A[3 + lda * 0];
  a_40 = A[4 + lda * 0];
  a_50 = A[5 + lda * 0];
  a_60 = A[6 + lda * 0];
  a_70 = A[7 + lda * 0];
  y_0 *= a_00;
  y[0] = y_0;
  y_1 -= a_10 * y_0;
  y_2 -= a_20 * y_0;
  y_3 -= a_30 * y_0;
  y_4 -= a_40 * y_0;
  y_5 -= a_50 * y_0;
  y_6 -= a_60 * y_0;
  y_7 -= a_70 * y_0;
  if (ksv == 1) {
    y[1] = y_1;
    y[2] = y_2;
    y[3] = y_3;
    y[4] = y_4;
    y[5] = y_5;
    y[6] = y_6;
    y[7] = y_7;
    return;
  }
  a_10 = A[1 + lda * 1];
  a_20 = A[2 + lda * 1];
  a_30 = A[3 + lda * 1];
  a_40 = A[4 + lda * 1];
  a_50 = A[5 + lda * 1];
  a_60 = A[6 + lda * 1];
  a_70 = A[7 + lda * 1];
  y_1 *= a_10;
  y[1] = y_1;
  y_2 -= a_20 * y_1;
  y_3 -= a_30 * y_1;
  y_4 -= a_40 * y_1;
  y_5 -= a_50 * y_1;
  y_6 -= a_60 * y_1;
  y_7 -= a_70 * y_1;
  if (ksv == 2) {
    y[2] = y_2;
    y[3] = y_3;
    y[4] = y_4;
    y[5] = y_5;
    y[6] = y_6;
    y[7] = y_7;
    return;
  }
  a_20 = A[2 + lda * 2];
  a_30 = A[3 + lda * 2];
  a_40 = A[4 + lda * 2];
  a_50 = A[5 + lda * 2];
  a_60 = A[6 + lda * 2];
  a_70 = A[7 + lda * 2];
  y_2 *= a_20;
  y[2] = y_2;
  y_3 -= a_30 * y_2;
  y_4 -= a_40 * y_2;
  y_5 -= a_50 * y_2;
  y_6 -= a_60 * y_2;
  y_7 -= a_70 * y_2;
  if (ksv == 3) {
    y[3] = y_3;
    y[4] = y_4;
    y[5] = y_5;
    y[6] = y_6;
    y[7] = y_7;
    return;
  }
  a_30 = A[3 + lda * 3];
  a_40 = A[4 + lda * 3];
  a_50 = A[5 + lda * 3];
  a_60 = A[6 + lda * 3];
  a_70 = A[7 + lda * 3];
  y_3 *= a_30;
  y[3] = y_3;
  y_4 -= a_40 * y_3;
  y_5 -= a_50 * y_3;
  y_6 -= a_60 * y_3;
  y_7 -= a_70 * y_3;
  if (ksv == 4) {
    y[4] = y_4;
    y[5] = y_5;
    y[6] = y_6;
    y[7] = y_7;
    return;
  }
  a_40 = A[4 + lda * 4];
  a_50 = A[5 + lda * 4];
  a_60 = A[6 + lda * 4];
  a_70 = A[7 + lda * 4];
  y_4 *= a_40;
  y[4] = y_4;
  y_5 -= a_50 * y_4;
  y_6 -= a_60 * y_4;
  y_7 -= a_70 * y_4;
  if (ksv == 5) {
    y[5] = y_5;
    y[6] = y_6;
    y[7] = y_7;
    return;
  }
  a_50 = A[5 + lda * 5];
  a_60 = A[6 + lda * 5];
  a_70 = A[7 + lda * 5];
  y_5 *= a_50;
  y[5] = y_5;
  y_6 -= a_60 * y_5;
  y_7 -= a_70 * y_5;
  if (ksv == 6) {
    y[6] = y_6;
    y[7] = y_7;
    return;
  }
  a_60 = A[6 + lda * 6];
  a_70 = A[7 + lda * 6];
  y_6 *= a_60;
  y[6] = y_6;
  y_7 -= a_70 * y_6;
  if (ksv == 7) {
    y[7] = y_7;
    return;
  }
  a_70 = A[7 + lda * 7];
  y_7 *= a_70;
  y[7] = y_7;
}


x86 assembly (clang, -O0):
<kernel_strsv_n_8_lib8>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
movl   $0x8,-0x24(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x7,%ecx
cmp    %ecx,%eax
jge    1a23 <kernel_strsv_n_8_lib8+0x923>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  -0x30(%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  -0x30(%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  -0x34(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x44(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x48(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4c(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x50(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x54(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x58(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x5c(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x60(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x64(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x68(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x6c(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x70(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x74(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x78(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x7c(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
add    $0x80,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  -0x30(%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  -0x30(%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  -0x34(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x44(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x48(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4c(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x50(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x54(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x58(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x5c(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x60(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x64(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x68(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x6c(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x70(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x74(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x78(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x7c(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
add    $0x80,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x28(%rbp)
jmp    1164 <kernel_strsv_n_8_lib8+0x64>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
subss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
subss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
subss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
subss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movss  0x10(%rax),%xmm0
subss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x14(%rax),%xmm0
subss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movss  0x18(%rax),%xmm0
subss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x20(%rbp),%rax
movss  0x1c(%rax),%xmm0
subss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x5c(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x60(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x64(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x68(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x6c(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x70(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x74(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x78(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
cmpl   $0x1,-0x8(%rbp)
jne    1cd5 <kernel_strsv_n_8_lib8+0xbd5>
movss  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x44(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x1c(%rax)
jmp    2423 <kernel_strsv_n_8_lib8+0x1323>
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x60(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x64(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x68(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x6c(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x70(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x74(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x78(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
cmpl   $0x2,-0x8(%rbp)
jne    1ead <kernel_strsv_n_8_lib8+0xdad>
movss  -0x44(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x1c(%rax)
jmp    2423 <kernel_strsv_n_8_lib8+0x1323>
mov    -0x10(%rbp),%rax
movss  0x48(%rax),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4c(%rax),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0x50(%rax),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x54(%rax),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movss  0x58(%rax),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
movss  0x5c(%rax),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x64(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x68(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x6c(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x70(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x74(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x78(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
cmpl   $0x3,-0x8(%rbp)
jne    2040 <kernel_strsv_n_8_lib8+0xf40>
movss  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x1c(%rax)
jmp    2423 <kernel_strsv_n_8_lib8+0x1323>
mov    -0x10(%rbp),%rax
movss  0x6c(%rax),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0x70(%rax),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x74(%rax),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movss  0x78(%rax),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
movss  0x7c(%rax),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x68(%rbp),%xmm0
mulss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x6c(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x70(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x74(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x78(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
cmpl   $0x4,-0x8(%rbp)
jne    218e <kernel_strsv_n_8_lib8+0x108e>
movss  -0x4c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x1c(%rax)
jmp    2423 <kernel_strsv_n_8_lib8+0x1323>
mov    -0x10(%rbp),%rax
movss  0x90(%rax),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x94(%rax),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movss  0x98(%rax),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
movss  0x9c(%rax),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x6c(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x70(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x74(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x78(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
cmpl   $0x5,-0x8(%rbp)
jne    22a3 <kernel_strsv_n_8_lib8+0x11a3>
movss  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x1c(%rax)
jmp    2423 <kernel_strsv_n_8_lib8+0x1323>
mov    -0x10(%rbp),%rax
movss  0xb4(%rax),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movss  0xb8(%rax),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
movss  0xbc(%rax),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x70(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x74(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x78(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
cmpl   $0x6,-0x8(%rbp)
jne    2370 <kernel_strsv_n_8_lib8+0x1270>
movss  -0x54(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x1c(%rax)
jmp    2423 <kernel_strsv_n_8_lib8+0x1323>
mov    -0x10(%rbp),%rax
movss  0xd8(%rax),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
movss  0xdc(%rax),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x74(%rbp),%xmm0
mulss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x78(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
cmpl   $0x7,-0x8(%rbp)
jne    23f5 <kernel_strsv_n_8_lib8+0x12f5>
movss  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x1c(%rax)
jmp    2423 <kernel_strsv_n_8_lib8+0x1323>
mov    -0x10(%rbp),%rax
movss  0xfc(%rax),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x78(%rbp),%xmm0
mulss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x1c(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_strsv_n_8_lib8>:
xorps  %xmm0,%xmm0
cmp    $0x8,%edi
jl     12c1 <kernel_strsv_n_8_lib8+0x1c1>
add    $0xfffffff9,%edi
xorps  %xmm3,%xmm3
xor    %eax,%eax
xorps  %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movups 0x4(%rdx),%xmm4
movss  (%rcx,%rax,4),%xmm6
movss  0x4(%rcx,%rax,4),%xmm5
movss  0x8(%rcx,%rax,4),%xmm2
movss  0xc(%rcx,%rax,4),%xmm1
shufps $0x0,%xmm6,%xmm6
mulps  %xmm6,%xmm4
addps  %xmm0,%xmm4
movss  0x14(%rdx),%xmm0
movss  (%rdx),%xmm7
unpcklps %xmm0,%xmm7
movhps 0x18(%rdx),%xmm7
mulps  %xmm6,%xmm7
addps  %xmm3,%xmm7
movups 0x24(%rdx),%xmm0
shufps $0x0,%xmm5,%xmm5
mulps  %xmm5,%xmm0
movss  0x34(%rdx),%xmm3
movss  0x20(%rdx),%xmm6
unpcklps %xmm3,%xmm6
movhps 0x38(%rdx),%xmm6
addps  %xmm4,%xmm0
mulps  %xmm5,%xmm6
addps  %xmm7,%xmm6
movups 0x44(%rdx),%xmm3
shufps $0x0,%xmm2,%xmm2
mulps  %xmm2,%xmm3
addps  %xmm0,%xmm3
movss  0x54(%rdx),%xmm0
movss  0x40(%rdx),%xmm4
unpcklps %xmm0,%xmm4
movhps 0x58(%rdx),%xmm4
mulps  %xmm2,%xmm4
addps  %xmm6,%xmm4
movups 0x64(%rdx),%xmm0
shufps $0x0,%xmm1,%xmm1
mulps  %xmm1,%xmm0
addps  %xmm3,%xmm0
movss  0x74(%rdx),%xmm2
movss  0x60(%rdx),%xmm3
unpcklps %xmm2,%xmm3
movhps 0x78(%rdx),%xmm3
mulps  %xmm1,%xmm3
addps  %xmm4,%xmm3
movups 0x84(%rdx),%xmm1
movss  0x10(%rcx,%rax,4),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm2,%xmm1
addps  %xmm0,%xmm1
movss  0x94(%rdx),%xmm0
movss  0x80(%rdx),%xmm4
unpcklps %xmm0,%xmm4
movhps 0x98(%rdx),%xmm4
mulps  %xmm2,%xmm4
addps  %xmm3,%xmm4
movups 0xa4(%rdx),%xmm0
movss  0x14(%rcx,%rax,4),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm2,%xmm0
addps  %xmm1,%xmm0
movss  0xb4(%rdx),%xmm1
movss  0xa0(%rdx),%xmm3
unpcklps %xmm1,%xmm3
movhps 0xb8(%rdx),%xmm3
mulps  %xmm2,%xmm3
addps  %xmm4,%xmm3
movups 0xc4(%rdx),%xmm2
movss  0x18(%rcx,%rax,4),%xmm4
shufps $0x0,%xmm4,%xmm4
mulps  %xmm4,%xmm2
addps  %xmm0,%xmm2
movss  0xd4(%rdx),%xmm0
movss  0xc0(%rdx),%xmm1
unpcklps %xmm0,%xmm1
movhps 0xd8(%rdx),%xmm1
mulps  %xmm4,%xmm1
addps  %xmm3,%xmm1
movups 0xe4(%rdx),%xmm0
movss  0x1c(%rcx,%rax,4),%xmm3
shufps $0x0,%xmm3,%xmm3
mulps  %xmm3,%xmm0
addps  %xmm2,%xmm0
movss  0xf4(%rdx),%xmm2
movss  0xe0(%rdx),%xmm4
unpcklps %xmm2,%xmm4
movhps 0xf8(%rdx),%xmm4
mulps  %xmm3,%xmm4
movaps %xmm4,%xmm3
addps  %xmm1,%xmm3
add    $0x100,%rdx
add    $0x8,%rax
cmp    %edi,%eax
jl     1120 <kernel_strsv_n_8_lib8+0x20>
addps  %xmm1,%xmm4
jmp    12c4 <kernel_strsv_n_8_lib8+0x1c4>
xorps  %xmm4,%xmm4
movss  (%r8),%xmm5
subss  %xmm4,%xmm5
movups 0x4(%r8),%xmm1
subps  %xmm0,%xmm1
movss  0x14(%r8),%xmm3
movaps %xmm4,%xmm0
shufps $0x55,%xmm4,%xmm0
subss  %xmm0,%xmm3
movss  0x18(%r8),%xmm2
movaps %xmm4,%xmm0
unpckhpd %xmm4,%xmm0
subss  %xmm0,%xmm2
movss  0x1c(%r8),%xmm0
shufps $0xff,%xmm4,%xmm4
subss  %xmm4,%xmm0
movups 0x4(%rdx),%xmm4
mulss  (%rdx),%xmm5
movss  0x14(%rdx),%xmm6
mulss  %xmm5,%xmm6
movss  0x18(%rdx),%xmm7
mulss  %xmm5,%xmm7
subss  %xmm7,%xmm2
movss  0x1c(%rdx),%xmm7
mulss  %xmm5,%xmm7
subss  %xmm7,%xmm0
movss  %xmm5,(%r8)
shufps $0x0,%xmm5,%xmm5
mulps  %xmm4,%xmm5
subps  %xmm5,%xmm1
subss  %xmm6,%xmm3
cmp    $0x1,%esi
jne    1355 <kernel_strsv_n_8_lib8+0x255>
movups %xmm1,0x4(%r8)
movss  %xmm3,0x14(%r8)
jmp    139e <kernel_strsv_n_8_lib8+0x29e>
movups 0x28(%rdx),%xmm4
movss  0x24(%rdx),%xmm5
mulss  %xmm1,%xmm5
movss  0x38(%rdx),%xmm6
mulss  %xmm5,%xmm6
movss  0x3c(%rdx),%xmm7
mulss  %xmm5,%xmm7
movss  %xmm5,0x4(%r8)
shufps $0x0,%xmm5,%xmm5
mulps  %xmm4,%xmm5
shufps $0xf4,%xmm1,%xmm3
shufps $0x29,%xmm3,%xmm1
subps  %xmm5,%xmm1
subss  %xmm6,%xmm2
subss  %xmm7,%xmm0
cmp    $0x2,%esi
jne    13ab <kernel_strsv_n_8_lib8+0x2ab>
movups %xmm1,0x8(%r8)
movss  %xmm2,0x18(%r8)
movss  %xmm0,0x1c(%r8)
ret
movups 0x4c(%rdx),%xmm3
movss  0x48(%rdx),%xmm4
mulss  %xmm1,%xmm4
movss  0x5c(%rdx),%xmm5
mulss  %xmm4,%xmm5
movss  %xmm4,0x8(%r8)
shufps $0x0,%xmm4,%xmm4
mulps  %xmm3,%xmm4
shufps $0xf4,%xmm1,%xmm2
shufps $0x29,%xmm2,%xmm1
subps  %xmm4,%xmm1
subss  %xmm5,%xmm0
cmp    $0x3,%esi
jne    13ee <kernel_strsv_n_8_lib8+0x2ee>
movups %xmm1,0xc(%r8)
movss  %xmm0,0x1c(%r8)
ret
movss  0x6c(%rdx),%xmm2
mulss  %xmm1,%xmm2
movss  0x70(%rdx),%xmm4
mulss  %xmm2,%xmm4
movss  0x74(%rdx),%xmm5
mulss  %xmm2,%xmm5
movss  0x78(%rdx),%xmm6
mulss  %xmm2,%xmm6
movss  0x7c(%rdx),%xmm7
mulss  %xmm2,%xmm7
movss  %xmm2,0xc(%r8)
movaps %xmm1,%xmm3
shufps $0x55,%xmm1,%xmm3
subss  %xmm4,%xmm3
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
subss  %xmm5,%xmm2
shufps $0xff,%xmm1,%xmm1
subss  %xmm6,%xmm1
subss  %xmm7,%xmm0
cmp    $0x4,%esi
jne    1450 <kernel_strsv_n_8_lib8+0x350>
movss  %xmm3,0x10(%r8)
jmp    1493 <kernel_strsv_n_8_lib8+0x393>
mulss  0x90(%rdx),%xmm3
movss  0x94(%rdx),%xmm4
mulss  %xmm3,%xmm4
movss  0x98(%rdx),%xmm5
mulss  %xmm3,%xmm5
movss  0x9c(%rdx),%xmm6
mulss  %xmm3,%xmm6
movss  %xmm3,0x10(%r8)
subss  %xmm4,%xmm2
subss  %xmm5,%xmm1
subss  %xmm6,%xmm0
cmp    $0x5,%esi
jne    14a6 <kernel_strsv_n_8_lib8+0x3a6>
movss  %xmm2,0x14(%r8)
movss  %xmm1,0x18(%r8)
movss  %xmm0,0x1c(%r8)
ret
mulss  0xb4(%rdx),%xmm2
movss  0xb8(%rdx),%xmm3
mulss  %xmm2,%xmm3
movss  0xbc(%rdx),%xmm4
mulss  %xmm2,%xmm4
movss  %xmm2,0x14(%r8)
subss  %xmm3,%xmm1
subss  %xmm4,%xmm0
cmp    $0x6,%esi
je     1499 <kernel_strsv_n_8_lib8+0x399>
mulss  0xd8(%rdx),%xmm1
movss  0xdc(%rdx),%xmm2
mulss  %xmm1,%xmm2
movss  %xmm1,0x18(%r8)
subss  %xmm2,%xmm0
cmp    $0x7,%esi
je     1504 <kernel_strsv_n_8_lib8+0x404>
mulss  0xfc(%rdx),%xmm0
movss  %xmm0,0x1c(%r8)
ret

LLVM IR (-O0):
define void @kernel_strsv_n_8_lib8(i32 %0, i32 %1, float* %2, float* %3, float* %4) {
%6 = alloca i32
%7 = alloca i32
%8 = alloca float*
%9 = alloca float*
%10 = alloca float*
%11 = alloca i32
%12 = alloca i32
%13 = alloca float
%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
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca float
%27 = alloca float
%28 = alloca float
%29 = alloca float
%30 = alloca float
%31 = alloca float
%32 = alloca float
store i32 %0, i32* %6
store i32 %1, i32* %7
store float* %2, float** %8
store float* %3, float** %9
store float* %4, float** %10
store i32 8, i32* %11
store float 0.000000e+00, float* %17
store float 0.000000e+00, float* %18
store float 0.000000e+00, float* %19
store float 0.000000e+00, float* %20
store float 0.000000e+00, float* %21
store float 0.000000e+00, float* %22
store float 0.000000e+00, float* %23
store float 0.000000e+00, float* %24
store i32 0, i32* %12
br label %33
33: ; preds = %455, %5
%34 = load i32, i32* %12
%35 = load i32, i32* %6
%36 = sub nsw i32 %35, 7
%37 = icmp slt i32 %34, %36
br i1 %37, label %38, label %458
38: ; preds = %33
%39 = load float*, float** %9
%40 = getelementptr inbounds float, float* %39, i64 0
%41 = load float, float* %40
store float %41, float* %13
%42 = load float*, float** %9
%43 = getelementptr inbounds float, float* %42, i64 1
%44 = load float, float* %43
store float %44, float* %14
%45 = load float*, float** %9
%46 = getelementptr inbounds float, float* %45, i64 2
%47 = load float, float* %46
store float %47, float* %15
%48 = load float*, float** %9
%49 = getelementptr inbounds float, float* %48, i64 3
%50 = load float, float* %49
store float %50, float* %16
%51 = load float*, float** %8
%52 = getelementptr inbounds float, float* %51, i64 0
%53 = load float, float* %52
%54 = load float, float* %13
%55 = load float, float* %17
%56 = call float @llvm.fmuladd.f32(float %53, float %54, float %55)
store float %56, float* %17
%57 = load float*, float** %8
%58 = getelementptr inbounds float, float* %57, i64 1
%59 = load float, float* %58
%60 = load float, float* %13
%61 = load float, float* %18
%62 = call float @llvm.fmuladd.f32(float %59, float %60, float %61)
store float %62, float* %18
%63 = load float*, float** %8
%64 = getelementptr inbounds float, float* %63, i64 2
%65 = load float, float* %64
%66 = load float, float* %13
%67 = load float, float* %19
%68 = call float @llvm.fmuladd.f32(float %65, float %66, float %67)
store float %68, float* %19
%69 = load float*, float** %8
%70 = getelementptr inbounds float, float* %69, i64 3
%71 = load float, float* %70
%72 = load float, float* %13
%73 = load float, float* %20
%74 = call float @llvm.fmuladd.f32(float %71, float %72, float %73)
store float %74, float* %20
%75 = load float*, float** %8
%76 = getelementptr inbounds float, float* %75, i64 4
%77 = load float, float* %76
%78 = load float, float* %13
%79 = load float, float* %21
%80 = call float @llvm.fmuladd.f32(float %77, float %78, float %79)
store float %80, float* %21
%81 = load float*, float** %8
%82 = getelementptr inbounds float, float* %81, i64 5
%83 = load float, float* %82
%84 = load float, float* %13
%85 = load float, float* %22
%86 = call float @llvm.fmuladd.f32(float %83, float %84, float %85)
store float %86, float* %22
%87 = load float*, float** %8
%88 = getelementptr inbounds float, float* %87, i64 6
%89 = load float, float* %88
%90 = load float, float* %13
%91 = load float, float* %23
%92 = call float @llvm.fmuladd.f32(float %89, float %90, float %91)
store float %92, float* %23
%93 = load float*, float** %8
%94 = getelementptr inbounds float, float* %93, i64 7
%95 = load float, float* %94
%96 = load float, float* %13
%97 = load float, float* %24
%98 = call float @llvm.fmuladd.f32(float %95, float %96, float %97)
store float %98, float* %24
%99 = load float*, float** %8
%100 = getelementptr inbounds float, float* %99, i64 8
%101 = load float, float* %100
%102 = load float, float* %14
%103 = load float, float* %17
%104 = call float @llvm.fmuladd.f32(float %101, float %102, float %103)
store float %104, float* %17
%105 = load float*, float** %8
%106 = getelementptr inbounds float, float* %105, i64 9
%107 = load float, float* %106
%108 = load float, float* %14
%109 = load float, float* %18
%110 = call float @llvm.fmuladd.f32(float %107, float %108, float %109)
store float %110, float* %18
%111 = load float*, float** %8
%112 = getelementptr inbounds float, float* %111, i64 10
%113 = load float, float* %112
%114 = load float, float* %14
%115 = load float, float* %19
%116 = call float @llvm.fmuladd.f32(float %113, float %114, float %115)
store float %116, float* %19
%117 = load float*, float** %8
%118 = getelementptr inbounds float, float* %117, i64 11
%119 = load float, float* %118
%120 = load float, float* %14
%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 12
%125 = load float, float* %124
%126 = load float, float* %14
%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 13
%131 = load float, float* %130
%132 = load float, float* %14
%133 = load float, float* %22
%134 = call float @llvm.fmuladd.f32(float %131, float %132, float %133)
store float %134, float* %22
%135 = load float*, float** %8
%136 = getelementptr inbounds float, float* %135, i64 14
%137 = load float, float* %136
%138 = load float, float* %14
%139 = load float, float* %23
%140 = call float @llvm.fmuladd.f32(float %137, float %138, float %139)
store float %140, float* %23
%141 = load float*, float** %8
%142 = getelementptr inbounds float, float* %141, i64 15
%143 = load float, float* %142
%144 = load float, float* %14
%145 = load float, float* %24
%146 = call float @llvm.fmuladd.f32(float %143, float %144, float %145)
store float %146, float* %24
%147 = load float*, float** %8
%148 = getelementptr inbounds float, float* %147, i64 16
%149 = load float, float* %148
%150 = load float, float* %15
%151 = load float, float* %17
%152 = call float @llvm.fmuladd.f32(float %149, float %150, float %151)
store float %152, float* %17
%153 = load float*, float** %8
%154 = getelementptr inbounds float, float* %153, i64 17
%155 = load float, float* %154
%156 = load float, float* %15
%157 = load float, float* %18
%158 = call float @llvm.fmuladd.f32(float %155, float %156, float %157)
store float %158, float* %18
%159 = load float*, float** %8
%160 = getelementptr inbounds float, float* %159, i64 18
%161 = load float, float* %160
%162 = load float, float* %15
%163 = load float, float* %19
%164 = call float @llvm.fmuladd.f32(float %161, float %162, float %163)
store float %164, float* %19
%165 = load float*, float** %8
%166 = getelementptr inbounds float, float* %165, i64 19
%167 = load float, float* %166
%168 = load float, float* %15
%169 = load float, float* %20
%170 = call float @llvm.fmuladd.f32(float %167, float %168, float %169)
store float %170, float* %20
%171 = load float*, float** %8
%172 = getelementptr inbounds float, float* %171, i64 20
%173 = load float, float* %172
%174 = load float, float* %15
%175 = load float, float* %21
%176 = call float @llvm.fmuladd.f32(float %173, float %174, float %175)
store float %176, float* %21
%177 = load float*, float** %8
%178 = getelementptr inbounds float, float* %177, i64 21
%179 = load float, float* %178
%180 = load float, float* %15
%181 = load float, float* %22
%182 = call float @llvm.fmuladd.f32(float %179, float %180, float %181)
store float %182, float* %22
%183 = load float*, float** %8
%184 = getelementptr inbounds float, float* %183, i64 22
%185 = load float, float* %184
%186 = load float, float* %15
%187 = load float, float* %23
%188 = call float @llvm.fmuladd.f32(float %185, float %186, float %187)
store float %188, float* %23
%189 = load float*, float** %8
%190 = getelementptr inbounds float, float* %189, i64 23
%191 = load float, float* %190
%192 = load float, float* %15
%193 = load float, float* %24
%194 = call float @llvm.fmuladd.f32(float %191, float %192, float %193)
store float %194, float* %24
%195 = load float*, float** %8
%196 = getelementptr inbounds float, float* %195, i64 24
%197 = load float, float* %196
%198 = load float, float* %16
%199 = load float, float* %17
%200 = call float @llvm.fmuladd.f32(float %197, float %198, float %199)
store float %200, float* %17
%201 = load float*, float** %8
%202 = getelementptr inbounds float, float* %201, i64 25
%203 = load float, float* %202
%204 = load float, float* %16
%205 = load float, float* %18
%206 = call float @llvm.fmuladd.f32(float %203, float %204, float %205)
store float %206, float* %18
%207 = load float*, float** %8
%208 = getelementptr inbounds float, float* %207, i64 26
%209 = load float, float* %208
%210 = load float, float* %16
%211 = load float, float* %19
%212 = call float @llvm.fmuladd.f32(float %209, float %210, float %211)
store float %212, float* %19
%213 = load float*, float** %8
%214 = getelementptr inbounds float, float* %213, i64 27
%215 = load float, float* %214
%216 = load float, float* %16
%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 28
%221 = load float, float* %220
%222 = load float, float* %16
%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 29
%227 = load float, float* %226
%228 = load float, float* %16
%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 30
%233 = load float, float* %232
%234 = load float, float* %16
%235 = load float, float* %23
%236 = call float @llvm.fmuladd.f32(float %233, float %234, float %235)
store float %236, float* %23
%237 = load float*, float** %8
%238 = getelementptr inbounds float, float* %237, i64 31
%239 = load float, float* %238
%240 = load float, float* %16
%241 = load float, float* %24
%242 = call float @llvm.fmuladd.f32(float %239, float %240, float %241)
store float %242, float* %24
%243 = load float*, float** %8
%244 = getelementptr inbounds float, float* %243, i64 32
store float* %244, float** %8
%245 = load float*, float** %9
%246 = getelementptr inbounds float, float* %245, i64 4
store float* %246, float** %9
%247 = load float*, float** %9
%248 = getelementptr inbounds float, float* %247, i64 0
%249 = load float, float* %248
store float %249, float* %13
%250 = load float*, float** %9
%251 = getelementptr inbounds float, float* %250, i64 1
%252 = load float, float* %251
store float %252, float* %14
%253 = load float*, float** %9
%254 = getelementptr inbounds float, float* %253, i64 2
%255 = load float, float* %254
store float %255, float* %15
%256 = load float*, float** %9
%257 = getelementptr inbounds float, float* %256, i64 3
%258 = load float, float* %257
store float %258, float* %16
%259 = load float*, float** %8
%260 = getelementptr inbounds float, float* %259, i64 0
%261 = load float, float* %260
%262 = load float, float* %13
%263 = load float, float* %17
%264 = call float @llvm.fmuladd.f32(float %261, float %262, float %263)
store float %264, float* %17
%265 = load float*, float** %8
%266 = getelementptr inbounds float, float* %265, i64 1
%267 = load float, float* %266
%268 = load float, float* %13
%269 = load float, float* %18
%270 = call float @llvm.fmuladd.f32(float %267, float %268, float %269)
store float %270, float* %18
%271 = load float*, float** %8
%272 = getelementptr inbounds float, float* %271, i64 2
%273 = load float, float* %272
%274 = load float, float* %13
%275 = load float, float* %19
%276 = call float @llvm.fmuladd.f32(float %273, float %274, float %275)
store float %276, float* %19
%277 = load float*, float** %8
%278 = getelementptr inbounds float, float* %277, i64 3
%279 = load float, float* %278
%280 = load float, float* %13
%281 = load float, float* %20
%282 = call float @llvm.fmuladd.f32(float %279, float %280, float %281)
store float %282, float* %20
%283 = load float*, float** %8
%284 = getelementptr inbounds float, float* %283, i64 4
%285 = load float, float* %284
%286 = load float, float* %13
%287 = load float, float* %21
%288 = call float @llvm.fmuladd.f32(float %285, float %286, float %287)
store float %288, float* %21
%289 = load float*, float** %8
%290 = getelementptr inbounds float, float* %289, i64 5
%291 = load float, float* %290
%292 = load float, float* %13
%293 = load float, float* %22
%294 = call float @llvm.fmuladd.f32(float %291, float %292, float %293)
store float %294, float* %22
%295 = load float*, float** %8
%296 = getelementptr inbounds float, float* %295, i64 6
%297 = load float, float* %296
%298 = load float, float* %13
%299 = load float, float* %23
%300 = call float @llvm.fmuladd.f32(float %297, float %298, float %299)
store float %300, float* %23
%301 = load float*, float** %8
%302 = getelementptr inbounds float, float* %301, i64 7
%303 = load float, float* %302
%304 = load float, float* %13
%305 = load float, float* %24
%306 = call float @llvm.fmuladd.f32(float %303, float %304, float %305)
store float %306, float* %24
%307 = load float*, float** %8
%308 = getelementptr inbounds float, float* %307, i64 8
%309 = load float, float* %308
%310 = load float, float* %14
%311 = load float, float* %17
%312 = call float @llvm.fmuladd.f32(float %309, float %310, float %311)
store float %312, float* %17
%313 = load float*, float** %8
%314 = getelementptr inbounds float, float* %313, i64 9
%315 = load float, float* %314
%316 = load float, float* %14
%317 = load float, float* %18
%318 = call float @llvm.fmuladd.f32(float %315, float %316, float %317)
store float %318, float* %18
%319 = load float*, float** %8
%320 = getelementptr inbounds float, float* %319, i64 10
%321 = load float, float* %320
%322 = load float, float* %14
%323 = load float, float* %19
%324 = call float @llvm.fmuladd.f32(float %321, float %322, float %323)
store float %324, float* %19
%325 = load float*, float** %8
%326 = getelementptr inbounds float, float* %325, i64 11
%327 = load float, float* %326
%328 = load float, float* %14
%329 = load float, float* %20
%330 = call float @llvm.fmuladd.f32(float %327, float %328, float %329)
store float %330, float* %20
%331 = load float*, float** %8
%332 = getelementptr inbounds float, float* %331, i64 12
%333 = load float, float* %332
%334 = load float, float* %14
%335 = load float, float* %21
%336 = call float @llvm.fmuladd.f32(float %333, float %334, float %335)
store float %336, float* %21
%337 = load float*, float** %8
%338 = getelementptr inbounds float, float* %337, i64 13
%339 = load float, float* %338
%340 = load float, float* %14
%341 = load float, float* %22
%342 = call float @llvm.fmuladd.f32(float %339, float %340, float %341)
store float %342, float* %22
%343 = load float*, float** %8
%344 = getelementptr inbounds float, float* %343, i64 14
%345 = load float, float* %344
%346 = load float, float* %14
%347 = load float, float* %23
%348 = call float @llvm.fmuladd.f32(float %345, float %346, float %347)
store float %348, float* %23
%349 = load float*, float** %8
%350 = getelementptr inbounds float, float* %349, i64 15
%351 = load float, float* %350
%352 = load float, float* %14
%353 = load float, float* %24
%354 = call float @llvm.fmuladd.f32(float %351, float %352, float %353)
store float %354, float* %24
%355 = load float*, float** %8
%356 = getelementptr inbounds float, float* %355, i64 16
%357 = load float, float* %356
%358 = load float, float* %15
%359 = load float, float* %17
%360 = call float @llvm.fmuladd.f32(float %357, float %358, float %359)
store float %360, float* %17
%361 = load float*, float** %8
%362 = getelementptr inbounds float, float* %361, i64 17
%363 = load float, float* %362
%364 = load float, float* %15
%365 = load float, float* %18
%366 = call float @llvm.fmuladd.f32(float %363, float %364, float %365)
store float %366, float* %18
%367 = load float*, float** %8
%368 = getelementptr inbounds float, float* %367, i64 18
%369 = load float, float* %368
%370 = load float, float* %15
%371 = load float, float* %19
%372 = call float @llvm.fmuladd.f32(float %369, float %370, float %371)
store float %372, float* %19
%373 = load float*, float** %8
%374 = getelementptr inbounds float, float* %373, i64 19
%375 = load float, float* %374
%376 = load float, float* %15
%377 = load float, float* %20
%378 = call float @llvm.fmuladd.f32(float %375, float %376, float %377)
store float %378, float* %20
%379 = load float*, float** %8
%380 = getelementptr inbounds float, float* %379, i64 20
%381 = load float, float* %380
%382 = load float, float* %15
%383 = load float, float* %21
%384 = call float @llvm.fmuladd.f32(float %381, float %382, float %383)
store float %384, float* %21
%385 = load float*, float** %8
%386 = getelementptr inbounds float, float* %385, i64 21
%387 = load float, float* %386
%388 = load float, float* %15
%389 = load float, float* %22
%390 = call float @llvm.fmuladd.f32(float %387, float %388, float %389)
store float %390, float* %22
%391 = load float*, float** %8
%392 = getelementptr inbounds float, float* %391, i64 22
%393 = load float, float* %392
%394 = load float, float* %15
%395 = load float, float* %23
%396 = call float @llvm.fmuladd.f32(float %393, float %394, float %395)
store float %396, float* %23
%397 = load float*, float** %8
%398 = getelementptr inbounds float, float* %397, i64 23
%399 = load float, float* %398
%400 = load float, float* %15
%401 = load float, float* %24
%402 = call float @llvm.fmuladd.f32(float %399, float %400, float %401)
store float %402, float* %24
%403 = load float*, float** %8
%404 = getelementptr inbounds float, float* %403, i64 24
%405 = load float, float* %404
%406 = load float, float* %16
%407 = load float, float* %17
%408 = call float @llvm.fmuladd.f32(float %405, float %406, float %407)
store float %408, float* %17
%409 = load float*, float** %8
%410 = getelementptr inbounds float, float* %409, i64 25
%411 = load float, float* %410
%412 = load float, float* %16
%413 = load float, float* %18
%414 = call float @llvm.fmuladd.f32(float %411, float %412, float %413)
store float %414, float* %18
%415 = load float*, float** %8
%416 = getelementptr inbounds float, float* %415, i64 26
%417 = load float, float* %416
%418 = load float, float* %16
%419 = load float, float* %19
%420 = call float @llvm.fmuladd.f32(float %417, float %418, float %419)
store float %420, float* %19
%421 = load float*, float** %8
%422 = getelementptr inbounds float, float* %421, i64 27
%423 = load float, float* %422
%424 = load float, float* %16
%425 = load float, float* %20
%426 = call float @llvm.fmuladd.f32(float %423, float %424, float %425)
store float %426, float* %20
%427 = load float*, float** %8
%428 = getelementptr inbounds float, float* %427, i64 28
%429 = load float, float* %428
%430 = load float, float* %16
%431 = load float, float* %21
%432 = call float @llvm.fmuladd.f32(float %429, float %430, float %431)
store float %432, float* %21
%433 = load float*, float** %8
%434 = getelementptr inbounds float, float* %433, i64 29
%435 = load float, float* %434
%436 = load float, float* %16
%437 = load float, float* %22
%438 = call float @llvm.fmuladd.f32(float %435, float %436, float %437)
store float %438, float* %22
%439 = load float*, float** %8
%440 = getelementptr inbounds float, float* %439, i64 30
%441 = load float, float* %440
%442 = load float, float* %16
%443 = load float, float* %23
%444 = call float @llvm.fmuladd.f32(float %441, float %442, float %443)
store float %444, float* %23
%445 = load float*, float** %8
%446 = getelementptr inbounds float, float* %445, i64 31
%447 = load float, float* %446
%448 = load float, float* %16
%449 = load float, float* %24
%450 = call float @llvm.fmuladd.f32(float %447, float %448, float %449)
store float %450, float* %24
%451 = load float*, float** %8
%452 = getelementptr inbounds float, float* %451, i64 32
store float* %452, float** %8
%453 = load float*, float** %9
%454 = getelementptr inbounds float, float* %453, i64 4
store float* %454, float** %9
br label %455
455: ; preds = %38
%456 = load i32, i32* %12
%457 = add nsw i32 %456, 8
store i32 %457, i32* %12
br label %33
458: ; preds = %33
%459 = load float*, float** %10
%460 = getelementptr inbounds float, float* %459, i64 0
%461 = load float, float* %460
%462 = load float, float* %17
%463 = fsub float %461, %462
store float %463, float* %17
%464 = load float*, float** %10
%465 = getelementptr inbounds float, float* %464, i64 1
%466 = load float, float* %465
%467 = load float, float* %18
%468 = fsub float %466, %467
store float %468, float* %18
%469 = load float*, float** %10
%470 = getelementptr inbounds float, float* %469, i64 2
%471 = load float, float* %470
%472 = load float, float* %19
%473 = fsub float %471, %472
store float %473, float* %19
%474 = load float*, float** %10
%475 = getelementptr inbounds float, float* %474, i64 3
%476 = load float, float* %475
%477 = load float, float* %20
%478 = fsub float %476, %477
store float %478, float* %20
%479 = load float*, float** %10
%480 = getelementptr inbounds float, float* %479, i64 4
%481 = load float, float* %480
%482 = load float, float* %21
%483 = fsub float %481, %482
store float %483, float* %21
%484 = load float*, float** %10
%485 = getelementptr inbounds float, float* %484, i64 5
%486 = load float, float* %485
%487 = load float, float* %22
%488 = fsub float %486, %487
store float %488, float* %22
%489 = load float*, float** %10
%490 = getelementptr inbounds float, float* %489, i64 6
%491 = load float, float* %490
%492 = load float, float* %23
%493 = fsub float %491, %492
store float %493, float* %23
%494 = load float*, float** %10
%495 = getelementptr inbounds float, float* %494, i64 7
%496 = load float, float* %495
%497 = load float, float* %24
%498 = fsub float %496, %497
store float %498, float* %24
%499 = load float*, float** %8
%500 = getelementptr inbounds float, float* %499, i64 0
%501 = load float, float* %500
store float %501, float* %25
%502 = load float*, float** %8
%503 = getelementptr inbounds float, float* %502, i64 1
%504 = load float, float* %503
store float %504, float* %26
%505 = load float*, float** %8
%506 = getelementptr inbounds float, float* %505, i64 2
%507 = load float, float* %506
store float %507, float* %27
%508 = load float*, float** %8
%509 = getelementptr inbounds float, float* %508, i64 3
%510 = load float, float* %509
store float %510, float* %28
%511 = load float*, float** %8
%512 = getelementptr inbounds float, float* %511, i64 4
%513 = load float, float* %512
store float %513, float* %29
%514 = load float*, float** %8
%515 = getelementptr inbounds float, float* %514, i64 5
%516 = load float, float* %515
store float %516, float* %30
%517 = load float*, float** %8
%518 = getelementptr inbounds float, float* %517, i64 6
%519 = load float, float* %518
store float %519, float* %31
%520 = load float*, float** %8
%521 = getelementptr inbounds float, float* %520, i64 7
%522 = load float, float* %521
store float %522, float* %32
%523 = load float, float* %25
%524 = load float, float* %17
%525 = fmul float %524, %523
store float %525, float* %17
%526 = load float, float* %17
%527 = load float*, float** %10
%528 = getelementptr inbounds float, float* %527, i64 0
store float %526, float* %528
%529 = load float, float* %26
%530 = load float, float* %17
%531 = load float, float* %18
%532 = fneg float %529
%533 = call float @llvm.fmuladd.f32(float %532, float %530, float %531)
store float %533, float* %18
%534 = load float, float* %27
%535 = load float, float* %17
%536 = load float, float* %19
%537 = fneg float %534
%538 = call float @llvm.fmuladd.f32(float %537, float %535, float %536)
store float %538, float* %19
%539 = load float, float* %28
%540 = load float, float* %17
%541 = load float, float* %20
%542 = fneg float %539
%543 = call float @llvm.fmuladd.f32(float %542, float %540, float %541)
store float %543, float* %20
%544 = load float, float* %29
%545 = load float, float* %17
%546 = load float, float* %21
%547 = fneg float %544
%548 = call float @llvm.fmuladd.f32(float %547, float %545, float %546)
store float %548, float* %21
%549 = load float, float* %30
%550 = load float, float* %17
%551 = load float, float* %22
%552 = fneg float %549
%553 = call float @llvm.fmuladd.f32(float %552, float %550, float %551)
store float %553, float* %22
%554 = load float, float* %31
%555 = load float, float* %17
%556 = load float, float* %23
%557 = fneg float %554
%558 = call float @llvm.fmuladd.f32(float %557, float %555, float %556)
store float %558, float* %23
%559 = load float, float* %32
%560 = load float, float* %17
%561 = load float, float* %24
%562 = fneg float %559
%563 = call float @llvm.fmuladd.f32(float %562, float %560, float %561)
store float %563, float* %24
%564 = load i32, i32* %7
%565 = icmp eq i32 %564, 1
br i1 %565, label %566, label %588
566: ; preds = %458
%567 = load float, float* %18
%568 = load float*, float** %10
%569 = getelementptr inbounds float, float* %568, i64 1
store float %567, float* %569
%570 = load float, float* %19
%571 = load float*, float** %10
%572 = getelementptr inbounds float, float* %571, i64 2
store float %570, float* %572
%573 = load float, float* %20
%574 = load float*, float** %10
%575 = getelementptr inbounds float, float* %574, i64 3
store float %573, float* %575
%576 = load float, float* %21
%577 = load float*, float** %10
%578 = getelementptr inbounds float, float* %577, i64 4
store float %576, float* %578
%579 = load float, float* %22
%580 = load float*, float** %10
%581 = getelementptr inbounds float, float* %580, i64 5
store float %579, float* %581
%582 = load float, float* %23
%583 = load float*, float** %10
%584 = getelementptr inbounds float, float* %583, i64 6
store float %582, float* %584
%585 = load float, float* %24
%586 = load float*, float** %10
%587 = getelementptr inbounds float, float* %586, i64 7
store float %585, float* %587
br label %907
588: ; preds = %458
%589 = load float*, float** %8
%590 = getelementptr inbounds float, float* %589, i64 9
%591 = load float, float* %590
store float %591, float* %26
%592 = load float*, float** %8
%593 = getelementptr inbounds float, float* %592, i64 10
%594 = load float, float* %593
store float %594, float* %27
%595 = load float*, float** %8
%596 = getelementptr inbounds float, float* %595, i64 11
%597 = load float, float* %596
store float %597, float* %28
%598 = load float*, float** %8
%599 = getelementptr inbounds float, float* %598, i64 12
%600 = load float, float* %599
store float %600, float* %29
%601 = load float*, float** %8
%602 = getelementptr inbounds float, float* %601, i64 13
%603 = load float, float* %602
store float %603, float* %30
%604 = load float*, float** %8
%605 = getelementptr inbounds float, float* %604, i64 14
%606 = load float, float* %605
store float %606, float* %31
%607 = load float*, float** %8
%608 = getelementptr inbounds float, float* %607, i64 15
%609 = load float, float* %608
store float %609, float* %32
%610 = load float, float* %26
%611 = load float, float* %18
%612 = fmul float %611, %610
store float %612, float* %18
%613 = load float, float* %18
%614 = load float*, float** %10
%615 = getelementptr inbounds float, float* %614, i64 1
store float %613, float* %615
%616 = load float, float* %27
%617 = load float, float* %18
%618 = load float, float* %19
%619 = fneg float %616
%620 = call float @llvm.fmuladd.f32(float %619, float %617, float %618)
store float %620, float* %19
%621 = load float, float* %28
%622 = load float, float* %18
%623 = load float, float* %20
%624 = fneg float %621
%625 = call float @llvm.fmuladd.f32(float %624, float %622, float %623)
store float %625, float* %20
%626 = load float, float* %29
%627 = load float, float* %18
%628 = load float, float* %21
%629 = fneg float %626
%630 = call float @llvm.fmuladd.f32(float %629, float %627, float %628)
store float %630, float* %21
%631 = load float, float* %30
%632 = load float, float* %18
%633 = load float, float* %22
%634 = fneg float %631
%635 = call float @llvm.fmuladd.f32(float %634, float %632, float %633)
store float %635, float* %22
%636 = load float, float* %31
%637 = load float, float* %18
%638 = load float, float* %23
%639 = fneg float %636
%640 = call float @llvm.fmuladd.f32(float %639, float %637, float %638)
store float %640, float* %23
%641 = load float, float* %32
%642 = load float, float* %18
%643 = load float, float* %24
%644 = fneg float %641
%645 = call float @llvm.fmuladd.f32(float %644, float %642, float %643)
store float %645, float* %24
%646 = load i32, i32* %7
%647 = icmp eq i32 %646, 2
br i1 %647, label %648, label %667
648: ; preds = %588
%649 = load float, float* %19
%650 = load float*, float** %10
%651 = getelementptr inbounds float, float* %650, i64 2
store float %649, float* %651
%652 = load float, float* %20
%653 = load float*, float** %10
%654 = getelementptr inbounds float, float* %653, i64 3
store float %652, float* %654
%655 = load float, float* %21
%656 = load float*, float** %10
%657 = getelementptr inbounds float, float* %656, i64 4
store float %655, float* %657
%658 = load float, float* %22
%659 = load float*, float** %10
%660 = getelementptr inbounds float, float* %659, i64 5
store float %658, float* %660
%661 = load float, float* %23
%662 = load float*, float** %10
%663 = getelementptr inbounds float, float* %662, i64 6
store float %661, float* %663
%664 = load float, float* %24
%665 = load float*, float** %10
%666 = getelementptr inbounds float, float* %665, i64 7
store float %664, float* %666
br label %907
667: ; preds = %588
%668 = load float*, float** %8
%669 = getelementptr inbounds float, float* %668, i64 18
%670 = load float, float* %669
store float %670, float* %27
%671 = load float*, float** %8
%672 = getelementptr inbounds float, float* %671, i64 19
%673 = load float, float* %672
store float %673, float* %28
%674 = load float*, float** %8
%675 = getelementptr inbounds float, float* %674, i64 20
%676 = load float, float* %675
store float %676, float* %29
%677 = load float*, float** %8
%678 = getelementptr inbounds float, float* %677, i64 21
%679 = load float, float* %678
store float %679, float* %30
%680 = load float*, float** %8
%681 = getelementptr inbounds float, float* %680, i64 22
%682 = load float, float* %681
store float %682, float* %31
%683 = load float*, float** %8
%684 = getelementptr inbounds float, float* %683, i64 23
%685 = load float, float* %684
store float %685, float* %32
%686 = load float, float* %27
%687 = load float, float* %19
%688 = fmul float %687, %686
store float %688, float* %19
%689 = load float, float* %19
%690 = load float*, float** %10
%691 = getelementptr inbounds float, float* %690, i64 2
store float %689, float* %691
%692 = load float, float* %28
%693 = load float, float* %19
%694 = load float, float* %20
%695 = fneg float %692
%696 = call float @llvm.fmuladd.f32(float %695, float %693, float %694)
store float %696, float* %20
%697 = load float, float* %29
%698 = load float, float* %19
%699 = load float, float* %21
%700 = fneg float %697
%701 = call float @llvm.fmuladd.f32(float %700, float %698, float %699)
store float %701, float* %21
%702 = load float, float* %30
%703 = load float, float* %19
%704 = load float, float* %22
%705 = fneg float %702
%706 = call float @llvm.fmuladd.f32(float %705, float %703, float %704)
store float %706, float* %22
%707 = load float, float* %31
%708 = load float, float* %19
%709 = load float, float* %23
%710 = fneg float %707
%711 = call float @llvm.fmuladd.f32(float %710, float %708, float %709)
store float %711, float* %23
%712 = load float, float* %32
%713 = load float, float* %19
%714 = load float, float* %24
%715 = fneg float %712
%716 = call float @llvm.fmuladd.f32(float %715, float %713, float %714)
store float %716, float* %24
%717 = load i32, i32* %7
%718 = icmp eq i32 %717, 3
br i1 %718, label %719, label %735
719: ; preds = %667
%720 = load float, float* %20
%721 = load float*, float** %10
%722 = getelementptr inbounds float, float* %721, i64 3
store float %720, float* %722
%723 = load float, float* %21
%724 = load float*, float** %10
%725 = getelementptr inbounds float, float* %724, i64 4
store float %723, float* %725
%726 = load float, float* %22
%727 = load float*, float** %10
%728 = getelementptr inbounds float, float* %727, i64 5
store float %726, float* %728
%729 = load float, float* %23
%730 = load float*, float** %10
%731 = getelementptr inbounds float, float* %730, i64 6
store float %729, float* %731
%732 = load float, float* %24
%733 = load float*, float** %10
%734 = getelementptr inbounds float, float* %733, i64 7
store float %732, float* %734
br label %907
735: ; preds = %667
%736 = load float*, float** %8
%737 = getelementptr inbounds float, float* %736, i64 27
%738 = load float, float* %737
store float %738, float* %28
%739 = load float*, float** %8
%740 = getelementptr inbounds float, float* %739, i64 28
%741 = load float, float* %740
store float %741, float* %29
%742 = load float*, float** %8
%743 = getelementptr inbounds float, float* %742, i64 29
%744 = load float, float* %743
store float %744, float* %30
%745 = load float*, float** %8
%746 = getelementptr inbounds float, float* %745, i64 30
%747 = load float, float* %746
store float %747, float* %31
%748 = load float*, float** %8
%749 = getelementptr inbounds float, float* %748, i64 31
%750 = load float, float* %749
store float %750, float* %32
%751 = load float, float* %28
%752 = load float, float* %20
%753 = fmul float %752, %751
store float %753, float* %20
%754 = load float, float* %20
%755 = load float*, float** %10
%756 = getelementptr inbounds float, float* %755, i64 3
store float %754, float* %756
%757 = load float, float* %29
%758 = load float, float* %20
%759 = load float, float* %21
%760 = fneg float %757
%761 = call float @llvm.fmuladd.f32(float %760, float %758, float %759)
store float %761, float* %21
%762 = load float, float* %30
%763 = load float, float* %20
%764 = load float, float* %22
%765 = fneg float %762
%766 = call float @llvm.fmuladd.f32(float %765, float %763, float %764)
store float %766, float* %22
%767 = load float, float* %31
%768 = load float, float* %20
%769 = load float, float* %23
%770 = fneg float %767
%771 = call float @llvm.fmuladd.f32(float %770, float %768, float %769)
store float %771, float* %23
%772 = load float, float* %32
%773 = load float, float* %20
%774 = load float, float* %24
%775 = fneg float %772
%776 = call float @llvm.fmuladd.f32(float %775, float %773, float %774)
store float %776, float* %24
%777 = load i32, i32* %7
%778 = icmp eq i32 %777, 4
br i1 %778, label %779, label %792
779: ; preds = %735
%780 = load float, float* %21
%781 = load float*, float** %10
%782 = getelementptr inbounds float, float* %781, i64 4
store float %780, float* %782
%783 = load float, float* %22
%784 = load float*, float** %10
%785 = getelementptr inbounds float, float* %784, i64 5
store float %783, float* %785
%786 = load float, float* %23
%787 = load float*, float** %10
%788 = getelementptr inbounds float, float* %787, i64 6
store float %786, float* %788
%789 = load float, float* %24
%790 = load float*, float** %10
%791 = getelementptr inbounds float, float* %790, i64 7
store float %789, float* %791
br label %907
792: ; preds = %735
%793 = load float*, float** %8
%794 = getelementptr inbounds float, float* %793, i64 36
%795 = load float, float* %794
store float %795, float* %29
%796 = load float*, float** %8
%797 = getelementptr inbounds float, float* %796, i64 37
%798 = load float, float* %797
store float %798, float* %30
%799 = load float*, float** %8
%800 = getelementptr inbounds float, float* %799, i64 38
%801 = load float, float* %800
store float %801, float* %31
%802 = load float*, float** %8
%803 = getelementptr inbounds float, float* %802, i64 39
%804 = load float, float* %803
store float %804, float* %32
%805 = load float, float* %29
%806 = load float, float* %21
%807 = fmul float %806, %805
store float %807, float* %21
%808 = load float, float* %21
%809 = load float*, float** %10
%810 = getelementptr inbounds float, float* %809, i64 4
store float %808, float* %810
%811 = load float, float* %30
%812 = load float, float* %21
%813 = load float, float* %22
%814 = fneg float %811
%815 = call float @llvm.fmuladd.f32(float %814, float %812, float %813)
store float %815, float* %22
%816 = load float, float* %31
%817 = load float, float* %21
%818 = load float, float* %23
%819 = fneg float %816
%820 = call float @llvm.fmuladd.f32(float %819, float %817, float %818)
store float %820, float* %23
%821 = load float, float* %32
%822 = load float, float* %21
%823 = load float, float* %24
%824 = fneg float %821
%825 = call float @llvm.fmuladd.f32(float %824, float %822, float %823)
store float %825, float* %24
%826 = load i32, i32* %7
%827 = icmp eq i32 %826, 5
br i1 %827, label %828, label %838
828: ; preds = %792
%829 = load float, float* %22
%830 = load float*, float** %10
%831 = getelementptr inbounds float, float* %830, i64 5
store float %829, float* %831
%832 = load float, float* %23
%833 = load float*, float** %10
%834 = getelementptr inbounds float, float* %833, i64 6
store float %832, float* %834
%835 = load float, float* %24
%836 = load float*, float** %10
%837 = getelementptr inbounds float, float* %836, i64 7
store float %835, float* %837
br label %907
838: ; preds = %792
%839 = load float*, float** %8
%840 = getelementptr inbounds float, float* %839, i64 45
%841 = load float, float* %840
store float %841, float* %30
%842 = load float*, float** %8
%843 = getelementptr inbounds float, float* %842, i64 46
%844 = load float, float* %843
store float %844, float* %31
%845 = load float*, float** %8
%846 = getelementptr inbounds float, float* %845, i64 47
%847 = load float, float* %846
store float %847, float* %32
%848 = load float, float* %30
%849 = load float, float* %22
%850 = fmul float %849, %848
store float %850, float* %22
%851 = load float, float* %22
%852 = load float*, float** %10
%853 = getelementptr inbounds float, float* %852, i64 5
store float %851, float* %853
%854 = load float, float* %31
%855 = load float, float* %22
%856 = load float, float* %23
%857 = fneg float %854
%858 = call float @llvm.fmuladd.f32(float %857, float %855, float %856)
store float %858, float* %23
%859 = load float, float* %32
%860 = load float, float* %22
%861 = load float, float* %24
%862 = fneg float %859
%863 = call float @llvm.fmuladd.f32(float %862, float %860, float %861)
store float %863, float* %24
%864 = load i32, i32* %7
%865 = icmp eq i32 %864, 6
br i1 %865, label %866, label %873
866: ; preds = %838
%867 = load float, float* %23
%868 = load float*, float** %10
%869 = getelementptr inbounds float, float* %868, i64 6
store float %867, float* %869
%870 = load float, float* %24
%871 = load float*, float** %10
%872 = getelementptr inbounds float, float* %871, i64 7
store float %870, float* %872
br label %907
873: ; preds = %838
%874 = load float*, float** %8
%875 = getelementptr inbounds float, float* %874, i64 54
%876 = load float, float* %875
store float %876, float* %31
%877 = load float*, float** %8
%878 = getelementptr inbounds float, float* %877, i64 55
%879 = load float, float* %878
store float %879, float* %32
%880 = load float, float* %31
%881 = load float, float* %23
%882 = fmul float %881, %880
store float %882, float* %23
%883 = load float, float* %23
%884 = load float*, float** %10
%885 = getelementptr inbounds float, float* %884, i64 6
store float %883, float* %885
%886 = load float, float* %32
%887 = load float, float* %23
%888 = load float, float* %24
%889 = fneg float %886
%890 = call float @llvm.fmuladd.f32(float %889, float %887, float %888)
store float %890, float* %24
%891 = load i32, i32* %7
%892 = icmp eq i32 %891, 7
br i1 %892, label %893, label %897
893: ; preds = %873
%894 = load float, float* %24
%895 = load float*, float** %10
%896 = getelementptr inbounds float, float* %895, i64 7
store float %894, float* %896
br label %907
897: ; preds = %873
%898 = load float*, float** %8
%899 = getelementptr inbounds float, float* %898, i64 63
%900 = load float, float* %899
store float %900, float* %32
%901 = load float, float* %32
%902 = load float, float* %24
%903 = fmul float %902, %901
store float %903, float* %24
%904 = load float, float* %24
%905 = load float*, float** %10
%906 = getelementptr inbounds float, float* %905, i64 7
store float %904, float* %906
br label %907
907: ; preds = %897, %893, %866, %828, %779, %719, %648, %566
ret void
}

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