#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 */
void IIRsos(float *x, unsigned long Nx, float b0, float b1, float b2, float a1,
            float a2, float *tz1, float *tz2) {
  register float z0;
  register float z1;
  register float z2;
  if (tz1 == NULL)
    z1 = 0.0f;
  else
    z1 = *tz1;
  if (tz2 == NULL)
    z2 = 0.0f;
  else
    z2 = *tz2;
  if ((a1 != 0.0f) || (a2 != 0.0f)) {
    if ((b1 != 0.0f) || (b2 != 0.0f)) {
      while ((Nx) > 0) {
        Nx--;
        z0 = (*x) - a1 * z1 - a2 * z2;
        *(x++) = b0 * z0 + b1 * z1 + b2 * z2;
        z2 = z1;
        z1 = z0;
      }
    } else {
      if (b0 != 1.0f) {
        while ((Nx) > 0) {
          Nx--;
          z0 = (*x) - a1 * z1 - a2 * z2;
          *(x++) = b0 * z0;
          z2 = z1;
          z1 = z0;
        }
      } else {
        while ((Nx) > 0) {
          Nx--;
          z0 = (*x) - a1 * z1 - a2 * z2;
          *(x++) = z0;
          z2 = z1;
          z1 = z0;
        }
      }
    }
  } else {
    if ((b1 != 0.0f) || (b2 != 0.0f)) {
      while ((Nx) > 0) {
        Nx--;
        z0 = (*x);
        *(x++) = b0 * z0 + b1 * z1 + b2 * z2;
        z2 = z1;
        z1 = z0;
      }
    } else {
      if (b0 != 1.0f) {
        while ((Nx) > 0) {
          Nx--;
          *x = b0 * (*x);
          x++;
        }
      }
    }
  }
  if (tz1 != NULL)
    (*tz1) = z1;
  if (tz2 != NULL)
    (*tz2) = z2;
}


x86 assembly (clang, -O0):
<IIRsos>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
movss  %xmm1,-0x18(%rbp)
movss  %xmm2,-0x1c(%rbp)
movss  %xmm3,-0x20(%rbp)
movss  %xmm4,-0x24(%rbp)
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
cmpq   $0x0,-0x30(%rbp)
jne    1145 <IIRsos+0x45>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
jmp    1152 <IIRsos+0x52>
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
cmpq   $0x0,-0x38(%rbp)
jne    116a <IIRsos+0x6a>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
jmp    1177 <IIRsos+0x77>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x20(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    11aa <IIRsos+0xaa>
jp     11aa <IIRsos+0xaa>
movss  -0x24(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    11aa <IIRsos+0xaa>
jp     11aa <IIRsos+0xaa>
jmp    140d <IIRsos+0x30d>
movss  -0x18(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    11dd <IIRsos+0xdd>
jp     11dd <IIRsos+0xdd>
movss  -0x1c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    11dd <IIRsos+0xdd>
jp     11dd <IIRsos+0xdd>
jmp    12a3 <IIRsos+0x1a3>
jmp    11e2 <IIRsos+0xe2>
cmpq   $0x0,-0x10(%rbp)
jbe    129e <IIRsos+0x19e>
mov    -0x10(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x20(%rbp),%xmm1
movss  -0x40(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x24(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x14(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm2
movss  -0x18(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  %xmm0,(%rax)
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
jmp    11e2 <IIRsos+0xe2>
jmp    1408 <IIRsos+0x308>
movss  -0x14(%rbp),%xmm0
movss  0xd50(%rip),%xmm1
ucomiss %xmm1,%xmm0
jne    12c4 <IIRsos+0x1c4>
jp     12c4 <IIRsos+0x1c4>
jmp    1366 <IIRsos+0x266>
jmp    12c9 <IIRsos+0x1c9>
cmpq   $0x0,-0x10(%rbp)
jbe    1361 <IIRsos+0x261>
mov    -0x10(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x20(%rbp),%xmm1
movss  -0x40(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x24(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x14(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  %xmm0,(%rax)
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
jmp    12c9 <IIRsos+0x1c9>
jmp    1403 <IIRsos+0x303>
jmp    136b <IIRsos+0x26b>
cmpq   $0x0,-0x10(%rbp)
jbe    13fe <IIRsos+0x2fe>
mov    -0x10(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x20(%rbp),%xmm1
movss  -0x40(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x24(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  %xmm0,(%rax)
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
jmp    136b <IIRsos+0x26b>
jmp    1403 <IIRsos+0x303>
jmp    1408 <IIRsos+0x308>
jmp    153a <IIRsos+0x43a>
movss  -0x18(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1440 <IIRsos+0x340>
jp     1440 <IIRsos+0x340>
movss  -0x1c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1440 <IIRsos+0x340>
jp     1440 <IIRsos+0x340>
jmp    14c8 <IIRsos+0x3c8>
jmp    1445 <IIRsos+0x345>
cmpq   $0x0,-0x10(%rbp)
jbe    14c3 <IIRsos+0x3c3>
mov    -0x10(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x14(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm2
movss  -0x18(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  %xmm0,(%rax)
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
jmp    1445 <IIRsos+0x345>
jmp    1535 <IIRsos+0x435>
movss  -0x14(%rbp),%xmm0
movss  0xb2b(%rip),%xmm1
ucomiss %xmm1,%xmm0
jne    14e9 <IIRsos+0x3e9>
jp     14e9 <IIRsos+0x3e9>
jmp    1530 <IIRsos+0x430>
jmp    14ee <IIRsos+0x3ee>
cmpq   $0x0,-0x10(%rbp)
jbe    152b <IIRsos+0x42b>
mov    -0x10(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x10(%rbp)
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mulss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x8(%rbp)
jmp    14ee <IIRsos+0x3ee>
jmp    1530 <IIRsos+0x430>
jmp    1535 <IIRsos+0x435>
jmp    153a <IIRsos+0x43a>
cmpq   $0x0,-0x30(%rbp)
je     1552 <IIRsos+0x452>
movss  -0x40(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
cmpq   $0x0,-0x38(%rbp)
je     156a <IIRsos+0x46a>
movss  -0x44(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<IIRsos>:
xorps  %xmm10,%xmm10
xorps  %xmm8,%xmm8
test   %rdx,%rdx
je     1112 <IIRsos+0x12>
movss  (%rdx),%xmm8
test   %rcx,%rcx
je     111c <IIRsos+0x1c>
movss  (%rcx),%xmm10
xorps  %xmm5,%xmm5
ucomiss %xmm5,%xmm1
setp   %al
setne  %r8b
or     %al,%r8b
ucomiss %xmm5,%xmm2
setp   %r9b
setne  %al
or     %r9b,%al
or     %r8b,%al
ucomiss %xmm5,%xmm3
jne    1177 <IIRsos+0x77>
jp     1177 <IIRsos+0x77>
ucomiss %xmm5,%xmm4
jne    1177 <IIRsos+0x77>
jp     1177 <IIRsos+0x77>
test   %al,%al
je     11b5 <IIRsos+0xb5>
test   %rsi,%rsi
je     12fa <IIRsos+0x1fa>
test   $0x1,%sil
jne    1317 <IIRsos+0x217>
movaps %xmm8,%xmm3
mov    %rsi,%rax
cmp    $0x1,%rsi
je     1302 <IIRsos+0x202>
jmp    1355 <IIRsos+0x255>
test   %al,%al
je     1299 <IIRsos+0x199>
test   %rsi,%rsi
je     12fa <IIRsos+0x1fa>
movaps 0xe81(%rip),%xmm5
xorps  %xmm5,%xmm3
xorps  %xmm5,%xmm4
test   $0x1,%sil
jne    13c8 <IIRsos+0x2c8>
movaps %xmm8,%xmm7
mov    %rsi,%rax
cmp    $0x1,%rsi
je     1302 <IIRsos+0x202>
jmp    1421 <IIRsos+0x321>
test   %rsi,%rsi
je     12fa <IIRsos+0x1fa>
ucomiss 0xe3b(%rip),%xmm0
jne    11cd <IIRsos+0xcd>
jnp    12fa <IIRsos+0x1fa>
cmp    $0x8,%rsi
jb     127a <IIRsos+0x17a>
mov    %rsi,%r8
and    $0xfffffffffffffff8,%r8
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%r8),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     15fa <IIRsos+0x4fa>
mov    %r9,%r10
and    $0xfffffffffffffffe,%r10
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movups (%rdi,%rax,4),%xmm2
movups 0x10(%rdi,%rax,4),%xmm3
movups 0x20(%rdi,%rax,4),%xmm4
movups 0x30(%rdi,%rax,4),%xmm5
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rdi,%rax,4)
movups %xmm3,0x10(%rdi,%rax,4)
mulps  %xmm1,%xmm4
mulps  %xmm1,%xmm5
movups %xmm4,0x20(%rdi,%rax,4)
movups %xmm5,0x30(%rdi,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%r10
jne    1210 <IIRsos+0x110>
test   $0x1,%r9b
je     126a <IIRsos+0x16a>
movups (%rdi,%rax,4),%xmm2
movups 0x10(%rdi,%rax,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rdi,%rax,4)
movups %xmm3,0x10(%rdi,%rax,4)
cmp    %rsi,%r8
je     12fa <IIRsos+0x1fa>
and    $0x7,%esi
lea    (%rdi,%r8,4),%rdi
xor    %eax,%eax
nopl   0x0(%rax)
movss  (%rdi,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%rax,4)
add    $0x1,%rax
cmp    %rax,%rsi
jne    1280 <IIRsos+0x180>
jmp    12fa <IIRsos+0x1fa>
ucomiss 0xd60(%rip),%xmm0
jne    12a4 <IIRsos+0x1a4>
jnp    12d2 <IIRsos+0x1d2>
test   %rsi,%rsi
je     12fa <IIRsos+0x1fa>
movaps 0xd60(%rip),%xmm1
xorps  %xmm1,%xmm3
xorps  %xmm1,%xmm4
test   $0x1,%sil
jne    14c5 <IIRsos+0x3c5>
movaps %xmm8,%xmm11
mov    %rsi,%rax
cmp    $0x1,%rsi
je     1302 <IIRsos+0x202>
jmp    1501 <IIRsos+0x401>
test   %rsi,%rsi
je     12fa <IIRsos+0x1fa>
movaps 0xd32(%rip),%xmm0
xorps  %xmm0,%xmm3
xorps  %xmm0,%xmm4
test   $0x1,%sil
jne    1568 <IIRsos+0x468>
movaps %xmm8,%xmm11
mov    %rsi,%rax
jmp    1593 <IIRsos+0x493>
movaps %xmm8,%xmm11
movaps %xmm10,%xmm8
test   %rdx,%rdx
je     130c <IIRsos+0x20c>
movss  %xmm11,(%rdx)
test   %rcx,%rcx
je     1316 <IIRsos+0x216>
movss  %xmm8,(%rcx)
ret
lea    -0x1(%rsi),%rax
movss  (%rdi),%xmm11
movaps %xmm8,%xmm3
mulss  %xmm1,%xmm3
movaps %xmm0,%xmm4
mulss  %xmm11,%xmm4
addss  %xmm3,%xmm4
mulss  %xmm2,%xmm10
addss  %xmm4,%xmm10
movss  %xmm10,(%rdi)
add    $0x4,%rdi
movaps %xmm8,%xmm10
movaps %xmm11,%xmm3
cmp    $0x1,%rsi
je     1302 <IIRsos+0x202>
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movss  (%rdi,%rsi,4),%xmm8
movss  0x4(%rdi,%rsi,4),%xmm11
movaps %xmm2,%xmm4
mulss  %xmm3,%xmm4
mulss  %xmm1,%xmm3
movaps %xmm0,%xmm5
mulss  %xmm8,%xmm5
addss  %xmm3,%xmm5
mulss  %xmm2,%xmm10
addss  %xmm5,%xmm10
movss  %xmm10,(%rdi,%rsi,4)
movaps %xmm8,%xmm3
mulss  %xmm1,%xmm3
movaps %xmm0,%xmm5
mulss  %xmm11,%xmm5
addss  %xmm3,%xmm5
addss  %xmm4,%xmm5
movss  %xmm5,0x4(%rdi,%rsi,4)
add    $0x2,%rsi
movaps %xmm8,%xmm10
movaps %xmm11,%xmm3
cmp    %rsi,%rax
jne    1360 <IIRsos+0x260>
jmp    1302 <IIRsos+0x202>
lea    -0x1(%rsi),%rax
movaps %xmm3,%xmm7
mulss  %xmm8,%xmm7
addss  (%rdi),%xmm7
movaps %xmm4,%xmm11
mulss  %xmm10,%xmm11
addss  %xmm7,%xmm11
movaps %xmm8,%xmm9
mulss  %xmm1,%xmm9
movaps %xmm0,%xmm7
mulss  %xmm11,%xmm7
addss  %xmm9,%xmm7
mulss  %xmm2,%xmm10
addss  %xmm7,%xmm10
movss  %xmm10,(%rdi)
add    $0x4,%rdi
movaps %xmm8,%xmm10
movaps %xmm11,%xmm7
cmp    $0x1,%rsi
je     1302 <IIRsos+0x202>
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movaps %xmm3,%xmm5
mulss  %xmm7,%xmm5
addss  (%rdi,%rsi,4),%xmm5
movaps %xmm4,%xmm8
mulss  %xmm10,%xmm8
addss  %xmm5,%xmm8
movaps %xmm7,%xmm5
mulss  %xmm1,%xmm5
movaps %xmm0,%xmm6
mulss  %xmm8,%xmm6
addss  %xmm5,%xmm6
mulss  %xmm2,%xmm10
addss  %xmm6,%xmm10
movss  %xmm10,(%rdi,%rsi,4)
movaps %xmm3,%xmm6
mulss  %xmm8,%xmm6
addss  0x4(%rdi,%rsi,4),%xmm6
movaps %xmm4,%xmm11
mulss  %xmm7,%xmm11
addss  %xmm6,%xmm11
movaps %xmm8,%xmm6
mulss  %xmm1,%xmm6
movaps %xmm0,%xmm5
mulss  %xmm11,%xmm5
addss  %xmm6,%xmm5
mulss  %xmm2,%xmm7
addss  %xmm5,%xmm7
movss  %xmm7,0x4(%rdi,%rsi,4)
add    $0x2,%rsi
movaps %xmm8,%xmm10
movaps %xmm11,%xmm7
cmp    %rsi,%rax
jne    1430 <IIRsos+0x330>
jmp    1302 <IIRsos+0x202>
lea    -0x1(%rsi),%rax
movaps %xmm3,%xmm1
mulss  %xmm8,%xmm1
addss  (%rdi),%xmm1
mulss  %xmm4,%xmm10
movaps %xmm10,%xmm11
addss  %xmm1,%xmm11
movaps %xmm11,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rdi)
add    $0x4,%rdi
movaps %xmm8,%xmm10
cmp    $0x1,%rsi
je     1302 <IIRsos+0x202>
xor    %esi,%esi
movaps %xmm10,%xmm8
nopw   0x0(%rax,%rax,1)
movaps %xmm3,%xmm1
mulss  %xmm11,%xmm1
addss  (%rdi,%rsi,4),%xmm1
mulss  %xmm4,%xmm8
addss  %xmm1,%xmm8
movaps %xmm8,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%rsi,4)
movaps %xmm3,%xmm1
mulss  %xmm8,%xmm1
addss  0x4(%rdi,%rsi,4),%xmm1
mulss  %xmm4,%xmm11
addss  %xmm1,%xmm11
movaps %xmm11,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%rdi,%rsi,4)
add    $0x2,%rsi
cmp    %rsi,%rax
jne    1510 <IIRsos+0x410>
jmp    1302 <IIRsos+0x202>
lea    -0x1(%rsi),%rax
movaps %xmm3,%xmm0
mulss  %xmm8,%xmm0
addss  (%rdi),%xmm0
mulss  %xmm4,%xmm10
movaps %xmm10,%xmm11
addss  %xmm0,%xmm11
movss  %xmm11,(%rdi)
add    $0x4,%rdi
movaps %xmm8,%xmm10
cmp    $0x1,%rsi
je     1302 <IIRsos+0x202>
xor    %esi,%esi
movaps %xmm10,%xmm8
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movaps %xmm3,%xmm0
mulss  %xmm11,%xmm0
addss  (%rdi,%rsi,4),%xmm0
mulss  %xmm4,%xmm8
addss  %xmm0,%xmm8
movss  %xmm8,(%rdi,%rsi,4)
movaps %xmm3,%xmm0
mulss  %xmm8,%xmm0
addss  0x4(%rdi,%rsi,4),%xmm0
mulss  %xmm4,%xmm11
addss  %xmm0,%xmm11
movss  %xmm11,0x4(%rdi,%rsi,4)
add    $0x2,%rsi
cmp    %rsi,%rax
jne    15b0 <IIRsos+0x4b0>
jmp    1302 <IIRsos+0x202>
xor    %eax,%eax
test   $0x1,%r9b
jne    1252 <IIRsos+0x152>
jmp    126a <IIRsos+0x16a>

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

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