void kernel_strsv_t_4_lib4(int kmax, float *A, int sda, float *x) {
  if (kmax <= 0)
    return;
  const int lda = 4;
  const int bs = 4;
  int k;
  float *tA, *tx;
  tA = A;
  tx = x;
  float x_0, x_1, x_2, x_3, y_0 = 0, y_1 = 0, y_2 = 0, y_3 = 0;
  k = 4;
  A += 4 + (sda - 1) * lda;
  x += 4;
  for (; k < kmax - 4; k += 8) {
    x_0 = x[0];
    x_1 = x[1];
    x_2 = x[2];
    x_3 = x[3];
    y_0 += A[0 + lda * 0] * x_0;
    y_1 += A[0 + lda * 1] * x_0;
    y_2 += A[0 + lda * 2] * x_0;
    y_3 += A[0 + lda * 3] * x_0;
    y_0 += A[1 + lda * 0] * x_1;
    y_1 += A[1 + lda * 1] * x_1;
    y_2 += A[1 + lda * 2] * x_1;
    y_3 += A[1 + lda * 3] * x_1;
    y_0 += A[2 + lda * 0] * x_2;
    y_1 += A[2 + lda * 1] * x_2;
    y_2 += A[2 + lda * 2] * x_2;
    y_3 += A[2 + lda * 3] * x_2;
    y_0 += A[3 + lda * 0] * x_3;
    y_1 += A[3 + lda * 1] * x_3;
    y_2 += A[3 + lda * 2] * x_3;
    y_3 += A[3 + lda * 3] * x_3;
    A += sda * bs;
    x += 4;
    x_0 = x[0];
    x_1 = x[1];
    x_2 = x[2];
    x_3 = x[3];
    y_0 += A[0 + lda * 0] * x_0;
    y_1 += A[0 + lda * 1] * x_0;
    y_2 += A[0 + lda * 2] * x_0;
    y_3 += A[0 + lda * 3] * x_0;
    y_0 += A[1 + lda * 0] * x_1;
    y_1 += A[1 + lda * 1] * x_1;
    y_2 += A[1 + lda * 2] * x_1;
    y_3 += A[1 + lda * 3] * x_1;
    y_0 += A[2 + lda * 0] * x_2;
    y_1 += A[2 + lda * 1] * x_2;
    y_2 += A[2 + lda * 2] * x_2;
    y_3 += A[2 + lda * 3] * x_2;
    y_0 += A[3 + lda * 0] * x_3;
    y_1 += A[3 + lda * 1] * x_3;
    y_2 += A[3 + lda * 2] * x_3;
    y_3 += A[3 + lda * 3] * x_3;
    A += sda * bs;
    x += 4;
  }
  for (; k < kmax; k += 4) {
    x_0 = x[0];
    x_1 = x[1];
    x_2 = x[2];
    x_3 = x[3];
    y_0 += A[0 + lda * 0] * x_0;
    y_1 += A[0 + lda * 1] * x_0;
    y_2 += A[0 + lda * 2] * x_0;
    y_3 += A[0 + lda * 3] * x_0;
    y_0 += A[1 + lda * 0] * x_1;
    y_1 += A[1 + lda * 1] * x_1;
    y_2 += A[1 + lda * 2] * x_1;
    y_3 += A[1 + lda * 3] * x_1;
    y_0 += A[2 + lda * 0] * x_2;
    y_1 += A[2 + lda * 1] * x_2;
    y_2 += A[2 + lda * 2] * x_2;
    y_3 += A[2 + lda * 3] * x_2;
    y_0 += A[3 + lda * 0] * x_3;
    y_1 += A[3 + lda * 1] * x_3;
    y_2 += A[3 + lda * 2] * x_3;
    y_3 += A[3 + lda * 3] * x_3;
    A += sda * bs;
    x += 4;
  }
  A = tA;
  x = tx;
  y_3 = x[3] - y_3;
  y_3 *= A[3 + lda * 3];
  x[3] = y_3;
  y_2 = x[2] - A[3 + lda * 2] * y_3 - y_2;
  y_2 *= A[2 + lda * 2];
  x[2] = y_2;
  y_0 += A[2 + lda * 0] * y_2 + A[3 + lda * 0] * y_3;
  y_1 += A[2 + lda * 1] * y_2 + A[3 + lda * 1] * y_3;
  y_1 = x[1] - y_1;
  y_1 *= A[1 + lda * 1];
  x[1] = y_1;
  y_0 = x[0] - A[1 + lda * 0] * y_1 - y_0;
  y_0 *= A[0 + lda * 0];
  x[0] = y_0;
}


x86 assembly (clang, -O0):
<kernel_strsv_t_4_lib4>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
cmpl   $0x0,-0x4(%rbp)
jg     1121 <kernel_strsv_t_4_lib4+0x21>
jmp    1a5b <kernel_strsv_t_4_lib4+0x95b>
movl   $0x4,-0x24(%rbp)
movl   $0x4,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x40(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
movl   $0x4,-0x2c(%rbp)
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x2,%ecx
add    $0x4,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x4,%ecx
cmp    %ecx,%eax
jge    1663 <kernel_strsv_t_4_lib4+0x563>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x14(%rbp),%ecx
shl    $0x2,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x14(%rbp),%ecx
shl    $0x2,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x2c(%rbp)
jmp    1190 <kernel_strsv_t_4_lib4+0x90>
jmp    1668 <kernel_strsv_t_4_lib4+0x568>
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    18dc <kernel_strsv_t_4_lib4+0x7dc>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x14(%rbp),%ecx
shl    $0x2,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x2c(%rbp)
jmp    1668 <kernel_strsv_t_4_lib4+0x568>
mov    -0x38(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
subss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
mulss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x60(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
subss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
mulss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x5c(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm1
mulss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x5c(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm1
mulss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
subss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
mulss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x58(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
subss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mulss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_strsv_t_4_lib4>:
test   %edi,%edi
jle    1494 <kernel_strsv_t_4_lib4+0x394>
push   %rbp
push   %r14
push   %rbx
shl    $0x2,%edx
movslq %edx,%r8
lea    (%rsi,%r8,4),%rdx
lea    0x10(%rcx),%r14
cmp    $0x9,%edi
jb     12fd <kernel_strsv_t_4_lib4+0x1fd>
lea    -0x4(%rdi),%r10d
lea    -0x9(%rdi),%r9d
and    $0xfffffff8,%r9d
lea    0x0(,%r8,8),%r11
lea    0x0(,%r8,4),%rbx
xorps  %xmm3,%xmm3
mov    $0x4,%ebp
nopw   0x0(%rax,%rax,1)
mov    %rdx,%rax
movss  0x30(%rdx),%xmm0
movss  0x20(%rdx),%xmm1
unpcklps %xmm0,%xmm1
movss  0x10(%rdx),%xmm0
movss  (%rdx),%xmm6
unpcklps %xmm0,%xmm6
movlhps %xmm1,%xmm6
movss  0x4(%rdx),%xmm7
movss  0x8(%rdx),%xmm4
movss  0xc(%rdx),%xmm8
movss  (%r14),%xmm1
movss  0x4(%r14),%xmm5
movss  0x8(%r14),%xmm2
movss  0xc(%r14),%xmm0
shufps $0x0,%xmm1,%xmm1
mulps  %xmm6,%xmm1
addps  %xmm3,%xmm1
movss  0x34(%rdx),%xmm3
movss  0x24(%rdx),%xmm6
unpcklps %xmm3,%xmm6
movss  0x14(%rdx),%xmm3
unpcklps %xmm3,%xmm7
movlhps %xmm6,%xmm7
shufps $0x0,%xmm5,%xmm5
mulps  %xmm7,%xmm5
addps  %xmm1,%xmm5
movss  0x38(%rdx),%xmm1
movss  0x28(%rdx),%xmm3
unpcklps %xmm1,%xmm3
movss  0x18(%rdx),%xmm1
unpcklps %xmm1,%xmm4
movlhps %xmm3,%xmm4
shufps $0x0,%xmm2,%xmm2
mulps  %xmm4,%xmm2
addps  %xmm5,%xmm2
movss  0x3c(%rdx),%xmm1
movss  0x2c(%rdx),%xmm3
unpcklps %xmm1,%xmm3
movss  0x1c(%rdx),%xmm1
unpcklps %xmm1,%xmm8
movlhps %xmm3,%xmm8
shufps $0x0,%xmm0,%xmm0
mulps  %xmm8,%xmm0
addps  %xmm2,%xmm0
lea    (%rdx,%rbx,1),%rdx
movss  0x30(%rax,%rbx,1),%xmm1
movss  0x20(%rax,%rbx,1),%xmm2
unpcklps %xmm1,%xmm2
movss  0x10(%rax,%rbx,1),%xmm1
movss  (%rax,%rbx,1),%xmm4
unpcklps %xmm1,%xmm4
movlhps %xmm2,%xmm4
movss  0x4(%rax,%rbx,1),%xmm2
movss  0x8(%rax,%rbx,1),%xmm3
movss  0xc(%rax,%rbx,1),%xmm1
movss  0x10(%r14),%xmm5
shufps $0x0,%xmm5,%xmm5
mulps  %xmm4,%xmm5
addps  %xmm0,%xmm5
movss  0x34(%rax,%rbx,1),%xmm0
movss  0x24(%rax,%rbx,1),%xmm4
unpcklps %xmm0,%xmm4
movss  0x14(%rax,%rbx,1),%xmm0
unpcklps %xmm0,%xmm2
movlhps %xmm4,%xmm2
movss  0x14(%r14),%xmm0
shufps $0x0,%xmm0,%xmm0
mulps  %xmm2,%xmm0
addps  %xmm5,%xmm0
movss  0x38(%rax,%rbx,1),%xmm2
movss  0x28(%rax,%rbx,1),%xmm4
unpcklps %xmm2,%xmm4
movss  0x18(%rax,%rbx,1),%xmm2
unpcklps %xmm2,%xmm3
movlhps %xmm4,%xmm3
movss  0x18(%r14),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm3,%xmm2
addps  %xmm0,%xmm2
movss  0x3c(%rax,%rbx,1),%xmm0
movss  0x2c(%rax,%rbx,1),%xmm3
unpcklps %xmm0,%xmm3
movss  0x1c(%rax,%rbx,1),%xmm0
unpcklps %xmm0,%xmm1
movlhps %xmm3,%xmm1
movss  0x1c(%r14),%xmm0
shufps $0x0,%xmm0,%xmm0
mulps  %xmm1,%xmm0
movaps %xmm0,%xmm3
addps  %xmm2,%xmm3
add    $0x8,%ebp
add    $0x20,%r14
add    %rbx,%rdx
cmp    %r10d,%ebp
jl     1150 <kernel_strsv_t_4_lib4+0x50>
add    %r11,%rax
addps  %xmm2,%xmm0
add    $0xc,%r9d
mov    %rax,%rdx
cmp    %edi,%r9d
jl     130f <kernel_strsv_t_4_lib4+0x20f>
jmp    13f3 <kernel_strsv_t_4_lib4+0x2f3>
xorps  %xmm0,%xmm0
mov    $0x4,%r9d
cmp    %edi,%r9d
jge    13f3 <kernel_strsv_t_4_lib4+0x2f3>
add    $0x3c,%rdx
shl    $0x2,%r8
nopw   0x0(%rax,%rax,1)
movss  -0xc(%rdx),%xmm1
movss  -0x1c(%rdx),%xmm2
unpcklps %xmm1,%xmm2
movss  -0x2c(%rdx),%xmm1
movss  -0x3c(%rdx),%xmm6
unpcklps %xmm1,%xmm6
movlhps %xmm2,%xmm6
movss  -0x38(%rdx),%xmm7
movss  -0x34(%rdx),%xmm4
movss  -0x30(%rdx),%xmm8
movss  (%r14),%xmm3
movss  0x4(%r14),%xmm5
movss  0x8(%r14),%xmm1
movss  0xc(%r14),%xmm2
shufps $0x0,%xmm3,%xmm3
mulps  %xmm6,%xmm3
addps  %xmm0,%xmm3
movss  -0x8(%rdx),%xmm0
movss  -0x18(%rdx),%xmm6
unpcklps %xmm0,%xmm6
movss  -0x28(%rdx),%xmm0
unpcklps %xmm0,%xmm7
movlhps %xmm6,%xmm7
shufps $0x0,%xmm5,%xmm5
mulps  %xmm7,%xmm5
addps  %xmm3,%xmm5
movss  -0x4(%rdx),%xmm0
movss  -0x14(%rdx),%xmm3
unpcklps %xmm0,%xmm3
movss  -0x24(%rdx),%xmm0
unpcklps %xmm0,%xmm4
movlhps %xmm3,%xmm4
shufps $0x0,%xmm1,%xmm1
mulps  %xmm4,%xmm1
addps  %xmm5,%xmm1
movss  (%rdx),%xmm0
movss  -0x10(%rdx),%xmm3
unpcklps %xmm0,%xmm3
movss  -0x20(%rdx),%xmm0
unpcklps %xmm0,%xmm8
movlhps %xmm3,%xmm8
shufps $0x0,%xmm2,%xmm2
mulps  %xmm8,%xmm2
movaps %xmm2,%xmm0
addps  %xmm1,%xmm0
add    $0x4,%r9d
add    %r8,%rdx
add    $0x10,%r14
cmp    %edi,%r9d
jl     1320 <kernel_strsv_t_4_lib4+0x220>
addps  %xmm1,%xmm2
movaps %xmm2,%xmm0
movss  0xc(%rcx),%xmm1
movaps %xmm0,%xmm2
shufps $0xff,%xmm0,%xmm2
subss  %xmm2,%xmm1
mulss  0x3c(%rsi),%xmm1
movss  %xmm1,0xc(%rcx)
movss  0x8(%rcx),%xmm2
movss  0x2c(%rsi),%xmm3
mulss  %xmm1,%xmm3
subss  %xmm3,%xmm2
movaps %xmm0,%xmm3
unpckhpd %xmm0,%xmm3
subss  %xmm3,%xmm2
mulss  0x28(%rsi),%xmm2
movss  %xmm2,0x8(%rcx)
movss  0xc(%rsi),%xmm3
mulss  %xmm1,%xmm3
movss  0x8(%rsi),%xmm4
mulss  %xmm2,%xmm4
addss  %xmm3,%xmm4
addss  %xmm0,%xmm4
mulss  0x1c(%rsi),%xmm1
mulss  0x18(%rsi),%xmm2
addss  %xmm1,%xmm2
shufps $0x55,%xmm0,%xmm0
addss  %xmm2,%xmm0
movss  (%rcx),%xmm1
movss  0x4(%rcx),%xmm2
subss  %xmm0,%xmm2
mulss  0x14(%rsi),%xmm2
movss  %xmm2,0x4(%rcx)
mulss  0x4(%rsi),%xmm2
subss  %xmm2,%xmm1
subss  %xmm4,%xmm1
mulss  (%rsi),%xmm1
movss  %xmm1,(%rcx)
pop    %rbx
pop    %r14
pop    %rbp
ret

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

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