#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ fabs(float);
int /*<<< orphan*/ silk_bwexpander_FLP(float *, int, float);
void warped_true2monic_coefs(float *coefs, float lambda, float limit,
                             int order) {
  int i, iter, ind = 0;
  float tmp, maxabs, chirp, gain;
  for (i = order - 1; i > 0; i--) {
    coefs[i - 1] -= lambda * coefs[i];
  }
  gain = (1.0f - lambda * lambda) / (1.0f + lambda * coefs[0]);
  for (i = 0; i < order; i++) {
    coefs[i] *= gain;
  }
  for (iter = 0; iter < 10; iter++) {
    maxabs = -1.0f;
    for (i = 0; i < order; i++) {
      tmp = ((float)fabs(coefs[i]));
      if (tmp > maxabs) {
        maxabs = tmp;
        ind = i;
      }
    }
    if (maxabs <= limit) {
      return;
    }
    for (i = 1; i < order; i++) {
      coefs[i - 1] += lambda * coefs[i];
    }
    gain = 1.0f / gain;
    for (i = 0; i < order; i++) {
      coefs[i] *= gain;
    }
    chirp =
        0.99f - (0.8f + 0.1f * iter) * (maxabs - limit) / (maxabs * (ind + 1));
    silk_bwexpander_FLP(coefs, order, chirp);
    for (i = order - 1; i > 0; i--) {
      coefs[i - 1] -= lambda * coefs[i];
    }
    gain = (1.0f - lambda * lambda) / (1.0f + lambda * coefs[0]);
    for (i = 0; i < order; i++) {
      coefs[i] *= gain;
    }
  };
}


x86 assembly (clang, -O0):
<warped_true2monic_coefs>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
movss  %xmm1,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
jle    11a0 <warped_true2monic_coefs+0x80>
movss  -0xc(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    1149 <warped_true2monic_coefs+0x29>
movss  -0xc(%rbp),%xmm0
movss  -0xc(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm1,%xmm0
movss  0xe3d(%rip),%xmm1
addss  %xmm1,%xmm0
movss  -0xc(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm2
mulss  %xmm2,%xmm1
movss  0xe20(%rip),%xmm2
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1225 <warped_true2monic_coefs+0x105>
movss  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11f4 <warped_true2monic_coefs+0xd4>
movl   $0x0,-0x1c(%rbp)
cmpl   $0xa,-0x1c(%rbp)
jge    14b4 <warped_true2monic_coefs+0x394>
movss  0xdc6(%rip),%xmm0
movss  %xmm0,-0x28(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12a4 <warped_true2monic_coefs+0x184>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1040 <fabs@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x24(%rbp),%xmm0
ucomiss -0x28(%rbp),%xmm0
jbe    1291 <warped_true2monic_coefs+0x171>
movss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    1296 <warped_true2monic_coefs+0x176>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    124a <warped_true2monic_coefs+0x12a>
movss  -0x28(%rbp),%xmm1
movss  -0x10(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     12bc <warped_true2monic_coefs+0x19c>
jmp    14b4 <warped_true2monic_coefs+0x394>
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    130e <warped_true2monic_coefs+0x1ee>
movss  -0xc(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    12c3 <warped_true2monic_coefs+0x1a3>
movss  0xcea(%rip),%xmm0
divss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1358 <warped_true2monic_coefs+0x238>
movss  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1327 <warped_true2monic_coefs+0x207>
cvtsi2ssl -0x1c(%rbp),%xmm1
movss  0xca7(%rip),%xmm0
mulss  %xmm0,%xmm1
movss  0xc9f(%rip),%xmm0
addss  %xmm0,%xmm1
movss  -0x28(%rbp),%xmm0
subss  -0x10(%rbp),%xmm0
mulss  %xmm0,%xmm1
movss  -0x28(%rbp),%xmm0
mov    -0x20(%rbp),%eax
add    $0x1,%eax
cvtsi2ss %eax,%xmm2
mulss  %xmm2,%xmm0
divss  %xmm0,%xmm1
movss  0xc66(%rip),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%esi
movss  -0x2c(%rbp),%xmm0
call   1030 <silk_bwexpander_FLP@plt>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
jle    141c <warped_true2monic_coefs+0x2fc>
movss  -0xc(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    13c5 <warped_true2monic_coefs+0x2a5>
movss  -0xc(%rbp),%xmm0
movss  -0xc(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm1,%xmm0
movss  0xbc1(%rip),%xmm1
addss  %xmm1,%xmm0
movss  -0xc(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm2
mulss  %xmm2,%xmm1
movss  0xba4(%rip),%xmm2
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14a1 <warped_true2monic_coefs+0x381>
movss  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1470 <warped_true2monic_coefs+0x350>
jmp    14a6 <warped_true2monic_coefs+0x386>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    122c <warped_true2monic_coefs+0x10c>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<warped_true2monic_coefs>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %esi,%r12d
movss  %xmm1,0x1c(%rsp)
movaps %xmm0,%xmm8
mov    %rdi,%rbx
mov    $0xffffffff,%esi
lea    -0x1(%r12),%edi
movaps 0xeae(%rip),%xmm6
xorps  %xmm0,%xmm6
mov    %edi,%r10d
cmp    $0x2,%r12d
jl     11a1 <warped_true2monic_coefs+0x81>
cmp    $0x1,%edi
mov    %r10,%r9
adc    $0xffffffffffffffff,%r9
add    $0x1,%r9
cmp    $0x8,%r9
jae    19ae <warped_true2monic_coefs+0x88e>
mov    %r10,%rax
add    $0x1,%rax
nopl   (%rax)
lea    -0x2(%rax),%ecx
movss  -0x4(%rbx,%rax,4),%xmm0
mulss  %xmm6,%xmm0
addss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rbx,%rcx,4)
add    $0xffffffffffffffff,%rax
cmp    $0x1,%rax
ja     1180 <warped_true2monic_coefs+0x60>
movabs $0x3ffffffffffffffe,%r15
ff ff 3f
movaps %xmm6,%xmm2
mulss  %xmm8,%xmm2
movss  0xe55(%rip),%xmm3
addss  %xmm3,%xmm2
movss  (%rbx),%xmm0
movaps %xmm8,%xmm1
mulss  %xmm0,%xmm1
addss  %xmm3,%xmm1
movss  %xmm2,0x34(%rsp)
movaps %xmm2,%xmm7
divss  %xmm1,%xmm7
mov    %r12d,%ebp
test   %r12d,%r12d
jle    12c7 <warped_true2monic_coefs+0x1a7>
mulss  %xmm7,%xmm0
movss  %xmm0,(%rbx)
cmp    $0x1,%r12d
je     12c7 <warped_true2monic_coefs+0x1a7>
lea    -0x1(%rbp),%rcx
mov    $0x1,%eax
cmp    $0x8,%rcx
jb     12b0 <warped_true2monic_coefs+0x190>
mov    %rcx,%rax
and    $0xfffffffffffffff8,%rax
movaps %xmm7,%xmm0
shufps $0x0,%xmm7,%xmm0
lea    -0x8(%rax),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1ac3 <warped_true2monic_coefs+0x9a3>
mov    %rsi,%rdi
and    %r15,%rdi
mov    $0x1,%edx
xchg   %ax,%ax
movups (%rbx,%rdx,4),%xmm1
movups 0x10(%rbx,%rdx,4),%xmm2
movups 0x20(%rbx,%rdx,4),%xmm3
movups 0x30(%rbx,%rdx,4),%xmm4
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm2
movups %xmm1,(%rbx,%rdx,4)
movups %xmm2,0x10(%rbx,%rdx,4)
mulps  %xmm0,%xmm3
mulps  %xmm0,%xmm4
movups %xmm3,0x20(%rbx,%rdx,4)
movups %xmm4,0x30(%rbx,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1240 <warped_true2monic_coefs+0x120>
test   $0x1,%sil
je     129a <warped_true2monic_coefs+0x17a>
movups (%rbx,%rdx,4),%xmm1
movups 0x10(%rbx,%rdx,4),%xmm2
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm2
movups %xmm1,(%rbx,%rdx,4)
movups %xmm2,0x10(%rbx,%rdx,4)
cmp    %rax,%rcx
je     12c7 <warped_true2monic_coefs+0x1a7>
or     $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rbx,%rax,4),%xmm0
mulss  %xmm7,%xmm0
movss  %xmm0,(%rbx,%rax,4)
add    $0x1,%rax
cmp    %rax,%rbp
jne    12b0 <warped_true2monic_coefs+0x190>
lea    -0x1(%rbp),%rcx
test   %r10,%r10
mov    %r10,%r8
mov    $0x1,%r11d
cmovle %r10,%r11
mov    %r10,%rax
sub    %r11,%rax
lea    -0x2(%r12),%r9d
lea    (%r11,%r9,1),%rsi
sub    %r10,%rsi
mov    %rsi,0x8(%rsp)
lea    0x1(%r10),%rdx
sub    %r11,%rdx
mov    %rdx,0x20(%rsp)
mov    %ebp,%edx
and    $0xfffffff8,%edx
mov    %rdx,0xa0(%rsp)
add    $0xfffffffffffffff8,%rdx
mov    %rdx,0x98(%rsp)
shr    $0x3,%rdx
add    $0x1,%rdx
lea    -0x9(%rbp),%r13
mov    %r13,0x70(%rsp)
shr    $0x3,%r13
add    $0x1,%r13
mov    %ebp,%esi
and    $0xfffffffe,%esi
mov    %rsi,0xb0(%rsp)
mov    %rcx,0x10(%rsp)
mov    %rcx,%r14
and    $0xfffffffffffffff8,%r14
mov    %rdx,%rcx
mov    %rdx,0x90(%rsp)
and    %r15,%rdx
mov    %rdx,0x78(%rsp)
cmp    %eax,%r9d
setb   %dl
mov    %rax,%rdi
shr    $0x20,%rdi
setne  %cl
or     %dl,%cl
mov    $0x4,%edx
mul    %rdx
seto   %r10b
lea    (%rbx,%r9,4),%rsi
mov    %rsi,%rdi
sub    %rax,%rdi
cmp    %rsi,%rdi
seta   %dil
lea    (%rbx,%r8,4),%rdx
mov    %rdx,0xd0(%rsp)
mov    %rdx,%rsi
sub    %rax,%rsi
or     %r10b,%dil
cmp    %rdx,%rsi
seta   %al
or     %r10b,%al
or     %cl,%dil
mov    0x8(%rsp),%rcx
lea    (%rbx,%rcx,4),%rcx
or     %al,%dil
mov    %dil,0x7(%rsp)
lea    (%rbx,%r8,4),%rax
add    $0x4,%rax
cmp    %rax,%rcx
lea    0x4(%rbx,%r9,4),%rax
lea    (%rbx,%r11,4),%rcx
movaps %xmm8,%xmm5
shufps $0x0,%xmm8,%xmm5
setb   %dl
cmp    %rax,%rcx
setb   %al
and    %dl,%al
mov    %al,0x6(%rsp)
mov    0x20(%rsp),%r11
and    $0xfffffffffffffff8,%r11
mov    %r8,%rax
sub    %r11,%rax
mov    %rax,0x80(%rsp)
movaps %xmm6,%xmm0
shufps $0x0,%xmm6,%xmm0
movaps %xmm0,0xf0(%rsp)
mov    %r13,%rax
mov    %r13,0x68(%rsp)
and    %r13,%r15
mov    %r15,0x60(%rsp)
mov    %r11,0x88(%rsp)
neg    %r11
mov    %r11,0xc8(%rsp)
mov    %r8,0xc0(%rsp)
mov    $0xffffffff,%eax
add    %r8,%rax
mov    %rax,0xd8(%rsp)
lea    0x1(%r14),%rax
mov    %rax,0x38(%rsp)
xor    %eax,%eax
mov    %rax,0x28(%rsp)
xor    %r13d,%r13d
movaps %xmm8,0x50(%rsp)
movaps %xmm6,0x100(%rsp)
movaps %xmm5,0x40(%rsp)
mov    %r12,0xb8(%rsp)
mov    %r14,0xa8(%rsp)
jmp    14a6 <warped_true2monic_coefs+0x386>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x28(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x28(%rsp)
cmp    $0xa,%eax
je     199c <warped_true2monic_coefs+0x87c>
test   %r12d,%r12d
jle    1570 <warped_true2monic_coefs+0x450>
cmpq   $0x0,0x10(%rsp)
movaps %xmm7,0xe0(%rsp)
je     1580 <warped_true2monic_coefs+0x460>
xor    %r15d,%r15d
movss  0xb46(%rip),%xmm6
mov    0xb0(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
movss  %xmm6,0x8(%rsp)
movss  (%rbx,%r15,4),%xmm0
call   1040 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  0x8(%rsp),%xmm1
ucomiss %xmm1,%xmm0
mov    %r13d,%r12d
cmova  %r15d,%r12d
maxss  %xmm1,%xmm0
movss  %xmm0,0x8(%rsp)
movss  0x4(%rbx,%r15,4),%xmm0
call   1040 <fabs@plt>
xorps  %xmm6,%xmm6
cvtsi2ss %rax,%xmm6
movss  0x8(%rsp),%xmm0
ucomiss %xmm0,%xmm6
lea    0x1(%r15),%r13d
cmovbe %r12d,%r13d
maxss  %xmm0,%xmm6
add    $0x2,%r15
cmp    %r14,%r15
jne    14e0 <warped_true2monic_coefs+0x3c0>
mov    0xb8(%rsp),%r12
movaps 0x50(%rsp),%xmm8
mov    0xa8(%rsp),%r14
movaps 0xe0(%rsp),%xmm7
movaps 0x40(%rsp),%xmm5
test   $0x1,%bpl
jne    1591 <warped_true2monic_coefs+0x471>
jmp    15d1 <warped_true2monic_coefs+0x4b1>
movss  0xa9c(%rip),%xmm6
jmp    15d1 <warped_true2monic_coefs+0x4b1>
nopw   0x0(%rax,%rax,1)
xor    %r15d,%r15d
movss  0xa89(%rip),%xmm6
test   $0x1,%bpl
je     15d1 <warped_true2monic_coefs+0x4b1>
movss  (%rbx,%r15,4),%xmm0
movss  %xmm6,0x8(%rsp)
call   1040 <fabs@plt>
movaps 0x40(%rsp),%xmm5
movaps 0xe0(%rsp),%xmm7
movaps 0x50(%rsp),%xmm8
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  0x8(%rsp),%xmm1
ucomiss %xmm1,%xmm0
cmova  %r15d,%r13d
maxss  %xmm1,%xmm0
movaps %xmm0,%xmm6
movss  0x1c(%rsp),%xmm0
ucomiss %xmm6,%xmm0
mov    0xd8(%rsp),%r15
jae    199c <warped_true2monic_coefs+0x87c>
cmp    $0x2,%r12d
jl     1683 <warped_true2monic_coefs+0x563>
movss  (%rbx),%xmm0
mov    $0x1,%eax
cmpq   $0x8,0x10(%rsp)
jb     1660 <warped_true2monic_coefs+0x540>
shufps $0x0,%xmm0,%xmm0
xor    %eax,%eax
nopl   0x0(%rax)
movups 0x4(%rbx,%rax,4),%xmm1
shufps $0x3,%xmm1,%xmm0
shufps $0x98,%xmm1,%xmm0
movaps %xmm5,%xmm2
mulps  %xmm1,%xmm2
addps  %xmm0,%xmm2
movups 0x14(%rbx,%rax,4),%xmm0
shufps $0x3,%xmm0,%xmm1
shufps $0x98,%xmm0,%xmm1
movaps %xmm5,%xmm3
mulps  %xmm0,%xmm3
addps  %xmm1,%xmm3
movups %xmm2,(%rbx,%rax,4)
movups %xmm3,0x10(%rbx,%rax,4)
add    $0x8,%rax
cmp    %rax,%r14
jne    1610 <warped_true2monic_coefs+0x4f0>
cmp    %r14,0x10(%rsp)
je     1683 <warped_true2monic_coefs+0x563>
shufps $0xff,%xmm0,%xmm0
mov    0x38(%rsp),%rax
xchg   %ax,%ax
movss  (%rbx,%rax,4),%xmm1
movaps %xmm8,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,-0x4(%rbx,%rax,4)
add    $0x1,%rax
movaps %xmm1,%xmm0
cmp    %rax,%rbp
jne    1660 <warped_true2monic_coefs+0x540>
test   %r12d,%r12d
jle    1757 <warped_true2monic_coefs+0x637>
movss  0x97c(%rip),%xmm0
divss  %xmm7,%xmm0
cmp    $0x8,%r12d
jae    16b0 <warped_true2monic_coefs+0x590>
xor    %eax,%eax
jmp    1740 <warped_true2monic_coefs+0x620>
cs nopw 0x0(%rax,%rax,1)
nop
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x0,0x98(%rsp)
je     18de <warped_true2monic_coefs+0x7be>
mov    0x78(%rsp),%rcx
xor    %eax,%eax
nopl   (%rax)
movups (%rbx,%rax,4),%xmm2
movups 0x10(%rbx,%rax,4),%xmm3
movups 0x20(%rbx,%rax,4),%xmm4
movups 0x30(%rbx,%rax,4),%xmm5
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rbx,%rax,4)
movups %xmm3,0x10(%rbx,%rax,4)
mulps  %xmm1,%xmm4
mulps  %xmm1,%xmm5
movups %xmm4,0x20(%rbx,%rax,4)
movups %xmm5,0x30(%rbx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    16d0 <warped_true2monic_coefs+0x5b0>
testb  $0x1,0x90(%rsp)
01
je     172e <warped_true2monic_coefs+0x60e>
movups (%rbx,%rax,4),%xmm2
movups 0x10(%rbx,%rax,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rbx,%rax,4)
movups %xmm3,0x10(%rbx,%rax,4)
mov    0xa0(%rsp),%rcx
mov    %rcx,%rax
cmp    %rbp,%rcx
je     1757 <warped_true2monic_coefs+0x637>
xchg   %ax,%ax
movss  (%rbx,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rbx,%rax,4)
add    $0x1,%rax
cmp    %rax,%rbp
jne    1740 <warped_true2monic_coefs+0x620>
xorps  %xmm0,%xmm0
cvtsi2ssl 0x28(%rsp),%xmm0
mulss  0x8b0(%rip),%xmm0
addss  0x8ac(%rip),%xmm0
movaps %xmm6,%xmm1
subss  0x1c(%rsp),%xmm1
lea    0x1(%r13),%eax
xorps  %xmm2,%xmm2
cvtsi2ss %eax,%xmm2
mulss  %xmm0,%xmm1
mulss  %xmm6,%xmm2
divss  %xmm2,%xmm1
movss  0x888(%rip),%xmm0
subss  %xmm1,%xmm0
mov    %rbx,%rdi
mov    %r12d,%esi
call   1030 <silk_bwexpander_FLP@plt>
movaps 0x40(%rsp),%xmm5
cmp    $0x2,%r12d
movaps 0x50(%rsp),%xmm8
movaps 0x100(%rsp),%xmm6
mov    0xd0(%rsp),%rdx
mov    0xc8(%rsp),%rsi
jl     1881 <warped_true2monic_coefs+0x761>
cmpq   $0x8,0x20(%rsp)
setb   %al
or     0x7(%rsp),%al
or     0x6(%rsp),%al
mov    0xc0(%rsp),%rax
jne    1855 <warped_true2monic_coefs+0x735>
xor    %eax,%eax
movaps 0xf0(%rsp),%xmm7
nopl   0x0(%rax)
movups -0x1c(%rdx,%rax,4),%xmm0
movups -0xc(%rdx,%rax,4),%xmm1
lea    (%r15,%rax,1),%ecx
movups -0x1c(%rbx,%rcx,4),%xmm2
movups -0xc(%rbx,%rcx,4),%xmm3
movaps %xmm7,%xmm4
shufps $0x1b,%xmm7,%xmm4
mulps  %xmm4,%xmm1
addps  %xmm3,%xmm1
movups %xmm1,-0xc(%rbx,%rcx,4)
mulps  %xmm0,%xmm4
addps  %xmm2,%xmm4
movups %xmm4,-0x1c(%rbx,%rcx,4)
add    $0xfffffffffffffff8,%rax
cmp    %rax,%rsi
jne    1800 <warped_true2monic_coefs+0x6e0>
mov    0x80(%rsp),%rax
mov    0x88(%rsp),%rcx
cmp    %rcx,0x20(%rsp)
je     1881 <warped_true2monic_coefs+0x761>
add    $0x1,%rax
nopl   0x0(%rax)
lea    -0x2(%rax),%ecx
movss  -0x4(%rbx,%rax,4),%xmm0
mulss  %xmm6,%xmm0
addss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rbx,%rcx,4)
add    $0xffffffffffffffff,%rax
cmp    $0x1,%rax
jg     1860 <warped_true2monic_coefs+0x740>
movss  (%rbx),%xmm0
movaps %xmm8,%xmm1
mulss  %xmm0,%xmm1
addss  0x77b(%rip),%xmm1
movss  0x34(%rsp),%xmm7
divss  %xmm1,%xmm7
test   %r12d,%r12d
jle    1490 <warped_true2monic_coefs+0x370>
mulss  %xmm7,%xmm0
movss  %xmm0,(%rbx)
cmp    $0x1,%r12d
je     1490 <warped_true2monic_coefs+0x370>
mov    $0x1,%eax
cmpq   $0x8,0x10(%rsp)
jb     1980 <warped_true2monic_coefs+0x860>
movaps %xmm7,%xmm0
shufps $0x0,%xmm7,%xmm0
cmpq   $0x8,0x70(%rsp)
jae    18f3 <warped_true2monic_coefs+0x7d3>
xor    %eax,%eax
jmp    193e <warped_true2monic_coefs+0x81e>
xor    %eax,%eax
testb  $0x1,0x90(%rsp)
01
jne    1716 <warped_true2monic_coefs+0x5f6>
jmp    172e <warped_true2monic_coefs+0x60e>
mov    0x60(%rsp),%rcx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movups 0x4(%rbx,%rax,4),%xmm1
movups 0x14(%rbx,%rax,4),%xmm2
movups 0x24(%rbx,%rax,4),%xmm3
movups 0x34(%rbx,%rax,4),%xmm4
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm2
movups %xmm1,0x4(%rbx,%rax,4)
movups %xmm2,0x14(%rbx,%rax,4)
mulps  %xmm0,%xmm3
mulps  %xmm0,%xmm4
movups %xmm3,0x24(%rbx,%rax,4)
movups %xmm4,0x34(%rbx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    1900 <warped_true2monic_coefs+0x7e0>
testb  $0x1,0x68(%rsp)
je     1965 <warped_true2monic_coefs+0x845>
shl    $0x2,%rax
or     $0x4,%rax
movups (%rbx,%rax,1),%xmm1
movups 0x10(%rbx,%rax,1),%xmm2
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm2
movups %xmm1,(%rbx,%rax,1)
movups %xmm2,0x10(%rbx,%rax,1)
mov    0x38(%rsp),%rax
cmp    %r14,0x10(%rsp)
je     1490 <warped_true2monic_coefs+0x370>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rbx,%rax,4),%xmm0
mulss  %xmm7,%xmm0
movss  %xmm0,(%rbx,%rax,4)
add    $0x1,%rax
cmp    %rax,%rbp
jne    1980 <warped_true2monic_coefs+0x860>
jmp    1490 <warped_true2monic_coefs+0x370>
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0x1,%edi
mov    %r10,%rcx
adc    $0xffffffffffffffff,%rcx
lea    -0x2(%r12),%ebp
mov    $0x4,%edx
mov    %rcx,%rax
mul    %rdx
seto   %r8b
cmp    %ecx,%ebp
jb     1176 <warped_true2monic_coefs+0x56>
shr    $0x20,%rcx
jne    1176 <warped_true2monic_coefs+0x56>
lea    (%rbx,%rbp,4),%rdx
mov    %rdx,%rcx
sub    %rax,%rcx
cmp    %rdx,%rcx
ja     1176 <warped_true2monic_coefs+0x56>
test   %r8b,%r8b
jne    1176 <warped_true2monic_coefs+0x56>
lea    (%rbx,%r10,4),%rcx
mov    %rcx,%rdx
sub    %rax,%rdx
cmp    %rcx,%rdx
ja     1176 <warped_true2monic_coefs+0x56>
test   %r8b,%r8b
jne    1176 <warped_true2monic_coefs+0x56>
xor    %eax,%eax
test   %edi,%edi
setne  %al
lea    (%rax,%rbp,1),%rcx
sub    %r10,%rcx
lea    (%rbx,%rcx,4),%rcx
lea    (%rbx,%r10,4),%rdx
add    $0x4,%rdx
cmp    %rdx,%rcx
jae    1a4a <warped_true2monic_coefs+0x92a>
lea    (%rbx,%rbp,4),%rcx
add    $0x4,%rcx
lea    (%rbx,%rax,4),%rax
cmp    %rcx,%rax
jb     1176 <warped_true2monic_coefs+0x56>
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
mov    %r10,%rax
sub    %r8,%rax
movaps %xmm6,%xmm0
shufps $0x0,%xmm6,%xmm0
mov    %r8,%rdx
neg    %rdx
lea    (%rbx,%r10,4),%rdi
add    $0xfffffffffffffff4,%rdi
lea    (%r10,%rsi,1),%rbp
xor    %ecx,%ecx
shufps $0x1b,%xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rdi,%rcx,4),%xmm1
movups (%rdi,%rcx,4),%xmm2
lea    (%rcx,%rbp,1),%esi
movups -0x1c(%rbx,%rsi,4),%xmm3
movups -0xc(%rbx,%rsi,4),%xmm4
mulps  %xmm0,%xmm2
addps  %xmm4,%xmm2
movups %xmm2,-0xc(%rbx,%rsi,4)
mulps  %xmm0,%xmm1
addps  %xmm3,%xmm1
movups %xmm1,-0x1c(%rbx,%rsi,4)
add    $0xfffffffffffffff8,%rcx
cmp    %rcx,%rdx
jne    1a80 <warped_true2monic_coefs+0x960>
cmp    %r8,%r9
jne    1179 <warped_true2monic_coefs+0x59>
jmp    11a1 <warped_true2monic_coefs+0x81>
mov    $0x1,%edx
test   $0x1,%sil
jne    1282 <warped_true2monic_coefs+0x162>
jmp    129a <warped_true2monic_coefs+0x17a>

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

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