void kernel_strsv_t_2_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;
  x_2 = x[2];
  x_3 = x[3];
  y_0 += A[2 + lda * 0] * x_2;
  y_1 += A[2 + lda * 1] * x_2;
  y_0 += A[3 + lda * 0] * x_3;
  y_1 += A[3 + lda * 1] * x_3;
  k = 4;
  A += 4 + (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_0 += A[1 + lda * 0] * x_1;
    y_1 += A[1 + lda * 1] * x_1;
    y_0 += A[2 + lda * 0] * x_2;
    y_1 += A[2 + lda * 1] * x_2;
    y_0 += A[3 + lda * 0] * x_3;
    y_1 += A[3 + lda * 1] * x_3;
    A += 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_0 += A[1 + lda * 0] * x_1;
    y_1 += A[1 + lda * 1] * x_1;
    y_0 += A[2 + lda * 0] * x_2;
    y_1 += A[2 + lda * 1] * x_2;
    y_0 += A[3 + lda * 0] * x_3;
    y_1 += A[3 + lda * 1] * x_3;
    A += 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_0 += A[1 + lda * 0] * x_1;
    y_1 += A[1 + lda * 1] * x_1;
    y_0 += A[2 + lda * 0] * x_2;
    y_1 += A[2 + lda * 1] * x_2;
    y_0 += A[3 + lda * 0] * x_3;
    y_1 += A[3 + lda * 1] * x_3;
    A += sda * bs;
    x += 4;
  }
  A = tA;
  x = tx;
  y_1 = x[1] - y_1;
  y_1 *= A[1 + lda * 1];
  x[1] = y_1;
  y_0 = x[0] - A[1 + lda * 0] * y_1 - y_0;
  y_0 *= A[0 + lda * 0];
  x[0] = y_0;
}


x86 assembly (clang, -O0):
<kernel_strsv_t_2_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_2_lib4+0x21>
jmp    1700 <kernel_strsv_t_2_lib4+0x600>
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)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  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  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)
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    14ef <kernel_strsv_t_2_lib4+0x3ef>
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  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  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  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    -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  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  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  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    -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    121c <kernel_strsv_t_2_lib4+0x11c>
jmp    14f4 <kernel_strsv_t_2_lib4+0x3f4>
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1668 <kernel_strsv_t_2_lib4+0x568>
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  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  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  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    -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    14f4 <kernel_strsv_t_2_lib4+0x3f4>
mov    -0x38(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
subss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  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_2_lib4>:
test   %edi,%edi
jle    1385 <kernel_strsv_t_2_lib4+0x285>
push   %rbp
push   %r14
push   %rbx
movss  0x8(%rsi),%xmm1
movss  0xc(%rsi),%xmm2
movss  0x18(%rsi),%xmm0
unpcklps %xmm0,%xmm1
movss  0x1c(%rsi),%xmm0
unpcklps %xmm0,%xmm2
movss  0x8(%rcx),%xmm3
movss  0xc(%rcx),%xmm0
shufps $0x0,%xmm3,%xmm3
mulps  %xmm1,%xmm3
xorps  %xmm1,%xmm1
addps  %xmm3,%xmm1
shufps $0x0,%xmm0,%xmm0
mulps  %xmm2,%xmm0
addps  %xmm1,%xmm0
shl    $0x2,%edx
movslq %edx,%r8
lea    (%rsi,%r8,4),%rbx
lea    0x10(%rcx),%rdx
mov    $0x4,%r9d
cmp    $0x9,%edi
jb     12ad <kernel_strsv_t_2_lib4+0x1ad>
lea    -0x4(%rdi),%r10d
lea    -0x9(%rdi),%r9d
and    $0xfffffff8,%r9d
lea    0x0(,%r8,8),%r11
lea    0x0(,%r8,4),%r14
mov    $0x4,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbx,%rax
movss  0x10(%rbx),%xmm1
movss  (%rbx),%xmm4
unpcklps %xmm1,%xmm4
movss  0x4(%rbx),%xmm5
movss  0x8(%rbx),%xmm6
movss  0xc(%rbx),%xmm8
movss  (%rdx),%xmm7
movss  0x4(%rdx),%xmm2
movss  0x8(%rdx),%xmm3
movss  0xc(%rdx),%xmm1
shufps $0x0,%xmm7,%xmm7
mulps  %xmm4,%xmm7
addps  %xmm0,%xmm7
movss  0x14(%rbx),%xmm0
unpcklps %xmm0,%xmm5
shufps $0x0,%xmm2,%xmm2
mulps  %xmm5,%xmm2
addps  %xmm7,%xmm2
movss  0x18(%rbx),%xmm0
unpcklps %xmm0,%xmm6
shufps $0x0,%xmm3,%xmm3
mulps  %xmm6,%xmm3
addps  %xmm2,%xmm3
movss  0x1c(%rbx),%xmm0
unpcklps %xmm0,%xmm8
shufps $0x0,%xmm1,%xmm1
mulps  %xmm8,%xmm1
addps  %xmm3,%xmm1
lea    (%rbx,%r14,1),%rbx
movss  0x10(%rax,%r14,1),%xmm0
movss  (%rax,%r14,1),%xmm2
unpcklps %xmm0,%xmm2
movss  0x4(%rax,%r14,1),%xmm3
movss  0x8(%rax,%r14,1),%xmm4
movss  0xc(%rax,%r14,1),%xmm0
movss  0x10(%rdx),%xmm5
shufps $0x0,%xmm5,%xmm5
mulps  %xmm2,%xmm5
addps  %xmm1,%xmm5
movss  0x14(%rax,%r14,1),%xmm1
unpcklps %xmm1,%xmm3
movss  0x14(%rdx),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm3,%xmm2
addps  %xmm5,%xmm2
movss  0x18(%rax,%r14,1),%xmm1
unpcklps %xmm1,%xmm4
movss  0x18(%rdx),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm4,%xmm1
addps  %xmm2,%xmm1
movss  0x1c(%rax,%r14,1),%xmm2
unpcklps %xmm2,%xmm0
movss  0x1c(%rdx),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm0,%xmm2
movaps %xmm2,%xmm0
addps  %xmm1,%xmm0
add    $0x8,%ebp
add    $0x20,%rdx
add    %r14,%rbx
cmp    %r10d,%ebp
jl     1190 <kernel_strsv_t_2_lib4+0x90>
add    %r11,%rax
addps  %xmm1,%xmm2
add    $0xc,%r9d
mov    %rax,%rbx
movaps %xmm2,%xmm0
cmp    %edi,%r9d
jge    134e <kernel_strsv_t_2_lib4+0x24e>
add    $0x1c,%rbx
shl    $0x2,%r8
xchg   %ax,%ax
movss  -0xc(%rbx),%xmm1
movss  -0x1c(%rbx),%xmm4
unpcklps %xmm1,%xmm4
movss  -0x18(%rbx),%xmm5
movss  -0x14(%rbx),%xmm6
movss  -0x10(%rbx),%xmm8
movss  (%rdx),%xmm7
movss  0x4(%rdx),%xmm3
movss  0x8(%rdx),%xmm1
movss  0xc(%rdx),%xmm2
shufps $0x0,%xmm7,%xmm7
mulps  %xmm4,%xmm7
addps  %xmm0,%xmm7
movss  -0x8(%rbx),%xmm0
unpcklps %xmm0,%xmm5
shufps $0x0,%xmm3,%xmm3
mulps  %xmm5,%xmm3
addps  %xmm7,%xmm3
movss  -0x4(%rbx),%xmm0
unpcklps %xmm0,%xmm6
shufps $0x0,%xmm1,%xmm1
mulps  %xmm6,%xmm1
addps  %xmm3,%xmm1
movss  (%rbx),%xmm0
unpcklps %xmm0,%xmm8
shufps $0x0,%xmm2,%xmm2
mulps  %xmm8,%xmm2
movaps %xmm2,%xmm0
addps  %xmm1,%xmm0
add    $0x4,%r9d
add    %r8,%rbx
add    $0x10,%rdx
cmp    %edi,%r9d
jl     12c0 <kernel_strsv_t_2_lib4+0x1c0>
addps  %xmm1,%xmm2
movaps %xmm2,%xmm0
movss  (%rcx),%xmm1
movss  0x4(%rcx),%xmm2
movaps %xmm0,%xmm3
shufps $0x55,%xmm0,%xmm3
subss  %xmm3,%xmm2
mulss  0x14(%rsi),%xmm2
movss  %xmm2,0x4(%rcx)
mulss  0x4(%rsi),%xmm2
subss  %xmm2,%xmm1
subss  %xmm0,%xmm1
mulss  (%rsi),%xmm1
movss  %xmm1,(%rcx)
pop    %rbx
pop    %r14
pop    %rbp
ret

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

LLVM IR (-O2):
define void @kernel_strsv_t_2_lib4(i32 %0, float* nocapture %1, i32 %2, float* nocapture %3) {
%5 = icmp slt i32 %0, 1
br i1 %5, label %224, label %6
6: ; preds = %4
%7 = getelementptr inbounds float, float* %3, i64 2
%8 = load float, float* %7
%9 = getelementptr inbounds float, float* %3, i64 3
%10 = load float, float* %9
%11 = getelementptr inbounds float, float* %1, i64 2
%12 = load float, float* %11
%13 = getelementptr inbounds float, float* %1, i64 6
%14 = load float, float* %13
%15 = insertelement <2 x float> poison, float %12, i64 0
%16 = insertelement <2 x float> %15, float %14, i64 1
%17 = insertelement <2 x float> poison, float %8, i64 0
%18 = shufflevector <2 x float> %17, <2 x float> poison, <2 x i32> zeroinitializer
%19 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %16, <2 x float> %18, <2 x float> zeroinitializer)
%20 = getelementptr inbounds float, float* %1, i64 3
%21 = load float, float* %20
%22 = getelementptr inbounds float, float* %1, i64 7
%23 = load float, float* %22
%24 = insertelement <2 x float> poison, float %21, i64 0
%25 = insertelement <2 x float> %24, float %23, i64 1
%26 = insertelement <2 x float> poison, float %10, i64 0
%27 = shufflevector <2 x float> %26, <2 x float> poison, <2 x i32> zeroinitializer
%28 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %25, <2 x float> %27, <2 x float> %19)
%29 = shl i32 %2, 2
%30 = sext i32 %29 to i64
%31 = add nsw i32 %0, -4
%32 = getelementptr inbounds float, float* %1, i64 %30
%33 = getelementptr inbounds float, float* %3, i64 4
%34 = icmp ugt i32 %0, 8
br i1 %34, label %35, label %48
35: ; preds = %6
%36 = add nsw i32 %0, -9
%37 = and i32 %36, -8
br label %54
38: ; preds = %54
%39 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %71, <2 x float> %73, <2 x float> %59)
%40 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %80, <2 x float> %82, <2 x float> %39)
%41 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %89, <2 x float> %91, <2 x float> %40)
%42 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %98, <2 x float> %100, <2 x float> %41)
%43 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %115, <2 x float> %117, <2 x float> %42)
%44 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %124, <2 x float> %126, <2 x float> %43)
%45 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %133, <2 x float> %135, <2 x float> %44)
%46 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %142, <2 x float> %144, <2 x float> %45)
%47 = add i32 %37, 12
br label %48
48: ; preds = %38, %6
%49 = phi i32 [ 4, %6 ], [ %47, %38 ]
%50 = phi float* [ %32, %6 ], [ %147, %38 ]
%51 = phi float* [ %33, %6 ], [ %148, %38 ]
%52 = phi <2 x float> [ %28, %6 ], [ %46, %38 ]
%53 = icmp slt i32 %49, %0
br i1 %53, label %150, label %206
54: ; preds = %35, %54
%55 = phi float* [ %148, %54 ], [ %33, %35 ]
%56 = phi float* [ %147, %54 ], [ %32, %35 ]
%57 = phi float* [ %103, %54 ], [ %3, %35 ]
%58 = phi i32 [ %146, %54 ], [ 4, %35 ]
%59 = phi <2 x float> [ %145, %54 ], [ %28, %35 ]
%60 = load float, float* %55
%61 = getelementptr inbounds float, float* %57, i64 5
%62 = load float, float* %61
%63 = getelementptr inbounds float, float* %57, i64 6
%64 = load float, float* %63
%65 = getelementptr inbounds float, float* %57, i64 7
%66 = load float, float* %65
%67 = load float, float* %56
%68 = getelementptr inbounds float, float* %56, i64 4
%69 = load float, float* %68
%70 = insertelement <2 x float> poison, float %67, i64 0
%71 = insertelement <2 x float> %70, float %69, i64 1
%72 = insertelement <2 x float> poison, float %60, i64 0
%73 = shufflevector <2 x float> %72, <2 x float> poison, <2 x i32> zeroinitializer
%74 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %71, <2 x float> %73, <2 x float> %59)
%75 = getelementptr inbounds float, float* %56, i64 1
%76 = load float, float* %75
%77 = getelementptr inbounds float, float* %56, i64 5
%78 = load float, float* %77
%79 = insertelement <2 x float> poison, float %76, i64 0
%80 = insertelement <2 x float> %79, float %78, i64 1
%81 = insertelement <2 x float> poison, float %62, i64 0
%82 = shufflevector <2 x float> %81, <2 x float> poison, <2 x i32> zeroinitializer
%83 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %80, <2 x float> %82, <2 x float> %74)
%84 = getelementptr inbounds float, float* %56, i64 2
%85 = load float, float* %84
%86 = getelementptr inbounds float, float* %56, i64 6
%87 = load float, float* %86
%88 = insertelement <2 x float> poison, float %85, i64 0
%89 = insertelement <2 x float> %88, float %87, i64 1
%90 = insertelement <2 x float> poison, float %64, i64 0
%91 = shufflevector <2 x float> %90, <2 x float> poison, <2 x i32> zeroinitializer
%92 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %89, <2 x float> %91, <2 x float> %83)
%93 = getelementptr inbounds float, float* %56, i64 3
%94 = load float, float* %93
%95 = getelementptr inbounds float, float* %56, i64 7
%96 = load float, float* %95
%97 = insertelement <2 x float> poison, float %94, i64 0
%98 = insertelement <2 x float> %97, float %96, i64 1
%99 = insertelement <2 x float> poison, float %66, i64 0
%100 = shufflevector <2 x float> %99, <2 x float> poison, <2 x i32> zeroinitializer
%101 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %98, <2 x float> %100, <2 x float> %92)
%102 = getelementptr inbounds float, float* %56, i64 %30
%103 = getelementptr inbounds float, float* %57, i64 8
%104 = load float, float* %103
%105 = getelementptr inbounds float, float* %57, i64 9
%106 = load float, float* %105
%107 = getelementptr inbounds float, float* %57, i64 10
%108 = load float, float* %107
%109 = getelementptr inbounds float, float* %57, i64 11
%110 = load float, float* %109
%111 = load float, float* %102
%112 = getelementptr inbounds float, float* %102, i64 4
%113 = load float, float* %112
%114 = insertelement <2 x float> poison, float %111, i64 0
%115 = insertelement <2 x float> %114, float %113, i64 1
%116 = insertelement <2 x float> poison, float %104, i64 0
%117 = shufflevector <2 x float> %116, <2 x float> poison, <2 x i32> zeroinitializer
%118 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %115, <2 x float> %117, <2 x float> %101)
%119 = getelementptr inbounds float, float* %102, i64 1
%120 = load float, float* %119
%121 = getelementptr inbounds float, float* %102, i64 5
%122 = load float, float* %121
%123 = insertelement <2 x float> poison, float %120, i64 0
%124 = insertelement <2 x float> %123, float %122, i64 1
%125 = insertelement <2 x float> poison, float %106, i64 0
%126 = shufflevector <2 x float> %125, <2 x float> poison, <2 x i32> zeroinitializer
%127 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %124, <2 x float> %126, <2 x float> %118)
%128 = getelementptr inbounds float, float* %102, i64 2
%129 = load float, float* %128
%130 = getelementptr inbounds float, float* %102, i64 6
%131 = load float, float* %130
%132 = insertelement <2 x float> poison, float %129, i64 0
%133 = insertelement <2 x float> %132, float %131, i64 1
%134 = insertelement <2 x float> poison, float %108, i64 0
%135 = shufflevector <2 x float> %134, <2 x float> poison, <2 x i32> zeroinitializer
%136 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %133, <2 x float> %135, <2 x float> %127)
%137 = getelementptr inbounds float, float* %102, i64 3
%138 = load float, float* %137
%139 = getelementptr inbounds float, float* %102, i64 7
%140 = load float, float* %139
%141 = insertelement <2 x float> poison, float %138, i64 0
%142 = insertelement <2 x float> %141, float %140, i64 1
%143 = insertelement <2 x float> poison, float %110, i64 0
%144 = shufflevector <2 x float> %143, <2 x float> poison, <2 x i32> zeroinitializer
%145 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %142, <2 x float> %144, <2 x float> %136)
%146 = add nuw nsw i32 %58, 8
%147 = getelementptr inbounds float, float* %102, i64 %30
%148 = getelementptr inbounds float, float* %57, i64 12
%149 = icmp slt i32 %146, %31
br i1 %149, label %54, label %38
150: ; preds = %48, %150
%151 = phi float* [ %197, %150 ], [ %50, %48 ]
%152 = phi float* [ %198, %150 ], [ %51, %48 ]
%153 = phi i32 [ %199, %150 ], [ %49, %48 ]
%154 = phi <2 x float> [ %196, %150 ], [ %52, %48 ]
%155 = load float, float* %152
%156 = getelementptr inbounds float, float* %152, i64 1
%157 = load float, float* %156
%158 = getelementptr inbounds float, float* %152, i64 2
%159 = load float, float* %158
%160 = getelementptr inbounds float, float* %152, i64 3
%161 = load float, float* %160
%162 = load float, float* %151
%163 = getelementptr inbounds float, float* %151, i64 4
%164 = load float, float* %163
%165 = insertelement <2 x float> poison, float %162, i64 0
%166 = insertelement <2 x float> %165, float %164, i64 1
%167 = insertelement <2 x float> poison, float %155, i64 0
%168 = shufflevector <2 x float> %167, <2 x float> poison, <2 x i32> zeroinitializer
%169 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %166, <2 x float> %168, <2 x float> %154)
%170 = getelementptr inbounds float, float* %151, i64 1
%171 = load float, float* %170
%172 = getelementptr inbounds float, float* %151, i64 5
%173 = load float, float* %172
%174 = insertelement <2 x float> poison, float %171, i64 0
%175 = insertelement <2 x float> %174, float %173, i64 1
%176 = insertelement <2 x float> poison, float %157, i64 0
%177 = shufflevector <2 x float> %176, <2 x float> poison, <2 x i32> zeroinitializer
%178 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %175, <2 x float> %177, <2 x float> %169)
%179 = getelementptr inbounds float, float* %151, i64 2
%180 = load float, float* %179
%181 = getelementptr inbounds float, float* %151, i64 6
%182 = load float, float* %181
%183 = insertelement <2 x float> poison, float %180, i64 0
%184 = insertelement <2 x float> %183, float %182, i64 1
%185 = insertelement <2 x float> poison, float %159, i64 0
%186 = shufflevector <2 x float> %185, <2 x float> poison, <2 x i32> zeroinitializer
%187 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %184, <2 x float> %186, <2 x float> %178)
%188 = getelementptr inbounds float, float* %151, i64 3
%189 = load float, float* %188
%190 = getelementptr inbounds float, float* %151, i64 7
%191 = load float, float* %190
%192 = insertelement <2 x float> poison, float %189, i64 0
%193 = insertelement <2 x float> %192, float %191, i64 1
%194 = insertelement <2 x float> poison, float %161, i64 0
%195 = shufflevector <2 x float> %194, <2 x float> poison, <2 x i32> zeroinitializer
%196 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %193, <2 x float> %195, <2 x float> %187)
%197 = getelementptr inbounds float, float* %151, i64 %30
%198 = getelementptr inbounds float, float* %152, i64 4
%199 = add nuw nsw i32 %153, 4
%200 = icmp slt i32 %199, %0
br i1 %200, label %150, label %201
201: ; preds = %150
%202 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %166, <2 x float> %168, <2 x float> %154)
%203 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %175, <2 x float> %177, <2 x float> %202)
%204 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %184, <2 x float> %186, <2 x float> %203)
%205 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %193, <2 x float> %195, <2 x float> %204)
br label %206
206: ; preds = %201, %48
%207 = phi <2 x float> [ %52, %48 ], [ %205, %201 ]
%208 = getelementptr inbounds float, float* %3, i64 1
%209 = load float, float* %208
%210 = extractelement <2 x float> %207, i64 1
%211 = fsub float %209, %210
%212 = getelementptr inbounds float, float* %1, i64 5
%213 = load float, float* %212
%214 = fmul float %211, %213
store float %214, float* %208
%215 = load float, float* %3
%216 = getelementptr inbounds float, float* %1, i64 1
%217 = load float, float* %216
%218 = fneg float %217
%219 = tail call float @llvm.fmuladd.f32(float %218, float %214, float %215)
%220 = extractelement <2 x float> %207, i64 0
%221 = fsub float %219, %220
%222 = load float, float* %1
%223 = fmul float %222, %221
store float %223, float* %3
br label %224
224: ; preds = %4, %206
ret void
}